#4 · the request crosses the membrane

1. 27The engine takes #4ENGINE.CURSOR · propagate

   a wave is settlingengine: working on #4membrane: waiting at #2

   1. #0a listener
   2. #1a doer that asks
   3. #2a notemembrane
   4. #3readiness
   5. #4a requestengine · working
   6. ·end of the log

   What	before		after
   pointer — the next record to take	#4	→	#5

   The engine moves on to #4 — the request the doer has just written into the log.

   Where it happens takeNextTuple()Vol. 02 §4.1

   The engine's step: take the record under its pointer and move the pointer on — or stop, if the pointer has reached the end.

   Specification

   Vol. 02 §4.1

   Code

   takeNextTuple() in core/registers/take-next-tuple.ts, line 15: at the end of the log, the engine stops

   Journal

   #4 · ENGINE.CURSOR · propagate · offset: 4 · by engine

   Picture

   pointer — the next record to take: #4 → #5

   1. 1// ENGINE.CURSOR advance (Vol. 02 §4.1) — the machine's instruction pointer:
   2. 2// returns the tuple at the cursor and moves it forward exactly once, or null
   3. 3// at quiescence. Advancing IS the context switch: the ambient wave context
   4. 4// moves to the propagated tuple in the same movement, so every transition
   5. 5// journalled during its propagation is attributed to it — the cube's spine.
   6. 6// The cursor never rewinds.
   7. 7
   8. 8import type { WaveTuple } from "../wave/gate";
   9. 9import type { RegisterFile } from "./register-file";
   10. 10import { recordTransition } from "./record-transition";
   11. 11import { setDriver, setWaveContext } from "./set-wave-context";
   12. 12
   13. 13export function takeNextTuple(file: RegisterFile): WaveTuple | null {
   14. 14 const engine = file.registers.engine;
   15. 15 if (engine.cursor >= engine.base + engine.window.length) return null;↑ at the end of the log, the engine stops
   16. 16 const tuple = engine.window[engine.cursor - engine.base];
   17. 17 engine.cursor += 1;↑ the engine's pointer moves on by one
   18. 18 setWaveContext(file, { offset: tuple.offset, phase: "propagate" });
   19. 19 setDriver(file, "engine");
   20. 20 recordTransition(file, "engine", "ENGINE.CURSOR", "propagate", { offset: tuple.offset });↑ the change is written into the journal
   21. 21 return tuple;
   22. 22}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)

2. 28The request is indexed under its nameREQUESTS · index-request

   a wave is settlingengine: working on #4membrane: waiting at #2

   1. #0a listener
   2. #1a doer that asks
   3. #2a notemembrane
   4. #3readiness
   5. #4a requestengine · working
   6. ·end of the log

   What	before		after
   requests	empty	→	note.ask#1

   CellSpace keeps every request that leaves for the world under its name: note.ask#1 belongs to note.ask. Whatever comes back later — an answer or a failure — finds its doer through this index. No Cell is involved here: this is the plain case.

   Where it happens indexCausalRequest()Vol. 12 §5.1

   Indexes a request the moment it is written, under its intention's name — so that whatever answers it later finds the doer it belongs to.

   Specification

   Vol. 12 §5.1

   Code

   indexCausalRequest() in core/registers/index-causal-request.ts, line 12: the request is kept under its name

   Journal

   #4 · REQUESTS · index-request · uid: note.ask#1, bindId: note.ask · by cellspace

   Picture

   requests: empty → note.ask#1

   1. 1// REQUESTS write (Vol. 12 §5.1): every committed service intention is
   2. 2// indexed by uid so later proposals prove their causal authority against a
   3. 3// real, unconsumed, same-key request — admission is an act, not a lookup
   4. 4// (KEY_ARCHITECTURE §5).
   5. 5
   6. 6import type { CausalRequest } from "../cells/gate";
   7. 7import type { RegisterFile } from "./register-file";
   8. 8import { cellsRegion } from "./cells-region";
   9. 9import { recordTransition } from "./record-transition";
   10. 10
   11. 11export function indexCausalRequest(file: RegisterFile, request: CausalRequest): void {
   12. 12 cellsRegion(file).requests.set(request.uid, request);↑ the request is kept under its name
   13. 13 recordTransition(file, "cellspace", "REQUESTS", "index-request", {↑ the change is written into the journal
   14. 14 uid: request.uid,
   15. 15 bindId: request.bindId
   16. 16 });
   17. 17}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in f36e70d (2026-08-18)

when the membrane passed #4

