@woosh/meep-engine 3.14.6 → 3.16.0

package/src/shade/renderer/shadow/map/SpotLightShadowmap.js

@@ -22,21 +22,9 @@ export class SpotLightShadowmap extends Shadowmap {
 
         assert.equal(camera.isPerspectiveCamera, true, 'spot shadow view must use a PerspectiveCamera');
 
-        // the camera keeps the authored f32-matrix Transform, so the two are copied across by
-        // component rather than by object
-        const light_transform = light.transform_global;
-
-        camera.transform.rotation.set(
-            light_transform.rotation_x,
-            light_transform.rotation_y,
-            light_transform.rotation_z,
-            light_transform.rotation_w
-        );
-        camera.transform.position.set(
-            light_transform.translation_x,
-            light_transform.translation_y,
-            light_transform.translation_z
-        );
+        // both sides are Transform64 now, so this is one buffer copy rather than a component-by-
+        // component transfer across two representations
+        camera.transform.copy(light.transform_global);
 
         camera.fov = light.angle * 2;
         camera.aspect = 1;

package/src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TetrahedronPointLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;GAWG;AACH;IAEI;;;;;;OAMG;IACH,YAFU,MAAM,CAEmB;IAEnC,+CAwCC;IAED,wBAGC;IAGL;;;;;OAKG;IACH,eAFU,OAAO,CAEqC;CARrD;0BAvEyB,gBAAgB"}
+{"version":3,"file":"TetrahedronPointLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;GAWG;AACH;IAEI;;;;;;OAMG;IACH,YAFU,MAAM,CAEmB;IAEnC,+CA6CC;IAED,wBAGC;IAGL;;;;;OAKG;IACH,eAFU,OAAO,CAEqC;CARrD;0BA7EyB,gBAAgB"}

package/src/shade/renderer/shadow/map/TetrahedronPointLightShadowmap.js

@@ -8,6 +8,7 @@ import {
     POINT_SHADOW_TETRA_FOV,
 } from "./POINT_SHADOW_TETRAHEDRON_LAYOUT.js";
 import { Shadowmap } from "./Shadowmap.js";
+import { t64_look_rotation } from "../../../../engine/ecs/transform/t64_look_rotation.js";
 
 /**
  * Tetrahedral point-light shadow map: the 4-frustum parallel to {@link PointLightShadowmap}.
@@ -57,10 +58,15 @@ export class TetrahedronPointLightShadowmap extends Shadowmap {
 
             assert.equal(camera.isPerspectiveCamera, true, 'tetra-shadow face must use a PerspectiveCamera');
 
-            camera.transform.position.set(px, py, pz);
-            camera.transform.rotation.lookRotation(
-                POINT_SHADOW_TETRA_FACE_FORWARDS[i],
-                POINT_SHADOW_TETRA_FACE_UPS[i]
+            camera.transform.setTranslation(px, py, pz);
+            t64_look_rotation(
+                camera.transform,
+                POINT_SHADOW_TETRA_FACE_FORWARDS[i][0],
+                POINT_SHADOW_TETRA_FACE_FORWARDS[i][1],
+                POINT_SHADOW_TETRA_FACE_FORWARDS[i][2],
+                POINT_SHADOW_TETRA_FACE_UPS[i][0],
+                POINT_SHADOW_TETRA_FACE_UPS[i][1],
+                POINT_SHADOW_TETRA_FACE_UPS[i][2]
             );
 
             // symmetric square frustum (see POINT_SHADOW_TETRA_FOV_DEGREES) — aspect 1 so the

package/src/shade/renderer/shadow/vsm/GPUViewShadowMaps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewShadowMaps.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js"],"names":[],"mappings":"AAYA;IAYI;;;;OAIG;IACH,uDAGC;IAED;;;OAGG;IACH,SAFU,mBAAmB,gBAAgB,CAAC,CAE1B;IAEpB;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,2BAAO;IA0CP,eAkBC;IAED,qBAEC;IAED,gBAEC;;CACJ;iCArHgC,uBAAuB"}
+{"version":3,"file":"GPUViewShadowMaps.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js"],"names":[],"mappings":"AAaA;IAYI;;;;OAIG;IACH,uDAGC;IAED;;;OAGG;IACH,SAFU,mBAAmB,gBAAgB,CAAC,CAE1B;IAEpB;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,2BAAO;IA8CP,eAkBC;IAED,qBAEC;IAED,gBAEC;;CACJ;iCA1HgC,uBAAuB"}

package/src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js

@@ -1,6 +1,7 @@
 import { GPUCameraContext } from "../../camera/GPUCameraContext.js";
 import { OrthographicCamera } from "../../camera/OrthographicCamera.js";
 import { VirtualShadowMap } from "./VirtualShadowMap.js";
+import { t64_look_rotation } from "../../../../engine/ecs/transform/t64_look_rotation.js";
 
 // const DEFAULT_VIRTUAL_RESOLUTION = 1024;
 const DEFAULT_VIRTUAL_RESOLUTION = 16384;
@@ -76,8 +77,12 @@ export class GPUViewShadowMaps {
         shadow_camera.top = 100;
         shadow_camera.bottom = -100;
 
-        shadow_camera.transform.position.set(0,-10,0);
-        shadow_camera.transform.rotation.lookRotation(light.direction);
+        shadow_camera.transform.setTranslation(0, -10, 0);
+        t64_look_rotation(
+            shadow_camera.transform,
+            light.direction[0], light.direction[1], light.direction[2],
+            0, 1, 0
+        );
 
         const context = new GPUCameraContext(this.#device, shadow_camera);
 

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -286,7 +286,7 @@ export class GPUViewVolumetrics {
         const direction = sun.forward;
 
         const view_matrix = camera.view_matrix;
-        const position = camera.transform.position;
+        const position = camera.transform;
 
         // the medium lives in the froxel grid and the grid stops here, so there is nothing to
         // integrate past it
@@ -307,7 +307,7 @@ export class GPUViewVolumetrics {
                 ws_to_uvw: this.#sun_shadow_ws_to_uvw[cascade],
                 uvw_to_ws: this.#sun_shadow_uvw_to_ws[cascade],
                 light_direction: [direction.x, direction.y, direction.z],
-                camera_position: [position.x, position.y, position.z],
+                camera_position: [position.translation_x, position.translation_y, position.translation_z],
                 camera_forward,
                 fov_y: camera.fov,
                 aspect: camera.aspect,

package/src/shade/renderer/volumetrics/ParticipatingMediaVolume.d.ts

@@ -98,10 +98,10 @@ export class ParticipatingMediaVolume {
     /**
      * Defines actual scale, orientation and world position of the volume.
      * The base size of the volume is 1, centered at 0,0,0
-     * @type {Transform}
+     * @type {Transform64}
      */
-    transform: Transform;
+    transform: Transform64;
     #private;
 }
