@woosh/meep-engine 2.169.6 → 2.170.0

package/src/engine/physics/fluid/ecs/fluid.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid.worker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid.worker.js"],"names":[],"mappings":""}

package/src/engine/physics/fluid/ecs/fluid.worker.js

@@ -0,0 +1,12 @@
+import { SystemWorkerHost } from "../../../ecs/async/SystemWorkerHost.js";
+import { FluidWorkerCore } from "./FluidWorkerCore.js";
+
+/**
+ * Worker entry point for {@link WorkerFluidSystem}.
+ *
+ * A real module worker rather than a generated blob, so the solver it pulls in
+ * is the ordinary `FluidSimulator` — same source, same bundler treatment, same
+ * source maps — which is what makes bit-parity with the main-thread
+ * {@link FluidSystem} a property of the build rather than a coincidence.
+ */
+SystemWorkerHost.serve(new FluidWorkerCore());

package/src/engine/physics/fluid/ecs/fluid_build_world_to_grid.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Write the world-to-grid affine for a {@link FluidComponent} into `out`.
+ * Axis-aligned, uniform-scale, so the matrix is sparse:
+ *
+ *     [ 1/cs   0     0    -ox/cs ]
+ *     [ 0      1/cs  0    -oy/cs ]
+ *     [ 0      0     1/cs -oz/cs ]
+ *     [ 0      0     0     1     ]
+ *
+ * Stored column-major (matches the convention of {@link v3_matrix4_multiply}).
+ *
+ * Shared by {@link FluidSystem} and {@link WorkerFluidSystem}: both hand this
+ * matrix to effectors, and an effector must see the same world-space mapping
+ * regardless of which system is driving it.
+ *
+ * @param {Float32Array} out  length-16
+ * @param {FluidComponent} component
+ */
+export function fluid_build_world_to_grid(out: Float32Array, component: FluidComponent): void;
+//# sourceMappingURL=fluid_build_world_to_grid.d.ts.map

package/src/engine/physics/fluid/ecs/fluid_build_world_to_grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_build_world_to_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_build_world_to_grid.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAHW,YAAY,mCAgBtB"}

package/src/engine/physics/fluid/ecs/fluid_build_world_to_grid.js

@@ -0,0 +1,32 @@
+/**
+ * Write the world-to-grid affine for a {@link FluidComponent} into `out`.
+ * Axis-aligned, uniform-scale, so the matrix is sparse:
+ *
+ *     [ 1/cs   0     0    -ox/cs ]
+ *     [ 0      1/cs  0    -oy/cs ]
+ *     [ 0      0     1/cs -oz/cs ]
+ *     [ 0      0     0     1     ]
+ *
+ * Stored column-major (matches the convention of {@link v3_matrix4_multiply}).
+ *
+ * Shared by {@link FluidSystem} and {@link WorkerFluidSystem}: both hand this
+ * matrix to effectors, and an effector must see the same world-space mapping
+ * regardless of which system is driving it.
+ *
+ * @param {Float32Array} out  length-16
+ * @param {FluidComponent} component
+ */
+export function fluid_build_world_to_grid(out, component) {
+    const inv_cs = 1 / component.cell_size;
+    const ox = component.origin[0];
+    const oy = component.origin[1];
+    const oz = component.origin[2];
+
+    out[0]  = inv_cs;  out[1]  = 0;       out[2]  = 0;       out[3]  = 0;
+    out[4]  = 0;       out[5]  = inv_cs;  out[6]  = 0;       out[7]  = 0;
+    out[8]  = 0;       out[9]  = 0;       out[10] = inv_cs;  out[11] = 0;
+    out[12] = -ox * inv_cs;
+    out[13] = -oy * inv_cs;
+    out[14] = -oz * inv_cs;
+    out[15] = 1;
+}

