Wire Form Model

An in-memory value is laid out for one running process: it holds machine addresses valid only there, plus alignment holes whose contents are undefined. Another process shares none of that context, so the value must be re-expressed in a flat, self-standing form.

Because a multi-byte integer can be laid out most-significant byte first or least-significant byte first, and the two readings disagree: the bytes 00 00 00 01 mean 1 one way and 16,777,216 the other. Only the format can settle which.

A base-128 varint carries seven payload bits per byte and spends the eighth as a continuation flag: set means another byte belongs to this number, clear means this is the last one. The reader stops at the first byte whose top bit is clear.

It keeps an identity-keyed map of nodes already written. A node's first visit assigns an identifier, recorded before recursing, and writes the body once; every later encounter writes only a reference, so no body is written twice.

A tree walk writes that shared node's body once per path, so the wire carries three copies and decoding rebuilds three distinct objects with equal fields. Sharing is lost: a later change through one parent is invisible through the other two.

Self-describing bytes carry their own structure: field identity and type travel beside the values, so any reader can parse them unaided. Schema-driven bytes carry values only, so the reader must first obtain the schema that says which value is which.

Text parsing works character by character: it must find where each value ends and then convert digit characters into a number. A length-prefixed binary reader is told each field's width up front, so it reads or skips without inspecting content.

When decoding the bytes yields a value the application cannot distinguish from the original by any observation it makes. Correctness is round-trip equality over the declared fields, not byte-identity of the two memory images.

A discriminated union pairs an explicit tag field, drawn from a closed set declared in the contract, with that variant's fields. A reader meeting an unknown tag can reject the message, degrade to the shared fields, or retain the variant unchanged.

Schema-on-write checks the record against a declared schema before the bytes are stored, so everything in the archive conforms to some known version. Schema-on-read stores whatever arrived and leaves structure and validation to each consumer, years later.

A length prefix lets the reader take exactly that many bytes and step over the field without inspecting it, and the payload may hold any byte value. A terminator forces a scan and forbids that byte inside the payload unless it is escaped.

Two kinds do not travel: handles to process-local resources, which mean nothing in another process, and values derived from fields that do travel, which arrive stale. The decoder re-acquires the first and treats the second as not yet computed, recomputing on demand.

Inline names put identity in every record, so a rename changes the bytes and breaks readers. Numeric tags carry identity in one or two bytes and leave names free to change. Positional fields carry no identity, so order becomes the contract.

Serialization names the mechanism: a value becomes a flat byte sequence and back. Marshalling names preparing a value to cross into another execution context, which may ship a reference instead of the content. Persistence names storing it so it outlives the process.

A length counts bytes, but a UTF-8 character takes one to four of them, so a cut at an arbitrary byte position can land inside a character. The field then carries an incomplete sequence that a strict decoder rejects outright.

Because the bytes were laid out by the writer's schema, not the reader's. The reader's schema says what it wants; only the writer's says what is actually there, in what order and at what width, so decoding needs both.

Check what the hop is actually bound by. If the link is the constraint and processor headroom exists, compressing the text buys most of the size win for far less disruption; a binary encoding is justified when decode cost or skipping unwanted fields is the real constraint.

The time boundary. Crossing a process or a network leaves both ends alive and able to be diagnosed and changed together; crossing a year leaves the reader alone with immutable bytes, no writer to ask, and only whatever description of the shape was stored alongside them.

Pin four things: how integers are represented, the byte order of fixed-width fields, how every variable-length field declares its end, and the text encoding. Each one trades payload size against random access, writer complexity and how readable a hex dump stays.

Cut at the boundary of what the consumer cannot act without. Embed that subgraph as one consistent snapshot; emit stable identifiers for everything beyond it, plus the few fields needed to avoid an immediate follow-up fetch, and mark which snapshot the references were consistent with.

Mandate that anything entering long-term storage is interpretable from storage alone: either self-describing bytes, or schema-driven bytes with the writer schema in the same durable object. Decide per hop, not per estate, and defend it on asymmetry of failure.

Two's complement puts every negative number at the top of the unsigned range, so -1 would fill ten varint bytes. ZigZag interleaves the signs, mapping 0, -1, 1, -2 onto 0, 1, 2, 3, so small magnitudes stay short.

Names give a reader structure, not meaning. Self-describing bytes never say which fields are required, what an absent one means, what units or which closed set of values apply, or which shapes are legal but simply rare.

A text message can only carry characters, so raw bytes must be re-encoded into a safe alphabet. Base64 carries six bits per character, turning every three input bytes into four characters: roughly a third larger, before padding.

A handle is a token naming an entry in a table the operating system keeps for one specific process. It names a live relationship, not data, so writing its number out ships an index into a table the reader does not have.

It records an unresolved slot and fills it once the body arrives, either by backpatching a fixup list at the end or by decoding in two passes. Refusing forward references is impossible for a cyclic graph.