Define addressless Wire and full WireTree over the common Deixis contract

[jm9e]

Current model decision — 2026-09-26

The maintainer explicitly approved this breaking migration before more services build on the old names:

interface Data { read(): Promise<Bytes>; }
interface Wire { send(message: Message): void; }
type DataTree = DeixisNode<Data>;
type WireTree = DeixisNode<Wire>;

Both trees implement one complete structural contract: mandatory own primitive, finite exact-byte-keyed whole children, partial selection, decomposition and reconstruction. For a present path:

read(tree, path)          = select(tree, path).own().read()
send(tree, path, message) = select(tree, path).own().send(message)

Data is a reading capability; Bytes is the value it reads. A materialized codec snapshot is DeixisNode<Bytes>, not serialization of readers. An existing node whose read fails or whose Wire refuses is distinct from a missing node. Opaque addressed access cannot be relabeled a full tree. The former path-taking native Wire moves to an explicit AddressedWire bridge for existing carrier semantics; it is not WireTree. The End/ByteSource naming and the instruction to preserve the old addressed Wire name are superseded. Immutable releases and bitwire/1 remain unchanged; native API versions move separately.

This is an accepted model and naming decision. Implementation, release, consumer adoption, and generic service execution require their own evidence.

Ownership and migration

Bitwire owns Wire, WireTree, AddressedWire's carrier bridge, protocol contracts and independent conformance. bitruntime implements interaction. Bitstore owns Data, DataTree, byte storage bindings and snapshot codecs. Deixis owns the generic structural contract. Public packages must install without private checkout dependencies.

This supersedes the naming portion of draft PR #49. It does not approve unrelated open message/profile, lifecycle or received-context design choices in that draft. The new accepted decision and migration notes must distinguish the complete tree from access to it.

The new WireTree path domain is exact bytes. The existing bitwire/1 path spelling supports a specified UTF-8 subset: a bridge must explicitly map or refuse keys outside that image, never normalize them or change the immutable protocol in place.

Delivery and acceptance

• Deliver addressless Wire and full DeixisNode declarations in all eight language presentations, with the addressed carrier boundary explicitly renamed.
• Align the structural surface with DataTree and the Deixis core: own primitive, complete children, partial selection, both reconstruction directions, empty path/key, binary keys and missing-node distinction.
• Publish the breaking native version and migration map; preserve old immutable artifacts and separate current contract conformance from released historical-runtime evidence.
• Independently test derived sending, primitive identity, present-but-refusing nodes, reconstruction, structural selection and access views without claiming the latter are trees.
• Allocate message/profile, return capabilities, correlation, cancellation, invocation state, endpoint ownership and received context explicitly. Naming alone does not settle those remaining designs.
• Demonstrate standalone Go/TypeScript runtime composition without Nightseam in the bounded structural core.
• Deliver the remaining service/carrier adapters without Nightseam and demonstrate their actual integration.
• Release and verify the bounded Go/TypeScript runtime core v0.1.0 against public Bitwire v0.3.0.
• Verify the remaining consumer networking migration at exact releases. The structural core release does not complete carriers, services or bitsystem3 migration.

Coordination

• Bitstore storage lane; the public library is Bitspark/bitstore, not the deprecated private SDK facade.
• Deixis structural profile.
• Generic service coordinator and backend discovery.
• A0 relay.
• Runtime delivery, bitsystem3 migration, Bitlink, BitTree.
• Existing obligations remain in #39 (runtime independence), #29 (declared composition) and #20 (invocation capture/retirement).

The separate generic-service acceptance still requires the same artifact over both backends. Local library conformance does not close it. Historical Nightseam releases remain evidence at their pinned APIs until their consumers migrate.

Native contract source delivery

PR #50 merged as f825f3f4a79135646b775e25dcd770656546b4a1 after all required checks passed: Linux/Windows core, packages, legacy carrier conformance and the Python/Rust/Java/Haskell/C++/Swift binding checks. Accepted decision 0012 records addressless Wire, full WireTree, the common Deixis contract and the explicit AddressedWire migration boundary. All eight native presentations and their independent package consumers were updated.

The independent Go/TypeScript structural oracle tests exact/binary and empty keys, partial selection, own identity, both reconstruction directions, derived sending, and present-but-refusing nodes separately from absent nodes. The test-only tree implementation does not claim production runtime or carrier delivery. The former draft PR #49 is superseded by decision 0012; its unrelated open message/lifecycle proposals are not accepted by implication.

The exact-main release rehearsal and core v0.3.0 publication workflow passed. Per-language distribution availability, bounded runtime adoption and full consumer networking migration remain separately evidenced below.

Bounded runtime core source delivery

bitruntime PR #8 merged as d1280b56c1057fde9a382e8e8076f8c990b9dce6, the source of its verified v0.1.0 release. core/go and core/ts implement generic composition/selection, full decomposition and reconstruction, derived sending, and an explicit full-tree-to-AddressedWire facade using exact UTF-8 mapping. An opaque AddressedWire is never presented as a full tree.

Core CI and release workflow 36231858293, attempt 2 passed. Verification includes seven Go tests plus subtests, Linux race/vet, TypeScript checks/build and 12 tests, the independent Bitwire structural oracle in both bindings, fresh installed package execution and external TypeScript declaration compilation. The released Go consumer uses public Bitwire v0.3.0 with GOENV=off, a fresh module cache, the public proxy and checksum service; no private/local override substitutes for release evidence.

