Wave 2 · record #5domain.factnote.answered

#5 · the world answers, and the machine is quiet

Nothing was told to hear note.answered, so when the engine takes it nothing changes; the membrane passes it, and the machine is quiet. The request and the answer stand side by side, joined by note.ask#1.

Came fromthe worldThe world answered through the membrane — the controller controller.schema.double, the deterministic class's stand-in. step 34

Read as

when the engine took #5

35The engine takes #5ENGINE.CURSOR · propagate
a wave is settlingengine: working on #5membrane: waiting at #5
The log
#0a listener
#1a doer that asks
#2a note
#3readiness
#4a request
#5the answerengine · workingmembrane
end of the log
The engine
What before after
pointer — the next record to take #5 #6
The engine moves on to #5, the answer. Nothing was told to hear note.answered, so nothing changes — and the engine has reached the end.
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
#5 · ENGINE.CURSOR · propagate · offset: 5 · by engine
Picture
pointer — the next record to take: #5 → #6
core/registers/take-next-tuple.ts · build 043cc8b
// ENGINE.CURSOR advance (Vol. 02 §4.1) — the machine's instruction pointer:
// returns the tuple at the cursor and moves it forward exactly once, or null
// at quiescence. Advancing IS the context switch: the ambient wave context
// moves to the propagated tuple in the same movement, so every transition
// journalled during its propagation is attributed to it — the cube's spine.
// The cursor never rewinds.

import type { WaveTuple } from "../wave/gate";
import type { RegisterFile } from "./register-file";
import { recordTransition } from "./record-transition";
import { setDriver, setWaveContext } from "./set-wave-context";

export function takeNextTuple(file: RegisterFile): WaveTuple | null {
const engine = file.registers.engine;
if (engine.cursor >= engine.base + engine.window.length) return null;↑ at the end of the log, the engine stops
const tuple = engine.window[engine.cursor - engine.base];
engine.cursor += 1;↑ the engine's pointer moves on by one
setWaveContext(file, { offset: tuple.offset, phase: "propagate" });
setDriver(file, "engine");
recordTransition(file, "engine", "ENGINE.CURSOR", "propagate", { offset: tuple.offset });↑ the change is written into the journal
return tuple;
}
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)

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

when the membrane passed #5

36The membrane passes #5MEMBRANE.CURSOR · sweep
a wave is settlingengine: at the endmembrane: passing #5
The log
#0a listener
#1a doer that asks
#2a note
#3readiness
#4a request
#5the answermembrane · passing
end of the logengine
The membrane
What before after
pointer — the next record to pass #5 #6
The answer asks nothing more of the world. The membrane reaches the end of the log.
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
#5 · MEMBRANE.CURSOR · sweep · offset: 5 · by membrane
Picture
pointer — the next record to pass: #5 → #6
core/registers/sweep-next-tuple.ts · build 043cc8b
// MEMBRANE.CURSOR advance (Vol. 02 §4.6, Vol. 07 §3): the membrane's own
// reading of the one log — the second reception of one publication, never a
// second truth. The cursor advances exactly once per offset per machine:
// the exactly-once discharge guarantee lives in this movement.

import type { WaveTuple } from "../wave/gate";
import type { RegisterFile } from "./register-file";
import { recordTransition } from "./record-transition";
import { setDriver, setWaveContext } from "./set-wave-context";

export function sweepNextTuple(file: RegisterFile): WaveTuple | null {
const engine = file.registers.engine;
const membrane = file.registers.membrane;
if (membrane.cursor >= engine.base + engine.window.length) return null;
const tuple = engine.window[membrane.cursor - engine.base];
membrane.cursor += 1;↑ the membrane's pointer moves on by one
setWaveContext(file, { offset: tuple.offset, phase: "sweep" });
setDriver(file, "membrane");
recordTransition(file, "membrane", "MEMBRANE.CURSOR", "sweep", { offset: tuple.offset });↑ the change is written into the journal
return tuple;
}
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)

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

Choose a step in the stack — or press →.

A fact: the world's answer

What came back through the membrane, written under the type the doer asked for and carrying the doer's name and the intention's name, so that the request and the answer stay joined in the log. It is the world's record, not the doer's.

#5domain.factnote.answered the world

envelope
`offset`	`5`Its place in the log — the only address a record has. The engine gives it when the record is added, the next free number, and it never changes.
`kind`	`domain.fact`Which of the four kinds of record the machine knows. The kind decides what the payload holds.
`key`	`fragment-one-crossing-det`The lane of the request: the answer comes back on the lane it was asked on.
payload
`factType`	`note.answered`The type the doer asked for.
payload.data
`bindId`	`note.ask`The doer whose request this answers.
`uid`	`note.ask#1`The intention's name, returned — `note.ask#1`. It is how the answer finds its request.
payload.data.result
`answer`	«[deterministic class] answer · from: Is a request to the world a record of the log, or something outside it?»The answer, in the shape asked for. The stand-in writes what it is and what it answered from.

end · #5

In the specificationVol. 03 §1Vol. 03 §4Vol. 03 §5Vol. 04 §5.3Vol. 07 §4.2

Names it shares with other records

note.ask — also on #1 a doer that asks, #4 a request
note.ask#1 — also on #4 a request

The record as the machine keeps it

{
 "offset": 5,
 "kind": "domain.fact",
 "key": "fragment-one-crossing-det",
 "payload": {
  "factType": "note.answered",
  "data": {
   "bindId": "note.ask",
   "uid": "note.ask#1",
   "result": {
    "answer": "[deterministic class] answer · from: Is a request to the world a record of the log, or something outside it?"
   }
  }
 }
}