Retry macOS tests with `pytest-rerunfailures`

Give only the macOS matrix leg two retries so actor/PTY timing
flakes do not strand otherwise-green runs. Linux and Windows remain
strict first-attempt jobs, while persistent macOS failures stay red
after the final visible rerun.

Deats,
- add the pytest-dev-maintained plugin to testing deps
- keep a one-second delay between macOS attempts
- validate the workflow, lock and both observed flaky test areas

Prompt-IO: ai/prompt-io/opencode/20260821T052052Z_3690e43a_prompt_io.md

(this patch was generated in some part by `opencode` using `gpt-5.6-sol` (`openai`))

ai/prompt-io/claude/20260702T154255Z_65bf9df5_prompt_io.md

@@ -1,79 +0,0 @@
----
-model: claude-fable-5
-service: claude
-session: f6c84722-471a-4458-9a80-e453fea9029f
-timestamp: 2026-07-02T15:42:55Z
-git_ref: 65bf9df5
-scope: code
-substantive: true
-raw_file: 20260702T154255Z_65bf9df5_prompt_io.raw.md
----
-
-## Prompt
-
-Driver prompt file `ai/prompt-io/prompts/issue_477.md`:
-
-> attempt to resolve
-> https://github.com/goodboy/tractor/issues/477
-> do it with /open-wkt.
-
-(plus a hard stop-for-human-review deadline of 12:50PM
-EST the same day)
-
-Issue #477 asks to factor `ActorNursery.run_in_actor()`
-(and possibly `Portal.run()`) out of the nursery
-internals into a new `tractor.to_actor` wrapper
-subpackage of "higher level one shot" single-remote-task
-APIs, adopting the `trio.to_thread`/`anyio.to_process`
-parlance, so that error collection/propagation moves up
-into the caller's local `trio` scope and the nursery's
-spawn machinery can eventually drop the
-`._ria_nursery` coupling.
-
-## Response summary
-
-First-cut `tractor.to_actor` subpkg delivering the
-one-shot API composed purely from the existing
-daemon-spawn + portal primitives (`start_actor()` +
-`Portal.run()` + `Portal.cancel_actor()`), leaving the
-legacy `.run_in_actor()` machinery untouched (formal
-deprecation deferred until in-repo usage migrates):
-
-- `to_actor.run(fn, **fn_kwargs) -> Any`: spawn a
-  subactor, schedule `fn` as its lone remote task, wait
-  on and return its result, ALWAYS reaping the subactor
-  (shield-safe `finally`). Remote errors raise in the
-  caller's task as boxed `RemoteActorError`s.
-- placement variants: `portal=` reuses a running actor
-  (no spawn/reap), `an=` spawns from a caller-managed
-  actor-nursery, neither opens a call-scoped private
-  `open_nursery()` (implicitly booting the runtime,
-  configurable via `runtime_kwargs`).
-- fail-fast validation before any spawn: non-streaming
-  async fn required; `portal=`/`an=` mutually
-  exclusive; `runtime_kwargs` rejected alongside any
-  placement opt.
-- `run_in_actor()` TODO/docstring now cross-reference
-  the successor API.
-
-## Files changed
-
-- `tractor/to_actor/__init__.py` — new subpkg,
-  re-exports `run`
-- `tractor/to_actor/_api.py` — `run()` +
-  `_invoke_in_subactor()` + `_validate_one_shot_fn()`
-- `tractor/__init__.py` — top-level `to_actor`
-  re-export
-- `tractor/runtime/_supervise.py` — comment/docstring
-  pointers from `run_in_actor()` to the successor
-- `tests/test_to_actor.py` — 11-test suite covering
-  all placement variants, error relay, the concurrent
-  worker-pool-ish pattern and arg validation
-- `examples/parallelism/to_actor_one_shots.py` —
-  runnable demo (auto-collected by
-  `test_docs_examples.py`)
-
-## Human edits
-
-None yet — pending human review (work paused before the
-12:50PM EST deadline per the driver prompt).

ai/prompt-io/claude/20260702T154255Z_65bf9df5_prompt_io.raw.md

@@ -1,100 +0,0 @@
----
-model: claude-fable-5
-service: claude
-timestamp: 2026-07-02T15:42:55Z
-git_ref: 65bf9df5
-diff_cmd: git diff main..wkt/to_actor_subpkg
----
-
-# Raw AI output (diff-ref mode)
-
-All generated code is committed on the
-`wkt/to_actor_subpkg` branch; per diff-ref mode each
-file's verbatim content is reachable via the pointers
-below rather than duplicated here.
-
-## Generated files
-
-> `git diff main..wkt/to_actor_subpkg -- tractor/to_actor/__init__.py`
-
-New subpackage init: module docstring establishing the
-`trio.to_thread`/`anyio.to_process` "run it over there"
-parlance for actors, plus the single public re-export
-`run as run` from `._api`.
-
-> `git diff main..wkt/to_actor_subpkg -- tractor/to_actor/_api.py`
-
-The one-shot invocation impl, composed entirely from the
-lower level daemon-spawn + portal primitives as
-prescribed by issue #477:
-
-- `_validate_one_shot_fn()`: the `Portal.run()`
-  non-streaming-async-fn constraint checked up-front,
-  before any subactor is spawned.
-- `_invoke_in_subactor()`: `an.start_actor()` ->
-  `Portal.run()` -> always-reap via
-  `Portal.cancel_actor()` in a `finally` (the cancel
-  req's bounded wait is internally shielded so the reap
-  also runs under caller-scope cancellation).
-- `run()`: the public API. Placement options:
-  `portal=` (reuse a running actor, no spawn/reap),
-  `an=` (spawn from a caller-managed nursery), or
-  neither (private `open_nursery()` scoped to the call,
-  implicitly booting the runtime when needed, tunable
-  via pass-through `runtime_kwargs`). Spawn opts mirror
-  `ActorNursery.start_actor()`; `**fn_kwargs` are
-  relayed to the remote task. Errors raise in the
-  caller's task as boxed `RemoteActorError`s.
-  `runtime_kwargs` alongside any placement opt is a
-  hard `ValueError`, never silently ignored.
-
-> `git diff main..wkt/to_actor_subpkg -- tractor/__init__.py`
-
-Top-level `from . import to_actor as to_actor`
-re-export.
-
-> `git diff main..wkt/to_actor_subpkg -- tractor/runtime/_supervise.py`
-
-Comment/docstring-only: the `run_in_actor()` deprecation
-TODO now points at the implemented `.to_actor.run()`
-successor (checkbox ticked) and the method docstring
-gains a NOTE steering users to the new API; remaining
-TODO items are the `DeprecationWarning` emission +
-in-repo usage migration.
-
-> `git diff main..wkt/to_actor_subpkg -- tests/test_to_actor.py`
-
-11-test suite: private-nursery one-shot, implicit
-runtime boot via `runtime_kwargs`, remote-error relay to
-the caller's task (bare + caller-managed nursery),
-caller-nursery spawn, portal reuse w/o implicit reap,
-the concurrent worker-pool-ish pattern (local `trio`
-nursery x shared `an`), and the four validation
-rejections (sync fn, async-gen fn, `portal`+`an`
-combo, `runtime_kwargs`+placement combo).
-
-> `git diff main..wkt/to_actor_subpkg -- examples/parallelism/to_actor_one_shots.py`
-
-Runnable example (auto-collected by
-`test_docs_examples.py`): the fully-implicit one-shot
-plus the concurrent worker-pool-ish prime-check pattern
-against a shared caller-managed actor-nursery.
-
-## Test runs (verbatim)
-
-```
-tests/test_to_actor.py ..........                [100%]
-============= 10 passed in 4.29s =============
-```
-
-Regression subset for touched modules
-(`test_local.py test_rpc.py test_spawning.py
-test_cancellation.py`):
-
-```
-38 passed, 1 xfailed, 24 warnings in 80.71s (0:01:20)
-```
-
-(warnings are pre-existing stdlib `os.fork()`
-DeprecationWarnings from the mp spawn backends, not
-introduced by this change)

ai/prompt-io/opencode/20260818T031532Z_4151b956_prompt_io.md

@@ -1,43 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: pr481-review-fixes-p1-20260818
-timestamp: 2026-08-18T03:15:32Z
-git_ref: 4151b956
-scope: code
-substantive: true
-raw_file: 20260818T031532Z_4151b956_prompt_io.raw.md
----
-
-## Prompt
-
-Address the approved review findings on PR #481, but work
-iteratively: implement and verify one finding at a time, prepare a
-separate `/commit-plan` after each fix, and stop for the human commit
-before starting the next finding. Begin with the P1 per-child
-lifecycle issue. Also publish the already-approved review findings
-against the reviewed PR head before editing.
-
-## Response summary
-
-Published the approved non-approving review at head `4151b956`, then
-implemented only the P1 lifecycle fix. Owned one-shot actors now use
-a child-specific cancellation and process-reap handshake, including
-hard escalation for unacknowledged cancellation and deterministic
-bookkeeping removal before `to_actor.run()` returns.
-
-## Files changed
-
-- `tractor/runtime/_supervise.py` - coordinate child-specific cancel
-  and reap.
-- `tractor/spawn/_trio.py` - wait on the Trio child's reap request.
-- `tractor/spawn/_mp.py` - wait on the multiprocessing child's reap
-  request.
-- `tractor/spawn/_spawn.py` - publish monitor completion centrally.
-- `tractor/to_actor/_api.py` - await owned-child process reaping.
-- `tests/test_to_actor.py` - cover cleanup, escalation, and startup
-  ordering.
-
-## Human edits
-
-None - the generated P1 patch remains uncommitted for human review.

ai/prompt-io/opencode/20260818T031532Z_4151b956_prompt_io.raw.md

@@ -1,74 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-18T03:15:32Z
-git_ref: 4151b956
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Implemented only the P1 lifecycle finding from the approved PR #481
-review, preserving the requested one-fix-at-a-time commit boundary.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_supervise.py`
-
-Added per-child reap request/completion events to `ActorNursery`, a
-shielded child-specific cancel-and-reap operation, late-registration
-latching for nursery teardown, and cancellation escalation that waits
-for debugger release before using non-ignorable process termination.
-The nursery-wide cancellation path snapshots child records before
-checkpointing so concurrent one-shot cleanup cannot invalidate its
-iteration.
-
-> `git diff HEAD~1..HEAD -- tractor/spawn/_trio.py`
-
-Changed Trio child monitors to wait on their per-child reap requests.
-
-> `git diff HEAD~1..HEAD -- tractor/spawn/_mp.py`
-
-Changed multiprocessing child monitors to wait on their per-child reap
-requests.
-
-> `git diff HEAD~1..HEAD -- tractor/spawn/_spawn.py`
-
-Ensured every backend publishes child-reap completion after its process
-monitor exits.
-
-> `git diff HEAD~1..HEAD -- tractor/to_actor/_api.py`
-
-Changed owned one-shot cleanup to await child-specific process joining
-and bookkeeping removal instead of treating the cancel RPC as reaping.
-
-> `git diff HEAD~1..HEAD -- tests/test_to_actor.py`
-
-Added regressions for immediate caller-managed nursery cleanup, failed
-cancel acknowledgement escalation, and child registration after a
-latched nursery-wide teardown request.
-
-Verification:
-
-`pytest -q tests/test_to_actor.py tests/test_cancellation.py tests/test_spawning.py tests/discovery/test_multi_program.py`
-
-Result: `46 passed, 1 xfailed, 3 xpassed`.
-
-`pytest -q tests/test_to_actor.py --tpt-proto uds`
-
-Result: `13 passed`.
-
-`pytest -q tests/test_to_actor.py --spawn-backend mp_spawn --tpt-proto tcp`
-
-Result: `13 passed`.
-
-One broad verification run was mistakenly launched in parallel with
-the UDS and `mp_spawn` actor suites. It timed out
-`test_remote_error_from_caller_nursery`; the node passed immediately
-in isolation and the complete broad selection then passed serially.
-The failure was classified as concurrent test-session interference,
-not accepted as a passing boundary result.
-
-Ruff, Python compilation, and `git diff --check` passed for the changed
-boundary. Ruff's existing `_trio.py` F401 finding was reproduced at the
-unmodified PR head and excluded from attribution to this patch.
-
-No source files were staged, committed, pushed, or used for review
-replies. The previously approved top-level review was published before
-the fix at reviewed head `4151b956`.

ai/prompt-io/opencode/20260818T193001Z_bf06b4f8_prompt_io.md

@@ -1,36 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: ses_3e4c90d3eafeqHEtRYSIHgHhpA
-timestamp: 2026-08-18T19:30:01Z
-git_ref: bf06b4f8
-scope: code
-substantive: true
-raw_file: 20260818T193001Z_bf06b4f8_prompt_io.raw.md
----
-
-## Prompt
-
-Fix cancellation during an indeterminate transport write without
-allowing a second RPC msg to corrupt the stream. Keep the transport
-fix separate from the higher-level `to_actor` remediation and explain
-the length-prefixed protocol rather than using unexplained "framed
-send" terminology.
-
-## Response summary
-
-Close a msgpack transport stream when cancellation interrupts its
-length-prefixed `send_all()` operation. The stream can no longer be
-safely reused because Trio cannot report how many bytes were written.
-
-## Files changed
-
-- `tractor/ipc/_transport.py` - close an interrupted send stream.
-- `tests/ipc/test_each_tpt.py` - cover cancellation during the write.
-
-## Human edits
-
-The human required this transport edge-case fix to land as its own
-behavioral commit with a detailed message. During staged review, the
-human also rejected the unexplained "framed send" wording and asked
-for terminology tied directly to the actual transport operation.

ai/prompt-io/opencode/20260818T193001Z_bf06b4f8_prompt_io.raw.md

@@ -1,19 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-18T19:30:01Z
-git_ref: bf06b4f8
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Prospective review found that cancellation can interrupt
-`MsgpackTransport.send()` after `send_all()` writes only part of its
-length-prefixed msg. Sending a cancellation request afterward can
-append another msg to the indeterminate stream and desynchronize the
-peer decoder.
-
-> `git diff HEAD~1..HEAD -- tractor/ipc/_transport.py tests/ipc/test_each_tpt.py`
-
-Close the stream under a cancellation shield when `send_all()` is
-cancelled. Cover the behavior with a fake stream that checkpoints
-inside the write and records forced closure.

ai/prompt-io/opencode/20260818T193002Z_bf06b4f8_prompt_io.md

@@ -1,37 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: ses_3e4c90d3eafeqHEtRYSIHgHhpA
-timestamp: 2026-08-18T19:30:02Z
-git_ref: bf06b4f8
-scope: code
-substantive: true
-raw_file: 20260818T193002Z_bf06b4f8_prompt_io.raw.md
----
-
-## Prompt
-
-Distill repeated `Actor._contexts.pop()` machinery into a wrapper like
-the RPC-task registration helper so future teardown sites do not keep
-reconstructing the context-registry key independently. Preserve the
-existing lifecycle-specific cleanup behavior.
-
-## Response summary
-
-Add idempotent `Actor._drop_context()` registry removal keyed from the
-context's own channel and CID. Use it for caller context teardown and
-the strict callee-side RPC deregistration path.
-
-## Files changed
-
-- `tractor/runtime/_runtime.py` - own context-registry removal.
-- `tractor/runtime/_rpc.py` - use the helper for callee teardown.
-- `tractor/_context.py` - use the helper after caller teardown.
-
-## Human edits
-
-The human identified the repeated registry-pop code and requested a
-central primitive analogous to `_register_rpc_task()`. The agent first
-suggested an async helper that also closed receive channels; the final
-design was narrowed to registry removal only so each lifecycle owner
-retains its existing closure, debugger, shielding, and error policy.

ai/prompt-io/opencode/20260818T193002Z_bf06b4f8_prompt_io.raw.md

@@ -1,18 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-18T19:30:02Z
-git_ref: bf06b4f8
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Repeated teardown sites reconstruct the `Actor._contexts` registry
-key from a portal channel and context ID before popping it. Add an
-idempotent actor-owned helper deriving the key from the context itself,
-then route caller and callee context teardown through that helper.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_runtime.py tractor/runtime/_rpc.py tractor/_context.py`
-
-Keep receive-channel closure and cancellation shielding in each
-lifecycle owner so the helper centralizes registry machinery without
-changing their teardown ordering.

ai/prompt-io/opencode/20260818T193003Z_bf06b4f8_prompt_io.md

@@ -1,38 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: ses_3e4c90d3eafeqHEtRYSIHgHhpA
-timestamp: 2026-08-18T19:30:03Z
-git_ref: bf06b4f8
-scope: code
-substantive: true
-raw_file: 20260818T193003Z_bf06b4f8_prompt_io.raw.md
----
-
-## Prompt
-
-Cancel a remote task when its caller is cancelled after `Start`
-publication but before startup acknowledgement. Keep cancellation
-bounded, prevent its private `_cancel_task` RPC from recursively
-cancelling itself and preserve public target kwargs unchanged.
-
-## Response summary
-
-Add private portal startup policy, use it for non-recursive context
-cancellation and clean caller-side startup state under a shield.
-
-## Files changed
-
-- `tractor/runtime/_portal.py` - separate private startup policy.
-- `tractor/_context.py` - disable recursion for cancellation RPCs.
-- `tractor/runtime/_runtime.py` - clean cancelled task startup.
-- `tests/test_context_stream_semantics.py` - control cancellation
-  between `Start` publication and acknowledgement.
-
-## Human edits
-
-The human required this cancellation behavior to remain a distinct
-commit from general startup failures and from the public `to_actor`
-API. The human also requested that its runtime comment describe the
-actual length-prefixed transport guarantee and concrete `_cancel_task`
-operation rather than referring to an unnamed wrapper.

ai/prompt-io/opencode/20260818T193003Z_bf06b4f8_prompt_io.raw.md

@@ -1,20 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-18T19:30:03Z
-git_ref: bf06b4f8
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Cancellation while `Actor.start_remote_task()` waits for `StartAck`
-can strand its caller-side context and leave the remote task running.
-Make one bounded cleanup request, remove local startup state and close
-its receive channel.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_runtime.py tractor/runtime/_portal.py tractor/_context.py tests/test_context_stream_semantics.py`
-
-Separate private startup-cancellation policy from public target kwargs
-using `Portal._run_from_ns()`. Have `Context.cancel()` disable recursive
-startup cancellation for its own `_cancel_task` RPC. Exercise
-cancellation after `Start` publication and prove the caller-owned actor
-remains reusable without leaked contexts.

ai/prompt-io/opencode/20260818T193004Z_bf06b4f8_prompt_io.md

@@ -1,36 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: ses_3e4c90d3eafeqHEtRYSIHgHhpA
-timestamp: 2026-08-18T19:30:04Z
-git_ref: bf06b4f8
-scope: code
-substantive: true
-raw_file: 20260818T193004Z_bf06b4f8_prompt_io.raw.md
----
-
-## Prompt
-
-Release caller-side context state for every remote-task startup failure,
-not only local cancellation. Preserve the remote error, avoid unsafe
-follow-up sends and prove pre-publication serialization failures leave
-a reused portal healthy.
-
-## Response summary
-
-Extend remote-task startup cleanup across send, acknowledgement and
-validation errors. Track completed publication, perform only safe
-best-effort cancellation and deterministically remove local state.
-
-## Files changed
-
-- `tractor/runtime/_runtime.py` - clean every startup failure path.
-- `tests/test_context_stream_semantics.py` - cover authorization and
-  serialization failures before context entry.
-
-## Human edits
-
-The human accepted the discovered edge-case fixes but required general
-startup cleanup to land separately from cancellation cleanup, transport
-integrity and the public API. This boundary preserves that behavioral
-distinction and its dedicated commit-message rationale.

ai/prompt-io/opencode/20260818T193004Z_bf06b4f8_prompt_io.raw.md

@@ -1,19 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-18T19:30:04Z
-git_ref: bf06b4f8
-diff_cmd: git diff HEAD~1..HEAD
----
-
-`Actor.start_remote_task()` inserts a context before sending `Start`,
-but startup errors other than cancellation escape without removing or
-closing that caller state. Serialization errors, acknowledgement
-timeouts, malformed acknowledgements and remote authorization errors
-can therefore leak context-registry entries.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_runtime.py tests/test_context_stream_semantics.py`
-
-Cover the complete send, acknowledgement and validation phase with
-exceptional cleanup. Attempt remote cancellation only when publication
-is known complete or protocol-safe, and always release local state.

ai/prompt-io/opencode/20260818T193005Z_bf06b4f8_prompt_io.md

@@ -1,52 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: ses_3e4c90d3eafeqHEtRYSIHgHhpA
-timestamp: 2026-08-18T19:30:05Z
-git_ref: bf06b4f8
-scope: code
-substantive: true
-raw_file: 20260818T193005Z_bf06b4f8_prompt_io.raw.md
----
-
-## Prompt
-
-Replace abandoned `Portal.run()` one-shots with a static linked-context
-endpoint. Follow Trio positional-call semantics, use partials for target
-keywords, preserve Python 3.14 Placeholder behavior, keep target lookup
-behind the RPC allowlist and support private, nursery and portal
-placement.
-
-## Response summary
-
-Use `Portal.open_context()` and `Context.wait_for_result()` for one-shot
-tasks. Normalize every partial layer, validate signatures locally and
-send target namespace/function components separately to the authorized
-remote resolver. Retain the client-side function in its `NamespacePath`
-so `to_tuple()` does not re-import it. Owned actors enable the declaring
-`_api.__name__` directly; caller-owned portals opt in through the public
-`to_actor.MODULE` alias.
-
-## Files changed
-
-- `tractor/to_actor/_api.py` - implement linked one-shot calls.
-- `tractor/to_actor/__init__.py` - export `MODULE`.
-- `tractor/msg/ptr.py` - retain refs created by `from_ref()`.
-- `tests/test_to_actor.py` - cover the public API and authorization.
-- `examples/parallelism/to_actor_one_shots.py` - use positional inputs.
-
-## Human edits
-
-The human rejected nested target-kwargs configuration and selected
-Trio-style positional inputs plus `functools.partial()`. During staged
-review the human required a Python 3.14 compatibility comment rather
-than removing Placeholder support, requested separate namespace and
-function inputs, preserved `_get_rpc_func(ns: str, funcname: str)`
-authorization, renamed `RPC_MODULE` to `MODULE`, rejected global module
-exposure and deferred speculative nursery/module-list helpers to the
-`open_taskman()` design line. The human also required this public API
-to land only after its lower-level safety dependencies. In final staged
-review, the human required `_invoke_from_portal()` to use
-`NamespacePath.to_tuple()` with the already-held function ref and
-required internal actor setup to use `_api.__name__` directly, keeping
-`to_actor.MODULE` solely as the public importer-facing alias.

