@woosh/meep-engine 3.30.0 → 3.31.0

package/src/core/geom/vec4/v4_max_axis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v4_max_axis.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec4/v4_max_axis.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,+BATW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAmBlB"}

package/src/core/geom/vec4/v4_max_axis.js

@@ -0,0 +1,41 @@
+/**
+ * Index of the largest of four components: `0` for x, `1` for y, `2` for z, `3` for w.
+ *
+ * The CPU twin of `chunk_v4_max_axis`, written as the same comparison chain so that the two break ties
+ * the same way. That matters more than it looks: `quat3_encode_to_uint32` and its WGSL mirror
+ * `quat_encode_u32` use this to choose which quaternion component to *drop*, and on a tie they used to
+ * choose differently — for `|x| = |y| = 0.6`, `|z| = |w| = 0.1` the CPU dropped x and the GPU dropped y,
+ * so the same quaternion encoded to two different words. Both still decode correctly, because the dropped
+ * index travels in the low two bits, so nothing broke until something compared a CPU-encoded row against
+ * a GPU-encoded one.
+ *
+ * The tie rule, stated: the first component that is strictly greater than every component after it wins,
+ * so on a tie the *later* index is chosen. `(0.6, 0.6, 0.1, 0.1)` answers `1`.
+ *
+ * NaN in any component makes every comparison false, so the answer is `3`. That is the chunk's behaviour
+ * as well, and not a judgement about what a caller should want.
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ * @returns {number} `0..3`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function v4_max_axis(x, y, z, w) {
+    if (x > y && x > z && x > w) {
+        return 0;
+    }
+
+    if (y > z && y > w) {
+        return 1;
+    }
+
+    if (z > w) {
+        return 2;
+    }
+
+    return 3;
+}

package/src/core/graph/coloring/colorizeGraph.js

@@ -35,13 +35,16 @@ function graphToMatrix(graph) {
 
             const otherNode = edge.other(node);
 
-            const transition = edge.validateTransition(node, otherNode);
-
-            if (transition) {
-                const otherNodeIndex = nodes.indexOf(otherNode);
-
-                data[i * vertexCount + otherNodeIndex] = 1;
-            }
+            // Symmetric, whatever the edge's direction. Graph colouring is a property of the
+            // underlying undirected graph - `colorizeGraphGreedy` and `validateGraphColoring` both
+            // go through `graph.getNeighbours`, which is direction-agnostic. Writing only
+            // `[i][other]` when the edge is traversable FROM this node left a directed edge a->b
+            // invisible from b's row, so the kernel could give a and b the same colour and the
+            // validator would then reject the result. A directed triangle came out [1, 2, 1].
+            const otherNodeIndex = nodes.indexOf(otherNode);
+
+            data[i * vertexCount + otherNodeIndex] = 1;
+            data[otherNodeIndex * vertexCount + i] = 1;
         }
     }
 

package/src/core/graph/layout/graph_peel_topological_layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_peel_topological_layer.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/layout/graph_peel_topological_layer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;iBAP6B,MAAM;QAAE,MAAM,MAAG;KAAE,CAAC;wBAgChD"}
+{"version":3,"file":"graph_peel_topological_layer.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/layout/graph_peel_topological_layer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;iBAP6B,MAAM;QAAE,MAAM,MAAG;KAAE,CAAC;wBA8ChD"}

package/src/core/graph/layout/graph_peel_topological_layer.js

@@ -20,6 +20,15 @@
 export function graph_peel_topological_layer(remaining) {
     const layer = [];
 
+    // A snapshot taken BEFORE the scan, and a second pass to remove. Splicing inside the scan
+    // mutated the very set the readiness test reads, so a node peeled a moment ago looked "already
+    // laid out" to its own dependant and the two landed in the same layer - which of them happened
+    // first being decided by the caller's array order alone. The Set also takes the pass from
+    // O(n^2) to O(n + edges).
+    const pending = new Set(remaining);
+
+    const peeled_indices = [];
+
     main_loop: for (let i = remaining.length - 1; i >= 0; i--) {
         const node = remaining[i];
         const connections = node.connections;
@@ -29,17 +38,22 @@ export function graph_peel_topological_layer(remaining) {
 
             const source = connection.source;
 
-            if (source !== node && remaining.indexOf(source) !== -1) {
+            if (source !== node && pending.has(source)) {
                 // a source is still pending, so this node is not ready for this layer
                 continue main_loop;
             }
         }
 
-        remaining.splice(i, 1);
+        peeled_indices.push(i);
 
         // all sources are already laid out
         layer.push(node);
     }
 
+    // descending, because the scan ran backwards - each splice only shifts entries already past
+    for (let i = 0; i < peeled_indices.length; i++) {
+        remaining.splice(peeled_indices[i], 1);
+    }
+
     return layer;
 }

package/src/core/json/JsonUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JsonUtils.d.ts","sourceRoot":"","sources":["../../../../src/core/json/JsonUtils.js"],"names":[],"mappings":"AA4EA,6CAeC;AAzFD;;;;GAIG;AACH,sCAHW,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,IAAI,QAAM,+BAsEzC"}
+{"version":3,"file":"JsonUtils.d.ts","sourceRoot":"","sources":["../../../../src/core/json/JsonUtils.js"],"names":[],"mappings":"AAgFA,6CAeC;AA7FD;;;;GAIG;AACH,sCAHW,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,IAAI,QAAM,+BA0EzC"}

package/src/core/json/JsonUtils.js

@@ -13,7 +13,9 @@ function stringifyStream(json, addToOutput) {
      * @param {object|number|string|null|array} value
      */
     function processProperty(name, value) {
-        addToOutput('"' + name + '":');
+        // the same escaping the value path uses - a key holding a quote, a backslash or a control
+        // character produced output that JSON.parse refuses
+        addToOutput(JSON.stringify(name) + ':');
         processValue(value);
     }
 
