@woosh/meep-engine 2.169.0 → 2.169.2

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

@@ -0,0 +1,45 @@
+/**
+ * Peel one topological layer off `remaining`: every node whose incoming connections all originate outside
+ * `remaining` (i.e. from nodes already laid out) is removed from it and returned.
+ *
+ * MUTATES `remaining` — peeled nodes are spliced out, so repeated calls walk the graph layer by layer and
+ * an empty result means the rest of the graph is cyclic.
+ *
+ * Self-connections are ignored, so a node pointing at itself does not block its own layer.
+ *
+ * Pure graph topology, no geometry: shared verbatim by the box and circle layouters, which each held an
+ * identical private copy closed over their own `remaining`.
+ *
+ * @template {{ connections: Array<{ source: * }> }} T
+ * @param {T[]} remaining nodes not yet laid out; mutated
+ * @returns {T[]} the peeled layer, empty when nothing can be peeled
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function graph_peel_topological_layer(remaining) {
+    const layer = [];
+
+    main_loop: for (let i = remaining.length - 1; i >= 0; i--) {
+        const node = remaining[i];
+        const connections = node.connections;
+
+        for (let j = 0; j < connections.length; j++) {
+            const connection = connections[j];
+
+            const source = connection.source;
+
+            if (source !== node && remaining.indexOf(source) !== -1) {
+                // a source is still pending, so this node is not ready for this layer
+                continue main_loop;
+            }
+        }
+
+        remaining.splice(i, 1);
+
+        // all sources are already laid out
+        layer.push(node);
+    }
+
+    return layer;
+}

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

@@ -1,11 +1,11 @@
 /**
  * @template T
  * @param {T} source
- * @param {Map<string, function(v:Object):Object>} serializers
+ * @param {Map<string, (v: Object) => Object>} serializers
  * @param {Map<*,string>} classNames
  * @param {boolean} [constructorNameFallback]
  */
