ADR-0011: Structure Registry Replication — BaseNet List, Client Registry Copy, Wall Colliders, and the Chest Binding

Status

Accepted

Accepted 2026-09-11. Gate 0 confirmed GO the same day by the two-machine friend playtest (production/playtests/gate-0-2026-09-11/, record production/gate-checks/gate-0-provisional-pass-2026-09-11.md); the provisional note and revisit clause this ADR was written under are discharged. Playtest observation carried to the register: occasional remote stutter at ≈ 150–180 ms RTT (interpolation tuning, ADR-0009 §6).

Date

2026-09-11

Engine Compatibility

Revisit clause (Gate 0)

No section is feel-dependent. The one-tick state lag (ADR-0008 §2) means a client may receive StructurePlaced one tick before the row that creates the collider; §3 makes presenters act on the outcome and movement on the collider, so the lag is invisible except as ≤ 20 ms of "the thunk before the wall".

Documents Amended by This ADR

ADR Dependencies

Context

Problem Statement

StructureInstance = {instanceId, structureId, position} "is the whole registry" (BB), host-authoritative, permanent in the save, low hundreds of rows at most (EC18). Every client needs a copy: a wall's entire function is collision (Rule 8, AC-27) and it must block "the instant its host-confirmed placement lands"; the ghost's provisional F1 and crafting's advisory stationPresent read a client copy that is "legal for display, never for gating" (Rule 13, AC-39b); a storage structure is also a StorageNet (ADR-0010) that must bind to its row; a late joiner needs the whole base before it can walk into a wall. StructureId is a string and list rows must be unmanaged. Row 11 of the architecture asks: list vs NetworkObject per structure, snapshot-vs-in-flight ordering, static collider instantiation, the layer matrix.

Constraints

• ADR-0008 §5: state = server-written list on the owning object; edges = outcomes; never both for one fact.
• BB AC-24: StructureInstance is exactly three fields (fenced); no builder, no cost snapshot (EC14), no footprint.
• BB Rule 13 / AC-39b: the host commit-instant evaluation is authoritative and never cached; a client copy is advisory only and a client never pre-validates in place of the host.
• ADR-0009 §3: blockers are static colliders on Structure; the matrix is fenced; EC21 is an owner-side write triggered when a wall lands on the player's cell.
• ADR-0010: StorageNet per chest, spawned by PlaceStructureCommand via QueueSpawn, despawned via QueueDespawn; ContainerId = "s"+instance.
• ADR-0004 stage 6: permanent reconcile — unknown structureId → inert relic, never dropped; instanceId counter persisted.
• Gameplay values are data (structures.json, ADR-0006): StructureDef, placementReach, socketNoBuildRadius, perimeterSegments; stationRange is crafting's knob.

Requirements

TR-bb-002 (registry replication representation), TR-bb-005 (demolish, refund to CARRY, storage empty-first, relic reconcile — the wire half), TR-bb-006 (two station predicates; storage placement instantiates a container), TR-bb-007 (walls are static 2D colliders; EC21 write mode — decided by ADR-0009, trigger decided here), TR-move-003 (blocker set), TR-craft-003's station gate input.

Decision

**Alternative A: one in-scene BaseNet NetworkObject carries NetworkList<StructureNetRow{uint InstanceId, ushort StructureIndex, short X, short Y, byte W, byte H}> mirrored from the host StructureRegistry after every drain by one writer; every machine (host included) builds a ClientRegistry from the list's events and instantiates one plain StructureView per row — a static BoxCollider2D on the Structure layer sized to the def's footprint plus the sprite — created on Add, destroyed on Remove; storage rows bind lazily to the StorageNet whose StructureInstance matches; StructureId crosses as an index from a StructureIndexTable hashed into the snapshot header; relics are rows whose def is absent on the receiving machine and render as the fallback visual at the row's own footprint; stationPresent* is evaluated on the host over the live registry and on clients over the copy for display only; the snapshot drops the structures table.**

1. The row and the codec