@@ -60,7 +62,9 @@ function stringifyStream(json, addToOutput) {
                 addToOutput(JSON.stringify(o));
                 break;
             case "undefined":
-                processValue("null");
+                // the JSON literal, not the four-character string - recursing through
+                // processValue landed in the "string" case and emitted `"null"` with quotes
+                addToOutput("null");
                 break;
             case "symbol":
             case "function":

package/src/core/json/abstractJSONSerializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abstractJSONSerializer.d.ts","sourceRoot":"","sources":["../../../../src/core/json/abstractJSONSerializer.js"],"names":[],"mappings":"AA+BA;;;;;;GAMG;AACH,kEAJW,IAAI,MAAM,EAAE,CAAC,CAAC,KAAQ,QAAW,CAAC,cAClC,SAAM,MAAM,CAAC,4BACb,OAAO;;;EA4DjB"}
+{"version":3,"file":"abstractJSONSerializer.d.ts","sourceRoot":"","sources":["../../../../src/core/json/abstractJSONSerializer.js"],"names":[],"mappings":"AAmCA;;;;;;GAMG;AACH,kEAJW,IAAI,MAAM,EAAE,CAAC,CAAC,KAAQ,QAAW,CAAC,cAClC,SAAM,MAAM,CAAC,4BACb,OAAO;;;EA4DjB"}

package/src/core/json/abstractJSONSerializer.js

@@ -18,7 +18,11 @@ function resolve_class_name(Klass, classNames, max_depth = 64) {
 
         const proto = Object.getPrototypeOf(Klass);
 
-        if (proto !== null && typeof proto === "object") {
+        // NOTE: no `typeof proto === "object"` guard here. `Klass` is a constructor, so its
+        // prototype is the parent constructor - a function - and that guard made this walk, and
+        // the whole `max_depth` parameter, unreachable. `proto !== null` is what terminates it:
+        // the chain runs constructor -> ... -> Function.prototype -> Object.prototype -> null.
+        if (proto !== null) {
 
             return resolve_class_name(proto, classNames, max_depth - 1);
 

package/src/core/lang/reactive/ReactiveOperatorType.d.ts

@@ -1,3 +1,19 @@
+/**
+ * An integer code per operator of the reactive expression language.
+ *
+ * **This is not the authority on what operators exist.** {@link ReactivePegCompiler } dispatches on
+ * the operator string the parse tree carries (`"&&"`, `"+"`, `"<="` …) straight to the expression
+ * class, and routing that through an integer would only add a hop. Nothing in the engine reads these
+ * codes; the enum is kept because an export of a package that ships raw source is public surface.
+ *
+ * It used to name only ten of the fourteen operators the compiler supports — `&&`, `||`, `!` and
+ * unary `-` were missing — so a reader adding an operator had two places that looked authoritative
+ * and one that was. The set is complete now, and `ReactiveOperatorType.spec` holds a table of the
+ * operators that both this enum and the compiler are checked against.
+ *
+ * Codes are append-only, in case one has been persisted somewhere outside this repo.
+ */
+export type ReactiveOperatorType = number;
 export namespace ReactiveOperatorType {
     let Add: number;
     let Subtract: number;
@@ -9,5 +25,9 @@ export namespace ReactiveOperatorType {
     let GreaterThanOrEqual: number;
     let Equal: number;
     let NotEqual: number;
+    let And: number;
+    let Or: number;
+    let Not: number;
+    let Negate: number;
 }
 //# sourceMappingURL=ReactiveOperatorType.d.ts.map

package/src/core/lang/reactive/ReactiveOperatorType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveOperatorType.d.ts","sourceRoot":"","sources":["../../../../../src/core/lang/reactive/ReactiveOperatorType.js"],"names":[],"mappings":""}
+{"version":3,"file":"ReactiveOperatorType.d.ts","sourceRoot":"","sources":["../../../../../src/core/lang/reactive/ReactiveOperatorType.js"],"names":[],"mappings":";;;;;;;;;;;;;;;mCAgBU,MAAM"}

package/src/core/lang/reactive/ReactiveOperatorType.js

@@ -1,12 +1,34 @@
-export const ReactiveOperatorType = {
-    Add: 0,
-    Subtract: 1,
-    Multiply: 2,
-    Divide: 3,
-    LessThan: 4,
-    LessThanOrEqual: 5,
-    GreaterThan: 6,
-    GreaterThanOrEqual: 7,
-    Equal: 8,
-    NotEqual: 9
-}
+/**
+ * An integer code per operator of the reactive expression language.
+ *
+ * **This is not the authority on what operators exist.** {@link ReactivePegCompiler} dispatches on
+ * the operator string the parse tree carries (`"&&"`, `"+"`, `"<="` …) straight to the expression
+ * class, and routing that through an integer would only add a hop. Nothing in the engine reads these
+ * codes; the enum is kept because an export of a package that ships raw source is public surface.
+ *
+ * It used to name only ten of the fourteen operators the compiler supports — `&&`, `||`, `!` and
+ * unary `-` were missing — so a reader adding an operator had two places that looked authoritative
+ * and one that was. The set is complete now, and `ReactiveOperatorType.spec` holds a table of the
+ * operators that both this enum and the compiler are checked against.
+ *
+ * Codes are append-only, in case one has been persisted somewhere outside this repo.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const ReactiveOperatorType = {
+    Add: 0,
+    Subtract: 1,
+    Multiply: 2,
+    Divide: 3,
+    LessThan: 4,
+    LessThanOrEqual: 5,
+    GreaterThan: 6,
+    GreaterThanOrEqual: 7,
+    Equal: 8,
+    NotEqual: 9,
+    And: 10,
+    Or: 11,
+    Not: 12,
+    Negate: 13
+}

package/src/core/localization/LanguageMetadata.d.ts

@@ -21,7 +21,8 @@ export class LanguageMetadata {
      * @type {string}
      */
     locale: string;
-    fromJSON({ reading_speed, fallback_languages }: {
+    fromJSON({ locale, reading_speed, fallback_languages }: {
+        locale?: string;
         reading_speed?: number;
         fallback_languages?: any[];
     }): void;

package/src/core/localization/LanguageMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LanguageMetadata.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/LanguageMetadata.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAmCI,0CAMC;IAxCD;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,oBAFU,MAAM,EAAE,CAEK;IAEvB;;;;OAIG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;aAWC;CASJ"}
+{"version":3,"file":"LanguageMetadata.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/LanguageMetadata.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAyCI,0CAMC;IA9CD;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,oBAFU,MAAM,EAAE,CAEK;IAEvB;;;;OAIG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;aAiBC;CASJ"}

package/src/core/localization/LanguageMetadata.js

@@ -26,16 +26,22 @@ export class LanguageMetadata {
     locale = "";
 
     fromJSON({
+                 locale = "",
                  reading_speed = 10,
                  fallback_languages = []
              }) {
 
         assert.isNumber(reading_speed, 'reading_speed');
         assert.greaterThan(reading_speed, 0, 'reading_speed');
+        assert.isString(locale, 'locale');
 
         this.reading_speed = reading_speed;
 
         this.fallback_languages = fallback_languages;
+
+        // LocalizationEngine keys its registry on this, so leaving it at the class-field default
+        // would file every deserialized language under the empty string
+        this.locale = locale;
     }
 
     static fromJSON(j) {

package/src/core/localization/Localization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Localization.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/Localization.js"],"names":[],"mappings":"AAkCA;IACI;;;OAGG;IACH,cAFU,iEAAa,IAAI,CAEP;IAEpB,SAAU;IAEV;;;OAGG;IACH,6BAFU,gBAAgB,CAEoB;IAE9C;;;OAGG;IACH,QAFU,cAAc,CAEQ;IAEhC;;;OAGG;IACH,OAFU,OAAO,CAEJ;IAEb;;;OAGG;IACH,wBAIG;IAEH;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,0FAEC;IAED;;;OAGG;IACH,wBAFW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,KAAG,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,GAD/C,OAAO,CAoBnB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,SACN,MAAM,gBAgDhB;IAGD;;;OAGG;IACH,gCAFW,MAAM,UAMhB;IAED;;;;;OAKG;IACH,0BA0BC;IAED;;;;;;OAMG;IACH,eALW,MAAM,SACN,MAAM,GAEJ,MAAM,CAoBlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACL,OAAO,CAIlB;CACJ;;iCAtPgC,uBAAuB;2BAL7B,4BAA4B"}
+{"version":3,"file":"Localization.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/Localization.js"],"names":[],"mappings":"AAkCA;IACI;;;OAGG;IACH,cAFU,iEAAa,IAAI,CAEP;IAEpB,SAAU;IAEV;;;OAGG;IACH,6BAFU,gBAAgB,CAEoB;IAE9C;;;OAGG;IACH,QAFU,cAAc,CAEQ;IAEhC;;;OAGG;IACH,OAFU,OAAO,CAEJ;IAEb;;;OAGG;IACH,wBAIG;IAEH;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,0FAEC;IAED;;;OAGG;IACH,wBAFW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,KAAG,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,GAD/C,OAAO,CAoBnB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,SACN,MAAM,gBA2DhB;IAGD;;;OAGG;IACH,gCAFW,MAAM,UAMhB;IAED;;;;;OAKG;IACH,0BA4BC;IAED;;;;;;OAMG;IACH,eALW,MAAM,SACN,MAAM,GAEJ,MAAM,CAoBlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACL,OAAO,CAIlB;CACJ;;iCAnQgC,uBAAuB;2BAL7B,4BAA4B"}

package/src/core/localization/Localization.js

@@ -148,24 +148,35 @@ export class Localization {
             .then(asset => {
                 const json = asset.create();
 
+                // the table and the observable naming it are written together, so a caller can
+                // never observe a locale whose strings are not loaded
                 this.json = json;
 
                 this.locale.set(locale);
-            }, reason => {
-
+            })
+            // NOTE: `.catch` rather than the two-argument `.then`, so a throw from the fulfilled
+            // handler is reported too, and it re-throws - swallowing the rejection made a failed
+            // switch indistinguishable from a successful one
+            .catch(reason => {
                 console.error(`Failed to load locale data for locale '${locale}' : ${reason}`);
 
-                // reset data
-                this.json = {};
-
+                throw reason;
             });
 
         const pLoadMetadata = am.promise(`${_path}/languages.json`, "json")
             .then(asset => {
                 const languages_metadata = asset.create();
 
-                this.language_metadata = LanguageMetadata.fromJSON(languages_metadata[locale]);
-            }, reason => {
+                const entry = languages_metadata[locale];
+
+                // a language with no entry is not an error, it just has no metadata of its own;
+                // destructuring `undefined` here used to throw out of the fulfilled handler, where
+                // its own rejection handler could not catch it
+                this.language_metadata = entry === undefined
+                    ? DEFAULT_LANGUAGE_METADATA
+                    : LanguageMetadata.fromJSON(entry);
+            })
+            .catch(reason => {
                 console.error(`Failed to load language metadata: ${reason}`);
 
                 this.language_metadata = DEFAULT_LANGUAGE_METADATA;
@@ -200,15 +211,17 @@ export class Localization {
 
             //try to find similar keys
             const similarities = Object.keys(this.json).map(function (key) {
-                const distance = string_compute_similarity(key, id);
+                const similarity = string_compute_similarity(key, id);
                 return {
                     key,
-                    distance
+                    similarity
                 };
             });
 
+            // descending: this is a similarity, where 1 is an exact match. It used to be called
+            // `distance` and sorted ascending, which offered the three *least* similar keys.
             similarities.sort(function (a, b) {
-                return a.distance - b.distance;
+                return b.similarity - a.similarity;
             });
 
             const suggestions = similarities.slice(0, 3).map(p => p.key);

package/src/core/localization/LocalizationEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LocalizationEngine.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/LocalizationEngine.js"],"names":[],"mappings":"AAKA;IAaI;;;;OAIG;IACH,sBAHW,MAAM,gCAQhB;IAED;;;OAGG;IACH,sDAIC;IAED;;;;;;;OAOG;IACH,sBAJW,MAAM,gBACN,MAAM,GACJ,MAAO,MAAM,GAAC,SAAS,CAiDnC;;CAEJ"}
+{"version":3,"file":"LocalizationEngine.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/LocalizationEngine.js"],"names":[],"mappings":"AAKA;IAaI;;;;OAIG;IACH,sBAHW,MAAM,gCAQhB;IAED;;;OAGG;IACH,sDAQC;IAED;;;;;;;OAOG;IACH,sBAJW,MAAM,gBACN,MAAM,GACJ,MAAO,MAAM,GAAC,SAAS,CAiDnC;;CAEJ"}

package/src/core/localization/LocalizationEngine.js

@@ -35,6 +35,10 @@ export class LocalizationEngine {
     addLanguageMetadata(metadata) {
         assert.defined(metadata, 'metadata');
 
+        // an empty locale means the metadata was built from a document that did not carry one, and
+        // every such language would pile up under the same registry key
+        assert.notEqual(metadata.locale, "", 'metadata.locale');
+
         this.#languages[metadata.locale] = metadata;
     }
 

package/src/core/math/fract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fract.d.ts","sourceRoot":"","sources":["../../../../src/core/math/fract.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,yBAHW,MAAM,GACJ,MAAM,CAMlB"}
+{"version":3,"file":"fract.d.ts","sourceRoot":"","sources":["../../../../src/core/math/fract.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,yBAHW,MAAM,GACJ,MAAM,CAOlB"}

package/src/core/math/fract.js

@@ -6,7 +6,8 @@
  * @returns {number} returns the fractional part of x. This is calculated as x - floor(x).
  */
 export function fract(v) {
-    const whole = v >> 0; // fast way to cut off fraction
-
-    return v - whole;
+    // NOT `v >> 0`: that truncates toward zero, so it returned `v - trunc(v)` - a negative number -
+    // for every negative input, where GLSL gives the positive fractional part. It also coerces to
+    // int32, so anything at or past 2^31 wrapped: fract(2147483648.5) came back as 4294967296.5.
+    return v - Math.floor(v);
 }

package/src/core/math/hash/squirrel3.d.ts

@@ -1,9 +1,17 @@
 /**
  * Based on Squirrel3 hash function by Squirrel Eiserloh
- * Alex: Personally I found it to have low entropy, so I don't see it as very useful
+ *
+ * NOTE: every step is wrapping u32 arithmetic, matching the WGSL twin `chunk_hash_squirrel3` bit
+ * for bit. This used to multiply with plain `*`, which is a double multiply - `hash * 0x1B56C4E9`
+ * exceeds 2^53 for any int32-sized hash, so the low bits the following `hash ^= hash >> 8` mixes
+ * were rounded away before they were used. The result set bit 31 in exactly zero of 200,000
+ * outputs, half the codomain unreachable, and disagreed with the GPU on every value. An in-file
+ * comment used to blame the algorithm for the resulting low entropy; it was this port.
+ *
+ * @deprecated prefer {@link lowbias32}, as the WGSL chunk already says of its own twin
  * @see GDC 2017 presentation on "Math for Game Programmers: Noise-Based RNG"
  * @param {number} value expected to be an integer, if not - it will be truncated to such
- * @returns {number} signed 32-bit integer
+ * @returns {number} unsigned 32-bit integer
  */
 export function squirrel3(value: number): number;
 //# sourceMappingURL=squirrel3.d.ts.map

package/src/core/math/hash/squirrel3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squirrel3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/squirrel3.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,iCAHW,MAAM,GACJ,MAAM,CAYlB"}
+{"version":3,"file":"squirrel3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/squirrel3.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,iCAHW,MAAM,GACJ,MAAM,CAYlB"}

package/src/core/math/hash/squirrel3.js

@@ -4,19 +4,27 @@ const BIT_NOISE3 = 0x1B56C4E9;
 
 /**
  * Based on Squirrel3 hash function by Squirrel Eiserloh
- * Alex: Personally I found it to have low entropy, so I don't see it as very useful
+ *
+ * NOTE: every step is wrapping u32 arithmetic, matching the WGSL twin `chunk_hash_squirrel3` bit
+ * for bit. This used to multiply with plain `*`, which is a double multiply - `hash * 0x1B56C4E9`
+ * exceeds 2^53 for any int32-sized hash, so the low bits the following `hash ^= hash >> 8` mixes
+ * were rounded away before they were used. The result set bit 31 in exactly zero of 200,000
+ * outputs, half the codomain unreachable, and disagreed with the GPU on every value. An in-file
+ * comment used to blame the algorithm for the resulting low entropy; it was this port.
+ *
+ * @deprecated prefer {@link lowbias32}, as the WGSL chunk already says of its own twin
  * @see GDC 2017 presentation on "Math for Game Programmers: Noise-Based RNG"
  * @param {number} value expected to be an integer, if not - it will be truncated to such
- * @returns {number} signed 32-bit integer
+ * @returns {number} unsigned 32-bit integer
  */
 export function squirrel3(value) {
-    let hash = value * BIT_NOISE1;
+    let hash = Math.imul(value, BIT_NOISE1);
 
-    hash ^= (hash >> 8);
-    hash += BIT_NOISE2;
+    hash ^= (hash >>> 8);
+    hash = (hash + BIT_NOISE2) | 0;
     hash ^= (hash << 8);
-    hash *= BIT_NOISE3;
-    hash ^= (hash >> 8);
+    hash = Math.imul(hash, BIT_NOISE3);
+    hash ^= (hash >>> 8);
 
-    return hash;
+    return hash >>> 0;
 }

package/src/core/math/linalg/m2/m2_polar_decomp_noS.d.ts

@@ -10,6 +10,13 @@
  *  where 'c' is the cosine and 's' is the sine of the rotation angle.  Modified in-place.
  * @param {number[]} m Input: 2x2 matrix, stored as a flattened, *transposed* array [a, b, c, d],
  *  representing the matrix [[a, c], [b, d]].
+ *
+ * A matrix with no rotational component at all — symmetric with zero trace, such as the pure
+ * reflection [[1,0],[0,-1]], or the zero matrix — decomposes to the IDENTITY rotation, which is the
+ * conventional choice when the angle is undefined. Both terms are zero there, and the division used
+ * to be unguarded: 1/sqrt(0) is Infinity and 0 * Infinity is NaN, so the whole output was NaN. In
+ * MLS-MPM that goes into the corotated stress, is scattered to the grid in P2G, and from there
+ * reaches every particle sharing those nodes — one inverted element taking out a neighbourhood.
  */
 export function m2_polar_decomp_noS(R: number[], m: number[]): void;
 //# sourceMappingURL=m2_polar_decomp_noS.d.ts.map

package/src/core/math/linalg/m2/m2_polar_decomp_noS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m2_polar_decomp_noS.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/m2/m2_polar_decomp_noS.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,uCALW,MAAM,EAAE,KAER,MAAM,EAAE,QAqBlB"}
+{"version":3,"file":"m2_polar_decomp_noS.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/m2/m2_polar_decomp_noS.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uCAZW,MAAM,EAAE,KAER,MAAM,EAAE,QAwClB"}

package/src/core/math/linalg/m2/m2_polar_decomp_noS.js

@@ -10,6 +10,13 @@
  *  where 'c' is the cosine and 's' is the sine of the rotation angle.  Modified in-place.
  * @param {number[]} m Input: 2x2 matrix, stored as a flattened, *transposed* array [a, b, c, d],
  *  representing the matrix [[a, c], [b, d]].
+ *
+ * A matrix with no rotational component at all — symmetric with zero trace, such as the pure
+ * reflection [[1,0],[0,-1]], or the zero matrix — decomposes to the IDENTITY rotation, which is the
+ * conventional choice when the angle is undefined. Both terms are zero there, and the division used
+ * to be unguarded: 1/sqrt(0) is Infinity and 0 * Infinity is NaN, so the whole output was NaN. In
+ * MLS-MPM that goes into the corotated stress, is scattered to the grid in P2G, and from there
+ * reaches every particle sharing those nodes — one inverted element taking out a neighbourhood.
  */
 export function m2_polar_decomp_noS(
     R,
@@ -19,7 +26,19 @@ export function m2_polar_decomp_noS(
     const x = m[0] + m[3];
     const y = m[2] - m[1];
 
-    const scale = 1.0 / Math.sqrt(x * x + y * y);
+    const norm2 = x * x + y * y;
+
+    if (norm2 === 0) {
+        // no rotation is defined; the identity is the conventional answer
+        R[0] = 1;
+        R[1] = 0;
+        R[2] = 0;
+        R[3] = 1;
+
+        return;
+    }
+
+    const scale = 1.0 / Math.sqrt(norm2);
 
     const c = x * scale;
     const s = y * scale;

package/src/core/math/physics/pdf/pdf_normal.d.ts

@@ -1,7 +1,15 @@
 /**
- * Normal Probability Distribution Function
- * @param {number} x
- * @param {number} sigma
+ * Normal Probability Distribution Function.
+ *
+ * `1 / (sigma * sqrt(2 * PI)) * exp(-x^2 / (2 * sigma^2))`.
+ *
+ * This is the one implementation of the normal PDF in the tree.
+ * {@link gaussian_amplitude} is the same function parameterised by variance rather than standard
+ * deviation, and calls this. The two used to be written out separately, which cost 5.7e-6 of relative
+ * accuracy here — the normalisation factor was a five-digit literal, `0.39894`.
+ *
+ * @param {number} x distance from the mean
+ * @param {number} sigma standard deviation, greater than 0
  * @return {number}
  */
 export function pdf_normal(x: number, sigma: number): number;

package/src/core/math/physics/pdf/pdf_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pdf_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/pdf/pdf_normal.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,8BAJW,MAAM,SACN,MAAM,GACL,MAAM,CAIjB"}
+{"version":3,"file":"pdf_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/pdf/pdf_normal.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,8BAJW,MAAM,SACN,MAAM,GACL,MAAM,CAIjB"}

package/src/core/math/physics/pdf/pdf_normal.js

@@ -1,11 +1,25 @@
-import { gaussian } from "../../gaussian.js";
-
-/**
- * Normal Probability Distribution Function
- * @param {number} x
- * @param {number} sigma
- * @return {number}
- */
-export function pdf_normal(x, sigma) {
-    return 0.39894 * gaussian(sigma, x) / sigma;
-}
+import { gaussian } from "../../gaussian.js";
+
+/**
+ * `sqrt(2 * PI)`, the normalisation denominator of the unit normal, to full double precision.
+ * @type {number}
+ */
+const SQRT_TWO_PI = Math.sqrt(2 * Math.PI);
+
+/**
+ * Normal Probability Distribution Function.
+ *
+ * `1 / (sigma * sqrt(2 * PI)) * exp(-x^2 / (2 * sigma^2))`.
+ *
+ * This is the one implementation of the normal PDF in the tree.
+ * {@link gaussian_amplitude} is the same function parameterised by variance rather than standard
+ * deviation, and calls this. The two used to be written out separately, which cost 5.7e-6 of relative
+ * accuracy here — the normalisation factor was a five-digit literal, `0.39894`.
+ *
+ * @param {number} x distance from the mean
+ * @param {number} sigma standard deviation, greater than 0
+ * @return {number}
+ */
+export function pdf_normal(x, sigma) {
+    return gaussian(sigma, x) / (sigma * SQRT_TWO_PI);
+}

package/src/core/math/solveQuadratic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solveQuadratic.d.ts","sourceRoot":"","sources":["../../../../src/core/math/solveQuadratic.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,uCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KAJN,MAAM,KACN,MAAM,KACN,MAAM,GAGJ,MAAM,CAsDlB"}
+{"version":3,"file":"solveQuadratic.d.ts","sourceRoot":"","sources":["../../../../src/core/math/solveQuadratic.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,uCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KAJN,MAAM,KACN,MAAM,KACN,MAAM,GAGJ,MAAM,CAyElB"}

package/src/core/math/solveQuadratic.js

@@ -52,10 +52,29 @@ export function solveQuadratic(
             // if discriminant square is negative, solution can only be imaginary, we don't deal with that
 
             const disc = Math.sqrt(disc_sqr);
-            const a2 = 2 * a;
 
-            result[result_offset] = (-b - disc) / a2;
-            result[result_offset + 1] = (-b + disc) / a2;
+            // The textbook `(-b +/- disc) / 2a` computes one of the two roots as a subtraction of
+            // two nearly equal doubles whenever `b*b >> 4ac`, so the small root is left with
+            // whatever digits survive the cancellation - at b = 1e8 it was 25% out, at 1e9 it was
+            // gone entirely. The `q` form costs nothing and keeps both roots:
+            //
+            //   q = -(b + sign(b) * disc) / 2,   x = q/a   and   x = c/q
+            //
+            // The ordering below is the one this function has always had: the minus-root first,
+            // which for a negative `a` is the larger of the two.
+            const q = -0.5 * (b + (b >= 0 ? disc : -disc));
+
+            if (q === 0) {
+                // only when b and disc are both zero, i.e. a double root at the origin
+                result[result_offset] = 0;
+                result[result_offset + 1] = 0;
+            } else if (b >= 0) {
+                result[result_offset] = q / a;
+                result[result_offset + 1] = c / q;
+            } else {
+                result[result_offset] = c / q;
+                result[result_offset + 1] = q / a;
+            }
 
             return 2;
         }

package/src/core/math/statistics/computeStatisticalPartialMedian.d.ts

@@ -1,8 +1,15 @@
 /**
+ * The median of `values[start..end]` inclusive.
+ *
+ * NOTE: `start`/`end` index the INPUT, not sorted order. This used to sort the whole array and then
+ * index the sorted copy, which is a rank window rather than a value window - so anything outside
+ * `[start, end]` was still sorted in and displaced the window's own values. A caller with a
+ * fixed-capacity backing array (`RingBufferMetric`) got a median drawn from the slots past its
+ * live count. `computeStatisticalPercentile`, whose start/end really are ranks, sorts for itself.
  *
  * @param {number[]} values
- * @param {number} start
- * @param {number} end
+ * @param {number} start first index of the window, inclusive
+ * @param {number} end last index of the window, inclusive
  * @returns {number}
  */
 export function computeStatisticalPartialMedian(values: number[], start: number, end: number): number;