package/src/engine/physics/fluid/ecs/fluid_gather_visible_effectors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Collect every effector in the dataset whose world-space AABB overlaps
+ * `field_aabb` into `out`.
+ *
+ * The broad-phase is cheap (AABB-AABB intersect, 6 comparisons) and skips the
+ * expensive per-cell splat work for effectors that wouldn't have hit anything
+ * anyway. Gather + filter happens per field; effectors that overlap multiple
+ * fields are evaluated multiple times — fine for the typical "few fields" case,
+ * optimise to a cached per-effector AABB pass if you find yourself with many
+ * fields.
+ *
+ * Shared by {@link FluidSystem} and {@link WorkerFluidSystem} so both select the
+ * same effector set for a given field.
+ *
+ * @param {AbstractFluidEffector[]} out  cleared and refilled
+ * @param {EntityComponentDataset} ecd
+ * @param {AABB3} field_aabb  world-space bounds of the field being stepped
+ * @param {AABB3} effector_aabb  scratch, rewritten per effector
+ * @returns {AbstractFluidEffector[]} `out`, for chaining
+ */
+export function fluid_gather_visible_effectors(out: AbstractFluidEffector[], ecd: EntityComponentDataset, field_aabb: AABB3, effector_aabb: AABB3): AbstractFluidEffector[];
+//# sourceMappingURL=fluid_gather_visible_effectors.d.ts.map

package/src/engine/physics/fluid/ecs/fluid_gather_visible_effectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_gather_visible_effectors.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_gather_visible_effectors.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,oDANW,uBAAuB,yEAIrB,uBAAuB,CAyBnC"}

package/src/engine/physics/fluid/ecs/fluid_gather_visible_effectors.js

@@ -0,0 +1,47 @@
+import { aabb3_intersects_aabb3 } from "../../../../core/geom/3d/aabb/aabb3_intersects_aabb3.js";
+import { FluidEffectorsComponent } from "./FluidEffectorsComponent.js";
+
+/**
+ * Collect every effector in the dataset whose world-space AABB overlaps
+ * `field_aabb` into `out`.
+ *
+ * The broad-phase is cheap (AABB-AABB intersect, 6 comparisons) and skips the
+ * expensive per-cell splat work for effectors that wouldn't have hit anything
+ * anyway. Gather + filter happens per field; effectors that overlap multiple
+ * fields are evaluated multiple times — fine for the typical "few fields" case,
+ * optimise to a cached per-effector AABB pass if you find yourself with many
+ * fields.
+ *
+ * Shared by {@link FluidSystem} and {@link WorkerFluidSystem} so both select the
+ * same effector set for a given field.
+ *
+ * @param {AbstractFluidEffector[]} out  cleared and refilled
+ * @param {EntityComponentDataset} ecd
+ * @param {AABB3} field_aabb  world-space bounds of the field being stepped
+ * @param {AABB3} effector_aabb  scratch, rewritten per effector
+ * @returns {AbstractFluidEffector[]} `out`, for chaining
+ */
+export function fluid_gather_visible_effectors(out, ecd, field_aabb, effector_aabb) {
+    out.length = 0;
+
+    ecd.traverseComponents(FluidEffectorsComponent, function (effectors_component) {
+        const effectors = effectors_component.effectors;
+
+        for (let i = 0; i < effectors.length; i++) {
+            const effector = effectors[i];
+
+            effector.getBoundingBox(effector_aabb);
+
+            if (aabb3_intersects_aabb3(
+                effector_aabb.x0, effector_aabb.y0, effector_aabb.z0,
+                effector_aabb.x1, effector_aabb.y1, effector_aabb.z1,
+                field_aabb.x0, field_aabb.y0, field_aabb.z0,
+                field_aabb.x1, field_aabb.y1, field_aabb.z1
+            )) {
+                out.push(effector);
+            }
+        }
+    });
+
+    return out;
+}