-export function abstractJSONSerializer<T>(source: T, serializers: any, classNames: Map<any, string>, constructorNameFallback?: boolean): T | {
+export function abstractJSONSerializer<T>(source: T, serializers: Map<string, (v: any) => any>, classNames: Map<any, string>, constructorNameFallback?: boolean): T | {
     type: any;
     data: any;
 };

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,mFAHW,SAAM,MAAM,CAAC,4BACb,OAAO;;;EA4DjB"}
+{"version":3,"file":"abstractJSONSerializer.d.ts","sourceRoot":"","sources":["../../../../src/core/json/abstractJSONSerializer.js"],"names":[],"mappings":"AA+BA;;;;;;GAMG;AACH,4GAHW,SAAM,MAAM,CAAC,4BACb,OAAO;;;EA4DjB"}

package/src/core/json/abstractJSONSerializer.js

@@ -32,7 +32,7 @@ function resolve_class_name(Klass, classNames, max_depth = 64) {
 /**
  * @template T
  * @param {T} source
- * @param {Map<string, function(v:Object):Object>} serializers
+ * @param {Map<string, (v: Object) => Object>} serializers
  * @param {Map<*,string>} classNames
  * @param {boolean} [constructorNameFallback]
  */

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

@@ -23,10 +23,9 @@ export class AbstractCachingParser<T> {
     /**
      *
      * @param {string} code
-     * @param {function(e:Error)} [errorConsumer]
+     * @param {(e: Error) => void} [errorConsumer]
      */
-    validate(code: string, errorConsumer?: typeof noop): boolean;
+    validate(code: string, errorConsumer?: (e: Error) => void): boolean;
 }
 import { Cache } from "../../cache/Cache.js";
-import { noop } from "../../function/noop.js";
 //# sourceMappingURL=AbstractCachingParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AbstractCachingParser.d.ts","sourceRoot":"","sources":["../../../../../src/core/lang/reactive/AbstractCachingParser.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IAEI;;;OAGG;IACH,SAFU,MAAM,MAAM,EAAE,CAAC,CAAC,CAKvB;IAGH;;;;;OAKG;IACH,wBAEC;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,CAAC,CAWb;IAED;;;;OAIG;IACH,eAHW,MAAM,wCAgBhB;CACJ;sBAjEqB,sBAAsB;qBAEvB,wBAAwB"}
+{"version":3,"file":"AbstractCachingParser.d.ts","sourceRoot":"","sources":["../../../../../src/core/lang/reactive/AbstractCachingParser.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IAEI;;;OAGG;IACH,SAFU,MAAM,MAAM,EAAE,CAAC,CAAC,CAKvB;IAGH;;;;;OAKG;IACH,wBAEC;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,CAAC,CAWb;IAED;;;;OAIG;IACH,eAHW,MAAM,sBACF,KAAK,KAAK,IAAI,WAe5B;CACJ;sBAjEqB,sBAAsB"}

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

@@ -48,7 +48,7 @@ export class AbstractCachingParser {
     /**
      *
      * @param {string} code
-     * @param {function(e:Error)} [errorConsumer]
+     * @param {(e: Error) => void} [errorConsumer]
      */
     validate(code, errorConsumer = noop) {
         assert.isString(code, 'code');

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

@@ -44,9 +44,9 @@ export class Localization {
     setAssetManager(am: AssetManager): void;
     /**
      * @returns {boolean}
-     * @param {function(key:string, error:*, original: string)} errorConsumer
+     * @param {(key: string, error: *, original: string) => void} errorConsumer
      */
-    validate(errorConsumer: any): boolean;
+    validate(errorConsumer: (key: string, error: any, original: string) => void): boolean;
     /**
      * Request locale switch
      * Assumes a specific folder structure, each different locale is stored with its locale code as name, and there's also "languages.json" file expected to be in the folder

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":"AA8BA;IAEQ;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB,SAAc;IAEd;;;OAGG;IACH,6BAFU,gBAAgB,CAEwB;IAElD;;;OAGG;IACH,QAFU,cAAc,CAEY;IAEpC;;;OAGG;IACH,OAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,wBAIE;IAGN;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,wCAEC;IAED;;;OAGG;IACH,8BAHa,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;iCApPgC,uBAAuB;2BAL7B,4BAA4B"}
+{"version":3,"file":"Localization.d.ts","sourceRoot":"","sources":["../../../../src/core/localization/Localization.js"],"names":[],"mappings":"AA8BA;IAEQ;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB,SAAc;IAEd;;;OAGG;IACH,6BAFU,gBAAgB,CAEwB;IAElD;;;OAGG;IACH,QAFU,cAAc,CAEY;IAEpC;;;OAGG;IACH,OAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,wBAIE;IAGN;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,wCAEC;IAED;;;OAGG;IACH,8BAFiB,MAAM,wBAAsB,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;iCApPgC,uBAAuB;2BAL7B,4BAA4B"}

package/src/core/localization/Localization.js

@@ -97,7 +97,7 @@ export class Localization {
 
     /**
      * @returns {boolean}
-     * @param {function(key:string, error:*, original: string)} errorConsumer
+     * @param {(key: string, error: *, original: string) => void} errorConsumer
      */
     validate(errorConsumer) {
         let result = true;

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

@@ -0,0 +1,21 @@
+/**
+ * Combine two integer hashes into one, using the classic `h * 31 + x` step truncated to int32.
+ *
+ * This is the canonical two-value mixer. Prefer it over {@link combine_hash} on any path that runs more
+ * than occasionally: `combine_hash` is varargs and therefore allocates a rest array per call, whereas this
+ * is allocation-free and monomorphic.
+ *
+ * Both `(a << 5) - a + b` and `a * 31 + b` spellings appear in the codebase and agree once truncated —
+ * `a * 31 + b` stays exact in a double for int32 inputs (31 * 2^31 is well under 2^53), so the trailing
+ * `| 0` reduces both mod 2^32 identically. The spelling is unified here so the truncation cannot be
+ * forgotten, which is how {@link Vector2#hash} came to return a non-int32.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number} int32
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function hash_mix2(a: number, b: number): number;
+//# sourceMappingURL=hash_mix2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash_mix2.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/hash_mix2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6BAPW,MAAM,KACN,MAAM,GACJ,MAAM,CAOlB"}

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

@@ -0,0 +1,22 @@
+/**
+ * Combine two integer hashes into one, using the classic `h * 31 + x` step truncated to int32.
+ *
+ * This is the canonical two-value mixer. Prefer it over {@link combine_hash} on any path that runs more
+ * than occasionally: `combine_hash` is varargs and therefore allocates a rest array per call, whereas this
+ * is allocation-free and monomorphic.
+ *
+ * Both `(a << 5) - a + b` and `a * 31 + b` spellings appear in the codebase and agree once truncated —
+ * `a * 31 + b` stays exact in a double for int32 inputs (31 * 2^31 is well under 2^53), so the trailing
+ * `| 0` reduces both mod 2^32 identically. The spelling is unified here so the truncation cannot be
+ * forgotten, which is how {@link Vector2#hash} came to return a non-int32.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number} int32
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function hash_mix2(a, b) {
+    return (a * 31 + b) | 0;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Combine three integer hashes into one. Left-folded {@link hash_mix2}, so
+ * `hash_mix3(a, b, c) === hash_mix2(hash_mix2(a, b), c)`.
+ *
+ * Allocation-free, unlike the varargs {@link combine_hash}.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @returns {number} int32
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function hash_mix3(a: number, b: number, c: number): number;
+//# sourceMappingURL=hash_mix3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash_mix3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/hash_mix3.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,6BARW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAOlB"}

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

@@ -0,0 +1,19 @@
+import { hash_mix2 } from "./hash_mix2.js";
+
+/**
+ * Combine three integer hashes into one. Left-folded {@link hash_mix2}, so
+ * `hash_mix3(a, b, c) === hash_mix2(hash_mix2(a, b), c)`.
+ *
+ * Allocation-free, unlike the varargs {@link combine_hash}.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @returns {number} int32
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function hash_mix3(a, b, c) {
+    return hash_mix2(hash_mix2(a, b), c);
+}

package/src/core/math/lookup/LUT_HEATMAP.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Canonical 6-stop "cold to hot" heatmap ramp, RGBA in 0..255, uniformly spaced across `[0,1]`:
+ * black → blue → teal → green → yellow → red.
+ *
+ * This exists so that every debug/diagnostic overlay in the engine reads the same colours; before
+ * it the identical six rows were declared independently by the terrain overlay painter and the
+ * forward+ froxel debug grid, and a palette tweak in one made the two disagree.
+ *
+ * Write mode is disabled, so the shared instance cannot be mutated by a consumer — build your own
+ * {@link ParameterLookupTable} if you need a different ramp.
+ *
+ * @readonly
+ * @type {ParameterLookupTable}
+ */
+export const LUT_HEATMAP: ParameterLookupTable;
+import { ParameterLookupTable } from "./ParameterLookupTable.js";
+//# sourceMappingURL=LUT_HEATMAP.d.ts.map

package/src/core/math/lookup/LUT_HEATMAP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LUT_HEATMAP.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/LUT_HEATMAP.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,0BAFU,oBAAoB,CAEyB;qCAhBlB,2BAA2B"}

package/src/core/math/lookup/LUT_HEATMAP.js

@@ -0,0 +1,30 @@
+import { ParameterLookupTable } from "./ParameterLookupTable.js";
+
+/**
+ * Canonical 6-stop "cold to hot" heatmap ramp, RGBA in 0..255, uniformly spaced across `[0,1]`:
+ * black → blue → teal → green → yellow → red.
+ *
+ * This exists so that every debug/diagnostic overlay in the engine reads the same colours; before
+ * it the identical six rows were declared independently by the terrain overlay painter and the
+ * forward+ froxel debug grid, and a palette tweak in one made the two disagree.
+ *
+ * Write mode is disabled, so the shared instance cannot be mutated by a consumer — build your own
+ * {@link ParameterLookupTable} if you need a different ramp.
+ *
+ * @readonly
+ * @type {ParameterLookupTable}
+ */
+export const LUT_HEATMAP = new ParameterLookupTable(4);
+
+LUT_HEATMAP.write([
+    0, 0, 0, 255,
+    0, 0, 255, 255,
+    0, 179, 179, 255,
+    0, 255, 0, 255,
+    255, 255, 0, 255,
+    255, 5, 5, 255
+]);
+
+LUT_HEATMAP.computeUniformPositions();
+
+LUT_HEATMAP.disableWriteMode();

package/src/core/math/noise/create_simplex_noise_2d.d.ts

@@ -1,7 +1,7 @@
 /**
  * Creates a 2D noise function
  * @param [random] the random function that will be used to build the permutation table
- * @returns {function(x:number, y:number):number} producing values in range -1 .. 1
+ * @returns {(x: number, y: number) => number} producing values in range -1 .. 1
  */
-export function create_simplex_noise_2d(random?: () => number): (arg0: x) => number;
+export function create_simplex_noise_2d(random?: () => number): (x: number, y: number) => number;
 //# sourceMappingURL=create_simplex_noise_2d.d.ts.map

package/src/core/math/noise/create_simplex_noise_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create_simplex_noise_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/create_simplex_noise_2d.js"],"names":[],"mappings":"AAyDA;;;;GAIG;AACH,6EAFwB,MAAM,CA0G7B"}
+{"version":3,"file":"create_simplex_noise_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/create_simplex_noise_2d.js"],"names":[],"mappings":"AAyDA;;;;GAIG;AACH,oEAFiB,MAAM,KAAK,MAAM,KAAK,MAAM,CA0G5C"}

package/src/core/math/noise/create_simplex_noise_2d.js

@@ -58,7 +58,7 @@ const grad4 = /*#__PURE__*/ new Float64Array([0, 1, 1, 1, 0, 1, 1, -1, 0, 1, -1,
 /**
  * Creates a 2D noise function
  * @param [random] the random function that will be used to build the permutation table
- * @returns {function(x:number, y:number):number} producing values in range -1 .. 1
+ * @returns {(x: number, y: number) => number} producing values in range -1 .. 1
  */
 export function create_simplex_noise_2d(random = Math.random) {
     // allocate continuous chunk of memory

package/src/core/math/noise/curl_noise_3d.d.ts

@@ -1,4 +1,10 @@
 /**
+ * Divergence-free 3D curl noise.
+ *
+ * This is the time-independent face of {@link curl_noise_3dt}: sampling the animated field at `w = 0`.
+ * `0` is a real point on the time axis, not a sentinel. The three decorrelation offsets that separate the
+ * potential-field components live in `curl_noise_3dt` only — duplicating them here meant retuning one
+ * field silently decorrelated it from the other.
  *
  * @param {number[]} result
  * @param {number} x

package/src/core/math/noise/curl_noise_3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curl_noise_3d.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/curl_noise_3d.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,sCALW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,QAchB"}
+{"version":3,"file":"curl_noise_3d.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/curl_noise_3d.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,sCALW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,QAIhB"}

package/src/core/math/noise/curl_noise_3d.js

@@ -1,27 +1,18 @@
-import { sdnoise3 } from "./sdnoise.js";
-
-
-const p_x0 = [];
-const p_y0 = [];
-const p_z0 = [];
-
-/**
- *
- * @param {number[]} result
- * @param {number} x
- * @param {number} y
- * @param {number} z
- */
-export function curl_noise_3d(result, x,y,z) {
-    sdnoise3(p_x0, x, y, z);
-    sdnoise3(p_y0, x + 31.341, y - 43.23, z + 12.34);
-    sdnoise3(p_z0, x - 231.141, y + 124.123, z -54.4341);
-
-    const _x = p_z0[1] - p_y0[2];
-    const _y = p_x0[2] - p_z0[0];
-    const _z = p_y0[0] - p_x0[1];
-
-    result[0] = _x;
-    result[1] = _y;
-    result[2] = _z;
-}
+import { curl_noise_3dt } from "./curl_noise_3dt.js";
+
+/**
+ * Divergence-free 3D curl noise.
+ *
+ * This is the time-independent face of {@link curl_noise_3dt}: sampling the animated field at `w = 0`.
+ * `0` is a real point on the time axis, not a sentinel. The three decorrelation offsets that separate the
+ * potential-field components live in `curl_noise_3dt` only — duplicating them here meant retuning one
+ * field silently decorrelated it from the other.
+ *
+ * @param {number[]} result
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function curl_noise_3d(result, x, y, z) {
+    curl_noise_3dt(result, x, y, z, 0);
+}

package/src/core/math/physics/mie/MIE_PARTICLES_STANDARD.js

@@ -14,7 +14,7 @@ import { ri_water } from "./ri_water.js";
  * Assumes the medium is air (n=1.0).
  * Computes the spectrally-averaged RGB Mie properties.
  * @param {number} diameter_m (in meters)
- * @param {function(result:number[], wavelength:number):number[]} refraction refraction [n, k] - Complex refractive index of the particle. (n=real, k=imaginary)
+ * @param {(result: number[], wavelength: number) => number[]} refraction refraction [n, k] - Complex refractive index of the particle. (n=real, k=imaginary)
  */
 function make(diameter_m, refraction){
     const radius = diameter_m * 0.5;

package/src/core/math/physics/mie/compute_mie_particle_properties_rgb.d.ts

@@ -3,11 +3,11 @@
  * Performs full wide visible spectrum sweep.
  * Energy is relative to D65 illuminant (standard for rec709 and sRGB).
  * @param {number} radius_m Particle radius in meters.
- * @param {function(result:number[], wavelength_nm:number)} n_p Particle Refraction Index. function of wavelength, Complex number.
- * @param {function(result:number[], wavelength_nm:number)} n_med Medium Refraction Index. function of wavelength, Complex number.
+ * @param {(result: number[], wavelength_nm: number) => void} n_p Particle Refraction Index. function of wavelength, Complex number.
+ * @param {(result: number[], wavelength_nm: number) => void} n_med Medium Refraction Index. function of wavelength, Complex number.
  * @param {number} [step_size_nm] In nanometers. Controls step size in spectral integration steps, smaller steps = more accurate. Use 1, or multiples of 5
  */
-export function compute_mie_particle_properties_rgb(radius_m: number, n_p: any, n_med: any, step_size_nm?: number): {
+export function compute_mie_particle_properties_rgb(radius_m: number, n_p: (result: number[], wavelength_nm: number) => void, n_med: (result: number[], wavelength_nm: number) => void, step_size_nm?: number): {
     scattering_coefficients: number[];
     extinction_coefficients: number[];
     extinction_intercept: number[];

package/src/core/math/physics/mie/compute_mie_particle_properties_rgb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_mie_particle_properties_rgb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_mie_particle_properties_rgb.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,8DALW,MAAM,uCAGN,MAAM;;;;;;EA+JhB"}
+{"version":3,"file":"compute_mie_particle_properties_rgb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_mie_particle_properties_rgb.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,8DALW,MAAM,gBACG,MAAM,EAAE,iBAAiB,MAAM,KAAK,IAAI,kBACxC,MAAM,EAAE,iBAAiB,MAAM,KAAK,IAAI,iBACjD,MAAM;;;;;;EA+JhB"}

package/src/core/math/physics/mie/compute_mie_particle_properties_rgb.js

@@ -9,8 +9,8 @@ import { compute_lorenz_mie_optical_properties } from "./compute_lorenz_mie_opti
  * Performs full wide visible spectrum sweep.
  * Energy is relative to D65 illuminant (standard for rec709 and sRGB).
  * @param {number} radius_m Particle radius in meters.
- * @param {function(result:number[], wavelength_nm:number)} n_p Particle Refraction Index. function of wavelength, Complex number.
- * @param {function(result:number[], wavelength_nm:number)} n_med Medium Refraction Index. function of wavelength, Complex number.
+ * @param {(result: number[], wavelength_nm: number) => void} n_p Particle Refraction Index. function of wavelength, Complex number.
+ * @param {(result: number[], wavelength_nm: number) => void} n_med Medium Refraction Index. function of wavelength, Complex number.
  * @param {number} [step_size_nm] In nanometers. Controls step size in spectral integration steps, smaller steps = more accurate. Use 1, or multiples of 5
  */
 export function compute_mie_particle_properties_rgb(

package/src/core/math/random/seededRandom_Mulberry32.d.ts

@@ -1,9 +1,10 @@
 /**
  *
  * @param {number} [seed]
- * @returns {(function():number)|{setCurrentSeed:( function(v:number):void),getCurrentSeed:(function():number)}}
+ * @returns {(function():number)|{setCurrentSeed:( (v: number) => void),getCurrentSeed:(function():number)}}
  */
 export function seededRandom_Mulberry32(seed?: number): (() => number) | {
-    setCurrentSeed: ((arg0: v) => number);
+    setCurrentSeed: (v: number) => void;
+    getCurrentSeed: (() => number);
 };
 //# sourceMappingURL=seededRandom_Mulberry32.d.ts.map

package/src/core/math/random/seededRandom_Mulberry32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seededRandom_Mulberry32.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/seededRandom_Mulberry32.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,+CAHW,MAAM,GACJ,OAAY,MAAM,CAAC,GAAC;IAAC,cAAc,EAAC,cAAa,MAAM,CAAC,CAAA;CAAA,CA2BpE"}
+{"version":3,"file":"seededRandom_Mulberry32.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/seededRandom_Mulberry32.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,+CAHW,MAAM,UACQ,MAAM;wBAAwB,MAAM,KAAK,IAAI;oBAAiB,OAAY,MAAM,CAAC;EA2BzG"}

package/src/core/math/random/seededRandom_Mulberry32.js

@@ -1,7 +1,7 @@
 /**
  *
  * @param {number} [seed]
- * @returns {(function():number)|{setCurrentSeed:( function(v:number):void),getCurrentSeed:(function():number)}}
+ * @returns {(function():number)|{setCurrentSeed:( (v: number) => void),getCurrentSeed:(function():number)}}
  */
 export function seededRandom_Mulberry32(seed = 0) {
     let _seed = seed;

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

@@ -1,22 +1,34 @@
 /**
- * Second coordinate of the Hammersley set: the van der Corput radical inverse
- * of `i` in base `R`.
+ * Writes the `i`-th point of the `N`-point Hammersley set to `output`.
  *
- * Computed in closed form, as {@link halton_sequence} does. The previous
- * incremental formulation restarted from zero and applied `i` successive
- * additions, so for any base whose reciprocal is not exactly representable --
- * base 3 among them -- rounding accumulated until the comparisons inside it
- * stopped agreeing with exact arithmetic and the sequence collapsed onto a
- * short cycle. It was also O(i) per element, and therefore quadratic to
- * enumerate; this is O(log i).
+ * The point is `( i/N, Φ_b(i) … )`, one radical inverse per entry of `bases`.
+ * Only the leading `i/N` distinguishes the Hammersley set from the Halton
+ * sequence -- every coordinate after it is a radical inverse, identical to the
+ * corresponding Halton coordinate. That one term is the whole construction: it
+ * buys a log factor of star discrepancy, O((log N)^(s-1) / N) against Halton's
+ * O((log N)^s / N), and it is paid for with `N`.
  *
- * The radical inverse does not depend on the size of the set, so the `count`
- * parameter this used to take is gone: the first Hammersley coordinate is
- * `i / count` and belongs to the caller. It was never read by the body.
+ * Which is why this is a *set* and not a sequence. `N` is fixed before the
+ * first point, and adding one moves every point already emitted. Where samples
+ * are drawn until some quality bar is met, rather than counted out in advance,
+ * the extensible {@link halton_sequence} is the one that applies.
  *
- * @param {number} i index of sequence element
- * @param {number} R a prime number
- * @returns {number} value in [0,1)
+ * ### This is the slow path
+ *
+ * Prefer {@link hammersley_sequence_2d}, which is the two-dimensional base-2
+ * case -- overwhelmingly the common one, and the only one anything in this tree
+ * currently asks for. It resolves its second coordinate through
+ * {@link radical_inverse_VdC_base_2}: a single bit reversal and a multiply, no
+ * loop. This function has no such route. Each coordinate costs a digit loop
+ * with a division per digit, so a point runs `bases.length` of them. Generate
+ * the set once into a buffer, as {@link generate_hammersley_jitter} does; do
+ * not call it per sample inside a hot loop.
+ *
+ * @param {number[]|Float32Array|Float64Array} output receives `1 + bases.length` values
+ * @param {number} output_offset
+ * @param {number} i index of the point within the set
+ * @param {number} N size of the set; `i` must lie in [0, N)
+ * @param {number[]} bases one per dimension after the first, pairwise coprime -- consecutive primes, canonically
  */
-export function hammersley_sequence(i: number, R: number): number;
+export function hammersley_sequence(output: number[] | Float32Array | Float64Array, output_offset: number, i: number, N: number, bases: number[]): void;
 //# sourceMappingURL=hammersley_sequence.d.ts.map

package/src/core/math/statistics/hammersley_sequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hammersley_sequence.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/hammersley_sequence.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAelB"}
+{"version":3,"file":"hammersley_sequence.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/hammersley_sequence.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,4CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,EAAE,QAmBlB"}

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

@@ -1,34 +1,53 @@
-/**
- * Second coordinate of the Hammersley set: the van der Corput radical inverse
- * of `i` in base `R`.
- *
- * Computed in closed form, as {@link halton_sequence} does. The previous
- * incremental formulation restarted from zero and applied `i` successive
- * additions, so for any base whose reciprocal is not exactly representable --
- * base 3 among them -- rounding accumulated until the comparisons inside it
- * stopped agreeing with exact arithmetic and the sequence collapsed onto a
- * short cycle. It was also O(i) per element, and therefore quadratic to
- * enumerate; this is O(log i).
- *
- * The radical inverse does not depend on the size of the set, so the `count`
- * parameter this used to take is gone: the first Hammersley coordinate is
- * `i / count` and belongs to the caller. It was never read by the body.
- *
- * @param {number} i index of sequence element
- * @param {number} R a prime number
- * @returns {number} value in [0,1)
- */
-export function hammersley_sequence(i, R) {
-
-    let result = 0;
-    let f = 1;
-    let n = i;
-
-    while (n > 0) {
-        f = f / R;
-        result = result + f * (n % R);
-        n = (n / R) >>> 0;
-    }
-
-    return result;
-}
+import { assert } from "../../assert.js";
+import { halton_sequence } from "./halton_sequence.js";
+
+/**
+ * Writes the `i`-th point of the `N`-point Hammersley set to `output`.
+ *
+ * The point is `( i/N, Φ_b(i) … )`, one radical inverse per entry of `bases`.
+ * Only the leading `i/N` distinguishes the Hammersley set from the Halton
+ * sequence -- every coordinate after it is a radical inverse, identical to the
+ * corresponding Halton coordinate. That one term is the whole construction: it
+ * buys a log factor of star discrepancy, O((log N)^(s-1) / N) against Halton's
+ * O((log N)^s / N), and it is paid for with `N`.
+ *
+ * Which is why this is a *set* and not a sequence. `N` is fixed before the
+ * first point, and adding one moves every point already emitted. Where samples
+ * are drawn until some quality bar is met, rather than counted out in advance,
+ * the extensible {@link halton_sequence} is the one that applies.
+ *
+ * ### This is the slow path
+ *
+ * Prefer {@link hammersley_sequence_2d}, which is the two-dimensional base-2
+ * case -- overwhelmingly the common one, and the only one anything in this tree
+ * currently asks for. It resolves its second coordinate through
+ * {@link radical_inverse_VdC_base_2}: a single bit reversal and a multiply, no
+ * loop. This function has no such route. Each coordinate costs a digit loop
+ * with a division per digit, so a point runs `bases.length` of them. Generate
+ * the set once into a buffer, as {@link generate_hammersley_jitter} does; do
+ * not call it per sample inside a hot loop.
+ *
+ * @param {number[]|Float32Array|Float64Array} output receives `1 + bases.length` values
+ * @param {number} output_offset
+ * @param {number} i index of the point within the set
+ * @param {number} N size of the set; `i` must lie in [0, N)
+ * @param {number[]} bases one per dimension after the first, pairwise coprime -- consecutive primes, canonically
+ */
+export function hammersley_sequence(
+    output, output_offset,
+    i, N, bases
+) {
+    assert.isNonNegativeInteger(output_offset, 'output_offset');
+    assert.isNonNegativeInteger(i, 'i');
+    assert.isPositiveInteger(N, 'N');
+    assert.lessThan(i, N, 'point index must lie within the set');
+    assert.isArray(bases, 'bases');
+
+    output[output_offset] = i / N;
+
+    const dimensions = bases.length;
+
+    for (let d = 0; d < dimensions; d++) {
+        output[output_offset + 1 + d] = halton_sequence(bases[d], i);
+    }
+}

package/src/core/model/ModuleRegistry.d.ts

@@ -9,9 +9,9 @@ export class ModuleRegistry<T> {
     readonly proxy: ModuleRegistry<any>;
     /**
      *
-     * @param {function(name:string,module:T):void} visitor
+     * @param {(name: string, module: T) => void} visitor
      */
-    traverse(visitor: any): void;
+    traverse(visitor: (name: string, module: T) => void): void;
     /**
      * @template {T} M
      * @param {String} name

package/src/core/model/ModuleRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModuleRegistry.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ModuleRegistry.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAaI;;;OAGG;IACH,oCAiBG;IAEH;;;OAGG;IACH,6BAEC;IAGD;;;;OAIG;IACH,kCAEC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,gBAEJ,OAAO,CA0BnB;IAED;;;;;;OAMG;IACH,qCAHa,MAAM,EAAE,CAYpB;IAED,mBAEC;;CACJ"}
+{"version":3,"file":"ModuleRegistry.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ModuleRegistry.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAaI;;;OAGG;IACH,oCAiBG;IAEH;;;OAGG;IACH,yBAFkB,MAAM,UAAU,CAAC,KAAK,IAAI,QAI3C;IAGD;;;;OAIG;IACH,kCAEC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,gBAEJ,OAAO,CA0BnB;IAED;;;;;;OAMG;IACH,qCAHa,MAAM,EAAE,CAYpB;IAED,mBAEC;;CACJ"}