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

bitspark_bitwire-0.5.0/NOTICE

@@ -0,0 +1,9 @@
+bitwire
+Copyright 2026 Bitspark and contributors
+
+This product includes software developed at Bitspark. The current generic wire
+contract is original work. It includes a checked consumer mirror of ontos v0.9.0
+from 5eed85de5697f53397407f9f82f3b310648827f7: frozen L0 values, canonical codec
+and optional data embeddings. ontos/manifest.json records exact source provenance
+and import adaptations. The prior declarations and drivers derived from nightseam
+were removed; their provenance and immutable releases remain in Git history.

bitspark_bitwire-0.5.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: bitspark-bitwire
+Version: 0.5.0
+Summary: Addressless wires and addressed access over ontos values
+Author: Bitspark
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Bitspark/bitwire
+Project-URL: Documentation, https://github.com/Bitspark/bitwire/tree/main/docs
+Project-URL: Repository, https://github.com/Bitspark/bitwire
+Project-URL: Issues, https://github.com/Bitspark/bitwire/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+# py wire presentation
+
+Addressless Wire sends a ground ontos value. Endpoint adds receive ownership and
+closure. AddressedWire adds an exact byte-path argument; AddressedEndpoint carries
+that layer over one endpoint. WireNode is the complete deixis structure over Wire
+values (a nominal interface in Java), not opaque route access.
+
+See the repository's docs/wire/contract.md and docs/wire/carriers.md. Version 0.5.0
+is a clean breaking replacement; compilation and packaged consumers check the
+native surface, while bitruntime supplies independently tested implementations.

bitspark_bitwire-0.5.0/README.md

@@ -0,0 +1,10 @@
+# py wire presentation
+
+Addressless Wire sends a ground ontos value. Endpoint adds receive ownership and
+closure. AddressedWire adds an exact byte-path argument; AddressedEndpoint carries
+that layer over one endpoint. WireNode is the complete deixis structure over Wire
+values (a nominal interface in Java), not opaque route access.
+
+See the repository's docs/wire/contract.md and docs/wire/carriers.md. Version 0.5.0
+is a clean breaking replacement; compilation and packaged consumers check the
+native surface, while bitruntime supplies independently tested implementations.

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

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bitspark-bitwire"
-version = "0.3.0"
-description = "Addressless Wire primitives, full WireTree structure and addressed carrier contracts for Python"
+version = "0.5.0"
+description = "Addressless wires and addressed access over ontos values"
 readme = "README.md"
 requires-python = ">=3.11"
 license = "Apache-2.0"

bitspark_bitwire-0.5.0/src/bitspark_bitwire.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: bitspark-bitwire
+Version: 0.5.0
+Summary: Addressless wires and addressed access over ontos values
+Author: Bitspark
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Bitspark/bitwire
+Project-URL: Documentation, https://github.com/Bitspark/bitwire/tree/main/docs
+Project-URL: Repository, https://github.com/Bitspark/bitwire
+Project-URL: Issues, https://github.com/Bitspark/bitwire/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+# py wire presentation
+
+Addressless Wire sends a ground ontos value. Endpoint adds receive ownership and
+closure. AddressedWire adds an exact byte-path argument; AddressedEndpoint carries
+that layer over one endpoint. WireNode is the complete deixis structure over Wire
+values (a nominal interface in Java), not opaque route access.
+
+See the repository's docs/wire/contract.md and docs/wire/carriers.md. Version 0.5.0
+is a clean breaking replacement; compilation and packaged consumers check the
+native surface, while bitruntime supplies independently tested implementations.

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

@@ -10,7 +10,7 @@ src/bitspark_bitwire.egg-info/SOURCES.txt
 src/bitspark_bitwire.egg-info/dependency_links.txt
 src/bitspark_bitwire.egg-info/top_level.txt
 src/bitwire/__init__.py
+src/bitwire/ontos.py
 src/bitwire/py.typed
 tests/test_consumer.py
-tests/test_tree.py
 tests/typecheck.py

bitspark_bitwire-0.5.0/src/bitwire/__init__.py