1. 31The membrane passes #4MEMBRANE.CURSOR · sweep

   a wave is settlingengine: at the endmembrane: passing #4

   1. #0a listener
   2. #1a doer that asks
   3. #2a note
   4. #3readiness
   5. #4a requestmembrane · passing
   6. ·end of the logengine

   What	before		after
   pointer — the next record to pass	#4	→	#5

   #4 is different: it is a request. The membrane's pointer moves past it — and the membrane looks for someone in the world who will take it.

   Where it happens sweepNextTuple()Vol. 02 §4.6 · Vol. 07 §3

   The membrane's step: pass over the record under its pointer and move the pointer on — exactly once per record.

   Specification

   Vol. 02 §4.6 · Vol. 07 §3

   Code

   sweepNextTuple() in core/registers/sweep-next-tuple.ts, line 16: the membrane's pointer moves on by one

   Journal

   #4 · MEMBRANE.CURSOR · sweep · offset: 4 · by membrane

   Picture

   pointer — the next record to pass: #4 → #5

   1. 1// MEMBRANE.CURSOR advance (Vol. 02 §4.6, Vol. 07 §3): the membrane's own
   2. 2// reading of the one log — the second reception of one publication, never a
   3. 3// second truth. The cursor advances exactly once per offset per machine:
   4. 4// the exactly-once discharge guarantee lives in this movement.
   5. 5
   6. 6import type { WaveTuple } from "../wave/gate";
   7. 7import type { RegisterFile } from "./register-file";
   8. 8import { recordTransition } from "./record-transition";
   9. 9import { setDriver, setWaveContext } from "./set-wave-context";
   10. 10
   11. 11export function sweepNextTuple(file: RegisterFile): WaveTuple | null {
   12. 12 const engine = file.registers.engine;
   13. 13 const membrane = file.registers.membrane;
   14. 14 if (membrane.cursor >= engine.base + engine.window.length) return null;
   15. 15 const tuple = engine.window[membrane.cursor - engine.base];
   16. 16 membrane.cursor += 1;↑ the membrane's pointer moves on by one
   17. 17 setWaveContext(file, { offset: tuple.offset, phase: "sweep" });
   18. 18 setDriver(file, "membrane");
   19. 19 recordTransition(file, "membrane", "MEMBRANE.CURSOR", "sweep", { offset: tuple.offset });↑ the change is written into the journal
   20. 20 return tuple;
   21. 21}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)

2. 32The request is handed to the worldDISCHARGE.TABLE · track-discharge

   a wave is settlingengine: at the endmembrane: passing #4

   1. #0a listener
   2. #1a doer that asks
   3. #2a note
   4. #3readiness
   5. #4a requestmembrane · passing
   6. ·end of the logengine

   No register changed its value.

   A controller — the world's only station — claims #4 by its shape. The runtime notes the hand-out as discharge 1: the machine now waits for what comes back. This is the only place the machine touches the world.

   Where it happens trackDischarge()Vol. 02 §4.6 · Vol. 08 §3

   Notes, at the membrane, that a record has been handed to the world, and keeps it among those the machine still waits on.

   Specification

   Vol. 02 §4.6 · Vol. 08 §3

   Code

   trackDischarge() in core/registers/track-discharge.ts, line 19: the hand-out gets the next number

   Journal

   #4 · DISCHARGE.TABLE · track-discharge · id: 1, controller: controller.schema.double, offset: 4 · by runtime

   Picture

   no register changed its value

   1. 1// DISCHARGE.TABLE entry (Vol. 02 §4.6, Vol. 08 §3): an in-flight discharge
   2. 2// joins the table under a fresh slot id. The defect path is part of the
   3. 3// entry's own movement: a rejected discharge leaves the table as the
   4. 4// rejection propagates, so the machine stays usable for the next wave
   5. 5// (refimpl 06 §1; host ADR-011 finding 2).
   6. 6
   7. 7import type { WaveEmission } from "../wave/gate";
   8. 8import type { RegisterFile } from "./register-file";
   9. 9import { recordTransition } from "./record-transition";
   10. 10import { setDriver, setWaveContext } from "./set-wave-context";
   11. 11
   12. 12export function trackDischarge(
   13. 13 file: RegisterFile,
   14. 14 claim: { controller: string; offset: number },
   15. 15 discharge: Promise<readonly WaveEmission[]>
   16. 16): void {
   17. 17 setWaveContext(file, { offset: claim.offset, phase: "sweep" }); // attribute to the claimed tuple
   18. 18 setDriver(file, "runtime");
   19. 19 file.ephemeral.nextDischargeId += 1;↑ the hand-out gets the next number
   20. 20 const id = file.ephemeral.nextDischargeId;
   21. 21 file.ephemeral.inFlight.set(↑ it is kept among those still out in the world
   22. 22 id,
   23. 23 discharge.then(
   24. 24 (emissions) => ({ id, controller: claim.controller, offset: claim.offset, emissions }),
   25. 25 (defect: unknown) => {
   26. 26 file.ephemeral.inFlight.delete(id);
   27. 27 recordTransition(file, "runtime", "DISCHARGE.TABLE", "discharge-defect", { id, ...claim });↑ the change is written into the journal
   28. 28 throw defect;
   29. 29 }
   30. 30 )
   31. 31 );
   32. 32 recordTransition(file, "runtime", "DISCHARGE.TABLE", "track-discharge", { id, ...claim });↑ the change is written into the journal
   33. 33}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in 6730f58 (2026-09-13)