package/src/engine/physics/fluid/ecs/fluid_reanchor_field.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Keep a fluid field's grid origin locked to a cell-aligned position near its
+ * transform, shifting the field's contents when the alignment changes so the
+ * fluid appears to stay put in world space while the grid hops between cells.
+ *
+ * Centre formula: `q * cell_size + offset`, where `q` is the cell index along
+ * each axis. Origin is then the centre minus half the grid extent so the centre
+ * lands at the geometric middle of the grid.
+ *
+ * Hysteresis: instead of recomputing `q` from the raw position every frame
+ * (which would re-shift on every boundary crossing for a Transform jittering on
+ * a cell edge), the current `q` is recovered from the existing origin and only
+ * advances to a new cell when the raw position has drifted more than
+ * `0.5 + hysteresis` cells from it. Crossing the threshold snaps to the new
+ * nearest cell, so a single large move still produces a single discrete shift.
+ *
+ * First sync (`anchored = false`): snap origin to the desired value, no shift.
+ * Subsequent syncs: per-axis hysteretic quantization, then `field.shift` if the
+ * integer delta is non-zero.
+ *
+ * Shared by {@link FluidSystem} and {@link WorkerFluidSystem} — both anchor
+ * identically, and the two must not be allowed to drift apart.
+ *
+ * @param {FluidComponent} component
+ * @param {Transform} transform
+ */
+export function fluid_reanchor_field(component: FluidComponent, transform: Transform): void;
+//# sourceMappingURL=fluid_reanchor_field.d.ts.map

package/src/engine/physics/fluid/ecs/fluid_reanchor_field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_reanchor_field.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_reanchor_field.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4FA0DC"}

package/src/engine/physics/fluid/ecs/fluid_reanchor_field.js

@@ -0,0 +1,85 @@
+/**
+ * Keep a fluid field's grid origin locked to a cell-aligned position near its
+ * transform, shifting the field's contents when the alignment changes so the
+ * fluid appears to stay put in world space while the grid hops between cells.
+ *
+ * Centre formula: `q * cell_size + offset`, where `q` is the cell index along
+ * each axis. Origin is then the centre minus half the grid extent so the centre
+ * lands at the geometric middle of the grid.
+ *
+ * Hysteresis: instead of recomputing `q` from the raw position every frame
+ * (which would re-shift on every boundary crossing for a Transform jittering on
+ * a cell edge), the current `q` is recovered from the existing origin and only
+ * advances to a new cell when the raw position has drifted more than
+ * `0.5 + hysteresis` cells from it. Crossing the threshold snaps to the new
+ * nearest cell, so a single large move still produces a single discrete shift.
+ *
+ * First sync (`anchored = false`): snap origin to the desired value, no shift.
+ * Subsequent syncs: per-axis hysteretic quantization, then `field.shift` if the
+ * integer delta is non-zero.
+ *
+ * Shared by {@link FluidSystem} and {@link WorkerFluidSystem} — both anchor
+ * identically, and the two must not be allowed to drift apart.
+ *
+ * @param {FluidComponent} component
+ * @param {Transform} transform
+ */
+export function fluid_reanchor_field(component, transform) {
+    const cs = component.cell_size;
+    const p = transform.position;
+    const offset = component.offset;
+    const hyst = component.hysteresis;
+
+    const res = component.field.getResolution();
+    const half_extent_x = (res[0] - 1) * cs * 0.5;
+    const half_extent_y = (res[1] - 1) * cs * 0.5;
+    const half_extent_z = (res[2] - 1) * cs * 0.5;
+
+    const origin = component.origin;
+
+    if (!component.anchored) {
+        // First sync — adopt the freshly-quantized origin without shifting.
+        // Subsequent frames will see integer-cs differences and shift instead.
+        const q_x = Math.round(p.x / cs);
+        const q_y = Math.round(p.y / cs);
+        const q_z = Math.round(p.z / cs);
+        origin[0] = q_x * cs + offset[0] - half_extent_x;
+        origin[1] = q_y * cs + offset[1] - half_extent_y;
+        origin[2] = q_z * cs + offset[2] - half_extent_z;
+        component.anchored = true;
+        return;
+    }
+
+    // Recover the current quantized cell index per axis from the existing origin.
+    // origin_axis = q_curr * cs + offset - half_extent  →
+    //     q_curr = (origin_axis + half_extent - offset) / cs.
+    // Round defends against floating drift; the value should already be integer.
+    const q_curr_x = Math.round((origin[0] + half_extent_x - offset[0]) / cs);
+    const q_curr_y = Math.round((origin[1] + half_extent_y - offset[1]) / cs);
+    const q_curr_z = Math.round((origin[2] + half_extent_z - offset[2]) / cs);
+
+    // Raw (fractional) cell coordinate the Transform sits at right now.
+    const raw_x = p.x / cs;
+    const raw_y = p.y / cs;
+    const raw_z = p.z / cs;
+
+    // Hysteretic re-quantize: only adopt a new cell when raw has drifted past
+    // 0.5 + hyst from the current one. Snap to the new nearest, not the threshold.
+    const threshold = 0.5 + hyst;
+    const q_new_x = Math.abs(raw_x - q_curr_x) > threshold ? Math.round(raw_x) : q_curr_x;
+    const q_new_y = Math.abs(raw_y - q_curr_y) > threshold ? Math.round(raw_y) : q_curr_y;
+    const q_new_z = Math.abs(raw_z - q_curr_z) > threshold ? Math.round(raw_z) : q_curr_z;
+
+    const shift_x = q_new_x - q_curr_x;
+    const shift_y = q_new_y - q_curr_y;
+    const shift_z = q_new_z - q_curr_z;
+
+    if (shift_x === 0 && shift_y === 0 && shift_z === 0) {
+        return;
+    }
+
+    component.field.shift(shift_x, shift_y, shift_z);
+    origin[0] = q_new_x * cs + offset[0] - half_extent_x;
+    origin[1] = q_new_y * cs + offset[1] - half_extent_y;
+    origin[2] = q_new_z * cs + offset[2] - half_extent_z;
+}

