Wave 1 · record #0sys.knot.defined

#0 · the first fragment's listener

When the engine takes it, the machine stores the listener and gives it a trial lane. This time its slot will be filled by a Cell.

Came froma personThe fragment's author added it at the door: the first half of the template. step 2

Read as

when it came in at the door

2Record #0 enters the logLOG · append
a wave is settlingengine: next: #0membrane: waiting at #0
The log
#0a listenernewenginemembrane
end of the log
The log
What before after
records in the log 0 1
#0 — a listener · sys.knot.defined
The door adds the first record: a description of a listener — the first fragment's listener, note.gate, unchanged. It gets number #0.
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
LOG · append · offset: 0, kind: sys.knot.defined · by engine
Picture
records in the log: 0 → 1
core/registers/append-emissions.ts · build 043cc8b
// The one LOG writer (Vol. 02 §4.1, Vol. 03 §1): emissions become tuples by
// receiving the next dense absolute offset — `base + window.length` — and
// nothing else ever grows the log. Each append is journalled under the
// ambient context, so a batch born of a propagated tuple carries that
// tuple's offset as its cause — the cube's provenance line (ADR-002).

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

export function appendEmissions(file: RegisterFile, emissions: readonly WaveEmission[]): void {
const engine = file.registers.engine;
for (const emission of emissions) {
const tuple: WaveTuple = { ...emission, offset: engine.base + engine.window.length };↑ the new record gets the next free number
engine.window.push(tuple);↑ it is added at the end of the log
recordTransition(file, "engine", "LOG", "append", {↑ the change is written into the journal
offset: tuple.offset,
kind: tuple.kind
});
}
}
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)

What	before		after
records in the log	0	→	1
#0	—	→	a listener · `sys.knot.defined`

when the engine took #0

4The engine takes #0ENGINE.CURSOR · propagate
a wave is settlingengine: working on #0membrane: waiting at #0
The log
#0a listenerengine · workingmembrane
#1a doer
end of the log
The engine
What before after
pointer — the next record to take #0 #1
The engine's pointer moves past #0, and the machine reacts to it.
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
#0 · ENGINE.CURSOR · propagate · offset: 0 · by engine
Picture
pointer — the next record to take: #0 → #1
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)
5The listener is added to the figureKNOT.DEFS · register-knot
a wave is settlingengine: working on #0membrane: waiting at #0
The log
#0a listenerengine · workingmembrane
#1a doer
end of the log
The figure
What before after
listener note.gate — hears note.given → slot note; ready when note != null
The machine writes the listener's description into its list of listeners, under the name note.gate. Nothing was there before under that name.
Where it happens registerKnotDefinition()Vol. 02 §4.2 · Vol. 04 §2.1
Stores a listener's description under its name and gives it a bank of lanes with one trial lane.
Specification
Vol. 02 §4.2 · Vol. 04 §2.1
Code
registerKnotDefinition() in core/registers/register-knot-definition.ts, line 21: the description is stored under its name
Journal
#0 · KNOT.DEFS · register-knot · id: note.gate, strategy: deterministic, replaced: false · by region:root
Picture
listener note.gate: — → hears note.given → slot note; ready when note != null
core/registers/register-knot-definition.ts · build 043cc8b
// KNOT.DEFS write (Vol. 02 §4.2): the definition payload lands as data, and
// re-registration of an id replaces the definition AND resets its clew bank
// to a fresh null-key probe — accumulated clews of the old definition are
// discarded (the machine's only 'edit'). The probe clew is supplied by the
// resolved executor so invalid configuration has already failed at the
// factory (Vol. 04 §2.1); the stale executor cache entry is dropped here so
// the replacement takes effect for the next tuple.

import type { KnotDefinedPayload } from "../topology/gate";
import type { ClewRegisters, TopologyRegisters } from "./topology-registers";
import type { RegisterFile } from "./register-file";
import { recordTransition } from "./record-transition";

export function registerKnotDefinition(
file: RegisterFile,
region: TopologyRegisters,
payload: KnotDefinedPayload,
probeClew: ClewRegisters
): void {
const replaced = region.knotDefs.has(payload.id);
region.knotDefs.set(payload.id, payload);↑ the description is stored under its name
region.clews.set(payload.id, new Map([[null, probeClew]]));↑ its bank of lanes, with a trial lane
file.ephemeral.knotExecutors.delete(`${region.regionId}/${payload.id}`);
recordTransition(file, `topology:${region.regionId}`, "KNOT.DEFS", "register-knot", {↑ the change is written into the journal
id: payload.id,
strategy: payload.strategy,
replaced
});
// The clew station is born here, with its null-key probe lane — journaled
// on the station itself so fold(journal) holds it before any lane opens
// (the document model's oracle, ADR-004 d10; Vol. 02 §4.5).
recordTransition(file, `topology:${region.regionId}/clew:${payload.id}`, "CLEWS", "open-clew", { key: null, probe: true, replaced }, "registerKnotDefinition");↑ the change is written into the journal
}
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)
A finding for the machine's authors, recorded and left as it is: the journal stamps CLEWS·open-clew → core/registers/ensure-clew.ts for registerKnotDefinition(), which lives in core/registers/register-knot-definition.ts (the op map's file for that register · action).
6It gets a trial laneCLEWS · open-clew
a wave is settlingengine: working on #0membrane: waiting at #0
The log
#0a listenerengine · workingmembrane
#1a doer
end of the log
The listener note.gate · appears
What before after
lane · trial lane (no key) — open
Before any note arrives, the listener gets one trial lane with no key — proof that its description works.
Where it happens registerKnotDefinition()Vol. 02 §4.2 · Vol. 04 §2.1
Stores a listener's description under its name and gives it a bank of lanes with one trial lane.
Specification
Vol. 02 §4.2 · Vol. 04 §2.1
Code
registerKnotDefinition() in core/registers/register-knot-definition.ts, line 21: the description is stored under its name
Journal
#0 · CLEWS · open-clew · key: null, probe: true, replaced: false · by region:root
Picture
lane · trial lane (no key): — → open
core/registers/register-knot-definition.ts · build 043cc8b
// KNOT.DEFS write (Vol. 02 §4.2): the definition payload lands as data, and
// re-registration of an id replaces the definition AND resets its clew bank
// to a fresh null-key probe — accumulated clews of the old definition are
// discarded (the machine's only 'edit'). The probe clew is supplied by the
// resolved executor so invalid configuration has already failed at the
// factory (Vol. 04 §2.1); the stale executor cache entry is dropped here so
// the replacement takes effect for the next tuple.

