Wave 2 · record #4domain.factnote.echoed

#4 · the note is released

Nothing was told to hear note.echoed, so when the engine takes it nothing changes. The membrane passes it — the doer never asked the outside world for anything — and the machine is quiet.

Came fromthe machineThe machine wrote it while the engine took #3: the doer note.echo acted — a local action — and released the note. step 26

Read as

when the engine took #4

27The engine takes #4ENGINE.CURSOR · propagate
a wave is settlingengine: working on #4membrane: waiting at #2
The log
#0a listener
#1a doer
#2a notemembrane
#3readiness
#4the releaseengine · working
end of the log
The engine
What before after
pointer — the next record to take #4 #5
The engine moves on to #4, the release. Nothing was told to hear note.echoed, 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
#4 · ENGINE.CURSOR · propagate · offset: 4 · by engine
Picture
pointer — the next record to take: #4 → #5
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	#4	→	#5

when the membrane passed #4

30The membrane passes #4MEMBRANE.CURSOR · sweep
a wave is settlingengine: at the endmembrane: passing #4
The log
#0a listener
#1a doer
#2a note
#3readiness
#4the releasemembrane · passing
end of the logengine
The membrane
What before after
pointer — the next record to pass #4 #5
#4 is local too — the doer never asked the world for anything. 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
#4 · MEMBRANE.CURSOR · sweep · offset: 4 · by membrane
Picture
pointer — the next record to pass: #4 → #5
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	#4	→	#5

Choose a step in the stack — or press →.

A fact: the doer's release

A fact a doer released: its result, stamped with the doer's name and the name of the intention that produced it, so that the act and its result stay joined in the log.

#4domain.factnote.echoed the machine

envelope
`offset`	`4`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-knot-one-bind`The lane it was released on — the same lane as the readiness that woke the doer.
payload
`factType`	`note.echoed`The fact type the doer was told to write.
payload.data
`bindId`	`note.echo`The doer that released it.
`uid`	`note.echo#1`The intention's name: the doer's name and a number — this doer's first act. It joins the release to the act that made it.
payload.data.result
`note`	«The machine hears this note and releases it, unchanged.»The result: what the listener understood, released unchanged.

end · #4

In the specificationVol. 03 §1Vol. 03 §4Vol. 03 §5Vol. 04 §3.1Vol. 06 §6

Names it shares with other records

note.echo — also on #1 a doer

The record as the machine keeps it

{
 "offset": 4,
 "kind": "domain.fact",
 "key": "fragment-one-knot-one-bind",
 "payload": {
  "factType": "note.echoed",
  "data": {
   "bindId": "note.echo",
   "uid": "note.echo#1",
   "result": {
    "note": "The machine hears this note and releases it, unchanged."
   }
  }
 }
}