bitspark-bitwire 0.1.0__tar.gz → 0.3.0__tar.gz

{bitspark_bitwire-0.1.0/src/bitspark_bitwire.egg-info → bitspark_bitwire-0.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: bitspark-bitwire
-Version: 0.1.0
-Summary: The shared relative-path Wire contract for Python
+Version: 0.3.0
+Summary: Addressless Wire primitives, full WireTree structure and addressed carrier contracts for Python
 Author: Bitspark
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/Bitspark/bitwire
@@ -20,16 +20,41 @@ Dynamic: license-file
 
 # Bitwire for Python
 
-`bitspark-bitwire` provides the shared relative-path Wire contract as the Python
+**Source contract: 0.3.0; publication pending.** `Wire` is the addressless
+primitive `send(message)`. `WireTree = DeixisNode<Wire>` provides the complete
+finite, acyclic structure: own value, complete byte-keyed children, partial
+selection and decomposition. Keys are exact arbitrary bytes, including empty
+and non-UTF-8 keys. Empty path selects self; a missing edge is distinct from a
+present refusing primitive. Recomposition preserves own and child identities.
+
+This is symmetric with Bitstore's `Data.read()` primitive and
+`DataTree = DeixisNode<Data>`. Derived sending selects the node and invokes its
+own Wire. Construction and derived operators belong in bitruntime; these
+packages publish declarations and criteria, not a production tree runtime.
+See [decision 0012](https://github.com/Bitspark/bitwire/blob/main/docs/decisions/0012-explicit-data-and-wire-trees.md)
+and the [migration guide](https://github.com/Bitspark/bitwire/blob/main/docs/migration-0.3.md).
+
+`AddressedWire` explicitly names the former `Wire.send(path, message)` surface.
+It is not a full WireTree. `Endpoint` extends AddressedWire, and return
+capabilities retain AddressedWire so the existing response/lifecycle path
+space, local identity, received context and closure rules remain intact.
+Carrier paths remain exact Unicode-scalar strings under unchanged `bitwire/1`;
+they do not imply support for arbitrary tree byte keys on that carrier.
+
+The following addressed-carrier examples use the **0.3 source names**. Older
+0.2.0 artifacts used `Wire` for the addressed interface; their release evidence
+does not validate the renamed declarations or full structural trees.
+
+`bitspark-bitwire` provides the shared relative-path AddressedWire contract as the Python
 module `bitwire`. It requires Python 3.11 or newer and has no runtime dependencies.
 The package contains typed declarations and supporting values; endpoint runtimes,
 carriers, codecs and routing helpers belong to implementations.
 
 ```python
-from bitwire import Message, Receiver, ReturnAddress, Wire
+from bitwire import Endpoint, Message, Receiver, ReturnAddress, AddressedWire
 
 
-def call(endpoint: Wire, replies: Wire) -> None:
+def call(endpoint: AddressedWire, replies: AddressedWire) -> None:
     endpoint.send(
         ["cells", "get"],
         Message(
@@ -39,20 +64,24 @@ def call(endpoint: Wire, replies: Wire) -> None:
     )
 
 
-def listen(endpoint: Wire):
+def listen(endpoint: Endpoint):
     def receive(path, message):
         print(path, message.frame)
 
-    return endpoint.receive([], Receiver(namespace=True, message=receive))
+    return endpoint.receive(Receiver(message=receive))
 ```
 
-`Wire` is a structural `Protocol`; implementations do not need to inherit from
-it. `send` accepts or refuses synchronously; the implementation schedules delivery.
-Receivers may return an awaitable. `receive` returns an idempotent detach function.
+`AddressedWire` is a send-only structural `Protocol`; implementations do not need to inherit
+from it. `send` accepts or refuses synchronously; the implementation schedules
+delivery. `Endpoint` extends it with `receive(receiver)` and `close`, keeping
+attachment and closure authority separate from send access. One receive attachment
+is allowed at a time; duplicates are refused. Receivers may return an awaitable.
+`receive` returns an idempotent detach function that cannot remove a replacement.
+Path matching belongs to routing compositions, not to these interfaces.
 Paths are sequences of opaque Unicode-scalar strings and retain empty segments.
-Receiver paths are relative to the Wire on which they registered.
+Receiver paths are relative to the attached endpoint.
 
-`ReturnAddress` uses object identity, including when its Wire cannot be compared
+`ReturnAddress` uses object identity, including when its AddressedWire cannot be compared
 or hashed. Preserve this object during routing. The return address is local
 capability data and must never be serialized into the profile envelope. Profile
 payloads must follow the JSON profile despite their Python `object` annotation.
@@ -60,7 +89,7 @@ Runtime-owned received context associated with the return identity must survive
 routing. Application-supplied context or metadata does not establish verified
 invocation context; that verification remains the runtime's responsibility.
 
-The [Wire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
+The [AddressedWire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
 and [profile boundary](https://github.com/Bitspark/bitwire/blob/main/docs/wire/profile.md)
 define the behavior. Runtime protocol checks verify only the presence of methods;
 they cannot establish conformance.
@@ -107,6 +136,6 @@ the workflow from `main`. Tokens are passed only to publication steps. Revoke th
 bootstrap token after trusted publishing is configured. The workflow verifies the
 packaged artifact before upload and installs the published PyPI package afterward.
 
-The binding is adapted from Nightseam's Python Wire declarations at commit
+The binding is adapted from Nightseam's Python AddressedWire declarations at commit
 [`1c63f1c4`](https://github.com/Bitspark/nightseam/blob/1c63f1c4d7e4b5987d4bd32e294177645c92ed8f/duplex/py/nightseam/duplex/wire.py)
 under Apache-2.0. See the included `LICENSE` and `NOTICE` files.

{bitspark_bitwire-0.1.0 → bitspark_bitwire-0.3.0}/README.md

@@ -1,15 +1,40 @@
 # Bitwire for Python
 
-`bitspark-bitwire` provides the shared relative-path Wire contract as the Python
+**Source contract: 0.3.0; publication pending.** `Wire` is the addressless
+primitive `send(message)`. `WireTree = DeixisNode<Wire>` provides the complete
+finite, acyclic structure: own value, complete byte-keyed children, partial
+selection and decomposition. Keys are exact arbitrary bytes, including empty
+and non-UTF-8 keys. Empty path selects self; a missing edge is distinct from a
+present refusing primitive. Recomposition preserves own and child identities.
+
+This is symmetric with Bitstore's `Data.read()` primitive and
+`DataTree = DeixisNode<Data>`. Derived sending selects the node and invokes its
+own Wire. Construction and derived operators belong in bitruntime; these
+packages publish declarations and criteria, not a production tree runtime.
+See [decision 0012](https://github.com/Bitspark/bitwire/blob/main/docs/decisions/0012-explicit-data-and-wire-trees.md)
+and the [migration guide](https://github.com/Bitspark/bitwire/blob/main/docs/migration-0.3.md).
+
+`AddressedWire` explicitly names the former `Wire.send(path, message)` surface.
+It is not a full WireTree. `Endpoint` extends AddressedWire, and return
+capabilities retain AddressedWire so the existing response/lifecycle path
+space, local identity, received context and closure rules remain intact.
+Carrier paths remain exact Unicode-scalar strings under unchanged `bitwire/1`;
+they do not imply support for arbitrary tree byte keys on that carrier.
+
+The following addressed-carrier examples use the **0.3 source names**. Older
+0.2.0 artifacts used `Wire` for the addressed interface; their release evidence
+does not validate the renamed declarations or full structural trees.
+
+`bitspark-bitwire` provides the shared relative-path AddressedWire contract as the Python
 module `bitwire`. It requires Python 3.11 or newer and has no runtime dependencies.
 The package contains typed declarations and supporting values; endpoint runtimes,
 carriers, codecs and routing helpers belong to implementations.
 
 ```python
-from bitwire import Message, Receiver, ReturnAddress, Wire
+from bitwire import Endpoint, Message, Receiver, ReturnAddress, AddressedWire
 
 
-def call(endpoint: Wire, replies: Wire) -> None:
+def call(endpoint: AddressedWire, replies: AddressedWire) -> None:
     endpoint.send(
         ["cells", "get"],
         Message(
@@ -19,20 +44,24 @@ def call(endpoint: Wire, replies: Wire) -> None:
     )
 
 
-def listen(endpoint: Wire):
+def listen(endpoint: Endpoint):
     def receive(path, message):
         print(path, message.frame)
 
-    return endpoint.receive([], Receiver(namespace=True, message=receive))
+    return endpoint.receive(Receiver(message=receive))
 ```
 
-`Wire` is a structural `Protocol`; implementations do not need to inherit from
-it. `send` accepts or refuses synchronously; the implementation schedules delivery.
-Receivers may return an awaitable. `receive` returns an idempotent detach function.
+`AddressedWire` is a send-only structural `Protocol`; implementations do not need to inherit
+from it. `send` accepts or refuses synchronously; the implementation schedules
+delivery. `Endpoint` extends it with `receive(receiver)` and `close`, keeping
+attachment and closure authority separate from send access. One receive attachment
+is allowed at a time; duplicates are refused. Receivers may return an awaitable.
+`receive` returns an idempotent detach function that cannot remove a replacement.
+Path matching belongs to routing compositions, not to these interfaces.
 Paths are sequences of opaque Unicode-scalar strings and retain empty segments.
-Receiver paths are relative to the Wire on which they registered.
+Receiver paths are relative to the attached endpoint.
 
-`ReturnAddress` uses object identity, including when its Wire cannot be compared
+`ReturnAddress` uses object identity, including when its AddressedWire cannot be compared
 or hashed. Preserve this object during routing. The return address is local
 capability data and must never be serialized into the profile envelope. Profile
 payloads must follow the JSON profile despite their Python `object` annotation.
@@ -40,7 +69,7 @@ Runtime-owned received context associated with the return identity must survive
 routing. Application-supplied context or metadata does not establish verified
 invocation context; that verification remains the runtime's responsibility.
 
-The [Wire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
+The [AddressedWire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
 and [profile boundary](https://github.com/Bitspark/bitwire/blob/main/docs/wire/profile.md)
 define the behavior. Runtime protocol checks verify only the presence of methods;
 they cannot establish conformance.
@@ -87,6 +116,6 @@ the workflow from `main`. Tokens are passed only to publication steps. Revoke th
 bootstrap token after trusted publishing is configured. The workflow verifies the
 packaged artifact before upload and installs the published PyPI package afterward.
 
-The binding is adapted from Nightseam's Python Wire declarations at commit
+The binding is adapted from Nightseam's Python AddressedWire declarations at commit
 [`1c63f1c4`](https://github.com/Bitspark/nightseam/blob/1c63f1c4d7e4b5987d4bd32e294177645c92ed8f/duplex/py/nightseam/duplex/wire.py)
 under Apache-2.0. See the included `LICENSE` and `NOTICE` files.

{bitspark_bitwire-0.1.0 → bitspark_bitwire-0.3.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bitspark-bitwire"
-version = "0.1.0"
-description = "The shared relative-path Wire contract for Python"
+version = "0.3.0"
+description = "Addressless Wire primitives, full WireTree structure and addressed carrier contracts for Python"
 readme = "README.md"
 requires-python = ">=3.11"
 license = "Apache-2.0"

{bitspark_bitwire-0.1.0 → bitspark_bitwire-0.3.0/src/bitspark_bitwire.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: bitspark-bitwire
-Version: 0.1.0
-Summary: The shared relative-path Wire contract for Python
+Version: 0.3.0
+Summary: Addressless Wire primitives, full WireTree structure and addressed carrier contracts for Python
 Author: Bitspark
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/Bitspark/bitwire
@@ -20,16 +20,41 @@ Dynamic: license-file
 
 # Bitwire for Python
 
-`bitspark-bitwire` provides the shared relative-path Wire contract as the Python
+**Source contract: 0.3.0; publication pending.** `Wire` is the addressless
+primitive `send(message)`. `WireTree = DeixisNode<Wire>` provides the complete
+finite, acyclic structure: own value, complete byte-keyed children, partial
+selection and decomposition. Keys are exact arbitrary bytes, including empty
+and non-UTF-8 keys. Empty path selects self; a missing edge is distinct from a
+present refusing primitive. Recomposition preserves own and child identities.
+
+This is symmetric with Bitstore's `Data.read()` primitive and
+`DataTree = DeixisNode<Data>`. Derived sending selects the node and invokes its
+own Wire. Construction and derived operators belong in bitruntime; these
+packages publish declarations and criteria, not a production tree runtime.
+See [decision 0012](https://github.com/Bitspark/bitwire/blob/main/docs/decisions/0012-explicit-data-and-wire-trees.md)
+and the [migration guide](https://github.com/Bitspark/bitwire/blob/main/docs/migration-0.3.md).
+
+`AddressedWire` explicitly names the former `Wire.send(path, message)` surface.
+It is not a full WireTree. `Endpoint` extends AddressedWire, and return
+capabilities retain AddressedWire so the existing response/lifecycle path
+space, local identity, received context and closure rules remain intact.
+Carrier paths remain exact Unicode-scalar strings under unchanged `bitwire/1`;
+they do not imply support for arbitrary tree byte keys on that carrier.
+
+The following addressed-carrier examples use the **0.3 source names**. Older
+0.2.0 artifacts used `Wire` for the addressed interface; their release evidence
+does not validate the renamed declarations or full structural trees.
+
+`bitspark-bitwire` provides the shared relative-path AddressedWire contract as the Python
 module `bitwire`. It requires Python 3.11 or newer and has no runtime dependencies.
 The package contains typed declarations and supporting values; endpoint runtimes,
 carriers, codecs and routing helpers belong to implementations.
 
 ```python
-from bitwire import Message, Receiver, ReturnAddress, Wire
+from bitwire import Endpoint, Message, Receiver, ReturnAddress, AddressedWire
 
 
-def call(endpoint: Wire, replies: Wire) -> None:
+def call(endpoint: AddressedWire, replies: AddressedWire) -> None:
     endpoint.send(
         ["cells", "get"],
         Message(
@@ -39,20 +64,24 @@ def call(endpoint: Wire, replies: Wire) -> None:
     )
 
 
-def listen(endpoint: Wire):
+def listen(endpoint: Endpoint):
     def receive(path, message):
         print(path, message.frame)
 
-    return endpoint.receive([], Receiver(namespace=True, message=receive))
+    return endpoint.receive(Receiver(message=receive))
 ```
 
-`Wire` is a structural `Protocol`; implementations do not need to inherit from
-it. `send` accepts or refuses synchronously; the implementation schedules delivery.
-Receivers may return an awaitable. `receive` returns an idempotent detach function.
+`AddressedWire` is a send-only structural `Protocol`; implementations do not need to inherit
+from it. `send` accepts or refuses synchronously; the implementation schedules
+delivery. `Endpoint` extends it with `receive(receiver)` and `close`, keeping
+attachment and closure authority separate from send access. One receive attachment
+is allowed at a time; duplicates are refused. Receivers may return an awaitable.
+`receive` returns an idempotent detach function that cannot remove a replacement.
+Path matching belongs to routing compositions, not to these interfaces.
 Paths are sequences of opaque Unicode-scalar strings and retain empty segments.
-Receiver paths are relative to the Wire on which they registered.
+Receiver paths are relative to the attached endpoint.
 
-`ReturnAddress` uses object identity, including when its Wire cannot be compared
+`ReturnAddress` uses object identity, including when its AddressedWire cannot be compared
 or hashed. Preserve this object during routing. The return address is local
 capability data and must never be serialized into the profile envelope. Profile
 payloads must follow the JSON profile despite their Python `object` annotation.
@@ -60,7 +89,7 @@ Runtime-owned received context associated with the return identity must survive
 routing. Application-supplied context or metadata does not establish verified
 invocation context; that verification remains the runtime's responsibility.
 
-The [Wire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
+The [AddressedWire contract](https://github.com/Bitspark/bitwire/blob/main/docs/wire/contract.md)
 and [profile boundary](https://github.com/Bitspark/bitwire/blob/main/docs/wire/profile.md)
 define the behavior. Runtime protocol checks verify only the presence of methods;
 they cannot establish conformance.
@@ -107,6 +136,6 @@ the workflow from `main`. Tokens are passed only to publication steps. Revoke th
 bootstrap token after trusted publishing is configured. The workflow verifies the
 packaged artifact before upload and installs the published PyPI package afterward.
 
-The binding is adapted from Nightseam's Python Wire declarations at commit
+The binding is adapted from Nightseam's Python AddressedWire declarations at commit
 [`1c63f1c4`](https://github.com/Bitspark/nightseam/blob/1c63f1c4d7e4b5987d4bd32e294177645c92ed8f/duplex/py/nightseam/duplex/wire.py)
 under Apache-2.0. See the included `LICENSE` and `NOTICE` files.

{bitspark_bitwire-0.1.0 → bitspark_bitwire-0.3.0}/src/bitspark_bitwire.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ src/bitspark_bitwire.egg-info/top_level.txt
 src/bitwire/__init__.py
 src/bitwire/py.typed
 tests/test_consumer.py
+tests/test_tree.py
 tests/typecheck.py

{bitspark_bitwire-0.1.0 → bitspark_bitwire-0.3.0}/src/bitwire/__init__.py

@@ -1,4 +1,4 @@
-"""The shared relative-path Wire contract, without a runtime dependency.
+"""Addressless Wire, complete WireTree structure, and addressed compatibility.
 
 Adapted from Nightseam's duplex/py/nightseam/duplex/wire.py at
 1c63f1c4d7e4b5987d4bd32e294177645c92ed8f under Apache-2.0.
@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from collections.abc import Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
-from typing import Literal, NotRequired, Protocol, TypedDict, runtime_checkable
+from typing import Literal, NotRequired, Protocol, TypeAlias, TypeVar, TypedDict, runtime_checkable
 
 __all__ = [
     "Path",
@@ -24,11 +24,21 @@ __all__ = [
     "ReturnAddress",
     "Message",
     "Receiver",
+    "AddressedWire",
     "Wire",
+    "Key",
+    "TreePath",
+    "DeixisNode",
+    "WireTree",
+    "Endpoint",
 ]
 
 # Opaque Unicode-scalar segments: [] != [""] != ["a/b"] != ["a", "b"].
 Path = Sequence[str]
+# Structural keys admit every byte string, without Unicode conversion.
+Key = bytes
+TreePath = Sequence[Key]
+T_co = TypeVar("T_co", covariant=True)
 ProfileKind = Literal["request", "response", "event", "cancel"]
 
 
@@ -87,14 +97,14 @@ ProfileFrame = RequestFrame | ResultFrame | ErrorFrame | EventFrame | CancelFram
 class ReturnAddress:
     """Local capability with identity equality, never a network-envelope member.
 
-    Different addresses stay distinct even when they hold the same Wire. The
+    Different addresses stay distinct even when they hold the same AddressedWire. The
     wrapped implementation need not support equality or hashing. Routing must
     preserve this address object, rather than construct an equivalent wrapper.
     Runtime-owned received context associated with this identity must survive
     routing; application payloads are not evidence of verified context.
     """
 
-    wire: Wire
+    wire: AddressedWire
 
 
 @dataclass(frozen=True)
@@ -111,30 +121,72 @@ class Message:
 
 @dataclass(frozen=True)
 class Receiver:
-    """Callbacks receive paths relative to the Wire on which they registered.
+    """Callbacks receive every path relative to their attached endpoint.
 
-    Exact routes win, then the longest namespace segment prefix wins. A receiver
-    may be synchronous or awaitable; endpoint implementations own dispatch.
+    A receiver may be synchronous or awaitable; endpoints own dispatch.
     """
 
-    namespace: bool = False
     message: Callable[[Path, Message], None | Awaitable[None]] | None = None
     closed: Callable[[int, str], None] | None = None
 
 
 @runtime_checkable
 class Wire(Protocol):
-    """Access to an origin with synchronous admission and asynchronous dispatch.
+    """Addressless send access: admission or refusal, never handler completion.
+
+    No path, receive attachment or closure authority belongs to this primitive.
+    Tree selection followed by own().send(message) supplies structured interaction.
+    """
+
+    def send(self, message: Message) -> None: ...
+
+
+class DeixisNode(Protocol[T_co]):
+    """A complete finite acyclic structure with an own value at every node.
+
+    Children contain every unique exact byte key, including empty keys. An empty
+    path selects this node; a missing child returns None, never the parent's own
+    value. Decomposition retains the same own value and complete children.
+    Implementations preserve structure and payload identity. Constructors and
+    derived operations belong to runtimes, not this declaration package.
+    """
+
+    def own(self) -> T_co: ...
+
+    def children(self) -> Sequence[tuple[Key, DeixisNode[T_co]]]: ...
+
+    def at(self, path: TreePath) -> DeixisNode[T_co] | None: ...
+
+    def decompose(self) -> tuple[T_co, Sequence[tuple[Key, DeixisNode[T_co]]]]: ...
+
+
+WireTree: TypeAlias = DeixisNode[Wire]
+
+
+@runtime_checkable
+class AddressedWire(Protocol):
+    """Compatibility access for the unchanged addressed bitwire/1 profile.
 
     send returns on acceptance or raises on refusal, without running destination
-    application code on the sender's stack. receive refuses duplicate paths and
-    returns an idempotent detach. A root owns dispatch, bounds and closure; a
-    selected view shares that closure, while a mount owns only its registrations
-    and routing. Structural protocol matching alone does not prove these laws.
+    application code on the sender's stack. It grants no receiving or closure
+    authority. Structural protocol matching alone does not prove these laws.
     """
 
     def send(self, path: Path, message: Message) -> None: ...
 
-    def receive(self, path: Path, receiver: Receiver) -> Callable[[], None]: ...
+
+@runtime_checkable
+class Endpoint(AddressedWire, Protocol):
+    """Owning endpoint access with one receive attachment and endpoint closure.
+
+    receive refuses a second active attachment or a closed endpoint and returns
+    an idempotent detach. A stale detach cannot remove a later attachment. Callbacks receive the complete
+    message and its relative path; routing policy belongs above this boundary.
+    Detach preserves captured return access and does not close the endpoint.
+    Closing notifies the active receiver once; detached receivers are not notified.
+    Closing twice has no additional effect and does not release live bindings.
+    """
+
+    def receive(self, receiver: Receiver) -> Callable[[], None]: ...
 
     def close(self, code: int = 1000, reason: str = "") -> None: ...

{bitspark_bitwire-0.1.0 → bitspark_bitwire-0.3.0}/tests/test_consumer.py

@@ -7,7 +7,7 @@ import inspect
 import unittest
 from collections.abc import Callable
 
-from bitwire import Message, Path, Receiver, ReturnAddress, Wire
+from bitwire import Endpoint, Message, Path, Receiver, ReturnAddress, AddressedWire
 
 
 class RecordingEndpoint:
@@ -15,38 +15,53 @@ class RecordingEndpoint:
 
     def __init__(self) -> None:
         self.sent: list[tuple[tuple[str, ...], Message]] = []
-        self.receivers: dict[tuple[str, ...], Receiver] = {}
+        self.receiver: Receiver | None = None
+        self.attachment: object | None = None
         self.ending: tuple[int, str] | None = None
 
     def __eq__(self, other: object) -> bool:
-        raise AssertionError("ReturnAddress must not compare the wrapped Wire")
+        raise AssertionError("ReturnAddress must not compare the wrapped AddressedWire")
 
     def send(self, path: Path, message: Message) -> None:
         self.sent.append((tuple(path), message))
 
-    def receive(self, path: Path, receiver: Receiver) -> Callable[[], None]:
-        key = tuple(path)
-        self.receivers[key] = receiver
+    def receive(self, receiver: Receiver) -> Callable[[], None]:
+        if self.ending is not None:
+            raise RuntimeError("endpoint closed")
+        if self.receiver is not None:
+            raise RuntimeError("receiver already attached")
+        token = object()
+        self.receiver = receiver
+        self.attachment = token
 
         def detach() -> None:
-            self.receivers.pop(key, None)
+            if self.attachment is token:
+                self.receiver = None
+                self.attachment = None
 
         return detach
 
     def close(self, code: int = 1000, reason: str = "") -> None:
+        if self.ending is not None:
+            return
         self.ending = (code, reason)
+        receiver = self.receiver
+        self.receiver = None
+        self.attachment = None
+        if receiver is not None and receiver.closed is not None:
+            receiver.closed(code, reason)
 
 
 class ConsumerTests(unittest.TestCase):
     def test_structural_consumer_keeps_path_frame_and_return_object(self) -> None:
         endpoint = RecordingEndpoint()
-        wire: Wire = endpoint
+        wire: AddressedWire = endpoint
         replies = ReturnAddress(RecordingEndpoint())
         request = Message(
             {"version": 1, "kind": "request", "id": "r1", "params": {"count": 2**80}},
             replies,
         )
-        self.assertIsInstance(endpoint, Wire)
+        self.assertIsInstance(endpoint, AddressedWire)
         for path in ([], [""], ["a/b"], ["a", "b"], ["\u03bb", "\U0001f30d"]):
             wire.send(path, request)
 
@@ -72,14 +87,13 @@ class ConsumerTests(unittest.TestCase):
             await asyncio.sleep(0)
             observed.append((tuple(path), message))
 
-        receiver = Receiver(namespace=True, message=delivered)
-        detach = endpoint.receive(["reply"], receiver)
+        receiver = Receiver(message=delivered)
+        detach = endpoint.receive(receiver)
         request = Message({"version": 1, "kind": "event", "data": None})
 
         async def dispatch() -> None:
-            registered = endpoint.receivers[("reply",)]
-            self.assertTrue(registered.namespace)
-            assert registered.message is not None
+            registered = endpoint.receiver
+            assert registered is not None and registered.message is not None
             result = registered.message(["reply", ""], request)
             if inspect.isawaitable(result):
                 await result
@@ -88,9 +102,47 @@ class ConsumerTests(unittest.TestCase):
         self.assertEqual(observed, [(("reply", ""), request)])
         detach()
         detach()
-        self.assertEqual(endpoint.receivers, {})
+        self.assertIsNone(endpoint.receiver)
         self.assertIsNone(endpoint.ending)
 
+    def test_attachment_ownership_and_stale_detach(self) -> None:
+        endpoint: Endpoint = RecordingEndpoint()
+        first = Receiver()
+        detach = endpoint.receive(first)
+        with self.assertRaises(RuntimeError):
+            endpoint.receive(first)
+        detach()
+        second = Receiver()
+        second_detach = endpoint.receive(second)
+        detach()
+        assert isinstance(endpoint, RecordingEndpoint)
+        self.assertIs(endpoint.receiver, second)
+        second_detach()
+        self.assertIsNone(endpoint.receiver)
+
+    def test_close_notifies_only_active_attachment_once(self) -> None:
+        endpoint = RecordingEndpoint()
+        endings: list[tuple[int, str]] = []
+        detached: list[tuple[int, str]] = []
+        endpoint.receive(Receiver(closed=lambda c, r: detached.append((c, r))))()
+        endpoint.receive(Receiver(closed=lambda c, r: endings.append((c, r))))
+        endpoint.close(1000, "done")
+        endpoint.close(1001, "again")
+        self.assertEqual(endings, [(1000, "done")])
+        self.assertEqual(detached, [])
+        with self.assertRaises(RuntimeError):
+            endpoint.receive(Receiver())
+
+    def test_send_only_wire_requires_no_endpoint_control(self) -> None:
+        class Access:
+            def send(self, path: Path, message: Message) -> None:
+                pass
+
+        access: AddressedWire = Access()
+        self.assertIsInstance(access, AddressedWire)
+        self.assertNotIsInstance(access, Endpoint)
+        self.assertIs(ReturnAddress(access).wire, access)
+
     def test_closed_callback_is_independent_from_message_callback(self) -> None:
         endings: list[tuple[int, str]] = []
         receiver = Receiver(closed=lambda code, reason: endings.append((code, reason)))
@@ -98,7 +150,7 @@ class ConsumerTests(unittest.TestCase):
         receiver.closed(1000, "complete")
         self.assertEqual(endings, [(1000, "complete")])
         self.assertIsNone(receiver.message)
-        self.assertFalse(receiver.namespace)
+
 
 
 if __name__ == "__main__":

bitspark_bitwire-0.3.0/tests/test_tree.py

@@ -0,0 +1,85 @@
+"""Independent finite structural fixture; no production tree implementation."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+import unittest
+
+from bitwire import DeixisNode, Key, Message, TreePath, Wire, WireTree
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class Node(Generic[T]):
+    value: T
+    entries: tuple[tuple[Key, DeixisNode[T]], ...] = ()
+
+    def own(self) -> T:
+        return self.value
+
+    def children(self) -> Sequence[tuple[Key, DeixisNode[T]]]:
+        return self.entries
+
+    def at(self, path: TreePath) -> DeixisNode[T] | None:
+        node: DeixisNode[T] = self
+        for key in path:
+            child = next((child for name, child in node.children() if name == key), None)
+            if child is None:
+                return None
+            node = child
+        return node
+
+    def decompose(self) -> tuple[T, Sequence[tuple[Key, DeixisNode[T]]]]:
+        return self.value, self.entries
+
+
+class RefusingWire:
+    def send(self, message: Message) -> None:
+        raise RuntimeError("refused")
+
+
+class RecordingWire:
+    def __init__(self) -> None:
+        self.messages: list[Message] = []
+
+    def send(self, message: Message) -> None:
+        self.messages.append(message)
+
+
+class TreeTests(unittest.TestCase):
+    def test_complete_structure_preserves_binary_empty_and_missing_keys(self) -> None:
+        child: WireTree = Node[Wire](RefusingWire())
+        binary: WireTree = Node[Wire](RefusingWire())
+        tree: WireTree = Node[Wire](RefusingWire(), ((b"", child), (b"\xff\x00", binary)))
+        self.assertIs(tree.at([]), tree)
+        self.assertIs(tree.at([b""]), child)
+        self.assertIs(tree.at([b"\xff\x00"]), binary)
+        self.assertIsNone(tree.at([b"missing"]))
+        self.assertIsNone(tree.at([b"", b""]))
+        self.assertEqual([key for key, _ in tree.children()], [b"", b"\xff\x00"])
+        value, children = tree.decompose()
+        self.assertIs(value, tree.own())
+        rebuilt: WireTree = Node[Wire](value, tuple(children))
+        self.assertIs(rebuilt.at([b""]), child)
+        with self.assertRaisesRegex(RuntimeError, "refused"):
+            child.own().send(Message({"version": 1, "kind": "event", "data": None}))
+        # A present refusing leaf is still observable, unlike a missing child.
+        self.assertEqual(child.children(), ())
+
+    def test_selected_send_is_own_send_and_retains_message_identity(self) -> None:
+        root = RecordingWire()
+        destination = RecordingWire()
+        tree: WireTree = Node[Wire](root, ((b"route", Node[Wire](destination)),))
+        message = Message({"version": 1, "kind": "event", "data": {"value": 1}})
+        selected = tree.at([b"route"])
+        assert selected is not None
+        selected.own().send(message)
+        self.assertEqual(root.messages, [])
+        self.assertIs(destination.messages[0], message)
+
+
+if __name__ == "__main__":
+    unittest.main()

{bitspark_bitwire-0.1.0 → bitspark_bitwire-0.3.0}/tests/typecheck.py

@@ -5,6 +5,7 @@ from typing import assert_type
 from bitwire import (
     CancelFrame,
     ErrorFrame,
+    Endpoint,
     EventFrame,
     Message,
     Path,
@@ -14,14 +15,16 @@ from bitwire import (
     RequestFrame,
     ResultFrame,
     ReturnAddress,
+    AddressedWire,
     Wire,
+    WireTree,
 )
 
 
-def consume(wire: Wire, frame: ProfileFrame) -> None:
+def consume(wire: AddressedWire, endpoint: Endpoint, frame: ProfileFrame) -> None:
     address = ReturnAddress(wire)
     wire.send(["scope", ""], Message(frame, address))
-    assert_type(address.wire, Wire)
+    assert_type(address.wire, AddressedWire)
     kind: ProfileKind = frame["kind"]
     assert_type(kind, ProfileKind)
     if frame["kind"] == "request":
@@ -30,10 +33,28 @@ def consume(wire: Wire, frame: ProfileFrame) -> None:
     async def delivered(path: Path, message: Message) -> None:
         assert_type(message.return_address, ReturnAddress | None)
 
-    wire.receive([], Receiver(namespace=True, message=delivered))()
+    endpoint.receive(Receiver(message=delivered))()
+    wire.receive(Receiver())  # type: ignore[attr-defined]
+    wire.close()  # type: ignore[attr-defined]
     wire.send([42], Message(frame))  # type: ignore[list-item]
 
 
+def consume_tree(tree: WireTree, primitive: Wire, message: Message) -> None:
+    primitive.send(message)
+    assert_type(tree.own(), Wire)
+    selected = tree.at([b"", b"\xff\x00"])
+    if selected is not None:
+        selected.own().send(message)
+    own, children = tree.decompose()
+    assert_type(own, Wire)
+    for key, child in children:
+        assert_type(key, bytes)
+        assert_type(child, WireTree)
+    primitive.send([], message)  # type: ignore[call-arg,arg-type]
+    tree.at(["text"])  # type: ignore[list-item]
+    ReturnAddress(primitive)  # type: ignore[arg-type]
+
+
 request: RequestFrame = {"version": 1, "kind": "request", "id": "1", "params": {}}
 result: ResultFrame = {"version": 1, "kind": "response", "id": "1", "result": None}
 error: ErrorFrame = {"version": 1, "kind": "response", "id": "1", "error": {"code": "no", "message": "No"}}