when the world answered

1. 33The world answersDISCHARGE.TABLE · resolve-discharge

   a wave is settlingengine: at the endmembrane: passing #4

   1. #0a listener
   2. #1a doer that asks
   3. #2a note
   4. #3readiness
   5. #4a requestmembrane · passing
   6. ·end of the logengine

   No register changed its value.

   The controller returns one answer, and the runtime closes discharge 1. The answer is not a record yet: it waits at the edge until the log takes it. A failure would come back the same way, under the same name.

   Where it happens resolveDischarge()Vol. 08 §3 · Vol. 03 §3.3

   Notes that the world has answered: the hand-out is closed, and what came back is ready to enter the log.

   Specification

   Vol. 08 §3 · Vol. 03 §3.3

   Code

   resolveDischarge() in core/registers/resolve-discharge.ts, line 14: no longer waiting on the world

   Journal

   #4 · DISCHARGE.TABLE · resolve-discharge · id: 1, emissions: 1, controller: controller.schema.double, offset: 4 · by runtime

   Picture

   no register changed its value

   1. 1// DISCHARGE.TABLE settlement (Vol. 08 §3): the earliest completed discharge
   2. 2// leaves the table and its answers re-enter the wave as the next run's
   3. 3// seeds. Earliest completion wins; consumers rely on correlation, never
   4. 4// adjacency (Vol. 03 §3.3).
   5. 5
   6. 6import type { RegisterFile } from "./register-file";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9// The resolution names the claim it answers (controller · the swept tuple)
   10. 10// and is journaled under THAT tuple's wave context, so the tuple's own
   11. 11// journal states which discharge answered it (ADR-004 d17); the answer's
   12. 12// emissions are then appended under the same attribution.
   13. 13export function resolveDischarge(file: RegisterFile, id: number, emissionCount: number, claim?: { controller: string; offset: number }): void {
   14. 14 file.ephemeral.inFlight.delete(id);↑ no longer waiting on the world
   15. 15 recordTransition(file, "runtime", "DISCHARGE.TABLE", "resolve-discharge", { id, emissions: emissionCount, ...(claim ?? {}) });↑ the change is written into the journal
   16. 16}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in de79653 (2026-09-11)

2. 34The answer enters the log as #5LOG · append

   a wave is settlingengine: next: #5membrane: waiting at #5

   1. #0a listener
   2. #1a doer that asks
   3. #2a note
   4. #3readiness
   5. #4a request
   6. #5the answernewenginemembrane
   7. ·end of the log

   What	before		after
   records in the log	5	→	6
   #5	—	→	the answer · note.answered

   The answer is written at the end of the log as #5 — a fact of the type the doer asked for, note.answered, carrying the doer's name and the intention's name. It came from the world, not from the doer.

   Where it happens appendEmissions()Vol. 02 §4.1 · Vol. 03 §1

   The only function that adds records to the log. Each new record gets the next free number, at the end.

   Specification

   Vol. 02 §4.1 · Vol. 03 §1

   Code

   appendEmissions() in core/registers/append-emissions.ts, line 14: the new record gets the next free number

   Journal

   #4 · LOG · append · offset: 5, kind: domain.fact · by engine

   Picture

   records in the log: 5 → 6

   1. 1// The one LOG writer (Vol. 02 §4.1, Vol. 03 §1): emissions become tuples by
   2. 2// receiving the next dense absolute offset — `base + window.length` — and
   3. 3// nothing else ever grows the log. Each append is journalled under the
   4. 4// ambient context, so a batch born of a propagated tuple carries that
   5. 5// tuple's offset as its cause — the cube's provenance line (ADR-002).
   6. 6
   7. 7import type { WaveEmission, WaveTuple } from "../wave/gate";
   8. 8import type { RegisterFile } from "./register-file";
   9. 9import { recordTransition } from "./record-transition";
   10. 10
   11. 11export function appendEmissions(file: RegisterFile, emissions: readonly WaveEmission[]): void {
   12. 12 const engine = file.registers.engine;
   13. 13 for (const emission of emissions) {
   14. 14 const tuple: WaveTuple = { ...emission, offset: engine.base + engine.window.length };↑ the new record gets the next free number
   15. 15 engine.window.push(tuple);↑ it is added at the end of the log
   16. 16 recordTransition(file, "engine", "LOG", "append", {↑ the change is written into the journal
   17. 17 offset: tuple.offset,
   18. 18 kind: tuple.kind
   19. 19 });
   20. 20 }
   21. 21}

   AGPL-3.0-onlyThe Lab's demonstration environment, as this fragment ran it (build 043cc8b). The code may change, and may differ from the code of a working machine.

   Nest VM core, incubated in the CoAgnes garden · build 043cc8b (2026-09-21) · this file last changed in f36e70d (2026-08-18)