@hatiolab/figure-model 0.3.3 → 0.3.4

package/dist/graph.js

@@ -1055,11 +1055,16 @@ function compileInternal(source) {
             let analysis;
             /* Every call, refused or not; a pose step's \`read\` and \`changed\` answer while it is still the last one. */
             let calls = 0;
-            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]))
+            /* 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) => {
@@ -1070,10 +1075,104 @@ function compileInternal(source) {
                     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,
                 /**
@@ -1105,16 +1204,47 @@ function compileInternal(source) {
                                 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());
                 }
             };
         }
@@ -1182,11 +1312,32 @@ function compileInternal(source) {
      * 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) {
+    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 = {};
@@ -1204,7 +1355,8 @@ function compileInternal(source) {
             geometry,
             mark: new Int32Array(w.keys.length),
             ran: new Int32Array(w.nodes.length),
-            epoch: 0
+            epoch: 0,
+            pending: { nodes: new Set(), slots: new Set() }
         };
     }
     /*
@@ -1280,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
@@ -1292,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);
@@ -1306,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];
@@ -1369,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);
@@ -1382,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 = {
@@ -1403,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;
@@ -1438,9 +1599,7 @@ function compileInternal(source) {
                     }
             visit = all.sort((a, b) => a - b);
         }
-        let reshaped = false;
-        /* The copies made in this call, so a pose a body and a value both carry is copied once. */
-        let made;
+        const ran = [];
         for (const index of visit) {
             const node = w.nodes[index];
             if (node.op.pure && !node.args.some(s => held.mark[s] === epoch))
@@ -1455,15 +1614,46 @@ function compileInternal(source) {
                 touched.push(s);
             });
             if (node.op.geometry) {
-                const own = bodiesOf(node.op.geometry(args, out, node.n), node.n.id);
-                held.bodies[index] = own;
-                held.shown[index] = own.map(b => publicOf(b, (made ??= new Map())));
-                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]] = publicOf(held.slots[s], (made ??= new Map()));
-        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.shown[index];
@@ -1472,7 +1662,8 @@ function compileInternal(source) {
             }
             held.geometry = geometry;
         }
-        return { values: { ...held.values }, geometry: held.geometry.slice() };
+        nodes.clear();
+        slots.clear();
     }
 }
 //# sourceMappingURL=graph.js.map