@woosh/meep-engine 3.41.0 → 3.42.0

package/src/engine/physics/fluid/solver/v3_grid_advect_maccormack_velocity.js

@@ -1,7 +1,7 @@
 import { v3_grid_limit8_at_indices } from "./v3_grid_limit8_at_indices.js";
 import { assert } from "../../../../core/assert.js";
 import { clamp } from "../../../../core/math/clamp.js";
-import { scs3d_sample_linear3 } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
+import { scs3d_sample_linear3_array } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
 
 /*
  * COLLOCATED VARIANT. FluidSimulator transports through the MAC (staggered-grid) kernels in the sibling
@@ -76,6 +76,7 @@ export function v3_grid_advect_maccormack_velocity(outputs, sources, carrier_x,
     const last_y = res_y - 1;
     const last_z = res_z - 1;
     const sample = scratch_sample;
+    const position = scratch_position;
 
     // ─── pass 1: forward SL step into the scratch trio ──────────────────────
     for (let z = 0; z < res_z; z++) {
@@ -93,7 +94,10 @@ export function v3_grid_advect_maccormack_velocity(outputs, sources, carrier_x,
                 const s_x = x - carrier_x[c] * time_delta;
                 const s_y = y - carrier_y[c] * time_delta;
                 const s_z = z - carrier_z[c] * time_delta;
-                scs3d_sample_linear3(sample, src_x, src_y, src_z, res_x, res_y, res_z, s_x, s_y, s_z);
+                position[0] = s_x;
+                position[1] = s_y;
+                position[2] = s_z;
+                scs3d_sample_linear3_array(sample, src_x, src_y, src_z, res_x, res_y, res_z, position, 0);
                 fwd_x[c] = sample[0];
                 fwd_y[c] = sample[1];
                 fwd_z[c] = sample[2];
@@ -119,7 +123,10 @@ export function v3_grid_advect_maccormack_velocity(outputs, sources, carrier_x,
                 const vy = carrier_y[c] * time_delta;
                 const vz = carrier_z[c] * time_delta;
 
-                scs3d_sample_linear3(sample, fwd_x, fwd_y, fwd_z, res_x, res_y, res_z, x + vx, y + vy, z + vz);
+                position[0] = x + vx;
+                position[1] = y + vy;
+                position[2] = z + vz;
+                scs3d_sample_linear3_array(sample, fwd_x, fwd_y, fwd_z, res_x, res_y, res_z, position, 0);
                 const corr_x = fwd_x[c] + 0.5 * (src_x[c] - sample[0]);
                 const corr_y = fwd_y[c] + 0.5 * (src_y[c] - sample[1]);
                 const corr_z = fwd_z[c] + 0.5 * (src_z[c] - sample[2]);
@@ -160,3 +167,5 @@ export function v3_grid_advect_maccormack_velocity(outputs, sources, carrier_x,
 
 /** Module-static sample destination — avoids per-cell allocation. */
 const scratch_sample = new Float32Array(3);
+/** Continuous coordinates passed to the sampler during this synchronous typed-array sweep. */
+const scratch_position = new Float64Array(3);

package/src/engine/physics/fluid/solver/v3_grid_advect_sl_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_grid_advect_sl_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_advect_sl_velocity.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oDAdW,YAAY,EAAE,WACd,YAAY,EAAE,aAEd,YAAY,aACZ,YAAY,aACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QA+DpB"}
+{"version":3,"file":"v3_grid_advect_sl_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_advect_sl_velocity.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oDAdW,YAAY,EAAE,WACd,YAAY,EAAE,aAEd,YAAY,aACZ,YAAY,aACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QAmEpB"}

package/src/engine/physics/fluid/solver/v3_grid_advect_sl_velocity.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { scs3d_sample_linear3 } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
+import { scs3d_sample_linear3_array } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
 
 /*
  * COLLOCATED VARIANT. FluidSimulator transports through the MAC (staggered-grid) kernels in the sibling
@@ -72,6 +72,7 @@ export function v3_grid_advect_sl_velocity(outputs, sources, carrier_x, carrier_
 
     const slice_size = res_x * res_y;
     const sample = scratch_sample;
+    const position = scratch_position;
 
     for (let z = 0; z < res_z; z++) {
         const z_off = z * slice_size;
@@ -94,7 +95,10 @@ export function v3_grid_advect_sl_velocity(outputs, sources, carrier_x, carrier_
                 const s_y = y - carrier_y[c] * time_delta;
                 const s_z = z - carrier_z[c] * time_delta;
 
-                scs3d_sample_linear3(sample, src_x, src_y, src_z, res_x, res_y, res_z, s_x, s_y, s_z);
+                position[0] = s_x;
+                position[1] = s_y;
+                position[2] = s_z;
+                scs3d_sample_linear3_array(sample, src_x, src_y, src_z, res_x, res_y, res_z, position, 0);
                 out_x[c] = sample[0];
                 out_y[c] = sample[1];
                 out_z[c] = sample[2];
@@ -105,3 +109,5 @@ export function v3_grid_advect_sl_velocity(outputs, sources, carrier_x, carrier_
 
 /** Module-static sample destination — avoids per-cell allocation. */
 const scratch_sample = new Float32Array(3);