package/src/engine/physics/fluid/ecs/fluid_sync_effectors_from_transform.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Visitor for the (FluidEffectorsComponent, Transform) traversal — lets every
+ * position-bearing effector (wakes, splats) follow its owning entity.
+ *
+ * Shared by {@link FluidSystem} and {@link WorkerFluidSystem}.
+ *
+ * @param {FluidEffectorsComponent} effectors_component
+ * @param {Transform} transform
+ */
+export function fluid_sync_effectors_from_transform(effectors_component: FluidEffectorsComponent, transform: Transform): void;
+//# sourceMappingURL=fluid_sync_effectors_from_transform.d.ts.map

package/src/engine/physics/fluid/ecs/fluid_sync_effectors_from_transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_sync_effectors_from_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_sync_effectors_from_transform.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,8HAMC"}

package/src/engine/physics/fluid/ecs/fluid_sync_effectors_from_transform.js

@@ -0,0 +1,16 @@
+/**
+ * Visitor for the (FluidEffectorsComponent, Transform) traversal — lets every
+ * position-bearing effector (wakes, splats) follow its owning entity.
+ *
+ * Shared by {@link FluidSystem} and {@link WorkerFluidSystem}.
+ *
+ * @param {FluidEffectorsComponent} effectors_component
+ * @param {Transform} transform
+ */
+export function fluid_sync_effectors_from_transform(effectors_component, transform) {
+    const effectors = effectors_component.effectors;
+
+    for (let i = 0; i < effectors.length; i++) {
+        effectors[i].syncFromTransform(transform);
+    }
+}

package/src/engine/physics/fluid/ecs/fluid_worker_protocol.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Serialize a simulator's configuration into the command region.
+ *
+ * @param {Float64Array} command
+ * @param {FluidSimulator} simulator
+ * @param {number} time_delta_seconds
+ */
+export function fluid_command_write_simulator(command: Float64Array, simulator: FluidSimulator, time_delta_seconds: number): void;
+/**
+ * Apply a serialized configuration onto a simulator. Inverse of
+ * {@link fluid_command_write_simulator}; kept in the same module so the two
+ * cannot drift apart.
+ *
+ * @param {Float64Array} command
+ * @param {FluidSimulator} simulator
+ */
+export function fluid_command_read_simulator(command: Float64Array, simulator: FluidSimulator): void;
+/**
+ * Layout of the {@link WorkerSystem } command region used by
+ * {@link WorkerFluidSystem }.
+ *
+ * The whole simulator configuration is re-sent every tick rather than
+ * synchronised on change. It is a dozen `Float64` words written into memory the
+ * worker already shares — cheaper than tracking dirtiness — and it keeps
+ * `system.simulator.vorticity_confinement = 5` working exactly as it does with
+ * the main-thread {@link FluidSystem }, which is the point of a drop-in
+ * replacement.
+ */
+export type FluidCommand = number;
+export namespace FluidCommand {
+    let DT: number;
+    let VELOCITY_DIFFUSION_RATE: number;
+    let VELOCITY_DIFFUSION_ITERATIONS: number;
+    let SCALAR_DIFFUSION_RATE: number;
+    let SCALAR_DIFFUSION_ITERATIONS: number;
+    let VELOCITY_DAMPING: number;
+    let VORTICITY_CONFINEMENT: number;
+    let PRESSURE_ITERATION_SCALE: number;
+    let ADVECTION_REFLECTION: number;
+    let PROJECT_BEFORE_ADVECTION: number;
+    let ADVECTION_SCHEME: number;
+    let PRESSURE_SOLVER: number;
+    let FIELD_COUNT: number;
+    let FIELD_IDS: number;
+}
+/**
+ * Command words consumed before the variable-length field id list.
+ * @type {number}
+ */
+export const FLUID_COMMAND_HEADER_WORDS: number;
+//# sourceMappingURL=fluid_worker_protocol.d.ts.map