@@ -0,0 +1,35 @@
+"""Addressless interaction, addressed access and complete structure."""
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Callable, Protocol, TypeVar, Generic
+from .ontos import Atom, Tuple, Value, atom, tuple_, equals
+Path = tuple[Atom, ...]
+@dataclass(frozen=True)
+class Termination:
+    kind: str
+    message: str | None = None
+class Wire(Protocol):
+    async def send(self, message: Value) -> None: ...
+class Endpoint(Wire, Protocol):
+    def receive(self, handler: Callable[[Value], None]) -> Callable[[], None]: ...
+    async def closed(self) -> Termination: ...
+    async def close(self) -> None: ...
+class AddressedWire(Protocol):
+    async def send(self, path: Path, message: Value) -> None: ...
+class AddressedEndpoint(AddressedWire, Protocol):
+    def receive(self, handler: Callable[[Path, Value], None]) -> Callable[[], None]: ...
+    async def closed(self) -> Termination: ...
+    async def close(self) -> None: ...
+T = TypeVar('T')
+@dataclass(frozen=True)
+class Parts(Generic[T]):
+    own: T
+    children: tuple[tuple[Atom, DeixisNode[T]], ...]
+class DeixisNode(Protocol[T]):
+    def own(self) -> T: ...
+    def children(self) -> tuple[tuple[Atom, DeixisNode[T]], ...]: ...
+    def at(self, path: Path) -> DeixisNode[T] | None: ...
+    def decompose(self) -> Parts[T]: ...
+WireNode = DeixisNode[Wire]
+__all__ = ['Atom', 'Tuple', 'Value', 'atom', 'tuple_', 'equals', 'Path', 'Termination',
+           'Wire', 'Endpoint', 'AddressedWire', 'AddressedEndpoint', 'WireNode', 'Parts', 'DeixisNode']

bitspark_bitwire-0.5.0/src/bitwire/ontos.py