ai/prompt-io/opencode/20260818T193005Z_bf06b4f8_prompt_io.raw.md

@@ -1,24 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-18T19:30:05Z
-git_ref: bf06b4f8
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Implement `to_actor.run()` with Trio-style positional target arguments,
-`functools.partial` keyword and Python 3.14 Placeholder binding, and a
-static context endpoint that links remote results, errors and caller
-cancellation.
-
-> `git diff HEAD~1..HEAD -- tractor/to_actor/_api.py tractor/to_actor/__init__.py`
-
-Resolve target functions through `Actor._get_rpc_func()` so module
-authorization remains authoritative. Automatically expose the helper
-module for actors owned by `to_actor.run()` and document explicit
-exposure for a caller-owned portal.
-
-> `git diff HEAD~1..HEAD -- tests/test_to_actor.py examples/parallelism/to_actor_one_shots.py`
-
-Cover placement modes, argument binding, nested partials, caller-linked
-cancellation, remote errors and module authorization.

ai/prompt-io/opencode/20260819T020757Z_b38efed7_prompt_io.md

@@ -1,34 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: ses_3e4c90d3eafeqHEtRYSIHgHhpA
-timestamp: 2026-08-19T02:07:57Z
-git_ref: b38efed7
-scope: code
-substantive: true
-raw_file: 20260819T020757Z_b38efed7_prompt_io.raw.md
----
-
-## Prompt
-
-Resolve the remaining P3 review finding before landing PR #481:
-`runtime_kwargs={}` must not be silently accepted alongside either
-`an=` or `portal=` merely because the dict is falsey. Keep this as its
-own final review-remediation commit.
-
-## Response summary
-
-Treat any non-`None` `runtime_kwargs` value as provided when validating
-placement. Cover both placement APIs with empty and configured dicts,
-proving the error is raised locally before actor startup.
-
-## Files changed
-
-- `tractor/to_actor/_api.py` - validate option presence explicitly.
-- `tests/test_to_actor.py` - cover four invalid option combinations.
-
-## Human edits
-
-No direct line edits. The human accepted the P3 finding, required it to
-remain separate from the five P2 behavioral commits and prioritized it
-before the final PR #484 integration rebase and PR #481 landing steps.

ai/prompt-io/opencode/20260819T020757Z_b38efed7_prompt_io.raw.md

@@ -1,25 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-19T02:07:57Z
-git_ref: b38efed7
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Fix the final PR #481 review finding: `runtime_kwargs` is mutually
-exclusive with both caller placement options whenever it is provided,
-including an empty dict.
-
-> `git diff HEAD~1..HEAD -- tractor/to_actor/_api.py tests/test_to_actor.py`
-
-Use an explicit `is not None` check rather than dict truthiness. Expand
-the validation regression across `an=` and `portal=`, each with empty
-and configured runtime kwargs, so every invalid combination fails
-before actor runtime startup.
-
-Verification:
-
-- Trio/TCP: `23 passed`
-- Trio/UDS: `23 passed`
-- `mp_spawn`/TCP: `23 passed`
-- Ruff and `git diff --check`: clean

ai/prompt-io/opencode/20260819T234823Z_557065d8_prompt_io.md

@@ -1,37 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: 76c5d31c-5a2f-4503-9b16-410ee7f4fab3
-timestamp: 2026-08-19T23:48:23Z
-git_ref: 557065d8
-scope: tests
-substantive: true
-raw_file: 20260819T234823Z_557065d8_prompt_io.raw.md
----
-
-## Prompt
-
-Investigate PR #481's red CI run, explain the missing T-800 and
-debugger-output failures, and proceed with fixes in the PR #481
-worktree.
-
-## Response summary
-
-Updated stale teardown assertions to match #481's direct hard-reap
-path and observable process-lifetime invariants. Made nested debugger
-checks consume the complete pexpect transcript rather than only the
-last prompt latch.
-
-## Files changed
-
-- `tests/devx/test_debugger.py` - assert EOF/dead-process teardown and
-  accumulate nested debugger output across prompt boundaries.
-- `tests/devx/test_tooling.py` - assert cancel-timeout hard-reap
-  escalation instead of the bypassed T-800 backend marker.
-
-## Human edits
-
-The human reported the still-red PR #481 CI, supplied a failing job URL,
-required work in `/wkts/pr481_review_fixes` and directed the agent to
-continue immediately. No direct source-line edits were made by the
-human.

ai/prompt-io/opencode/20260819T234823Z_557065d8_prompt_io.raw.md

@@ -1,26 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-19T23:48:23Z
-git_ref: 557065d8
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Diagnose and fix the stale debugger and reaper assertions failing PR
-#481's Unix CI jobs.
-
-> `git diff HEAD~1..HEAD -- tests/devx/test_debugger.py tests/devx/test_tooling.py`
-
-Replace the old T-800 backend-log requirement with the new bounded
-cancel-ack escalation evidence. Prove debugger teardown with EOF and a
-dead child process instead of requiring optional `KeyboardInterrupt`
-text. Accumulate all pexpect prompt chunks for nested error propagation
-so expected tracebacks are not lost when `child.before` advances.
-
-Verification:
-
-- exact failed debugger/reaper nodes: `4 passed`
-- debugger/tooling TCP: `39 passed, 6 skipped`
-- debugger/tooling UDS: `39 passed, 6 skipped`
-- full TCP suite: `478 passed, 9 skipped, 7 xfailed, 3 xpassed`
-- full UDS rerun: `476 passed, 11 skipped, 8 xfailed, 2 xpassed`

ai/prompt-io/opencode/20260819T234824Z_557065d8_prompt_io.md

@@ -1,43 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: 76c5d31c-5a2f-4503-9b16-410ee7f4fab3
-timestamp: 2026-08-19T23:48:24Z
-git_ref: 557065d8
-scope: code
-substantive: true
-raw_file: 20260819T234824Z_557065d8_prompt_io.raw.md
----
-
-## Prompt
-
-Investigate and fix PR #481's macOS TCP clustering and stream-overrun
-failures without sacrificing IPC frame integrity or structured
-concurrency.
-
-## Response summary
-
-Changed cancellation during `send_all()` from actor-wide stream closure
-to shielded complete-frame publication followed by immediate pending
-cancellation. Prevented failed overrun error shipment from promoting a
-secondary transport closure over the context-local primary condition.
-
-## Files changed
-
-- `tractor/ipc/_transport.py` - complete in-flight frames before
-  delivering sender cancellation.
-- `tractor/_context.py` - absorb transport closure while reporting an
-  overrun on an already-closing channel.
-- `tests/ipc/test_each_tpt.py` - prove complete framing, cancellation
-  delivery and channel reuse.
-- `tests/test_context_stream_semantics.py` - prove overrun reporting
-  tolerates a closed transport.
-
-## Human edits
-
-The human reported PR #481's red CI, asked for diagnosis and directed
-the agent to proceed in the dedicated PR #481 worktree. During final
-review, the human required preservation of the original far-end
-cancellation rationale and fuller documentation of frame shielding,
-shared-channel ownership and cancellation-delay tradeoffs. These were
-human-directed agent edits; the human made no direct source-line edits.

ai/prompt-io/opencode/20260819T234824Z_557065d8_prompt_io.raw.md

@@ -1,31 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-19T23:48:24Z
-git_ref: 557065d8
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Fix the macOS TCP regressions where cancellation during a framed send
-closed the actor-wide channel and replaced primary stream errors with
-secondary `TransportClosed` failures.
-
-> `git diff HEAD~1..HEAD -- tractor/ipc/_transport.py tractor/_context.py tests/ipc/test_each_tpt.py tests/test_context_stream_semantics.py`
-
-Shield complete frame publication, then deliver pending cancellation
-immediately after leaving the shield. Preserve channel reuse instead of
-closing the multiplexed socket from a context-local sender. Treat
-`TransportClosed` while shipping `StreamOverrun` as failed delivery so
-the secondary error can not crash the actor-wide RPC loop.
-
-Add deterministic unit regressions for cancellation in the middle of a
-frame and overrun reporting after transport closure.
-
-Verification:
-
-- transport/context unit regressions: `3 passed`
-- exact TCP and UDS CI-node batches: `11 passed, 1 skipped`
-- transport/context/clustering/RPC TCP: `88 passed`
-- transport/context/clustering/RPC UDS: `86 passed, 2 skipped`
-- full TCP suite: `478 passed, 9 skipped, 7 xfailed, 3 xpassed`
-- full UDS rerun: `476 passed, 11 skipped, 8 xfailed, 2 xpassed`

ai/prompt-io/opencode/20260820T023004Z_88a23449_prompt_io.md

@@ -1,32 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: 76c5d31c-5a2f-4503-9b16-410ee7f4fab3
-timestamp: 2026-08-20T02:30:04Z
-git_ref: 88a23449
-scope: tests
-substantive: true
-raw_file: 20260820T023004Z_88a23449_prompt_io.raw.md
----
-
-## Prompt
-
-Inspect the two failed macOS jobs in PR #481's new CI run and continue
-toward a green landing candidate.
-
-## Response summary
-
-Confirmed both jobs fail only the known nested crash-REPL scenario from
-issue #320, while Ubuntu TCP/UDS and Windows pass. Added a targeted
-macOS-CI skip without reducing Linux coverage.
-
-## Files changed
-
-- `tests/devx/test_debugger.py` - skip the issue #320 nested
-  crash-REPL node on Darwin CI.
-
-## Human edits
-
-The human monitored the new CI run, reported both macOS jobs dead and
-directed the agent to continue diagnosis. No direct source-line edits
-were made by the human.

ai/prompt-io/opencode/20260820T023004Z_88a23449_prompt_io.raw.md

@@ -1,23 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-20T02:30:04Z
-git_ref: 88a23449
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Diagnose the remaining macOS PR #481 CI failures after the Linux
-debugger and transport fixes passed.
-
-> `git diff HEAD~1..HEAD -- tests/devx/test_debugger.py`
-
-Both macOS transports failed the same deeply nested crash-REPL test
-already tracked by issue #320: TCP omitted one actor-specific traceback
-record and UDS timed out waiting for a nested prompt. Apply an explicit
-Darwin-CI skip to this one node while retaining Linux TCP/UDS coverage.
-
-Verification:
-
-- debugger/tooling TCP: `39 passed, 6 skipped`
-- debugger/tooling UDS: `39 passed, 6 skipped`
-- Ruff, compilation and `git diff --check`: clean

ai/prompt-io/opencode/20260820T023005Z_88a23449_prompt_io.md

@@ -1,40 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: 76c5d31c-5a2f-4503-9b16-410ee7f4fab3
-timestamp: 2026-08-20T02:30:05Z
-git_ref: 88a23449
-scope: docs
-substantive: true
-raw_file: 20260820T023005Z_88a23449_prompt_io.raw.md
----
-
-## Prompt
-
-Audit all documentation and executable examples once more, replacing
-prescriptive `run_in_actor()` usage with `to_actor.run()` or explicit
-actor/context lifetime APIs before PR #481 lands.
-
-## Response summary
-
-Rewrote one-shot documentation around direct blocking result delivery,
-linked context execution and per-call reaping. Migrated all runnable
-examples, using daemon actors where reciprocal dialogs require longer
-lifetimes. Added API/guide cross-links and retained only three explicit
-legacy references.
-
-## Files changed
-
-- `docs/` - update API, quickstart and subsystem guides to showcase
-  `tractor.to_actor.run()` and link its underlying core APIs.
-- `examples/` - migrate one-shot calls and preserve explicit daemon
-  lifetimes for reciprocal or long-lived actor dialogs.
-
-## Human edits
-
-The human requested a final docs pass covering every place that should
-showcase `to_actor` over `.run_in_actor()`. Earlier review also required
-named target arguments to remain visible through `functools.partial()`
-and core API references to link to local guides/reference pages. These
-were human-directed agent edits; the human made no direct source-line
-edits.

ai/prompt-io/opencode/20260820T023005Z_88a23449_prompt_io.raw.md

@@ -1,27 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-20T02:30:05Z
-git_ref: 88a23449
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Perform a final rendered-documentation and executable-example pass so
-PR #481 showcases `tractor.to_actor.run()` instead of the legacy
-`ActorNursery.run_in_actor()` API.
-
-> `git diff HEAD~1..HEAD -- docs examples`
-
-Migrate one-shot guides and examples to direct result delivery through
-`to_actor.run()`, preserving named target inputs with target partials.
-Use daemon actors and concurrent portal calls where reciprocal actor
-lifetimes require both peers to coexist. Add API and guide cross-links,
-and retain only explicit legacy/removal notes.
-
-Verification:
-
-- executable docs examples: `23 passed`
-- debugger/tooling TCP: `39 passed, 6 skipped`
-- debugger/tooling UDS: `39 passed, 6 skipped`
-- Ruff, compilation and `git diff --check`: clean
-- local Sphinx build unavailable because Sphinx is not installed

ai/prompt-io/opencode/20260820T135125Z_9f99043b_prompt_io.md

@@ -1,35 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: 76c5d31c-5a2f-4503-9b16-410ee7f4fab3
-timestamp: 2026-08-20T13:51:25Z
-git_ref: 9f99043b
-scope: tests
-substantive: true
-raw_file: 20260820T135125Z_9f99043b_prompt_io.raw.md
----
-
-## Prompt
-
-Continue preparing PR #481 for landing after the prior test and
-documentation commits were pushed. Follow CI and proceed with clear next
-steps without merging or changing remote content unasked.
-
-## Response summary
-
-Followed CI through completion and found both macOS jobs failed because the
-new `skipif` expression returned the `CI=true` environment string. Corrected
-the condition to pass pytest a boolean before evaluating the marker. A
-simulated Darwin-CI run now skips cleanly, and the sequential TCP and UDS
-debugger/tooling suites each pass with 39 passed and 6 skipped.
-
-## Files changed
-
-- `tests/devx/test_debugger.py` - coerce the Darwin-CI skip condition to a
-  boolean.
-
-## Human edits
-
-The human pushed the preceding commits, directed the agent to continue, and
-approved recording this test-only follow-up in Prompt-IO. No direct
-source-line edits were made by the human.

ai/prompt-io/opencode/20260820T135125Z_9f99043b_prompt_io.raw.md

@@ -1,22 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-20T13:51:25Z
-git_ref: 9f99043b
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Continue preparing PR #481 for landing after the test and documentation
-commits were pushed. Follow the new CI run to completion and diagnose any
-failures.
-
-> `git diff HEAD~1..HEAD -- tests/devx/test_debugger.py`
-
-Both macOS jobs failed while evaluating the new `skipif` marker. The
-expression returned the `CI=true` environment string instead of a boolean,
-so pytest evaluated `true` as Python source and raised `NameError` during
-test setup. Coerce `_ci_env` to `bool` so pytest receives a boolean marker
-condition on Darwin CI.
-
-Verification should exercise the condition with `CI=true` and a simulated
-Darwin platform, then rerun the debugger/tooling TCP and UDS suites.

ai/prompt-io/opencode/20260820T143845Z_559fd0f1_prompt_io.md

@@ -1,43 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: 76c5d31c-5a2f-4503-9b16-410ee7f4fab3
-timestamp: 2026-08-20T14:38:50Z
-git_ref: 559fd0f1
-scope: code
-substantive: true
-raw_file: 20260820T143845Z_559fd0f1_prompt_io.raw.md
----
-
-## Prompt
-
-Continue preparing PR #481 after the latest fix was pushed. Follow CI and
-proceed with clear next steps toward a green landing candidate.
-
-## Response summary
-
-Traced the remaining macOS UDS failure to cancellation racing transport
-teardown inside the shielded framed-send path. Preserve pending cancellation
-over a transport error caused by concurrent teardown, and add a deterministic
-regression for that ordering. A follow-up A/B run showed the corrected
-cancellation precedence changes which nested debugger intermediary is
-rendered as the immediate source versus relay, so retain coverage for both
-actor levels without pinning those racy roles. The adjusted UDS node passes
-three consecutive runs, and both debugger/tooling transport suites pass with
-39 passed and 6 skipped.
-
-## Files changed
-
-- `tractor/ipc/_transport.py` - deliver pending cancellation before
-  translating a shielded send's transport error.
-- `tests/ipc/test_each_tpt.py` - reproduce cancellation followed by local
-  stream closure during shielded frame publication.
-- `tests/devx/test_debugger.py` - accept either valid source/relay role for
-  each nested intermediary while retaining the actor and error assertions.
-
-## Human edits
-
-The human pushed the preceding fix, ran the proposed verification plan, and
-reported a repeated UDS debugger failure. That report prompted the A/B
-comparison and role-insensitive assertion. No direct source-line edits were
-made by the human.

ai/prompt-io/opencode/20260820T143845Z_559fd0f1_prompt_io.raw.md

@@ -1,26 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-20T14:38:50Z
-git_ref: 559fd0f1
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Continue preparing PR #481 after pushing the macOS debugger skip fix.
-Follow the replacement CI run and address any remaining PR-specific
-failure.
-
-> `git diff HEAD~1..HEAD -- tractor/ipc/_transport.py`
-
-> `git diff HEAD~1..HEAD -- tests/ipc/test_each_tpt.py`
-
-macOS UDS failed `test_reqresp_ontopof_streaming` when its two-second
-`move_on_after()` scope cancelled during `stream.send('ping')`. Commit
-`88a23449` shields framed `send_all()` and checks pending cancellation only
-after a successful write. Concurrent transport teardown instead closed the
-socket, causing `ClosedResourceError` to escape as `TransportClosed` before
-the pending cancellation could be delivered.
-
-Preserve structured cancellation precedence on the shielded send's
-transport-error path, and add a deterministic regression that cancels the
-sender before making the fake stream raise `ClosedResourceError`.

ai/prompt-io/opencode/20260821T023537Z_ae6f2ac3_prompt_io.md

@@ -1,65 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: 76c5d31c-5a2f-4503-9b16-410ee7f4fab3
-timestamp: 2026-08-21T02:35:37Z
-git_ref: ae6f2ac3
-scope: code
-substantive: true
-raw_file: 20260821T023537Z_ae6f2ac3_prompt_io.raw.md
----
-
-## Prompt
-
-Simplify bounded actor cancellation by passing an explicit absolute
-deadline from `Portal.cancel_actor()` through `_run_from_ns()`,
-`Actor.start_remote_task()`, and `Channel.send()` into
-`MsgpackTransport.send()`. Avoid a `ContextVar`, watcher tasks, shared
-status, coalescing, and waiter state. After tracing the current
-`Start -> StartAck -> CancelAck` transaction, rename the local result to
-`cancel_ack_received`, document its exact semantics, and link a focused
-follow-up for a dedicated `Cancel -> CancelAck` protocol.
-
-## Response summary
-
-Threaded one absolute Trio deadline through the existing private
-actor-cancel RPC path. The transport retains complete-frame shielding
-for ordinary sends, while a cancel-control send that overruns its
-deadline force-closes the potentially corrupted stream before releasing
-the send lock. The outer actor-cancel scope uses the same deadline for
-ack waiting and redelivers pending caller cancellation afterward.
-
-Renamed the completion flag to `cancel_ack_received` and documented that
-the current private call consumes `StartAck`, then receives a real
-`CancelAck` after `Actor.cancel()` completes; this does not establish
-that the OS process exited. Added a source TODO linking issue #506 for
-the future first-class `Cancel -> CancelAck` transaction.
-
-Focused transport and actor-cancel verification passed all four tests.
-
-## Files changed
-
-- `tractor/runtime/_portal.py` - own the absolute deadline, accurately
-  record ack receipt, and link the dedicated cancellation protocol.
-- `tractor/runtime/_runtime.py` - forward the optional deadline for the
-  exact private `Start` publication.
-- `tractor/ipc/_chan.py` - pass the operation-specific deadline to the
-  transport without changing ordinary sends.
-- `tractor/ipc/_transport.py` - bound the shielded frame publication and
-  close a partial-frame stream before unlocking it.
-- `tests/ipc/test_each_tpt.py` - cover deadline expiry after a partial
-  frame prefix reaches the stream.
-- `tests/test_to_actor.py` - prove actor-cancel publication and ack
-  waiting share one absolute timeout budget.
-
-## Human edits
-
-The human rejected the initial watcher-task, shared `_SendStatus`, cancel
-coalescing, and per-waiter design as unnecessary complexity. They also
-rejected `ContextVar` propagation in favor of explicit functional
-threading, selected a single absolute deadline for publication and ack
-waiting, and required item 2 to remain separate from the item-3 child
-reaping work. After reviewing the result, they requested the precise
-`cancel_ack_received` name, a detailed protocol-trace comment, a focused
-follow-up issue, and a linked source TODO. No direct source-line edits
-were made by the human.

ai/prompt-io/opencode/20260821T023537Z_ae6f2ac3_prompt_io.raw.md

@@ -1,41 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-21T02:35:37Z
-git_ref: ae6f2ac3
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Replace the actor-cancel timeout watcher/status experiment with one
-explicit absolute deadline threaded through the existing private call
-path. Do not use a `ContextVar`, shared result state, waiter
-coalescing, or polling tasks.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_portal.py`
-
-`Portal.cancel_actor()` computes one absolute deadline and uses it for
-both `Start` frame publication and the subsequent cancel-ack wait.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_runtime.py`
-
-> `git diff HEAD~1..HEAD -- tractor/ipc/_chan.py`
-
-The private RPC path forwards the operation-specific deadline. Lower
-layers preserve the ordinary infinite-deadline call shape.
-
-> `git diff HEAD~1..HEAD -- tractor/ipc/_transport.py`
-
-`MsgpackTransport.send()` applies the deadline inside its complete-frame
-shield. If the deadline expires after partial publication, it closes
-the unusable stream before releasing the send lock.
-
-> `git diff HEAD~1..HEAD -- tests/ipc/test_each_tpt.py`
-
-> `git diff HEAD~1..HEAD -- tests/test_to_actor.py`
-
-Focused regressions prove a partial-frame timeout closes the stream and
-that actor-cancel publication and acknowledgement share one budget.
-
-The implementation removes the earlier `_SendStatus`, watcher task,
-coalescing, shared cancel result, and per-waiter state. Four focused
-transport and actor-cancel tests pass.