package/src/engine/physics/fluid/ecs/fluid_worker_protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_worker_protocol.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_worker_protocol.js"],"names":[],"mappings":"AAwDA;;;;;;GAMG;AACH,uDAJW,YAAY,iDAEZ,MAAM,QAqBhB;AAED;;;;;;;GAOG;AACH,sDAHW,YAAY,mCAqBtB;;;;;;;;;;;;2BAhGS,MAAM;;;;;;;;;;;;;;;;;AA0BhB;;;GAGG;AACH,yCAFU,MAAM,CAEiD"}

package/src/engine/physics/fluid/ecs/fluid_worker_protocol.js

@@ -0,0 +1,111 @@
+import { AdvectionScheme, PressureSolver } from "../FluidSimulator.js";
+
+/**
+ * Layout of the {@link WorkerSystem} command region used by
+ * {@link WorkerFluidSystem}.
+ *
+ * The whole simulator configuration is re-sent every tick rather than
+ * synchronised on change. It is a dozen `Float64` words written into memory the
+ * worker already shares — cheaper than tracking dirtiness — and it keeps
+ * `system.simulator.vorticity_confinement = 5` working exactly as it does with
+ * the main-thread {@link FluidSystem}, which is the point of a drop-in
+ * replacement.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const FluidCommand = {
+    DT: 0,
+    VELOCITY_DIFFUSION_RATE: 1,
+    VELOCITY_DIFFUSION_ITERATIONS: 2,
+    SCALAR_DIFFUSION_RATE: 3,
+    SCALAR_DIFFUSION_ITERATIONS: 4,
+    VELOCITY_DAMPING: 5,
+    VORTICITY_CONFINEMENT: 6,
+    PRESSURE_ITERATION_SCALE: 7,
+    ADVECTION_REFLECTION: 8,
+    PROJECT_BEFORE_ADVECTION: 9,
+    ADVECTION_SCHEME: 10,
+    PRESSURE_SOLVER: 11,
+    /**
+     * How many field ids follow.
+     */
+    FIELD_COUNT: 12,
+    /**
+     * First of {@link FluidCommand.FIELD_COUNT} field ids, in the order they
+     * should be stepped.
+     */
+    FIELD_IDS: 13
+};
+
+/**
+ * Command words consumed before the variable-length field id list.
+ * @type {number}
+ */
+export const FLUID_COMMAND_HEADER_WORDS = FluidCommand.FIELD_IDS;
+
+/**
+ * `AdvectionScheme` is a string enum; the command region is numeric.
+ * @type {number}
+ */
+const ADVECTION_SEMI_LAGRANGIAN = 0;
+const ADVECTION_MACCORMACK = 1;
+
+const SOLVER_SOR = 0;
+const SOLVER_MICPCG = 1;
+
+/**
+ * Serialize a simulator's configuration into the command region.
+ *
+ * @param {Float64Array} command
+ * @param {FluidSimulator} simulator
+ * @param {number} time_delta_seconds
+ */
+export function fluid_command_write_simulator(command, simulator, time_delta_seconds) {
+    command[FluidCommand.DT] = time_delta_seconds;
+    command[FluidCommand.VELOCITY_DIFFUSION_RATE] = simulator.velocity_diffusion_rate;
+    command[FluidCommand.VELOCITY_DIFFUSION_ITERATIONS] = simulator.velocity_diffusion_iterations;
+    command[FluidCommand.SCALAR_DIFFUSION_RATE] = simulator.scalar_diffusion_rate;
+    command[FluidCommand.SCALAR_DIFFUSION_ITERATIONS] = simulator.scalar_diffusion_iterations;
+    command[FluidCommand.VELOCITY_DAMPING] = simulator.velocity_damping;
+    command[FluidCommand.VORTICITY_CONFINEMENT] = simulator.vorticity_confinement;
+    command[FluidCommand.PRESSURE_ITERATION_SCALE] = simulator.pressure_iteration_scale;
+    command[FluidCommand.ADVECTION_REFLECTION] = simulator.advection_reflection ? 1 : 0;
+    command[FluidCommand.PROJECT_BEFORE_ADVECTION] = simulator.project_before_advection ? 1 : 0;
+
+    command[FluidCommand.ADVECTION_SCHEME] = simulator.advection_scheme === AdvectionScheme.MACCORMACK
+        ? ADVECTION_MACCORMACK
+        : ADVECTION_SEMI_LAGRANGIAN;
+
+    command[FluidCommand.PRESSURE_SOLVER] = simulator.pressure_solver === PressureSolver.MICPCG
+        ? SOLVER_MICPCG
+        : SOLVER_SOR;
+}
+
+/**
+ * Apply a serialized configuration onto a simulator. Inverse of
+ * {@link fluid_command_write_simulator}; kept in the same module so the two
+ * cannot drift apart.
+ *
+ * @param {Float64Array} command
+ * @param {FluidSimulator} simulator
+ */
+export function fluid_command_read_simulator(command, simulator) {
+    simulator.velocity_diffusion_rate = command[FluidCommand.VELOCITY_DIFFUSION_RATE];
+    simulator.velocity_diffusion_iterations = command[FluidCommand.VELOCITY_DIFFUSION_ITERATIONS];
+    simulator.scalar_diffusion_rate = command[FluidCommand.SCALAR_DIFFUSION_RATE];
+    simulator.scalar_diffusion_iterations = command[FluidCommand.SCALAR_DIFFUSION_ITERATIONS];
+    simulator.velocity_damping = command[FluidCommand.VELOCITY_DAMPING];
+    simulator.vorticity_confinement = command[FluidCommand.VORTICITY_CONFINEMENT];
+    simulator.pressure_iteration_scale = command[FluidCommand.PRESSURE_ITERATION_SCALE];
+    simulator.advection_reflection = command[FluidCommand.ADVECTION_REFLECTION] !== 0;
+    simulator.project_before_advection = command[FluidCommand.PROJECT_BEFORE_ADVECTION] !== 0;
+
+    simulator.advection_scheme = command[FluidCommand.ADVECTION_SCHEME] === ADVECTION_MACCORMACK
+        ? AdvectionScheme.MACCORMACK
+        : AdvectionScheme.SEMI_LAGRANGIAN;
+
+    simulator.pressure_solver = command[FluidCommand.PRESSURE_SOLVER] === SOLVER_MICPCG
+        ? PressureSolver.MICPCG
+        : PressureSolver.SOR;
+}

