@hatiolab/figure-model 0.2.12 → 0.2.14

package/dist/graph.js

@@ -643,6 +643,22 @@ for (const [name, op] of Object.entries(ops))
 const IMPURE_OPERATORS = [];
 for (const [name, op] of Object.entries(ops))
     op.pure = !IMPURE_OPERATORS.includes(name);
+/*
+  The operators a pose step may run (ADR-0108 decision 3): arithmetic, transforms, and what carries a pose -- placing,
+  assembling, repeating, selecting. Not a shape, a layout, a pitch or a feature of a shape: an input that reaches one
+  changes what is drawn, not only where. An operator added without a form here is left out of the fast path, and the
+  test that holds \`FIGURE_POSE_EXCLUDED_OPERATORS\` still says so.
+*/
+const POSE_FORMS = [
+    'add@1', 'mul@1', 'div@1', 'sin@1', 'geomean@1', 'curve@1', 'at-least@1', 'max@1', 'min@1', 'affine-bounds@1', 'between@1',
+    'assembly@1', 'repeat@1', 'select-item@1', 'rigid@1', 'axis-turn@1', 'axis-slide@1', 'compose@1', 'attach@1',
+    'point@1', 'map-point@1', 'distance@1', 'place@1', 'member@1'
+];
+for (const [name, op] of Object.entries(ops))
+    if (op.pure && POSE_FORMS.includes(name))
+        op.poseForm = 'run';
+/** The operators a pose step does not run: an input whose reach holds one goes by an ordinary evaluation. */
+export const FIGURE_POSE_EXCLUDED_OPERATORS = Object.freeze(Object.keys(ops).filter(k => !ops[k].poseForm));
 /** Every operator's state policy, by name, for the guard test and for readers of the contract. */
 export const FIGURE_OPERATOR_STATE_POLICY = Object.freeze(Object.fromEntries(Object.entries(ops).map(([k, op]) => [k, op.state])));
 /** Every operator's purity, by name, for the guard test and for readers of the evaluator. */
@@ -675,17 +691,100 @@ function checkedValue(value, type, path) {
             fail('COUNT', path, 'nonnegative safe integer required');
         return value;
     }
-    const check = (v) => {
-        if (typeof v === 'number')
-            num(v, path);
-        else if (Array.isArray(v))
-            v.forEach(check);
-        else if (v && typeof v === 'object')
-            Object.values(v).forEach(check);
-    };
-    check(value);
+    /*
+      By the value's type, where it says where the numbers are: a transform's are its r and t; a placed thing's are its
+      pose, its shape being the very object its shape node produced and this check already passed. The same numbers in
+      the same order as the walk below, without its bookkeeping for the two kinds a moving figure makes most of.
+    */
+    if (type.kind === 'transform' && isPose(value))
+        finitePose(value, path);
+    else if (type.kind === 'placed' && keysAre(value, 'shape', 'pose') && finiteObjects.has(value.shape) && isPose(value.pose))
+        finitePose(value.pose, path);
+    else {
+        finite(value, path);
+        /* A shape is what copies and placed things carry again and again: it is remembered, nothing else is. */
+        if (type.kind === 'shape' && value && typeof value === 'object')
+            finiteObjects.add(value);
+    }
     return value;
 }