ai/prompt-io/opencode/20260821T040803Z_3c1bbe73_prompt_io.md

@@ -1,57 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: 76c5d31c-5a2f-4503-9b16-410ee7f4fab3
-timestamp: 2026-08-21T04:08:03Z
-git_ref: 3c1bbe73
-scope: code
-substantive: true
-raw_file: 20260821T040803Z_3c1bbe73_prompt_io.raw.md
----
-
-## Prompt
-
-Continue PR #481 review cleanup one item at a time. Compare the
-remaining child-registration/reaping experiment against PR #484,
-identify the next valid behavior, and generate an exact commit plan for
-that boundary without committing automatically.
-
-## Response summary
-
-Separated late-child admission from the broader bounded-reap rewrite.
-Added one synchronous `ActorNursery._register_child()` publication step
-that stores the child and its reap events before sampling nursery
-cancellation. This closes both scheduler orderings around
-`ActorNursery.cancel()`'s child snapshot.
-
-The MP backend registers immediately before synchronous process startup
-and refuses to start when cancellation already owns the child. The Trio
-backend registers immediately after `open_process()` and kills that
-already-created process when registration observes cancellation. An
-early `start_actor()` guard rejects calls begun after cancellation is
-already visible.
-
-Deterministic tests cover the nursery registration ordering and the MP
-no-start invariant. Comparison with PR #484 confirmed that its retained
-generic nursery/backends do not close this race.
-
-## Files changed
-
-- `tractor/runtime/_supervise.py` - atomically publish child ownership
-  and reject actor starts after nursery cancellation.
-- `tractor/spawn/_mp.py` - register before synchronous process startup
-  and abort a cancellation-owned child.
-- `tractor/spawn/_trio.py` - register immediately after process creation,
-  kill a cancellation-owned child, and remove its stale unused import.
-- `tests/test_to_actor.py` - cover late registration and MP startup
-  suppression.
-
-## Human edits
-
-The human required review extras to be handled one item and one
-behavioral commit at a time, with each item compared against PR #484
-before acceptance. That direction split this late-registration fix from
-the original broad experiment's bounded post-ack reaping,
-`ActorNursery.cancel()` hard-reap rewrite, and debugger/error behavior.
-The human accepted the narrower late-registration boundary by requesting
-its commit plan. No direct source-line edits were made by the human.

ai/prompt-io/opencode/20260821T040803Z_3c1bbe73_prompt_io.raw.md

@@ -1,48 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-21T04:08:03Z
-git_ref: 3c1bbe73
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Compare the remaining child-registration and reaping experiment with
-PR #484, then identify the next review item without changing code.
-
-The next item is the late-child admission race. A spawn can pass
-`ActorNursery.start_actor()`'s early cancellation check, then be absent
-from `ActorNursery.cancel()`'s child snapshot and register afterward.
-The existing reap-request latch releases its monitor but does not send
-runtime cancellation, so the monitor can wait forever for a still-live
-process.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_supervise.py`
-
-`ActorNursery._register_child()` publishes the child, installs its reap
-events, and samples `ActorNursery._cancel_called` without a checkpoint.
-The two scheduler orderings are then complete: registration first puts
-the child in the cancel snapshot, while cancellation first makes the
-backend abort the late registration.
-
-> `git diff HEAD~1..HEAD -- tractor/spawn/_mp.py`
-
-The multiprocessing backend registers immediately before `proc.start()`
-and refuses to start a process already owned by nursery cancellation.
-There is no Trio checkpoint between registration and process startup.
-
-> `git diff HEAD~1..HEAD -- tractor/spawn/_trio.py`
-
-The Trio backend registers immediately after `open_process()` and kills
-the newly opened process if cancellation won the registration race. Its
-stale unused `get_runtime_vars` import is removed so the touched module
-remains lint-clean.
-
-> `git diff HEAD~1..HEAD -- tests/test_to_actor.py`
-
-Deterministic regressions prove late registration observes cancellation
-and that the MP backend never starts a process after cancellation owns
-its registration.
-
-PR #484 retains the affected generic nursery and spawn-backend paths and
-does not close this race. Keep this fix in PR #481 as its own commit;
-review bounded post-`CancelAck` reaping separately.

ai/prompt-io/opencode/20260824T222033Z_ce38cb6f_prompt_io.md

@@ -1,37 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: d9d7df2c-7044-463f-8768-ec024718eac9
-timestamp: 2026-08-24T22:20:33Z
-git_ref: ce38cb6f
-scope: code
-substantive: true
-raw_file: 20260824T222033Z_ce38cb6f_prompt_io.raw.md
----
-
-## Prompt
-
-Continue the PR #481 review after triage. The human explicitly accepted
-the proposed merge-blocking `Context.cancel()` deadline update with
-"keep" and required the work to remain limited to that review item.
-
-## Response summary
-
-Update `Context.cancel()` so one absolute deadline bounds both shielded
-cancel-request publication and acknowledgement waiting. Add a focused
-mocked-clock regression for the blocked-publication failure mode and run
-the narrow cancellation tests.
-
-## Files changed
-
-- `tractor/_context.py` - forward the cancel transaction's absolute
-  deadline to frame publication.
-- `tests/test_to_actor.py` - prove blocked context-cancel publication is
-  bounded by the shared deadline.
-
-## Human edits
-
-The human retained ownership of review scope and explicitly selected
-"keep" for this item after receiving keep/defer/drop options. The human
-required no unrelated cancellation changes and did not directly edit
-source lines.

ai/prompt-io/opencode/20260824T222033Z_ce38cb6f_prompt_io.raw.md

@@ -1,26 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-24T22:20:33Z
-git_ref: ce38cb6f
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Implement the approved PR #481 review update for `Context.cancel()`.
-Use one absolute deadline for both cancellation-request frame
-publication and acknowledgement waiting, without broadening the change
-to unrelated cancellation behavior.
-
-> `git diff HEAD~1..HEAD -- tractor/_context.py`
-
-`Context.cancel()` computes one absolute cancellation deadline, uses it
-for the outer bounded wait, and forwards it through
-`Portal._run_from_ns()` to shielded frame publication.
-
-> `git diff HEAD~1..HEAD -- tests/test_to_actor.py`
-
-A deterministic mocked-clock regression arranges a shielded blocked
-publication and proves that `Context.cancel()` forwards the same deadline
-which bounds the complete cancel transaction.
-
-Run the focused cancellation deadline regressions after the edit.

ai/prompt-io/opencode/20260824T223614Z_88d538e3_prompt_io.md

@@ -1,35 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: d9d7df2c-7044-463f-8768-ec024718eac9
-timestamp: 2026-08-24T22:36:14Z
-git_ref: 88d538e3
-scope: code
-substantive: true
-raw_file: 20260824T223614Z_88d538e3_prompt_io.raw.md
----
-
-## Prompt
-
-Continue PR #481 review remediation after committing the shared
-`Context.cancel()` deadline fix. The human accepted the proposed
-child-reap bookkeeping invariant, asking only that the first fix receive
-its own commit plan and commit before this update began.
-
-## Response summary
-
-Check that `ActorNursery` removes its paired reap-coordination entries
-together while preserving valid pre-registration and immediate-cancel
-paths. Extend the existing real-runtime reap tests to prove all three
-child bookkeeping mappings are empty before `to_actor.run()` returns.
-
-## Files changed
-
-- `tractor/runtime/_supervise.py` - assert paired reap-map cleanup.
-- `tests/test_to_actor.py` - verify graceful and hard-reap bookkeeping.
-
-## Human edits
-
-The human explicitly accepted this invariant update but directed the
-preceding cancellation fix to be planned and committed as a separate
-boundary first. No direct source-line edits were made by the human.

ai/prompt-io/opencode/20260824T223614Z_88d538e3_prompt_io.raw.md

@@ -1,26 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-24T22:36:14Z
-git_ref: 88d538e3
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Implement the approved PR #481 child-reap bookkeeping update after the
-preceding `Context.cancel()` fix was committed separately.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_supervise.py`
-
-`ActorNursery._mark_child_reaped()` captures both reap-coordination
-entries and asserts that they are either both present or both absent.
-It intentionally does not require the reap-request event to be set,
-because backend cancellation can reap immediately after registration.
-
-> `git diff HEAD~1..HEAD -- tests/test_to_actor.py`
-
-Existing real-runtime graceful and hard-reap tests verify that
-`ActorNursery._children`, `ActorNursery._child_reap_requests`, and
-`ActorNursery._child_reaped` are all empty before the one-shot call
-returns.
-
-Run focused bookkeeping and real-runtime reap tests after the edit.

ai/prompt-io/opencode/20260824T225356Z_2f86dd1a_prompt_io.md

@@ -1,39 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: d9d7df2c-7044-463f-8768-ec024718eac9
-timestamp: 2026-08-24T22:53:56Z
-git_ref: 2f86dd1a
-scope: code
-substantive: true
-raw_file: 20260824T225356Z_2f86dd1a_prompt_io.raw.md
----
-
-## Prompt
-
-Continue PR #481 review remediation after committing the paired
-`ActorNursery` reap-state invariant. The human selected "keep" for the
-reviewer's request to factor a duplicated debugger predicate in
-`_try_cancel_then_kill()`.
-
-## Response summary
-
-Factor the child/tree debugger predicate into a local sampler used both
-before and after the cancel-RPC checkpoint. Preserve dynamic debugger
-lock re-evaluation and its distinction from root-wide debug mode.
-
-## Files changed
-
-- `tractor/runtime/_supervise.py` - factor the duplicated debugger
-  predicate without changing cancellation behavior.
-
-## Human edits
-
-The human explicitly selected "keep" after receiving keep/defer/drop
-options for this isolated review item. During commit-plan review, the
-agent found that a single pre-checkpoint snapshot could become stale;
-the human selected a local helper which re-evaluates the lock after the
-cancel RPC. The human then considered moving the predicate into
-`.devx.debug` and accepted keeping it local after confirming that no
-existing helper shares its supervisor-owned semantics. No direct
-source-line edits were made by the human.

ai/prompt-io/opencode/20260824T225356Z_2f86dd1a_prompt_io.raw.md