package/src/engine/physics/fluid/ecs/makeFluidWorker.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Spawn the fluid solver worker.
+ *
+ * Isolated in its own module on purpose: `import.meta` is a syntax error under
+ * the CommonJS transform the test runner uses, so any module containing it
+ * cannot be imported by a spec — even transitively. Keeping the expression here
+ * lets {@link WorkerFluidSystem} stay testable while application code gets a
+ * one-import default.
+ *
+ * The `new Worker(new URL(...), { type: "module" })` form is what webpack 5
+ * detects statically, so the worker is emitted as a real chunk with its full
+ * dependency graph rather than being assembled at runtime.
+ *
+ * @returns {Worker}
+ */
+export function makeFluidWorker(): Worker;
+//# sourceMappingURL=makeFluidWorker.d.ts.map

package/src/engine/physics/fluid/ecs/makeFluidWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeFluidWorker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/makeFluidWorker.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,mCAFa,MAAM,CAIlB"}

package/src/engine/physics/fluid/ecs/makeFluidWorker.js

@@ -0,0 +1,18 @@
+/**
+ * Spawn the fluid solver worker.
+ *
+ * Isolated in its own module on purpose: `import.meta` is a syntax error under
+ * the CommonJS transform the test runner uses, so any module containing it
+ * cannot be imported by a spec — even transitively. Keeping the expression here
+ * lets {@link WorkerFluidSystem} stay testable while application code gets a
+ * one-import default.
+ *
+ * The `new Worker(new URL(...), { type: "module" })` form is what webpack 5
+ * detects statically, so the worker is emitted as a real chunk with its full
+ * dependency graph rather than being assembled at runtime.
+ *
+ * @returns {Worker}
+ */
+export function makeFluidWorker() {
+    return new Worker(new URL("./fluid.worker.js", import.meta.url), { type: "module" });
+}