-import { Transform } from "../../../engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 //# sourceMappingURL=ParticipatingMediaVolume.d.ts.map

package/src/shade/renderer/volumetrics/ParticipatingMediaVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMediaVolume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/ParticipatingMediaVolume.js"],"names":[],"mappings":"AAKA;IA6EI;;;;OAIG;IACH,+BAHW;QAAC,wBAAwB,CAAC;QAAC,wBAAwB,CAAC;QAAC,MAAM,CAAC;QAAC,CAAC,CAAA;KAAC,GAC9D,uBAAuB,CAalC;IAED,oDAIC;IAlGD;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,UAAQ;IAER,iCAIC;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAOjC;IAED;;;;;aA0BC;IAED;;;OAGG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAOnB;CAyBJ;AAED,6EAKI;AAIJ;IAII,iBAEC;IAED;;;OAGG;IACH,aAFU,MAAM,EAAE,CAEM;IACxB,0BAA4B;IAC5B,uBAAyB;IAEzB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,uBAFU,MAAM,EAAE,CAEgB;IAElC;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,gBAAc;IAEd;;;;;;;;;OASG;IACH,mCAEC;IAED,uCAA+E;IAE/E;;;;;;OAMG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,WAFU,SAAS,CAES;;CAE/B;0BAzLyB,4CAA4C"}
+{"version":3,"file":"ParticipatingMediaVolume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/ParticipatingMediaVolume.js"],"names":[],"mappings":"AAKA;IA6EI;;;;OAIG;IACH,+BAHW;QAAC,wBAAwB,CAAC;QAAC,wBAAwB,CAAC;QAAC,MAAM,CAAC;QAAC,CAAC,CAAA;KAAC,GAC9D,uBAAuB,CAalC;IAED,oDAIC;IAlGD;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,UAAQ;IAER,iCAIC;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAOjC;IAED;;;;;aA0BC;IAED;;;OAGG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAOnB;CAyBJ;AAED,6EAKI;AAIJ;IAII,iBAEC;IAED;;;OAGG;IACH,aAFU,MAAM,EAAE,CAEM;IACxB,0BAA4B;IAC5B,uBAAyB;IAEzB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,uBAFU,MAAM,EAAE,CAEgB;IAElC;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,gBAAc;IAEd;;;;;;;;;OASG;IACH,mCAEC;IAED,uCAA+E;IAE/E;;;;;;OAMG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,WAFU,WAAW,CAES;;CAEjC;4BAzL2B,8CAA8C"}

