@woosh/meep-engine 2.155.0 → 2.156.0

package/src/core/math/solveCubic.js

@@ -1,82 +1,95 @@
-import { assert } from "../assert.js";
-import { EPSILON } from "./EPSILON.js";
-import { solveQuadratic } from "./solveQuadratic.js";
-
-const ONE_THIRD = 1.0 / 3.0;
-const TWO_THIRDS_PI = 2.0 * Math.PI / 3.0;
-
-/**
- * Return real solutions for a cubic polynomial: ax³ + bx² + cx + d
- * Repeated roots are written once each — multiplicity is not duplicated in the output.
- * Imaginary roots are not provided.
- *
- * @param {number[]|Float32Array|Float64Array} result solutions are written here
- * @param {number} result_offset offset into result array where solutions are written to
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @param {number} d
- * @returns {number} number of real roots found (0, 1, 2, or 3)
- */
-export function solveCubic(result, result_offset, a, b, c, d) {
-    assert.isNumber(a, 'a');
-    assert.isNumber(b, 'b');
-    assert.isNumber(c, 'c');
-    assert.isNumber(d, 'd');
-
-    if (Math.abs(a) < EPSILON) {
-        // degrade to quadratic
-        return solveQuadratic(result, result_offset, b, c, d);
-    }
-
-    // normalize: x³ + B·x² + C·x + D = 0
-    const inv_a = 1 / a;
-    const B = b * inv_a;
-    const C = c * inv_a;
-    const D = d * inv_a;
-
-    // depress via x = y - B/3 → y³ + p·y + q = 0
-    const B_third = B * ONE_THIRD;
-    const p = C - B * B_third;
-    const q = 2 * B_third * B_third * B_third - C * B_third + D;
-
-    if (Math.abs(p) < EPSILON && Math.abs(q) < EPSILON) {
-        // triple root at y = 0
-        result[result_offset] = -B_third;
-        return 1;
-    }
-
-    // Cardano's discriminant criterion. ratio = (q/2)² + (p/3)³.
-    //   ratio > 0  → one real root, two complex
-    //   ratio = 0  → repeated real roots (single + double, or triple covered above)
-    //   ratio < 0  → three distinct real roots
-    const half_q = q * 0.5;
-    const third_p = p * ONE_THIRD;
-    const ratio = half_q * half_q + third_p * third_p * third_p;
-
-    if (ratio > EPSILON) {
-        const sqrt_ratio = Math.sqrt(ratio);
-        const u = Math.cbrt(-half_q + sqrt_ratio);
-        const v = Math.cbrt(-half_q - sqrt_ratio);
-
-        result[result_offset] = u + v - B_third;
-        return 1;
-    }
-
-    if (ratio < -EPSILON) {
-        // p must be negative for ratio < 0; sqrt(-p/3) is real
-        const m = 2 * Math.sqrt(-third_p);
-        const theta_third = ONE_THIRD * Math.acos(3 * q / (p * m));
-
-        result[result_offset]     = m * Math.cos(theta_third) - B_third;
-        result[result_offset + 1] = m * Math.cos(theta_third - TWO_THIRDS_PI) - B_third;
-        result[result_offset + 2] = m * Math.cos(theta_third - 2 * TWO_THIRDS_PI) - B_third;
-        return 3;
-    }
-
-    // ratio ≈ 0: simple + double root
-    const u = Math.cbrt(-half_q);
-    result[result_offset]     = 2 * u - B_third;
-    result[result_offset + 1] = -u - B_third;
-    return 2;
-}
+import { assert } from "../assert.js";
+import { EPSILON } from "./EPSILON.js";
+import { solveQuadratic } from "./solveQuadratic.js";
+
+const ONE_THIRD = 1.0 / 3.0;
+const TWO_THIRDS_PI = 2.0 * Math.PI / 3.0;
+
+/**
+ * Return real solutions for a cubic polynomial: ax³ + bx² + cx + d
+ * Repeated roots are written once each — multiplicity is not duplicated in the output.
+ * Imaginary roots are not provided.
+ *
+ * @param {number[]|Float32Array|Float64Array} result solutions are written here
+ * @param {number} result_offset offset into result array where solutions are written to
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {number} number of real roots found (0, 1, 2, or 3)
+ */
+export function solveCubic(result, result_offset, a, b, c, d) {
+    assert.isNumber(a, 'a');
+    assert.isNumber(b, 'b');
+    assert.isNumber(c, 'c');
+    assert.isNumber(d, 'd');
+
+    if (Math.abs(a) < EPSILON) {
+        // degrade to quadratic
+        return solveQuadratic(result, result_offset, b, c, d);
+    }
+
+    // normalize: x³ + B·x² + C·x + D = 0
+    const inv_a = 1 / a;
+    const B = b * inv_a;
+    const C = c * inv_a;
+    const D = d * inv_a;
+
+    // depress via x = y - B/3 → y³ + p·y + q = 0
+    const B_third = B * ONE_THIRD;
+    const p = C - B * B_third;
+    const q = 2 * B_third * B_third * B_third - C * B_third + D;
+
+    // Scale-invariant triple-root test. p has the units of root² and q of root³, so compare each against the
+    // coefficient scale raised to the matching power. An absolute `< EPSILON` test wrongly classified cubics
+    // whose roots are merely small (p and q tiny in absolute terms but the roots well separated) as a triple
+    // root. Exact p === 0 && q === 0 still passes here, routing to the triple-root branch.
+    const coeff_scale = Math.max(1, Math.abs(B));
+    if (
+        Math.abs(p) < EPSILON * coeff_scale * coeff_scale
+        && Math.abs(q) < EPSILON * coeff_scale * coeff_scale * coeff_scale
+    ) {
+        // triple root at y = 0
+        result[result_offset] = -B_third;
+        return 1;
+    }
+
+    // Cardano's discriminant criterion. ratio = (q/2)² + (p/3)³.
+    //   ratio > 0  → one real root, two complex
+    //   ratio = 0  → repeated real roots (single + double, or triple covered above)
+    //   ratio < 0  → three distinct real roots
+    const half_q = q * 0.5;
+    const third_p = p * ONE_THIRD;
+    const ratio = half_q * half_q + third_p * third_p * third_p;
+
+    // Relative dead-band: ratio has the units of root⁶, exactly like its two constituent terms. An absolute
+    // EPSILON band dropped a real root for small-magnitude roots (ratio tiny but genuinely non-zero); scale the
+    // tolerance by the magnitude of the constituent terms instead.
+    const ratio_tol = EPSILON * Math.max(half_q * half_q, Math.abs(third_p * third_p * third_p));
+
+    if (ratio > ratio_tol) {
+        const sqrt_ratio = Math.sqrt(ratio);
+        const u = Math.cbrt(-half_q + sqrt_ratio);
+        const v = Math.cbrt(-half_q - sqrt_ratio);
+
+        result[result_offset] = u + v - B_third;
+        return 1;
+    }
+
+    if (ratio < -ratio_tol) {
+        // p must be negative for ratio < 0; sqrt(-p/3) is real
+        const m = 2 * Math.sqrt(-third_p);
+        const theta_third = ONE_THIRD * Math.acos(3 * q / (p * m));
+
+        result[result_offset]     = m * Math.cos(theta_third) - B_third;
+        result[result_offset + 1] = m * Math.cos(theta_third - TWO_THIRDS_PI) - B_third;
+        result[result_offset + 2] = m * Math.cos(theta_third - 2 * TWO_THIRDS_PI) - B_third;
+        return 3;
+    }
+
+    // ratio ≈ 0: simple + double root
+    const u = Math.cbrt(-half_q);
+    result[result_offset]     = 2 * u - B_third;
+    result[result_offset + 1] = -u - B_third;
+    return 2;
+}