@@ -1,18 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-24T22:53:56Z
-git_ref: 2f86dd1a
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Implement the approved PR #481 review refactor in
-`_try_cancel_then_kill()` without changing debugger behavior.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_supervise.py`
-
-Compute the child/tree debugger predicate once, reuse it in the broader
-hard-kill protection predicate, and pass it directly to
-`debug.maybe_wait_for_debugger()`.
-
-Run focused debugger/cancellation coverage and lint after the edit.

ai/prompt-io/opencode/20260824T233957Z_5327b25e_prompt_io.md

@@ -1,36 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: d9d7df2c-7044-463f-8768-ec024718eac9
-timestamp: 2026-08-24T23:39:57Z
-git_ref: 5327b25e
-scope: code
-substantive: true
-raw_file: 20260824T233957Z_5327b25e_prompt_io.raw.md
----
-
-## Prompt
-
-Continue PR #481 review remediation after committing the debugger-state
-sampler. The human selected "keep" for the paired review request to use
-`Aid` objects as keys in the newly added reap-coordination maps.
-
-## Response summary
-
-Migrate only `ActorNursery._child_reap_requests` and
-`ActorNursery._child_reaped` to `Aid` keys. Preserve the legacy
-`ActorNursery._children` `.uid` key and pass full actor identities
-through the narrow process-monitor bookkeeping path.
-
-## Files changed
-
-- `tractor/runtime/_supervise.py` - key fresh reap maps by `Aid`.
-- `tractor/spawn/_spawn.py` - pass `Aid` into completed-reap cleanup.
-- `tests/test_to_actor.py` - exercise `Aid` registration keys.
-
-## Human edits
-
-The human explicitly selected "keep" after reviewing the scope,
-performance, and mutability tradeoffs. The human retained the legacy
-tuple key for `_children` and accepted `Aid` for only the two fresh
-private mappings. No direct source-line edits were made by the human.

ai/prompt-io/opencode/20260824T233957Z_5327b25e_prompt_io.raw.md

@@ -1,27 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-24T23:39:57Z
-git_ref: 5327b25e
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Implement the approved PR #481 review update which uses `Aid` keys for
-the two fresh `ActorNursery` reap-coordination maps while preserving the
-legacy `.uid` key for `ActorNursery._children`.
-
-> `git diff HEAD~1..HEAD -- tractor/runtime/_supervise.py`
-
-Type and access `_child_reap_requests` and `_child_reaped` by `Aid`.
-Pass full actor identities through registration, cancellation, and
-completed-reap bookkeeping, deriving `.uid` only for `_children`.
-
-> `git diff HEAD~1..HEAD -- tractor/spawn/_spawn.py`
-
-Forward `subactor.aid` when publishing completed process teardown.
-
-> `git diff HEAD~1..HEAD -- tests/test_to_actor.py`
-
-Update deterministic registration tests to exercise `Aid` map keys.
-
-Run focused registration/reaping tests and the full `to_actor` suite.

ai/prompt-io/opencode/20260825T015742Z_e42ecb55_prompt_io.md

@@ -1,38 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: d9d7df2c-7044-463f-8768-ec024718eac9
-timestamp: 2026-08-25T01:57:42Z
-git_ref: e42ecb55
-scope: code
-substantive: true
-raw_file: 20260825T015742Z_e42ecb55_prompt_io.raw.md
----
-
-## Prompt
-
-Continue PR #481 review remediation after committing the `Aid` reap-map
-migration. The human selected "keep" for comments explaining why both
-spawn backends provisionally register children with `portal=None`.
-
-## Response summary
-
-Document that a child has no `Portal` until its IPC handshake yields a
-`Channel`, and make `portal=None` explicit at both registration calls.
-Identify the later replacement of each provisional entry with
-`Portal(chan)`. Update the MP registration test double to accept and
-assert the explicit provisional portal state. Name every registration
-argument consistently in both backends.
-
-## Files changed
-
-- `tractor/spawn/_mp.py` - clarify provisional MP registration.
-- `tractor/spawn/_trio.py` - clarify provisional Trio registration.
-- `tests/test_to_actor.py` - model explicit provisional registration.
-
-## Human edits
-
-The human explicitly selected "keep" after receiving keep/defer/drop
-options for this paired clarification. During local review, the human
-then requested that `subactor` and `proc` also be passed by name in both
-backend calls. No direct source-line edits were made by the human.

ai/prompt-io/opencode/20260825T015742Z_e42ecb55_prompt_io.raw.md

@@ -1,21 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-25T01:57:42Z
-git_ref: e42ecb55
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Implement the approved PR #481 clarification for provisional child
-registration in both process-spawn backends.
-
-> `git diff HEAD~1..HEAD -- tractor/spawn/_mp.py`
-
-> `git diff HEAD~1..HEAD -- tractor/spawn/_trio.py`
-
-Explain that `portal=None` is provisional because no `Portal` can exist
-until the child completes its IPC handshake and returns a `Channel`.
-Use an explicit keyword argument and identify the later replacement with
-`Portal(chan)`.
-
-Run lint and the full `to_actor` runtime suite.

ai/prompt-io/opencode/20260825T021319Z_ce430fca_prompt_io.md

@@ -1,32 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-session: d9d7df2c-7044-463f-8768-ec024718eac9
-timestamp: 2026-08-25T02:13:19Z
-git_ref: ce430fca
-scope: code
-substantive: true
-raw_file: 20260825T021319Z_ce430fca_prompt_io.raw.md
----
-
-## Prompt
-
-Continue PR #481 review remediation after committing provisional child
-registration clarifications. The human selected "keep" for inlining the
-guarded `functools.Placeholder` lookup with a walrus assignment.
-
-## Response summary
-
-Remove the standalone placeholder assignment and bind the optional
-Python 3.14 sentinel directly in the existing conditional while
-preserving compatibility behavior.
-
-## Files changed
-
-- `tractor/to_actor/_api.py` - inline placeholder feature detection.
-
-## Human edits
-
-The human explicitly selected "keep" after receiving keep/defer/drop
-options for this isolated cleanup. No direct source-line edits were made
-by the human.

ai/prompt-io/opencode/20260825T021319Z_ce430fca_prompt_io.raw.md

@@ -1,19 +0,0 @@
----
-model: openai/gpt-5.6-sol
-service: opencode
-timestamp: 2026-08-25T02:13:19Z
-git_ref: ce430fca
-diff_cmd: git diff HEAD~1..HEAD
----
-
-Implement the approved PR #481 review cleanup for Python 3.14 partial
-placeholder detection.
-
-> `git diff HEAD~1..HEAD -- tractor/to_actor/_api.py`
-
-Inline the guarded `functools.Placeholder` lookup into the existing
-condition with a walrus assignment, preserving fallback behavior when
-the attribute is unavailable.
-
-Run partial/placeholder normalization tests and the full `to_actor`
-suite.

ai/prompt-io/prompts/issue_477.md

@@ -1,7 +0,0 @@
-NOTE: you MUST pause this work at 12:50PM EST (BEFORE your weekly
-limit reset) for review by a human!
-
----
-
-attempt to resolve https://github.com/goodboy/tractor/issues/477
-do it with /open-wkt.

docs/api/core.rst

@@ -37,6 +37,7 @@ Spawning actors
 
 .. autoclass:: ActorNursery
    :members: start_actor,
+             run_in_actor,
              cancel,
              cancel_called,
              cancelled_caught
@@ -45,25 +46,11 @@ Spawning actors
 
    :meth:`ActorNursery.start_actor` (daemon actor + portal) is the
    blessed spawning primitive; pair it with
-   :meth:`Portal.open_context` for SC-linked remote tasks.
+   ``Portal.open_context()`` for SC-linked remote tasks.
-
+   :meth:`ActorNursery.run_in_actor` is a *convenience* one-shot —
-One-shot task actors
+   spawn, run a single task, auto-cancel after the result — slated
---------------------
+   to be rebuilt as a high-level wrapper, so don't design around
-
+   it as the core model.
-.. autofunction:: tractor.to_actor.run
-
-.. note::
-
-   Without ``portal=``, :func:`tractor.to_actor.run` (parlance of
-   ``trio.to_thread.run_sync()`` and friends) is the convenience
-   one-shot: spawn, run one task, block on its result and reap. It
-   combines :meth:`ActorNursery.start_actor`, a linked
-   :meth:`Portal.open_context` call and per-child reaping. With
-   ``portal=`` it owns only the linked task and leaves the existing
-   actor's lifetime to the portal owner; that actor must expose both
-   the target module and ``tractor.to_actor.MODULE``. It supersedes
-   the legacy, non-blocking ``ActorNursery.run_in_actor()`` retained
-   only for compatibility until its removal in PR #484.
 
 .. deprecated:: 0.1.0a6
 
@@ -84,12 +71,14 @@ flowing back `exactly like trio`_.
    :members: run,
              run_from_ns,
              open_stream_from,
+             wait_for_result,
              cancel_actor,
              chan
 
 .. deprecated:: 0.1.0a6
 
-   The str-form ``Portal.run('mod.path', 'fn_name')`` warns;
+   ``Portal.result()`` warns; use :meth:`Portal.wait_for_result`.
+   The str-form ``Portal.run('mod.path', 'fn_name')`` also warns;
    pass a function *object* whose module is listed in the target's
    ``enable_modules``. ``Portal.channel`` is the legacy spelling
    of :attr:`Portal.chan`.

docs/api/index.rst

@@ -5,9 +5,8 @@ This is the curated reference for ``tractor``'s public surface: the
 names you can import and lean on without reading runtime internals.
 Everything below is re-exported at the top level (``import
 tractor``) unless a page says otherwise; subsystems like
-``tractor.msg``, ``tractor.trionics``, ``tractor.to_actor``,
+``tractor.msg``, ``tractor.trionics``, ``tractor.to_asyncio``,
-``tractor.to_asyncio``, ``tractor.devx`` and ``tractor.log`` are
+``tractor.devx`` and ``tractor.log`` are importable as submodules.
-importable as submodules.
 
 ``tractor`` is "just trio_" extended across processes: every API
 here is designed to keep the structured concurrency (SC) rules you
@@ -24,7 +23,6 @@ Most-used names at a glance:
 
    open_root_actor
    open_nursery
-   to_actor.run
    run_daemon
    ActorNursery
    Portal

docs/api/to_asyncio.rst

@@ -30,12 +30,11 @@ Starting asyncio tasks from trio
 .. note::
 
    :func:`open_channel_from` mirrors the
-   :meth:`tractor.Portal.open_context` handshake: the asyncio side calls
+   ``Portal.open_context()`` handshake: the asyncio side calls
    ``chan.started_nowait(value)`` and that value pops out as
    ``first`` on the trio side. :func:`run_task` is the one-shot
    form — run a single asyncio-compatible coroutine fn and return
-   its result to trio; :func:`tractor.to_actor.run` is its
+   its result to trio.
-   cross-process sibling.
 
 The inter-loop channel
 ----------------------

docs/guide/asyncio.rst

@@ -76,8 +76,8 @@ Just flip the flag on :meth:`tractor.ActorNursery.start_actor`:
             infect_asyncio=True,
         )
 
-The one-shot convenience ``tractor.to_actor.run()`` accepts the
+The one-shot convenience ``ActorNursery.run_in_actor()`` accepts
-same flag. The ``to_asyncio`` APIs may **only** be called from
+the same flag. The ``to_asyncio`` APIs may **only** be called from
 tasks inside an infected actor; calling them anywhere else raises
 a loud ``RuntimeError``. You can introspect at runtime with
 ``tractor.current_actor().is_infected_aio()``.
@@ -229,7 +229,7 @@ dialog, skip the channel ceremony and use
 
 It schedules the fn as an ``asyncio.Task``, waits for completion
 and hands the return value back to ``trio``; think of it as the
-cross-loop sibling of ``tractor.to_actor.run()``. Errors and
+cross-loop sibling of ``ActorNursery.run_in_actor()``. Errors and
 cancellation are translated exactly as for channels.
 
 Cross-loop errors and cancellation

docs/guide/cancellation.rst

@@ -64,13 +64,11 @@ What's going on here?
 - three healthy actors are spawned as daemons via
   :meth:`tractor.ActorNursery.start_actor`; left alone they'd
   happily idle forever,
-- a fourth actor runs ``assert_err()`` via a blocking
+- a fourth actor runs ``assert_err()`` via ``.run_in_actor()`` and
-  ``tractor.to_actor.run()`` one-shot and promptly trips its
+  promptly trips its ``assert 0``,
-  ``assert 0``,
 - the resulting ``AssertionError`` ships back over IPC as a
-  serialized error msg and re-raises *boxed* right at the call
+  serialized error msg and re-raises *boxed* inside the nursery
-  inside the nursery block as a
+  block as a :class:`tractor.RemoteActorError`,
-  :class:`tractor.RemoteActorError`,
 - the nursery reacts like any ``trio`` nursery would: it cancels
   the three healthy siblings (graceful runtime-cancel requests,
   acks awaited), reaps all four processes, then re-raises,
@@ -230,23 +228,22 @@ Graceful first, hard as a last resort
 
    The hard-kill path is *skipped* whenever an actor in the tree
    holds the debug-REPL lock (``debug_mode=True`` flavors):
-   Process signals raining down on a tree mid-``pdb`` session would
+   SIGTERM raining down on a tree mid-``pdb`` session would
    clobber your prompt. See :doc:`/guide/debugging`.
 
-Owned-child teardown in ``tractor`` begins with the same graceful
+Every process teardown in ``tractor`` walks the same escalation
-steps, then selects the escalation path used by its supervisor,
+ladder, top rung first,
 
 1. **graceful cancel request**: a runtime-cancel msg over IPC; the
    target actor cancels its tasks, closes its channels and exits
    its :func:`trio.run` cleanly,
 2. **soft wait**: the parent waits (bounded) for the child process
    to exit on its own,
-3. **actor-nursery hard reap**: no cancel ack within the bounded wait
+3. **SIGTERM**: no ack within the bounded wait (internally an
-   (internally an ``ActorTooSlowError``) escalates directly to
+   ``ActorTooSlowError``) escalates to ``proc.terminate()``,
-   ``proc.kill()`` before the child monitor joins the process,
+4. **SIGKILL ultimatum**: still alive after the hard-kill timeout
-4. **legacy soft-kill path**: older teardown callers may first issue
+   (~1.6s)? The runtime logs that the "T-800" has been deployed to
-   ``proc.terminate()`` and then deploy the "T-800" ``proc.kill()``
+   collect the zombie and issues ``proc.kill()``. No survivors.
-   ultimatum if the process survives that additional bounded wait.
 
 The result is the **no-zombies guarantee**: ``tractor`` tries to
 protect you from zombies, no matter what. Quoting the project

docs/guide/clustering.rst

@@ -62,10 +62,7 @@ one kwarg away,
 .. code:: python
 
     async with tractor.open_actor_cluster(
-        modules=[
+        modules=['mylib.workers'],
-            'mylib.workers',
-            tractor.to_actor.MODULE,
-        ],
         count=4,
         names=['scout', 'miner', 'smelter', 'smith'],
         debug_mode=True,    # whole-fleet crash-to-REPL
@@ -73,12 +70,9 @@ one kwarg away,
         ...
 
 From here the composition patterns are the usual ``tractor`` fare:
-``portal.run()`` for bare one-shot RPCs (as in the demo),
+``portal.run()`` for one-shot calls (as in the demo), or — for a
-``tractor.to_actor.run(..., portal=portal)`` for cancellation-linked
+persistent bidirectional dialog per worker — concurrently enter N
-one-shot tasks in an existing worker (include
+``portal.open_context()`` blocks with
-``tractor.to_actor.MODULE`` in ``modules``; the cluster still owns
-the worker's lifetime), or — for a persistent bidirectional dialog
-per worker — concurrently enter N ``portal.open_context()`` blocks with
 ``tractor.trionics.gather_contexts()``; see :doc:`/guide/context`
 for that whole layer.
 
@@ -93,8 +87,8 @@ Clusters vs. nurseries
 
 ``open_actor_cluster()`` is sugar, not a new primitive: under the
 hood it's just :func:`tractor.open_nursery` plus N concurrent
-:meth:`~tractor.ActorNursery.start_actor` calls plus a ``.cancel()``
+``start_actor()`` calls plus a ``.cancel()`` on the way out. Reach
-on the way out. Reach for it when,
+for it when,
 
 - you want a *flat*, homogeneous fleet (classic worker-pool or
   map-style fan-out shapes),

docs/guide/context.rst

@@ -15,12 +15,12 @@ a single `structured concurrency`_ (SC) scope over IPC.
    :alt: sequence diagram of the context handshake msg flow
 
 Pretty much everything else is (or is slated to be) built on this
-one primitive: ``tractor.to_actor.run()`` uses it for a linked
+one primitive: ``ActorNursery.run_in_actor()`` is a convenience
-one-shot task, spawning and reaping an actor only when no ``portal=``
+for "spawn, open a context, await the result, tear down"; plain
-is supplied; plain ``Portal.run()`` RPC is planned to be
+``Portal.run()`` RPC is planned to be re-implemented on top of it;
-re-implemented on top of it; the multi-process debugger's tree-wide
+the multi-process debugger's tree-wide REPL lock rides one. Grok
-REPL lock rides one. Grok this page and the rest of the library reads
+this page and the rest of the library reads as convenience
-as convenience wrappers B)
+wrappers B)
 
 The endpoint contract
 ---------------------

docs/guide/index.rst

@@ -9,8 +9,8 @@ docs; what you read is what CI runs).
 Roughly in "first date to long term relationship"
 order,
 
-- :doc:`spawning` — actor nurseries, daemons,
+- :doc:`spawning` — actor nurseries, daemons +
-  ``to_actor.run()`` one-shots and process lifetimes.
+  one-shot workers, process lifetimes.
 - :doc:`rpc` — portals: calling into another
   process like it's a local ``await``.
 - :doc:`context` — the cross-actor task-pair

docs/guide/parallelism.rst

@@ -119,16 +119,15 @@ Run a func in a process
 
 Even a pool can be overkill; "run this one async func in a
 subprocess and give me the result" is a one-liner via
-:func:`tractor.to_actor.run`,
+:meth:`tractor.ActorNursery.run_in_actor`,
 
 .. literalinclude:: ../../examples/parallelism/single_func.py
    :caption: examples/parallelism/single_func.py
    :language: python
 
-``to_actor.run()`` is a *convenience wrapper* — spawn an actor,
+``run_in_actor()`` is a *convenience wrapper* — spawn an actor, run
-run exactly one task in it, block on and return its result, reap
+exactly one task in it, reap on result — not the core spawning
-— not the core spawning model (that's
+model (that's :meth:`tractor.ActorNursery.start_actor` plus
-:meth:`tractor.ActorNursery.start_actor` plus
 :meth:`tractor.Portal.open_context`; see :doc:`/guide/context`).
 But for this fire-and-collect shape it's exactly the right amount
 of typing.

docs/guide/rpc.rst

@@ -80,56 +80,28 @@ One special namespace exists: ``'self'`` resolves to the remote
 how internal machinery (cancel requests, registry ops) travels;
 don't build your app on it.
 
-One-shot subactors: ``to_actor.run()``
+One-shot results: ``wait_for_result()``
---------------------------------------
+---------------------------------------
-When the call should own a fresh subactor whose entire job is one
+A portal returned from
-function call, :func:`tractor.to_actor.run` spawns it, runs the task,
+:meth:`~tractor.ActorNursery.run_in_actor` has exactly one
-returns its result and reaps the process — all in one blocking call:
+"main" task running remotely; that task's ``return`` value is
+delivered as the portal's *final result*:
 
 .. code:: python
 
-    from functools import partial
+    portal = await an.run_in_actor(fib, n=10)
-
+    final = await portal.wait_for_result()
-    final = await tractor.to_actor.run(
-        partial(fib, n=10),
-        an=an,
-    )
 
 Semantics worth knowing:
 
 - it blocks until the remote task returns, re-raising any
-  remote error in the usual boxed form right in the calling
+  remote error in the usual boxed form.
-  task.
+- once resolved it's idempotent: later calls return the same
-- lifetime mode also determines process ownership: ``an=`` spawns and
+  cached value.
-  reaps a fresh child in an existing actor nursery, while passing
+- a *daemon* portal (from ``start_actor()``) has no main task,
-  neither does the same in a private call-scoped nursery (booting
+  so there's no final result to wait for: you'll get a warning
-  the runtime if needed). ``portal=`` instead runs one linked task
+  plus a ``NoResult`` sentinel. Results of individual daemon
-  in an existing actor; it neither spawns nor reaps that actor, so
+  calls come straight back from each ``await portal.run()``.
-  the portal's owner remains responsible for its lifetime.
-- concurrency composes the plain ``trio`` way: schedule
-  multiple ``run()`` calls into a local task nursery (see
-  ``examples/parallelism/concurrent_toactor_primes.py``).
-
-A reused actor must expose both the target module and the
-``to_actor`` context trampoline:
-
-.. code:: python
-
-    async with tractor.open_nursery() as an:
-        portal = await an.start_actor(
-            'worker',
-            enable_modules=[
-                __name__,
-                tractor.to_actor.MODULE,
-            ],
-        )
-        try:
-            final = await tractor.to_actor.run(
-                partial(fib, n=10),
-                portal=portal,
-            )
-        finally:
-            await portal.cancel_actor()
 
 Pure RPC daemons: ``run_daemon()``
 ----------------------------------
@@ -175,8 +147,7 @@ call tears down the entire sub-tree — SC, transitively.
 
 When to graduate to ``Context``
 -------------------------------
-The :meth:`~tractor.Portal.run` method is great for one-shot,
+``portal.run()`` is great for one-shot, request-response calls.
-request-response calls.
 Reach for :meth:`~tractor.Portal.open_context` with an
 ``@tractor.context`` endpoint as soon as you want:
 
@@ -189,15 +160,10 @@ Reach for :meth:`~tractor.Portal.open_context` with an
   :meth:`~tractor.Portal.cancel_actor` nukes the **entire**
   remote runtime and its process.
 
-:func:`tractor.to_actor.run` already enters the full
+In fact the source plans for ``Portal.run()`` itself to be
-:meth:`~tractor.Portal.open_context` lifecycle. The older
+rebuilt on top of ``open_context()`` — contexts *are* the core
-:meth:`~tractor.Portal.run` path instead uses the ``Context`` returned
+inter-actor protocol. Take the full tour in
-by the lower-level ``Actor.start_remote_task()`` directly, avoiding a
+:doc:`/guide/context`.
-``Started`` handshake but owning less lifecycle machinery. A follow-up
-should factor their shared linked-task lifecycle without requiring
-``Portal.run()`` to delegate through the public context API or add
-another wire message. Take the full tour in
-:doc:`the context guide </guide/context>`.
 
 .. seealso::
 

docs/guide/spawning.rst

@@ -91,34 +91,31 @@ somebody-ing:
 
 What's going on here?
 
-- :meth:`~tractor.ActorNursery.start_actor` forks off
+- ``start_actor('frank', enable_modules=[__name__])`` forks off
   a new process, boots a ``tractor`` runtime inside it, and
   allows it to serve functions from the current module (see the
   allowlist section below).
-- each :meth:`~tractor.Portal.run` call schedules a *new* task in
+- each ``await portal.run(...)`` schedules a *new* task in
   frank's task tree and waits on its result — the full RPC story
   lives in :doc:`/guide/rpc`.
 - frank has no main task to complete, so without the final
-  :meth:`~tractor.Portal.cancel_actor` call the nursery block would
+  ``await portal.cancel_actor()`` the nursery block would wait
-  wait on him **forever**. Daemon lifetimes are *yours* to end;
+  on him **forever**. Daemon lifetimes are *yours* to end; that
-  that explicitness is the point.
+  explicitness is the point.
 
-``to_actor.run()``: quick one-shot parallelism
+``run_in_actor()``: quick one-shot parallelism
 ----------------------------------------------
-Without ``portal=``, :func:`tractor.to_actor.run` is the convenience
+:meth:`~tractor.ActorNursery.run_in_actor` is the convenience
-wrapper: spawn an actor, run exactly one async function in it, block
+wrapper: spawn an actor, run exactly one async function in it,
-on the result, then reap the process — the distributed sibling of
+then reap the process as soon as the result arrives.
-``trio.to_thread.run_sync()``.
 
 .. code:: python
 
-    async with (
+    async with tractor.open_nursery() as an:
-        tractor.open_nursery() as an,
+        portal = await an.run_in_actor(burn_cpu)
-        trio.open_nursery() as tn,
-    ):
         # burn rubber in the parent too...
-        tn.start_soon(burn_cpu)
+        await burn_cpu()
-        total = await tractor.to_actor.run(burn_cpu, an=an)
+        total = await portal.wait_for_result()
 
 A few details worth knowing:
 
@@ -126,61 +123,43 @@ A few details worth knowing:
   ``name='something_cuter'``.
 - the function's module is auto-added to the child's
   ``enable_modules`` allowlist.
-- targets cross IPC as ``module:name`` references, so portable calls
+- extra ``**kwargs`` are forwarded to the function itself.
-  use module-global async functions or ``functools.partial`` objects
+- the child is *auto-cancelled* once its "main" result lands;
-  wrapping them. Nested functions, methods and callable objects do not
+  at nursery exit these run-once children are always reaped
-  provide that stable address.
+  first (causality_ is paramount!).
-- target arguments are positional; use ``functools.partial()``
-  to bind target keyword arguments. Keywords passed directly to
-  ``run()`` configure actor placement and spawning.
-- the call blocks until the result (or error) lands and the
-  child is *auto-cancelled* (reaped) right after — so remote
-  errors raise directly in your calling task (causality_ is
-  paramount!).
-- "placement" composes: ``an=`` spawns a call-owned child from an
-  existing actor nursery, while passing neither opens a private
-  call-scoped nursery. ``portal=`` instead reuses an existing actor:
-  the call scopes only its linked remote task, neither spawns nor
-  reaps the actor, and leaves its lifetime with the portal's owner.
-  That actor must expose both the target module and
-  ``tractor.to_actor.MODULE``.
 
 .. note::
 
-   :func:`tractor.to_actor.run` is a convenience, **not** the core
+   ``run_in_actor()`` is a convenience, **not** the core model.
-   model. For actor-owning placements it combines
+   The source literally marks it for an eventual rebuild as
-   :meth:`~tractor.ActorNursery.start_actor`, a linked
+   a thin "hilevel" wrapper on top of
-   :meth:`~tractor.Portal.open_context` call, and per-child
+   :meth:`~tractor.Portal.open_context` (the modern inter-actor
-   cancellation/reaping. With ``portal=`` it uses only the linked
+   task API). Teach your fingers to use it for quick
-   context call and leaves the existing actor's lifetime untouched.
+   fire-and-collect parallelism — think a per-function
-   Teach your fingers to use it for quick
+   trio-parallel_ style one-shot — and reach for
-   fire-and-collect parallelism — think a per-function trio-parallel_
+   ``start_actor()`` + ``open_context()`` for anything
-   style one-shot — and reach for
+   long-lived, stateful or streaming
-   :meth:`~tractor.ActorNursery.start_actor` plus
+   (:doc:`/guide/context`).
-   :meth:`~tractor.Portal.open_context` for anything long-lived,
-   stateful or streaming; see :doc:`/guide/context`.
 
 Actor lifetimes and teardown order
 ----------------------------------
-There are two actor-lifetime flavors:
+So we have two lifetime flavors:
 
-- **call-owned one-shot** (``to_actor.run()`` without ``portal=``):
+- **run-once** (``run_in_actor()``): lives exactly as long as
-  spawned for one task, then cancelled and joined before ``run()``
+  its single task; reaped the moment its result (or error)
-  returns its result or raises its error.
+  arrives.
-- **caller-owned daemon** (:meth:`~tractor.ActorNursery.start_actor`),
+- **daemon** (``start_actor()``): lives until *someone* cancels
-  including an actor later reused through
+  it — an explicit ``await portal.cancel_actor()``, a bulk
-  ``to_actor.run(..., portal=portal)``: lives until *someone*
+  ``await an.cancel()``, or the one-cancels-all strategy kicking
-  cancels it via an explicit
+  in on error.
-  :meth:`~tractor.Portal.cancel_actor`, a bulk
-  :meth:`~tractor.ActorNursery.cancel`, or the one-cancels-all
-  strategy kicking in on error.
 
 On a clean exit of the nursery block the teardown order is:
 
-1. call-owned actors do not survive their own ``to_actor.run()``
+1. the nursery waits on every run-once actor's final result;
-   calls; each is reaped before its call returns.
+   any errors from these are raised immediately so your code
-2. the nursery waits on caller-owned daemon actors
+   (acting as supervisor) gets first crack at handling them.
-   **indefinitely**. If you spawned one, you own its lifetime.
+2. then it waits on daemon actors — **indefinitely**. If you
+   spawned a daemon, you own its lifetime.
 
 When a child *is* cancelled, teardown is graceful-first per SC
 discipline: the runtime sends an IPC cancel request and gives

docs/start/quickstart.rst

@@ -43,21 +43,24 @@ Run it::
 What's going on here?
 
 - ``trio.run(main)`` starts the **root actor**; the ``tractor``
-  runtime boots *implicitly* inside this ``tractor.to_actor.run()``
+  runtime boots *implicitly* inside ``tractor.open_nursery()``
-  call because neither ``an=`` nor ``portal=`` was supplied. No
+  whenever it isn't already up. No special entrypoint, no
-  special entrypoint, no framework takeover - it's just a ``trio``
+  framework takeover - it's just a ``trio`` app,
-  app,
 - inside ``main()`` a *subactor* is spawned via
-  ``tractor.to_actor.run()`` and told to run exactly one
+  ``ActorNursery.run_in_actor()`` and told to run exactly one
   function: ``cellar_door()``,
+- you get back a ``Portal``: your handle for invoking tasks in
+  the new process's (separate!) memory domain. We lean on it
+  much harder in the next section,
 - the subactor, *some_linguist*, boots a fresh ``trio.run()`` in
-  a **new process** and executes ``cellar_door()`` as its linked
+  a **new process** and executes ``cellar_door()`` as its *main
-  one-shot task (note the child proving it is *not* the root with
+  task* (note the child proving it is *not* the root with
   ``tractor.is_root_process()``), then ships the return value
   back over IPC,
-- the call *blocks* until that final result arrives, then
+- the parent grabs that *final result* with
-  returns it - causality is preserved: your task only proceeds
+  ``await portal.wait_for_result()``, much like you'd expect
-  once the child is *done*, dead, and reaped.
+  from a "future" - except causality is preserved: the nursery
+  block only exits once the child is *done*, dead, and reaped.
 
 .. margin:: Just need a worker pool?
 
@@ -68,20 +71,17 @@ What's going on here?
 
 .. note::
 
-   Without ``portal=``, ``to_actor.run()`` (parlance of
+   ``run_in_actor()`` is the *convenience* wrapper: one-shot
-   ``trio.to_thread`` and friends) is the *convenience* wrapper:
+   spawn-run-reap semantics for when a subactor's entire job is
-   one-shot spawn-run-reap semantics for when a subactor's entire
+   a single function call. The core primitives are
-   job is a single function call. The core primitives are
+   ``ActorNursery.start_actor()`` (next up) paired with
-   :meth:`~tractor.ActorNursery.start_actor` (next up) — which
+   ``Portal.open_context()`` for full, SC-linked cross-actor
-   hands you a ``Portal``, your handle for invoking tasks in the
+   dialogs - see :doc:`/guide/context`.
-   new process's (separate!) memory domain — paired with
-   :meth:`~tractor.Portal.open_context` for full, SC-linked
-   cross-actor dialogs; see :doc:`/guide/context`.
 
 Daemon actors and RPC
 ---------------------
-A subactor spawned by ``to_actor.run()`` terminates after its lone
+A ``run_in_actor()``-spawned actor terminates when its main task
-task returns. But often you want long-lived *daemon* actors instead:
+returns. But often you want long-lived *daemon* actors instead:
 spawned once, then serving (allowlisted) RPC requests until told
 otherwise. That's ``start_actor()``:
 
@@ -91,17 +91,14 @@ otherwise. That's ``start_actor()``:
 
 Two lifetime rules to internalize:
 
-- a subactor spawned and owned by ``to_actor.run()`` is cancelled
+- a ``run_in_actor()`` actor lives exactly as long as its main
-  and reaped before the call returns its result or raises its error,
+  task; the nursery waits for that function (and thus the
+  process) to complete before unblocking,
 - a ``start_actor()`` actor *lives forever* - an RPC daemon the
   nursery will happily wait on **indefinitely** - until some
   task explicitly cancels it via ``Portal.cancel_actor()`` (as
   above), or its parent nursery is cancelled wholesale.
 
-Passing ``portal=`` is different: the call owns only the linked
-remote task. It neither spawns nor reaps the existing actor; the
-portal's owner must end that actor's lifetime.
-
 .. tip::
 
    Want your *entire program* to just be a long-lived RPC
@@ -211,20 +208,16 @@ The script of the scene (runtime ``INFO`` log lines trimmed)::
 
 The new tricks in play:
 
-- *donny* and *gretchen* start as daemon actors so each remains alive
+- two subactors, *donny* and *gretchen*, are each told to run
-  while the other discovers it and completes its line,
+  ``say_hello()`` targeting the *other* by name,
-- a local ``trio`` nursery runs both ``Portal.run(say_hello)`` calls
-  concurrently; starting both actors first avoids either reciprocal
-  dialog racing one-shot process reaping,
 - ``tractor.wait_for_actor()`` blocks until the named peer has
   registered with the tree's *registrar* (every actor announces
   itself at boot), then yields a ``Portal`` connected
   **directly** to that peer,
 - each actor invokes its partner's ``hi()`` over that portal:
-  actor-to-actor RPC with the root merely *directing* - and each
+  actor-to-actor RPC with the root merely *directing* - and both
-  ``Portal.run()`` returns its final line directly to ``main()``,
+  final lines flow back to ``main()`` via
-- the actor nursery explicitly cancels both daemons only after both
+  ``await portal.wait_for_result()``,
-  dialogs complete,
 - ``tractor.log.get_console_log("INFO")`` cranks up runtime
   logging so you can watch the spawn/register/cancel machinery
   narrate itself; remove it for a quiet set.

examples/a_trynamic_first_scene.py

@@ -21,38 +21,22 @@ async def main():
     """Main tractor entry point, the "master" process (for now
     acts as the "director").
     """
-    async with tractor.open_nursery() as an:
+    async with tractor.open_nursery() as n:
         print("Alright... Action!")
 
-        # both actors wait on (then dial!) the *other*, so each
+        donny = await n.run_in_actor(
-        # must outlive both hellos: spawn as daemons, run the
-        # hellos concurrently, reap only once both complete.
-        portals: dict[str, tractor.Portal] = {
-            name: await an.start_actor(
-                name,
-                enable_modules=[__name__],
-            )
-            for name in ('donny', 'gretchen')
-        }
-
-        async def run_and_print(
-            name: str,
-            other_actor: str,
-        ) -> None:
-            print(
-                # RPC through an existing actor's `Portal`.
-                await portals[name].run(
             say_hello,
-                    other_actor=other_actor,
+            name='donny',
+            # arguments are always named
+            other_actor='gretchen',
         )
+        gretchen = await n.run_in_actor(
+            say_hello,
+            name='gretchen',
+            other_actor='donny',
         )
-
+        print(await gretchen.wait_for_result())
-        async with trio.open_nursery() as tn:
+        print(await donny.wait_for_result())
-            tn.start_soon(run_and_print, 'donny', 'gretchen')
-            tn.start_soon(run_and_print, 'gretchen', 'donny')
-
-        await an.cancel()
-
         print("CUTTTT CUUTT CUT!!! Donny!! You're supposed to say...")
 
 

examples/actor_spawning_and_causality.py

@@ -10,14 +10,17 @@ async def cellar_door():
 async def main():
     """The main ``tractor`` routine.
     """
-    # spawn a subactor, run ``cellar_door()`` as its lone task,
+    async with tractor.open_nursery() as n:
-    # block until its result arrives and the subactor is reaped.
+
-    print(
+        portal = await n.run_in_actor(
-        await tractor.to_actor.run(
             cellar_door,
             name='some_linguist',
         )
-    )
+
+    # The ``async with`` will unblock here since the 'some_linguist'
+    # actor has completed its main task ``cellar_door``.
+
+    print(await portal.wait_for_result())
 
 
 if __name__ == '__main__':

examples/debugging/multi_nested_subactors_error_up_through_nurseries.py

@@ -1,5 +1,3 @@
-from functools import partial
-
 import trio
 import tractor
 
@@ -23,41 +21,26 @@ async def breakpoint_forever():
 async def spawn_until(depth=0):
     """"A nested nursery that triggers another ``NameError``.
     """
-    async with (
+    async with tractor.open_nursery() as n:
-        tractor.open_nursery() as an,
-        trio.open_nursery() as tn,
-    ):
         if depth < 1:
 
-            tn.start_soon(
+            await n.run_in_actor(breakpoint_forever)
-                partial(
-                    tractor.to_actor.run,
-                    breakpoint_forever,
-                    an=an,
-                )
-            )
 
-            # Let the background one-shot enter `breakpoint_forever()`
+            p = await n.run_in_actor(
-            # before its sibling raises and cancellation propagates.
+                name_error,
+                name='name_error'
+            )
             await trio.sleep(0.5)
             # rx and propagate error from child
-            await tractor.to_actor.run(
+            await p.result()
-                name_error,
-                an=an,
-                name='name_error',
-            )
 
         else:
             # recusrive call to spawn another process branching layer of
-            # the tree; blocks (up) each level until the leaf's
+            # the tree
-            # `name_error` relays through.
             depth -= 1
-            await tractor.to_actor.run(
+            await n.run_in_actor(
-                partial(
                 spawn_until,
                 depth=depth,
-                ),
-                an=an,
                 name=f'spawn_until_{depth}',
             )
 
@@ -82,37 +65,34 @@ async def main():
              └─ python -m tractor._child --uid ('spawn_until_0', 'de918e6d ...)
 
     """
-    async with (
+    async with tractor.open_nursery(
-        tractor.open_nursery(
         debug_mode=True,
         loglevel='pdb',
-        ) as an,
+    ) as n:
-        trio.open_nursery() as tn,
+
-    ):
+        # spawn both actors
-        # spawn both spawner trees as concurrent one-shots; the
+        portal = await n.run_in_actor(
-        # first tree's (relayed) error cancels the other.
-        tn.start_soon(
-            partial(
-                tractor.to_actor.run,
-                partial(
             spawn_until,
             depth=3,
-                ),
-                an=an,
             name='spawner0',
         )
-        )
+        portal1 = await n.run_in_actor(
-        tn.start_soon(
-            partial(
-                tractor.to_actor.run,
-                partial(
             spawn_until,
             depth=4,
-                ),
-                an=an,
             name='spawner1',
         )
-        )
+
+        # TODO: test this case as well where the parent don't see
+        # the sub-actor errors by default and instead expect a user
+        # ctrl-c to kill the root.
+        with trio.move_on_after(3):
+            await trio.sleep_forever()
+
+        # gah still an issue here.
+        await portal.result()
+
+        # should never get here
+        await portal1.result()
 
 
 if __name__ == '__main__':

examples/debugging/multi_subactor_root_errors.py

@@ -15,12 +15,12 @@ async def name_error():
 async def spawn_error():
     """"A nested nursery that triggers another ``NameError``.
     """
-    async with tractor.open_nursery() as an:
+    async with tractor.open_nursery() as n:
-        return await tractor.to_actor.run(
+        portal = await n.run_in_actor(
             name_error,
-            an=an,
             name='name_error_1',
             )
+        return await portal.result()
 
 
 async def main():
@@ -38,36 +38,29 @@ async def main():
         - root actor should then fail on assert
         - program termination
     """
-    async with (
+    async with tractor.open_nursery(
-        tractor.open_nursery(
         debug_mode=True,
         loglevel='devx',
-        ) as an,
+    ) as n:
-        trio.open_nursery() as tn,
-    ):
-        # spawn both actors..
-        portal = await an.start_actor(
-            'name_error',
-            enable_modules=[__name__],
-        )
-        portal1 = await an.start_actor(
-            'spawn_error',
-            enable_modules=[__name__],
-        )
 
-        # ..and bg-schedule their erroring tasks.
+        # spawn both actors
-        tn.start_soon(portal.run, name_error)
+        portal = await n.run_in_actor(
-        tn.start_soon(portal1.run, spawn_error)
+            name_error,
-
+            name='name_error',
-        # yield to the bg tasks so both RPC requests are
+        )
-        # submitted (and start crashing) before the root's own
+        portal1 = await n.run_in_actor(
-        # error below (the legacy `run_in_actor()` submitted
+            spawn_error,
-        # in-line with each spawn).
+            name='spawn_error',
-        await trio.sleep(0.5)
+        )
 
         # trigger a root actor error
         assert 0
 
+        # attempt to collect results (which raises error in parent)
+        # still has some issues where the parent seems to get stuck
+        await portal.result()
+        await portal1.result()
+
 
 if __name__ == '__main__':
     trio.run(main)

examples/debugging/multi_subactors.py

@@ -17,12 +17,12 @@ async def name_error():
 async def spawn_error():
     """"A nested nursery that triggers another ``NameError``.
     """
-    async with tractor.open_nursery() as an:
+    async with tractor.open_nursery() as n:
-        return await tractor.to_actor.run(
+        portal = await n.run_in_actor(
             name_error,
-            an=an,
             name='name_error_1',
         )
+        return await portal.result()
 
 
 async def main():
@@ -36,39 +36,17 @@ async def main():
     `-python -m tractor._child --uid ('spawn_error', '52ee14a5 ...)
        `-python -m tractor._child --uid ('name_error', '3391222c ...)
     """
-    errors: list[BaseException] = []
-
     async with tractor.open_nursery(
         debug_mode=True,
         # loglevel='runtime',
-    ) as an:
+    ) as n:
 
-        async def run_and_collect(fn):
+        # Spawn both actors, don't bother with collecting results
-            '''
+        # (would result in a different debugger outcome due to parent's
-            One-shot whose (boxed) error is stashed instead of
+        # cancellation).
-            raised so a sibling's crash never cancels the others
+        await n.run_in_actor(breakpoint_forever)
-            before they've had their own debugger sessions (the
+        await n.run_in_actor(name_error)
-            "collect all errors" the legacy `run_in_actor()` API
+        await n.run_in_actor(spawn_error)
-            did implicitly at nursery teardown).
-
-            '''
-            try:
-                await tractor.to_actor.run(fn, an=an)
-            except tractor.RemoteActorError as rae:
-                errors.append(rae)
-
-        # Spawn all one-shot task actors, collecting (vs.
-        # raising) their errors.
-        async with trio.open_nursery() as tn:
-            tn.start_soon(run_and_collect, breakpoint_forever)
-            tn.start_soon(run_and_collect, name_error)
-            tn.start_soon(run_and_collect, spawn_error)
-
-        if errors:
-            raise BaseExceptionGroup(
-                'multi_subactors errored!',
-                errors,
-            )
 
 
 if __name__ == '__main__':

examples/debugging/root_cancelled_but_child_is_in_tty_lock.py

@@ -1,5 +1,3 @@
-from functools import partial
-
 import trio
 import tractor
 
@@ -12,17 +10,15 @@ async def name_error():
 async def spawn_until(depth=0):
     """"A nested nursery that triggers another ``NameError``.
     """
-    async with tractor.open_nursery() as an:
+    async with tractor.open_nursery() as n:
         if depth < 1:
-            await tractor.to_actor.run(name_error, an=an)
+            # await n.run_in_actor('breakpoint_forever', breakpoint_forever)
+            await n.run_in_actor(name_error)
         else:
             depth -= 1
-            await tractor.to_actor.run(
+            await n.run_in_actor(
-                partial(
                 spawn_until,
                 depth=depth,
-                ),
-                an=an,
                 name=f'spawn_until_{depth}',
             )
 
@@ -41,37 +37,28 @@ async def main():
        └─ python -m tractor._child --uid ('name_error', '6c2733b8 ...)
 
     '''
-    async with (
+    async with tractor.open_nursery(
-        tractor.open_nursery(
         debug_mode=True,
-            enable_transports=['uds'],  # TODO, pass this via osenv?
+        enable_transports=['uds'],  # TODO, apss this via osenv?
         loglevel='devx',  # XXX, required for test!
-        ) as an,
+    ) as n:
-        trio.open_nursery() as tn,
-    ):
-        # spawn the deeper tree in the bg..
-        tn.start_soon(
-            partial(
-                tractor.to_actor.run,
-                partial(
-                    spawn_until,
-                    depth=1,
-                ),
-                an=an,
-                name='spawner1',
-            )
-        )
 
-        # ..while blocking on the shallow (faster to fail) tree
+        # spawn both actors
-        # whose propagated error triggers nursery cancellation.
+        portal = await n.run_in_actor(
-        await tractor.to_actor.run(
-            partial(
             spawn_until,
             depth=0,
-            ),
-            an=an,
             name='spawner0',
         )
+        portal1 = await n.run_in_actor(
+            spawn_until,
+            depth=1,
+            name='spawner1',
+        )
+
+        # nursery cancellation should be triggered due to propagated
+        # error from child.
+        await portal.result()
+        await portal1.result()
 
 
 if __name__ == '__main__':

examples/debugging/root_timeout_while_child_crashed.py

@@ -13,24 +13,17 @@ async def main():
     simultaneously.
 
     '''
-    async with (
+    async with tractor.open_nursery(
-        tractor.open_nursery(
         debug_mode=True,
         # loglevel='debug'  # ?XXX required?
-        ) as an,
+    ) as n:
-        trio.open_nursery() as tn,
+
-    ):
+        # spawn both actors
-        # spawn the actor..
+        portal = await n.run_in_actor(key_error)
-        portal = await an.start_actor(
-            'key_error',
-            enable_modules=[__name__],
-        )
         print(
             f'Child is up @ {portal.chan.aid.reprol()}'
         )
-        # ..then schedule its erroring task in the bg while the
+
-        # root blocks below.
-        tn.start_soon(portal.run, key_error)
 
         # XXX: originally a bug caused by this is where root would enter
         # the debugger and clobber the tty used by the repl even though

examples/debugging/shielded_pause.py

@@ -74,11 +74,11 @@ async def cancelled_before_pause(
 async def main():
     async with tractor.open_nursery(
         debug_mode=True,
-    ) as an:
+    ) as n:
-        await tractor.to_actor.run(
+        portal: tractor.Portal = await n.run_in_actor(
             cancelled_before_pause,
-            an=an,
         )
+        await portal.wait_for_result()
 
         # ensure the same works in the root actor!
         await pm_on_cancelled()

examples/debugging/subactor_breakpoint.py

@@ -17,14 +17,12 @@ async def main():
     async with tractor.open_nursery(
         debug_mode=True,
         loglevel='cancel',
-    ) as an:
+    ) as n:
 
-        # parks awaiting a result which only arrives once the
+        portal = await n.run_in_actor(
-        # user quits (`BdbQuit`s) the child's REPL loop.
-        await tractor.to_actor.run(
             breakpoint_forever,
-            an=an,
         )
+        await portal.wait_for_result()
 
 
 if __name__ == '__main__':

examples/debugging/subactor_error.py

@@ -12,12 +12,16 @@ async def main():
     ) as an:
 
         # TODO: ideally the REPL arrives at this frame in the parent,
-        # ABOVE the @api_frame of `to_actor.run()` ..
+        # ABOVE the @api_frame of `Portal.run_in_actor()` (which
+        # should eventually not even be a portal method ... XD)
         # await tractor.pause()
+        p: tractor.Portal = await an.run_in_actor(name_error)
 
-        # the one-shot blocks on the subactor's result so the
+        # with this style, should raise on this line
-        # boxed `NameError` raises right here.
+        await p.wait_for_result()
-        await tractor.to_actor.run(name_error, an=an)
+
+        # with this alt style should raise at `open_nusery()`
+        # return await p.wait_for_result()
 
 
 if __name__ == '__main__':

examples/debugging/sync_bp.py

@@ -90,7 +90,7 @@ async def main() -> None:
 
         # TODO: 3 sub-actor usage cases:
         # -[x] via a `.open_context()`
-        # -[ ] via a `to_actor.run()` call
+        # -[ ] via a `.run_in_actor()` call
         # -[ ] via a `.run()`
         # -[ ] via a `.to_thread.run_sync()` in subactor
         async with p.open_context(

examples/parallelism/concurrent_toactor_primes.py

@@ -1,83 +0,0 @@
-'''
-`tractor.to_actor.run()`: concurrent one-shot prime checks
-invocation, the SC-parallelism sibling of
-`trio.to_thread.run_sync()` (and `anyio.to_process`).
-
-Each call spawns a subactor, schedules the async fn as
-its lone remote task, waits on the result and reaps the
-subactor. Concurrency composes the plain `trio` way:
-schedule multiple one-shot calls in a local task nursery
-against a shared actor-nursery; any remote error raises
-directly in the task which scheduled it.
-
-'''
-import math
-
-import tractor
-import trio
-
-
-async def is_prime(
-    n: int,
-) -> bool:
-    if n < 2:
-        return False
-    if n == 2:
-        return True
-    if n % 2 == 0:
-        return False
-
-    sqrt_n = int(math.floor(math.sqrt(n)))
-    for i in range(3, sqrt_n + 1, 2):
-        if n % i == 0:
-            return False
-    return True
-
-
-async def main() -> None:
-
-    # fully implicit one-shot: boots the actor-runtime,
-    # spawns a subactor, runs the task, reaps the
-    # subactor, tears the runtime back down.
-    assert await tractor.to_actor.run(
-        is_prime,
-        2,
-    )
-
-    # the "worker-pool-ish" pattern from the original
-    # `concurrent.futures` example: one subactor per
-    # input, all concurrent, results and errors
-    # collected by caller-side tasks.
-    results: dict[int, bool] = {}
-
-    async def check(
-        an: tractor.ActorNursery,
-        n: int,
-        i: int,
-    ) -> None:
-        results[n] = await tractor.to_actor.run(
-            is_prime,
-            n,
-            an=an,
-            name=f'prime_checker_{i}',
-        )
-
-    inputs: list[int] = [
-        7,
-        8,
-        3691,
-        3693,
-    ]
-    async with (
-        tractor.open_nursery() as an,
-        trio.open_nursery() as tn,
-    ):
-        for i, n in enumerate(inputs):
-            tn.start_soon(check, an, n, i)
-
-    for n, prime in sorted(results.items()):
-        print(f'{n} is prime: {prime}')
-
-
-if __name__ == '__main__':
-    trio.run(main)

examples/parallelism/single_func.py

@@ -20,20 +20,22 @@ async def burn_cpu():
     for _ in range(50000):
         await trio.sleep(1/50000/50)
 
-    return pid
+    return os.getpid()
 
 
 async def main():
 
-    async with trio.open_nursery() as tn:
+    async with tractor.open_nursery() as n:
+
+        portal = await n.run_in_actor(burn_cpu)
 
         #  burn rubber in the parent too
-        tn.start_soon(burn_cpu)
+        await burn_cpu()
 
-        # run the same func as the lone task in a subactor,
+        # wait on result from target function
-        # block on and collect its PID as the caller-side result
+        pid = await portal.wait_for_result()
-        pid = await tractor.to_actor.run(burn_cpu)
 
+    # end of nursery block
     print(f"Collected subproc {pid}")
 
 

examples/remote_error_propagation.py

@@ -7,20 +7,19 @@ async def assert_err():
 
 
 async def main():
-    async with tractor.open_nursery() as an:
+    async with tractor.open_nursery() as n:
         real_actors = []
         for i in range(3):
-            real_actors.append(await an.start_actor(
+            real_actors.append(await n.start_actor(
                 f'actor_{i}',
                 enable_modules=[__name__],
             ))
 
-        # run one one-shot task actor that will fail immediately;
+        # start one actor that will fail immediately
-        # its error raises right here in the caller's task..
+        await n.run_in_actor(assert_err)
-        await tractor.to_actor.run(assert_err, an=an)
 
-    # ..as a ``RemoteActorError`` containing an ``AssertionError``
+    # should error here with a ``RemoteActorError`` containing
-    # and all the other actors have been cancelled
+    # an ``AssertionError`` and all the other actors have been cancelled
 
 
 if __name__ == '__main__':

nooz/477.feature.rst

@@ -1,3 +0,0 @@
-Add ``tractor.to_actor.run()`` for Trio-style one-shot async calls in
-new or existing actors, with caller-scoped result/error propagation,
-linked cancellation, and deterministic reaping of call-owned children.

tests/_helpers.py

@@ -1,53 +0,0 @@
-'''
-Shared helpers for actor-runtime test suites.
-
-'''
-from pathlib import Path
-from types import TracebackType
-
-import tractor
-import trio
-
-
-class CancellationMarkers:
-    '''
-    Mark a test endpoint and require cancellation-driven teardown.
-
-    '''
-    def __init__(
-        self,
-        started_path: str,
-        cancelled_path: str,
-    ) -> None:
-        self.started_path = started_path
-        self.cancelled_path = cancelled_path
-
-    def __enter__(self) -> None:
-        Path(self.started_path).touch()
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException]|None,
-        exc_value: BaseException|None,
-        traceback: TracebackType|None,
-    ) -> None:
-        assert exc_type is trio.Cancelled
-        assert isinstance(exc_value, trio.Cancelled)
-        Path(self.cancelled_path).touch()
-
-
-def non_registration_contexts(
-    actor: tractor.Actor,
-) -> dict[tuple, str]:
-    '''
-    Snapshot application contexts without registrar-service traffic.
-
-    '''
-    return {
-        key: str(ctx._nsf)
-        for key, ctx in actor._contexts.items()
-        if str(ctx._nsf) != (
-            'tractor.discovery._registry:'
-            'Registrar.register_actor'
-        )
-    }

tests/devx/test_debugger.py

@@ -27,7 +27,6 @@ from pexpect.exceptions import (
 import tractor
 
 from .conftest import (
-    ansi_strip,
     do_ctlc,
     PROMPT,
     _pause_msg,
@@ -769,15 +768,6 @@ def test_multi_subactors_root_errors(
 
 
 @has_nested_actors
-@pytest.mark.skipif(
-    platform.system() == 'Darwin'
-    and
-    bool(_ci_env),
-    reason=(
-        'Nested crash-REPL ordering is unreliable on macOS CI; '
-        'see https://github.com/goodboy/tractor/issues/320'
-    ),
-)
 def test_multi_nested_subactors_error_through_nurseries(
     ci_env: bool,
     spawn: PexpectSpawner,
@@ -804,7 +794,6 @@ def test_multi_nested_subactors_error_through_nurseries(
         loglevel='pdb',
     )
     last_send_char: str|None = None
-    transcript_parts: list[str] = []
 
     # inflate pexpect waits under CPU throttle — incl. the
     # sustained-load power-cap invisible to static freq reads — so
@@ -844,9 +833,6 @@ def test_multi_nested_subactors_error_through_nurseries(
                 PROMPT,
                 timeout=timeout,
             )
-            transcript_parts.append(
-                ansi_strip(child.before.decode())
-            )
             delay: float = 0.1
             test_log.info('Sleeping {delay!r} before next send-chart..')
             time.sleep(delay)
@@ -856,9 +842,6 @@ def test_multi_nested_subactors_error_through_nurseries(
 
         # script finally exited with tb on console.
         except EOF:
-            transcript_parts.append(
-                ansi_strip(child.before.decode())
-            )
             test_log.info(
                 f'Breaking from send-char loop'
                 f'last_send_char: {last_send_char!r}\n'
@@ -892,33 +875,24 @@ def test_multi_nested_subactors_error_through_nurseries(
     # happening but ONLY WHEN RUN FROM THE TEST, bc when i try to
     # run the test script manually the correct output ALWAYS seems
     # to be in the last `str(child.before.decode())` output !?!?
-    transcript: str = '\n'.join(transcript_parts)
     if (
         not is_forking_spawner
         and
         last_send_char == 'q'
     ):
-        # Cancellation can swap which intermediary is rendered as
+        expect_patts += [
-        # the immediate source vs. relay. Require both actor levels
+            # expect the pdb-quit exc.
-        # below without pinning those racy roles.
+            "bdb.BdbQuit",
-        expect_patts.append('bdb.BdbQuit')
+            # BUT WHY these dude!?
-        for uid in (
+            "src_uid=('spawn_until_0'",
-            'spawn_until_0',
+            "relay_uid=('spawn_until_1'",
-            'spawn_until_1',
+        ]
-        ):
-            assert any(
-                role in transcript
-                for role in (
-                    f"src_uid=('{uid}'",
-                    f"relay_uid=('{uid}'",
-                )
-            )
 
-    for part in expect_patts:
+    assert_before(
-        assert part in transcript
+        child,
-
+        expect_patts,
-    assert child.flag_eof
+    )
-    assert not child.isalive()
+    expect(child, EOF)
 
 
 # @pytest.mark.timeout(15)
@@ -1309,8 +1283,13 @@ def test_ctxep_pauses_n_maybe_ipc_breaks(
             )
             child.sendline('c')
             child.expect(EOF)
-            assert child.flag_eof
+            assert_before(
-            assert not child.isalive()
+                child,
+                ["tractor._exceptions.RemoteActorError: remote task raised a 'BdbQuit'",
+                 "bdb.BdbQuit",
+                 "('bp_boi'",
+                ]
+            )
             break  # end-of-test
 
         child.sendline('c')
@@ -1359,10 +1338,10 @@ def test_ctxep_pauses_n_maybe_ipc_breaks(
                 expect_prompt=False,
             )
             child.expect(EOF)
-            before += ansi_strip(child.before.decode())
+            assert_before(
-            assert 'KeyboardInterrupt' in before
+                child,
-            assert child.flag_eof
+                ['KeyboardInterrupt'],
-            assert not child.isalive()
+            )
 
 
 def test_crash_handling_within_cancelled_root_actor(

tests/devx/test_tooling.py

@@ -191,8 +191,9 @@ def test_shield_pause(
     ]
     if not no_capfd:
         expect_on_teardown += [
-            'Cancel-ack TIMED OUT for sub-actor',
+            # 'Shutting down actor runtime',
-            '-> escalating to `proc.kill()` (hard-reap)',
+            '#T-800 deployed to collect zombie B0',
+            "'--uid', \"('hanger',",
         ]
     assert_before(
         child,

tests/discovery/test_multi_program.py

@@ -207,7 +207,7 @@ def test_dup_name_cancel_cascade_escalates_to_hard_kill(
 
     Post-fix, `Portal.cancel_actor()` raises `ActorTooSlowError` on
     the bounded-wait timeout, and `ActorNursery.cancel()`'s
-    per-child wrapper escalates directly to `proc.kill()` (hard-reap).
+    per-child wrapper escalates to `proc.terminate()` (hard-kill).
     The full nursery teardown therefore stays bounded even under
     pathological timing.
 
@@ -266,7 +266,7 @@ def test_dup_name_cancel_cascade_escalates_to_hard_kill(
 
         # post-teardown sanity: every child proc must be reaped.
         # If escalation worked, even timed-out cancel-RPCs would
-        # have triggered `proc.kill()` and the procs are dead.
+        # have triggered `proc.terminate()` and the procs are dead.
         for p in portals:
             # `Portal.channel.connected()` -> False once the
             # underlying chan disconnected (clean exit OR

tests/ipc/test_each_tpt.py

@@ -7,7 +7,6 @@ import os
 from pathlib import Path
 import socket
 import stat
-import struct
 import sys
 import tempfile
 from types import SimpleNamespace
@@ -15,275 +14,12 @@ from unittest.mock import Mock
 
 import pytest
 import trio
-from trio.testing import (
-    MockClock,
-    wait_all_tasks_blocked,
-)
 import tractor
 from tractor import Actor
 from tractor.discovery import _addr
-from tractor.ipc._transport import MsgpackTransport
 from tractor.runtime import _state
 
 
-
-def test_cancelled_transport_send_completes_frame():
-    '''
-    Finish an in-flight frame before delivering sender cancellation.
-
-    A cancelled `send_all()` may leave an arbitrary frame prefix on the
-    wire. Closing the actor-wide stream avoids decoder corruption but
-    also destroys unrelated contexts using that channel. On its first
-    call, the fake stream publishes two header bytes and blocks until
-    the parent test releases it. This lets the parent cancel the sender
-    while frame publication is suspended. The sender must remain inside
-    `send_first()` until the complete frame is written, then observe
-    pending cancellation; a second sender proves sibling contexts can
-    safely reuse the still frame-aligned stream.
-
-    '''
-    class PartialSendStream:
-        def __init__(self) -> None:
-            self.send_all_entered = trio.Event()
-            self.send_all_release = trio.Event()
-            self.closed = False
-            self.wire = bytearray()
-
-        async def send_all(
-            self,
-            data: bytes,
-        ) -> None:
-            assert data
-            if not self.wire:
-                self.wire.extend(data[:2])
-                self.send_all_entered.set()
-                await self.send_all_release.wait()
-                self.wire.extend(data[2:])
-            else:
-                self.wire.extend(data)
-
-        async def aclose(self) -> None:
-            self.closed = True
-
-    def count_frames(wire: bytearray) -> int:
-        offset: int = 0
-        count: int = 0
-        while offset < len(wire):
-            header_end: int = offset + 4
-            assert header_end <= len(wire)
-            size, = struct.unpack('<I', wire[offset:header_end])
-            offset = header_end + size
-            assert offset <= len(wire)
-            count += 1
-
-        assert offset == len(wire)
-        return count
-
-    async def main() -> None:
-        stream = PartialSendStream()
-        transport = object.__new__(MsgpackTransport)
-        transport.stream = stream
-        transport._send_lock = trio.StrictFIFOLock()
-        sender_done = trio.Event()
-        sender_scopes: list[trio.CancelScope] = []
-        cancelled_caught: bool = False
-
-        first_msg = tractor.msg.Start(
-            ns=__name__,
-            func='add_one',
-            kwargs={'n': 1},
-            uid=('root', 'test'),
-            cid='partial-send',
-        )
-        second_msg = tractor.msg.Start(
-            ns=__name__,
-            func='add_one',
-            kwargs={'n': 2},
-            uid=('root', 'test'),
-            cid='second-send',
-        )
-
-        async def send_first() -> None:
-            nonlocal cancelled_caught
-            with trio.CancelScope() as cs:
-                sender_scopes.append(cs)
-                await transport.send(first_msg)
-
-            cancelled_caught = cs.cancelled_caught
-            sender_done.set()
-
-        async with trio.open_nursery() as tn:
-            tn.start_soon(
-                send_first,
-            )
-            await stream.send_all_entered.wait()
-            sender_scopes[0].cancel()
-            await wait_all_tasks_blocked()
-
-            assert not stream.closed
-            # Cancellation is pending, but complete-frame shielding
-            # keeps `send_first()` suspended in `.send_all()`.
-            assert not sender_done.is_set()
-
-            # Let the underlying frame write finish after the parent
-            # has requested sender cancellation.
-            stream.send_all_release.set()
-            await sender_done.wait()
-
-            assert cancelled_caught
-            assert not stream.closed
-            # The initial two-byte prefix was completed into one valid
-            # frame before cancellation reached `send_first()`.
-            assert count_frames(stream.wire) == 1
-
-            await transport.send(second_msg)
-            # A sibling sender can append and decode another frame only
-            # because the first cancellation preserved stream alignment.
-            assert count_frames(stream.wire) == 2
-
-            tn.cancel_scope.cancel()
-
-    trio.run(main)
-
-
-def test_transport_send_deadline_closes_partial_frame():
-    '''
-    Destroy a stalled partial frame before another sender can append.
-
-    Ordinary cancellation cannot interrupt complete-frame publication.
-    Bounded actor/context cancellation instead passes its absolute
-    deadline into this operation. The fake stream writes a partial
-    header and stalls; when the send's own deadline fires, the transport
-    must close the stream before releasing its shared send lock. This
-    prevents the next sender from appending bytes which a decoder would
-    treat as the remainder of the corrupt first frame.
-
-    '''
-    class StalledStream:
-        def __init__(self) -> None:
-            self.closed = False
-            self.wire = bytearray()
-
-        async def send_all(
-            self,
-            data: bytes,
-        ) -> None:
-            self.wire.extend(data[:2])
-            await trio.sleep_forever()
-
-        async def aclose(self) -> None:
-            self.closed = True
-
-    async def main() -> None:
-        stream = StalledStream()
-        transport = object.__new__(MsgpackTransport)
-        transport.stream = stream
-        transport._send_lock = trio.StrictFIFOLock()
-        msg = tractor.msg.Start(
-            ns=__name__,
-            func='add_one',
-            kwargs={'n': 1},
-            uid=('root', 'test'),
-            cid='deadline-send',
-        )
-
-        with pytest.raises(
-            tractor.TransportClosed,
-            match='frame publication exceeded',
-        ):
-            await transport.send(
-                msg,
-                send_deadline=1,
-            )
-
-        assert stream.closed  # partial-frame timeout destroys stream
-        assert len(stream.wire) == 2  # only a header fragment was sent
-        assert not transport._send_lock.locked()  # cleanup released lock
-
-    trio.run(
-        main,
-        clock=MockClock(autojump_threshold=0),
-    )
-
-
-def test_cancelled_transport_send_preserves_cancellation():
-    '''
-    Prefer sender cancellation when teardown closes the stream.
-
-    `MsgpackTransport.send()` shields frame publication at
-    `tractor.ipc._transport:MsgpackTransport.send`. Before this fix, an
-    outer `move_on_after()`/cancel scope could cancel `Channel.send()`
-    while actor teardown closed the shared stream. The resulting
-    `ClosedResourceError` escaped from the transport handler instead of
-    its `checkpoint_if_cancelled()` redelivering pending cancellation.
-
-    The fake stream blocks inside the shield until the test cancels the
-    sender. Parent-controlled release then simulates actor teardown
-    closing the socket and raises the `ClosedResourceError` observed on
-    macOS UDS. `CancelScope.cancelled_caught` proves the handler's
-    checkpoint preserved cancellation as the primary outcome instead of
-    leaking that secondary close error.
-
-    '''
-    class ClosingStream:
-        def __init__(self) -> None:
-            self.send_all_entered = trio.Event()
-            self.send_all_release = trio.Event()
-
-        async def send_all(
-            self,
-            data: bytes,
-        ) -> None:
-            assert data
-            self.send_all_entered.set()
-            await self.send_all_release.wait()
-            # Model actor teardown closing the shared transport while
-            # this sender is still inside the complete-frame shield.
-            raise trio.ClosedResourceError(
-                'this socket was already closed'
-            )
-
-    async def main() -> None:
-        stream = ClosingStream()
-        transport = object.__new__(MsgpackTransport)
-        transport.stream = stream
-        transport._send_lock = trio.StrictFIFOLock()
-        sender_done = trio.Event()
-        sender_scopes: list[trio.CancelScope] = []
-        cancelled_caught: bool = False
-
-        msg = tractor.msg.Start(
-            ns=__name__,
-            func='add_one',
-            kwargs={'n': 1},
-            uid=('root', 'test'),
-            cid='close-during-cancelled-send',
-        )
-
-        async def send() -> None:
-            nonlocal cancelled_caught
-            with trio.CancelScope() as cs:
-                sender_scopes.append(cs)
-                await transport.send(msg)
-
-            cancelled_caught = cs.cancelled_caught
-            sender_done.set()
-
-        async with trio.open_nursery() as tn:
-            tn.start_soon(send)
-            await stream.send_all_entered.wait()
-            sender_scopes[0].cancel()
-            await wait_all_tasks_blocked()
-
-            assert not sender_done.is_set()
-            stream.send_all_release.set()
-            await sender_done.wait()
-
-        assert cancelled_caught
-
-    trio.run(main)
-
-
 @pytest.fixture
 def bindspace_dir_str() -> str:
 

tests/msg/test_namespace_path.py

@@ -1,43 +0,0 @@
-'''
-`NamespacePath` Python-object reference tests.
-
-'''
-import pytest
-
-from tractor.msg import ptr as msgptr
-from tractor.msg.ptr import NamespacePath
-
-
-def example_target() -> None:
-    '''
-    Provide a module-addressable reference for pointer tests.
-
-    '''
-
-
-def test_retains_target_ref(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    '''
-    Reuse a retained target ref when splitting its namespace path.
-
-    `NamespacePath.from_ref()` previously discarded `example_target`,
-    so `to_tuple()` imported and resolved the just-created string again.
-    Replacing `resolve_name()` with a failure proves the retained ref
-    supplies the tuple without a redundant lookup.
-
-    '''
-    target = NamespacePath.from_ref(example_target)
-
-    def fail_resolve(name: str) -> object:
-        raise AssertionError(f'unexpected lookup for {name!r}')
-
-    monkeypatch.setattr(
-        msgptr,
-        'resolve_name',
-        fail_resolve,
-    )
-    assert target.to_tuple() == (
-        example_target.__module__,
-        example_target.__name__,
-    )

tests/test_context_stream_semantics.py

@@ -7,18 +7,12 @@ sync-opening a ``tractor.Context`` beforehand.
 '''
 from itertools import count
 import math
-from pathlib import Path
 import platform
 from pprint import pformat
 import sys
-from types import SimpleNamespace
 from typing import (
     Callable,
 )
-from unittest.mock import (
-    AsyncMock,
-    Mock,
-)
 
 import pytest
 import trio
@@ -31,7 +25,6 @@ from tractor import (
 from tractor._exceptions import (
     StreamOverrun,
     ContextCancelled,
-    TransportClosed,
 )
 from tractor.runtime._state import current_ipc_ctx
 
@@ -40,11 +33,6 @@ from tractor._testing import (
     expect_ctxc,
 )
 
-from ._helpers import (
-    CancellationMarkers,
-    non_registration_contexts,
-)
-
 # ``Context`` semantics are as follows,
 #  ------------------------------------
 
@@ -84,112 +72,9 @@ from ._helpers import (
 #   with implicit stream closure on the cancelling end.
 
 
-def test_overrun_error_send_tolerates_transport_close(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    '''
-    Preserve a stream overrun when its error can not be shipped.
-
-    A full local stream buffer makes `Context._deliver_msg()` package
-    `StreamOverrun` for the remote sender. On Darwin, a concurrently
-    closing socket is wrapped as `TransportClosed`; allowing that
-    secondary error to escape replaces the primary overrun and crashes
-    the actor-wide RPC loop. This fake context forces that ordering and
-    proves failed error shipment reports non-delivery without raising.
-
-    '''
-    error_msg = tractor.msg.Error(
-        src_uid=('local', 'test'),
-        src_type_str='StreamOverrun',
-        boxed_type_str='StreamOverrun',
-        relay_path=[],
-        sender=('peer', 'test'),
-        cid='overrun',
-    )
-    packed: dict[str, object] = {}
-
-    # Spy on the generated `StreamOverrun` and return a stable wire
-    # `Error`; the real packer adds traceback/relay details unrelated to
-    # this test's secondary transport-close contract.
-    def pack_overrun(
-        local_err: BaseException,
-        cid: str,
-        **kwargs: object,
-    ) -> tractor.msg.Error:
-        packed['local_err'] = local_err
-        packed['cid'] = cid
-        packed['kwargs'] = kwargs
-        return error_msg
-
-    monkeypatch.setattr(
-        'tractor._context.pack_from_raise',
-        pack_overrun,
-    )
-
-    async def main() -> None:
-        send_chan = Mock()
-        send_chan.send_nowait.side_effect = trio.WouldBlock
-        chan = SimpleNamespace(
-            aid=SimpleNamespace(uid=('peer', 'test')),
-            send=AsyncMock(
-                side_effect=TransportClosed('peer closed'),
-            ),
-        )
-        local_aid = SimpleNamespace(
-            name='local',
-            reprol=lambda: 'local@test',
-        )
-        ctx = SimpleNamespace(
-            cid='overrun',
-            chan=chan,
-            _send_chan=send_chan,
-            _nsf='tests:overrun',
-            side='parent',
-            peer_side='child',
-            _portal=object(),
-            _task=None,
-            repr_api='Context',
-            repr_caller='test',
-            _in_overrun=False,
-            _actor=SimpleNamespace(aid=local_aid),
-            _stream_opened=True,
-            _allow_overruns=False,
-        )
-        msg = tractor.msg.Yield(
-            cid=ctx.cid,
-            pld='payload',
-        )
-
-        delivered: bool = await Context._deliver_msg(ctx, msg)
-
-        assert delivered is False
-        assert isinstance(packed['local_err'], StreamOverrun)
-        assert packed['cid'] == ctx.cid
-        chan.send.assert_awaited_once_with(error_msg)
-
-    trio.run(main)
-
 _state: bool = False
 
 
-@tractor.context
-async def startup_cancel_target(
-    ctx: Context,
-    started_path: str,
-    cancelled_path: str,
-) -> None:
-    with CancellationMarkers(
-        started_path,
-        cancelled_path,
-    ):
-        await ctx.started()
-        await trio.sleep_forever()
-
-
-async def return_one() -> int:
-    return 1
-
-
 @tractor.context
 async def too_many_starteds(
     ctx: Context,
@@ -278,184 +163,11 @@ async def simple_setup_teardown(
         _state = False
 
 
-async def assert_state(value: bool) -> None:
+async def assert_state(value: bool):
     global _state
     assert _state == value
 
 
-@tractor_test
-async def test_cancel_during_context_startup(
-    monkeypatch: pytest.MonkeyPatch,
-    tmp_path: Path,
-    start_method: str,
-    debug_mode: bool,
-) -> None:
-    '''
-    Cancel a context after sending `Start` but before its ack.
-
-    `Portal.open_context()` allocates its caller-side `Context` while
-    entering the async context manager. Cancellation used to strand
-    that local context and leave the remote target running. The patched
-    `Channel.send()` publishes `Start`, then blocks before
-    `Actor.start_remote_task()` can await `StartAck`. Cancelling the
-    caller proves cleanup issues one bounded, non-recursive cancel RPC,
-    stops the target and removes both helper contexts. A subsequent
-    RPC proves the caller-owned actor remains usable.
-
-    '''
-    started_path = tmp_path / 'startup_started'
-    cancelled_path = tmp_path / 'startup_cancelled'
-    start_sent = trio.Event()
-    start_funcs: list[str] = []
-    original_send = tractor.Channel.send
-
-    async def delay_after_start(
-        chan: tractor.Channel,
-        payload: object,
-        hide_tb: bool = False,
-        send_deadline: float = float('inf'),
-    ) -> None:
-        await original_send(
-            chan,
-            payload,
-            hide_tb=hide_tb,
-            send_deadline=send_deadline,
-        )
-        # The patched method keeps `Channel.send()`'s broad message
-        # contract. It sees both the requested endpoint `Start` and the
-        # internal `self._cancel_task` startup RPC used for cleanup.
-        if isinstance(payload, tractor.msg.Start):
-            start_funcs.append(payload.func)
-            if payload.func == 'startup_cancel_target':
-                start_sent.set()
-            await trio.sleep_forever()
-
-    async def open_target(
-        portal: tractor.Portal,
-    ) -> None:
-        async with portal.open_context(
-            startup_cancel_target,
-            started_path=str(started_path),
-            cancelled_path=str(cancelled_path),
-        ):
-            raise AssertionError('context startup should be cancelled')
-
-    async with tractor.open_nursery() as an:
-        actor: Actor = tractor.current_actor()
-        portal: tractor.Portal = await an.start_actor(
-            'startup_cancel_worker',
-            enable_modules=[__name__],
-        )
-        contexts_before = non_registration_contexts(actor)
-        monkeypatch.setattr(
-            tractor.Channel,
-            'send',
-            delay_after_start,
-        )
-
-        async with trio.open_nursery() as tn:
-            tn.start_soon(open_target, portal)
-            with trio.fail_after(5):
-                await start_sent.wait()
-                while not started_path.exists():
-                    await trio.sleep(0.01)
-            tn.cancel_scope.cancel()
-
-        monkeypatch.setattr(
-            tractor.Channel,
-            'send',
-            original_send,
-        )
-        assert cancelled_path.exists()
-        assert non_registration_contexts(actor) == contexts_before
-        assert await portal.run_from_ns(
-            __name__,
-            'return_one',
-        ) == 1
-        assert non_registration_contexts(actor) == contexts_before
-        assert start_funcs == [
-            'startup_cancel_target',
-            '_cancel_task',
-        ]
-        await portal.cancel_actor()
-
-
-@tractor_test
-async def test_start_serialization_error_cleans_context(
-    start_method: str,
-    debug_mode: bool,
-) -> None:
-    '''
-    Deallocate caller state when `Start` can not be serialized.
-
-    `Actor.start_remote_task()` registers its caller-side `Context`
-    before encoding the request. An unsupported argument used to raise
-    `MsgTypeError` before publication while leaking that registry
-    entry. Comparing the context registry around the failed start
-    proves cleanup, and a following valid context proves no bytes
-    reached or damaged the reused portal's transport.
-
-    '''
-    async with tractor.open_nursery() as an:
-        actor: Actor = tractor.current_actor()
-        portal: tractor.Portal = await an.start_actor(
-            'serialization_error_worker',
-            enable_modules=[__name__],
-        )
-        contexts_before = non_registration_contexts(actor)
-        with pytest.raises(tractor.MsgTypeError):
-            async with portal.open_context(
-                simple_setup_teardown,
-                data=object(),
-            ):
-                raise AssertionError('invalid `Start` was accepted')
-
-        assert non_registration_contexts(actor) == contexts_before
-        async with portal.open_context(
-            simple_setup_teardown,
-            data=1,
-        ) as (ctx, started):
-            assert started == 2
-            assert await ctx.wait_for_result() == 'yo'
-
-        assert non_registration_contexts(actor) == contexts_before
-        await portal.cancel_actor()
-
-
-@tractor_test
-async def test_start_module_error_cleans_context(
-    start_method: str,
-    debug_mode: bool,
-) -> None:
-    '''
-    Deallocate caller state after a remote startup rejection.
-
-    A target actor without this test module rejects the requested
-    context before sending `StartAck`. That remote
-    `ModuleNotExposed` used to escape startup validation while leaving
-    the caller context registered. The boxed error and before/after
-    registry comparison prove the remote failure remains visible and
-    local startup state is released.
-
-    '''
-    async with tractor.open_nursery() as an:
-        actor: Actor = tractor.current_actor()
-        portal: tractor.Portal = await an.start_actor(
-            'module_error_worker',
-        )
-        contexts_before = non_registration_contexts(actor)
-        with pytest.raises(tractor.RemoteActorError) as excinfo:
-            async with portal.open_context(
-                simple_setup_teardown,
-                data=1,
-            ):
-                raise AssertionError('unexposed context was started')
-
-        assert excinfo.value.boxed_type is tractor.ModuleNotExposed
-        assert non_registration_contexts(actor) == contexts_before
-        await portal.cancel_actor()
-
-
 @pytest.mark.parametrize(
     'error_parent',
     [False, ValueError, KeyboardInterrupt],

tractor/__init__.py

@@ -62,7 +62,6 @@ from .devx import (
     post_mortem as post_mortem,
 )
 from . import msg as msg
-from . import to_actor as to_actor
 from ._root import (
     run_daemon as run_daemon,
     open_root_actor as open_root_actor,

tractor/_context.py

@@ -1097,12 +1097,7 @@ class Context:
                 )
 
             cid: str = self.cid
-            cancel_deadline: float = (
+            with trio.move_on_after(timeout) as cs:
-                trio.current_time()
-                +
-                timeout
-            )
-            with trio.move_on_at(cancel_deadline) as cs:
                 cs.shield = True
                 log.cancel(
                     header
@@ -1113,16 +1108,10 @@ class Context:
                 # NOTE: we're telling the far end actor to cancel a task
                 # corresponding to *this actor*. The far end local channel
                 # instance is passed to `Actor._cancel_task()` implicitly.
-                # Use private `Portal._run_from_ns()` because cancellation
+                await self._portal.run_from_ns(
-                # needs its internal `cancel_on_startup=False` policy and
-                # the transaction's shared absolute `send_deadline`; public
-                # `run_from_ns()` exposes neither control.
-                await self._portal._run_from_ns(
                     'self',
                     '_cancel_task',
-                    kwargs={'cid': cid},
+                    cid=cid,
-                    cancel_on_startup=False,
-                    send_deadline=cancel_deadline,
                 )
 
             if cs.cancelled_caught:
@@ -1959,9 +1948,6 @@ class Context:
         # the sender; the main motivation is that using bp can block the
         # msg handling loop which calls into this method!
         except trio.WouldBlock:
-            # `send_chan.send_nowait(msg)` found the local receive feeder
-            # full. With overruns disabled below, report that primary
-            # local overflow to the far-end sender as `StreamOverrun`.
 
             # XXX: always push an error even if the local receiver
             # is in overrun state - i.e. if an 'error' msg is
@@ -2034,17 +2020,9 @@ class Context:
                     await chan.send(err_msg)
                     return True
 
-                # The `StreamOverrun` shipment can fail secondarily when
+                # XXX: local consumer has closed their side of
-                # context/channel teardown has already closed shared IPC.
+                # the IPC so cancel the far end streaming task
-                # Local stream closure may surface as
+                except trio.BrokenResourceError:
-                # `BrokenResourceError`; either peer closing the transport
-                # can surface as `TransportClosed`. In both cases teardown
-                # owns far-end cancellation and the primary overrun can no
-                # longer be delivered.
-                except (
-                    TransportClosed,
-                    trio.BrokenResourceError,
-                ):
                     log.warning(
                         'Channel for ctx is already closed?\n'
                         f'|_{chan}\n'
@@ -2647,7 +2625,10 @@ async def open_context_from_portal(
             f'uid: {uid}\n'
             f'cid: {ctx.cid}\n'
         )
-        portal.actor._drop_context(ctx)
+        portal.actor._contexts.pop(
+            (uid, ctx.cid),
+            None,
+        )
 
         # XXX revert to prior IPC-task-ctx scope
         _ctxvar_Context.reset(prior_ctx_tok)

tractor/ipc/_chan.py

@@ -310,7 +310,6 @@ class Channel:
         payload: Any,
 
         hide_tb: bool = False,
-        send_deadline: float = float('inf'),
 
     ) -> None:
         '''
@@ -321,9 +320,6 @@ class Channel:
         expected-graceful cases, normally ephemercal
         (re/dis)connects.
 
-        `send_deadline` is an absolute Trio clock deadline forwarded
-        only to transports that support bounded frame publication.
-
         '''
         __tracebackhide__: bool = hide_tb
         try:
@@ -334,17 +330,10 @@ class Channel:
                     f'{pformat(payload)}\n'
                 )
             # assert self._transport  # but why typing?
-            if send_deadline == float('inf'):
             await self._transport.send(
                 payload,
                 hide_tb=hide_tb,
             )
-            else:
-                await self._transport.send(
-                    payload,
-                    hide_tb=hide_tb,
-                    send_deadline=send_deadline,
-                )
         except (
             BaseException,
             MsgTypeError,

tractor/ipc/_transport.py

@@ -439,7 +439,6 @@ class MsgpackTransport(MsgTransport):
 
         strict_types: bool = True,
         hide_tb: bool = True,
-        send_deadline: float = float('inf'),
 
     ) -> None:
         '''
@@ -448,12 +447,6 @@ class MsgpackTransport(MsgTransport):
         If `strict_types == True` then a `MsgTypeError` will be raised on any
         invalid msg type
 
-        `send_deadline` bounds publication of one complete
-        length-prefixed frame. If it expires after a prefix or payload
-        fragment reaches the wire, a later sender would append bytes the
-        peer decoder treats as the remainder of that corrupt frame. The
-        stream is therefore destroyed before releasing `._send_lock`.
-
         '''
         __tracebackhide__: bool = hide_tb
 
@@ -505,56 +498,11 @@ class MsgpackTransport(MsgTransport):
             # https://stackoverflow.com/a/54027962
             size: bytes = struct.pack("<I", len(bytes_data))
             try:
-                # Every IPC msg is length-prefixed and all contexts
+                return await self.stream.send_all(size + bytes_data)
-                # on this actor pair share one transport stream. If
-                # the send deadline interrupts `send_all()`, an unknown
-                # frame prefix may already be on the wire; allowing the
-                # next sender to append would corrupt framing.
-                #
-                # The enclosing `async with self._send_lock` retains the
-                # lock through shielded publication and any forced-close
-                # cleanup. Context-manager exit releases it only after a
-                # complete frame or destruction of the corrupt stream.
-                # Ordinary outer cancellation remains shielded until
-                # complete publication; only expiry of `send_deadline`
-                # intentionally closes a partial stream here.
-                #
-                # Ordinary sends may delay cancellation while the remote
-                # peer actor is not reading. Bounded actor/context cancel
-                # requests pass an absolute deadline so this operation
-                # can close a stalled stream.
-                with trio.CancelScope(
-                    deadline=send_deadline,
-                    shield=True,
-                ) as send_cs:
-                    await self.stream.send_all(size + bytes_data)
-
-                if send_cs.cancelled_caught:
-                    # This frame may be partial. Destroy the stream
-                    # before releasing `_send_lock` so no later sender
-                    # can append bytes to a corrupted frame.
-                    await trio.aclose_forcefully(self.stream)
-                    await trio.lowlevel.checkpoint_if_cancelled()
-                    raise TransportClosed(
-                        'IPC frame publication exceeded its '
-                        f'deadline of {send_deadline!r}'
-                    )
-
-                # The frame is complete and still aligned. Redeliver any
-                # pending outer cancellation before normal lock release.
-                await trio.lowlevel.checkpoint_if_cancelled()
-                return None
-
             except (
                 trio.BrokenResourceError,
                 trio.ClosedResourceError,
             ) as _re:
-                # A shielded send can race outer cancellation with
-                # stream teardown. If teardown closes the stream, let
-                # the pending cancellation retain precedence instead
-                # of converting that close into `TransportClosed`.
-                await trio.lowlevel.checkpoint_if_cancelled()
-
                 trans_err = _re
                 tpt_name: str = f'{type(self).__name__!r}'
 

tractor/msg/ptr.py

@@ -123,20 +123,9 @@ class NamespacePath(str):
         ref: type|object,
 
     ) -> NamespacePath:
-        '''
-        Build a path while retaining its process-local object reference.
-
-        The originating process already holds `ref`; caching it prevents
-        `to_tuple()` from immediately importing and resolving the same
-        object again. Serialized paths carry only the `str` value and
-        therefore resolve lazily through `load_ref()` after decoding.
-
-        '''
 
         fqnp: tuple[str, str] = cls._mk_fqnp(ref)
-        nsp = cls(':'.join(fqnp))
+        return cls(':'.join(fqnp))
-        nsp._ref = ref
-        return nsp
 
     def to_tuple(
         self,

tractor/runtime/_portal.py

@@ -292,7 +292,7 @@ class Portal:
         - `True`: on bounded-wait expiry, raise `ActorTooSlowError`
           so the caller MUST handle the failure explicitly.
           `ActorNursery.cancel()` opts in so it can escalate via
-          direct `proc.kill()` hard-reaping per SC-discipline.
+          `proc.terminate()` per SC-discipline.
 
         '''
         __runtimeframe__: int = 1  # noqa
@@ -319,53 +319,39 @@ class Portal:
             or
             self.cancel_timeout
         )
-        cancel_deadline: float = (
-            trio.current_time()
-            +
-            cancel_timeout
-        )
-        # NOTE: Actor-runtime cancellation currently rides the normal
-        # RPC envelope:
-        #
-        # `Start(self.cancel)` -> `StartAck` -> `CancelAck`.
-        #
-        # `Actor.start_remote_task()` consumes the `StartAck`, then
-        # `._run_from_ns()` returns only after `PldRx.recv_pld()`
-        # decodes the final `CancelAck`. Thus this flag means that ack
-        # reached this portal after the peer's `Actor.cancel()` routine
-        # completed; it does not prove the peer OS process has exited.
-        # A dedicated `Cancel` request msg can eventually replace the
-        # internal `Start` RPC envelope and its extra `StartAck`.
-        cancel_ack_received: bool = False
         try:
-            with trio.move_on_at(cancel_deadline) as cs:
+            # send cancel cmd - might not get response
+            # XXX: sure would be nice to make this work with
+            # a proper shield
+            with trio.move_on_after(cancel_timeout) as cs:
                 cs.shield: bool = True
-                await self._run_from_ns(
+                await self.run_from_ns(
                     'self',
                     'cancel',
-                    kwargs={},
-                    cancel_on_startup=False,
-                    send_deadline=cancel_deadline,
                 )
-                cancel_ack_received = True
+                return True
 
-            # Preserve shielded actor teardown, then immediately
+            # `move_on_after` fired — peer didn't ack within
-            # redeliver any cancellation pending from an outer scope.
-            await trio.lowlevel.checkpoint_if_cancelled()
-
-            # `move_on_at` fired — peer didn't ack within
             # bounded window. Behaviour depends on
             # `raise_on_timeout`:
-            if cs.cancelled_caught:
+            if (
-                if raise_on_timeout:
+                cs.cancelled_caught
+                and
+                raise_on_timeout
+            ):
                 raise ActorTooSlowError(
                     f'Peer {peer_id} did not ack its '
                     f'`Actor.cancel()` RPC within bounded wait '
                     f'of {cancel_timeout!r}s'
                 )
 
-                # Legacy fire-and-forget callers decide whether to
+            # legacy fire-and-forget path: log + return False so
-                # escalate the missed acknowledgement themselves.
+            # the caller can decide whether to escalate.
+            #
+            # NOTE, we also land here in the (unexpected) case where
+            # the shielded `move_on_after` block exits WITHOUT
+            # `return True` and WITHOUT the deadline firing — prefer
+            # a soft `False` over an `assert`-crash mid-teardown.
             log.debug(
                 f'May have failed to cancel peer?\n'
                 f'\n'
@@ -373,8 +359,6 @@ class Portal:
             )
             return False
 
-            return cancel_ack_received
-
         except TransportClosed as tpt_err:
             ipc_borked_report: str = (
                 f'IPC for actor already closed/broken?\n\n'
@@ -395,47 +379,6 @@ class Portal:
 
             return False
 
-    # TODO: Replace actor-runtime cancellation's internal
-    # `Start -> StartAck -> CancelAck` RPC with a dedicated
-    # `Cancel -> CancelAck` transaction:
-    # https://github.com/goodboy/tractor/issues/506
-    async def _run_from_ns(
-        self,
-        namespace_path: str,
-        function_name: str,
-        kwargs: dict[str, Any],
-        cancel_on_startup: bool = True,
-        send_deadline: float = float('inf'),
-    ) -> Any:
-        '''
-        Run a namespace target with local startup policy controls.
-
-        `send_deadline` bounds only publication of the `Start` frame;
-        the caller owns any larger RPC/acknowledgement deadline.
-
-        '''
-        nsf = NamespacePath(
-            f'{namespace_path}:{function_name}'
-        )
-        ctx: Context = await self.actor.start_remote_task(
-            chan=self.channel,
-            nsf=nsf,
-            kwargs=kwargs,
-            portal=self,
-            cancel_on_startup=cancel_on_startup,
-            send_deadline=send_deadline,
-        )
-        try:
-            return await ctx._pld_rx.recv_pld(
-                ipc=ctx,
-                expect_msg=Return,
-            )
-        finally:
-            self.actor._drop_context(ctx)
-            if not ctx._rx_chan._closed:
-                with trio.CancelScope(shield=True):
-                    await ctx._rx_chan.aclose()
-
     # TODO: do we still need this for low level `Actor`-runtime
     # method calls or can we also remove it?
     async def run_from_ns(
@@ -461,10 +404,18 @@ class Portal:
 
         '''
         __runtimeframe__: int = 1  # noqa
-        return await self._run_from_ns(
+        nsf = NamespacePath(
-            namespace_path,
+            f'{namespace_path}:{function_name}'
-            function_name,
+        )
+        ctx: Context = await self.actor.start_remote_task(
+            chan=self.channel,
+            nsf=nsf,
             kwargs=kwargs,
+            portal=self,
+        )
+        return await ctx._pld_rx.recv_pld(
+            ipc=ctx,
+            expect_msg=Return,
         )
 
     # TODO: factor this out into a `.highlevel` API-wrapper that uses

tractor/runtime/_rpc.py

@@ -879,8 +879,10 @@ async def _invoke(
             # don't pop the local context until we know the
             # associated child isn't in debug any more
             await debug.maybe_wait_for_debugger()
-            dropped_ctx: Context|None = actor._drop_context(ctx)
+            ctx: Context = actor._contexts.pop((
-            assert dropped_ctx is ctx
+                chan.aid.uid,
+                cid,
+            ))
 
             logmeth: Callable = log.runtime
             merr: Exception|None = ctx.maybe_error

tractor/runtime/_runtime.py

@@ -600,21 +600,14 @@ class Actor:
     # - cancel_rpc_tasks(),
     # - _cancel_task(),
     #
-    def _get_rpc_func(
+    def _get_rpc_func(self, ns, funcname):
-        self,
-        ns: str,
-        funcname: str,
-    ):
         '''
         Try to lookup and return a target RPC func from the
         post-fork enabled module set.
 
         '''
         try:
-            return getattr(
+            return getattr(self._mods[ns], funcname)
-                self._mods[ns],
-                funcname,
-            )
         except KeyError as err:
             mne = ModuleNotExposed(*err.args)
 
@@ -760,23 +753,6 @@ class Actor:
 
         return ctx
 
-    def _drop_context(
-        self,
-        ctx: Context,
-    ) -> Context|None:
-        '''
-        Remove `ctx` from this actor's IPC context registry.
-
-        Teardown paths can converge after normal return, cancellation
-        or startup failure, so registry removal is idempotent.
-
-        '''
-        peer_uid: tuple[str, str] = ctx.chan.aid.uid
-        return self._contexts.pop(
-            (peer_uid, ctx.cid),
-            None,
-        )
-
     async def start_remote_task(
         self,
         chan: Channel,
@@ -791,13 +767,6 @@ class Actor:
         allow_overruns: bool = False,
         load_nsf: bool = False,
         ack_timeout: float = float('inf'),
-        cancel_on_startup: bool = True,
-
-        # Optional absolute deadline for publishing this exact `Start`
-        # frame. Used by bounded actor/context cancel RPCs whose outer
-        # timeout cannot penetrate `Channel.send()` forwarding into the
-        # shield in `MsgpackTransport.send()`.
-        send_deadline: float = float('inf'),
 
     ) -> Context:
         '''
@@ -849,23 +818,13 @@ class Actor:
 
             f'{pretty_struct.pformat(msg)}'
         )
-        start_published: bool = False
-        try:
-            if send_deadline == float('inf'):
         await chan.send(msg)
-            else:
-                await chan.send(
-                    msg,
-                    send_deadline=send_deadline,
-                )
-            start_published = True
 
         # NOTE wait on first `StartAck` response msg and validate;
         # this should be immediate and does not (yet) wait for the
         # remote child task to sync via `Context.started()`.
         with trio.fail_after(ack_timeout):
             first_msg: msgtypes.StartAck = await ctx._rx_chan.receive()
-
         try:
             functype: str = first_msg.functype
         except AttributeError:
@@ -877,48 +836,9 @@ class Actor:
             'context',
         ):
             raise ValueError(
-                    f'Invalid `StartAck.functype: str = '
+                f'Invalid `StartAck.functype: str = {first_msg!r}` ??'
-                    f'{first_msg!r}` ??'
             )
 
