#3 · the listener is ready

1. 20The engine takes #3ENGINE.CURSOR · propagate

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

   1. #0a listener
   2. #1a doer
   3. #2a notemembrane
   4. #3readinessengine · working
   5. ·end of the log

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

   The engine moves on to #3 — a record the machine wrote itself.

   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

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

   Picture

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

   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. 21The doer opens its rendezvousRDV · open-bank

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

   1. #0a listener
   2. #1a doer
   3. #2a notemembrane
   4. #3readinessengine · working
   5. ·end of the log

   What	before		after
   rendezvous opened	—	→	note.echo

   The doer note.echo waits for note.gate, so this readiness wakes it. It opens its rendezvous — the place where it gathers what its listeners have said.

   Where it happens ensureRendezvous()Vol. 02 §4.5 · Vol. 06 §4.5

   Opens a doer's rendezvous the first time it is woken, and a lane in it for each new key.

   Specification

   Vol. 02 §4.5 · Vol. 06 §4.5

   Code

   ensureRendezvous() in core/registers/ensure-rendezvous.ts, line 13: a rendezvous for this doer

   Journal

   #3 · RDV · open-bank · bindId: note.echo · by bind:note.echo

   Picture

   rendezvous opened: — → note.echo

   1. 1// RDV lane access (Vol. 02 §4.5): one rendezvous state per key lane, created
   2. 2// lazily on the first readiness that reaches the bind — activated at birth
   3. 3// when the bind declares no `on` (a demands-only bind, Vol. 06 §4.5).
   4. 4// Creation is a transition; an existing lane passes through as a read.
   5. 5
   6. 6import type { BindHandle, RendezvousLane, RendezvousRegisters } from "./topology-registers";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9export function ensureRendezvous(bind: BindHandle, key: string | null, activatedAtBirth: boolean): RendezvousLane {
   10. 10 let bank: RendezvousRegisters | undefined = bind.region.rdv.get(bind.bindId);
   11. 11 if (!bank) {
   12. 12 bank = { lanes: new Map(), intentCtr: 0 };
   13. 13 bind.region.rdv.set(bind.bindId, bank);↑ a rendezvous for this doer
   14. 14 // A new bank changes the REGION's RDV register set (Vol. 02 §4.5) — the
   15. 15 // region station journals it, so its document (rdvOrder) folds true
   16. 16 // (the fold oracle, ADR-004 d11).
   17. 17 recordTransition(bind.file, `topology:${bind.region.regionId}`, "RDV", "open-bank", { bindId: bind.bindId });↑ the change is written into the journal
   18. 18 }
   19. 19 let lane = bank.lanes.get(key);
   20. 20 if (!lane) {
   21. 21 lane = { activated: activatedAtBirth, scope: new Map(), projected: false };
   22. 22 bank.lanes.set(key, lane);↑ a lane for this key
   23. 23 recordTransition(bind.file, `topology:${bind.region.regionId}/bind:${bind.bindId}`, "RDV", "open-lane", {↑ the change is written into the journal
   24. 24 key,
   25. 25 activatedAtBirth
   26. 26 });
   27. 27 }
   28. 28 return lane;
   29. 29}

   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 3530f2c (2026-09-07)

