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

{bitspark_bitwire-0.2.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.2.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 Endpoint, 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(
@@ -46,7 +71,7 @@ def listen(endpoint: Endpoint):
     return endpoint.receive(Receiver(message=receive))
 ```
 
-`Wire` is a send-only structural `Protocol`; implementations do not need to inherit
+`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
@@ -56,7 +81,7 @@ 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 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.
@@ -64,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.
@@ -111,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.2.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 Endpoint, 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(
@@ -26,7 +51,7 @@ def listen(endpoint: Endpoint):
     return endpoint.receive(Receiver(message=receive))
 ```
 
-`Wire` is a send-only structural `Protocol`; implementations do not need to inherit
+`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
@@ -36,7 +61,7 @@ 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 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.
@@ -44,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.
@@ -91,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.2.0 → bitspark_bitwire-0.3.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bitspark-bitwire"
-version = "0.2.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.2.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.2.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 Endpoint, 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(
@@ -46,7 +71,7 @@ def listen(endpoint: Endpoint):
     return endpoint.receive(Receiver(message=receive))
 ```
 
-`Wire` is a send-only structural `Protocol`; implementations do not need to inherit
+`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
@@ -56,7 +81,7 @@ 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 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.
@@ -64,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.
@@ -111,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.2.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.2.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,12 +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"]
 
 
@@ -88,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)
@@ -123,7 +132,40 @@ class Receiver:
 
 @runtime_checkable
 class Wire(Protocol):
-    """Send-only access 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. It grants no receiving or closure
@@ -134,7 +176,7 @@ class Wire(Protocol):
 
 
 @runtime_checkable
-class Endpoint(Wire, Protocol):
+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

{bitspark_bitwire-0.2.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 Endpoint, Message, Path, Receiver, ReturnAddress, Wire
+from bitwire import Endpoint, Message, Path, Receiver, ReturnAddress, AddressedWire
 
 
 class RecordingEndpoint:
@@ -20,7 +20,7 @@ class RecordingEndpoint:
         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))
@@ -55,13 +55,13 @@ class RecordingEndpoint:
 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)
 
@@ -138,8 +138,8 @@ class ConsumerTests(unittest.TestCase):
             def send(self, path: Path, message: Message) -> None:
                 pass
 
-        access: Wire = Access()
-        self.assertIsInstance(access, Wire)
+        access: AddressedWire = Access()
+        self.assertIsInstance(access, AddressedWire)
         self.assertNotIsInstance(access, Endpoint)
         self.assertIs(ReturnAddress(access).wire, access)
 

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.2.0 → bitspark_bitwire-0.3.0}/tests/typecheck.py

@@ -15,14 +15,16 @@ from bitwire import (
     RequestFrame,
     ResultFrame,
     ReturnAddress,
+    AddressedWire,
     Wire,
+    WireTree,
 )
 
 
-def consume(wire: Wire, endpoint: Endpoint, 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":
@@ -37,6 +39,22 @@ def consume(wire: Wire, endpoint: Endpoint, frame: ProfileFrame) -> None:
     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"}}