package/src/core/math/spline/computeCatmullRomSplineUniformDistance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeCatmullRomSplineUniformDistance.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/computeCatmullRomSplineUniformDistance.js"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH,+DAPW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,cACN,MAAM,gBACN,MAAM,UACN,MAAM,QAuFhB"}
+{"version":3,"file":"computeCatmullRomSplineUniformDistance.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/computeCatmullRomSplineUniformDistance.js"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH,+DAPW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,cACN,MAAM,gBACN,MAAM,UACN,MAAM,QAoGhB"}

package/src/core/math/spline/computeCatmullRomSplineUniformDistance.js

@@ -69,6 +69,19 @@ export function computeCatmullRomSplineUniformDistance(result, input, input_leng
 
     const step_distance = distances_sum / (sample_count - 1);
 
+    if (!(step_distance > 0)) {
+        // Degenerate input. When the total path length is 0 (all control points coincide) step_distance is 0,
+        // which would make the sampling loop below spin forever (next_point_distance never advances). When
+        // sample_count < 2 it is Infinity/NaN. In every such case collapse all requested samples onto the first
+        // input point. The `!(step_distance > 0)` test also covers NaN and -0. Note: when sample_count is 0 this
+        // loop is a no-op, which is the correct (empty) result.
+        for (let i = 0; i < sample_count; i++) {
+            array_copy(input, 0, result, i * dimensions, dimensions);
+        }
+
+        return;
+    }
+
     let cursor_index = 0;
 
     let current_input_distance = 0;

package/src/core/math/statistics/softmax.js

@@ -14,7 +14,7 @@ export function softmax(z, i, k) {
     // NOTE that if we want to compute softmax for an entire vector, it could be far more efficient
     let sum = 0;
 
-    for (let j = 1; j < k; j++) {
+    for (let j = 0; j < k; j++) {
 
         sum += Math.exp(z[j]);
 

package/src/core/model/node-graph/visual/NodeGraphVisualData.d.ts

@@ -45,6 +45,7 @@ export class NodeGraphVisualData {
     getNode(id: number): NodeVisualData | undefined;
     toJSON(): {
         nodes: {};
+        dataColors: {};
     };
     fromJSON(json: any): void;
 }

package/src/core/model/node-graph/visual/NodeGraphVisualData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeGraphVisualData.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/visual/NodeGraphVisualData.js"],"names":[],"mappings":"AASA;IAEI;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAEnB;IAElB;;;OAGG;IACH,YAFU,IAAI,MAAM,EAAE,KAAK,CAAC,CAEL;IAEvB;;;OAGG;IACH,wCAgBC;IAED;;;OAGG;IACH,+BAwHC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,KAAK,QAMf;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAIjB;IAED;;;;OAIG;IACH,YAHW,MAAM,QACN,cAAc,QAIxB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,cAAc,GAAC,SAAS,CAIpC;IAED;;MAgBC;IAED,0BA0BC;CACJ;+BAvP8B,qBAAqB;sBAL9B,yBAAyB"}
+{"version":3,"file":"NodeGraphVisualData.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/visual/NodeGraphVisualData.js"],"names":[],"mappings":"AASA;IAEI;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAEnB;IAElB;;;OAGG;IACH,YAFU,IAAI,MAAM,EAAE,KAAK,CAAC,CAEL;IAEvB;;;OAGG;IACH,wCAgBC;IAED;;;OAGG;IACH,+BAwHC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,KAAK,QAMf;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAIjB;IAED;;;;OAIG;IACH,YAHW,MAAM,QACN,cAAc,QAIxB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,cAAc,GAAC,SAAS,CAIpC;IAED;;;MAiBC;IAED,0BA0BC;CACJ;+BAxP8B,qBAAqB;sBAL9B,yBAAyB"}

package/src/core/model/node-graph/visual/NodeGraphVisualData.js

@@ -221,7 +221,8 @@ export class NodeGraphVisualData {
         }
 
         return {
-            nodes
+            nodes,
+            dataColors
         };
     }
 

package/src/core/model/node-graph/visual/NodeVisualData.js

@@ -64,6 +64,6 @@ export class NodeVisualData {
     fromJSON(json) {
         this.id = json.id;
         this.dimensions.fromJSON(json.dimensions);
-        this.ports.fromJSON(json, PortVisualData);
+        this.ports.fromJSON(json.ports, PortVisualData);
     }
 }

package/src/core/model/object/ImmutableObjectPool.d.ts

@@ -44,6 +44,13 @@ export class ImmutableObjectPool<Key, Value> {
      */
     size: number;
     get(key: any): Value;
+    /**
+     * Detach an element from the global eviction list, keeping the head/tail pointers consistent.
+     * Does NOT touch the per-key bucket, size, or the onRemoved signal.
+     * @param {CacheElement<Key,Value>} el
+     * @private
+     */
+    private __unlinkFromList;
     /**
      * Removed all elements from cache
      * NOTE: {@link onRemoved} signal *does* get triggered for each element

package/src/core/model/object/ImmutableObjectPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImmutableObjectPool.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/ImmutableObjectPool.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAyBI;;;OAoBC;IA5CD;;;OAGG;IACH,oBAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEH;IACxB;;;OAGG;IACH,MAFU,QAAQ,GAAG,EAAE,aAAa,GAAG,EAAC,KAAK,CAAC,EAAE,CAAC,CAE5B;IAErB;;;;OAIG;IACH,gBAAe;IACf;;;;OAIG;IACH,eAAc;IAKV;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gBAFU,MAAM,CAEoB;IAEpC;;;OAGG;IACH,MAFU,MAAM,CAEH;IAGjB,qBAuBC;IAED;;;OAGG;IACH,cAIC;IAED;;;;OAIG;IACH,wBA0BC;IAED,mCA2CC;CACJ;mBApKkB,+BAA+B;wBAD1B,iCAAiC;6BAD5B,6BAA6B"}
+{"version":3,"file":"ImmutableObjectPool.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/ImmutableObjectPool.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAyBI;;;OAoBC;IA5CD;;;OAGG;IACH,oBAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEH;IACxB;;;OAGG;IACH,MAFU,QAAQ,GAAG,EAAE,aAAa,GAAG,EAAC,KAAK,CAAC,EAAE,CAAC,CAE5B;IAErB;;;;OAIG;IACH,gBAAe;IACf;;;;OAIG;IACH,eAAc;IAKV;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gBAFU,MAAM,CAEoB;IAEpC;;;OAGG;IACH,MAFU,MAAM,CAEH;IAGjB,qBAuBC;IAED;;;;;OAKG;IACH,yBAUC;IAED;;;OAGG;IACH,cAIC;IAED;;;;OAIG;IACH,wBAkBC;IAED,mCA2CC;CACJ;mBA9KkB,+BAA+B;wBAD1B,iCAAiC;6BAD5B,6BAA6B"}

package/src/core/model/object/ImmutableObjectPool.js

@@ -70,13 +70,31 @@ export class ImmutableObjectPool {
             this.data.delete(key);
         }
 
-        element.unlink();
+        this.__unlinkFromList(element);
 
         this.size--;
 
         return element.value;
     }
 
+    /**
+     * Detach an element from the global eviction list, keeping the head/tail pointers consistent.
+     * Does NOT touch the per-key bucket, size, or the onRemoved signal.
+     * @param {CacheElement<Key,Value>} el
+     * @private
+     */
+    __unlinkFromList(el) {
+        if (el === this.__first) {
+            this.__first = el.next;
+        }
+
+        if (el === this.__last) {
+            this.__last = el.previous;
+        }
+
+        el.unlink();
+    }
+
     /**
      * Removed all elements from cache
      * NOTE: {@link onRemoved} signal *does* get triggered for each element
@@ -93,15 +111,7 @@ export class ImmutableObjectPool {
      * @private
      */
     __removeElement(el) {
-        if (el === this.__first) {
-            this.__first = el.next;
-        }
-
-        if (el === this.__last) {
-            this.__last = el.previous;
-        }
-
-        el.unlink();
+        this.__unlinkFromList(el);
 
         const key = el.key;
 

package/src/core/model/reactive/evaluation/MultiPredicateEvaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MultiPredicateEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/evaluation/MultiPredicateEvaluator.js"],"names":[],"mappings":"AAuGA;;GAEG;AACH;IACI;;;OAGG;IACH,4DAFwC,MAAM,EA4E7C;IAzEG;;;OAGG;IACH,+CAFwC,MAAM,CAER;IAEtC;;;OAGG;IACH,YAFU,oBAAoB,CAEV;IAEpB;;;OAGG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,iCAA4C;IAE5C;;;OAGG;IACH,aAFU,MAAM,CAEe;IAG/B;;;;OAIG;IACH,+BAA2C;IAE3C;;;;OAIG;IACH,iCAAkC;IAElC;;;;OAIG;IACH,sCAAuC;IAEvC;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,oBAAoB;IAEpB;;;;OAIG;IACH,0BAA0B;IAG9B;;;OAGG;IACH,kBAFW,oBAAoB,QAsC9B;IAED;;;;;;OAMG;IACH,2BAuCC;IAED;;;;;OAKG;IACH,uBAiCC;IAED;;;;OAIG;IACH,0BAcC;IAED;;;;;OAKG;IACH,uBA2FC;IAGD,+BAOC;IAED,iBAEC;IAED;;OAEG;IACH,QAFa,qBAAmB,SAAS,CA4BxC;CACJ;uBAjesB,2BAA2B"}
+{"version":3,"file":"MultiPredicateEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/reactive/evaluation/MultiPredicateEvaluator.js"],"names":[],"mappings":"AAuGA;;GAEG;AACH;IACI;;;OAGG;IACH,4DAFwC,MAAM,EA4E7C;IAzEG;;;OAGG;IACH,+CAFwC,MAAM,CAER;IAEtC;;;OAGG;IACH,YAFU,oBAAoB,CAEV;IAEpB;;;OAGG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,iCAA4C;IAE5C;;;OAGG;IACH,aAFU,MAAM,CAEe;IAG/B;;;;OAIG;IACH,+BAA2C;IAE3C;;;;OAIG;IACH,iCAAkC;IAElC;;;;OAIG;IACH,sCAAuC;IAEvC;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,oBAAoB;IAEpB;;;;OAIG;IACH,0BAA0B;IAG9B;;;OAGG;IACH,kBAFW,oBAAoB,QAsC9B;IAED;;;;;;OAMG;IACH,2BAuCC;IAED;;;;;OAKG;IACH,uBAiCC;IAED;;;;OAIG;IACH,0BAcC;IAED;;;;;OAKG;IACH,uBAgIC;IAGD,+BAOC;IAED,iBAEC;IAED;;OAEG;IACH,QAFa,qBAAmB,SAAS,CA4BxC;CACJ;uBAtgBsB,2BAA2B"}

package/src/core/model/reactive/evaluation/MultiPredicateEvaluator.js

@@ -303,11 +303,11 @@ export class MultiPredicateEvaluator {
                 const parent = parents[i];
 
                 if (value === false) {
-                    if (parent.isReactiveAnd === true) {
+                    if (parent.expression.isReactiveAnd === true) {
                         this.__assign_value(parent, false);
                     }
                 } else {
-                    if (parent.isReactiveOr === true) {
+                    if (parent.expression.isReactiveOr === true) {
                         this.__assign_value(parent, true);
                     }
                 }
@@ -393,6 +393,43 @@ export class MultiPredicateEvaluator {
 
                 return false;
             }
+        } else if (expression.isReactiveAnd === true || expression.isReactiveOr === true) {
+
+            // Short-circuiting boolean AND/OR: a determinable result must be produced from whichever operand
+            // resolves, WITHOUT requiring the other operand to resolve (mirrors ReactiveAnd/ReactiveOr.evaluate).
+            // The generic binary branch below would instead require BOTH operands to resolve and drop the whole
+            // predicate when one operand is an unresolved reference.
+            const left_node = node.children[0];
+            const right_node = node.children[1];
+
+            const is_and = expression.isReactiveAnd === true;
+            const short_circuit_value = !is_and; // false short-circuits AND, true short-circuits OR
+
+            let resolved = false;
+
+            if (this.__resolve_node(left_node)) {
+                const left_value = left_node.getValue();
+
+                if (left_value === short_circuit_value) {
+                    value = short_circuit_value;
+                    resolved = true;
+                } else if (this.__resolve_node(right_node)) {
+                    value = expression.transform(left_value, right_node.getValue());
+                    resolved = true;
+                }
+            } else if (this.__resolve_node(right_node)) {
+                const right_value = right_node.getValue();
+
+                if (right_value === short_circuit_value) {
+                    value = short_circuit_value;
+                    resolved = true;
+                }
+            }
+
+            if (!resolved) {
+                return false;
+            }
+
         } else if (expression.isBinaryExpression) {
 
             const children = node.children;

package/src/core/model/reactive/model/terminal/ReactiveReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveReference.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/terminal/ReactiveReference.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IAoII;;;;;OAKG;IACH,oBAJW,2CAAuC,SACvC,MAAM,GACJ,iBAAiB,CAe7B;IArJD;;;OAGG;IACH,mBAFW,MAAM,EAkBhB;IAXG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,QAFU,mDAA0C,CAElC;IAGtB;;;OAGG;IACH,YAFW,iBAAiB,QAU3B;IAED;;;OAGG;IACH,SAFY,iBAAiB,CAQ5B;IAED,gCAEC;IAED;;;;;OAKG;IACH;;;aAoBC;IAED;;;OAGG;IACH,mBAYC;IAED,wBAKC;IAED,iBAEC;IAGD,eAKC;IAED,0BAMC;IA8BL;;;OAGG;IACH,qBAFU,OAAO,CAEqB;IAEtC;;;OAGG;IACH,sBAFU,OAAO,CAEsB;CAZtC;mCAhKkC,0BAA0B"}
+{"version":3,"file":"ReactiveReference.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/reactive/model/terminal/ReactiveReference.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IAsII;;;;;OAKG;IACH,oBAJW,2CAAuC,SACvC,MAAM,GACJ,iBAAiB,CAe7B;IAvJD;;;OAGG;IACH,mBAFW,MAAM,EAkBhB;IAXG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,QAFU,mDAA0C,CAElC;IAGtB;;;OAGG;IACH,YAFW,iBAAiB,QAY3B;IAED;;;OAGG;IACH,SAFY,iBAAiB,CAQ5B;IAED,gCAEC;IAED;;;;;OAKG;IACH;;;aAoBC;IAED;;;OAGG;IACH,mBAYC;IAED,wBAKC;IAED,iBAEC;IAGD,eAKC;IAED,0BAMC;IA8BL;;;OAGG;IACH,qBAFU,OAAO,CAEqB;IAEtC;;;OAGG;IACH,sBAFU,OAAO,CAEsB;CAZtC;mCAlKkC,0BAA0B"}

package/src/core/model/reactive/model/terminal/ReactiveReference.js

@@ -39,6 +39,8 @@ export class ReactiveReference extends ReactiveExpression {
      */
     copy(other) {
         this.name = other.name;
+        // preserve the instance dataType (mirrors from()); without this the clone reverts to DataType.Any
+        this.dataType = other.dataType;
 
         this.disconnect();
 

package/src/core/parser/simple/readHexToken.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readHexToken.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/simple/readHexToken.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,mCALW,MAAM,UACN,MAAM,UACN,MAAM,SA0FhB"}
+{"version":3,"file":"readHexToken.d.ts","sourceRoot":"","sources":["../../../../../src/core/parser/simple/readHexToken.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,mCALW,MAAM,UACN,MAAM,UACN,MAAM,SAgGhB"}

package/src/core/parser/simple/readHexToken.js

@@ -95,6 +95,12 @@ export function readHexToken(text, cursor, length) {
         value = value * 16 + digit;
     }
 
+    if (i === cursor + 2) {
+        // no hex digits were consumed after the "0x" prefix. This covers both "0xZ" (loop breaks immediately)
+        // and "0x" at end of input (loop body never runs); the per-character `i === cursor` guard above is dead
+        // code because i starts at cursor + 2.
+        throw new ParserError(i, `Expected at least one hex digit [0-9,A-F] after '0x'`, text);
+    }
 
     return new Token(value, cursor, i, "uint", DataType.Number);
 }

package/src/core/primitives/numbers/number_pretty_print.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number_pretty_print.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/numbers/number_pretty_print.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,2CAHW,MAAM,GACJ,MAAM,CAmBlB"}
+{"version":3,"file":"number_pretty_print.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/numbers/number_pretty_print.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,2CAHW,MAAM,GACJ,MAAM,CAsBlB"}

package/src/core/primitives/numbers/number_pretty_print.js

@@ -14,7 +14,10 @@ export function number_pretty_print(value) {
 
     const fraction = value % 1;
 
-    const would_produce_decimals = fraction * Math.pow(10, MAX_DECIMALS) > 0;
+    // Use the magnitude: for negative values `fraction` is negative, so `fraction * 100 > 0` was false and the
+    // decimals were dropped. `>= 1` also correctly treats fractions that round to nothing at MAX_DECIMALS as
+    // having no displayable decimals.
+    const would_produce_decimals = Math.abs(fraction) * Math.pow(10, MAX_DECIMALS) >= 1;
 
     if (would_produce_decimals && Math.abs(value) < 100) {
         const truncated = value.toFixed(MAX_DECIMALS);

package/src/core/primitives/strings/string_jaro_winkler.js

@@ -61,5 +61,5 @@ function getPrefix(a1, a2, character_limit) {
         }
     }
 
-    return ++p;
+    return p;
 }

package/src/core/process/CompositeProcess.js

@@ -42,6 +42,6 @@ export class CompositeProcess extends BaseProcess {
 
         this.children.forEach(c => c.shutdown());
 
-        super.startup();
+        super.shutdown();
     }
 }

package/src/core/process/action/AsynchronousDelayAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AsynchronousDelayAction.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/action/AsynchronousDelayAction.js"],"names":[],"mappings":"AAUA;IAEI;;;;OAIG;IACH,+CAFW,MAAM,EAqBhB;IAdG,8BAAgB;IAChB,eAAkB;IAElB,iBAA4B;IAahC,wBAMC;CAOJ;mCA3CkC,yBAAyB;mBARzC,+BAA+B"}
+{"version":3,"file":"AsynchronousDelayAction.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/action/AsynchronousDelayAction.js"],"names":[],"mappings":"AAUA;IAEI;;;;OAIG;IACH,+CAFW,MAAM,EAqBhB;IAdG,8BAAgB;IAChB,eAAkB;IAElB,iBAA4B;IAahC,wBASC;CAOJ;mCA9CkC,yBAAyB;mBARzC,+BAA+B"}

package/src/core/process/action/AsynchronousDelayAction.js

@@ -39,6 +39,9 @@ export class AsynchronousDelayAction extends AsynchronousAction {
     cancel() {
         if (this.status === TaskState.RUNNING) {
             this.__entity.destroy();
+            // transition state and notify listeners, mirroring AsynchronousActionSequence.cancel
+            this.status = TaskState.CANCELLED;
+            this.on.cancelled.send0();
         }
 
         return Promise.resolve();

package/src/core/process/executor/ConcurrentExecutor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConcurrentExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/executor/ConcurrentExecutor.js"],"names":[],"mappings":";AAgBA;;GAEG;AACH;IAaI;;;;;OAKG;IACH,wBAJW,MAAM,aACN,MAAM,EAwChB;IApCG;;;OAGG;IACH,WAFU,MAAM,CAEU;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,iBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,YAFU,MAAM,CAEI;IAEpB;;;;MAIC;IAED,cAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,GAAC,gBAAgB,CAES;IAG9C;;;OAGG;IACH,qCAmEC;IAED;;;OAGG;IACH,oCAaC;IAED;;;;OAIG;IACH,wBAFY,OAAO,CAwBlB;IAED;;;OAGG;IACH,sBAGC;IAED;;;OAGG;IACH,eAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,kBAkCC;IAED;;OAEG;IACH,qBA8BC;IAED;;;;OAIG;IACH,sBAFa,OAAO,CAYnB;IAwLD;;;OAGG;IACH,aAQC;IAED,0BAMC;;CACJ;;;;mBAhgBkB,+BAA+B;wBAogBxC,MAAM"}
+{"version":3,"file":"ConcurrentExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/executor/ConcurrentExecutor.js"],"names":[],"mappings":";AAgBA;;GAEG;AACH;IAaI;;;;;OAKG;IACH,wBAJW,MAAM,aACN,MAAM,EAwChB;IApCG;;;OAGG;IACH,WAFU,MAAM,CAEU;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,iBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,YAFU,MAAM,CAEI;IAEpB;;;;MAIC;IAED,cAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,GAAC,gBAAgB,CAES;IAG9C;;;OAGG;IACH,qCAmEC;IAED;;;OAGG;IACH,oCAaC;IAED;;;;OAIG;IACH,wBAFY,OAAO,CAwBlB;IAED;;;OAGG;IACH,sBAGC;IAED;;;OAGG;IACH,eAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,kBAkCC;IAED;;OAEG;IACH,qBA+BC;IAED;;;;OAIG;IACH,sBAFa,OAAO,CAYnB;IAwLD;;;OAGG;IACH,aAQC;IAED,0BAMC;;CACJ;;;;mBAjgBkB,+BAA+B;wBAqgBxC,MAAM"}

package/src/core/process/executor/ConcurrentExecutor.js

@@ -277,8 +277,9 @@ class ConcurrentExecutor {
                     //attempt to start the task
                     this.startTask(unresolvedTask);
 
-                    //task start could have altered unresolved queue, re-initialize iteration
-                    i = 0;
+                    //task start could have altered unresolved queue, re-initialize iteration.
+                    //use -1 so the loop's i++ restarts at index 0; i=0 would skip the element now at index 0.
+                    i = -1;
                     l = queueUnresolved.length;
 
                     break;

package/src/core/process/task/util/randomCountTask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomCountTask.d.ts","sourceRoot":"","sources":["../../../../../../src/core/process/task/util/randomCountTask.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,sCANW,MAAM,WACN,MAAM,mBAAa,MAAM,CAAA,SACzB,MAAM,mBAAa,MAAM,CAAA,kBAEvB,IAAI,CAoDhB;iBA7DgB,YAAY"}
+{"version":3,"file":"randomCountTask.d.ts","sourceRoot":"","sources":["../../../../../../src/core/process/task/util/randomCountTask.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,sCANW,MAAM,WACN,MAAM,mBAAa,MAAM,CAAA,SACzB,MAAM,mBAAa,MAAM,CAAA,kBAEvB,IAAI,CAsDhB;iBA/DgB,YAAY"}

package/src/core/process/task/util/randomCountTask.js

@@ -17,7 +17,9 @@ export function randomCountTask(seed, initial, limit, callback) {
 
     const span = limit - initial;
 
-    const sequence = new Uint16Array(span);
+    // Uint32Array, not Uint16Array: the sequence stores indices 0..span-1, which overflow a Uint16 once
+    // span exceeds 65535 (sequence[i] = i would wrap), corrupting the produced order.
+    const sequence = new Uint32Array(span);
 
     let i = 0;
 

package/src/core/process/undo/ActionProcessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionProcessor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/ActionProcessor.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IACI;;;;OAIG;IACH,0BA4DC;IA3DG;;;OAGG;IACH,SAFU,YAAY,CAEG;IAEzB;;;OAGG;IACH,aAAsB;IAEtB;;;OAGG;IACH,aAAe;IAEf;;OAEG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,oBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEa;IAE7B;;;OAGG;IACH,oBAFU,MAAM,CAEmB;IAEnC;;;OAGG;IACH,6GAA+B;IAE/B;;;OAGG;IACH,+GAAiC;IAEjC;;;;OAIG;IACH,uBAAuC;IAG3C;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,GACJ,CAAC,CAWb;IAED;;OAEG;IACH,cAGC;IAED;;;;;;;;OAQG;IACH,wBAFW,MAAM,QAqChB;IAED;;;OAGG;IACH,oCAiCC;IAED,uBA2BC;IAED;;;;;OAKG;IACH,2CAcC;IAED;;;;;OAKG;IACH,4BAJW,CAAC,GACC,OAAO,CAWnB;IAED;;;;;;OAMG;IACH,4BAyDC;IAED,sBAQC;IAED;;;;OAIG;IACH,sBAmCC;IAED;;OAEG;IACH,sBAQC;IAED;;;;OAIG;IACH,sBA0BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,iBAuBlB;IAED;;;OAGG;IACH,kCAQC;IAED;;;;;OAKG;IACH,oBAgBC;IAED;;;;OAIG;IACH,kBAMC;CACJ;iBAzfgB,+BAA+B;qBAG3B,WAAW;mBAFb,+BAA+B"}
+{"version":3,"file":"ActionProcessor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/ActionProcessor.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IACI;;;;OAIG;IACH,0BA4DC;IA3DG;;;OAGG;IACH,SAFU,YAAY,CAEG;IAEzB;;;OAGG;IACH,aAAsB;IAEtB;;;OAGG;IACH,aAAe;IAEf;;OAEG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,oBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEa;IAE7B;;;OAGG;IACH,oBAFU,MAAM,CAEmB;IAEnC;;;OAGG;IACH,6GAA+B;IAE/B;;;OAGG;IACH,+GAAiC;IAEjC;;;;OAIG;IACH,uBAAuC;IAG3C;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,GACJ,CAAC,CAWb;IAED;;OAEG;IACH,cAGC;IAED;;;;;;;;OAQG;IACH,wBAFW,MAAM,QAuChB;IAED;;;OAGG;IACH,oCAiCC;IAED,uBA2BC;IAED;;;;;OAKG;IACH,2CAcC;IAED;;;;;OAKG;IACH,4BAJW,CAAC,GACC,OAAO,CAWnB;IAED;;;;;;OAMG;IACH,4BAyDC;IAED,sBAQC;IAED;;;;OAIG;IACH,sBAmCC;IAED;;OAEG;IACH,sBAQC;IAED;;;;OAIG;IACH,sBA0BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,iBAuBlB;IAED;;;OAGG;IACH,kCAQC;IAED;;;;;OAKG;IACH,oBAgBC;IAED;;;;OAIG;IACH,kBAMC;CACJ;iBA3fgB,+BAA+B;qBAG3B,WAAW;mBAFb,+BAA+B"}

package/src/core/process/undo/ActionProcessor.js

@@ -147,13 +147,15 @@ export class ActionProcessor {
             mark.index -= recordsToDrop;
         }
 
-        //update cursor
-        this.cursor -= recordsToDrop;
+        //update cursor (clamp: recordsToDrop can exceed the cursor, e.g. dropping history after some undos)
+        this.cursor = Math.max(0, this.cursor - recordsToDrop);
 
         // dispatch signal
         dropped_marks.forEach(this.onMarkRemoved.send1, this.onMarkRemoved);
 
-        // update history
+        // update history: actually drop the records. List.crop(start, end) keeps [start, end), so this removes
+        // the first recordsToDrop records and keeps the remainder (consistent with the shifted marks/cursor).
+        this.history.crop(recordsToDrop, this.history.length);
 
     }
 

package/src/core/process/worker/WorkerBuilder.js

@@ -118,8 +118,8 @@ class WorkerBuilder {
         Array.prototype.push.apply(codeLines, [
             //language=js
             `function extractTransferables(obj, result) {
-                if (typeof obj !== "object") {
-                    return; //not an object, skip
+                if (obj === null || typeof obj !== "object") {
+                    return; //not an object (or null, which typeof reports as "object"), skip
                 } else if (obj instanceof ArrayBuffer) {
                     result.push(obj);
                 } else if (obj.buffer instanceof ArrayBuffer) {
@@ -167,7 +167,7 @@ class WorkerBuilder {
                     try {
                         const method_result = method.apply(null, parameters);
                         
-                        if(typeof method_result.then === "function"){
+                        if(method_result != null && typeof method_result.then === "function"){
                             // thenable
                             method_result.then(sendResult, sendError);
                         }else{

package/src/engine/animation/curve/AnimationCurve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationCurve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/AnimationCurve.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,gDANwB,QAAQ;IAqZ5B;;;;OAIG;IACH,kBAHW,QAAQ,EAAE,GACR,cAAc,CAQ1B;IAED;;;;;;;;;OASG;IACH,6BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAUzB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,YACN,MAAM,UACN,MAAM,GACL,cAAc,CAOzB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAezB;IAldD;;;;;OAKG;IACH,eAFU,QAAQ,EAAE,CAEV;IAEV;;;;;OAKG;IACH,SAHW,QAAQ,GACN,MAAM,CAuClB;IAED;;;OAGG;IACH,cAFW,QAAQ,EAAE,QAUpB;IAED;;;;OAIG;IACH,YAHW,QAAQ,GACN,OAAO,CAYnB;IAED;;OAEG;IACH,cAEC;IAGD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,yBAUC;IAED;;;;OAIG;IACH,uBAUC;IAED;;;;OAIG;IACH,uBAcC;IAED;;;;;;OAMG;IACH,qBAHW,MAAM,GACJ,MAAM,CAmDlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACL,MAAM,CAoCjB;IAED;;;;OAIG;IACH,qBAFW,MAAM,QAmChB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;OAEG;IACH,yBAQC;IAGD;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACb,OAAO,CAIlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;MAIC;IAED;;aAkBC;IAoFL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;IAGzC;;;OAGG;IACH,mBAA+B;IA9F3B,wDAQC;CAuEJ;yBA/ewB,eAAe"}
+{"version":3,"file":"AnimationCurve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/AnimationCurve.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,gDANwB,QAAQ;IAuZ5B;;;;OAIG;IACH,kBAHW,QAAQ,EAAE,GACR,cAAc,CAQ1B;IAED;;;;;;;;;OASG;IACH,6BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAUzB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,YACN,MAAM,UACN,MAAM,GACL,cAAc,CAOzB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAezB;IApdD;;;;;OAKG;IACH,eAFU,QAAQ,EAAE,CAEV;IAEV;;;;;OAKG;IACH,SAHW,QAAQ,GACN,MAAM,CAuClB;IAED;;;OAGG;IACH,cAFW,QAAQ,EAAE,QAUpB;IAED;;;;OAIG;IACH,YAHW,QAAQ,GACN,OAAO,CAYnB;IAED;;OAEG;IACH,cAEC;IAGD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,yBAUC;IAED;;;;OAIG;IACH,uBAUC;IAED;;;;OAIG;IACH,uBAcC;IAED;;;;;;OAMG;IACH,qBAHW,MAAM,GACJ,MAAM,CAmDlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACL,MAAM,CAoCjB;IAED;;;;OAIG;IACH,qBAFW,MAAM,QAqChB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;OAEG;IACH,yBAQC;IAGD;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACb,OAAO,CAIlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;MAIC;IAED;;aAkBC;IAoFL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;IAGzC;;;OAGG;IACH,mBAA+B;IA9F3B,wDAQC;CAuEJ;yBAjfwB,eAAe"}

package/src/engine/animation/curve/AnimationCurve.js

@@ -321,7 +321,9 @@ export class AnimationCurve {
             const time_span = key_main.time - key_previous.time;
             const value_span = key_main.value - key_previous.value;
 
-            key_main.inTangent = value_span / time_span;
+            // a zero-width span (coincident keys) has no defined slope, treat it as flat
+            // to avoid NaN/Infinity, matching inverseLerp and AnimationCurve.linear
+            key_main.inTangent = time_span === 0 ? 0 : value_span / time_span;
         }
 
 
@@ -331,7 +333,7 @@ export class AnimationCurve {
             const time_span = key_next.time - key_main.time;
             const value_span = key_next.value - key_main.value;
 
-            key_main.outTangent = value_span / time_span;
+            key_main.outTangent = time_span === 0 ? 0 : value_span / time_span;
         }
     }
 

package/src/engine/control/first-person/DESIGN.md

@@ -537,7 +537,7 @@ For landing recovery, use the same form with `zeta = 0.55` so it overshoots once
 ### 5.4 Edge cases and rules
 
 - **Look-pitch clamp** is *non-wrapping*: the pitch is stored as a separate scalar so it cannot accidentally roll over. Yaw on the body wraps freely.
-- **Crouch under a ceiling**: if `intent.crouch` releases but the entity cannot stand up (raycast collides), the controller *holds* crouch and exposes `state.crouchBlocked = true`. Standing happens automatically when clear. This rule lives in the controller because it's universal; the raycast itself is a service-injection point.
+- **Posture is intent-driven; ceilings only block RISING, never push you down**: low geometry constrains posture in exactly one direction. If `intent.crouch` releases but an *already-crouched* (or -prone) entity cannot grow into the taller posture (headroom up-cast collides), the controller *holds* the lower posture and exposes `state.crouchBlocked = true`; standing resumes automatically when clear. The converse is deliberately NOT done: a *standing* player who walks under a low overhang is **not** auto-crouched, and a crouching player who meets a sub-crouch overhang is **not** auto-proned. Their current-posture capsule simply doesn't fit, so the mover blocks their forward motion — "if I can't clear it, I don't move forward." Dropping to a lower stance is always the player's choice (press crouch / slide), never the ceiling's. This rule lives in the controller because it's universal; the headroom cast itself is a service-injection point.
 - **Sprint requires forward intent**: sideways-only or backwards movement should not consume exertion at sprint rates. Specifically `sprint = intent.sprint && intent.move.y > 0.5 && state.grounded`.
 - **No bob in air**: stride does not advance while `!grounded`. Phase freezes so landing doesn't re-fire a stale footstep.
 - **Jump cancel during anticipation**: if grounded becomes false during anticipation (e.g. ground pulled out), drop the queued impulse and emit `onLeaveGround{reason:"fall"}` without `onJumpStart`.