-        except BaseException as startup_err:
-            with trio.CancelScope(shield=True):
-                # `MsgpackTransport.send()` shields length-prefixed frame
-                # publication until complete, then checkpoints pending
-                # cancellation before returning. Thus `start_published`
-                # can remain false after a complete `Start` reached the
-                # wire. If the send's own deadline catches a partial
-                # frame, it closes the stream. A connected channel means
-                # cancellation happened before the write or after frame
-                # completion, so `_cancel_task` is protocol-safe (and
-                # a no-op when `Start` was unsent).
-                if (
-                    cancel_on_startup
-                    and
-                    (
-                        start_published
-                        or (
-                            isinstance(startup_err, trio.Cancelled)
-                            and
-                            chan.connected()
-                        )
-                    )
-                ):
-                    try:
-                        await ctx.cancel()
-                    except BaseException as cancel_err:
-                        log.warning(
-                            'Failed to cancel RPC task during '
-                            'startup?\n'
-                            f'{cancel_err!r}\n'
-                        )
-
-                self._drop_context(ctx)
-                if not ctx._rx_chan._closed:
-                    await ctx._rx_chan.aclose()
-
-            raise
-
         ctx._remote_func_type = functype
         return ctx
 

tractor/runtime/_supervise.py

@@ -46,7 +46,6 @@ from ..log import (
     get_logger,
     get_loglevel,
 )