import type { KnotDefinedPayload } from "../topology/gate";
import type { ClewRegisters, TopologyRegisters } from "./topology-registers";
import type { RegisterFile } from "./register-file";
import { recordTransition } from "./record-transition";

export function registerKnotDefinition(
file: RegisterFile,
region: TopologyRegisters,
payload: KnotDefinedPayload,
probeClew: ClewRegisters
): void {
const replaced = region.knotDefs.has(payload.id);
region.knotDefs.set(payload.id, payload);↑ the description is stored under its name
region.clews.set(payload.id, new Map([[null, probeClew]]));↑ its bank of lanes, with a trial lane
file.ephemeral.knotExecutors.delete(`${region.regionId}/${payload.id}`);
recordTransition(file, `topology:${region.regionId}`, "KNOT.DEFS", "register-knot", {↑ the change is written into the journal
id: payload.id,
strategy: payload.strategy,
replaced
});
// The clew station is born here, with its null-key probe lane — journaled
// on the station itself so fold(journal) holds it before any lane opens
// (the document model's oracle, ADR-004 d10; Vol. 02 §4.5).
recordTransition(file, `topology:${region.regionId}/clew:${payload.id}`, "CLEWS", "open-clew", { key: null, probe: true, replaced }, "registerKnotDefinition");↑ the change is written into the journal
}
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)
A finding for the machine's authors, recorded and left as it is: the journal stamps CLEWS·open-clew → core/registers/ensure-clew.ts for registerKnotDefinition(), which lives in core/registers/register-knot-definition.ts (the op map's file for that register · action).

What	before		after
pointer — the next record to take	#0	→	#1

What	before		after
listener `note.gate`	—	→	hears `note.given` → slot note; ready when note != null

What	before		after
lane · trial lane (no key)	—	→	open

when the membrane passed #0

9The membrane passes #0MEMBRANE.CURSOR · sweep
a wave is settlingengine: at the endmembrane: passing #0
The log
#0a listenermembrane · passing
#1a doer
end of the logengine
The membrane
What before after
pointer — the next record to pass #0 #1
With nothing left for the engine to take, the membrane passes over the new records. #0 asks nothing of the world.
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
#0 · MEMBRANE.CURSOR · sweep · offset: 0 · by membrane
Picture
pointer — the next record to pass: #0 → #1
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	#0	→	#1

Choose a step in the stack — or press →.

A listener's definition

Brings a listener into the machine: its name, how it decides it is ready, what it collects into which slot, and the condition that makes it ready. Four sorts are written here: the first fragment's listener, the admission figure's, the Cell's inner one — written by the machine when the Cell opened — and the return listener.

#0sys.knot.defined a person

envelope
`offset`	`0`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`	`sys.knot.defined`Which of the four kinds of record the machine knows. The kind decides what the payload holds.
`key`	∅No lane (∅): a definition belongs to the whole machine, not to one lane.
payload
`id`	`note.gate`The listener's name, unique in the machine. A listener inside a Cell carries the Cell's name before its own: cell@20::…
`strategy`	`deterministic`How it decides it is ready. Deterministic: by a plain condition over its slots — nothing is asked of the world.
payload.config
`condition`	«note != null»When it is ready — a condition over its slots, such as: the slot note holds something.
`meta`	title · gloss · fields ×1Words for people — a title, a gloss, the field a person fills; for what the act sowed, which act and for which slot. The machine's own parts never read them.
payload.config.wind.collect[0]
`as`	`note`The name of the slot the heard value goes into.
`match_type`	`note.given`The type of fact it hears.
`reduce`	`latest`Which value the slot keeps. Latest: the newest replaces the one before.
`field`	`text`Which field of the heard fact goes into the slot.

end · #0

In the specificationVol. 03 §1Vol. 03 §2Vol. 03 §5Vol. 04 §2.1Vol. 05 §3Vol. 05 §4Vol. 12 §4

Names it shares with other records

note.gate — also on #42 readiness

The record as the machine keeps it

{
 "offset": 0,
 "kind": "sys.knot.defined",
 "key": null,
 "payload": {
  "id": "note.gate",
  "strategy": "deterministic",
  "config": {
   "meta": {
    "title": "A note",
    "gloss": "One knot: it hears a note and is ready as soon as it has one.",
    "fields": [
     {
      "name": "text",
      "label": "A note, in your words",
      "kind": "text",
      "for": "note"
     }
    ]
   },
   "wind": {
    "collect": [
     {
      "as": "note",
      "match_type": "note.given",
      "reduce": "latest",
      "field": "text"
     }
    ]
   },
   "condition": "note != null"
  }
 }
}