@woosh/meep-engine 3.41.0 → 3.43.0

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

@@ -302,6 +302,8 @@ function classifyType(ident, args, template_list_node) {
         // template arg 0 is the element type (sub-template), arg 1 is the count
         let element = T_UNKNOWN;
         let count = -1;
+        // a count named by a module constant is read from that constant when a value is made
+        let count_name = null;
         if (template_list_node !== null) {
             const comma_list = namedChildByType(template_list_node, 'template_arg_comma_list');
             if (comma_list !== null) {
@@ -312,12 +314,14 @@ function classifyType(ident, args, template_list_node) {
                     element = parseTypeSpecifier(inner_expr);
                 }
                 if (arg_nodes.length > 1) {
-                    const c = parseInt(arg_nodes[1].text.trim());
+                    const text = arg_nodes[1].text.trim();
+                    const c = parseInt(text);
                     if (!isNaN(c)) count = c;
+                    else if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(text)) count_name = text;
                 }
             }
         }
-        return { kind: 'array', element, count };
+        return count_name === null ? { kind: 'array', element, count } : { kind: 'array', element, count, count_name };
     }
     if (ident === 'atomic') {
         const inner = args.length > 0 ? args[0] : 'i32';
@@ -843,14 +847,16 @@ function defaultValueForType(type) {
         case 'mat':
             return `new Float32Array(${type.cols * type.rows})`;
         case 'array': {
-            if (type.count > 0) {
+            const length = type.count > 0 ? String(type.count)
+                : type.count_name !== undefined ? `Number(${identToJs(type.count_name)})` : null;
+            if (length !== null) {
                 if (type.element.kind === 'primitive') {
                     const ctor = arrayCtorForScalar(type.element.name);
-                    return `new ${ctor}(${type.count})`;
+                    return `new ${ctor}(${length})`;
                 }
                 // For non-primitive elements (vec / mat / struct / nested array) build the
                 // array eagerly so `out[i]` is a fresh, mutable element rather than `undefined`.
-                return `Array.from({ length: ${type.count} }, () => ${defaultValueForType(type.element)})`;
+                return `Array.from({ length: ${length} }, () => ${defaultValueForType(type.element)})`;
             }
             return '[]';
         }
@@ -1485,7 +1491,8 @@ function emitVariableUpdatingStatement(c, node) {
             || isScalarUnsigned(lhs_compiled.type)
             || isScalarUnsigned(rhs_compiled.type)
         )) {
-            c.out.add(emitWriteStatement(lhs_compiled, `wgsl.${bitwise_helper}(${lhs_compiled.code}, ${rhs_compiled.code})`));
+            c.out.add(emitWriteStatement(lhs_compiled,
+                `wgsl.${shiftHelperFor(bitwise_helper, lhs_compiled.type)}(${lhs_compiled.code}, ${rhs_compiled.code})`));
             return;
         }
         c.out.add(`${lhs_compiled.code} ${op_text} ${rhs_compiled.code};`);
@@ -2149,14 +2156,15 @@ function compileBinaryExpression(c, node, op_type, mode) {
     // bit set was negative too. The helpers normalise with `>>> 0`, which is what WGSL u32 means.
     //
     // Deliberately not extended to i32: `bit_and` and friends return an unsigned result, and a
-    // signed operand is exactly the case raw JS already gets right.
+    // signed operand is exactly the case raw JS already gets right. A shift is the exception: WGSL
+    // makes its amount a u32 whatever it shifts, so an i32 shift lands here and takes the signed helper.
     const bitwise_helper = BITWISE_HELPER[op_text];
     if (bitwise_helper !== undefined) {
         if (isContainerType(left.type) || isContainerType(right.type)
             || isScalarBool(left.type) || isScalarBool(right.type)
             || isScalarUnsigned(left.type) || isScalarUnsigned(right.type)) {
             return {
-                code: `wgsl.${bitwise_helper}(${left.code}, ${right.code})`,
+                code: `wgsl.${shiftHelperFor(bitwise_helper, left.type)}(${left.code}, ${right.code})`,
                 type: inferRawBinaryResultType(left.type, right.type, op_text),
             };
         }
@@ -2187,6 +2195,12 @@ const BITWISE_HELPER = {
     '>>': 'shr',
 };
 
+/** The helper for a bitwise operator on a value of type `t`: a shift of an i32 (scalar or vector) keeps its sign. */
+function shiftHelperFor(helper, t) {
+    if ((helper === 'shl' || helper === 'shr') && isIntegerType(t) && integerScalarName(t) === 'i32') { return `${helper}_i32`; }
+    return helper;
+}
+
 /** Map WGSL comparison operators to language-core element-wise helper names. */
 const COMPARISON_HELPER = {
     '==': 'eq',
@@ -2727,7 +2741,13 @@ function compileCallPhraseTyped(c, node) {
 
     // 6) array / array<T, N> constructor.
     if (callee_name === 'array') {
-        return { code: `[${stored_args.join(', ')}]`, type: T_UNKNOWN };
+        // The element type is what makes a member or swizzle on an element read compile; without
+        // a template, it is the first argument's, as WGSL infers it.
+        let type = parseTypeSpecifier(ident_node);
+        if ((type.kind !== 'array' || type.element === T_UNKNOWN) && arg_results.length > 0 && !isAbstractType(arg_results[0].type)) {
+            type = { kind: 'array', element: arg_results[0].type, count: arg_results.length };
+        }
+        return { code: `[${stored_args.join(', ')}]`, type };
     }
 
     // 7) Struct constructor.

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

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IA8+CA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAy/CA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}

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

@@ -586,6 +586,9 @@ export const WGSLLanguageCore = {
     bit_xor: (a, b) => binop(a, b, (x, y) => typeof x === 'boolean' ? x !== y : (x ^ y) >>> 0),
     shl:     (a, b) => binop(a, b, (x, y) => (x << y) >>> 0),
     shr:     (a, b) => binop(a, b, (x, y) => x >>> y),
+    // The same on an i32, whose shift amount WGSL still makes a u32: `>>` sign-extends, and both stay signed.
+    shl_i32: (a, b) => binop(a, b, (x, y) => (x << y) | 0),
+    shr_i32: (a, b) => binop(a, b, (x, y) => x >> y),
 
     neg: (a) => unop(a, x => -x),
     not: (a) => unop(a, x => (~x) >>> 0),
@@ -1265,17 +1268,25 @@ export const WGSLLanguageCore = {
      * silently dropped (WGSL semantics). `coords` length matches the
      * texture dimensionality.
      *
+     * Four arguments is the `texture_storage_2d_array` form — `(t, coords, array_index, value)` —
+     * where the third argument selects the slice, stored along z as the sampling side reads it.
+     *
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
      * @param {Int32Array | Uint32Array | number[] | number} coords
-     * @param {Float32Array | Int32Array | Uint32Array | number[]} value
+     * @param {Float32Array | Int32Array | Uint32Array | number[] | number} value_or_index
+     * @param {Float32Array | Int32Array | Uint32Array | number[]} [array_value]
      */
-    textureStore(t, coords, value) {
+    textureStore(t, coords, value_or_index, array_value = undefined) {
         assert.defined(t, 'texture');
+        if (array_value !== undefined) {
+            t.write(coords[0] | 0, coords[1] | 0, value_or_index | 0, array_value);
+            return;
+        }
         const dim = t.dimensionality;
         const x = (dim >= 1 ? (typeof coords === 'number' ? coords : coords[0]) : 0) | 0;
         const y = (dim >= 2 ? coords[1] : 0) | 0;
         const z = (dim >= 3 ? coords[2] : 0) | 0;
-        t.write(x, y, z, value);
+        t.write(x, y, z, value_or_index);
     },
 
     // CPUBitmapData models one stored mip level.

package/src/core/geom/2d/polygon/polygon2_triangulate.corpus.d.ts

@@ -1,28 +0,0 @@
-/**
- * Inputs that have actually broken {@link polygon2_triangulate}, kept so they can
- * never break it again.
- *
- * This file only ever grows, and only from real failures -- a case someone
- * *imagines* might be hard belongs in the ordinary spec, not here. Every entry
- * records what went wrong when it was added, because that is the part that stops
- * a future change from quietly reintroducing the same class of bug. The practice
- * is borrowed from manifold, whose triangulator carries ~3 MB of recorded failing
- * polygons replayed as tests.
- *
- * `expect_full` says whether the polygon is well-formed enough that the whole of
- * its area must be covered. `false` means the input is genuinely invalid
- * (self-intersecting) and the only requirements are the universal ones: no throw,
- * no hang, no out-of-range index.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export const POLYGON2_TRIANGULATE_CORPUS: {
-    name: string;
-    why: string;
-    points: number[];
-    contour_ends: number[];
-    contour_count: number;
-    expect_full: boolean;
-}[];
-//# sourceMappingURL=polygon2_triangulate.corpus.d.ts.map

package/src/core/geom/2d/polygon/polygon2_triangulate.corpus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polygon2_triangulate.corpus.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/polygon/polygon2_triangulate.corpus.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;;;;;;IAkEE"}

package/src/core/geom/2d/polygon/polygon2_triangulate.corpus.js

@@ -1,86 +0,0 @@
-/**
- * Inputs that have actually broken {@link polygon2_triangulate}, kept so they can
- * never break it again.
- *
- * This file only ever grows, and only from real failures -- a case someone
- * *imagines* might be hard belongs in the ordinary spec, not here. Every entry
- * records what went wrong when it was added, because that is the part that stops
- * a future change from quietly reintroducing the same class of bug. The practice
- * is borrowed from manifold, whose triangulator carries ~3 MB of recorded failing
- * polygons replayed as tests.
- *
- * `expect_full` says whether the polygon is well-formed enough that the whole of
- * its area must be covered. `false` means the input is genuinely invalid
- * (self-intersecting) and the only requirements are the universal ones: no throw,
- * no hang, no out-of-range index.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export const POLYGON2_TRIANGULATE_CORPUS = [
-    {
-        name: "unit-offset micro square",
-        why: "Winding was decided by the shoelace sum, whose sign here is pure "
-            + "rounding noise: the true area is 1e-18 against ~1e-16 per-term error. "
-            + "The ring came out backwards, every corner looked reflex, and the "
-            + "result was zero triangles. Fixed by deciding winding with one exact "
-            + "orientation predicate at a hull vertex (polygon2_is_counter_clockwise).",
-        points: [
-            1, 1,
-            1 + 1e-9, 1,
-            1 + 1e-9, 1 + 1e-9,
-            1, 1 + 1e-9,
-        ],
-        contour_ends: [4],
-        contour_count: 1,
-        expect_full: true,
-    },
-    {
-        name: "coarse-grid point soup (fuzz seed 24)",
-        why: "Twenty points on a 7x7 integer grid, with duplicates and collinear "
-            + "runs. The ear search exhausted itself, fell through to the "
-            + "cure-local-intersections pass, and that pass walked the "
-            + "collapsed-ring sentinel as if it were a node -- an infinite loop. "
-            + "Fixed by making the recovery pass accept and propagate the sentinel, "
-            + "and by stopping it once the ring holds fewer than three nodes.",
-        points: [
-            2, 3, 3, 6, 1, 5, 0, 4, 5, 0,
-            4, 2, 3, 3, 3, 6, 2, 3, 6, 1,
-            4, 4, 2, 6, 3, 2, 6, 4, 1, 1,
-            3, 0, 5, 0, 3, 2, 6, 4, 3, 3,
-        ],
-        contour_ends: [20],
-        contour_count: 1,
-        expect_full: false,
-    },
-    {
-        name: "two rectangular holes bridged through a shared edge",
-        why: "Produced 12 triangles where the Euler bound allows 14, which looked "
-            + "like dropped geometry. It was not: the bridges left collinear corners "
-            + "that were correctly absorbed rather than emitted as zero-area "
-            + "triangles. Kept as the standing reminder that V + 2H - 2 is an upper "
-            + "bound, not an equality -- area conservation is the real invariant.",
-        points: [
-            0, 0, 20, 0, 20, 10, 0, 10,
-            2, 8, 6, 8, 6, 2, 2, 2,
-            12, 8, 18, 8, 18, 2, 12, 2,
-        ],
-        contour_ends: [4, 8, 12],
-        contour_count: 3,
-        expect_full: true,
-    },
-    {
-        name: "hole touching the outer boundary at a vertex",
-        why: "Same class as above -- 6 triangles against a bound of 7. The hole's "
-            + "corner lands exactly on the outer edge, so the bridge is degenerate "
-            + "and one corner becomes collinear. Area is still exact and every input "
-            + "vertex is still used.",
-        points: [
-            0, 0, 10, 0, 10, 10, 0, 10,
-            4, 7, 4, 3, 0, 5,
-        ],
-        contour_ends: [4, 7],
-        contour_count: 2,
-        expect_full: true,
-    },
-];

package/src/engine/ecs/storage/binary/object-v2/serializerTestHarness.d.ts

@@ -1,29 +0,0 @@
-/**
- * Serialize `value` with a serializer built on `registry`, then deserialize it with a deserializer built on
- * `registry` + `modules`. Shared by the object-graph specs.
- *
- * @template T
- * @param {T} value
- * @param {{registry?: BinarySerializationRegistry, modules?: ModuleRegistry}} [options]
- * @returns {T}
- */
-export function roundTrip<T>(value: T, { registry, modules }?: {
-    registry?: BinarySerializationRegistry;
-    modules?: ModuleRegistry<any>;
-}): T;
-/**
- * @param {*} value
- * @param {BinarySerializationRegistry} [registry]
- * @returns {BinaryBuffer} rewound to position 0
- */
-export function serialize(value: any, registry?: BinarySerializationRegistry): BinaryBuffer;
-/**
- * @param {*} value
- * @param {BinarySerializationRegistry} [registry]
- * @returns {number} byte length of the serialized form
- */
-export function serializedSize(value: any, registry?: BinarySerializationRegistry): number;
-import { BinarySerializationRegistry } from "../BinarySerializationRegistry.js";
-import { ModuleRegistry } from "../../../../../core/model/ModuleRegistry.js";
-import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
-//# sourceMappingURL=serializerTestHarness.d.ts.map

package/src/engine/ecs/storage/binary/object-v2/serializerTestHarness.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializerTestHarness.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/storage/binary/object-v2/serializerTestHarness.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,+DAHW;IAAC,QAAQ,CAAC,EAAE,2BAA2B,CAAC;IAAC,OAAO,CAAC,sBAAgB;CAAC,KAS5E;AAED;;;;GAIG;AACH,iDAHW,2BAA2B,GACzB,YAAY,CAQxB;AAED;;;;GAIG;AACH,sDAHW,2BAA2B,GACzB,MAAM,CAIlB;4CAzC2C,mCAAmC;+BADhD,6CAA6C;6BAD/C,4CAA4C"}

package/src/engine/ecs/storage/binary/object-v2/serializerTestHarness.js

@@ -1,44 +0,0 @@
-import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
-import { ModuleRegistry } from "../../../../../core/model/ModuleRegistry.js";
-import { BinarySerializationRegistry } from "../BinarySerializationRegistry.js";
-import { BinaryObjectDeSerializer } from "./BinaryObjectDeSerializer.js";
-import { BinaryObjectSerializer } from "./BinaryObjectSerializer.js";
-
-/**
- * Serialize `value` with a serializer built on `registry`, then deserialize it with a deserializer built on
- * `registry` + `modules`. Shared by the object-graph specs.
- *
- * @template T
- * @param {T} value
- * @param {{registry?: BinarySerializationRegistry, modules?: ModuleRegistry}} [options]
- * @returns {T}
- */
-export function roundTrip(value, { registry = new BinarySerializationRegistry(), modules = new ModuleRegistry() } = {}) {
-    const buffer = serialize(value, registry);
-
-    buffer.position = 0;
-
-    return new BinaryObjectDeSerializer(registry, modules).deserialize(buffer);
-}
-
-/**
- * @param {*} value
- * @param {BinarySerializationRegistry} [registry]
- * @returns {BinaryBuffer} rewound to position 0
- */
-export function serialize(value, registry = new BinarySerializationRegistry()) {
-    const buffer = new BinaryBuffer();
-
-    new BinaryObjectSerializer(registry).serialize(buffer, value);
-
-    return buffer;
-}
-
-/**
- * @param {*} value
- * @param {BinarySerializationRegistry} [registry]
- * @returns {number} byte length of the serialized form
- */
-export function serializedSize(value, registry = new BinarySerializationRegistry()) {
-    return serialize(value, registry).position;
-}

package/src/shade/renderer/water/medium/shader_water_bodies_derive.d.ts

@@ -1,4 +0,0 @@
-export const WORKGROUP_SIZE: 64;
-export const shader_water_bodies_derive: ComputeShader;
-import { ComputeShader } from "../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_water_bodies_derive.d.ts.map

package/src/shade/renderer/water/medium/shader_water_bodies_derive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_water_bodies_derive.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/shader_water_bodies_derive.js"],"names":[],"mappings":"AASA,gCAAiC;AAIjC,uDAkBG;8BA/B2B,+BAA+B"}

package/src/shade/renderer/water/medium/shader_water_bodies_derive.js

@@ -1,32 +0,0 @@
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { chunk_water_medium_derived } from "./chunk_water_medium_derived.js";
-import { chunk_water_medium_scattering } from "./chunk_water_medium_scattering.js";
-import { WATER_BODIES_TABLE as table } from "./chunk_water_bodies.js";
-import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
-
-export const WORKGROUP_SIZE = 64;
-const pg = table.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup().addStorageBuffer('scene_database', WebGPUArray.u32, true);
-export const shader_water_bodies_derive = ComputeShader.from({
-    label: "Water / bodies derive", resources,
-    body: CodeChunk.from(/* language=WGSL */ `
-@compute @workgroup_size(${WORKGROUP_SIZE})
-fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
-    if (!${pg}_setup(&scene_database, folded_workgroup_index(group), lane)) { return; }
-    let slot = ${pg}_slot_in_page(lane);
-    if (slot >= ${pg}_ELEMENTS_PER_PAGE || !${pg}_is_occupied(slot)) { return; }
-    var body = ${pg}_read(&scene_database, slot);
-    if (body.dirty == 0u) { return; }
-    body.backscattering = vec4f(water_medium_backscattering(body.medium), 0.0);
-    body.extinction = vec4f(body.medium.absorption + water_medium_scattering(body.medium), 0.0);
-    body.diffuse_transmittance = water_diffuse_fresnel_transmittance(body.ior);
-    body.dirty = 0u;
-    ${table.marshalling_method_write}(&scene_database, ${pg}_slot_to_index(slot), body);
-}
-`, [table.chunk_iterate(WORKGROUP_SIZE, true), table.chunk_write, chunk_water_medium_derived,
-        chunk_water_medium_scattering, chunk_folded_workgroup_index]),
-});

package/src/shade/renderer/water/surface/GPUWaterWaveSimulation.d.ts

@@ -1,25 +0,0 @@
-/**
- * A shared wave atlas, indexed by occupied water_waves rows. Calm bodies allocate no grid.
- * Each fixed step dispatches the whole atlas once; tessellated vertices sample it in local xz.
- * The regular grid is a displacement field, never the rendered water footprint.
- */
-export class GPUWaterWaveSimulation {
-    onInputsConsumed: Signal;
-    resolution: number;
-    step: number;
-    max_steps_per_frame: number;
-    damping: number;
-    get time(): number;
-    get buffer(): any;
-    get grid_resolution(): number;
-    advance(dt: any): void;
-    dispose(): void;
-    record({ graph, device, scene }: {
-        graph: any;
-        device: any;
-        scene: any;
-    }): void;
-    #private;
-}
-import Signal from "../../../../core/events/signal/Signal.js";
-//# sourceMappingURL=GPUWaterWaveSimulation.d.ts.map

package/src/shade/renderer/water/surface/GPUWaterWaveSimulation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GPUWaterWaveSimulation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/GPUWaterWaveSimulation.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IACI,yBAAgC;IAChC,mBAAiB;IACjB,aAAe;IACf,4BAAwB;IACxB,gBAAe;IAYf,mBAAiC;IACjC,kBAAkD;IAClD,8BAAqE;IAErE,uBAIC;IAED,gBAMC;IAED;;;;aAiFC;;CACJ;mBA/HkB,0CAA0C"}

package/src/shade/renderer/water/surface/GPUWaterWaveSimulation.js

@@ -1,128 +0,0 @@
-import Signal from "../../../../core/events/signal/Signal.js";
-import { assert } from "../../../../core/assert.js";
-import { WATER_WAVE_BATCH_STRUCT, shader_water_wave_batch, shader_water_wave_batch_finish } from "./shader_water_wave_batch.js";
-import { shader_water_wave_bounds, shader_water_wave_domain } from "./shader_water_wave_domain.js";
-
-/**
- * A shared wave atlas, indexed by occupied water_waves rows. Calm bodies allocate no grid.
- * Each fixed step dispatches the whole atlas once; tessellated vertices sample it in local xz.
- * The regular grid is a displacement field, never the rendered water footprint.
- */
-export class GPUWaterWaveSimulation {
-    onInputsConsumed = new Signal();
-    resolution = 128;
-    step = 1 / 120;
-    max_steps_per_frame = 8;
-    damping = 0.08;
-    #device = null;
-    #scene = null;
-    #state = [];
-    #domain = null;
-    #capacity = 0;
-    #resolution = 0;
-    #parity = 0;
-    #pending = 0;
-    #time = 0;
-    #recorded = new WeakSet();
-    #write_pending = true;
-    get time() { return this.#time; }
-    get buffer() { return this.#state[this.#parity]; }
-    get grid_resolution() { return this.#resolution || this.resolution; }
-
-    advance(dt) {
-        assert.isFinite(dt, 'dt'); assert.greaterThanOrEqual(dt, 0, 'dt');
-        this.#pending += dt;
-        this.#write_pending = true;
-    }
-
-    dispose() {
-        for (const buffer of this.#state) { buffer.destroy(); }
-        this.#domain?.destroy(); this.#domain = null;
-        this.#state = []; this.#capacity = 0; this.#device = null; this.#scene = null;
-        this.#recorded = new WeakSet();
-        this.#write_pending = true;
-    }
-
-    record({ graph, device, scene }) {
-        if (this.#recorded.has(graph)) { return; }
-        if (device !== this.#device || scene !== this.#scene) {
-            this.dispose(); this.#device = device; this.#scene = scene;
-        }
-        this.#recorded.add(graph);
-        if (!this.#write_pending) { return; }
-        this.#write_pending = false;
-        const table = scene.scene_database.get('water_waves');
-        const capacity = table.count === 0 ? 0 : table.element_capacity;
-        assert.isInteger(this.resolution, 'resolution'); assert.greaterThanOrEqual(this.resolution, 2, 'resolution');
-        assert.greaterThan(this.step, 0, 'step');
-        const resize = capacity > this.#capacity || (capacity === 0 && this.#capacity !== 0) || this.resolution !== this.#resolution;
-        const old = this.#state;
-        const old_domain = this.#domain;
-        if (resize || old.length === 0) {
-            const size = Math.max(4, capacity * this.resolution ** 2 * 4);
-            assert.lessThanOrEqual(size, device.limits.maxStorageBufferBindingSize, 'Water wave atlas exceeds device storage limit; lower waves.resolution');
-            this.#state = [0, 1].map(i => device.createBuffer({ label: `Water / wave state ${i}`, size,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST }));
-            this.#domain = device.createBuffer({ label: 'Water / authored footprint', size,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST });
-            this.#capacity = capacity;
-        }
-        const same_resolution = this.#resolution === this.resolution;
-        this.#resolution = this.resolution;
-        const steps = Math.min(Math.floor(this.#pending / this.step + 1e-6), this.max_steps_per_frame);
-        this.#pending = Math.max(0, Math.min(this.#pending - steps * this.step, this.step));
-        const start = this.#parity, time = this.#time, state = this.#state, domain = this.#domain;
-        this.#parity = (start + steps) % 2;
-        this.#time += steps * this.step;
-        const n = this.#resolution, dt = this.step, damping = this.damping;
-        const pass = graph.add('Water / batched surface update', {}, (_d, _r, { encoder }) => {
-            if (state !== old) {
-                if (same_resolution && old.length !== 0) {
-                    for (let i = 0; i < 2; i++) { encoder.copyBufferToBuffer(old[i], 0, state[i], 0, Math.min(old[i].size, state[i].size)); }
-                    encoder.copyBufferToBuffer(old_domain, 0, domain, 0, Math.min(old_domain.size, domain.size));
-                }
-                encoder.done.then(() => { for (const buffer of old) { buffer.destroy(); } old_domain?.destroy(); });
-            }
-            if (capacity === 0) { return; }
-            const groups = Math.ceil(capacity * n * n / 128);
-            shader_water_wave_domain.dispatch({ encoder, bindings: {
-                batch: encoder.allocateTransientValueBuffer(WATER_WAVE_BATCH_STRUCT,
-                    { resolution: n, capacity, apply_impulses: same_resolution ? 0 : 1 }),
-                scene_database: scene.scene_database_buffer, domain,
-                geometries: scene.geometries.buffer_metadata,
-                blas_lookup: scene.geometries.blas.buffer_metadata, blas_data: scene.geometries.blas.buffer_data,
-                meshlet_metadata: scene.geometries.meshlets.buffer_metadata, meshlet_data: scene.geometries.meshlets.buffer_data,
-            }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
-            const dispatch = (parity, step_dt, step_time, apply_impulses) => {
-                shader_water_wave_batch.dispatch({ encoder, bindings: {
-                    batch: encoder.allocateTransientValueBuffer(WATER_WAVE_BATCH_STRUCT,
-                        { resolution: n, capacity, dt: step_dt, time: step_time, damping, apply_impulses }),
-                    scene_database: scene.scene_database_buffer, domain, state_current: state[parity], state_previous: state[1 - parity],
-                }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
-            };
-            // Clear both histories of new/reused slots before advancing, then release the reset flag.
-            dispatch(0, 0, time, 0); dispatch(1, 0, time, 0);
-            const finish = apply_impulses => {
-                const groups = table.dispatch_group_count(64);
-                shader_water_wave_batch_finish.dispatch({ encoder, bindings: { scene_database: scene.scene_database_buffer,
-                    batch: encoder.allocateTransientValueBuffer(WATER_WAVE_BATCH_STRUCT,
-                        { resolution: n, capacity, dt, time, damping, apply_impulses }) },
-                    group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
-            };
-            finish(0);
-            for (let i = 0; i < steps; i++) { dispatch((start + i) % 2, dt, time + i * dt, i === 0 ? 1 : 0); }
-            if (steps > 0) {
-                finish(1);
-                // Submit is the ownership boundary for staged CPU inputs. Use the encoder's
-                // existing synchronous signal so a later scene/update cannot be cleared by
-                // an old promise callback.
-                encoder.onFinished.addOne(() => this.onInputsConsumed.dispatch(scene));
-            }
-            shader_water_wave_bounds.dispatch({ encoder, bindings: {
-                batch: encoder.allocateTransientValueBuffer(WATER_WAVE_BATCH_STRUCT, { resolution: n, capacity }),
-                scene_database: scene.scene_database_buffer, state: state[(start + steps) % 2],
-            }, group_count_x: Math.min(capacity, 65535), group_count_y: Math.ceil(capacity / 65535) });
-        });
-        pass.make_side_effect();
-    }
-}

package/src/shade/renderer/water/surface/chunk_water_tessellation.d.ts

@@ -1,9 +0,0 @@
-export const WATER_TILE_CELLS: 16;
-export const WATER_TILE_VERTEX_COUNT: number;
-export const WATER_TILE_STRUCT: WebGPUStruct;
-export const WATER_TESSELLATION_STRUCT: WebGPUStruct;
-/** Clip in barycentric space: every generated point remains on the authored triangle. */
-export const chunk_water_tessellation: CodeChunk;
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_water_tessellation.d.ts.map

package/src/shade/renderer/water/surface/chunk_water_tessellation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_water_tessellation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_tessellation.js"],"names":[],"mappings":"AAKA,kCAAmC;AAEnC,6CAAkE;AAClE,6CAEuB;AACvB,qDAE+B;AAE/B,yFAAyF;AACzF,iDA+H8B;6BA9ID,mCAAmC;0BADtC,oCAAoC"}