package/src/shade/renderer/volumetrics/ParticipatingMediaVolume.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
 import { rgb_to_luminance } from "../../../core/color/rgb_to_luminance.js";
-import { Transform } from "../../../engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 
 export class VolumetricsParticleSpec {
     /**
@@ -182,8 +182,8 @@ export class ParticipatingMediaVolume {
     /**
      * Defines actual scale, orientation and world position of the volume.
      * The base size of the volume is 1, centered at 0,0,0
-     * @type {Transform}
+     * @type {Transform64}
      */
-    transform = new Transform();
+    transform = new Transform64();
 
 }

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

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

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

@@ -383,6 +383,16 @@ const ARITHMETIC_OP = {
 
 const RAW_BINARY_OPS = new Set(['<', '>', '<=', '>=', '==', '!=', '&&', '||', '&', '|', '^', '<<', '>>']);
 
+/**
+ * Arithmetic operators that wrap at 32 bits when WGSL types the result as an integer. Mapped to the
+ * helper-name prefix; the scalar type (`u32` / `i32`) is appended at the call site.
+ */
+const INTEGER_WRAPPING_OP = {
+    '+': 'add',
+    '-': 'sub',
+    '*': 'mul',
+};
+
 // =========================================================================
 // Compiler context — central state during compilation
 // =========================================================================
@@ -972,7 +982,20 @@ function emitEntryWrapper(c) {
         }
     }
 
-    c.out.add(`return ${c.entry.name}(${param_names.join(', ')});`);
+    if (is_compute && c.workgroupVars.length > 0) {
+        // The lanes of one workgroup are dispatched one call at a time, and a scalar
+        // `var<workgroup>` a lane assigns lives in the module-scope slot above — a copy of the
+        // state object's field, not the field. Writing it back is what lets the next lane see it,
+        // which is the whole point of workgroup memory (an array slot already persists, since the
+        // slot holds a reference and the lane mutates it in place).
+        c.out.add(`const __result__ = ${c.entry.name}(${param_names.join(', ')});`);
+        for (const wv of c.workgroupVars) {
+            c.out.add(`__workgroup__.${wv.name} = ${wv.name};`);
+        }
+        c.out.add('return __result__;');
+    } else {
+        c.out.add(`return ${c.entry.name}(${param_names.join(', ')});`);
+    }
 
     c.out.dedent();
     c.out.add('}');
@@ -1139,6 +1162,19 @@ function emitVariableUpdatingStatement(c, node) {
             c.out.add(emitWriteStatement(lhs_compiled, `wgsl.${arith[op_text]}(${lhs_compiled.code}, ${rhs_compiled.code})`));
             return;
         }
+
+        // Bitwise / shift compound assignment, routed like the binary operators: through the
+        // element-wise helpers for a vec/mat or bool LHS (raw JS coerces a typed array to NaN and
+        // a bool to 0/1), and for `>>=` on u32 (JS `>>` sign-extends).
+        const bitwise_helper = BITWISE_HELPER[op_text.slice(0, -1)];
+        if (bitwise_helper !== undefined && (
+            isContainerType(lhs_compiled.type)
+            || isScalarBool(lhs_compiled.type)
+            || (op_text === '>>=' && (isScalarUnsigned(lhs_compiled.type) || isScalarUnsigned(rhs_compiled.type)))
+        )) {
+            c.out.add(emitWriteStatement(lhs_compiled, `wgsl.${bitwise_helper}(${lhs_compiled.code}, ${rhs_compiled.code})`));
+            return;
+        }
         c.out.add(`${lhs_compiled.code} ${op_text} ${rhs_compiled.code};`);
         return;
     }
