@hatiolab/figure-model 0.3.2 → 0.3.4

package/dist/graph.js

@@ -708,6 +708,62 @@ function checkedValue(value, type, path) {
     }
     return value;
 }
+/*
+  Who owns what an instance's evaluator returns (completeness review 2026-10-04, F1). Its slots hold the values it runs
+  on, and an unchanged one is handed on, as the same object, to the next result and stays in the results given before.
+  A caller's write into one used to reach the next evaluation (a shape's size.x written as 999 came back as 999).
+
+  Shapes are frozen where they are: they are made when a design value changes, and a renderer keeps its plan while a
+  body's shape is the same object. Everything else a result holds -- poses, placed things, rows, bodies -- is a frozen
+  copy of the slot's value, made when the value changes and handed on unchanged after that; the slots themselves stay
+  as they were made. Freezing the slots in place cost more than the copies: a frozen list of numbers holds them boxed,
+  so a pose step reading frozen poses ran 50% slower, and the 6-axis robot's evaluation with every joint moved took
+  35 us instead of 12 (2026-10-04, Node 24). A whole evaluation keeps nothing, and all of it is the caller's.
+*/
+function frozen(v) {
+    if (!v || typeof v !== 'object' || Object.isFrozen(v))
+        return v;
+    Object.freeze(v);
+    if (Array.isArray(v))
+        for (let i = 0; i < v.length; i++)
+            frozen(v[i]);
+    else
+        for (const k in v)
+            frozen(v[k]);
+    return v;
+}
+/**
+ * The frozen copy of a value a result holds. Something already frozen -- a shape, or a copy made before -- is itself;
+ * \`made\` holds the copies made in this call, so a pose a body and a value both carry is copied once.
+ */
+function publicOf(v, made) {
+    if (!v || typeof v !== 'object' || Object.isFrozen(v))
+        return v;
+    let p = made.get(v);
+    if (p)
+        return p;
+    if (isPose(v)) {
+        const r = new Array(v.r.length);
+        for (let i = 0; i < r.length; i++)
+            r[i] = Object.freeze(v.r[i].slice());
+        p = { r: Object.freeze(r), t: Object.freeze(v.t.slice()) };
+    }
+    else if (Array.isArray(v)) {
+        p = new Array(v.length);
+        for (let i = 0; i < v.length; i++)
+            p[i] = publicOf(v[i], made);
+    }
+    else {
+        p = {};
+        for (const k in v)
+            p[k] = publicOf(v[k], made);
+    }
+    Object.freeze(p);
+    made.set(v, p);
+    return p;
+}
+/** A geometry node's bodies: a placement's one, a row's many. */
+const bodiesOf = (g, id) => (Array.isArray(g) ? g : [{ id, ...g }]);
 /** Whether a value's own keys are exactly these two, in this order -- without making the list of them. */
 const keysAre = (v, a, b) => {
     if (!v || typeof v !== 'object' || Array.isArray(v))
@@ -785,6 +841,13 @@ const finiteObjects = new WeakSet();
 /** What a pose step may change: numbers, transforms, and what carries a pose. A shape, a layout, a count or a flag may not. */
 const POSE_KINDS = ['transform', 'placed', 'assembly', 'collection', 'point'];
 const notPose = (t) => (Array.isArray(t) || POSE_KINDS.includes(t?.kind) ? undefined : String(t?.kind ?? 'value'));
+/**
+ * Compiles a graph whatever order its nodes are written in, and however deep its chains (the walk keeps its own stack).
+ * It holds no size limit of its own: the byte and node limits -- 1 MiB of JSON, nesting 64, \`FIGURE_DOCUMENT_NODE_LIMIT\`
+ * nodes -- are the document's and the asset's (\`compileFigureDocument\`, \`compileFigureAsset\`), the entrances for what
+ * arrives from outside. A caller compiling a graph directly answers for its size, and its compile and evaluation take
+ * time and memory in proportion to it.
+ */
 export function compileFigureGraph(source) {
     return compileInternal(source);
 }
@@ -843,41 +906,62 @@ function compileInternal(source) {
             assign(output, n.id);
         nodes.set(n.id, n);
     }
+    /*
+      Depth first, in declaration order: a node is typed once every node it reads is (completeness review 2026-10-04, F3).
+      The walk keeps its own stack -- a chain of 2,000 nodes written last-first overflowed the engine's -- and gives the
+      order, the refusals and the cycle path the recursive walk gave: a cycle is named from where the walk entered it.
+    */
     const visited = new Set();
-    function visit(name) {
-        if (visited.has(name))
-            return;
-        if (active.includes(name))
+    const onPath = new Set();
+    const path = [];
+    const enter = (name) => {
+        if (onPath.has(name))
             fail('CYCLE', name, [...active, name].join(' -> '));
         active.push(name);
-        const n = nodes.get(name), op = ops[n.op];
-        const inputTypes = n.args.map(ref => {
-            if (!writers.has(ref))
-                fail('UNKNOWN_REFERENCE', n.id, ref);
-            if (!types.has(ref))
-                visit(writers.get(ref));
-            return types.get(ref);
-        });
-        const resultTypes = op.types(inputTypes, n.id, n);
-        const depends = new Set();
-        for (const ref of n.args)
-            for (const s of dependence.get(ref) ?? [])
-                depends.add(s);
-        if (depends.size) {
-            if (op.state === undefined)
-                fail('STATE_POLICY', n.id, `${n.op} declares no policy for a state-dependent argument (${[...depends].join(', ')})`);
-            if (op.state === 'refuses')
-                fail('TOPOLOGY_STATE', n.id, `${n.op} must depend on design inputs only; it depends on ${[...depends].join(', ')}`);
+        onPath.add(name);
+        path.push({ n: nodes.get(name), at: 0, inputTypes: [] });
+    };
+    for (const root of nodes.keys()) {
+        if (visited.has(root))
+            continue;
+        enter(root);
+        while (path.length) {
+            const frame = path[path.length - 1];
+            const n = frame.n;
+            if (frame.at < n.args.length) {
+                const ref = n.args[frame.at];
+                if (!writers.has(ref))
+                    fail('UNKNOWN_REFERENCE', n.id, ref);
+                if (!types.has(ref)) {
+                    enter(writers.get(ref));
+                    continue;
+                }
+                frame.inputTypes.push(types.get(ref));
+                frame.at++;
+                continue;
+            }
+            const op = ops[n.op];
+            const resultTypes = op.types(frame.inputTypes, n.id, n);
+            const depends = new Set();
+            for (const ref of n.args)
+                for (const s of dependence.get(ref) ?? [])
+                    depends.add(s);
+            if (depends.size) {
+                if (op.state === undefined)
+                    fail('STATE_POLICY', n.id, `${n.op} declares no policy for a state-dependent argument (${[...depends].join(', ')})`);
+                if (op.state === 'refuses')
+                    fail('TOPOLOGY_STATE', n.id, `${n.op} must depend on design inputs only; it depends on ${[...depends].join(', ')}`);
+            }
+            op.ports.forEach((p, i) => types.set(n.outputs[p], resultTypes[i]));
+            if (depends.size)
+                Object.values(n.outputs).forEach(ref => dependence.set(ref, new Set(depends)));
+            path.pop();
+            active.pop();
+            onPath.delete(n.id);
+            visited.add(n.id);
+            order.push(n);
         }
-        op.ports.forEach((p, i) => types.set(n.outputs[p], resultTypes[i]));
-        if (depends.size)
-            Object.values(n.outputs).forEach(ref => dependence.set(ref, new Set(depends)));
-        active.pop();
-        visited.add(name);
-        order.push(n);
     }
-    for (const name of nodes.keys())
-        visit(name);
     /** An instance evaluator's walk, made on first use (`walkOf`). */
     let walk;
     /** The pose analyses made so far, by what reads the graph (`poseAnalysisOf`). */
@@ -938,8 +1022,7 @@ function compileInternal(source) {
                 changed.add(n.outputs[p]);
             });
             if (op.geometry) {
-                const g = op.geometry(args, out, n);
-                const own = Array.isArray(g) ? g : [{ id: n.id, ...g }];
+                const own = bodiesOf(op.geometry(args, out, n), n.id);
                 bodies.set(n.id, own);
                 geometry.push(...own);
             }
@@ -970,25 +1053,126 @@ function compileInternal(source) {
             let ids = [];
             /* What reads this graph does not change under an evaluator: its analysis is looked up once. */
             let analysis;
-            const evaluated = (result, whole) => {
-                const now = result.geometry.map((g) => g.id);
-                if (whole || now.length !== ids.length || now.some((id, i) => id !== ids[i]))
+            /* Every call, refused or not; a pose step's \`read\` and \`changed\` answer while it is still the last one. */
+            let calls = 0;
+            /* Whether the bodies are others than the last ones (a whole evaluation always is): the generation moves on. */
+            const moved = (now, whole) => {
+                const other = whole || now.length !== ids.length || now.some((id, i) => id !== ids[i]);
+                if (other)
                     generation++;
                 ids = now;
+                return other;
+            };
+            const evaluated = (result, whole) => {
+                moved(result.geometry.map((g) => g.id), whole);
                 return result;
             };
             const evaluate = (input) => {
+                calls++;
                 const previous = kept;
                 kept = undefined;
                 if (!previous) {
-                    const whole = run(input, undefined);
-                    kept = hold(whole.kept, whole.result);
-                    return evaluated(whole.result, true);
+                    kept = hold(run(input, undefined).kept);
+                    return evaluated({ values: { ...kept.values }, geometry: kept.geometry.slice() }, true);
                 }
-                const result = step(input, previous);
+                const result = step(input, previous, true);
                 kept = previous;
                 return evaluated(result, false);
             };
+            /*
+              An evaluation told as its changes (\`FigureGraphChanges\`, chosen with \`changes: true\`). It runs what an evaluation
+              runs, in the same order; what a snapshot would publish waits for the next \`evaluate\` (\`Held.pending\`). Told: the
+              bodies that ran, by slot -- every slot when the bodies are others than the last ones, with the new ids and keys.
+            */
+            const changesOf = (input, why) => {
+                const call = ++calls;
+                const previous = kept;
+                kept = undefined;
+                /* What pose steps moved since the last evaluation: an evaluation drops their state, so it is taken first. */
+                const posed = previous?.fast;
+                let ran;
+                if (!previous) {
+                    kept = hold(run(input, undefined).kept, false);
+                    ran = w().shapes;
+                }
+                else {
+                    ran = step(input, previous, false);
+                    kept = previous;
+                }
+                const held = kept;
+                const now = [], keys = [], paths = [], indexes = [];
+                const start = new Int32Array(w().nodes.length);
+                for (const index of w().shapes) {
+                    start[index] = now.length;
+                    for (const b of held.bodies[index] ?? []) {
+                        now.push(b.id);
+                        keys.push(b.key);
+                        /* A row's copy keeps the path through its rows: a frozen copy, told with the structure only. */
+                        paths.push(b.path ? Object.freeze(b.path.slice()) : undefined);
+                        indexes.push(b.index);
+                    }
+                }
+                const structure = moved(now, !previous);
+                const told = structure ? w().shapes : posed?.wrote.size ? [...new Set([...ran, ...posed.wrote])].sort((a, b) => a - b) : ran;
+                let count = 0;
+                for (const index of told)
+                    count += held.bodies[index]?.length ?? 0;
+                const bodies = new Int32Array(count), poses = new Float64Array(count * 12), shapes = new Array(count);
+                let k = 0;
+                for (const index of told)
+                    (held.bodies[index] ?? []).forEach((b, j) => {
+                        bodies[k] = start[index] + j;
+                        shapes[k] = b.shape ?? null;
+                        const o = k * 12;
+                        /* A body with no pose (a scalar provider) has no numbers: NaN, never a pose made up for it. */
+                        if (b.pose) {
+                            const r = b.pose.r, t = b.pose.t;
+                            poses[o] = r[0][0];
+                            poses[o + 1] = r[0][1];
+                            poses[o + 2] = r[0][2];
+                            poses[o + 3] = r[1][0];
+                            poses[o + 4] = r[1][1];
+                            poses[o + 5] = r[1][2];
+                            poses[o + 6] = r[2][0];
+                            poses[o + 7] = r[2][1];
+                            poses[o + 8] = r[2][2];
+                            poses[o + 9] = t[0];
+                            poses[o + 10] = t[1];
+                            poses[o + 11] = t[2];
+                        }
+                        else
+                            poses.fill(NaN, o, o + 12);
+                        k++;
+                    });
+                const epoch = held.epoch;
+                const live = () => {
+                    if (calls !== call)
+                        fail('STEP_EXPIRED', 'advance', 'read a step\'s changes before the next call on its evaluator');
+                };
+                return {
+                    kind: 'changes',
+                    generation,
+                    why,
+                    ...(structure ? { structure: { ids: now, keys, paths, indexes } } : {}),
+                    bodies,
+                    poses,
+                    shapes,
+                    /* A number or a flag as it is; anything else a frozen copy made for this read -- never the evaluator's own. */
+                    read: (ref) => {
+                        live();
+                        const s = w().slot.get(ref);
+                        if (s === undefined)
+                            fail('TARGET_ABSENT', ref, 'no such value');
+                        return publicOf(held.slots[s], new Map());
+                    },
+                    changed: (ref) => {
+                        live();
+                        const s = w().slot.get(ref);
+                        return s !== undefined && (structure || held.mark[s] === epoch || !!posed?.moved.has(s));
+                    }
+                };
+            };
+            const w = () => walkOf();
             return {
                 evaluate,
                 /**
@@ -998,22 +1182,69 @@ function compileInternal(source) {
                  */
                 advance(input, ordinary) {
                     if (kept && !ordinary) {
+                        const call = ++calls;
                         const previous = kept;
                         kept = undefined;
                         const step = poseStep(input, previous, (analysis ??= poseAnalysisOf(options.reads)));
                         kept = previous;
-                        if ('result' in step)
-                            return { ...step.result, generation };
+                        if ('result' in step) {
+                            /*
+                              A pose step is not a snapshot: \`read\` and \`changed\` look into the evaluator as this step left it, and
+                              the next call moves it on. Past that they are refused rather than answering with a later step's values.
+                            */
+                            const { read, changed } = step.result;
+                            const live = () => {
+                                if (calls !== call)
+                                    fail('STEP_EXPIRED', 'advance', 'read a pose step before the next call on its evaluator');
+                            };
+                            return {
+                                ...step.result,
+                                generation,
+                                read: (ref) => (live(), read(ref)),
+                                changed: (ref) => (live(), changed(ref))
+                            };
+                        }
+                        if (options.changes)
+                            return changesOf(input, step.why);
                         const result = evaluate(input);
                         return { kind: 'evaluation', result, generation, why: step.why };
                     }
                     const bound = !!kept;
+                    const why = { code: bound ? ordinary : 'NOT_BOUND' };
+                    if (options.changes)
+                        return changesOf(input, why);
                     const result = evaluate(input);
-                    return { kind: 'evaluation', result, generation, why: { code: bound ? ordinary : 'NOT_BOUND' } };
+                    return { kind: 'evaluation', result, generation, why };
                 },
                 /** Which inputs take the fast path for what reads this graph, and why the others do not. */
                 poseInputs() {
                     return poseAnalysisOf(options.reads).inputs.map(a => ({ ...a }));
+                },
+                /**
+                 * One value as the evaluator stands now -- after the last evaluation and the pose steps since -- without a
+                 * snapshot: a number or a flag as it is, anything else a frozen copy made for this read, the caller's to keep.
+                 * Refused (NOT_BOUND) before the first evaluation and after a refusal.
+                 */
+                value(ref) {
+                    if (!kept)
+                        fail('NOT_BOUND', ref, 'evaluate before reading a value');
+                    const s = w().slot.get(ref);
+                    if (s === undefined)
+                        fail('TARGET_ABSENT', ref, 'no such value');
+                    /* The pose steps' slots start as the evaluation's and move on with each step: they are the latest. */
+                    const fast = kept.fast;
+                    if (!fast)
+                        return publicOf(kept.slots[s], new Map());
+                    /*
+                      Except a row nothing reads, whose copies a pose step writes as poses alone (its slot stays the evaluation's):
+                      asked for, it is run from the steps' slots, as an evaluation would run it.
+                    */
+                    const writer = w().nodes.find(node => node.outs.includes(s));
+                    if (writer && fast.wrote.has(writer.index) && !fast.moved.has(s)) {
+                        const out = writer.op.run(writer.args.map(a => fast.slots[a]), writer.n.id, writer.n);
+                        return publicOf(out[writer.outs.indexOf(s)], new Map());
+                    }
+                    return publicOf(fast.slots[s], new Map());
                 }
             };
         }
@@ -1072,30 +1303,68 @@ function compileInternal(source) {
             readers,
             reach: m.inputs.map((_, i) => reachOf([i])),
             always,
-            shapes: nodes.filter(node => node.op.geometry).map(node => node.index)
+            shapes: nodes.filter(node => node.op.geometry).map(node => node.index),
+            shapeSlot: keys.map(k => types.get(k)?.kind === 'shape')
         };
         return walk;
     }
-    /** What an evaluator keeps between calls: its slots, its bodies by node, and its own copy of the last result. */
-    function hold(whole, result) {
+    /**
+     * What an evaluator keeps between calls: its slots, its bodies by node, and the last result as a caller is given it --
+     * frozen copies of the slots' values and bodies (\`publicOf\`), shapes frozen where they are.
+     */
+    function hold(whole, publish = true) {
         const w = walkOf();
+        const slots = w.keys.map(k => whole.values.get(k));
+        slots.forEach((v, s) => w.shapeSlot[s] && frozen(v));
+        const bodies = w.nodes.map(node => whole.bodies.get(node.n.id));
+        /*
+          An evaluator told as changes publishes nothing until a snapshot is asked for: everything is pending, and the record
+          holds its keys in the order a snapshot gives them.
+        */
+        if (!publish) {
+            const values = {};
+            for (const k of w.keys)
+                values[k] = undefined;
+            return {
+                raw: m.inputs.map(p => whole.input[p.id]),
+                slots,
+                bodies,
+                shown: bodies.map(() => undefined),
+                values,
+                geometry: [],
+                mark: new Int32Array(w.keys.length),
+                ran: new Int32Array(w.nodes.length),
+                epoch: 0,
+                pending: { nodes: new Set(w.shapes.filter(index => bodies[index])), slots: new Set(w.keys.keys()) }
+            };
+        }
+        const made = new Map();
+        const shown = bodies.map(own => own?.map(b => publicOf(b, made)));
+        const values = {};
+        w.keys.forEach((k, s) => (values[k] = publicOf(slots[s], made)));
+        const geometry = [];
+        for (const index of w.shapes)
+            if (shown[index])
+                geometry.push(...shown[index]);
         return {
             raw: m.inputs.map(p => whole.input[p.id]),
-            slots: w.keys.map(k => whole.values.get(k)),
-            bodies: w.nodes.map(node => whole.bodies.get(node.n.id)),
-            /* Copies: the caller owns what it was given, and what it does with it never reaches the next evaluation. */
-            values: { ...result.values },
-            geometry: result.geometry.slice(),
+            slots,
+            bodies,
+            shown,
+            values,
+            geometry,
             mark: new Int32Array(w.keys.length),
             ran: new Int32Array(w.nodes.length),
-            epoch: 0
+            epoch: 0,
+            pending: { nodes: new Set(), slots: new Set() }
         };
     }
     /*
       One evaluation after the first. The result is the one a whole evaluation gives: the same refusals for the same
       inputs, the same values in the same order, an unchanged body as the same object. What is returned is a snapshot
-      of its own -- a new values record and a new geometry list, copied from the evaluator's own -- so a result kept by a
-      caller does not change when the evaluator moves on, and a caller writing into one does not change the next.
+      of its own -- a new values record and a new geometry list, copied from the evaluator's own, holding frozen values and
+      bodies -- so a result kept by a caller does not change when the evaluator moves on, and a caller writing into one
+      does not change the next.
     */
     /*
       Which inputs take the fast path (ADR-0108 decision 2), decided from everything each one reaches: every node it
@@ -1163,7 +1432,7 @@ function compileInternal(source) {
             start[index] = at;
             at += held.bodies[index]?.length ?? 0;
         }
-        return { raw: held.raw.slice(), slots: held.slots.slice(), mark: new Int32Array(w.keys.length), epoch: 0, start, bodyCount: at, prefix: new Map() };
+        return { raw: held.raw.slice(), slots: held.slots.slice(), mark: new Int32Array(w.keys.length), epoch: 0, start, bodyCount: at, prefix: new Map(), wrote: new Set(), moved: new Set() };
     }
     /*
       A pose step (ADR-0108): every changed input takes the fast path, so only poses move. The reach of the changed inputs
@@ -1175,13 +1444,18 @@ function compileInternal(source) {
     function poseStep(input, held, analysis) {
         const w = walkOf();
         inputFields(input);
-        const fast = (held.fast ??= bindFast(held));
+        /*
+          What moved is told against the pose steps' own inputs, or the evaluation's while no pose step has been bound since:
+          an input that takes no fast path is found before the steps' state is made (it was made, and dropped, at every
+          evaluation frame of a resize -- 2026-10-05).
+        */
+        const raw = held.fast?.raw ?? held.raw;
         const moved = [];
         const values = [];
         for (let i = 0; i < m.inputs.length; i++) {
             const p = m.inputs[i];
             const given = input[p.id];
-            if (given === fast.raw[i])
+            if (given === raw[i])
                 continue;
             values.push(inputValue(p, given));
             moved.push(i);
@@ -1189,6 +1463,7 @@ function compileInternal(source) {
         for (const i of moved)
             if (!analysis.inputs[i].fast)
                 return { why: analysis.inputs[i] };
+        const fast = (held.fast ??= bindFast(held));
         const epoch = ++fast.epoch;
         moved.forEach((i, k) => {
             fast.raw[i] = input[m.inputs[i].id];
@@ -1252,12 +1527,14 @@ function compileInternal(source) {
                         finite(p, node.n.id);
                         write(slot++, p);
                     }
+                fast.wrote.add(index);
                 continue;
             }
             const out = node.op.run(args, node.n.id, node.n);
             node.outs.forEach((s, i) => {
                 fast.slots[s] = checkedValue(out[i], node.types[i], node.n.id);
                 fast.mark[s] = epoch;
+                fast.moved.add(s);
             });
             if (node.op.geometry) {
                 const g = node.op.geometry(args, out, node.n);
@@ -1265,6 +1542,7 @@ function compileInternal(source) {
                 let slot = fast.start[index];
                 for (const body of own)
                     write(slot++, body.pose);
+                fast.wrote.add(index);
             }
         }
         const result = {
@@ -1272,11 +1550,12 @@ function compileInternal(source) {
             generation: 0,
             bodies: bodies.slice(0, written),
             poses: poses.slice(0, written * 12),
+            /* What it hands out is a frozen copy, as an evaluation's values are. */
             read: (ref) => {
                 const s = w.slot.get(ref);
                 if (s === undefined)
                     fail('TARGET_ABSENT', ref, 'no such value');
-                return fast.slots[s];
+                return publicOf(fast.slots[s], new Map());
             },
             changed: (ref) => {
                 const s = w.slot.get(ref);
@@ -1285,7 +1564,7 @@ function compileInternal(source) {
         };
         return { result };
     }
-    function step(input, held) {
+    function step(input, held, publish) {
         const w = walkOf();
         inputFields(input);
         held.fast = undefined;
@@ -1320,7 +1599,7 @@ function compileInternal(source) {
                     }
             visit = all.sort((a, b) => a - b);
         }
-        let reshaped = false;
+        const ran = [];
         for (const index of visit) {
             const node = w.nodes[index];
             if (node.op.pure && !node.args.some(s => held.mark[s] === epoch))
@@ -1329,27 +1608,62 @@ function compileInternal(source) {
             const out = node.op.run(args, node.n.id, node.n);
             node.outs.forEach((s, i) => {
                 held.slots[s] = checkedValue(out[i], node.types[i], node.n.id);
+                if (w.shapeSlot[s])
+                    frozen(held.slots[s]);
                 held.mark[s] = epoch;
                 touched.push(s);
             });
             if (node.op.geometry) {
-                const g = node.op.geometry(args, out, node.n);
-                held.bodies[index] = Array.isArray(g) ? g : [{ id: node.n.id, ...g }];
-                reshaped = true;
+                held.bodies[index] = bodiesOf(node.op.geometry(args, out, node.n), node.n.id);
+                held.pending.nodes.add(index);
+                ran.push(index);
             }
         }
         for (const s of touched)
-            held.values[w.keys[s]] = held.slots[s];
-        if (reshaped) {
+            held.pending.slots.add(s);
+        if (!publish) {
+            /*
+              What ran is published again at the next snapshot: the copies made of it before are let go here, so a snapshot read
+              once does not keep its changed bodies and values alive through the changes after it. A snapshot a caller kept is
+              not touched; what did not run keeps its copies, the same objects in the next snapshot.
+            */
+            for (const index of ran)
+                held.shown[index] = undefined;
+            if (ran.length)
+                held.geometry = [];
+            for (const s of touched)
+                held.values[w.keys[s]] = undefined;
+            return ran;
+        }
+        publishPending(held);
+        return { values: { ...held.values }, geometry: held.geometry.slice() };
+    }
+    /*
+      What a snapshot shows of what ran since the last one (\`Held.pending\`): frozen copies of the bodies and values made
+      then, once each however many evaluations ran them, in the order a snapshot made them before -- bodies, then values,
+      one copy of a pose both carry. What did not run keeps the copies the earlier snapshots hold.
+    */
+    function publishPending(held) {
+        const w = walkOf();
+        const { nodes, slots } = held.pending;
+        if (!nodes.size && !slots.size)
+            return;
+        const made = new Map();
+        for (const index of [...nodes].sort((a, b) => a - b))
+            held.shown[index] = held.bodies[index].map(b => publicOf(b, made));
+        for (const s of slots)
+            held.values[w.keys[s]] = publicOf(held.slots[s], made);
+        if (nodes.size) {
             const geometry = [];
             for (const index of w.shapes) {
-                const own = held.bodies[index];
+                const own = held.shown[index];
                 if (own)
                     geometry.push(...own);
             }
             held.geometry = geometry;
         }
-        return { values: { ...held.values }, geometry: held.geometry.slice() };
+        nodes.clear();
+        slots.clear();
     }
 }
 //# sourceMappingURL=graph.js.map