-from ..msg import Aid
 from ._runtime import Actor
 from ._portal import Portal
 from ..trionics import (
@@ -91,7 +90,7 @@ async def _try_cancel_then_kill(
     Sends a graceful actor-runtime cancel-RPC via
     `Portal.cancel_actor(raise_on_timeout=True)`. If the bounded-wait
     expires before the peer ack's, `ActorTooSlowError` is raised and
-    we escalate via `proc.kill()` per SC-discipline:
+    we escalate via `proc.terminate()` (SIGTERM) per SC-discipline:
 
       graceful cancel-req -> bounded wait -> hard-kill
 
@@ -103,9 +102,11 @@ async def _try_cancel_then_kill(
     the wider write-up.
 
     '''
-    # XXX, delay hard-kill escalation while any debugger guard
+    # XXX, do NOT escalate to `proc.terminate()` while ANY of
-    # below is active. Killing the sub immediately would tear down
+    # the following are true — SIGTERM-ing a sub would tear
-    # its tree and clobber an actor proxying a REPL session:
+    # down its sub-tree including any descendant proxying
+    # stdio to/from a REPL-locked actor, clobbering the user's
+    # debug session:
     #
     # - `Lock.ctx_in_debug is not None`: most precise — some
     #   actor in the tree is currently REPL-locked. Set in the
@@ -121,7 +122,7 @@ async def _try_cancel_then_kill(
     #   child.
     #
     # - `debug_mode_active`: this nursery has at least one
-    #   child started with an explicit `debug_mode=True` arg
+    #   child started with an explicit `debug_mode=` arg
     #   (`ActorNursery._at_least_one_child_in_debug`). Catches
     #   the case where root is NOT in debug-mode but a
     #   nursery-direct child opted in.
@@ -131,63 +132,36 @@ async def _try_cancel_then_kill(
     # mutated by per-child `debug_mode=True`). ORing covers
     # every flavor without false-positively skipping
     # legitimate hard-kill paths in non-debug trees.
-    def child_in_debug() -> bool:
+    if (
-        '''
-        Sample child/tree debugger protection state.
-
-        '''
-        return (
-            debug_mode_active
-            or
         debug.Lock.ctx_in_debug is not None
-        )
-
-    debug_protected: bool = (
-        child_in_debug()
         or
         _state._runtime_vars.get('_debug_mode', False)
-    )
+        or
+        debug_mode_active
+    ):
+        await portal.cancel_actor()
+        return
 
     try:
-        cancelled: bool = await portal.cancel_actor(
+        await portal.cancel_actor(raise_on_timeout=True)
-            raise_on_timeout=not debug_protected,
-        )
-        if not cancelled:
-            if debug_protected:
-                await debug.maybe_wait_for_debugger(
-                    # Re-sample after the cancel-RPC checkpoint.
-                    child_in_debug=child_in_debug(),
-                    header_msg=(
-                        'Delaying subproc hard-reap while '
-                        'debugger locked..\n'
-                    ),
-                )
-
-            peer_id: str = portal.channel.aid.reprol()
-            raise ActorTooSlowError(
-                f'Peer {peer_id} disconnected before '
-                f'acknowledging its `Actor.cancel()` RPC'
-            )
-
     except ActorTooSlowError as too_slow:
         log.error(
             f'Cancel-ack TIMED OUT for sub-actor\n'
             f'  uid: {subactor.aid.reprol()!r}\n'
             f'  reason: {too_slow}\n'
-            f'-> escalating to `proc.kill()` (hard-reap)\n'
+            f'-> escalating to `proc.terminate()` (hard-kill)\n'
         )
         # XXX, the `subint` backend stores an `int` interp-id in the
-        # `proc` slot (not a `Process`), so it has no `.kill()`.
+        # `proc` slot (not a `Process`), so it has no `.terminate()`.
         # Guard here so a cancel-ack timeout doesn't `AttributeError`
         # once that backend lands; its hard-kill path is a TODO.
-        if hasattr(proc, 'kill'):
+        if hasattr(proc, 'terminate'):
-            if proc.poll() is None:
+            proc.terminate()
-                proc.kill()
         else:
             log.error(
                 f'Cannot hard-kill sub-actor — backend proc-handle '
                 f'{proc!r} ({type(proc).__name__!r}) has no '
-                f'`.kill()`!\n'
+                f'`.terminate()`!\n'
                 f'  uid: {subactor.aid.reprol()!r}\n'
                 f'TODO: per-backend cancel-escalation.\n'
             )
@@ -246,14 +220,6 @@ class ActorNursery:
         ] = {}
 
         self._join_procs = trio.Event()
-        self._child_reap_requests: dict[
-            Aid,
-            trio.Event,
-        ] = {}
-        self._child_reaped: dict[
-            Aid,
-            trio.Event,
-        ] = {}
         self._at_least_one_child_in_debug: bool = False
         self.errors = errors
         self._scope_error: BaseException|None = None
@@ -318,112 +284,6 @@ class ActorNursery:
             # self._cancelled_caught
         )
 
-    def _register_child_reap(
-        self,
-        aid: Aid,
-    ) -> tuple[trio.Event, trio.Event]:
-        '''
-        Register a child monitor's process-reap events.
-
-        '''
-        reap_request = trio.Event()
-        reaped = trio.Event()
-        self._child_reap_requests[aid] = reap_request
-        self._child_reaped[aid] = reaped
-        if self._join_procs.is_set():
-            reap_request.set()
-        return reap_request, reaped
-
-    def _register_child(
-        self,
-        subactor: Actor,
-        proc: 'ProcessType',
-        portal: Portal|None,
-    ) -> tuple[trio.Event, trio.Event, bool]:
-        '''
-        Atomically publish one child and its reap coordination.
-
-        '''
-        aid: Aid = subactor.aid
-        uid: tuple[str, str] = aid.uid
-        self._children[uid] = (
-            subactor,
-            proc,
-            portal,
-        )
-        reap_request, reaped = self._register_child_reap(aid)
-        return (
-            reap_request,
-            reaped,
-            self._cancel_called,
-        )
-
-    def _request_reap_all(self) -> None:
-        '''
-        Release every child monitor into its process-join phase.
-
-        '''
-        self._join_procs.set()
-        for reap_request in tuple(
-            self._child_reap_requests.values()
-        ):
-            reap_request.set()
-
-    def _mark_child_reaped(
-        self,
-        aid: Aid,
-    ) -> None:
-        '''
-        Publish completed child-process teardown to its waiter.
-
-        '''
-        uid: tuple[str, str] = aid.uid
-        self._children.pop(uid, None)
-        reap_request: trio.Event|None = (
-            self._child_reap_requests.pop(aid, None)
-        )
-        reaped: trio.Event|None = self._child_reaped.pop(
-            aid,
-            None,
-        )
-        assert (
-            (reap_request is None)
-            ==
-            (reaped is None)
-        )
-        if reaped is not None:
-            reaped.set()
-
-    async def _cancel_and_reap_child(
-        self,
-        portal: Portal,
-    ) -> None:
-        '''
-        Cancel, join and unregister one nursery-owned child.
-
-        '''
-        aid: Aid = portal.channel.aid
-        uid: tuple[str, str] = aid.uid
-        child_entry = self._children.get(uid)
-        if child_entry is None:
-            return
-
-        subactor, proc, _ = child_entry
-        reap_request: trio.Event = self._child_reap_requests[aid]
-        reaped: trio.Event = self._child_reaped[aid]
-
-        with trio.CancelScope(shield=True):
-            try:
-                await _try_cancel_then_kill(
-                    portal,
-                    proc,
-                    subactor,
-                    self._at_least_one_child_in_debug,
-                )
-            finally:
-                reap_request.set()
-                await reaped.wait()
-
     async def start_actor(
         self,
         name: str,
@@ -459,12 +319,6 @@ class ActorNursery:
 
         '''
         __runtimeframe__: int = 1  # noqa
-        if self._cancel_called:
-            raise RuntimeError(
-                'Cannot start an actor in a cancelling '
-                '`ActorNursery`'
-            )
-
         loglevel: str = (
             loglevel
             or self._actor.loglevel
@@ -479,7 +333,7 @@ class ActorNursery:
         # allow setting debug policy per actor
         if debug_mode is not None:
             _rtv['_debug_mode'] = debug_mode
-            self._at_least_one_child_in_debug |= debug_mode
+            self._at_least_one_child_in_debug = True
 
         enable_modules = list(enable_modules or [])
         proc_kwargs = dict(proc_kwargs or {})
@@ -529,13 +383,12 @@ class ActorNursery:
         )
 
     # TODO: DEPRECATE THIS:
-    # -[x] impl instead as a hilevel wrapper on top of
+    # -[ ] impl instead as a hilevel wrapper on
-    #   the lower level daemon-spawn + portal APIs
+    #   top of a `@context` style invocation.
-    #  |_ see `.to_actor.run()` (issue #477) which does
+    #  |_ dynamic @context decoration on child side
-    #    `.start_actor()` + `Portal.run()` + a one-shot
+    #  |_ implicit `Portal.open_context() as (ctx, first):`
-    #    reap via `Portal.cancel_actor()`.
+    #    and `return first` on parent side.
-    # -[ ] emit a `DeprecationWarning` here (requires
+    #  |_ mention how it's similar to `trio-parallel` API?
-    #   migrating all in-repo usage first!)
     # -[ ] use @api_frame on the wrapper
     async def run_in_actor(
         self,
@@ -563,11 +416,6 @@ class ActorNursery:
         until the task spawned by executing ``fn`` completes at which point
         the actor is terminated.
 
-        NOTE: prefer the (eventual) replacement API
-        `tractor.to_actor.run()` which delivers the same
-        one-shot semantics decoupled from this nursery's
-        internal spawn machinery; see issue #477.
-
         '''
         __runtimeframe__: int = 1  # noqa
         mod_path: str = fn.__module__
@@ -630,7 +478,7 @@ class ActorNursery:
 
         # TODO: impl a repr for spawn more compact
         # then `._children`..
-        children: tuple = tuple(self._children.values())
+        children: dict = self._children
         child_count: int = len(children)
         msg: str = f'Cancelling actor nursery with {child_count} children\n'
 
@@ -649,7 +497,7 @@ class ActorNursery:
                     subactor,
                     proc,
                     portal,
-                ) in children:
+                ) in children.values():
 
                     # TODO: are we ever even going to use this or
                     # is the spawning backend responsible for such
@@ -669,9 +517,7 @@ class ActorNursery:
                             await event.wait()
 
                             # channel/portal should now be up
-                            _, _, portal = self._children[
+                            _, _, portal = children[subactor.aid.uid]
-                                subactor.aid.uid
-                            ]
 
                             # XXX should be impossible to get here
                             # unless method was called from within
@@ -718,14 +564,14 @@ class ActorNursery:
                 subactor,
                 proc,
                 portal,
-                ) in children:
+            ) in children.values():
                 log.warning(f"Hard killing process {proc}")
                 proc.terminate()
         else:
             self._cancelled_caught
 
         # mark ourselves as having (tried to have) cancelled all subactors
-        self._request_reap_all()
+        self._join_procs.set()
 
 
 @acm
@@ -787,7 +633,7 @@ async def _open_and_supervise_one_cancels_all_nursery(
                         'Waiting on subactors to complete:\n'
                         f'>}} {len(an._children)}\n'
                     )
-                    an._request_reap_all()
+                    an._join_procs.set()
 
                 except BaseException as _inner_err:
                     inner_err = _inner_err
@@ -806,7 +652,7 @@ async def _open_and_supervise_one_cancels_all_nursery(
                     # if the caller's scope errored then we activate our
                     # one-cancels-all supervisor strategy (don't
                     # worry more are coming).
-                    an._request_reap_all()
+                    an._join_procs.set()
 
                     # XXX NOTE XXX: hypothetically an error could
                     # be raised and then a cancel signal shows up

tractor/spawn/_mp.py

@@ -138,24 +138,12 @@ async def mp_proc(
         # daemon=True,
         name=name,
     )
-    # `multiprocessing` only (since no async interface): publish the
+
-    # process and its reap coordination before start so cancellation
+    # `multiprocessing` only (since no async interface):
-    # can own every subsequently started child.
+    # register the process before start in case we get a cancel
-    # No `Portal` exists until the IPC handshake returns `chan`.
+    # request before the actor has fully spawned - then we can wait
-    # Replace this provisional entry with `Portal(chan)` below.
+    # for it to fully come up before sending a cancel request
-    (
+    actor_nursery._children[subactor.aid.uid] = (subactor, proc, None)
-        reap_request,
-        _,
-        cancel_during_registration,
-    ) = actor_nursery._register_child(
-        subactor=subactor,
-        proc=proc,
-        portal=None,
-    )
-    if cancel_during_registration:
-        raise RuntimeError(
-            'Actor registered after its nursery began cancelling'
-        )
 
     proc.start()
     if not proc.is_alive():
@@ -187,8 +175,8 @@ async def mp_proc(
         # unblock parent task
         task_status.started(portal)
 
-        # wait for this child or its `ActorNursery` to signal that
+        # wait for ``ActorNursery`` block to signal that
-        # the subprocess can be joined.
+        # subprocesses can be waited upon.
         # This is required to ensure synchronization
         # with user code that may want to manually await results
         # from nursery spawned sub-actors. We don't want the
@@ -197,7 +185,7 @@ async def mp_proc(
         # nursery block closes do we allow subactor results to be
         # awaited and reported upwards to the supervisor.
         with trio.CancelScope(shield=True):
-            await reap_request.wait()
+            await actor_nursery._join_procs.wait()
 
         async with trio.open_nursery() as nursery:
             if portal in actor_nursery._cancel_after_result_on_exit:

tractor/spawn/_spawn.py

@@ -446,7 +446,6 @@ async def new_proc(
     # mark the new actor with the global spawn method
     subactor._spawn_method = _spawn_method
 
-    try:
     await target(
         name,
         actor_nursery,
@@ -459,8 +458,6 @@ async def new_proc(
         task_status=task_status,
         proc_kwargs=proc_kwargs
     )
-    finally:
-        actor_nursery._mark_child_reaped(subactor.aid)
 
 
 # NOTE: bottom-of-module to avoid a circular import since the

tractor/spawn/_trio.py

@@ -39,6 +39,7 @@ from tractor.runtime._state import (
     current_actor,
     is_root_process,
     debug_mode,
+    get_runtime_vars,
 )
 from tractor.log import get_logger
 from tractor.discovery._addr import UnwrappedAddress
@@ -130,26 +131,6 @@ async def trio_proc(
                 f' |_{proc}\n'
             )
 
-            # No `Portal` exists until the IPC handshake returns
-            # `chan`. Replace this provisional entry with
-            # `Portal(chan)` below.
-            (
-                reap_request,
-                _,
-                cancel_during_registration,
-            ) = actor_nursery._register_child(
-                subactor=subactor,
-                proc=proc,
-                portal=None,
-            )
-            if cancel_during_registration:
-                cancelled_during_spawn = True
-                proc.kill()
-                raise RuntimeError(
-                    'Actor registered after its nursery began '
-                    'cancelling'
-                )
-
             # wait for actor to spawn and connect back to us
             # channel should have handshake completed by the
             # local actor by the time we get a ref to it
@@ -210,10 +191,9 @@ async def trio_proc(
         # resume caller at next checkpoint now that child is up
         task_status.started(portal)
 
-        # wait for this child or its `ActorNursery` to request
+        # wait for ActorNursery.wait() to be called
-        # process joining.
         with trio.CancelScope(shield=True):
-            await reap_request.wait()
+            await actor_nursery._join_procs.wait()
 
         async with trio.open_nursery() as nursery:
             if portal in actor_nursery._cancel_after_result_on_exit:

tractor/to_actor/__init__.py

@@ -1,39 +0,0 @@
-# tractor: distributed structured concurrency.
-# Copyright 2018-eternity Tyler Goodlet.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-'''
-`tractor.to_actor`: high-level "one-shot" remote-task APIs.
-
-Adopts the "run it over there" parlance from analogous
-(sibling-library) APIs like `trio.to_thread` and
-`anyio.to_process` but for SC-supervised actors: spawn (or
-reuse) a subactor, schedule a single remote task, wait on
-its result and (when the call owns the subactor) reap it.
-Target arguments follow Trio's positional convention; use
-`functools.partial()` to bind target keyword arguments.
-
-The "spiritual successor" to (and eventual replacement of)
-the `ActorNursery.run_in_actor()` API; see
-https://github.com/goodboy/tractor/issues/477
-
-'''
-from . import _api as _api
-from ._api import (
-    run as run,
-)
-
-
-MODULE: str = _api.__name__

tractor/to_actor/_api.py

@@ -1,367 +0,0 @@
-# tractor: distributed structured concurrency.
-# Copyright 2018-eternity Tyler Goodlet.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-'''
-One-shot remote-task invocation built on spawn-and-portal
-primitives.
-
-Implemented (as prescribed by #477) entirely "on top of"
-the lower level daemon-actor spawn + portal APIs,
-
-- `ActorNursery.start_actor()` for (daemon-style) subactor
-  spawning,
-- `Portal.open_context()` for scheduling the lone remote
-  task with linked cancellation and waiting on its result,
-- `Portal.cancel_actor()` for reaping the subactor once
-  that result (or error) arrives,
-
-such that error collection and propagation happens in the
-*caller's task* (and thus whatever `trio` nursery/scope
-encloses it) instead of inside the actor-nursery's
-spawn-machinery nurseries as with the (to be deprecated)
-`ActorNursery.run_in_actor()` API.
-
-'''
-from __future__ import annotations
-import functools
-import inspect
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    TYPE_CHECKING,
-    TypeVar,
-    TypeVarTuple,
-    Unpack,
-)
-
-from .._context import (
-    Context,
-    context,
-)
-from ..msg.ptr import NamespacePath
-from ..runtime._state import current_actor
-from ..runtime._supervise import (
-    ActorNursery,
-    open_nursery,
-)
-
-if TYPE_CHECKING:
-    from ..discovery._addr import UnwrappedAddress
-    from ..runtime._portal import Portal
-
-
-ArgsT = TypeVarTuple('ArgsT')
-RetT = TypeVar('RetT')
-
-
-def _validate_one_shot_fn(
-    fn: Callable,
-) -> None:
-    '''
-    Ensure `fn` is a non-streaming async function, raise
-    a `TypeError` otherwise.
-
-    The same constraint enforced by `Portal.open_context()` but
-    checked up-front, BEFORE any subactor is spawned.
-
-    '''
-    if not (
-        inspect.iscoroutinefunction(fn)
-        and
-        not getattr(
-            fn,
-            '_tractor_stream_function',
-            False,
-        )
-    ):
-        raise TypeError(
-            f'{fn!r} must be a non-streaming async '
-            f'function!'
-        )
-
-
-def _normalize_call(
-    fn: Callable,
-    args: tuple[Any, ...],
-) -> tuple[
-    Callable,
-    tuple[Any, ...],
-    dict[str, Any],
-]:
-    '''
-    Normalize Trio-style positional and partial-bound arguments.
-
-    Actor calls must send a namespace-addressable base function and
-    serializable inputs to another process, so decompose partials and
-    validate their complete call signature before runtime startup.
-
-    '''
-    kwargs: dict[str, Any] = {}
-    while isinstance(fn, functools.partial):
-        partial_args: tuple[Any, ...] = fn.args
-
-        # `functools.Placeholder` was added in Python 3.14. Drop
-        # this `getattr()` guard once 3.14 is the minimum version.
-        if (
-            (
-                placeholder := getattr(
-                    functools,
-                    'Placeholder',
-                    None,
-                )
-            ) is not None
-            and
-            any(
-                arg is placeholder
-                for arg in partial_args
-            )
-        ):
-            call_args = iter(args)
-            merged_args: list[Any] = []
-            for arg in partial_args:
-                if arg is placeholder:
-                    try:
-                        arg = next(call_args)
-                    except StopIteration:
-                        raise TypeError(
-                            'Not enough positional arguments to '
-                            'fill `functools.Placeholder`s'
-                        ) from None
-
-                merged_args.append(arg)
-
-            merged_args.extend(call_args)
-            args = tuple(merged_args)
-        else:
-            args = partial_args + args
-
-        partial_kwargs = dict(fn.keywords or {})
-        partial_kwargs.update(kwargs)
-        kwargs = partial_kwargs
-        fn = fn.func
-
-    _validate_one_shot_fn(fn)
-    inspect.signature(fn).bind(*args, **kwargs)
-    return fn, args, kwargs
-
-
-@context
-async def _invoke_one_shot(
-    ctx: Context,
-    namespace: str,
-    funcname: str,
-    args: list[Any],
-    kwargs: dict[str, Any],
-) -> Any:
-    '''
-    Invoke an ordinary async function inside a linked IPC context.
-
-    '''
-    # Do not use `NamespacePath.load_ref()` here: target resolution
-    # must remain behind the actor's RPC module allowlist.
-    fn: Callable = current_actor()._get_rpc_func(
-        namespace,
-        funcname,
-    )
-    _validate_one_shot_fn(fn)
-    await ctx.started()
-    return await fn(*args, **kwargs)
-
-
-async def _invoke_from_portal(
-    portal: Portal,
-    fn: Callable,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-) -> Any:
-    '''
-    Run `fn` through the context-linked one-shot endpoint.
-
-    '''
-    namespace, funcname = NamespacePath.from_ref(fn).to_tuple()
-    async with portal.open_context(
-        _invoke_one_shot,
-        namespace=namespace,
-        funcname=funcname,
-        args=list(args),
-        kwargs=kwargs,
-    ) as (ctx, _):
-        return await ctx.wait_for_result()
-
-
-async def _invoke_in_subactor(
-    an: ActorNursery,
-    fn: Callable,
-    args: tuple[Any, ...],
-    kwargs: dict[str, Any],
-    name: str,
-    spawn_kwargs: dict[str, Any],
-) -> Any:
-    '''
-    Spawn a (daemon) subactor via `an.start_actor()`,
-    schedule `fn` as its context-linked lone remote task and,
-    ALWAYS, reap the subactor once that task's result (or error)
-    has been delivered.
-
-    '''
-    portal: Portal = await an.start_actor(
-        name,
-        **spawn_kwargs,
-    )
-    try:
-        return await _invoke_from_portal(
-            portal,
-            fn,
-            args,
-            kwargs,
-        )
-    finally:
-        # Cancel and join this child before returning. The nursery
-        # helper shields teardown, escalates a missed cancel ack and
-        # waits for the child monitor to remove its process record.
-        await an._cancel_and_reap_child(portal)
-
-
-async def run(
-    fn: Callable[[Unpack[ArgsT]], Awaitable[RetT]],
-    *args: Unpack[ArgsT],
-
-    # actor lifetime management: reuse an already-running peer
-    # via its `portal: Portal`, spawn a fresh subactor from
-    # a caller-managed `an: ActorNursery`, or, when
-    # neither is provided, open a private actor-nursery
-    # (implicitly booting the actor-runtime as needed)
-    # scoped to just this call.
-    portal: Portal|None = None,
-    an: ActorNursery|None = None,
-
-    # subactor spawn opts passed (mostly) verbatim to
-    # `ActorNursery.start_actor()`; unused when `portal`
-    # is provided.
-    name: str|None = None,
-    bind_addrs: list[UnwrappedAddress]|None = None,
-    enable_modules: list[str]|None = None,
-    loglevel: str|None = None,
-    debug_mode: bool|None = None,
-    infect_asyncio: bool = False,
-    inherit_parent_main: bool = True,
-    proc_kwargs: dict[str, Any]|None = None,
-
-    # passed verbatim to the private `open_nursery()`
-    # (and in turn any implicit `open_root_actor()`)
-    # when NO `an`/`portal` is provided.
-    runtime_kwargs: dict[str, Any]|None = None,
-
-) -> RetT:
-    '''
-    Run the async `fn(*args)` as the lone task in a (new)
-    subactor, block waiting on its result and return it; the
-    distributed-parallelism equivalent of
-    `trio.to_thread.run_sync()`.
-
-    As with Trio's API, target arguments are positional. Use
-    `functools.partial()` to bind target keyword arguments; all
-    keyword arguments accepted here configure actor lifetime
-    management, including actor reuse and spawning. A caller-supplied
-    `portal` must address an actor started with both
-    `tractor.to_actor.MODULE` and the target function's
-    module in its `enable_modules` list. Calls that spawn their own
-    actor add the trampoline module automatically.
-
-    Unlike `ActorNursery.run_in_actor()` (which returns
-    a `Portal` whose result is only collected at
-    actor-nursery teardown) this is a plain "call and
-    wait" primitive: any remote error is raised HERE, in
-    the caller's task. Concurrency is composed the usual
-    `trio` way by scheduling multiple `run()` calls in
-    a local task nursery, ideally against a shared
-    caller-managed `an: ActorNursery` (see the test
-    suite for the canonical worker-pool-ish pattern).
-
-    '''
-    __runtimeframe__: int = 1  # noqa
-    fn, args, kwargs = _normalize_call(fn, args)
-
-    if (
-        runtime_kwargs is not None
-        and
-        (
-            an is not None
-            or
-            portal is not None
-        )
-    ):
-        raise ValueError(
-            '`runtime_kwargs` only applies when this '
-            'call opens its own private actor-nursery '
-            '(no `an`/`portal` provided)!'
-        )
-
-    if portal is not None:
-        if an is not None:
-            raise ValueError(
-                'Pass at most ONE of `portal` or `an`, '
-                'not both!'
-            )
-        return await _invoke_from_portal(
-            portal,
-            fn,
-            args,
-            kwargs,
-        )
-
-    name: str = name or fn.__name__
-    spawn_kwargs: dict[str, Any] = dict(
-        enable_modules=(
-            [
-                # The public `to_actor.MODULE` alias is only for
-                # callers configuring an existing actor.
-                __name__,
-                fn.__module__,
-            ]
-            +
-            (enable_modules or [])
-        ),
-        bind_addrs=bind_addrs,
-        loglevel=loglevel,
-        debug_mode=debug_mode,
-        infect_asyncio=infect_asyncio,
-        inherit_parent_main=inherit_parent_main,
-        proc_kwargs=proc_kwargs,
-    )
-    if an is not None:
-        return await _invoke_in_subactor(
-            an,
-            fn,
-            args,
-            kwargs,
-            name,
-            spawn_kwargs,
-        )
-
-    an: ActorNursery
-    async with open_nursery(
-        **(runtime_kwargs or {}),
-    ) as an:
-        return await _invoke_in_subactor(
-            an,
-            fn,
-            args,
-            kwargs,
-            name,
-            spawn_kwargs,
-        )