@@ -1648,9 +1684,19 @@ function compileBinaryExpression(c, node, op_type, mode) {
             if (op_text === '/' && integerDivision(left, right)) {
                 actual_helper = 'idiv';
             }
+            // WGSL `+` / `-` / `*` on integer types wrap at 32 bits. JS numbers don't, and the bits
+            // an overflowing f64 drops are the low ones — which silently ruins hashes and PRNGs
+            // (see the wrapping helpers in WGSLLanguageCore.js). Route to the wrapping variant only
+            // when the result type is *known* to be an integer, so anything untyped or float keeps
+            // the plain helper.
+            const arith_type = inferBinaryArithResultType(left.type, right.type);
+            const wrapping = INTEGER_WRAPPING_OP[op_text];
+            if (wrapping !== undefined && isIntegerType(arith_type)) {
+                actual_helper = `${wrapping}_${integerScalarName(arith_type)}`;
+            }
             return {
                 code: `wgsl.${actual_helper}(${left.code}, ${right.code})`,
-                type: inferBinaryArithResultType(left.type, right.type),
+                type: arith_type,
                 // arithmetic on two AbstractInts is still AbstractInt: `(1 + 2) / 2` is 1
                 abstract_int: left.abstract_int === true && right.abstract_int === true,
             };
@@ -1658,11 +1704,13 @@ function compileBinaryExpression(c, node, op_type, mode) {
     }
 
     // Bitwise (`&` / `|` / `^`) and shift (`<<` / `>>`) operators. Routed through element-wise
-    // helpers for vec/mat operands (JS raw operators coerce typed arrays to NaN), AND for `>>`
-    // on u32 scalars — JS's signed `>>` sign-extends, but WGSL u32 shift is logical.
+    // helpers for vec/mat operands (JS raw operators coerce typed arrays to NaN), for bool
+    // operands (raw JS yields 0/1 where WGSL yields a bool), AND for `>>` on u32 scalars — JS's
+    // signed `>>` sign-extends, but WGSL u32 shift is logical.
     const bitwise_helper = BITWISE_HELPER[op_text];
     if (bitwise_helper !== undefined) {
-        if (isContainerType(left.type) || isContainerType(right.type)) {
+        if (isContainerType(left.type) || isContainerType(right.type)
+            || isScalarBool(left.type) || isScalarBool(right.type)) {
             return {
                 code: `wgsl.${bitwise_helper}(${left.code}, ${right.code})`,
                 type: inferRawBinaryResultType(left.type, right.type, op_text),
@@ -1722,6 +1770,17 @@ function isScalarUnsigned(t) {
     return t && t.kind === 'primitive' && t.name === 'u32';
 }
 
+/** True if `t` is a bool scalar — WGSL `&` / `|` / `^` on bools are logical and stay bool. */
+function isScalarBool(t) {
+    return t && t.kind === 'primitive' && t.name === 'bool';
+}
+
+/** The scalar name (`u32` / `i32`) of an integer type, for picking a wrapping arithmetic helper. */
+function integerScalarName(t) {
+    if (t.kind === 'primitive') return t.name;
+    return t.scalar;
+}
+
 /** True if `t` is an integer type (scalar or vec/mat of i32/u32). */
 function isIntegerType(t) {
     if (!t) return false;
@@ -2135,6 +2194,8 @@ function inferBuiltinReturnType(name, args) {
         'exp', 'exp2', 'log', 'log2', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan',
         'pow', 'atan2', 'min', 'max', 'step', 'clamp', 'saturate', 'mix', 'smoothstep',
         'normalize', 'reflect', 'fma',
+        // not math, but the same shape: the result has the type of its one argument
+        'subgroupBroadcastFirst',
     ]);
     if (ELEMENT_WISE.has(name)) {
         for (const a of args) {

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

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA0PA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAm+Bd"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA0PA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAkgCd"}

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

@@ -468,13 +468,30 @@ export const WGSLLanguageCore = {
     // The compiler routes `/` through `idiv` when both operands' tracked types are integer.
     idiv: (a, b) => binop(a, b, (x, y) => Math.trunc(x / y)),
 
+    // WGSL integer arithmetic wraps at 32 bits; JS numbers grow instead. Without wrapping, any
+    // hash or PRNG that multiplies by a large odd constant leaves the u32 range within a step or
+    // two, and once the f64 mantissa runs out it is the *low* bits that fall off — exactly the
+    // ones an output permutation exists to mix. A generator would then collapse into a short cycle
+    // under emulation while being perfectly well distributed on device.
+    //
+    // The compiler routes `+` / `-` / `*` here only when the result type is known to be an integer,
+    // so float math never reaches these.
+    add_u32: (a, b) => binop(a, b, (x, y) => (x + y) >>> 0),
+    sub_u32: (a, b) => binop(a, b, (x, y) => (x - y) >>> 0),
+    mul_u32: (a, b) => binop(a, b, (x, y) => Math.imul(x, y) >>> 0),
+
+    add_i32: (a, b) => binop(a, b, (x, y) => (x + y) | 0),
+    sub_i32: (a, b) => binop(a, b, (x, y) => (x - y) | 0),
+    mul_i32: (a, b) => binop(a, b, (x, y) => Math.imul(x, y) | 0),
+
     // Element-wise bitwise / shift helpers. JS's raw `&` / `|` / `^` / `<<` / `>>` work on
     // scalars but not typed arrays (they coerce the array to a number → NaN), so the compiler
     // routes vec/mat operands through these. Right-shift uses `>>>` (unsigned) to match WGSL
-    // u32 semantics; signed sources should bitcast first.
-    bit_and: (a, b) => binop(a, b, (x, y) => (x & y) >>> 0),
-    bit_or:  (a, b) => binop(a, b, (x, y) => (x | y) >>> 0),
-    bit_xor: (a, b) => binop(a, b, (x, y) => (x ^ y) >>> 0),
+    // u32 semantics; signed sources should bitcast first. On bools (WGSL's non-short-circuit
+    // logical `&` / `|` / `^`) the result stays a bool rather than JS's 0/1.
+    bit_and: (a, b) => binop(a, b, (x, y) => typeof x === 'boolean' ? x && y : (x & y) >>> 0),
+    bit_or:  (a, b) => binop(a, b, (x, y) => typeof x === 'boolean' ? x || y : (x | y) >>> 0),
+    bit_xor: (a, b) => binop(a, b, (x, y) => typeof x === 'boolean' ? x !== y : (x ^ y) >>> 0),
     shl:     (a, b) => binop(a, b, (x, y) => (x << y) >>> 0),
     shr:     (a, b) => binop(a, b, (x, y) => x >>> y),
 
@@ -1162,6 +1179,20 @@ export const WGSLLanguageCore = {
     // modelled as the values they name. The barrier half is the no-op above.
     workgroupUniformLoad(value) { return value; },
 
+    // ---------------------------------------------------------------------
+    // Subgroups — one invocation at a time, so the subgroup is that invocation.
+    // ---------------------------------------------------------------------
+    //
+    // `subgroupBroadcastFirst(e)` returns `e` from the lowest active invocation of the subgroup. Run
+    // pointwise there is exactly one, so the answer is the caller's own value — which is also the
+    // only value a shader can soundly rely on it for: one that broadcasts something its lanes
+    // disagree on has made its result depend on which lane the hardware counts as first, and no
+    // CPU model reproduces that. The rest of the family — ballots, reductions, shuffles — stays
+    // unsupported on purpose: a reduction over one lane would pass tests a real wave fails, which
+    // is worse than throwing.
+
+    subgroupBroadcastFirst(value) { return value; },
+
     // ---------------------------------------------------------------------
     // Fragment-stage derivatives — unsupported because we run a single pixel.
     // ---------------------------------------------------------------------

package/src/view/minimap/Minimap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Minimap.d.ts","sourceRoot":"","sources":["../../../../src/view/minimap/Minimap.js"],"names":[],"mappings":";AAgBA;IAGI;;;;;;OAMG;IACH,yFAFW,+BAA6B,EA8IvC;IArJD,YAAkD;IAY9C;;;OAGG;IACH,sCAAkC;IAWpB,OAFJ,SAAS,CAEiC;IAepD,uBAAyB;IAML,eAFV,iBAAiB,EAAE,CAEc;IA+B3C,+BAAyF;IA+BzE,uBAA2C;IAyC/D;;;;;;;OAOG;IACH,cAUC;CAmCJ;iBAlNgB,YAAY;sBAXP,iCAAiC;sBAUjC,0BAA0B;kCAEd,4BAA4B;+BAV/B,oCAAoC;8BAMrC,6CAA6C"}
+{"version":3,"file":"Minimap.d.ts","sourceRoot":"","sources":["../../../../src/view/minimap/Minimap.js"],"names":[],"mappings":";AAgBA;IAGI;;;;;;OAMG;IACH,yFAFW,+BAA6B,EAgJvC;IAvJD,YAAkD;IAY9C;;;OAGG;IACH,sCAAkC;IAWpB,OAFJ,SAAS,CAEiC;IAepD,uBAAyB;IAML,eAFV,iBAAiB,EAAE,CAEc;IAiC3C,+BAA2F;IA+B3E,uBAA2C;IAyC/D;;;;;;;OAOG;IACH,cAUC;CAmCJ;iBApNgB,YAAY;sBAXP,iCAAiC;sBAUjC,0BAA0B;kCAEd,4BAA4B;+BAV/B,oCAAoC;8BAMrC,6CAA6C"}