@@ -0,0 +1,219 @@
+"""ontos/core (L0) — the frozen value model.
+
+    Bytes = finite octet strings
+    Value = Atom(bytes) | Tuple(Value*)
+
+A value is finite, immutable, well-founded (a finite tree, never cyclic),
+uninterpreted, and compared by structural identity. This module defines what a
+value is and when two values are the same — nothing else. There is no byte
+encoding here (that is ``ontos_codec``) and no interpretation of atoms or shapes.
+See docs/spec/ontos-core.md.
+
+This is the Python peer of the go/rs/ts cores (ontos #60). It exists to
+empirically validate the conformance protocol: it implements the same contract
+and registers as a fourth ``--impl`` in the differential harness with no protocol
+change. It is a validation lane, **not** a published/substrate lane.
+
+Common Value API (all four cores)
+---------------------------------
+The Go, Rust, TypeScript, and Python cores expose the same conceptual surface so
+a developer who learns one can predict the others. Every core provides, by its
+own naming convention:
+
+- Construct — ``atom(bytes)`` / ``tuple_(items)`` (Go ``NewAtom``/``NewTuple``,
+  Rust ``Value::atom``/``tuple``, TS ``atom``/``tuple``).
+- Atom bytes + length — ``Atom.bytes()`` and ``len(atom)``.
+- Tuple children + arity + indexed access — ``Tuple.items()``, ``len(tuple)``,
+  and ``Tuple.at(i)``.
+- Structural equality — ``==`` (``__eq__``) and the module-level ``equals``.
+- Diagnostic string — ``str(value)`` (Go ``String``, Rust ``Display``, TS
+  ``toString``); **not** a canonical encoding.
+
+Intentional per-language extras
+--------------------------------
+Python exposes ``is_atom``/``is_tuple`` (idiomatic ``isinstance`` shorthands) and
+hashability (``__hash__``) so values can be dict keys / set members in Python
+code. These are binding conveniences; they confer no new identity (``__hash__`` is
+consistent with structural ``__eq__``) and no canonical form.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Union
+
+__all__ = [
+    "Value",
+    "Atom",
+    "Tuple",
+    "atom",
+    "tuple_",
+    "is_value",
+    "equals",
+]
+
+
+class Value:
+    """The abstract base of the two value constructors: ``Atom`` and ``Tuple``.
+
+    ``Value`` itself is never instantiated; it exists only so ``isinstance(v,
+    Value)`` and type hints have a single nominal type. The value set is closed:
+    every value is exactly one of ``Atom`` or ``Tuple`` (ontos-core §1).
+    """
+
+    __slots__ = ()
+
+
+class Atom(Value):
+    """An opaque byte atom. The bytes have no built-in interpretation.
+
+    The bytes are copied and stored immutably; ``bytes()`` returns them as an
+    (immutable) ``bytes`` object, so a caller can never mutate the atom.
+    """
+
+    __slots__ = ("_bytes",)
+
+    def __init__(self, data: Union[bytes, bytearray, Iterable[int]] = b"") -> None:
+        # bytes(...) copies and validates that every element is a 0..255 int, so
+        # an out-of-range or non-int element raises ValueError/TypeError here —
+        # exactly the "an atom carries octets" invariant (ontos-core §1).
+        object.__setattr__(self, "_bytes", bytes(data))
+
+    def __setattr__(self, name: str, value: object) -> None:  # pragma: no cover
+        raise AttributeError("ontos values are immutable")
+
+    def __delattr__(self, name: str) -> None:  # pragma: no cover
+        raise AttributeError("ontos values are immutable")
+
+    def bytes(self) -> bytes:
+        """Return the atom's octets. ``bytes`` is itself immutable in Python."""
+        return self._bytes
+
+    def __len__(self) -> int:
+        """The atom's byte length (the analog of TS ``Atom#length``)."""
+        return len(self._bytes)
+
+    @property
+    def is_atom(self) -> bool:
+        return True
+
+    @property
+    def is_tuple(self) -> bool:
+        return False
+
+    def __eq__(self, other: object) -> bool:
+        # Atom(b) = Atom(c) iff b and c are the same octet string; Atom != Tuple
+        # always (ontos-core §3). NotImplemented lets Python try the reflected op
+        # for unrelated types rather than declaring inequality prematurely.
+        if isinstance(other, Atom):
+            return self._bytes == other._bytes
+        if isinstance(other, Tuple):
+            return False
+        return NotImplemented
+
+    def __ne__(self, other: object) -> bool:
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return result
+        return not result
+
+    def __hash__(self) -> int:
+        # Tagged so an Atom and a Tuple with related structure never share a hash
+        # bucket by accident; consistent with __eq__ (equal atoms hash equal).
+        return hash(("atom", self._bytes))
+
+    def __str__(self) -> str:
+        return f"Atom(0x{self._bytes.hex()})"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class Tuple(Value):
+    """A finite ordered tuple of values. Arity, order, and multiplicity matter.
+
+    Children are validated to be ``Value`` instances and stored in an immutable
+    builtin tuple, so a ``Tuple`` cannot be mutated and cannot hold a non-value.
+    """
+
+    __slots__ = ("_items",)
+
+    def __init__(self, items: Iterable[Value] = ()) -> None:
+        copied = tuple(items)
+        for item in copied:
+            if not isinstance(item, Value):
+                raise TypeError("expected an ontos Value as a tuple child")
+        object.__setattr__(self, "_items", copied)
+
+    def __setattr__(self, name: str, value: object) -> None:  # pragma: no cover
+        raise AttributeError("ontos values are immutable")
+
+    def __delattr__(self, name: str) -> None:  # pragma: no cover
+        raise AttributeError("ontos values are immutable")
+
+    def items(self) -> tuple:
+        """Return the children as an immutable builtin tuple of ``Value``."""
+        return self._items
+
+    def at(self, index: int) -> Value:
+        """The child at ``index`` (Go ``Tuple.At`` / Rust ``Tuple::at``)."""
+        return self._items[index]
+
+    def __len__(self) -> int:
+        """The arity (number of children)."""
+        return len(self._items)
+
+    @property
+    def is_atom(self) -> bool:
+        return False
+
+    @property
+    def is_tuple(self) -> bool:
+        return True
+
+    def __eq__(self, other: object) -> bool:
+        # Tuple(xs) = Tuple(ys) iff same arity and xs[i] = ys[i] recursively;
+        # Tuple != Atom always (ontos-core §3).
+        if isinstance(other, Tuple):
+            return self._items == other._items
+        if isinstance(other, Atom):
+            return False
+        return NotImplemented
+
+    def __ne__(self, other: object) -> bool:
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return result
+        return not result
+
+    def __hash__(self) -> int:
+        return hash(("tuple", self._items))
+
+    def __str__(self) -> str:
+        return "Tuple(" + ", ".join(str(item) for item in self._items) + ")"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+def atom(data: Union[bytes, bytearray, Iterable[int]] = b"") -> Atom:
+    """Construct an ``Atom`` from bytes (or an iterable of 0..255 ints)."""
+    return Atom(data)
+
+
+def tuple_(items: Iterable[Value] = ()) -> Tuple:
+    """Construct a ``Tuple`` from an iterable of values.
+
+    Named ``tuple_`` (trailing underscore) so it does not shadow the builtin
+    ``tuple``; the type is exported as ``Tuple``.
+    """
+    return Tuple(items)
+
+
+def is_value(value: object) -> bool:
+    """Whether ``value`` is an ontos ``Value`` (an ``Atom`` or a ``Tuple``)."""
+    return isinstance(value, (Atom, Tuple))
+
+
+def equals(left: Value, right: Value) -> bool:
+    """Structural equality (ontos-core §3). The same relation as ``left == right``."""
+    return left == right

