@woosh/meep-engine 3.41.0 → 3.43.0

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}'`);
     }

package/src/shade/device/mock/SoftwareGPUDevice.d.ts

@@ -38,10 +38,8 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase implements GPUDevic
      * @param {GPUFeatureName[]} [descriptor.requiredFeatures] optional features to enable, from
      * {@link SUPPORTED_OPTIONAL_FEATURES}. Asking for one this device cannot emulate throws, as
      * `requestDevice` rejects for one the adapter does not have.
-     * @param {Partial<GPUSupportedLimits>} [descriptor.requiredLimits] limits to report instead of
-     * the defaults. Only *worse* values are accepted — see {@link build_limits}. Lowering one is how
-     * a test reaches the clamping paths the renderer takes on a small device without allocating
-     * anything large.
+     * @param {Partial<GPUSupportedLimits>} [descriptor.requiredLimits] requested limits; worse-than-default
+     * requests preserve the defaults, and unsupported better requests are refused
      */
     constructor(descriptor?: {
         label?: string;

package/src/shade/device/mock/SoftwareGPUDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AAsQA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;;;OAUG;IACH;QAT+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAyBrC;IAzDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAmCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAmJD;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;;;;;OAOG;IACH,kEAUC;IAkCD;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WA/sBa,mBAAiB,IAAI;;sCArQG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}
+{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AA+QA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;OAQG;IACH;QAP+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAuBrC;IAvDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAiCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAmJD;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;;;;;OAOG;IACH,kEAUC;IAkCD;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WA7sBa,mBAAiB,IAAI;;sCA9QG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}

package/src/shade/device/mock/SoftwareGPUDevice.js

@@ -87,11 +87,11 @@ const LIMIT_NAMES = Object.keys(DEFAULT_LIMITS);
 /**
  * Build the limits one device reports.
  *
- * An override may only make a limit *worse*, which is the direction `requestDevice` allows to
- * succeed: asking for a limit better than the adapter supports rejects there, and granting one here
- * would let a test pass against a device no hardware offers. "Better" is larger for a `max*` limit
- * and smaller for a `min*` one — the alignment limits are minimums, and a device that permitted a
- * *smaller* alignment would hide exactly the misalignment bugs those limits exist to catch.
+ * Like `requestDevice`, requests worse than the defaults leave those defaults in place.
+ * This software device supports the default capabilities, so a better request is refused.
+ * "Better" means larger for maximum limits and smaller for minimum alignment limits.
+ *
+ * @see https://gpuweb.github.io/gpuweb/#dom-gpuadapter-requestdevice
  *
  * @param {Partial<GPUSupportedLimits>} [overrides]
  * @returns {GPUSupportedLimits} frozen, as a real one is read-only
@@ -100,13 +100,23 @@ function build_limits(overrides = {}) {
     const limits = { ...DEFAULT_LIMITS };
 
     for (const [name, value] of Object.entries(overrides)) {
+        if (value === undefined) {
+            continue;
+        }
         if (!LIMIT_NAMES.includes(name)) {
-            throw new TypeError(
-                `SoftwareGPUDevice: '${name}' is not a GPUSupportedLimits member`
+            throw new DOMException(
+                `SoftwareGPUDevice: '${name}' is not a GPUSupportedLimits member`,
+                'OperationError'
             );
         }
 
         const is_minimum = name.startsWith('min');
+        if (is_minimum && (!Number.isInteger(Math.log2(value)) || value >= 2 ** 32)) {
+            throw new DOMException(
+                `SoftwareGPUDevice: required alignment limit ${name}=${value} must be a power of two less than 2^32`,
+                'OperationError'
+            );
+        }
         const better = is_minimum
             ? value < DEFAULT_LIMITS[name]
             : value > DEFAULT_LIMITS[name];
@@ -118,7 +128,6 @@ function build_limits(overrides = {}) {
             );
         }
 
-        limits[name] = value;
     }
 
     return Object.freeze(limits);
@@ -332,10 +341,8 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase {
      * @param {GPUFeatureName[]} [descriptor.requiredFeatures] optional features to enable, from
      * {@link SUPPORTED_OPTIONAL_FEATURES}. Asking for one this device cannot emulate throws, as
      * `requestDevice` rejects for one the adapter does not have.
-     * @param {Partial<GPUSupportedLimits>} [descriptor.requiredLimits] limits to report instead of
-     * the defaults. Only *worse* values are accepted — see {@link build_limits}. Lowering one is how
-     * a test reaches the clamping paths the renderer takes on a small device without allocating
-     * anything large.
+     * @param {Partial<GPUSupportedLimits>} [descriptor.requiredLimits] requested limits; worse-than-default
+     * requests preserve the defaults, and unsupported better requests are refused
      */
     constructor(descriptor = {}) {
         super(descriptor);
@@ -990,4 +997,4 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase {
  * @readonly
  * @type {boolean}
  */
-SoftwareGPUDevice.prototype.isSoftwareGPUDevice = true;
+SoftwareGPUDevice.prototype.isSoftwareGPUDevice = true;

package/src/shade/playground/skinned_blas_refit/sweep_views.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sweep_views.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/sweep_views.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;GAYG;AACH;IAX6B,QAAQ;IACC,MAAM;IAClB,KAAK;IACJ,MAAM,EAAtB,MAAM;IAC4B,OAAO,UAAhC,OAAO,KAAG,IAAI;IACN,QAAQ,GAAzB,MAAM;IACa,UAAU,GAA7B,MAAM,EAAE;IACS,QAAQ,GAAzB,MAAM;IACW,OAAO,GAAxB,MAAM;IACJ,QAAQ,MAAM,CAAC,CAwG3B"}
+{"version":3,"file":"sweep_views.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/sweep_views.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;GAYG;AACH;IAX6B,QAAQ;IACC,MAAM;IAClB,KAAK;IACJ,MAAM,EAAtB,MAAM;IAC4B,OAAO,UAAhC,OAAO,KAAG,IAAI;IACN,QAAQ,GAAzB,MAAM;IACa,UAAU,GAA7B,MAAM,EAAE;IACS,QAAQ,GAAzB,MAAM;IACW,OAAO,GAAxB,MAAM;IACJ,QAAQ,MAAM,CAAC,CAyG3B"}

package/src/shade/playground/skinned_blas_refit/sweep_views.js

@@ -61,6 +61,7 @@ export async function sweep_views({
 
     const kept = {
         position: [...camera.transform.translation],
+        rotation: [...camera.transform.rotation],
         near: camera.near,
         far: camera.far,
     };
@@ -108,7 +109,7 @@ export async function sweep_views({
     }
 
     camera.transform.setTranslation(...kept.position);
-    camera.transform.lookAt(centre);
+    camera.transform.setRotation(...kept.rotation);
     camera.near = kept.near;
     camera.far = kept.far;
 

package/src/shade/playground/vgeo_runtime/README.md

@@ -46,10 +46,11 @@ and drawn, and its sub-pixel jitter does not move the cut: the τ table below is
 and off. The environment is not awaited — `test_assets/` is gitignored, so a checkout without it
 gets the sun alone and still draws every triangle the cut selected.
 
-**Not the GPU sky, and that is worth writing down.** `renderer/atmosphere/GPUSky.js` and
-`view/GPUViewSkyContext.js` would be the natural source for this and are **not reachable**: nothing
-in the engine constructs either, `GPUSceneContext` has no `sky` for `GPUViewSkyContext.update` to
-ask for, and `Renderer` does not mention the atmosphere at all. Reviving it is not a playground's
+**Not the GPU sky, and that is worth writing down.** `view/GPUViewSkyContext.js` would be the
+natural source for this and is **not reachable**: nothing in the engine constructs it, and `Renderer`
+does not mention the atmosphere. (`GPUSceneContext.sky` is real now -- the scene's `GPUSky`, whose
+transmittance and multiple-scattering LUTs the volumetrics read -- but those are look-up tables, not
+the convolved environment this would need.) Reviving the sky as a light source is not a playground's
 change — the sky produces an already-convolved GPU texture with `SPHERE_PROBE_MIPMAP_LEVELS` mips,
 while `GPULightCollection` builds its environment privately from a CPU `ShadeTexture` and convolves
 a full mip chain itself, so the two do not meet without a new way to hand that class a GPU-side

package/src/shade/playground/water_refraction/README.md

@@ -23,14 +23,12 @@ below-interface view. The grazing camera stays over the submerged floor.
 
 Water is an entity with `Water`, `MeshletGeometry` and `Transform64`. The mesh authors the outline
 and elevations, and the transform places it; Level edits the transform's height. This fixture
-has a curved, coarse authored outline. Optical controls edit Water. Optional WaterWaves supplies wind
-forcing to a persistent shared GPU displacement atlas, with 128² samples per active body. The existing
-geometry BLAS bakes the authored footprint into a simulation mask when a wave row is created;
-dry samples remain zero, including holes and gaps. Vertices sample the field in local xz and move
-along local y. This primitive simulation therefore expects a surface that can be represented as a
-height field in local xz; multiple stacked surfaces sharing that domain also share its displacement.
-Calm meshes allocate no grid. The simulation uses a one-metre reference depth and
-does not infer bathymetry from the mesh. Screen reflections can be disabled while retaining the
+has a curved, coarse authored outline. Optical controls edit Water. Optional WaterWaves sets the wind:
+the body's waves are a fetch-limited JONSWAP sea over its own extent along the wind, drawn from 18
+spectral bands every body shares, plus the wave particles of its splashes, which reflect off the mesh's
+outline (`WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md`). Vertices sample both in the body's metric local
+frame and move in it; deep water is assumed, and nothing is inferred from bathymetry. A body with a
+triangle too steep to flatten onto a reference plane stays calm. Screen reflections can be disabled while retaining the
 fallback to the renderer's indirect lighting (IBL, or Brick4 when it is the active mode).
 The Newton, bounded HZB traversal, and undisplaced control modes all use the same AVBOIT path.
 The Medium select picks one of the water presets (`shade/renderer/medium/water/water_presets.js`):
@@ -162,8 +160,8 @@ tiny-loss resolve guard; existing particle, mesh and ribbon APIs remain intact.
 Water bodies occupy persistent rows in the existing scene database. Optical and component edits
 queue CPU writes; idle updates do not enumerate bodies. GPU page iteration, the existing prefix
 scan, ordered meshlet expansion and indirect draws cover the scene. A GPU reduction supplies signed
-local-y displacement bounds after each simulation update. Body frustum culling expands the authored
-bounds by those extrema before applying the GPU world transform.
+local-y and horizontal displacement bounds every frame. Body frustum culling expands the authored
+bounds by them before applying the GPU world transform.
 
 Following Far Cry 5's view-tile approach, each candidate triangle classifies its swept footprint into
 view tiles. A tile contains 16×16 cells; `settings.tessellation_pixels` sets their reference-view spacing
@@ -181,7 +179,8 @@ against the view planes. Calm bodies project the authored triangles directly. Re
 when displacement can bring them into view. Opaque depth is tested after displacement, so an
 undisplaced depth rejection cannot hide a crest. Both surface passes share the same patch counts
 and reconstruction inputs. Simulation is independent of camera position and render resolution;
-wave dispatch count depends on fixed steps, not the number of bodies. Device buffer and indirect
+the spectral bands cost the same for any number of bodies, and particles are dispatched from their
+GPU count. Device buffer and indirect
 draw limits still bound scene complexity. If the reference is coplanar with the camera, it moves
 farther beyond the displacement envelope to retain a projectable surface. The body's conservative
 swept span sets one shared grid spacing, at least the requested pixel spacing. This bounds each