3. 22A lane for this sessionRDV · open-lane

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

   1. #0a listener
   2. #1a doer
   3. #2a notemembrane
   4. #3readinessengine · working
   5. ·end of the log

   What	before		after
   lane · this session	—	→	open
   lane · this session · active	—	→	no
   lane · this session · has acted	—	→	no
   intentions named so far	—	→	0

   Inside the rendezvous, a lane for this session's key. It is not active yet: it becomes active when the listener it acts on is ready.

   Where it happens ensureRendezvous()Vol. 02 §4.5 · Vol. 06 §4.5

   Opens a doer's rendezvous the first time it is woken, and a lane in it for each new key.

   Specification

   Vol. 02 §4.5 · Vol. 06 §4.5

   Code

   ensureRendezvous() in core/registers/ensure-rendezvous.ts, line 13: a rendezvous for this doer

   Journal

   #3 · RDV · open-lane · key: fragment-one-knot-one-bind, activatedAtBirth: false · by bind:note.echo

   Picture

   lane · this session: — → open

   1. 1// RDV lane access (Vol. 02 §4.5): one rendezvous state per key lane, created
   2. 2// lazily on the first readiness that reaches the bind — activated at birth
   3. 3// when the bind declares no `on` (a demands-only bind, Vol. 06 §4.5).
   4. 4// Creation is a transition; an existing lane passes through as a read.
   5. 5
   6. 6import type { BindHandle, RendezvousLane, RendezvousRegisters } from "./topology-registers";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9export function ensureRendezvous(bind: BindHandle, key: string | null, activatedAtBirth: boolean): RendezvousLane {
   10. 10 let bank: RendezvousRegisters | undefined = bind.region.rdv.get(bind.bindId);
   11. 11 if (!bank) {
   12. 12 bank = { lanes: new Map(), intentCtr: 0 };
   13. 13 bind.region.rdv.set(bind.bindId, bank);↑ a rendezvous for this doer
   14. 14 // A new bank changes the REGION's RDV register set (Vol. 02 §4.5) — the
   15. 15 // region station journals it, so its document (rdvOrder) folds true
   16. 16 // (the fold oracle, ADR-004 d11).
   17. 17 recordTransition(bind.file, `topology:${bind.region.regionId}`, "RDV", "open-bank", { bindId: bind.bindId });↑ the change is written into the journal
   18. 18 }
   19. 19 let lane = bank.lanes.get(key);
   20. 20 if (!lane) {
   21. 21 lane = { activated: activatedAtBirth, scope: new Map(), projected: false };
   22. 22 bank.lanes.set(key, lane);↑ a lane for this key
   23. 23 recordTransition(bind.file, `topology:${bind.region.regionId}/bind:${bind.bindId}`, "RDV", "open-lane", {↑ the change is written into the journal
   24. 24 key,
   25. 25 activatedAtBirth
   26. 26 });
   27. 27 }
   28. 28 return lane;
   29. 29}

   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 3530f2c (2026-09-07)

4. 23What the listener understood is gatheredRDV.ACTIVATED,RDV.SCOPE · latch-scope

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

   1. #0a listener
   2. #1a doer
   3. #2a notemembrane
   4. #3readinessengine · working
   5. ·end of the log

   What	before		after
   lane · this session · active	no	→	yes
   lane · this session · gathered activation	—	→	note = “The machine hears this note and releases it, unchanged.”

   The readiness activates the lane, and the listener's understanding enters the doer's scope under the name activation. The doer needs nothing else.

   Where it happens latchRendezvousScope()Vol. 02 §4.5 · Vol. 06 §4

   Gathers what a listener understood into the doer's scope — and, from the listener the doer acts on, activates the lane.

   Specification

   Vol. 02 §4.5 · Vol. 06 §4

   Code

   latchRendezvousScope() in core/registers/latch-rendezvous-scope.ts, line 17: the lane is activated

   Journal

   #3 · RDV.ACTIVATED,RDV.SCOPE · latch-scope · key: fragment-one-knot-one-bind, as: activation · by bind:note.echo

   Picture

   lane · this session · active: no → yes

   1. 1// RDV scope latch (Vol. 02 §4.5, Vol. 06 §4): a readiness understanding
   2. 2// enters the bound scope under its declared name — a later readiness of the
   3. 3// same demand refreshes its entry until projection (the latching barrier).
   4. 4// Activation readiness additionally opens the lane (ACTIVATED).
   5. 5
   6. 6import type { BindHandle, RendezvousLane } from "./topology-registers";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9export function latchRendezvousScope(
   10. 10 bind: BindHandle,
   11. 11 lane: RendezvousLane,
   12. 12 key: string | null,
   13. 13 as: string,
   14. 14 understanding: unknown,
   15. 15 options: { activates: boolean }
   16. 16): void {
   17. 17 if (options.activates) lane.activated = true;↑ the lane is activated
   18. 18 lane.scope.set(as, understanding);↑ the understanding is gathered
   19. 19 recordTransition(↑ the change is written into the journal
   20. 20 bind.file,
   21. 21 `topology:${bind.region.regionId}/bind:${bind.bindId}`,
   22. 22 options.activates ? "RDV.ACTIVATED,RDV.SCOPE" : "RDV.SCOPE",
   23. 23 "latch-scope",
   24. 24 { key, as }
   25. 25 );
   26. 26}

   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)