bitspark_bitwire-0.5.0/tests/test_consumer.py

@@ -0,0 +1,14 @@
+import unittest
+from bitwire import Atom, Tuple, Path
+class Contract(unittest.TestCase):
+    def test_paths_and_ground_values(self) -> None:
+        path: Path = (Atom(),)
+        self.assertNotEqual((), path)
+        self.assertNotEqual((Atom(b'a/b'),), (Atom(b'a'), Atom(b'b')))
+        self.assertNotEqual(Atom(), Tuple())
+    def test_value_ownership(self) -> None:
+        source = bytearray([0,255])
+        value = Atom(source)
+        source.clear()
+        self.assertEqual(value, Atom(bytes([0,255])))
+if __name__ == '__main__': unittest.main()

bitspark_bitwire-0.5.0/tests/typecheck.py

@@ -0,0 +1,14 @@
+from bitwire import Wire, Endpoint, AddressedEndpoint, Atom, Tuple
+async def send_only(wire: Wire) -> None:
+    await wire.send(Atom())
+async def consume(endpoint: Endpoint, addressed: AddressedEndpoint) -> None:
+    detach = endpoint.receive(lambda message: None)
+    await send_only(endpoint)
+    await endpoint.send(Tuple())
+    detach()
+    await addressed.send((Atom(b'leaf'),), Atom())
+    addressed.receive(lambda path, message: None)()
+    await addressed.close()
+    await addressed.closed()
+    await endpoint.close()
+    await endpoint.closed()

bitspark_bitwire-0.3.0/NOTICE

