Wave 5 · Review and seal · record #37domain.factcell.sealed

#37 · the Cell is sealed

Nothing was told to hear it, so nothing changes. Nothing inside the Cell will move again.

Came fromthe machineThe machine wrote it while the engine took #36: CellSpace sealed the Cell. step 204

Read as

when the engine took #37

206The engine takes #37ENGINE.CURSOR · propagate
a wave is settlingengine: working on #37membrane: waiting at #36
The log
#0a listener
#1a doer
#2listener: the charter
#3doer: the author
#4listener: charter seen
#5listener: blueprint seen
#6doer: the planner
#7listener: assess · charter
#8listener: assess · result
#9doer: the evaluator
#10the charter wanted
#11the blueprint
#12readiness
#13readiness
#14a request: a charter
#15the charter proposed
#16the charter defined
#17readiness
#18readiness
#19a request: a Cell
#20the seed
#21the Cell is open
#22inner listener
#23inner doer
#24the Cell's context
#25return listener
#26return doer
#27the return address
#28the person's words
#29readiness
#30the private result
#31the result, marked
#32readiness
#33a request: assess
#34assessment proposed
#35the Cell assessed
#36the decisionmembrane
#37the Cell sealedengine · working
#38the export
end of the log
The engine
What before after
pointer — the next record to take #37 #38
The engine moves on to #37, the seal. Nothing was told to hear cell.sealed, so nothing changes.
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
#37 · ENGINE.CURSOR · propagate · offset: 37 · by engine
Picture
pointer — the next record to take: #37 → #38
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	#37	→	#38

when the membrane passed #37

215The membrane passes #37MEMBRANE.CURSOR · sweep
a wave is settlingengine: at the endmembrane: passing #37
The log
#0a listener
#1a doer
#2listener: the charter
#3doer: the author
#4listener: charter seen
#5listener: blueprint seen
#6doer: the planner
#7listener: assess · charter
#8listener: assess · result
#9doer: the evaluator
#10the charter wanted
#11the blueprint
#12readiness
#13readiness
#14a request: a charter
#15the charter proposed
#16the charter defined
#17readiness
#18readiness
#19a request: a Cell
#20the seed
#21the Cell is open
#22inner listener
#23inner doer
#24the Cell's context
#25return listener
#26return doer
#27the return address
#28the person's words
#29readiness
#30the private result
#31the result, marked
#32readiness
#33a request: assess
#34assessment proposed
#35the Cell assessed
#36the decision
#37the Cell sealedmembrane · passing
#38the export
#39readiness
#40a request: present again
end of the logengine
The membrane
What before after
pointer — the next record to pass #37 #38
#37 asks nothing of the world, so the membrane's pointer simply 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
#37 · MEMBRANE.CURSOR · sweep · offset: 37 · by membrane
Picture
pointer — the next record to pass: #37 → #38
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	#37	→	#38

Choose a step in the stack — or press →.

A fact: the Cell, sealed

CellSpace's mark that a Cell is closed for good, naming the assessment and the review it rests on.

#37domain.factcell.sealed the machine

envelope
`offset`	`37`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-cell`This session's lane.
payload
`factType`	`cell.sealed`The fact type — `cell.sealed`, written by CellSpace alone.
payload.data
`cellRef`	`cell@20`The Cell sealed.
`assessmentOffset`	`34`The assessment it rests on.
`reviewOffset`	`36`The review that closed it.

end · #37

In the specificationVol. 03 §1Vol. 03 §5Vol. 12 §5.5

Names it shares with other records

cell@20 — also on #21 the Cell is open, #24 the Cell's context, #27 the return address, #31 the result, marked, #35 the Cell assessed, #36 the decision, #38 the export

The record as the machine keeps it

{
 "offset": 37,
 "kind": "domain.fact",
 "key": "fragment-one-cell",
 "payload": {
  "factType": "cell.sealed",
  "data": {
   "cellRef": "cell@20",
   "assessmentOffset": 34,
   "reviewOffset": 36
  }
 }
}