+/** Continuous coordinates passed to the sampler during this synchronous typed-array sweep. */
+const scratch_position = new Float64Array(3);

package/src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.d.ts

@@ -27,4 +27,23 @@
  * @return {number}
  */
 export function v3_grid_sample_scalar_masked(data: Float32Array, solid: Uint8Array, res_x: number, res_y: number, res_z: number, x: number, y: number, z: number, fallback: number): number;
+/**
+ * {@link v3_grid_sample_scalar_masked} with `[x, y, z, fallback]` read from a reusable operand record
+ * and the sample written into `out`. No continuous number crosses the call boundary, including the
+ * result, so a per-cell caller does not need this sampler to be inlined to avoid numeric boxes.
+ *
+ * The operands are read before any output write; `out` may overlap `operands` or `data`. Float64
+ * operands preserve the scalar form's coordinate and fallback precision.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array} data
+ * @param {Uint8Array} solid
+ * @param {number} res_x
+ * @param {number} res_y
+ * @param {number} res_z
+ * @param {Float64Array} operands `[x, y, z, fallback]`
+ * @param {number} operands_offset
+ */
+export function v3_grid_sample_scalar_masked_array(out: Float32Array | Float64Array | number[], out_offset: number, data: Float32Array, solid: Uint8Array, res_x: number, res_y: number, res_z: number, operands: Float64Array, operands_offset: number): void;
 //# sourceMappingURL=v3_grid_sample_scalar_masked.d.ts.map

package/src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_grid_sample_scalar_masked.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mDAXW,YAAY,SACZ,UAAU,SACV,MAAM,SACN,MAAM,SACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,GACL,MAAM,CA+DjB"}
+{"version":3,"file":"v3_grid_sample_scalar_masked.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mDAXW,YAAY,SACZ,UAAU,SACV,MAAM,SACN,MAAM,SACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,GACL,MAAM,CAYjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wDAVW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,QACN,YAAY,SACZ,UAAU,SACV,MAAM,SACN,MAAM,SACN,MAAM,YACN,YAAY,mBACZ,MAAM,QAqEhB"}

package/src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.js

@@ -1,5 +1,8 @@
 import { clamp } from "../../../../core/math/clamp.js";
 
