Fix when root-actor addrs is set as rtvs

Move `_root_addrs` assignment to after `async_main()` unblocks (via
`.started()`) which now delivers the bind addrs , ensuring correct
`UnwrappedAddress` propagation into `._state._runtime_vars` for
non-registar root actors..

Previously for non-registrar root actors the `._state._runtime_vars`
entries were being set as `Address` values which ofc IPC serialize
incorrectly rn vs. the unwrapped versions, (well until we add a msgspec
for their structs anyway) and thus are passed in incorrect form to
children/subactors during spawning..

This fixes the issue by waiting for the `.ipc.*` stack to
bind-and-resolve any randomly allocated addrs (by the OS) until after
the initial `Actor` startup is complete.

Deats,
- primarily, mv `_root_addrs` assignment from before `root_tn.start()`
  to after, using started(-ed) `accept_addrs` now delivered from
  `._runtime.async_main()`..
- update `task_status` type hints to match.
- unpack and set the `(accept_addrs, reg_addrs)` tuple from
  `root_tn.start()` call into `._state._runtime_vars` entries.
- improve and embolden comments distinguishing registrar vs non-registrar
  init paths, ensure typing reflects wrapped vs. unwrapped addrs.

Also,
- add a masked `mk_pdb().set_trace()` for debugging `raddrs` values
  being "off".
- add TODO about using UDS on linux for root mailbox
- rename `trans_bind_addrs` -> `tpt_bind_addrs` for clarity.
- expand comment about random port allocation for
  non-registrar case

(this commit msg was generated in some part by [`claude-code`][claude-code-gh])
[claude-code-gh]: https://github.com/anthropics/claude-code

tests/test_multi_program.py

@@ -1,13 +1,8 @@
 """
 Multiple python programs invoking the runtime.
 """
-from __future__ import annotations
 import platform
-import subprocess
 import time
-from typing import (
-    TYPE_CHECKING,
-)
 
 import pytest
 import trio
@@ -15,29 +10,14 @@ import tractor
 from tractor._testing import (
     tractor_test,
 )
-from tractor import (
-    current_actor,
-    _state,
-    Actor,
-    Context,
-    Portal,
-)
 from .conftest import (
     sig_prog,
     _INT_SIGNAL,
     _INT_RETURN_CODE,
 )
 
-if TYPE_CHECKING:
-    from tractor.msg import Aid
-    from tractor._addr import (
-        UnwrappedAddress,
-    )
 
-
+def test_abort_on_sigint(daemon):
-def test_abort_on_sigint(
-    daemon: subprocess.Popen,
-):
     assert daemon.returncode is None
     time.sleep(0.1)
     sig_prog(daemon, _INT_SIGNAL)
@@ -50,11 +30,8 @@ def test_abort_on_sigint(
 
 
 @tractor_test
-async def test_cancel_remote_arbiter(
+async def test_cancel_remote_arbiter(daemon, reg_addr):
-    daemon: subprocess.Popen,
+    assert not tractor.current_actor().is_arbiter
-    reg_addr: UnwrappedAddress,
-):
-    assert not current_actor().is_arbiter
     async with tractor.get_registry(reg_addr) as portal:
         await portal.cancel_actor()
 
@@ -68,106 +45,24 @@ async def test_cancel_remote_arbiter(
             pass
 
 
-def test_register_duplicate_name(
+def test_register_duplicate_name(daemon, reg_addr):
-    daemon: subprocess.Popen,
+
-    reg_addr: UnwrappedAddress,
-):
     async def main():
+
         async with tractor.open_nursery(
             registry_addrs=[reg_addr],
-        ) as an:
+        ) as n:
 
-            assert not current_actor().is_arbiter
+            assert not tractor.current_actor().is_arbiter
 
-            p1 = await an.start_actor('doggy')
+            p1 = await n.start_actor('doggy')
-            p2 = await an.start_actor('doggy')
+            p2 = await n.start_actor('doggy')
 
             async with tractor.wait_for_actor('doggy') as portal:
                 assert portal.channel.uid in (p2.channel.uid, p1.channel.uid)
 
-            await an.cancel()
+            await n.cancel()
 
-    # XXX, run manually since we want to start this root **after**
+    # run it manually since we want to start **after**
-    # the other "daemon" program with it's own root.
+    # the other "daemon" program
-    trio.run(main)
-
-
-@tractor.context
-async def get_root_portal(
-    ctx: Context,
-):
-    '''
-    Connect back to the root actor manually (using `._discovery` API)
-    and ensure it's contact info is the same as our immediate parent.
-
-    '''
-    sub: Actor = current_actor()
-    rtvs: dict = _state._runtime_vars
-    raddrs: list[UnwrappedAddress] = rtvs['_root_addrs']
-
-    # await tractor.pause()
-    # XXX, in case the sub->root discovery breaks you might need
-    # this (i know i did Xp)!!
-    # from tractor.devx import mk_pdb
-    # mk_pdb().set_trace()
-
-    assert (
-        len(raddrs) == 1
-        and
-        list(sub._parent_chan.raddr.unwrap()) in raddrs
-    )
-
-    # connect back to our immediate parent which should also
-    # be the actor-tree's root.
-    from tractor._discovery import get_root
-    ptl: Portal
-    async with get_root() as ptl:
-        root_aid: Aid = ptl.chan.aid
-        parent_ptl: Portal = current_actor().get_parent()
-        assert (
-            root_aid.name == 'root'
-            and
-            parent_ptl.chan.aid == root_aid
-        )
-        await ctx.started()
-
-
-def test_non_registrar_spawns_child(
-    daemon: subprocess.Popen,
-    reg_addr: UnwrappedAddress,
-    loglevel: str,
-    debug_mode: bool,
-):
-    '''
-    Ensure a non-regristar (serving) root actor can spawn a sub and
-    that sub can connect back (manually) to it's rent that is the
-    root without issue.
-
-    More or less this audits the global contact info in
-    `._state._runtime_vars`.
-
-    '''
-    async def main():
-        async with tractor.open_nursery(
-            registry_addrs=[reg_addr],
-            loglevel=loglevel,
-            debug_mode=debug_mode,
-        ) as an:
-
-            actor: Actor = tractor.current_actor()
-            assert not actor.is_registrar
-            sub_ptl: Portal = await an.start_actor(
-                name='sub',
-                enable_modules=[__name__],
-            )
-
-            async with sub_ptl.open_context(
-                get_root_portal,
-            ) as (ctx, first):
-                print('Waiting for `sub` to connect back to us..')
-
-            await an.cancel()
-
-    # XXX, run manually since we want to start this root **after**
-    # the other "daemon" program with it's own root.
     trio.run(main)

tractor/_root.py

@@ -616,13 +616,6 @@ async def open_root_actor(
             ):
                 _state._runtime_vars['_debug_mode'] = False
 
-            # !XXX, clear ALL prior contact info state, this is MEGA
-            # important if you are opening the runtime multiple times
-            # from the same parent process (like in our test
-            # harness)!
-            _state._runtime_vars['_root_addrs'].clear()
-            _state._runtime_vars['_root_mailbox'] = None
-
             _state._current_actor = None
             _state._last_actor_terminated = actor