@@ -1,10 +0,0 @@
-Bitwire
-Copyright 2026 Bitspark and the Bitwire contributors
-
-This product includes software developed at Bitspark (https://github.com/Bitspark).
-
-The Python Wire declarations are adapted from Nightseam, licensed under the
-Apache License, Version 2.0:
-Copyright 2026 Bitspark and the Nightseam contributors.
-Source revision: 1c63f1c4d7e4b5987d4bd32e294177645c92ed8f.
-Source path: duplex/py/nightseam/duplex/wire.py.

bitspark_bitwire-0.3.0/PKG-INFO

@@ -1,141 +0,0 @@
-Metadata-Version: 2.4
-Name: bitspark-bitwire
-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
-Project-URL: Documentation, https://github.com/Bitspark/bitwire/tree/main/docs
-Project-URL: Repository, https://github.com/Bitspark/bitwire
-Project-URL: Issues, https://github.com/Bitspark/bitwire/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Typing :: Typed
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-License-File: NOTICE
-Dynamic: license-file
-
-# Bitwire for 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, AddressedWire
-
-
-def call(endpoint: AddressedWire, replies: AddressedWire) -> None:
-    endpoint.send(
-        ["cells", "get"],
-        Message(
-            {"version": 1, "kind": "request", "id": "request-1", "params": {}},
-            return_address=ReturnAddress(replies),
-        ),
-    )
-
-
-def listen(endpoint: Endpoint):
-    def receive(path, message):
-        print(path, message.frame)
-
-    return endpoint.receive(Receiver(message=receive))
-```
-
-`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 attached endpoint.
-
-`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.
-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 [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.
-
-## Packaging and checks
-
-From this directory:
-
-```sh
-python -m pip install -r requirements-dev.txt
-python check.py
-```
-
-This builds a source distribution and a wheel from it, verifies the distribution
-contents, installs the wheel into a temporary virtual environment, and runs both
-consumer tests and static typing checks against that installed package. The test
-endpoint is a recording fixture, not a Bitwire runtime or conformance driver.
-
-For release artifacts at a chosen location:
-
-```sh
-python -m build --outdir dist
-```
-
-## Optional PyPI publication
-
-The manual `publish-python.yml` workflow publishes an existing immutable public
-release tag. It is separate from the Go/TypeScript release and does not gate that
-handover. Its default authentication is a PyPI trusted publisher. Configure these
-fields under the PyPI account's **Publishing** page for a pending project:
-
-| Field | Value |
-| --- | --- |
-| PyPI project name | `bitspark-bitwire` |
-| Owner | `Bitspark` |
-| Repository name | `bitwire` |
-| Workflow name | `publish-python.yml` |
-| Environment name | `pypi` |
-
-For an existing project, add the same publisher under the project's publishing
-settings. As a bootstrap fallback, store an API token in the repository or `pypi`
-environment secret named `PYPI_API_TOKEN`, then select `api-token` when dispatching
-the workflow from `main`. Tokens are passed only to publication steps. Revoke the
-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 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.3.0/README.md

@@ -1,121 +0,0 @@
-# Bitwire for 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, AddressedWire
-
-
-def call(endpoint: AddressedWire, replies: AddressedWire) -> None:
-    endpoint.send(
-        ["cells", "get"],
-        Message(
-            {"version": 1, "kind": "request", "id": "request-1", "params": {}},
-            return_address=ReturnAddress(replies),
-        ),
-    )
-
-
-def listen(endpoint: Endpoint):
-    def receive(path, message):
-        print(path, message.frame)
-
-    return endpoint.receive(Receiver(message=receive))
-```
-
-`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 attached endpoint.
-
-`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.
-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 [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.
-
-## Packaging and checks
-
-From this directory:
-
-```sh
-python -m pip install -r requirements-dev.txt
-python check.py
-```
-
-This builds a source distribution and a wheel from it, verifies the distribution
-contents, installs the wheel into a temporary virtual environment, and runs both
-consumer tests and static typing checks against that installed package. The test
-endpoint is a recording fixture, not a Bitwire runtime or conformance driver.
-
-For release artifacts at a chosen location:
-
-```sh
-python -m build --outdir dist
-```
-
-## Optional PyPI publication
-
-The manual `publish-python.yml` workflow publishes an existing immutable public
-release tag. It is separate from the Go/TypeScript release and does not gate that
-handover. Its default authentication is a PyPI trusted publisher. Configure these
-fields under the PyPI account's **Publishing** page for a pending project:
-
-| Field | Value |
-| --- | --- |
-| PyPI project name | `bitspark-bitwire` |
-| Owner | `Bitspark` |
-| Repository name | `bitwire` |
-| Workflow name | `publish-python.yml` |
-| Environment name | `pypi` |
-
-For an existing project, add the same publisher under the project's publishing
-settings. As a bootstrap fallback, store an API token in the repository or `pypi`
-environment secret named `PYPI_API_TOKEN`, then select `api-token` when dispatching
-the workflow from `main`. Tokens are passed only to publication steps. Revoke the
-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 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.