+const scratch_operands = new Float64Array(4);
+const scratch_sample = new Float64Array(1);
+
 /**
  * Trilinearly sample a cell-centered scalar at a fractional position,
  * EXCLUDING solid cells from the interpolation: solid taps contribute zero
@@ -29,6 +32,41 @@ import { clamp } from "../../../../core/math/clamp.js";
  * @return {number}
  */
 export function v3_grid_sample_scalar_masked(data, solid, res_x, res_y, res_z, x, y, z, fallback) {
+    const operands = scratch_operands;
+    operands[0] = x;
+    operands[1] = y;
+    operands[2] = z;
+    operands[3] = fallback;
+
+    v3_grid_sample_scalar_masked_array(scratch_sample, 0, data, solid, res_x, res_y, res_z, operands, 0);
+
+    return scratch_sample[0];
+}
+
+/**
+ * {@link v3_grid_sample_scalar_masked} with `[x, y, z, fallback]` read from a reusable operand record
+ * and the sample written into `out`. No continuous number crosses the call boundary, including the
+ * result, so a per-cell caller does not need this sampler to be inlined to avoid numeric boxes.
+ *
+ * The operands are read before any output write; `out` may overlap `operands` or `data`. Float64
+ * operands preserve the scalar form's coordinate and fallback precision.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array} data
+ * @param {Uint8Array} solid
+ * @param {number} res_x
+ * @param {number} res_y
+ * @param {number} res_z
+ * @param {Float64Array} operands `[x, y, z, fallback]`
+ * @param {number} operands_offset
+ */
+export function v3_grid_sample_scalar_masked_array(out, out_offset, data, solid, res_x, res_y, res_z, operands, operands_offset) {
+    const x = operands[operands_offset];
+    const y = operands[operands_offset + 1];
+    const z = operands[operands_offset + 2];
+    const fallback = operands[operands_offset + 3];
+
     const x_max = res_x - 1;
     const y_max = res_y - 1;
     const z_max = res_z - 1;
@@ -80,7 +118,8 @@ export function v3_grid_sample_scalar_masked(data, solid, res_x, res_y, res_z, x
 
     const total = w000 + w100 + w010 + w110 + w001 + w101 + w011 + w111;
     if (total <= 0) {
-        return fallback;
+        out[out_offset] = fallback;
+        return;
     }
 
     const sum = w000 * data[c000] + w100 * data[c100]
@@ -88,5 +127,5 @@ export function v3_grid_sample_scalar_masked(data, solid, res_x, res_y, res_z, x
         + w001 * data[c001] + w101 * data[c101]
         + w011 * data[c011] + w111 * data[c111];
 
-    return sum / total;
+    out[out_offset] = sum / total;
 }

package/src/engine/physics/fluid/solver/v3_mac_advect_scalar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_mac_advect_scalar.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_scalar.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QA4CpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wDAZW,YAAY,SACZ,YAAY,mBACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QA8GpB"}
+{"version":3,"file":"v3_mac_advect_scalar.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_scalar.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QAgDpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wDAZW,YAAY,SACZ,YAAY,mBACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QA8GpB"}

package/src/engine/physics/fluid/solver/v3_mac_advect_scalar.js

@@ -1,9 +1,11 @@
 import { assert } from "../../../../core/assert.js";
 import { clamp } from "../../../../core/math/clamp.js";
-import { v3_grid_sample_scalar_masked } from "./v3_grid_sample_scalar_masked.js";
+import { v3_grid_sample_scalar_masked, v3_grid_sample_scalar_masked_array } from "./v3_grid_sample_scalar_masked.js";
 import { v3_mac_clip_trace } from "./v3_mac_clip_trace.js";
 
 const scratch_clip = new Float32Array(3);
+// This synchronous typed-array kernel has no callbacks while a sample is in progress.
+const scratch_sample_operands = new Float64Array(4);
 
 /**
  * Straight-line (loop-free, inlinable) test: is the cell containing the
@@ -66,6 +68,7 @@ export function v3_mac_advect_sl_scalar(output, input, vel_u, vel_v, vel_w, res_
     assert.greaterThanOrEqual(input.length, cell_count, "input covers grid");
 
     const cell_slice = res_x * res_y;
+    const operands = scratch_sample_operands;
     const sx = res_x + 1;
     const v_slice = res_x * (res_y + 1);
 
@@ -96,8 +99,11 @@ export function v3_mac_advect_sl_scalar(output, input, vel_u, vel_v, vel_w, res_
                     bx = scratch_clip[0]; by = scratch_clip[1]; bz = scratch_clip[2];
                 }
 
-                output[c] = v3_grid_sample_scalar_masked(input, solid, res_x, res_y, res_z,
-                    bx, by, bz, input[c]);
+                operands[0] = bx;
+                operands[1] = by;
+                operands[2] = bz;
+                operands[3] = input[c];
+                v3_grid_sample_scalar_masked_array(output, c, input, solid, res_x, res_y, res_z, operands, 0);
             }
         }
     }

package/src/engine/physics/fluid/solver/v3_mac_advect_sl_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_mac_advect_sl_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_sl_velocity.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,mDAZW,YAAY,EAAE,WACd,YAAY,EAAE,WACd,YAAY,EAAE,SACd,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,gBACN,UAAU,gBACV,UAAU,gBACV,UAAU,SACV,UAAU,QAwKpB"}
+{"version":3,"file":"v3_mac_advect_sl_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_sl_velocity.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,mDAZW,YAAY,EAAE,WACd,YAAY,EAAE,WACd,YAAY,EAAE,SACd,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,gBACN,UAAU,gBACV,UAAU,gBACV,UAAU,SACV,UAAU,QAuLpB"}

package/src/engine/physics/fluid/solver/v3_mac_advect_sl_velocity.js

@@ -1,8 +1,9 @@
 import { assert } from "../../../../core/assert.js";
-import { scs3d_sample_linear } from "../../../graphics/texture/3d/scs3d_sample_linear.js";
+import { scs3d_sample_linear_array } from "../../../graphics/texture/3d/scs3d_sample_linear.js";
 import { v3_mac_clip_trace } from "./v3_mac_clip_trace.js";
 
 const scratch_clip = new Float32Array(3);
+const scratch_position = new Float64Array(3);
 
 /**
  * Semi-Lagrangian advection of a MAC (face-centered) velocity field along a
@@ -116,12 +117,17 @@ export function v3_mac_advect_sl_velocity(outputs, sources, carrier, res_x, res_
                 if (ecy < 0) ecy = 0; else if (ecy >= res_y) ecy = last_cy;
                 if (ecz < 0) ecz = 0; else if (ecz >= res_z) ecz = last_cz;
                 if (solid[ecz * cell_slice + ecy * res_x + ecx] === 0) {
-                    out_u[f] = scs3d_sample_linear(src_u, sx, res_y, res_z, ex + 0.5, ey, ez);
+                    scratch_position[0] = ex + 0.5;
+                    scratch_position[1] = ey;
+                    scratch_position[2] = ez;
+                    scs3d_sample_linear_array(out_u, f, src_u, sx, res_y, res_z, scratch_position, 0);
                 } else {
                     v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z,
                         x - 0.5, y, z, ex, ey, ez);
-                    out_u[f] = scs3d_sample_linear(src_u, sx, res_y, res_z,
-                        scratch_clip[0] + 0.5, scratch_clip[1], scratch_clip[2]);
+                    scratch_position[0] = scratch_clip[0] + 0.5;
+                    scratch_position[1] = scratch_clip[1];
+                    scratch_position[2] = scratch_clip[2];
+                    scs3d_sample_linear_array(out_u, f, src_u, sx, res_y, res_z, scratch_position, 0);
                 }
             }
         }
@@ -159,12 +165,17 @@ export function v3_mac_advect_sl_velocity(outputs, sources, carrier, res_x, res_
                 if (ecy < 0) ecy = 0; else if (ecy >= res_y) ecy = last_cy;
                 if (ecz < 0) ecz = 0; else if (ecz >= res_z) ecz = last_cz;
                 if (solid[ecz * cell_slice + ecy * res_x + ecx] === 0) {
-                    out_v[f] = scs3d_sample_linear(src_v, res_x, sy, res_z, ex, ey + 0.5, ez);
+                    scratch_position[0] = ex;
+                    scratch_position[1] = ey + 0.5;
+                    scratch_position[2] = ez;
+                    scs3d_sample_linear_array(out_v, f, src_v, res_x, sy, res_z, scratch_position, 0);
                 } else {
                     v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z,
                         x, y - 0.5, z, ex, ey, ez);
-                    out_v[f] = scs3d_sample_linear(src_v, res_x, sy, res_z,
-                        scratch_clip[0], scratch_clip[1] + 0.5, scratch_clip[2]);
+                    scratch_position[0] = scratch_clip[0];
+                    scratch_position[1] = scratch_clip[1] + 0.5;
+                    scratch_position[2] = scratch_clip[2];
+                    scs3d_sample_linear_array(out_v, f, src_v, res_x, sy, res_z, scratch_position, 0);
                 }
             }
         }
@@ -204,12 +215,17 @@ export function v3_mac_advect_sl_velocity(outputs, sources, carrier, res_x, res_
                 if (ecy < 0) ecy = 0; else if (ecy >= res_y) ecy = last_cy;
                 if (ecz < 0) ecz = 0; else if (ecz >= res_z) ecz = last_cz;
                 if (solid[ecz * cell_slice + ecy * res_x + ecx] === 0) {
-                    out_w[f] = scs3d_sample_linear(src_w, res_x, res_y, sz, ex, ey, ez + 0.5);
+                    scratch_position[0] = ex;
+                    scratch_position[1] = ey;
+                    scratch_position[2] = ez + 0.5;
+                    scs3d_sample_linear_array(out_w, f, src_w, res_x, res_y, sz, scratch_position, 0);
                 } else {
                     v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z,
                         x, y, z - 0.5, ex, ey, ez);
-                    out_w[f] = scs3d_sample_linear(src_w, res_x, res_y, sz,
-                        scratch_clip[0], scratch_clip[1], scratch_clip[2] + 0.5);
+                    scratch_position[0] = scratch_clip[0];
+                    scratch_position[1] = scratch_clip[1];
+                    scratch_position[2] = scratch_clip[2] + 0.5;
+                    scs3d_sample_linear_array(out_w, f, src_w, res_x, res_y, sz, scratch_position, 0);
                 }
             }
         }

package/src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.d.ts

@@ -28,10 +28,7 @@ export class RandomContainerAudioClip extends ContainerAudioClip {
      * container picks uniformly). A weight of `0` (or any non-positive value) means the child is
      * NEVER picked.
      *
-     * Degenerate-but-accepted: if EVERY weight is 0 the container still resolves — deterministically —
-     * to a single child (there is simply nothing to weight, so the pick collapses to a fixed index).
-     * That is a content-authoring mistake, not an engine fault; the engine stays well-defined. In
-     * other words, ten children all weighted 0 will "work", but you get the dog food.
+     * If every child is disabled, the container resolves to an empty timeline.
      * @type {number[]}
      */
     weights: number[];
@@ -81,9 +78,9 @@ export class RandomContainerAudioClip extends ContainerAudioClip {
      * this clip) rather than on this shared, immutable definition; this method owns both the selection
      * algorithm and the maintenance of that history ring.
      * @param {SopraPlaybackContext} playback
-     * @returns {number} chosen child index
+     * @returns {number|undefined} chosen child index, or undefined when no child has positive weight
      */
-    pickChildIndex(playback: SopraPlaybackContext): number;
+    pickChildIndex(playback: SopraPlaybackContext): number | undefined;
     planTimeline(env: any, gainDb?: number, pitchCents?: number, offset?: number): {
         plays: {
             clip: import("./SampleAudioClip.js").SampleAudioClip;

package/src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RandomContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IAqEI;;;;;;OAMG;IACH,uBALW,mBAAmB,oCACnB;QAAC,kBAAkB,CAAC,EAAC,MAAM,CAAC;QAAC,OAAO,CAAC,EAAC,MAAM,EAAE,CAAA;KAAC,GAE7C,wBAAwB,CAapC;IArFD;;;OAGG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;;;;;;;;OAYG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;;;OAKG;IACH,4CAFa,IAAI,CAQhB;IAWD;;;;;;OAMG;IACH,oBAHW,MAAM,EAAE,GACN,IAAI,CAgBhB;IAsBD;;;;OAIG;IACH,cAHW,wBAAwB,GACtB,OAAO,CAuBnB;IAcD,kCAaC;IAED;;;;;;;;;MAQC;IAED;;;;;;aAQC;IAED;;;;;;;;OAQG;IACH,gDAFa,MAAM,CA6BlB;IAED;;;;;;;;;MAQC;CACJ;;;;mCA5NkC,yBAAyB"}
+{"version":3,"file":"RandomContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IAkEI;;;;;;OAMG;IACH,uBALW,mBAAmB,oCACnB;QAAC,kBAAkB,CAAC,EAAC,MAAM,CAAC;QAAC,OAAO,CAAC,EAAC,MAAM,EAAE,CAAA;KAAC,GAE7C,wBAAwB,CAapC;IAlFD;;;OAGG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;;;;;OASG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;;;OAKG;IACH,4CAFa,IAAI,CAQhB;IAWD;;;;;;OAMG;IACH,oBAHW,MAAM,EAAE,GACN,IAAI,CAgBhB;IAsBD;;;;OAIG;IACH,cAHW,wBAAwB,GACtB,OAAO,CAuBnB;IAcD,kCAaC;IAED;;;;;;;;;MAQC;IAED;;;;;;aAQC;IAED;;;;;;;;OAQG;IACH,gDAFa,MAAM,GAAC,SAAS,CAyC5B;IAED;;;;;;;;;MAYC;CACJ;;;;mCAzOkC,yBAAyB"}

package/src/engine/sound/sopra/definition/clip/RandomContainerAudioClip.js

@@ -25,10 +25,7 @@ export class RandomContainerAudioClip extends ContainerAudioClip {
      * container picks uniformly). A weight of `0` (or any non-positive value) means the child is
      * NEVER picked.
      *
-     * Degenerate-but-accepted: if EVERY weight is 0 the container still resolves — deterministically —
-     * to a single child (there is simply nothing to weight, so the pick collapses to a fixed index).
-     * That is a content-authoring mistake, not an engine fault; the engine stays well-defined. In
-     * other words, ten children all weighted 0 will "work", but you get the dog food.
+     * If every child is disabled, the container resolves to an empty timeline.
      * @type {number[]}
      */
     weights = [];
@@ -181,29 +178,41 @@ export class RandomContainerAudioClip extends ContainerAudioClip {
      * this clip) rather than on this shared, immutable definition; this method owns both the selection
      * algorithm and the maintenance of that history ring.
      * @param {SopraPlaybackContext} playback
-     * @returns {number} chosen child index
+     * @returns {number|undefined} chosen child index, or undefined when no child has positive weight
      */
     pickChildIndex(playback) {
         const children = this.children;
         const n = children.length;
 
-        // can't avoid every option — cap so at least one candidate remains
-        const avoid = Math.min(this.avoid_repeating_last, n - 1);
+        const weights = this.weights;
+        let eligibleCount = 0;
+        for (let i = 0; i < n; i++) {
+            if (weights[i] > 0) eligibleCount++;
+        }
+
+        // Disabled children cannot keep an enabled choice out of contention.
+        const avoid = Math.max(0, Math.min(this.avoid_repeating_last, eligibleCount - 1));
 
         const recent = playback.getState(this, () => []);
+        while (recent.length > avoid) {
+            recent.shift();
+        }
 
         const candidates = [];
         for (let i = 0; i < n; i++) {
-            if (recent.indexOf(i) === -1) {
+            if (weights[i] > 0 && recent.indexOf(i) === -1) {
                 candidates.push(i);
             }
         }
 
         // weighted pick among the surviving candidates (weight looked up by child index). With the
         // default all-1 weights this is a uniform draw; a 0 weight removes that child from contention.
-        const weights = this.weights;
         const index = weightedRandomFromArray(candidates, playback.random, i => weights[i]);
 
+        if (index === undefined) {
+            return undefined;
+        }
+
         recent.push(index);
         while (recent.length > avoid) {
             recent.shift();
@@ -219,6 +228,10 @@ export class RandomContainerAudioClip extends ContainerAudioClip {
 
         const index = this.pickChildIndex(env.playback);
 
+        if (index === undefined) {
+            return { plays: [], duration: 0 };
+        }
+
         return this.children[index].planTimeline(env, gainDb + this.gain, pitchCents + this.pitch, offset);
     }
 }

package/src/engine/ui/DraggableAspect.d.ts

@@ -20,13 +20,16 @@ export class DraggableAspect {
      * @param {(position:Vector2, event:Event)=>*} [options.dragStart=noop]
      * @param {(position:Vector2, origin:Vector2, delta:Vector2, event:Event)=>*} [options.drag=noop]
      * @param {(position:Vector2, origin:Vector2, event:Event)=>*} [options.dragEnd=noop]
+     * @param {(event:Event|undefined)=>*} [options.dragCancel=noop] called for a cancelled press or drag;
+     *   pointercancel/blur carries its event, while stop() carries undefined. Cancellation never commits dragEnd.
      * @param {boolean} [options.stopPropagation=true] prevent propagation of pointer events up the DOM tree
      */
-    constructor({ el, dragStart, drag, dragEnd, stopPropagation }: {
+    constructor({ el, dragStart, drag, dragEnd, dragCancel, stopPropagation }: {
         el: EventTarget;
         dragStart?: (position: Vector2, event: Event) => any;
         drag?: (position: Vector2, origin: Vector2, delta: Vector2, event: Event) => any;
         dragEnd?: (position: Vector2, origin: Vector2, event: Event) => any;
+        dragCancel?: (event: Event | undefined) => any;
         stopPropagation?: boolean;
     });
     /**
@@ -44,6 +47,7 @@ export class DraggableAspect {
     getPointer(): PointerDevice;
     start(): void;
     stop(): void;
+    #private;
 }
 import { PointerDevice } from "../input/devices/PointerDevice.js";
 import Vector2 from "../../core/geom/Vector2.js";

package/src/engine/ui/DraggableAspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DraggableAspect.d.ts","sourceRoot":"","sources":["../../../../src/engine/ui/DraggableAspect.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;;;OAQG;IACH;QANgC,EAAE,EAAvB,WAAW;QACkC,SAAS,GAAtD,CAAC,QAAQ,EAAC,OAAO,EAAE,KAAK,EAAC,KAAK,QAAI;QAC0C,IAAI,GAAhF,CAAC,QAAQ,EAAC,OAAO,EAAE,MAAM,EAAC,OAAO,EAAE,KAAK,EAAC,OAAO,EAAE,KAAK,EAAC,KAAK,QAAI;QACJ,OAAO,GAApE,CAAC,QAAQ,EAAC,OAAO,EAAE,MAAM,EAAC,OAAO,EAAE,KAAK,EAAC,KAAK,QAAI;QAChC,eAAe,GAAjC,OAAO;OAuEjB;IApEG;;;;;OAKG;IACH,8BAAyC;IAQnB,+BAA8C;IAwDxE;;;OAGG;IACH,cAFa,aAAa,CAIzB;IAED,cAEC;IAED,aAGC;CACJ;8BAjHyD,mCAAmC;oBADzE,4BAA4B"}
+{"version":3,"file":"DraggableAspect.d.ts","sourceRoot":"","sources":["../../../../src/engine/ui/DraggableAspect.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH;IAKI;;;;;;;;;;OAUG;IACH;QARgC,EAAE,EAAvB,WAAW;QACkC,SAAS,GAAtD,CAAC,QAAQ,EAAC,OAAO,EAAE,KAAK,EAAC,KAAK,QAAI;QAC0C,IAAI,GAAhF,CAAC,QAAQ,EAAC,OAAO,EAAE,MAAM,EAAC,OAAO,EAAE,KAAK,EAAC,OAAO,EAAE,KAAK,EAAC,KAAK,QAAI;QACJ,OAAO,GAApE,CAAC,QAAQ,EAAC,OAAO,EAAE,MAAM,EAAC,OAAO,EAAE,KAAK,EAAC,KAAK,QAAI;QACb,UAAU,GAA/C,CAAC,KAAK,EAAC,KAAK,GAAC,SAAS,QAAI;QAER,eAAe,GAAjC,OAAO;OAkHjB;IA/GG;;;;;OAKG;IACH,8BAAyC;IAQnB,+BAA8C;IAmGxE;;;OAGG;IACH,cAFa,aAAa,CAIzB;IAED,cAMC;IAED,aAOC;;CACJ;8BA1KyD,mCAAmC;oBADzE,4BAA4B"}

package/src/engine/ui/DraggableAspect.js

@@ -17,6 +17,10 @@ import { PointerDevice, readPositionFromMouseEvent } from "../input/devices/Poin
  * @copyright Company Named Limited (c) 2026
  */
 export class DraggableAspect {
+    #started = false;
+    #cancelGesture = noop;
+    #handleCancel = event => this.#cancelGesture(event);
+
     /**
      *
      * @param {Object} options
@@ -24,9 +28,11 @@ export class DraggableAspect {
      * @param {(position:Vector2, event:Event)=>*} [options.dragStart=noop]
      * @param {(position:Vector2, origin:Vector2, delta:Vector2, event:Event)=>*} [options.drag=noop]
      * @param {(position:Vector2, origin:Vector2, event:Event)=>*} [options.dragEnd=noop]
+     * @param {(event:Event|undefined)=>*} [options.dragCancel=noop] called for a cancelled press or drag;
+     *   pointercancel/blur carries its event, while stop() carries undefined. Cancellation never commits dragEnd.
      * @param {boolean} [options.stopPropagation=true] prevent propagation of pointer events up the DOM tree
      */
-    constructor({ el, dragStart = noop, drag = noop, dragEnd = noop, stopPropagation = true }) {
+    constructor({ el, dragStart = noop, drag = noop, dragEnd = noop, dragCancel = noop, stopPropagation = true }) {
         /**
          *
          * @type {PointerDevice}
@@ -48,6 +54,41 @@ export class DraggableAspect {
 
         // top-left corner of `el` in client space, sampled when a drag gesture begins
         const frameOrigin = new Vector2();
+        let pressed = false;
+        let dragging = false;
+        let pointerId = null;
+        let stopDrag = null;
+
+        this.#cancelGesture = event => {
+            if (event?.type === 'pointercancel' && event.pointerId !== pointerId) return;
+            const pending = pressed || dragging;
+            pressed = dragging = false;
+            pointerId = null;
+            if (stopDrag !== null) {
+                pointerGlobal.on.up.remove(stopDrag);
+                stopDrag = null;
+            }
+            pointerGlobal.stop();
+            // An uncaptured pointer can be cancelled outside the local element. Clear its
+            // pending detector before the caller can stop the aspect in dragCancel.
+            if (pending && event?.type === 'pointercancel' && this.#started) {
+                this.pointerLocal.stop();
+                if (this.#started) this.pointerLocal.start();
+            }
+            if (pending) dragCancel(event);
+        };
+
+        this.pointerLocal.on.down.add((p, event) => {
+            if (pressed || dragging) return;
+            pressed = true;
+            pointerId = event.pointerId;
+        });
+        this.pointerLocal.on.globalUp.add((p, event) => {
+            if (!dragging && event.pointerId === pointerId) {
+                pressed = false;
+                pointerId = null;
+            }
+        });
 
         if (stopPropagation) {
             this.pointerLocal.on.down.add((p, e) => {
@@ -56,6 +97,8 @@ export class DraggableAspect {
         }
 
         this.pointerLocal.on.dragStart.add((p, event) => {
+            if (!pressed || dragging || event.pointerId !== pointerId) return;
+            dragging = true;
             // freeze the coordinate frame of `el` for the duration of the gesture
             if (typeof el.getBoundingClientRect === "function") {
                 const rect = el.getBoundingClientRect();
@@ -70,9 +113,14 @@ export class DraggableAspect {
             pointerGlobal.start();
 
             dragStart(p, event);
+            if (!dragging) return;
 
-            function stopDrag(endClientPosition, endEvent) {
+            stopDrag = (endClientPosition, endEvent) => {
+                if (endEvent.pointerId !== pointerId) return;
                 pointerGlobal.on.up.remove(stopDrag);
+                stopDrag = null;
+                pressed = dragging = false;
+                pointerId = null;
                 pointerGlobal.stop();
 
                 position.set(
@@ -81,12 +129,13 @@ export class DraggableAspect {
                 );
 
                 dragEnd(position, dragOriginalPosition, endEvent);
-            }
+            };
 
             pointerGlobal.on.up.add(stopDrag);
         });
 
         this.pointerGlobal.on.move.add((clientPosition, event, delta) => {
+            if (!dragging || event.pointerId !== pointerId) return;
             // the global device reports client coordinates, convert into the frozen frame of `el`
             position.set(
                 clientPosition.x - frameOrigin.x,
@@ -106,11 +155,19 @@ export class DraggableAspect {
     }
 
     start() {
+        this.#started = true;
         this.pointerLocal.start();
+        this.pointerLocal.domElement.addEventListener('pointercancel', this.#handleCancel);
+        window.addEventListener('pointercancel', this.#handleCancel);
+        window.addEventListener('blur', this.#handleCancel);
     }
 
     stop() {
+        this.#started = false;
+        this.pointerLocal.domElement.removeEventListener('pointercancel', this.#handleCancel);
+        window.removeEventListener('pointercancel', this.#handleCancel);
+        window.removeEventListener('blur', this.#handleCancel);
         this.pointerLocal.stop();
-        this.pointerGlobal.stop();
+        this.#cancelGesture();
     }
 }

package/src/format/image/avif/heif/ItemProperty.d.ts

@@ -137,7 +137,7 @@ export class ImageRotation {
     angle: number;
 }
 /**
- * `imir` — mirroring, applied after `clap` and before `irot`.
+ * `imir` — mirroring, applied after `clap` and `irot` in MIAF.
  */
 export class ImageMirror {
     static TYPE: string;

package/src/format/image/avif/heif/ItemProperty.js

@@ -184,7 +184,7 @@ export class ImageRotation {
 }
 
 /**
- * `imir` — mirroring, applied after `clap` and before `irot`.
+ * `imir` — mirroring, applied after `clap` and `irot` in MIAF.
  */
 export class ImageMirror {
     static TYPE = "imir";

package/src/format/image/png/chunk/png_chunk_decode_iTXt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"png_chunk_decode_iTXt.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/chunk/png_chunk_decode_iTXt.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6CAHW,UAAU,GACR,QAAQ;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,CA8CtG"}
+{"version":3,"file":"png_chunk_decode_iTXt.d.ts","sourceRoot":"","sources":["../../../../../../src/format/image/png/chunk/png_chunk_decode_iTXt.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,6CAHW,UAAU,GACR,QAAQ;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,CAwDtG"}

package/src/format/image/png/chunk/png_chunk_decode_iTXt.js

@@ -1,4 +1,5 @@
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { utf8_decode } from "../../../../core/binary/utf8/utf8_decode.js";
 import { png_inflate } from "../png_inflate.js";
 
 /**
@@ -16,20 +17,32 @@ export async function png_chunk_decode_iTXt(chunk) {
     const buffer = BinaryBuffer.fromArrayBuffer(chunk_buffer);
     buffer.position = chunk_byte_offset;
 
-    const keyword = buffer.readASCIICharacters(79, true);
+    const keyword = buffer.readASCIICharacters(80, true);
+    if (keyword.length > 79) {
+        throw new Error('iTXt keyword exceeds 79 bytes');
+    }
     const compression_flag = buffer.readUint8();
     const compression_method = buffer.readUint8();
 
 
     const language_tag = buffer.readASCIICharacters(Number.MAX_SAFE_INTEGER, true);
-    const translated_keyword = buffer.readASCIICharacters(Number.MAX_SAFE_INTEGER, true);
+    const translated_start = buffer.position - chunk_byte_offset;
+    let translated_end = translated_start;
+    while (translated_end < chunk_size && chunk[translated_end] !== 0) {
+        translated_end++;
+    }
+    if (translated_end >= chunk_size) {
+        throw new Error('iTXt translated keyword is not terminated');
+    }
+    const translated_keyword = utf8_decode(chunk, translated_start, translated_end);
+    buffer.position = chunk_byte_offset + translated_end + 1;
 
     const remaining_bytes = chunk_byte_end - buffer.position;
 
     let text;
 
     if (compression_flag === 0) {
-        text = buffer.readASCIICharacters(remaining_bytes);
+        text = utf8_decode(chunk, buffer.position - chunk_byte_offset, chunk_size);
     } else if (compression_flag === 1) {
 
         if (compression_method !== 0) {
@@ -38,9 +51,7 @@ export async function png_chunk_decode_iTXt(chunk) {
 
         const decoded = await png_inflate([new Uint8Array(buffer.data, buffer.position, remaining_bytes)]);
 
-        buffer.fromArrayBuffer(decoded.buffer);
-
-        text = buffer.readASCIICharacters(decoded.byteLength);
+        text = utf8_decode(decoded);
     } else {
         throw new Error(`Invalid compression flag value '${compression_flag}'`);
     }