+/** 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))
+        return false;
+    let n = 0;
+    for (const k in v) {
+        if (!Object.hasOwn(v, k))
+            continue;
+        if (n > 1 || k !== (n === 0 ? a : b))
+            return false;
+        n++;
+    }
+    return n === 2;
+};
+const isPose = (v) => keysAre(v, 'r', 't') && Array.isArray(v.r) && Array.isArray(v.t);
+/** A list's numbers in order, the first one not finite refused; anything else in it walked as \`finite\` walks it. */
+function finiteList(list, path) {
+    for (let i = 0; i < list.length; i++) {
+        if (!(i in list))
+            continue;
+        const x = list[i];
+        if (typeof x === 'number') {
+            if (!Number.isFinite(x))
+                fail('NON_FINITE', path, String(x));
+        }
+        else
+            finite(x, path);
+    }
+}
+function finitePose(p, path) {
+    for (let i = 0; i < p.r.length; i++) {
+        if (!(i in p.r))
+            continue;
+        const row = p.r[i];
+        if (Array.isArray(row))
+            finiteList(row, path);
+        else
+            finite(row, path);
+    }
+    finiteList(p.t, path);
+}
+/*
+  Every number in a value is finite: the first one that is not, depth first in key order, is refused. A plain loop:
+  a repeat's output holds every copy's pose, and the walk with a closure and forEach per level was most of what
+  rerunning a turning roller row cost (64% of 24 us; 17 us after, 2026-10-03).
+*/
+function finite(v, path) {
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v))
+            fail('NON_FINITE', path, String(v));
+    }
+    else if (Array.isArray(v)) {
+        for (let i = 0; i < v.length; i++)
+            if (i in v)
+                finite(v[i], path);
+    }
+    else if (v && typeof v === 'object') {
+        const keys = Object.keys(v);
+        /* A pose -- two lists of numbers -- is walked: remembering it costs more than walking it. */
+        const small = keys.length <= 2 && Array.isArray(v[keys[0]]) && (keys.length < 2 || Array.isArray(v[keys[1]]));
+        if (!small && finiteObjects.has(v))
+            return;
+        for (let i = 0; i < keys.length; i++)
+            finite(v[keys[i]], path);
+    }
+}
+/*
+  Shapes already found finite. A computed value is never written after it is made (the evaluator hands unchanged
+  values on as the same objects), so one found finite stays so: a row's twenty-four copies carry the one shape of the
+  member they copy, and that shape -- most of the numbers -- was walked again for every copy at every turn (51% of a
+  turning roller row, 2026-10-03). Only shapes are remembered: remembering every object kept a table the size of the
+  busiest moment (4 MB after 500 conveyors were made and dropped).
+*/
+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'));
 export function compileFigureGraph(source) {
     return compileInternal(source);
 }