5. 24The doer acts — onceRDV.PROJECTED · latch-projection

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

   1. #0a listener
   2. #1a doer
   3. #2a notemembrane
   4. #3readinessengine · working
   5. ·end of the log

   What	before		after
   lane · this session · has acted	no	→	yes

   The lane is latched: the doer acts now, and never again on this lane. That is why a doer's result is a release, not a stream.

   Where it happens latchRendezvousProjection()Vol. 02 §4.5 · Vol. 06 §4.2

   Latches a doer's lane after it acts, so that it never acts on that lane again.

   Specification

   Vol. 02 §4.5 · Vol. 06 §4.2

   Code

   latchRendezvousProjection() in core/registers/latch-rendezvous-projection.ts, line 9: the lane is latched for good

   Journal

   #3 · RDV.PROJECTED · latch-projection · key: fragment-one-knot-one-bind · by bind:note.echo

   Picture

   lane · this session · has acted: no → yes

   1. 1// RDV.PROJECTED latch (Vol. 02 §4.5, Vol. 06 §4.2): one-shot — once the
   2. 2// scope is judged and the intention projected (or rejected at a gate), the
   3. 3// lane never fires again. The latch never reopens; revision is fresh binds.
   4. 4
   5. 5import type { BindHandle, RendezvousLane } from "./topology-registers";
   6. 6import { recordTransition } from "./record-transition";
   7. 7
   8. 8export function latchRendezvousProjection(bind: BindHandle, lane: RendezvousLane, key: string | null): void {
   9. 9 lane.projected = true;↑ the lane is latched for good
   10. 10 recordTransition(bind.file, `topology:${bind.region.regionId}/bind:${bind.bindId}`, "RDV.PROJECTED", "latch-projection", {↑ the change is written into the journal
   11. 11 key
   12. 12 });
   13. 13}

   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)

6. 25The intention gets its nameINTENT.CTR · mint-uid

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

   1. #0a listener
   2. #1a doer
   3. #2a notemembrane
   4. #3readinessengine · working
   5. ·end of the log

   What	before		after
   intentions named so far	0	→	1

   What the doer is about to do gets a unique name, note.echo#1, from a counter that never goes back. The release will carry that name.

   Where it happens nextIntentionUid()Vol. 02 §4.5 · Vol. 02 §4.7

   Gives a doer's next intention its unique name, from a counter that never goes back.

   Specification

   Vol. 02 §4.5 · Vol. 02 §4.7

   Code

   nextIntentionUid() in core/registers/next-intention-uid.ts, line 12: the counter moves on

   Journal

   #3 · INTENT.CTR · mint-uid · uid: note.echo#1 · by bind:note.echo

   Picture

   intentions named so far: 0 → 1

   1. 1// INTENT.CTR advance (Vol. 02 §4.5, §4.7 rule 3): the service-intention uid
   2. 2// sequence, shared across lanes and never reset — uids stay unique per
   3. 3// machine instance, which is exactly why this counter belongs to the durable
   4. 4// stratum and must survive a snapshot/restore (ADR-002 decision 4).
   5. 5
   6. 6import type { BindHandle } from "./topology-registers";
   7. 7import { recordTransition } from "./record-transition";
   8. 8
   9. 9export function nextIntentionUid(bind: BindHandle): string {
   10. 10 const bank = bind.region.rdv.get(bind.bindId);
   11. 11 if (!bank) throw new Error(`Rendezvous bank missing for bind '${bind.bindId}'.`);
   12. 12 bank.intentCtr += 1;↑ the counter moves on
   13. 13 const uid = `${bind.bindId}#${bank.intentCtr}`;↑ the name: the doer's name and the count
   14. 14 recordTransition(bind.file, `topology:${bind.region.regionId}/bind:${bind.bindId}`, "INTENT.CTR", "mint-uid", {↑ the change is written into the journal
   15. 15 uid
   16. 16 });
   17. 17 return uid;
   18. 18}

   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)

7. 26The release enters the log as #4LOG · append

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

   1. #0a listener
   2. #1a doer
   3. #2a notemembrane
   4. #3readinessengine · working
   5. #4the releasenew
   6. ·end of the log

   What	before		after
   records in the log	4	→	5
   #4	—	→	the release · note.echoed

   The doer's action is local: it releases what it gathered as a new fact, note.echoed, written at the end of the log as #4.

   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

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

   Picture

   records in the log: 4 → 5

   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)

when the membrane passed #3

1. 29The membrane passes #3MEMBRANE.CURSOR · sweep

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

   1. #0a listener
   2. #1a doer
   3. #2a note
   4. #3readinessmembrane · passing
   5. #4the release
   6. ·end of the logengine

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

   #3, the readiness, asks nothing of the outside world either. The membrane's pointer moves on.

   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

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

   Picture

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

   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)