package/src/engine/physics/island/IslandBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IslandBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/island/IslandBuilder.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH;IAyFI;;;;;OAKG;IACH,gCAOC;IA0ND;;;;;;;;;;;;;OAaG;IACH,2CAmBC;IAED;;;;;OAKG;IACH,6BAIC;IAED;;;OAGG;IACH,6BAIC;IApXG;;;;;OAKG;IACH,QAFU,WAAW,CAEY;IAEjC;;;;OAIG;IACH,gBAFU,UAAU,CAEoB;IAExC;;;OAGG;IACH,cAFU,MAAM,CAEK;IAErB;;;;OAIG;IACH,cAFU,WAAW,CAEiB;IAEtC;;;;OAIG;IACH,WAFU,WAAW,CAEe;IAEpC;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;;OAKG;IACH,iBAFU,WAAW,CAEoB;IAEzC;;;;OAIG;IACH,cAFU,WAAW,CAEkB;IAEvC;;;OAGG;IACH,eAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,yBAA0C;IAE1C;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;OAIG;IACH,kBAAmC;IAkBvC;;;;;;;;;;;OAWG;IACH,8DANW,WAAW,uBACX,OAAO,UACP,OAAO,QAqGjB;IAED;;;;OAIG;IACH,yBA+CC;IAED;;;;;;OAMG;IACH,4BA0CC;IA2DD;;;;;;;;;OASG;IACH,yBAsBC;IAID;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,uCAOC;IAED;;;OAGG;IACH,oCAIC;IAED;;;OAGG;IACH,uCAIC;CACJ"}
+{"version":3,"file":"IslandBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/island/IslandBuilder.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH;IAuFI;;;;;OAKG;IACH,gCAOC;IA0ND;;;;;;;;;;;;;OAaG;IACH,2CAmBC;IAED;;;;;OAKG;IACH,6BAIC;IAED;;;OAGG;IACH,6BAIC;IAnXD;;;;;OAKG;IACH,QAFU,WAAW,CAEQ;IAE7B;;;;OAIG;IACH,gBAFU,UAAU,CAEgB;IAEpC;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,cAFU,WAAW,CAEa;IAElC;;;;OAIG;IACH,WAFU,WAAW,CAEW;IAEhC;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;;OAKG;IACH,iBAFU,WAAW,CAEgB;IAErC;;;;OAIG;IACH,cAFU,WAAW,CAEc;IAEnC;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,yBAAsC;IAEtC;;;;;OAKG;IACH,wBAAsC;IAEtC;;;;OAIG;IACH,kBAA+B;IAiB/B;;;;;;;;;;;OAWG;IACH,8DANW,WAAW,uBACX,OAAO,UACP,OAAO,QAqGjB;IAED;;;;OAIG;IACH,yBA+CC;IAED;;;;;;OAMG;IACH,4BA0CC;IA2DD;;;;;;;;;OASG;IACH,yBAsBC;IAID;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,uCAOC;IAED;;;OAGG;IACH,oCAIC;IAED;;;OAGG;IACH,uCAIC;CACJ"}