convene-mix

The root descriptor for the mix crate — the transport domain. This is the layer the team in the book actually builds: how a sealed thing gets from a sender to the recipient it is for without an observer of the whole wire being able to tell who is talking to whom. It is a domain with its own experts — protocol designers, not case workers — and its own enabling specification in their vocabulary. It sits below the comms domain and realises its one seam: the mix layer implements core's Relay, so where core says "deliver this to Karin", mix says how — chunk it into indistinguishable cells, route them through a pool of mixing tumblers, and let Karin recognise hers cheaply and privately at the far end.

The mix speaks its own vocabulary, not the comms layer's: it carries a Payload (an opaque blob — what was a sealed EncryptedMessage one layer up, meaningless here), seals under a SealKey (opaque material — set from the recipient's epoch key at the seam), and routes to a Peer edge. It never names a member, a group, or a message. That is the layer boundary made real: the comms layer's typed values become the transport's opaque bytes at the Relay seam (in the host glue), and below that seam the transport is a self-contained domain that could carry any layer's sealed bytes. So this crate depends on nothing — it is the reusable transport the comms layer is bound to, not built into.

The whole design is a Sphinx/Loopix-class mix, expressed as Data and Contexts rather than code:

• Fixed-size cells (Cell, CellContent) — every wire unit is one padded, indistinguishable cell; a message too big for a cell is chunked and a message too small is padded, so nothing on the wire can be sorted by size, and the reassembly grouping rides inside the seal.
• Tumblers (Tumbler) — a pool of mixing nodes; a cell enters, is held with others, and leaves in a reordered batch, so a sender's fan of cells is decorrelated from each other and from the sender.
• Private detection (DetectionTag) — a recipient recognises their own cells with a cheap test under a key they hold, without a stable address anyone could cluster them by.
• The verbs (Deliver, Mix, Collect) — the sender's send, a tumbler node's mixing step, and the recipient's collection.

Below itself the mix layer names two seams to the floor — Wire (move a cell between peers) and Entropy (the randomness mixing needs) — which the host crate binds to existing crates. Modeling stops there.

Build

kind: library

Depends on

(none) — the transport is self-contained: it carries opaque Payload bytes under opaque SealKey material between Peer edges, naming nothing of the comms layer above it. The comms layer is bound to this transport at the Relay seam by the host crate, which is where a typed EncryptedMessage becomes an opaque Payload and an epoch key becomes a SealKey.

Contains

• data/ — the transport values: the Payload it carries and the SealKey it seals under; the Cell and its sealed CellContent; the DetectionTag; the Tumbler; and the Peer a cell moves between.
• contexts/ — the transport acts: Deliver (a sender turns a sealed message into routed cells), Mix (a tumbler node admits a cell and releases a reordered batch), Collect (a recipient recognises and reassembles their own cells).
• ports/ — the downward seams to the floor: Wire and Entropy.