@@ -779,6 +878,31 @@ function compileInternal(source) {
     }
     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`). */
+    const analyses = new Map();
+    /*
+      The one check of an input record (ADR-0108 C1): a whole evaluation, an instance's next evaluation and a pose step
+      all take their inputs through these two, so a value refused one way is refused every way.
+    */
+    const inputIds = new Set(m.inputs.map(p => p.id));
+    function inputFields(input) {
+        if (!input || typeof input !== 'object' || Array.isArray(input))
+            fail('SCHEMA', 'input values', 'object required');
+        for (const p of m.inputs)
+            if (!Object.hasOwn(input, p.id))
+                fail('SCHEMA', 'input values', `missing ${p.id}`);
+        for (const k of Object.keys(input))
+            if (!inputIds.has(k))
+                fail('SCHEMA', 'input values', `unknown ${k}`);
+    }
+    function inputValue(p, given) {
+        const raw = num(given, p.id);
+        if (raw < p.min || raw > p.max)
+            fail('INPUT_RANGE', p.id, `${raw} outside [${p.min},${p.max}]`);
+        return checkedValue(raw * unit(p.unit, p.id)[1], types.get(p.id), p.id);
+    }
     /*
       One evaluation. Given the last one, only what the changed inputs reach runs again (user's decision 2026-09-26: a
       figure whose controls move re-evaluated every body every frame -- 2.2 us a body, 26.7 ms for sixty turning
@@ -787,14 +911,11 @@ function compileInternal(source) {
       tests compare the two over random sequences of inputs.
     */
     function run(input, previous) {
-        fields(input, m.inputs.map(p => p.id), [], 'input values');
+        inputFields(input);
         const values = new Map(), geometry = [], bodies = new Map(), changed = new Set();
         for (const p of m.inputs) {
-            const raw = num(input[p.id], p.id);
-            if (raw < p.min || raw > p.max)
-                fail('INPUT_RANGE', p.id, `${raw} outside [${p.min},${p.max}]`);
-            values.set(p.id, checkedValue(raw * unit(p.unit, p.id)[1], types.get(p.id), p.id));
-            if (!previous || previous.input[p.id] !== raw)
+            values.set(p.id, inputValue(p, input[p.id]));
+            if (!previous || previous.input[p.id] !== input[p.id])
                 changed.add(p.id);
         }
         for (const p of m.constants)
@@ -838,18 +959,397 @@ function compileInternal(source) {
          * (chief architect's ruling 2026-09-26: the compiled graph is shared, the last values belong to the instance -- sixty
          * conveyors of one type sharing one cache would break it at every call). A throw drops what it kept.
          */
-        evaluator() {
+        evaluator(options = {}) {
             let kept;
+            /*
+              The generation (ADR-0108): while it stands, body slot n is the same body -- the same id at the same place in the
+              geometry. It moves on with a whole evaluation (the first, and the one after a refusal) and with an evaluation
+              whose bodies differ from the last one's.
+            */
+            let generation = 0;
+            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]))
+                    generation++;
+                ids = now;
+                return result;
+            };
+            const evaluate = (input) => {
+                const previous = kept;
+                kept = undefined;
+                if (!previous) {
+                    const whole = run(input, undefined);
+                    kept = hold(whole.kept, whole.result);
+                    return evaluated(whole.result, true);
+                }
+                const result = step(input, previous);
+                kept = previous;
+                return evaluated(result, false);
+            };
             return {
-                evaluate(input) {
-                    const previous = kept;
-                    kept = undefined;
-                    const next = run(input, previous);
-                    kept = next.kept;
-                    return next.result;
+                evaluate,
+                /**
+                 * One step (ADR-0108): poses alone when every changed input takes the fast path, an evaluation otherwise --
+                 * with why. The inputs are checked as an evaluation checks them; a refusal drops what was kept, as it does there.
+                 * \`evaluate\` (\`ordinary\` names why) takes no fast path.
+                 */
+                advance(input, ordinary) {
+                    if (kept && !ordinary) {
+                        const previous = kept;
+                        kept = undefined;
+                        const step = poseStep(input, previous, (analysis ??= poseAnalysisOf(options.reads)));
+                        kept = previous;
+                        if ('result' in step)
+                            return { ...step.result, generation };
+                        const result = evaluate(input);
+                        return { kind: 'evaluation', result, generation, why: step.why };
+                    }
+                    const bound = !!kept;
+                    const result = evaluate(input);
+                    return { kind: 'evaluation', result, generation, why: { code: bound ? ordinary : 'NOT_BOUND' } };
+                },
+                /** 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 }));
                 }
             };
         }
     };
+    /*
+      The walk an instance's evaluator takes after its first evaluation (chief architect's ruling 2026-10-03, ADR-0087
+      amendment 1). The whole order was visited at every call, every value moved into a new Map and every input checked
+      again, so a conveyor whose turn reruns 5 of its 320 nodes still paid for 320 (39 of 73 us). Here every value has a
+      slot and every input the nodes it reaches, in order: a call visits only those, and an unchanged value stays in its
+      slot. Made once per plan, shared by its evaluators, never written after it is made.
+    */
+    function walkOf() {
+        if (walk)
+            return walk;
+        const slot = new Map();
+        const keys = [];
+        const add = (ref) => {
+            slot.set(ref, keys.length);
+            keys.push(ref);
+        };
+        m.inputs.forEach(p => add(p.id));
+        m.constants.forEach(p => add(p.id));
+        const nodes = order.map((n, index) => {
+            const op = ops[n.op];
+            op.ports.forEach(p => add(n.outputs[p]));
+            return { n, op, index, args: n.args.map(ref => slot.get(ref)), outs: op.ports.map(p => slot.get(n.outputs[p])), types: op.ports.map(p => types.get(n.outputs[p])) };
+        });
+        const readers = keys.map(() => []);
+        for (const node of nodes)
+            for (const s of node.args)
+                readers[s].push(node.index);
+        /* The nodes a value reaches, in order: what must run again when it changes. */
+        const reachOf = (start) => {
+            const seen = new Uint8Array(nodes.length);
+            const stack = [...start];
+            while (stack.length) {
+                const s = stack.pop();
+                for (const i of readers[s]) {
+                    if (seen[i])
+                        continue;
+                    seen[i] = 1;
+                    stack.push(...nodes[i].outs);
+                }
+            }
+            const out = [];
+            seen.forEach((v, i) => v && out.push(i));
+            return out;
+        };
+        /* A node that is not pure runs at every evaluation, and so does every node it reaches. */
+        const impure = nodes.filter(node => !node.op.pure);
+        const always = [...new Set([...impure.map(node => node.index), ...reachOf(impure.flatMap(node => node.outs))])].sort((a, b) => a - b);
+        walk = {
+            keys,
+            slot,
+            nodes,
+            readers,
+            reach: m.inputs.map((_, i) => reachOf([i])),
+            always,
+            shapes: nodes.filter(node => node.op.geometry).map(node => node.index)
+        };
+        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) {
+        const w = walkOf();
+        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(),
+            mark: new Int32Array(w.keys.length),
+            ran: new Int32Array(w.nodes.length),
+            epoch: 0
+        };
+    }
+    /*
+      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.
+    */
+    /*
+      Which inputs take the fast path (ADR-0108 decision 2), decided from everything each one reaches: every node it
+      reaches has a pose form, every value it changes is a number or carries a pose, and nothing outside the graph that
+      may not change reads one. Made once per plan and what reads it.
+    */
+    function poseAnalysisOf(reads = {}) {
+        const key = JSON.stringify([reads.forbidden ?? {}, [...(reads.external ?? [])].sort()]);
+        const held = analyses.get(key);
+        if (held)
+            return held;
+        const w = walkOf();
+        const forbidden = reads.forbidden ?? {};
+        const external = new Set(reads.external ?? []);
+        const inputs = m.inputs.map((p, i) => {
+            const kind = notPose(types.get(p.id));
+            if (kind)
+                return { fast: false, code: 'INPUT_NOT_POSE', input: p.id, node: p.id, reaches: kind };
+            if (Object.hasOwn(forbidden, p.id))
+                return { fast: false, code: 'INPUT_NOT_POSE', input: p.id, node: p.id, reaches: forbidden[p.id] };
+            for (const index of w.reach[i]) {
+                const node = w.nodes[index];
+                if (!node.op.poseForm)
+                    return { fast: false, code: 'UNSUPPORTED_OPERATOR', input: p.id, node: node.n.id, op: node.n.op };
+                for (const [k, s] of node.outs.entries()) {
+                    const kind = notPose(node.types[k]);
+                    if (kind)
+                        return { fast: false, code: 'INPUT_NOT_POSE', input: p.id, node: node.n.id, reaches: kind };
+                    const ref = w.keys[s];
+                    if (Object.hasOwn(forbidden, ref))
+                        return { fast: false, code: 'INPUT_NOT_POSE', input: p.id, node: node.n.id, reaches: forbidden[ref] };
+                }
+            }
+            return { fast: true };
+        });
+        /* A row whose copies nothing reads -- no node, nothing outside -- is written by its poses alone. */
+        const terminal = w.nodes.map(node => node.n.op === 'repeat@1' && !node.n.params?.within && node.outs.every(s => !w.readers[s].length && !external.has(w.keys[s])));
+        const made = { inputs, terminal, visits: new Map() };
+        analyses.set(key, made);
+        return made;
+    }
+    /* The nodes a set of changed inputs reaches, once each, in order -- made once per set and kept with the analysis. */
+    function visitOf(moved, analysis) {
+        const w = walkOf();
+        if (moved.length === 1)
+            return w.reach[moved[0]];
+        const key = moved.join();
+        let visit = analysis.visits.get(key);
+        if (!visit) {
+            const seen = new Set();
+            for (const i of moved)
+                for (const n of w.reach[i])
+                    seen.add(n);
+            visit = [...seen].sort((a, b) => a - b);
+            if (analysis.visits.size < 256)
+                analysis.visits.set(key, visit);
+        }
+        return visit;
+    }
+    function bindFast(held) {
+        const w = walkOf();
+        const start = new Int32Array(w.nodes.length).fill(-1);
+        let at = 0;
+        for (const index of w.shapes) {
+            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() };
+    }
+    /*
+      A pose step (ADR-0108): every changed input takes the fast path, so only poses move. The reach of the changed inputs
+      runs once, in order, each node by its own run as an evaluation runs it -- the same operations in the same order, so
+      the poses are an evaluation's to the bit (same engine). A row nothing reads has its copies composed straight into the
+      pose list: compose(compose(pose, offset), member), the offset part made once while the row's pose stands.
+      Returns undefined, having changed nothing, when an input does not take the fast path.
+    */
+    function poseStep(input, held, analysis) {
+        const w = walkOf();
+        inputFields(input);
+        const fast = (held.fast ??= bindFast(held));
+        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])
+                continue;
+            values.push(inputValue(p, given));
+            moved.push(i);
+        }
+        for (const i of moved)
+            if (!analysis.inputs[i].fast)
+                return { why: analysis.inputs[i] };
+        const epoch = ++fast.epoch;
+        moved.forEach((i, k) => {
+            fast.raw[i] = input[m.inputs[i].id];
+            fast.slots[i] = values[k];
+            fast.mark[i] = epoch;
+        });
+        const visit = visitOf(moved, analysis);
+        const bodies = new Int32Array(fast.bodyCount);
+        const poses = new Float64Array(fast.bodyCount * 12);
+        let written = 0;
+        const write = (slot, pose) => {
+            const r = pose.r, t = pose.t, o = written * 12;
+            bodies[written++] = slot;
+            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];
+        };
+        for (const index of visit) {
+            const node = w.nodes[index];
+            let reached = false;
+            for (const s of node.args)
+                if (fast.mark[s] === epoch) {
+                    reached = true;
+                    break;
+                }
+            if (!reached)
+                continue;
+            const args = new Array(node.args.length);
+            for (let k = 0; k < node.args.length; k++)
+                args[k] = fast.slots[node.args[k]];
+            if (analysis.terminal[index]) {
+                const [layout, assembly, pose, rise] = args;
+                const axis = ['x', 'y', 'z'].indexOf(node.n.params.axis), up = ['x', 'y', 'z'].indexOf(node.n.params.riseAxis);
+                /* The offsets stand while the row's own pose and rise do (its layout is never a pose step's to change). */
+                const steady = fast.mark[node.args[2]] !== epoch && (node.args[3] === undefined || fast.mark[node.args[3]] !== epoch);
+                let prefix = steady ? fast.prefix.get(index) : undefined;
+                if (!prefix) {
+                    prefix = [];
+                    for (let i = 0; i < layout.count; i++) {
+                        const t = [0, 0, 0];
+                        t[axis] = layout.centers[i];
+                        if (rise !== undefined)
+                            t[up] = i * rise;
+                        prefix.push(compose(pose, { r: identity(), t }));
+                    }
+                    fast.prefix.set(index, prefix);
+                }
+                let slot = fast.start[index];
+                for (let i = 0; i < layout.count; i++)
+                    for (const member of assembly.members) {
+                        const p = compose(prefix[i], member.pose);
+                        finite(p, node.n.id);
+                        write(slot++, p);
+                    }
+                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;
+            });
+            if (node.op.geometry) {
+                const g = node.op.geometry(args, out, node.n);
+                const own = Array.isArray(g) ? g : [g];
+                let slot = fast.start[index];
+                for (const body of own)
+                    write(slot++, body.pose);
+            }
+        }
+        const result = {
+            kind: 'poses',
+            generation: 0,
+            bodies: bodies.slice(0, written),
+            poses: poses.slice(0, written * 12),
+            read: (ref) => {
+                const s = w.slot.get(ref);
+                if (s === undefined)
+                    fail('TARGET_ABSENT', ref, 'no such value');
+                return fast.slots[s];
+            },
+            changed: (ref) => {
+                const s = w.slot.get(ref);
+                return s !== undefined && fast.mark[s] === epoch;
+            }
+        };
+        return { result };
+    }
+    function step(input, held) {
+        const w = walkOf();
+        inputFields(input);
+        held.fast = undefined;
+        const epoch = ++held.epoch;
+        const touched = [];
+        let moved = -1;
+        let several = false;
+        m.inputs.forEach((p, i) => {
+            const given = input[p.id];
+            /* The same number as last time passed every check then. */
+            if (given === held.raw[i])
+                return;
+            held.slots[i] = inputValue(p, given);
+            held.raw[i] = given;
+            held.mark[i] = epoch;
+            touched.push(i);
+            if (moved >= 0)
+                several = true;
+            moved = i;
+        });
+        /* The nodes to visit, in order: what the changed inputs reach, and what runs at every evaluation. */
+        let visit;
+        if (!several && !w.always.length)
+            visit = moved >= 0 ? w.reach[moved] : [];
+        else {
+            const all = [];
+            for (const i of [...touched.map(t => w.reach[t]), w.always])
+                for (const n of i)
+                    if (held.ran[n] !== epoch) {
+                        held.ran[n] = epoch;
+                        all.push(n);
+                    }
+            visit = all.sort((a, b) => a - b);
+        }
+        let reshaped = false;
+        for (const index of visit) {
+            const node = w.nodes[index];
+            if (node.op.pure && !node.args.some(s => held.mark[s] === epoch))
+                continue;
+            const args = node.args.map(s => held.slots[s]);
+            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);
+                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;
+            }
+        }
+        for (const s of touched)
+            held.values[w.keys[s]] = held.slots[s];
+        if (reshaped) {
+            const geometry = [];
+            for (const index of w.shapes) {
+                const own = held.bodies[index];
+                if (own)
+                    geometry.push(...own);
+            }
+            held.geometry = geometry;
+        }
+        return { values: { ...held.values }, geometry: held.geometry.slice() };
+    }
 }
 //# sourceMappingURL=graph.js.map