Which parts of a node's in-memory state should be excluded from its serialized form, and how does a decoder restore them?

## Deciding what a node actually is The fields of a node are not all the same kind of thing. Writing it out forces a classification that in-memory code never has to make: 1. **Authoritative state** — the facts this node is the source of. It travels. 2. **Process-local scaffolding** — handles that only mean something inside this process. It cannot travel. 3. **Derived state** — values computed from category 1 and cached for speed. It need not travel. 4. **Restricted state** — facts the receiver is not entitled to see. It must not travel, whatever category it is otherwise in. Omitting a field is a **contract decision**, not a local optimisation: it changes what the reader is able to reconstruct, and it is visible to every consumer. ## Category 2: handles that cannot cross the boundary An open connection, a file handle, a lock, a reference to a running worker, an index into a local buffer, a raw address — each is a token interpreted by one process's own tables. Serialized, it becomes a number that names something else entirely on the far side, or nothing at all. The honest treatment is to exclude it and have the decoded node re-acquire an equivalent against the local environment, lazily on first use or in an explicit post-decode step. Note that the node's **configuration** for that resource is category 1 and should travel: the address to connect to travels, the connection does not. ## Category 3: derived values, and the stale-cache trap A memoized total, a sorted view of a collection, a cached hash, a computed display string — all reproducible from the fields that travel. Reasons to exclude them: - **Size.** A derived index can dwarf the data it indexes. - **Consistency.** If the derived field is written at a different moment from its inputs, the receiver can decode a total that does not match the items. Recomputing is the only guarantee that the two agree. - **Contract weight.** Once a derived value is on the wire, a consumer will read it, and now the algorithm that produced it is part of the contract and cannot change without breaking that consumer. The corresponding obligation lands on the decoder: a decoded object must not present a missing cache as a computed answer. A total that arrives absent means *not yet computed*, and the node must recompute it on demand. Presenting it as zero, or as an empty index, produces a plausible wrong answer, which is the expensive kind. ## The field that only looks derived The subtle case is a field the writer computed from something the **reader does not have** — a price at the moment of capture, a total across records the receiver cannot see, a decision that used inputs now gone. It is a cache in the writer's process and authoritative state everywhere else. Excluding it deletes information that cannot be reconstructed. The test is one question: *can the receiver compute this from the fields that travel?* If not, it is category 1, however cache-like it looks. | Field | Travels? | What the decoder owes it | |---|---|---| | The address a connection is opened to | Yes | Nothing; it is plain state | | The open connection itself | No | Re-acquire against the local environment | | A total over items that travel | No | Mark not computed; recompute on demand | | A total over records the receiver cannot see | Yes | Nothing; it is authoritative here | | A held credential or token | No | Obtain its own, by its own authority | ## Restoring invariants after decode A node that arrives with fields but no scaffolding is not yet the object its methods assume. Something must close that gap: a post-decode hook, lazy initialisation on first access, or a factory that builds the real node from the decoded fields. Ecosystems differ in which of these they offer and in whether any hook runs automatically at all, so a contract that depends on one is a contract that travels badly. The most portable design keeps the serialized form a plain record of category 1, and puts reconstruction in ordinary code the receiver runs deliberately. Two failures recur. One is running validation during decode, before the reconstruction step, so the node is judged in a state it is never supposed to be observed in. The other is a node whose exclusions were chosen field by field over time until the decoded form can no longer rebuild itself, and the receiver quietly depends on a second call to fill in what should have travelled. ## What an interviewer is listening for A classification rather than a list of examples, the recomputability test applied to a field that looks derived but is not, and awareness that the decoded node is incomplete until something re-establishes its invariants — with a named place where that happens.