StructureNetRow { uint InstanceId; ushort StructureIndex; short X; short Y; byte W; byte H; } — 14 B, unmanaged, IEquatable. W, H are the footprint as it was when the row was written (from the def at placement; from the save column on load) — carried so a relic keeps its silhouette after its def is gone (user decision 2026-09-11). StructureIndex comes from StructureIndexTable (Runtime): the ordinal-sorted key order of IGameData.Structures at data load — the ItemIndexTable pattern (ADR-0010 §1); its hash is folded with the item table's into the snapshot header's dataHash (ADR-0008 amended) — dataHash = FNV-1a over the concatenation of each index table's own hash in a fixed table order: items, structures, then any table a later ADR adds, appended, never reordered (ADR-0012 appends its enemy/template table rather than defining a second header field; TD C8) so a client whose structures.json differs disconnects with ConfigVersion instead of mis-mapping a wall to a chest. X, Y are the footprint's anchor cell (Cell, min corner — ADR-0003 §2). Relic rows (BB EC13): a structureId absent from current data has no index — the host's StructureIndexTable returns 0xFFFF and the string stays only in the host's save table; every machine renders 0xFFFF as the generic relic visual at the row's own W × H, and the relic blocks noOverlap, movement and FindCorrectionCell over that whole footprint — EC13's "position/footprint preserved" holds as written. The footprint survives the patch because the structures save table writes a footprint column per row (ADR-0004 stage 6; a table column, written from the def at save time, not a field of StructureInstance — AC-24's allow-list stays literal). Live rows carry W, H too (redundant with data, self-describing on the wire, 2 B).

2. Host truth and the mirror

• Truth: StructureRegistry : IStructureRegistry, IReconcilable (Runtime.Build) — the permanent structures save table (ADR-0004 stage 6) plus the host-monotonic instanceId counter (BB Rule 16 / EC16, persisted). Written only inside PlaceStructureCommand.Execute (Add) and DemolishCommand.Execute (Remove) — ADR-0002 invariant 4. HostContext.Structures is this object; every F1/F2 conjunct re-samples it at commit (Rule 13: never cached host-side).
• Mirror: BaseNet.Structures : NetworkList<StructureNetRow> (server-write) on the in-scene, always-spawned BaseNet object (its own NetworkObject — bulk state never shares HostCommitChannel, ADR-0008's bulk_payload_on_command_channel). RegistryReplicator (host) runs once after every Drain() in the same phase-4 window as StorageReplicator (ADR-0010 §3) and applies the drain's registry diff: Structures.Add(row) per new instance, Structures.Remove(row) per removed one (by value — V2 — so clients key on InstanceId, never on list index; order is placement order and carries no meaning). Like StorageNet.Rows, the list is a mirror, not host-rail state: no gate reads it, no table holds it, it is reconstructible from StructureRegistry at any instant.
• Boot (host): after Save.Load() reconciles structures (relics kept), BaseNet.Structures is filled from the registry before StartHost — a hard precondition, not a preference: NGO populates its in-scene object table at manager start (CHANGELOG #3177), so the boot scene holding BaseNet must be loaded and filled first (V1). Before StartHost there is no session: Initialise populates the backing list directly — it is not a replicated write and does not pass through RegistryReplicator, which is the only writer once the session is live; Initialise throws if NetworkManager.Singleton.IsListening (TD C1; companion negative of Bld_ListSingleWriter), and every storage row's StorageNet is spawned with its rows pre-filled (ADR-0010 §3 "Load").
• Late join: the joiner receives BaseNet with the full list during synchronisation (V1); the snapshot carries no structures table (ADR-0008 amended). A placement in flight during the join is an ordinary later delta. There is no snapshot-vs-in-flight ordering problem to solve because there is no second source: the list is the only registry a client ever sees.

3. The client copy, colliders and sprites — one code path on every machine

• ClientRegistry (Runtime.Build, one per machine including the host's own process): subscribes to Structures.OnListChanged; on Add creates a StructureView — a plain (non-networked) GameObject at Cell.Center(X, Y) with a BoxCollider2D on layer Structure sized Footprint × 1 u (offset to the footprint's centre), isTrigger = false, static (no Rigidbody2D), plus the SpriteRenderer (def's sprite; relic → fallback), then Physics2D.SyncTransforms() so the sweep sees it this frame (V3). On Remove (keyed by Value.InstanceId only — NGO leaves Index unset on that event, V2) it destroys the view. ClientRegistry exposes IStructureRegistry's read half (All, AnyCovers, TryGet) for the ghost's provisional F1 and the advisory stationPresent* — display only; a relic row surfaces there as a StructureInstance whose Structure is the reserved sentinel StructureId.Relic (the client never needs the original string — only the host's save table holds it; AnyCovers uses the row's W × H; StationPresence never matches it: no def, no tier) (TD C9) (Rule 13 / AC-39b; fence §7: no command's Execute can see it — Rules cannot name a Runtime type, and the host's commands read HostContext.Structures, never the copy).
• Instant blocking (AC-27): the collider exists the frame the Add event fires; ADR-0009's sweep is per rendered frame and casts against Structure, so the next Sweep.Move on every machine stops at it (V3). The host's own player sees the wall on the same frame the replicator's Add fires (host-local list event).
• Outcome vs row (ADR-0008 §2 lag): StructurePlaced (the edge — thunk, reason-string clear, CarryFold cost) may arrive one tick before the row; presenters act on the outcome, movement on the collider. Nothing reads ClientRegistry inside an outcome handler (ADR-0008's outcome_handler_reads_variable).
• Host and client are the same code: the host's ClientRegistry listens to its own BaseNet list, so wall colliders on the host are created by the identical path — no "host instantiates directly" branch. Ordering on the host, stated (TD C4): HostContext.Structures gains the row inside Execute; the host's own collider appears when RegistryReplicator fires the list event after the drain — a sub-tick window in which the registry leads the colliders. Safe by construction because the two are read from different places and never compared: every host gate reads the registry (never a collider), every sweep reads colliders (never the registry). No code may derive a blocker from HostContext.Structures or a gate from a collider — reviewed per command and registered (registry_and_colliders_never_compared); ADR-0012 in particular may not query colliders for enemy pathing.

4. Chests — a registry row and a StorageNet, bound lazily

A storage-category placement produces two replicated things from one command: the registry row (this ADR) and the StorageNet spawned via QueueSpawn(SpawnRequest.SharedStorage(instance, origin, slots)) (ADR-0010) — both deferred effects of the same drain, on two NetworkObjects with no ordering relation. StructureView for a storage row therefore binds lazily: it looks up StorageNet by StructureInstance (a static dictionary StorageNet registers itself into on OnNetworkSpawn) and, if absent, subscribes to a StorageNet.Spawned event; StorageView (ADR-0010) binds the other way for the UI. Demolish: DemolishCommand (gated on ChestNotEmpty) removes the row and QueueDespawns the object in the same drain; a client handles either order (the view's OnDestroy unsubscribes; a StorageNet despawn with no view is a no-op). A client with the chest panel open when the row is removed closes it on the Remove event (TD C5): StructureView's teardown raises StructureRemoved(InstanceId) and PanelManager (ADR-0014) closes any panel bound to that instance; StructureDemolished stays the presenter edge — the close is keyed on the row, never the outcome (§3's rule). PlayMode asserts: open panel → demolish → panel closed, no StorageNet reference survives. ContainerId = "s" + InstanceId (ADR-0010's constraint, accepted) is the one string form both sides derive from the same uint.

5. Outcomes

Both Structure* outcomes name the actor so the fold (ADR-0010) can apply cost/refund from data; the row itself carries no actor (AC-24 — anonymity is a registry fact, not a wire fact; an outcome is an edge that happens to have an author, exactly like SwingLanded).

6. BB Edge Case 21 — trigger and write mode

ADR-0009 §5 decided the write (owner-side CorrectTo, interpolated for observers). This ADR decides the trigger: on the list Add event (the same instant the collider appears — never on the outcome, which can precede the collider by a tick), the local ClientRegistry checks whether the local player's cell is inside the new footprint; if so it calls Rules.Build.FindCorrectionCell(seed, terrain, registry, placeable) — the GDD's reference implementation, pure, reading no player positions — and PlayerMotor.CorrectTo(cell.Center); null (enclosed) is EC22, socially resolved. Only the owner corrects itself (owner rail); remote bodies under a wall are their own owner's problem on their own machine. The GDD's three pins carry over (TD C6): (ii) re-check immediately before the write — the player may have walked clear between the event and the correction; if its cell is no longer covered, no write; (iii) at most one correction in flight, re-evaluated fresh at the post-correction cell (AC-14e) — a second wall landing during the first correction queues one re-check, never a second concurrent write; and FindCorrectionCell's N, E, S, W order is the binding tie-break (AC-14c; fenced Bld_CorrectionOrderIsNESW against the GDD's fixtures).

7. stationPresent* — two contexts, one function

Rules.Build.StationPresence.Exact(tier, asker, registry, defs, stationRange) / .AtLeast(...) — pure over IStructureRegistry + IGameData.Structures. Host: StationPresence : IStationPresenceProvider over HostContext.Structures, evaluated at the commit instant inside CraftCommitCommand.Execute, never cached (Rule 13); asker is ctx.Positions.HostKnown(OwnerClientId) — the same source and the same ≤ 1 RTT + 1 tick staleness as F1's noPlayerOccupancy (ADR-0009 §7). ADR-0008 §7's RangeSlackUnits does not apply (TD C7, ruled): stationRange is a design knob, not an anti-cheat reach gate; widening it would change crafting's reachability rule. Client: the same function over ClientRegistry for greying/hints — display only; the client never skips the host re-sample (AC-39b). Exactly two predicates are exposed (AC-44; fenced by ADR-0003's Schema_*).

8. Fences (EditMode unless noted)

Architecture Diagram

HOST (drain)                                                                    EVERY MACHINE (host included)
PlaceStructureCommand.Execute: 8 gates over HostContext.Structures/Terrain/Sockets/Positions → Inventory.Remove(cost) → Structures.Add → Persist → Broadcast(StructurePlaced) → [storage] QueueSpawn(SharedStorage)
DemolishCommand.Execute: exists ∧ (not storage ∨ empty) ∧ CanAdd(refund) → Inventory.Add → Structures.Remove → Persist → Broadcast(StructureDemolished) → [storage] QueueDespawn
   │ phase 4: OutcomeRpc ─────────────────────────────────────────────────────► presenters (thunk) · CarryFold (cost/refund from data) · HUD
   │ after Drain: RegistryReplicator → BaseNet.Structures.Add/Remove(row) ═══ list delta ═══► ClientRegistry: StructureView (BoxCollider2D on Structure + sprite) · EC21 check (owner) · advisory F1 / stationPresent
   │               StorageNet spawn/despawn (ADR-0010) ═══ separate object ═══► StructureView ⇄ StorageNet bound lazily by InstanceId
boot: Save.Load → StructureRegistry (relics kept) → BaseNet.Structures filled → StartHost; late joiner: BaseNet scene sync carries the whole base (V1); snapshot has no structures table

Key Interfaces

namespace Driftlands.Rules.Commands                      // placeholders shipped in HostContextServices.cs get their shape
{
    public interface IStructureRegistry {                // HostContext.Structures — host truth; ClientRegistry implements the READ half only
        IReadOnlyList<StructureInstance> All { get; }
        bool AnyCovers(Cell c);                          // any footprint covers the cell (data for live rows, the stored column for relics)
        bool TryGet(uint instanceId, out StructureInstance s);
        uint Add(StructureId id, Cell origin);           // host only, inside PlaceStructureCommand.Execute; returns the monotonic instanceId
        bool Remove(uint instanceId);                    // host only, inside DemolishCommand.Execute
    }
    public interface IStationPresenceProvider {          // exactly two (BB AC-44)
        bool StationPresentExact(StationTier tier, Vector2 asker);
        bool StationPresentAtLeast(StationTier tier, Vector2 asker);
    }
    public interface ITerrainQuery { bool IsBuildable(Cell c); bool InPlaceableRegion(Cell c); }
}

namespace Driftlands.Data { public sealed record StructureInstance(uint InstanceId, StructureId Structure, Cell Position); }   // exactly three (AC-24, fenced)

namespace Driftlands.Rules.Build                         // engine-free (ADR-0003 already assigns F1–F4, snap, FindCorrectionCell here)
{
    public readonly record struct Footprint(Cell Origin, int W, int H) { public bool Covers(Cell c); public Cell Center { get; } }
    public static class BuildRules { public static PlacementVerdict PlacementLegality(/* ADR-0003 §4's argument list */); public static DemolishVerdict DemolishLegality(/* structure, storage-empty, CanAdd(refund) */); public static Cell? FindCorrectionCell(Cell seed, ITerrainQuery terrain, IReadOnlyList<Footprint> registry, Region placeable); }
    public static class StationPresence { public static bool Exact(StationTier t, Vector2 asker, IStructureRegistry r, IReadOnlyDictionary<StructureId, StructureDef> defs, float range); public static bool AtLeast(/* same */); }
    public sealed record StructurePlaced(uint Instance, StructureId Structure, Cell Origin, PlayerKey Placer) : IOutcome;                              // wire: StructureIndex ushort
    public sealed record StructureDemolished(uint Instance, StructureId Structure, Cell Origin, PlayerKey Demolisher, bool RefundIsZero) : IOutcome;
    public sealed record DemolishCommand(ulong OwnerClientId, uint ClientSeq, PlayerKey Player, uint Instance) : ICommand;                              // PlaceStructureCommand: ADR-0003 §4
}

namespace Driftlands.Runtime.Build
{
    public struct StructureNetRow : IEquatable<StructureNetRow> { public uint InstanceId; public ushort StructureIndex; public short X; public short Y; public byte W; public byte H; }   // 14 B; 0xFFFF = relic (renders at W×H)
    public sealed class StructureIndexTable { public ushort Of(StructureId id); public StructureId? At(ushort i); public uint Hash { get; } public static StructureIndexTable Build(IGameData data); }
    public sealed class StructureRegistry : IStructureRegistry, IReconcilable { /* structures table + instanceId counter; relics kept with their string id */ }
    public sealed class BaseNet : NetworkBehaviour {                                    // in-scene, always spawned, server-owned; bulk state off the command channel
        public NetworkList<StructureNetRow> Structures = new(writePerm: NetworkVariableWritePermission.Server);
        internal void Initialise(IStructureRegistry host, StructureIndexTable idx);    // host, before StartHost
    }
    public sealed class RegistryReplicator { public void AfterDrain(IReadOnlyList<StructureInstance> added, IReadOnlyList<uint> removed); }   // the ONLY runtime writer of Structures
    public sealed class ClientRegistry : IStructureRegistry /* read half; Add/Remove throw */ { /* OnListChanged → StructureView create/destroy; EC21 check for the local player */ }
    public sealed class StructureView : MonoBehaviour { /* BoxCollider2D on Structure + SpriteRenderer; lazy StorageNet binding for storage rows */ }
    public sealed class StationPresence : IStationPresenceProvider { /* host: over HostContext.Structures at commit instant; client instance over ClientRegistry for display */ }
}

Alternatives Considered

Alternative B: a NetworkObject per structure

• Description: each wall/station/chest is a spawned prefab with NetworkVariables for def and position; colliders live on the prefab.
• Pros: no client instantiation code; a chest is one object, not a row plus an object.
• Cons: 50–100 spawn messages for a perimeter; each placement is a spawn (heavier than a 12 B delta); the in-scene NetworkPrefabsList grows per structure kind; AnyCovers/FindCorrectionCell on clients would iterate NetworkObjects; a late joiner receives 100 spawns instead of one list.
• Rejection Reason: user decision 2026-09-11; the registry is a small table and NGO lists exist for small tables.

Alternative C: outcome-driven registry + snapshot

• Rejection Reason: user decision 2026-09-11 — a joiner would have no walls until it applied the document, and the snapshot-vs-in-flight ordering problem row 11 asks about would be real; the list dissolves it.

Alternative D: wall Tilemap + TilemapCollider2D + CompositeCollider2D

• Pros: one merged collider for hundreds of wall cells.
• Cons: every placement rebuilds the composite; stations and chests still need their own colliders; a second representation of "where walls are" beside the registry.
• Rejection Reason: user decision 2026-09-11; a BoxCollider2D per row is one collider per structure at EC18's scale. Recorded as the optimisation to revisit if the box count ever measures.

Alternative E: store the relic's footprint in StructureInstance

• Rejection Reason: AC-24's allow-list is a pillar-level fence (anonymity); widening it for relics would reopen it. The chosen form — a save-table column plus two wire bytes — preserves the footprint without touching the type.

Alternative E′: narrow relics to a 1×1 anchor cell

• Cons: the base silhouette shrinks where a def was removed; cells the relic covered become buildable and walkable while its art still reads as solid — a creative change to EC13's "the base silhouette holds".
• Rejection Reason: user decision 2026-09-11 (offered with the column option; the column costs 2 wire bytes and one save column).

Alternative F: EC21 triggered from the StructurePlaced outcome

• Rejection Reason: the outcome can precede the row (and thus the collider) by one tick (ADR-0008 §2); correcting before the collider exists could move the player into it. The list event is the collider's own edge.

Consequences

Positive

• One list, one replicator, one client path for host and clients alike; walls block on the same frame the row lands everywhere.
• The snapshot loses another table; late join for the whole base is the in-scene object's own sync.
• The registry's anonymity stays a schema fact: the wire row has no actor; the outcomes that do are edges.
• Chest binding is order-independent by construction, so the two-object placement never needs an ordering guarantee NGO does not give.

Negative

• A structure is two things on a client (row → view) and, for chests, three (row, view, StorageNet); the lazy binding is code that must exist.
• Every row carries 2 B of footprint the data already knows — redundancy accepted so relics need no def.
• StructureIndex means structures.json edits that add/remove a def change every client's index table — the dataHash disconnect is the guard, and it is loud by design.

Risks

• V1 fails (in-scene object list not delivered at scene sync): BaseNet.Ready : NetworkVariable<bool> set after fill; ClientRegistry binds on it — one line, same pattern as ADR-0010's closed contingency.
• Wall count growth past EC18's assumption: BoxCollider2D per row is linear; Alternative D is the recorded swap; the replicator and list are unaffected.
• A def removed by a patch: the relic keeps its footprint (column), so nothing about collision or noOverlap changes for anyone standing near it; the only visible change is the fallback art. If a save predates the column (none exist before this ADR — the table is new), the loader treats a missing column as 1×1 and reports KeptOrphan.

GDD Requirements Addressed

Performance Implications

• CPU: replicator O(changes) per drain; ClientRegistry O(1) per event; AnyCovers O(rows) per ghost frame (≤ ~100) — trivial; one static collider per structure.
• Memory: 14 B per row on the wire; one GameObject + BoxCollider2D per structure per machine.
• Network: 14 B delta per placement/demolish; ≤ ~1.4 KB in the scene-sync message for the whole base.
• Load time: StructureIndexTable at data load; BaseNet fill before StartHost (µs).

Migration Plan

• StructureDef/BuildConfig fields + structures.json + RequiredFiles (+ both TestJson fixtures) — BaseBuilding Data story (ADR-0006 validation rows already specified).
• Rules.Build: Footprint, BuildRules (F1 eight conjuncts, F2, snap, FindCorrectionCell), StationPresence — pure, EditMode, mutation-checked (the GDD's ACs).
• StructureRegistry + structures table + counter (ADR-0004 stage 6) + IStructureRegistry shape; PlaceStructureCommand/DemolishCommand + outcomes + codecs (ADR-0008); CarryFold cases (ADR-0010).
• StructureIndexTable (+ dataHash), StructureNetRow, BaseNet, RegistryReplicator, ClientRegistry, StructureView + Bld_* fences; V1/V3 in PlayMode; lazy StorageNet binding (V4).
• EC21 trigger in ClientRegistry (with ADR-0009's CorrectTo); StationPresence host + client instances.
• HUD build picker / placement screens bind to ClientRegistry/StructureIndexTable (presentation-ui-hud-screens).

Validation Criteria

• EditMode: the §8 fences with companion negatives; F1/F2 pure tests per the GDD's ACs (AC-13–19, 20b, 14b/14c); StructureIndexTable round-trip + relic 0xFFFF; codec round-trips for both outcomes.
• PlayMode (host): after a scripted place/demolish sequence, BaseNet.Structures equals the registry's rows; StructureView colliders match (V3); a storage row binds to its StorageNet whether the spawn is processed before or after the row (V4, simulated by firing the events in both orders).
• Documented playtest / two standalone builds: V1 (late joiner receives the full base at scene sync and walks into a wall immediately); a wall placed by the host blocks the client on its next frame (AC-27); two ghosts racing one footprint → exactly one commits (AC-20c); EC21 correction slides on observers (ADR-0009 V2).

Related Decisions

• ADR-0008 (rule, outcomes, snapshot, dataHash), ADR-0009 (Structure layer, sweep, EC21 write), ADR-0010 (StorageNet, SpawnRequest, ContainerId, index tables, fold), ADR-0002/0003 (commands, HostContext, purity, AC-24/44 fences), ADR-0004 (stage 6), ADR-0006 (structures.json).
• design/gdd/base-building.md, design/ux/build-mode.md, design/quick-specs/player-movement-2026-08-27.md (Rule 6), crafting-system.md (station gate); architecture.md row 11.