@woosh/meep-engine 3.16.0 → 3.17.0

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise3.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 3-D simplex noise with rotating gradients and an analytic derivative — `psrdnoise` without the
+ * `p`, for fields that never need to tile.
+ *
+ * Returns `vec4(noise, gradient.xyz)`: the noise value is in `.x`, in `[-1, 1]`, and `.yzw` is its
+ * exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * `alpha` turns every gradient in the field by that many radians about a per-corner pseudo-random
+ * axis. Animating it swirls the field in place, which with the gradient is what curl noise wants —
+ * see {@link chunk_psrdnoise3_kernel}.
+ *
+ * This is {@link chunk_psrdnoise3} with the wrap deleted, not a call into it with a zero period: it
+ * exists so a caller whose period is a runtime value it never sets does not pay for the branch and
+ * the modulo. It still repeats every 289 cells — that is the hash's modulus, not a choice — so it
+ * is "non-periodic" only in the sense that it does not tile to a period you name.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_srdnoise3: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_srdnoise3.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_srdnoise3.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise3.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8BAFU,SAAS,CAkDjB;0BAzEwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise3.js

@@ -0,0 +1,74 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_psrdnoise3_kernel } from "./chunk_psrdnoise3_kernel.js";
+import { chunk_psrdnoise3_skew } from "./chunk_psrdnoise3_skew.js";
+import { chunk_psrdnoise3_unskew } from "./chunk_psrdnoise3_unskew.js";
+
+/**
+ * 3-D simplex noise with rotating gradients and an analytic derivative — `psrdnoise` without the
+ * `p`, for fields that never need to tile.
+ *
+ * Returns `vec4(noise, gradient.xyz)`: the noise value is in `.x`, in `[-1, 1]`, and `.yzw` is its
+ * exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * `alpha` turns every gradient in the field by that many radians about a per-corner pseudo-random
+ * axis. Animating it swirls the field in place, which with the gradient is what curl noise wants —
+ * see {@link chunk_psrdnoise3_kernel}.
+ *
+ * This is {@link chunk_psrdnoise3} with the wrap deleted, not a call into it with a zero period: it
+ * exists so a caller whose period is a runtime value it never sets does not pay for the branch and
+ * the modulo. It still repeats every 289 cells — that is the hash's modulus, not a choice — so it
+ * is "non-periodic" only in the sense that it does not tile to a period you name.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_srdnoise3 = CodeChunk.from(
+    //language=WGSL
+    `
+fn srdnoise3(
+    x: vec3<f32>,
+    alpha: f32
+) -> vec4<f32> {
+    let uvw = psrdnoise3_skew(x);
+
+    // which simplex we are in. i0 is the base corner of the skewed cube; o1 and o2 step to the
+    // second and third corners, found by rank-ordering u, v, w — the descending order of the
+    // fractional coordinates is exactly the order the tetrahedron's corners are traversed in
+    let i0 = floor(uvw);
+    let f0 = uvw - i0;
+
+    let gt_ = step(f0.xyx, f0.yzz);
+    let lt_ = 1.0 - gt_;
+    let gt = vec3<f32>(lt_.z, gt_.xy);
+    let lt = vec3<f32>(lt_.xy, gt_.z);
+    let o1 = min(gt, lt);
+    let o2 = max(gt, lt);
+
+    let i1 = i0 + o1;
+    let i2 = i0 + o2;
+    let i3 = i0 + vec3<f32>(1.0);
+
+    // the four corners back in texture space
+    let v0 = psrdnoise3_unskew(i0);
+    let v1 = psrdnoise3_unskew(i1);
+    let v2 = psrdnoise3_unskew(i2);
+    let v3 = psrdnoise3_unskew(i3);
+
+    return psrdnoise3_kernel(
+        vec4<f32>(i0.x, i1.x, i2.x, i3.x),
+        vec4<f32>(i0.y, i1.y, i2.y, i3.y),
+        vec4<f32>(i0.z, i1.z, i2.z, i3.z),
+        x - v0,
+        x - v1,
+        x - v2,
+        x - v3,
+        alpha
+    );
+}
+    `, [
+        chunk_psrdnoise3_kernel,
+        chunk_psrdnoise3_skew,
+        chunk_psrdnoise3_unskew,
+    ]
+);

package/src/shade/wgsl/emulator/ComputeShaderEmulator.d.ts

@@ -16,6 +16,11 @@
  *   emu.dispatch([0, 0, 0]);   // global_invocation_id = (0,0,0)
  *   emu.dispatch([1, 0, 0]);   // global_invocation_id = (1,0,0)
  *   // ... bindings now contain results
+ *
+ * Each dispatch is a fresh invocation: `var<private>` variables go back to their declared
+ * initializers first, as they do on the GPU. `var<workgroup>` variables do not — they belong to
+ * the workgroup, so lanes dispatched in sequence share them until {@link
+ * ComputeShaderEmulator#resetWorkgroup} is called.
  */
 export class ComputeShaderEmulator {
     /**
@@ -74,7 +79,9 @@ export class ComputeShaderEmulator {
     /**
      * Compile a {@link CodeChunk} (or a raw WGSL string) into a "library" object — every
      * top-level WGSL function becomes a method, every `var<private>` becomes a getter/setter
-     * property, and every module-scope `const` becomes a read-only getter.
+     * property, and every module-scope `const` becomes a read-only getter. `reset_private()`
+     * puts the private variables back to their initial values; there is no dispatch here to do
+     * it for you, so call it between cases that must not see each other's state.
      *
      * No `@compute` entry is required. This is the one-line escape hatch for unit-testing pure
      * helper code (RNGs, hashes, packing, math) without wrapping each chunk in a shader skeleton.
@@ -116,6 +123,17 @@ export class ComputeShaderEmulator {
      * @type {object}
      */
     bindings: object;
+    /**
+     * Whether {@link dispatch} starts each thread with the module's `var<private>` variables
+     * back at their start-of-invocation values. On by default, because that is what a GPU
+     * invocation gets — see {@link resetPrivate}.
+     *
+     * Turn it off to simulate something the hardware cannot, such as watching a private RNG
+     * advance across a run of dispatches.
+     *
+     * @type {boolean}
+     */
+    resetPrivateOnDispatch: boolean;
     /**
      * @returns {string} the WGSL source.
      */
@@ -153,6 +171,21 @@ export class ComputeShaderEmulator {
      * variables start fresh. No-op for fragment-stage entries.
      */
     resetWorkgroup(): void;
+    /**
+     * Return every module-scope `var<private>` to the value it has at the start of a WGSL
+     * invocation — its declared initializer, or zero when it was declared without one.
+     *
+     * {@link dispatch} calls this for you, because that is what the GPU does: private variables
+     * are per-invocation, and one invocation never sees what another left in them. Set
+     * {@link resetPrivateOnDispatch} to `false` for the rare simulation that wants a run of
+     * dispatches to share private state, then call this by hand.
+     *
+     * The private-address-space counterpart of {@link resetWorkgroup} — but note the asymmetry:
+     * `var<workgroup>` state is shared by the lanes of a workgroup, so it is reset per workgroup
+     * and by the caller; `var<private>` state is not shared at all, so it is reset per dispatch
+     * and by default.
+     */
+    resetPrivate(): void;
     /**
      * Dispatch a single thread (point-wise simulation). The arguments are the entry function's
      * parameters, in declaration order — for example a `@builtin(global_invocation_id)` param of

package/src/shade/wgsl/emulator/ComputeShaderEmulator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputeShaderEmulator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/ComputeShaderEmulator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAoII;;;;;;;;;;OAUG;IACH,0BANW,MAAM;QAEe,MAAM,GAA3B,UAAU;QACO,YAAY,GAA7B,MAAM;QACJ,QAAQ,qBAAqB,CAAC,CAa1C;IAED;;;;;;;;OAQG;IACH,iCANW,OAAO,wCAAwC,EAAE,aAAa;QAEzC,MAAM,GAA3B,UAAU;QACO,YAAY,GAA7B,MAAM;QACJ,QAAQ,qBAAqB,CAAC,CAM1C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,+BANW,OAAO,sCAAsC,EAAE,WAAW;QAErC,MAAM,GAA3B,UAAU;QACO,YAAY,GAA7B,MAAM;QACJ,QAAQ,qBAAqB,CAAC,CAM1C;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sCANW,OAAO,6CAA6C,EAAE,SAAS,GAAG,MAAM;QAEnD,MAAM,GAA3B,UAAU;QACO,YAAY,GAA7B,MAAM;QACJ,QAAQ,MAAM,CAAC,CAS3B;IAvMD;;;;;;;;;;OAUG;IACH;QAL2B,MAAM,EAAtB,MAAM;QACU,MAAM,EAAtB,MAAM;QACU,QAAQ,EAAxB,MAAM;QACU,YAAY,EAA5B,MAAM;OAYhB;IA5BD;;;;OAIG;IACH,UAFU,MAAM,CAEF;IAyBd;;OAEG;IACH,qBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,oCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,uBAIC;IAED;;;;;;;;;;;OAWG;IACH,kCAKC;;CA8FJ;2BAvP0B,kBAAkB"}
+{"version":3,"file":"ComputeShaderEmulator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/ComputeShaderEmulator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAqKI;;;;;;;;;;OAUG;IACH,0BANW,MAAM;QAEe,MAAM,GAA3B,UAAU;QACO,YAAY,GAA7B,MAAM;QACJ,QAAQ,qBAAqB,CAAC,CAa1C;IAED;;;;;;;;OAQG;IACH,iCANW,OAAO,wCAAwC,EAAE,aAAa;QAEzC,MAAM,GAA3B,UAAU;QACO,YAAY,GAA7B,MAAM;QACJ,QAAQ,qBAAqB,CAAC,CAM1C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,+BANW,OAAO,sCAAsC,EAAE,WAAW;QAErC,MAAM,GAA3B,UAAU;QACO,YAAY,GAA7B,MAAM;QACJ,QAAQ,qBAAqB,CAAC,CAM1C;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,sCANW,OAAO,6CAA6C,EAAE,SAAS,GAAG,MAAM;QAEnD,MAAM,GAA3B,UAAU;QACO,YAAY,GAA7B,MAAM;QACJ,QAAQ,MAAM,CAAC,CAS3B;IA9ND;;;;;;;;;;OAUG;IACH;QAL2B,MAAM,EAAtB,MAAM;QACU,MAAM,EAAtB,MAAM;QACU,QAAQ,EAAxB,MAAM;QACU,YAAY,EAA5B,MAAM;OAYhB;IAxCD;;;;OAIG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;;;OASG;IACH,wBAFU,OAAO,CAEa;IAyB9B;;OAEG;IACH,qBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,oCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,uBAIC;IAED;;;;;;;;;;;;;OAaG;IACH,qBAEC;IAED;;;;;;;;;;;OAWG;IACH,kCAQC;;CAgGJ;2BA/R0B,kBAAkB"}

package/src/shade/wgsl/emulator/ComputeShaderEmulator.js

@@ -21,6 +21,11 @@ import { WGSLLanguageCore } from "./WGSLLanguageCore.js";
  *   emu.dispatch([0, 0, 0]);   // global_invocation_id = (0,0,0)
  *   emu.dispatch([1, 0, 0]);   // global_invocation_id = (1,0,0)
  *   // ... bindings now contain results
+ *
+ * Each dispatch is a fresh invocation: `var<private>` variables go back to their declared
+ * initializers first, as they do on the GPU. `var<workgroup>` variables do not — they belong to
+ * the workgroup, so lanes dispatched in sequence share them until {@link
+ * ComputeShaderEmulator#resetWorkgroup} is called.
  */
 export class ComputeShaderEmulator {
 
@@ -46,6 +51,18 @@ export class ComputeShaderEmulator {
      */
     bindings = {};
 
+    /**
+     * Whether {@link dispatch} starts each thread with the module's `var<private>` variables
+     * back at their start-of-invocation values. On by default, because that is what a GPU
+     * invocation gets — see {@link resetPrivate}.
+     *
+     * Turn it off to simulate something the hardware cannot, such as watching a private RNG
+     * advance across a run of dispatches.
+     *
+     * @type {boolean}
+     */
+    resetPrivateOnDispatch = true;
+
     /**
      * Construct directly when you already have the WGSL source string.
      *
@@ -135,6 +152,24 @@ export class ComputeShaderEmulator {
         }
     }
 
+    /**
+     * Return every module-scope `var<private>` to the value it has at the start of a WGSL
+     * invocation — its declared initializer, or zero when it was declared without one.
+     *
+     * {@link dispatch} calls this for you, because that is what the GPU does: private variables
+     * are per-invocation, and one invocation never sees what another left in them. Set
+     * {@link resetPrivateOnDispatch} to `false` for the rare simulation that wants a run of
+     * dispatches to share private state, then call this by hand.
+     *
+     * The private-address-space counterpart of {@link resetWorkgroup} — but note the asymmetry:
+     * `var<workgroup>` state is shared by the lanes of a workgroup, so it is reset per workgroup
+     * and by the caller; `var<private>` state is not shared at all, so it is reset per dispatch
+     * and by default.
+     */
+    resetPrivate() {
+        this.#module.reset_private();
+    }
+
     /**
      * Dispatch a single thread (point-wise simulation). The arguments are the entry function's
      * parameters, in declaration order — for example a `@builtin(global_invocation_id)` param of
@@ -148,6 +183,9 @@ export class ComputeShaderEmulator {
      * @returns {*}
      */
     dispatch(...mainArgs) {
+        if (this.resetPrivateOnDispatch) {
+            this.resetPrivate();
+        }
         if (this.#module.stage === 'fragment') {
             return this.#module.entry(this.bindings, ...mainArgs);
         }
@@ -223,7 +261,9 @@ export class ComputeShaderEmulator {
     /**
      * Compile a {@link CodeChunk} (or a raw WGSL string) into a "library" object — every
      * top-level WGSL function becomes a method, every `var<private>` becomes a getter/setter
-     * property, and every module-scope `const` becomes a read-only getter.
+     * property, and every module-scope `const` becomes a read-only getter. `reset_private()`
+     * puts the private variables back to their initial values; there is no dispatch here to do
+     * it for you, so call it between cases that must not see each other's state.
      *
      * No `@compute` entry is required. This is the one-line escape hatch for unit-testing pure
      * helper code (RNGs, hashes, packing, math) without wrapping each chunk in a shader skeleton.

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.d.ts

@@ -6,8 +6,9 @@ export class WGSLJavaScriptCompiler {
      * a shader module object. The shape depends on what the WGSL declared:
      *
      * - **Always present:** every top-level user function (e.g. `module.random()`),
-     *   every struct class (e.g. `module.Foo`), and a getter/setter property for each
-     *   `var<private>` and getter for each module-scope `const`.
+     *   every struct class (e.g. `module.Foo`), a getter/setter property for each
+     *   `var<private>` and getter for each module-scope `const`, and `reset_private()`,
+     *   which returns every `var<private>` to its start-of-invocation value.
      * - **Compute-shader fields (only when a `@compute` entry is present):**
      *   ```
      *   {

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AAycA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UAjea,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAClG,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}
+{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AA2cA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UApea,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAClG,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -419,10 +419,12 @@ class Compiler {
 
         /**
          * Module-scope `var<private>` and `const` declarations, in declaration order.
-         * Each entry is `{ name, kind: 'let' | 'const', code }` — `code` is the JS line emitted
-         * verbatim; `name` and `kind` are also tracked so the returned module object can expose
-         * them as getter/setter (or read-only) properties for testing.
-         * @type {Array<{ name: string, kind: 'let' | 'const', code: string }>}
+         * Each entry is `{ name, kind: 'let' | 'const', code, init }` — `code` is the JS line
+         * emitted verbatim; `name` and `kind` are also tracked so the returned module object can
+         * expose them as getter/setter (or read-only) properties for testing, and `init` is the
+         * initializer expression on its own, which the private-state reset re-emits for the `let`
+         * ones (a `const` cannot be reassigned, and no invocation can disturb it).
+         * @type {Array<{ name: string, kind: 'let' | 'const', code: string, init: string }>}
          */
         this.privateGlobals = [];
 
@@ -464,8 +466,9 @@ export class WGSLJavaScriptCompiler {
      * a shader module object. The shape depends on what the WGSL declared:
      *
      * - **Always present:** every top-level user function (e.g. `module.random()`),
-     *   every struct class (e.g. `module.Foo`), and a getter/setter property for each
-     *   `var<private>` and getter for each module-scope `const`.
+     *   every struct class (e.g. `module.Foo`), a getter/setter property for each
+     *   `var<private>` and getter for each module-scope `const`, and `reset_private()`,
+     *   which returns every `var<private>` to its start-of-invocation value.
      * - **Compute-shader fields (only when a `@compute` entry is present):**
      *   ```
      *   {
@@ -549,7 +552,12 @@ function compileTranslationUnit(c, root) {
         if (node.type === 'function_decl') emitFunction(c, node);
     }
 
-    // 5) Entry-stage support code: the dispatch wrapper for any entry, plus a workgroup-state
+    // 5) The private-state reset. Emitted for every module, library ones included: a
+    //    `var<private>` is per-invocation state on the GPU, and the JS `let` above outlives the
+    //    dispatch that wrote it, so something has to put the initial values back.
+    emitPrivateStateReset(c);
+
+    // 6) Entry-stage support code: the dispatch wrapper for any entry, plus a workgroup-state
     //    factory for @compute entries (fragment shaders have no var<workgroup>). Skipped entirely
     //    in library mode (no entry attribute) so the resulting module is just a bag of pure
     //    functions and globals.
@@ -560,7 +568,7 @@ function compileTranslationUnit(c, root) {
         emitEntryWrapper(c);
     }
 
-    // 6) Build and return the module object.
+    // 7) Build and return the module object.
     emitModuleReturn(c);
 
     c.out.dedent();
@@ -571,8 +579,9 @@ function compileTranslationUnit(c, root) {
  * Emit the `return { ... }` block of the factory. Every top-level user function and struct
  * class is exposed by name; module-scope `var<private>` slots become getter/setter properties
  * (so tests can inspect or seed RNG state etc.), and module-scope `const`s become read-only
- * getters. When the WGSL had a `@compute` entry, the dispatch trio (`entry_name`,
- * `workgroup_size`, `param_names`, `entry`, `create_workgroup_state`) is included.
+ * getters. `reset_private` is always included. When the WGSL had a `@compute` entry, the dispatch
+ * trio (`entry_name`, `workgroup_size`, `param_names`, `entry`, `create_workgroup_state`) is
+ * included too.
  */
 function emitModuleReturn(c) {
     c.out.add('const __module__ = {};');
@@ -592,6 +601,8 @@ function emitModuleReturn(c) {
         }
     }
 
+    c.out.add('__module__.reset_private = __reset_private__;');
+
     if (c.entry !== null) {
         c.out.add(`__module__.entry_name = ${JSON.stringify(c.entry.name)};`);
         c.out.add(`__module__.stage = ${JSON.stringify(c.entry.stage)};`);
@@ -900,6 +911,7 @@ function collectGlobalVariable(c, node) {
         name,
         kind: 'let',
         code: `let ${name} = ${init_code};`,
+        init: init_code,
     });
 }
 
@@ -938,6 +950,7 @@ function collectGlobalValue(c, node) {
         name,
         kind: 'const',
         code: `const ${name} = ${expr.code};`,
+        init: expr.code,
     });
 }
 
@@ -945,6 +958,32 @@ function collectGlobalValue(c, node) {
 // Workgroup state factory + entry wrapper
 // =========================================================================
 
+/**
+ * Emit `__reset_private__()`, which restores every module-scope `var<private>` to the value it
+ * would have at the start of a WGSL invocation — its declared initializer, or the type's zero
+ * value when it was declared without one.
+ *
+ * This is the private-address-space counterpart of {@link emitWorkgroupStateFactory}. The
+ * generated module keeps its private slots in `let` bindings that live as long as the module, so
+ * without this a second dispatch would start from whatever the first one left behind — state the
+ * GPU never carries.
+ *
+ * Module-scope `const`s are skipped: they are immutable in the generated JS and no invocation can
+ * disturb them.
+ *
+ * @param {Compiler} c
+ */
+function emitPrivateStateReset(c) {
+    c.out.add('function __reset_private__() {');
+    c.out.indent();
+    for (const g of c.privateGlobals) {
+        if (g.kind !== 'let') continue;
+        c.out.add(`${g.name} = ${g.init};`);
+    }
+    c.out.dedent();
+    c.out.add('}');
+}
+
 function emitWorkgroupStateFactory(c) {
     c.out.add('function __create_workgroup_state__() {');
     c.out.indent();

package/src/view/minimap/dom/MinimapCameraView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MinimapCameraView.d.ts","sourceRoot":"","sources":["../../../../../src/view/minimap/dom/MinimapCameraView.js"],"names":[],"mappings":"AAYA;IACI;;;;;;;;OAQG;IACH,yFAwFC;IArFG,YAAkC;IAIlC;;;;OAIG;IACH,qBAAgD;IAIhD;;;OAGG;IACH,eAAoB;IAEpB;;;;;;;;;;;OAWG;IACH,UAFU,+BAA6B,CAEf;IACxB;;;OAGG;IACH,qBAA0B;IAE1B,eAAoB;IAEpB;;;;OAIG;IACH,gBAAoB;IAEpB;;;;OAIG;IACH,sBAA+B;IAE/B;;;OAGG;IACH,aAAsC;IA6B1C;;;;;;;;;OASG;IACH,uBARW,OAAO,WACP,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,QAsChB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA+BnB;IAED,iBAQC;CAgBJ;iBA7NgB,eAAe;oBACZ,+BAA+B"}
+{"version":3,"file":"MinimapCameraView.d.ts","sourceRoot":"","sources":["../../../../../src/view/minimap/dom/MinimapCameraView.js"],"names":[],"mappings":"AAWA;IACI;;;;;;;;OAQG;IACH,yFAoFC;IAjFG,YAAkC;IAIlC;;;;OAIG;IACH,qBAAgD;IAIhD;;;OAGG;IACH,eAAoB;IAEpB;;;;;;;;;;;OAWG;IACH,UAFU,+BAA6B,CAEf;IACxB;;;OAGG;IACH,qBAA0B;IAE1B,eAAoB;IAEpB;;;;OAIG;IACH,gBAAoB;IAEpB;;;;OAIG;IACH,sBAA+B;IAE/B;;;OAGG;IACH,aAAsC;IAyB1C;;;;;;;;;OASG;IACH,uBARW,OAAO,WACP,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,QAsChB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA+BnB;IAED,iBAQC;CAgBJ;iBAxNgB,eAAe;oBACZ,+BAA+B"}

package/src/view/minimap/dom/MinimapCameraView.js

@@ -4,8 +4,7 @@ import ObservedValue from "../../../core/model/ObservedValue.js";
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import SVG from "../../SVG.js";
 import { plane3_compute_ray_intersection } from "../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
-import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
-import { EventType } from "../../../engine/ecs/EventType.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../../../engine/ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 
 
 const rayContact = new SurfacePoint3();
@@ -93,18 +92,14 @@ export class MinimapCameraView extends View {
         // none, so it arrives from the dataset instead - one listener for the whole transform,
         // which is coarser and exactly as useful here: the view redraws from the pose either way.
         if (dataset !== null) {
-            const on_transform_changed = event => {
-                if (event.klass === Transform64) {
-                    this.__update();
-                }
-            };
+            const on_transform_changed = () => this.__update();
 
             this.on.linked.add(() => dataset.addEntityEventListener(
-                entity, EventType.ComponentChanged, on_transform_changed
+                entity, TRANSFORM64_EVENT_CHANGE, on_transform_changed
             ));
 
             this.on.unlinked.add(() => dataset.removeEntityEventListener(
-                entity, EventType.ComponentChanged, on_transform_changed
+                entity, TRANSFORM64_EVENT_CHANGE, on_transform_changed
             ));
         }
 

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

@@ -1,15 +0,0 @@
-export class BoxLayoutSpec {
-    bounds: AABB2;
-    /**
-     *
-     * @type {ConnectionLayoutSpec[]}
-     */
-    connections: ConnectionLayoutSpec[];
-    /**
-     *
-     * @type {boolean}
-     */
-    locked: boolean;
-}
-import AABB2 from "../../../../geom/2d/aabb/AABB2.js";
-//# sourceMappingURL=BoxLayoutSpec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"BoxLayoutSpec.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/BoxLayoutSpec.js"],"names":[],"mappings":"AAGA;IACI,cAAqB;IAErB;;;OAGG;IACH,aAFU,sBAAsB,CAEf;IAEjB;;;OAGG;IACH,QAFU,OAAO,CAEF;CAElB;kBAlBiB,mCAAmC"}

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

@@ -1,45 +0,0 @@
-export class ConnectedBoxLayouter {
-    /**
-     *
-     * @type {BoxLayoutSpec[]}
-     */
-    boxes: BoxLayoutSpec[];
-    /**
-     *
-     * @type {ConnectionLayoutSpec[]}
-     */
-    connections: ConnectionLayoutSpec[];
-    /**
-     *
-     * @type {QuadTreeNode<>}
-     * @private
-     */
-    private __spatial_index_connections;
-    /**
-     * @param {BoxLayoutSpec[]} boxes
-     * @param {ConnectionLayoutSpec[]} connections
-     */
-    initialize(boxes: BoxLayoutSpec[], connections: ConnectionLayoutSpec[]): void;
-    __resolve_box_overlap(max_steps?: number): void;
-    /**
-     *
-     * @param {BoxLayoutSpec} box
-     * @returns {number}
-     * @private
-     */
-    private __compute_box_cost;
-    __execute_swaps(): number;
-    /**
-     *
-     * @param {ConnectionLayoutSpec} spec
-     * @param {number} strength
-     * @private
-     */
-    private __pull_connection;
-    __pull_connections(strength: any): void;
-    __execute_many_swaps(limit: any): void;
-    __execute_initial_placement(): void;
-    step(): void;
-    layout(): void;
-}
-//# sourceMappingURL=ConnectedBoxLayouter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ConnectedBoxLayouter.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/ConnectedBoxLayouter.js"],"names":[],"mappings":"AAMA;IAGI;;;OAGG;IACH,OAFU,eAAe,CAEd;IACX;;;OAGG;IACH,aAFU,sBAAsB,CAEf;IAGjB;;;;OAIG;IACH,oCAAiD;IAGjD;;;OAGG;IACH,kBAHW,eAAe,eACf,sBAAsB,QAahC;IAED,gDAYC;IAED;;;;;OAKG;IACH,2BA6BC;IAED,0BAkDC;IAED;;;;;OAKG;IACH,0BAqBC;IAED,wCAQC;IAED,uCAQC;IAED,oCAkBC;IAED,aAOC;IAED,eAYC;CACJ"}

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

@@ -1,24 +0,0 @@
-export class ConnectionEndpointLayoutSpec {
-    /**
-     * @param {AABB2} box
-     * @param {Vector2} point
-     * @returns {ConnectionEndpointLayoutSpec}
-     */
-    static from(box: AABB2, point: Vector2): ConnectionEndpointLayoutSpec;
-    /**
-     *
-     * @type {BoxLayoutSpec}
-     */
-    box: BoxLayoutSpec;
-    /**
-     * Local offset inside the box where connection is attached
-     * @type {Vector2}
-     */
-    point: Vector2;
-    /**
-     *
-     * @param {Vector2} result
-     */
-    computePosition(result: Vector2): void;
-}
-//# sourceMappingURL=ConnectionEndpointLayoutSpec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ConnectionEndpointLayoutSpec.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/ConnectionEndpointLayoutSpec.js"],"names":[],"mappings":"AAAA;IA0BI;;;;OAIG;IACH,yCAFa,4BAA4B,CASxC;IApCD;;;OAGG;IACH,mBAAW;IAEX;;;OAGG;IACH,eAAa;IAGb;;;OAGG;IACH,uCAKC;CAeJ"}

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

@@ -1,19 +0,0 @@
-export class ConnectionLayoutSpec {
-    /**
-     * @param {ConnectionEndpointLayoutSpec} source
-     * @param {ConnectionEndpointLayoutSpec} target
-     * @returns {ConnectionLayoutSpec}
-     */
-    static from(source: ConnectionEndpointLayoutSpec, target: ConnectionEndpointLayoutSpec): ConnectionLayoutSpec;
-    /**
-     *
-     * @type {ConnectionEndpointLayoutSpec}
-     */
-    source: ConnectionEndpointLayoutSpec;
-    /**
-     *
-     * @type {ConnectionEndpointLayoutSpec}
-     */
-    target: ConnectionEndpointLayoutSpec;
-}
-//# sourceMappingURL=ConnectionLayoutSpec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ConnectionLayoutSpec.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/ConnectionLayoutSpec.js"],"names":[],"mappings":"AAAA;IAcI;;;;OAIG;IACH,yFAFa,oBAAoB,CAShC;IAxBD;;;OAGG;IACH,qCAAc;IACd;;;OAGG;IACH,qCAAc;CAgBjB"}

package/src/engine/ecs/transform/__probe.d.ts

@@ -1,4 +0,0 @@
-/** @param {Transform64} t */
-export function probe(t: Transform64): any[];
-import { Transform64 } from "./Transform64.js";
-//# sourceMappingURL=__probe.d.ts.map

package/src/engine/ecs/transform/__probe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"__probe.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/__probe.js"],"names":[],"mappings":"AAEA,6BAA6B;AAC7B,yBADY,WAAW,SAMtB;4BAP2B,kBAAkB"}

package/src/engine/ecs/util/hideEntityGracefully.d.ts

@@ -1,9 +0,0 @@
-/**
- *
- * @param {Entity} builder
- * @param {function():Entity} createEntity
- * @param {*} [createEntityThisArg]
- * @return {number} duration in seconds until the entity is completely hidden
- */
-export function hideEntityGracefully(builder: Entity, createEntity: () => Entity, createEntityThisArg?: any): number;
-//# sourceMappingURL=hideEntityGracefully.d.ts.map

package/src/engine/ecs/util/hideEntityGracefully.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hideEntityGracefully.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/util/hideEntityGracefully.js"],"names":[],"mappings":"AA2JA;;;;;;GAMG;AACH,8GAFY,MAAM,CAmCjB"}

package/src/shade/renderer/buffer/table/gpu_database_emulator_image.d.ts

@@ -1,27 +0,0 @@
-/**
- * Build the `array<u32>` image of a {@link GPUDatabase} — the exact bytes the generated marshalling
- * functions ({@link GPUTypedTableDescriptor#chunk_read} and friends) index: the page address table,
- * then pages at the addresses it names, each page's records past its
- * `[u32 live_count][u32 occupancy_bitmap...]` header.
- *
- * This exists for the WGSL emulator. The production route to those bytes is a compute dispatch
- * ({@link ./gpu_table_element_upload_shader.js}) against a live device, and the software device
- * records dispatches without running them — so a spec that wants to run a database-reading shader
- * on the CPU has no way to obtain a filled buffer. Everything here is derived from the descriptor's
- * own published geometry (`page_lookup_address`, `elements_per_page`, `page_header_words`,
- * `packed_element_size_bytes`), which is the same geometry the upload shader receives as its
- * settings, so the two cannot drift apart silently.
- *
- * Pages are allocated in ascending (table index, page index) order — the addresses therefore differ
- * from what a live database's slot allocator would hand out for the same writes. Nothing reads a
- * page address except through the table, so the layout is equivalent, not identical.
- *
- * @param {GPUDatabaseDefinition} definition
- * @param {Object<string, Iterable<[number, *]>>} contents records per table name, as
- *        `[element_index, value]` pairs (a `Map`, or an array of pairs)
- * @returns {Uint32Array}
- */
-export function gpu_database_emulator_image(definition: GPUDatabaseDefinition, contents: {
-    [x: string]: Iterable<[number, any]>;
-}): Uint32Array;
-//# sourceMappingURL=gpu_database_emulator_image.d.ts.map

package/src/shade/renderer/buffer/table/gpu_database_emulator_image.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gpu_database_emulator_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/gpu_database_emulator_image.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;QAJkB,MAAM,GAAE,SAAS,CAAC,MAAM,MAAI,CAAC;IAElC,WAAW,CAwFvB"}

package/src/shade/renderer/particles/cull/chunk_particle_cull.d.ts

@@ -1,14 +0,0 @@
-/**
- * Frustum culling math for emitter simulation culling (the optional, flagged "sleep when culled"
- * feature). A bounding sphere is visible unless it lies fully outside any frustum plane. Planes
- * follow the engine's Gribb-Hartmann convention (world space, `dot(n, p) + d >= 0` inside).
- *
- * The occlusion half of the test reuses the engine's HiZ query
- * (`src/webgpu/renderer/shader/chunk/depth/chunk_query_depth_from_screen_space_bb.js`) in the cull pass;
- * this chunk holds the emulator-testable frustum math.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_cull: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_particle_cull.d.ts.map

package/src/shade/renderer/particles/cull/chunk_particle_cull.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_particle_cull.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/cull/chunk_particle_cull.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,kCAFU,SAAS,CA0BhB;0BArCuB,oCAAoC"}