The TypeScript artifact is the npm-compatible GitHub release tarball bitspark-bitruntime-core-0.1.0.tgz, verified SHA-256 2661642fcf1fb57cd6aa66c088bd05bb8c4163fdd4d83d231342d4f68413a63d. npmjs publication of the runtime package is not claimed. This is the structural core only: transport carriers, RPC/dispatch, received-context behavior, service adapters and bitsystem3 networking migration remain separate open work.

Distribution verification status

Bitwire v0.3.0 is published from source f825f3f4a79135646b775e25dcd770656546b4a1; the public annotated tag is 713c9c8b0df718e77f572fe4eb6937a2c429bc22. All eight established delivery routes are verified:

• Core publication run 36231433436: fresh public Go, npm and Rust consumers passed. The strict Go public proxy/checksum checks passed after transient negative-cache expiry; npm publication includes provenance.
• Python run 36232678897: wheel publication and a fresh public PyPI installation passed.
• Java run 36232680583: signed Maven Central publication and public registry consumer passed.
• Source run 36232682234: anonymous public Swift, C++ and Haskell consumers passed.

Haskell's delivery route is Git source. Its pre-existing Hackage uploader-rights deferral remains explicit; no Hackage registry upload is claimed. Native release availability does not supply carriers, service implementation, received-context behavior or the remaining consumer networking migration.

Released cross-library structural evidence

bittheory PR #12 merged as db436bbb2f16c0aeb4028d78ccb16b545c4aea45 with three green CI checks. TREE-001 pins Bitstore v0.2.0, Bitwire v0.3.0 and Bitruntime v0.1.0. Strict TypeScript compilation and five tests, plus three Go tests with three historical fixture subcases, passed against those released dependencies.

The paired Data/Wire observations cover own capabilities, complete exact-key children, empty/binary/literal-slash keys, partial and staged selection, both reconstruction directions, derived read/send, own capability identity and missing structure versus a present failing/refusing primitive. Structural operations do not invoke either primitive. The three historical flat/linked byte fixtures and qualified roots remain unchanged.

TypeScript uses direct structural compatibility across packages with no boundary cast. Go uses explicit complete adapters because the separately declared recursive interfaces are nominal; the adapters retain own capabilities while reconstructing nodes, without claiming original node-pointer identity or physical sharing. This is finite library-level evidence, not carrier, discovery, generic-service, distributed-ordering, authority or durability evidence.

Current publication documentation delivered

PR #51 merged as 56486e6b2c936fc5f021aadc51cf99c26d6c284e after all eleven checks passed. README, the language delivery matrix, all eight native usage guides and migration documents now record verified v0.3.0 availability. Historical poster design is explicitly labeled. The immutable v0.3.0 source tag remains f825f3f4a79135646b775e25dcd770656546b4a1.

The native rename, distribution and bounded structural runtime are delivered. Remaining unchecked work concerns interaction design beyond the rename, actual carriers/service adapters and consumer networking migration. This issue remains open for those obligations.

Current follow-up execution graph — 2026-09-26

The native rename and bounded structural runtime remain delivered. Runtime v0.2.0 now supplies the existing-profile carrier/dispatch implementation; runtime #1 remains open for exact released independent acceptance (PR52) and actual bitsystem3 #7 migration.

The unchecked interaction-allocation decision has a bounded owner packet: #55. Protocol publication is #53, carrier/refusal/framing guarantees #54, lifecycle #20 ↔ runtime #13, and full-tree/carrier composition #29 ↔ runtime #15.

Full space/WireTree adoption is separately bitsystem3 #11. Raw relay design #13 → implementation #9, and generic service design #2 → implementation #1, retain distinct service acceptance. They are not implicit prerequisites for bounded direct #7.

Hackage #11 is an independent optional distribution deferral, not a missing native model binding. Family index and #47 link the full owner graph. Do not close this umbrella until remaining committed packet obligations have released evidence or explicit reviewed disposition.

[jm9e]

Direct peer coordination: https://github.com/Bitspark/bitstore-svc/issues/13 now explicitly owns the Bitstore SDK B0/B1 review alongside its backend integration. This issue and that issue link each other and https://github.com/Bitspark/deixis-svc/issues/1. The shared structural contract, backend versions and two-backend conformance must be reviewed together; an independent Wire API change is not enough to close the combined migration.

[jm9e]

Naming decided by the maintainer (26 September 2026): Bitwire = Deixis[End], structured interaction, as the counterpart of Bitdata = Deixis[Bytes], structured data.

• End is the addressless primitive (A0): sending access at one origin, with no path. It uses Deixis's own vocabulary (docs/WIRES.md): the wire is the conduit, and an end is what a party holds.
• bitwire.Wire stays the addressed interface (A1), so it keeps its name in all eight language presentations. Addressed sending is Bitwire's construction over Ends, not the primitive.
• This replaces Wire = A0 wherever that was written, including bitruntime's kickoff and the "Wire underneath Bitwire" exploration.

Lane. This Bitwire session (bitwire-12) is taking the design deliverable for this issue: a proposed decision 0011 with the exact Go and TypeScript interfaces for End and Bitwire, and a split into three layers:

• conveyance (End);
• the protocol layer (requests, responses, cancellation, correlation, return capabilities, the invocation lifecycle);
• addressing (Bitwire = Deixis[End], with opaque children).

It also covers the version transition, the Deixis dependency question and independent acceptance cases. The draft will be reviewed against deixis#49, bitstore-svc#13 and deixis-svc#1 before it is accepted. bitruntime implements the result, and its experiments inform the draft.

[jm9e]

Proposed decision 0011 is up as draft PR #49 for review. Findings from deixis#49, bitstore-svc#13 and bitruntime experiments belong on that PR.