@woosh/meep-engine 3.47.0 → 3.50.0

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

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { FLOAT32_MAX } from "../../../core/binary/FLOAT32_MAX.js";
 import LineBuilder from "../../../core/codegen/LineBuilder.js";
 
 // =========================================================================
@@ -7,7 +8,7 @@ import LineBuilder from "../../../core/codegen/LineBuilder.js";
 
 /**
  * @typedef {object} WgslType
- * @property {'primitive' | 'abstract' | 'vec' | 'mat' | 'array' | 'struct' | 'texture_2d' | 'sampler' | 'atomic' | 'unknown'} kind
+ * @property {'primitive' | 'abstract' | 'vec' | 'mat' | 'array' | 'struct' | 'texture' | 'sampler' | 'atomic' | 'unknown'} kind
  * @property {string} [name]
  * @property {number} [size]
  * @property {number} [cols]
@@ -15,6 +16,7 @@ import LineBuilder from "../../../core/codegen/LineBuilder.js";
  * @property {string} [scalar]
  * @property {WgslType} [element]
  * @property {number} [count]
+ * @property {1 | 2 | 3} [dimension] — of a texture: the size of what `textureDimensions` returns
  */
 
 const T_UNKNOWN = Object.freeze({ kind: 'unknown' });
@@ -33,6 +35,31 @@ const T_F32 = Object.freeze({ kind: 'primitive', name: 'f32' });
 const T_ABSTRACT_INT = Object.freeze({ kind: 'abstract', name: 'AbstractInt' });
 const T_ABSTRACT_FLOAT = Object.freeze({ kind: 'abstract', name: 'AbstractFloat' });
 
+/**
+ * Every WGSL texture type, by the number of components `textureDimensions` returns for it: a
+ * `u32` for 1D, a `vec2<u32>` for the 2D, array, cube and multisampled types, a `vec3<u32>` for 3D.
+ * @type {Object<string, 1 | 2 | 3>}
+ */
+const TEXTURE_DIMENSION = {
+    texture_1d: 1,
+    texture_storage_1d: 1,
+    texture_2d: 2,
+    texture_2d_array: 2,
+    texture_cube: 2,
+    texture_cube_array: 2,
+    texture_multisampled_2d: 2,
+    texture_external: 2,
+    texture_storage_2d: 2,
+    texture_storage_2d_array: 2,
+    texture_depth_2d: 2,
+    texture_depth_2d_array: 2,
+    texture_depth_cube: 2,
+    texture_depth_cube_array: 2,
+    texture_depth_multisampled_2d: 2,
+    texture_3d: 3,
+    texture_storage_3d: 3,
+};
+
 const VECTOR_ALIASES = {
     vec2i: { size: 2, scalar: 'i32' },
     vec3i: { size: 3, scalar: 'i32' },
@@ -55,10 +82,11 @@ const SWIZZLE_LETTERS = new Set(['x', 'y', 'z', 'w', 'r', 'g', 'b', 'a']);
 const SWIZZLE_INDEX = { x: 0, y: 1, z: 2, w: 3, r: 0, g: 1, b: 2, a: 3 };
 
 /**
- * Build a vec type alias name (e.g., {size:3, scalar:'f32'} → 'vec3f').
+ * Build a vec type alias name (e.g., {size:3, scalar:'f32'} → 'vec3f'). A `vec3<bool>` is the
+ * runtime's `vec3b`, which WGSL itself does not spell.
  */
 function vecAliasName(size, scalar) {
-    const suffix = { i32: 'i', u32: 'u', f32: 'f', f16: 'h' }[scalar] || 'f';
+    const suffix = { i32: 'i', u32: 'u', f32: 'f', f16: 'h', bool: 'b' }[scalar] || 'f';
     return `vec${size}${suffix}`;
 }
 
@@ -83,12 +111,25 @@ class Scope {
          * @type {Set<string>}
          */
         this.boxed = new Set();
+        /**
+         * The value of each abstract `const` declared here whose initializer folds, so a use of
+         * the name converts it at compile time as a use of the literal does.
+         * @type {Map<string, number>}
+         */
+        this.values = new Map();
     }
 
-    declare(name, type) {
+    /**
+     * @param {string} name
+     * @param {WgslType} type
+     * @param {number} [value] the folded value of an abstract `const`
+     */
+    declare(name, type, value) {
         this.symbols.set(name, type || T_UNKNOWN);
         this.pointers.delete(name);
         this.boxed.delete(name);
+        if (value !== undefined) this.values.set(name, value);
+        else this.values.delete(name);
     }
 
     /**
@@ -104,6 +145,7 @@ class Scope {
      */
     declarePointer(name, type, boxed) {
         this.symbols.set(name, type || T_UNKNOWN);
+        this.values.delete(name);
         this.pointers.add(name);
         if (boxed) this.boxed.add(name);
         else this.boxed.delete(name);
@@ -136,6 +178,16 @@ class Scope {
         return T_UNKNOWN;
     }
 
+    /**
+     * @param {string} name
+     * @returns {number | undefined} the folded value of `name`, as seen from here, if it is an abstract `const` that has one
+     */
+    lookupValue(name) {
+        if (this.symbols.has(name)) return this.values.get(name);
+        if (this.parent) return this.parent.lookupValue(name);
+        return undefined;
+    }
+
     push() {
         return new Scope(this);
     }
@@ -327,20 +379,12 @@ function classifyType(ident, args, template_list_node) {
         const inner = args.length > 0 ? args[0] : 'i32';
         return { kind: 'atomic', scalar: inner };
     }
-    // Texture types - 1D / 2D / 3D, sampled and storage variants. We
-    // collapse all of them to a single kind because the intrinsics in
-    // WGSLLanguageCore dispatch on the bound CPUBitmapData's
-    // `dimensionality`, not on the static WGSL type. (The 'texture_2d'
-    // kind label is preserved for backward compatibility with any
-    // downstream consumer that may grep for it.)
-    if (
-        ident === 'texture_2d' || ident === 'texture_storage_2d'
-        || ident === 'texture_1d' || ident === 'texture_storage_1d'
-        || ident === 'texture_3d' || ident === 'texture_storage_3d'
-        || ident === 'texture_2d_array'
-    ) {
+    // Texture types carry the dimension their declaration names. It is what `textureDimensions`
+    // answers with; the bound CPUBitmapData cannot say it, since a 1x1 bitmap is as much a
+    // texture_2d as a texture_1d.
+    if (TEXTURE_DIMENSION.hasOwnProperty(ident)) {
         const scalar = args.length > 0 ? args[0] : 'f32';
-        return { kind: 'texture_2d', scalar };
+        return { kind: 'texture', scalar, dimension: TEXTURE_DIMENSION[ident] };
     }
     if (ident === 'sampler') {
         return { kind: 'sampler' };
@@ -1135,7 +1179,7 @@ function collectGlobalValue(c, node) {
         type = keeps_abstract ? expr.type : concreteDefault(expr.type);
     }
 
-    c.scope.declare(name, type);
+    c.scope.declare(name, type, isAbstractType(type) ? expr.value : undefined);
     c.privateGlobals.push({
         name,
         kind: 'const',
@@ -1402,7 +1446,7 @@ function emitVariableOrValueStatement(c, node) {
         if (var_decl === null && isPointerExpression(c, expr_node)) {
             c.scope.declarePointer(name, type, false);
         } else {
-            c.scope.declare(name, type);
+            c.scope.declare(name, type, isAbstractType(type) ? expr.value : undefined);
         }
         c.out.add(`${kind} ${identToJs(name)} = ${value};`);
     } else {
@@ -1588,7 +1632,7 @@ function ownedValueCode(compiled) {
         case 'primitive':
         case 'abstract':
         case 'atomic':
-        case 'texture_2d':
+        case 'texture':
         case 'sampler':
             return compiled.code;
         default:
@@ -2054,10 +2098,10 @@ function compileExpressionAbstract(c, node) {
     if (u.type === 'template_elaborated_ident') {
         const ident = namedChildByType(u, 'ident');
         const name = ident !== null ? ident.text : u.text;
-        return { code: identToJs(name), type: c.scope.lookup(name), pointer_box: c.scope.isBoxedPointer(name) };
+        return { code: identToJs(name), type: c.scope.lookup(name), value: c.scope.lookupValue(name), pointer_box: c.scope.isBoxedPointer(name) };
     }
     if (u.type === 'ident') {
-        return { code: identToJs(u.text), type: c.scope.lookup(u.text), pointer_box: c.scope.isBoxedPointer(u.text) };
+        return { code: identToJs(u.text), type: c.scope.lookup(u.text), value: c.scope.lookupValue(u.text), pointer_box: c.scope.isBoxedPointer(u.text) };
     }
 
     c.error(u, `unsupported expression: ${u.type}`);
@@ -2277,10 +2321,16 @@ function concreteDefault(t) {
  * An abstract operand converted to the concrete scalar type it meets.
  *
  * Only a float target changes the value. An AbstractFloat becoming an f32 is rounded to one, and
- * so is an AbstractInt too large for f32 to hold. A literal is folded at compile time, and is
- * emitted unchanged when f32 holds it already, which most literals in a shader are. An integer
- * target changes nothing: an AbstractInt has the same value in i32 and u32, and an AbstractFloat
- * cannot meet an integer in a valid shader.
+ * so is an AbstractInt too large for f32 to hold. A literal, or a `const` initialized with one, is
+ * folded at compile time, and is emitted unchanged when f32 holds it already, which most literals
+ * in a shader are. An integer target changes nothing: an AbstractInt has the same value in i32 and
+ * u32, and an AbstractFloat cannot meet an integer in a valid shader.
+ *
+ * A folded value beyond the largest finite f32 is refused, as a device refuses it: WGSL makes that
+ * conversion a shader-creation error rather than a rounding, so `3.4028235e38` — the shortest
+ * decimal that names the largest f32 — does not compile where it meets an f32, although it would
+ * round to one. Rounding it here instead let ReSTIR DI's resample and spatial passes run under the
+ * emulator while neither compiled on a device.
  *
  * @param {{ code: string, type: WgslType, value?: number }} operand
  * @param {string} scalar the concrete scalar type's name
@@ -2295,6 +2345,9 @@ function convertAbstract(operand, scalar) {
         if (operand.value === undefined) {
             return { code: `wgsl.f32(${operand.code})`, type };
         }
+        if (!(Math.abs(operand.value) <= FLOAT32_MAX)) {
+            throw new Error(`WGSL compiler: value ${operand.value} cannot be represented as 'f32' (at ${JSON.stringify(operand.code)})`);
+        }
         const rounded = Math.fround(operand.value);
         return { code: rounded === operand.value ? operand.code : `(${rounded})`, type };
     }
@@ -2439,11 +2492,16 @@ function inferBinaryArithResultType(a, b) {
 
 /**
  * Pick the result type of a non-arithmetic binary op (comparison / logical / bitwise / shift).
- * Comparisons return bool; bitwise and shift preserve the leftmost known integer operand type.
+ * Comparisons return bool, or a `vec<bool>` of the operands' size when either is a vector, so a
+ * swizzle on the result indexes it; bitwise and shift preserve the leftmost known integer operand type.
  */
 function inferRawBinaryResultType(a, b, op) {
     const COMPARISON = new Set(['==', '!=', '<', '>', '<=', '>=']);
     const LOGICAL = new Set(['&&', '||']);
+    if (COMPARISON.has(op)) {
+        const vec = a && a.kind === 'vec' ? a : b && b.kind === 'vec' ? b : null;
+        if (vec !== null) return { kind: 'vec', size: vec.size, scalar: 'bool' };
+    }
     if (COMPARISON.has(op) || LOGICAL.has(op)) {
         return { kind: 'primitive', name: 'bool' };
     }
@@ -2475,6 +2533,7 @@ function compileUnaryExpression(c, node) {
             value: operand.value === undefined ? undefined : -operand.value,
         };
     }
+    if (prefix === '!' && operand.type && operand.type.kind === 'vec') return { code: `wgsl.logical_not(${operand.code})`, type: operand.type };
     if (prefix === '!') return { code: `!${operand.code}`, type: operand.type };
     if (prefix === '~') return { code: `wgsl.not(${operand.code})`, type: operand.type };
     if (prefix === '*' && operand.pointer_box === true) return { code: `${operand.code}.value`, type: operand.type };
@@ -2658,10 +2717,11 @@ function compileCallPhraseTyped(c, node) {
         }
         if (scalar === undefined) {
             // No explicit template — infer the component type from the arguments, mirroring
-            // WGSL's overload resolution. e.g. `vec4(some_u32)` is `vec4<u32>`, not `vec4<f32>`.
+            // WGSL's overload resolution. e.g. `vec4(some_u32)` is `vec4<u32>`, not `vec4<f32>`,
+            // and `vec2(a < b, c)` is a `vec2<bool>`.
             for (const a of arg_results) {
                 const t = a.type;
-                if (t && t.kind === 'primitive' && t.name !== 'bool') { scalar = t.name; break; }
+                if (t && t.kind === 'primitive') { scalar = t.name; break; }
                 if (t && (t.kind === 'vec' || t.kind === 'mat')) { scalar = t.scalar; break; }
             }
             if (scalar === undefined) scalar = 'f32';
@@ -2801,6 +2861,27 @@ function compileCallPhraseTyped(c, node) {
 
     // 9) WGSL builtins — best-effort type inference for common helpers.
     //
+    // `textureDimensions` answers with as many components as the texture's declaration has
+    // dimensions, which only the declaration says. A chunk compiled on its own may name a texture
+    // its importing shader declares; that compiles, and throws only if it runs.
+    if (callee_name === 'textureDimensions') {
+        const texture_type = arg_results[0] === undefined ? undefined : arg_results[0].type;
+
+        if (texture_type === undefined || texture_type.kind !== 'texture') {
+            const message = `textureDimensions: '${args[0]}' is not declared as a texture in this module, so its dimension is unknown`;
+
+            return {
+                code: `(() => { throw new Error(${JSON.stringify(message)}); })()`,
+                type: T_UNKNOWN,
+            };
+        }
+
+        return {
+            code: `wgsl.textureDimensions_${texture_type.dimension}d(${args.join(', ')})`,
+            type: inferBuiltinReturnType(callee_name, arg_results),
+        };
+    }
+
     // A few of them mean different things on i32 and on u32, and the operand type is the only
     // thing that says which — the same selection the arithmetic operators make.
     if (INTEGER_TYPED_BUILTIN.has(callee_name)) {
@@ -2835,7 +2916,8 @@ const INTEGER_TYPED_BUILTIN = new Set(['abs', 'firstLeadingBit', 'firstTrailingB
 
 /**
  * Element-wise builtins: the result has the type of the arguments. Most are vector-preserving
- * math; subgroupBroadcastFirst is not math, but has the same shape.
+ * math; subgroupBroadcastFirst is not math, but has the same shape. So have the derivatives, which
+ * the core refuses but a caller's core may answer.
  * @type {Set<string>}
  */
 const ELEMENT_WISE_BUILTIN = new Set([
@@ -2844,6 +2926,7 @@ const ELEMENT_WISE_BUILTIN = new Set([
     'pow', 'atan2', 'min', 'max', 'step', 'clamp', 'saturate', 'mix', 'smoothstep',
     'normalize', 'reflect', 'fma',
     'subgroupBroadcastFirst',
+    'dpdx', 'dpdy', 'fwidth', 'dpdxFine', 'dpdyFine', 'fwidthFine', 'dpdxCoarse', 'dpdyCoarse', 'fwidthCoarse',
 ]);
 
 /**
@@ -2902,7 +2985,11 @@ function inferBuiltinReturnType(name, args) {
         return { kind: 'vec', size: 4, scalar: 'f32' };
     }
     if (name === 'textureDimensions') {
-        return { kind: 'vec', size: 2, scalar: 'u32' };
+        const dimension = args[0].type.dimension;
+
+        return dimension === 1
+            ? { kind: 'primitive', name: 'u32' }
+            : { kind: 'vec', size: dimension, scalar: 'u32' };
     }
     if (name === 'atomicLoad') return { kind: 'primitive', name: 'i32' };
     if (name === 'unpack2x16unorm' || name === 'unpack2x16snorm' || name === 'unpack2x16float') {

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":";IAy/CA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IA6jDA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}

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

@@ -26,6 +26,18 @@ const FALLBACK_LINEAR_CLAMP_SAMPLER = Object.freeze({
  * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
  * @returns {number[]}
  */
+/**
+ * How many axes a texel coordinate addresses: a scalar for a 1D texture, a vector of the texture's
+ * dimension otherwise. WGSL makes a coordinate match the texture's declaration, so this is the
+ * declared dimension, where the bound bitmap only knows its size.
+ *
+ * @param {ArrayLike<number> | number} coords
+ * @returns {number}
+ */
+function coordinate_axis_count(coords) {
+    return typeof coords === 'number' ? 1 : coords.length;
+}
+
 function gather_texel_coord(coords, texture) {
     return [coords[0] * texture.size[0], coords[1] * texture.size[1]];
 }
@@ -83,6 +95,31 @@ function makeVec(TypedArrayCtor, size, args) {
     return out;
 }
 
+/**
+ * Build a `vec<bool>` as a plain `Array<boolean>`, the shape {@link binop_cmp} gives a vector
+ * comparison. Arguments are as for {@link makeVec}; each component converts as `bool(x)` does, so
+ * `vec2<bool>(vec2<f32>(0, 2))` is `[false, true]`.
+ *
+ * @param {number} size
+ * @param {*[]} args
+ * @returns {boolean[]}
+ */
+function makeBoolVec(size, args) {
+    const out = new Array(size).fill(false);
+    if (args.length === 1 && !is_vec(args[0])) {
+        return out.fill(!!args[0]);
+    }
+    let i = 0;
+    for (const a of args) {
+        if (is_vec(a)) {
+            for (let j = 0; j < a.length; j++) out[i++] = !!a[j];
+        } else {
+            out[i++] = !!a;
+        }
+    }
+    return out;
+}
+
 /**
  * Build a matrix constructor returning a typed array of `total_elements` entries. The returned
  * function accepts (a) no args → zero-filled, (b) `total_elements` scalars in column-major order,
@@ -370,6 +407,12 @@ export const WGSLLanguageCore = {
     vec3u: (...args) => makeVec(Uint32Array, 3, args),
     vec4u: (...args) => makeVec(Uint32Array, 4, args),
 
+    // vec<bool>, the Array<boolean> the comparison helpers return. WGSL has no `vec2b` alias; the
+    // compiler names these for `vec2<bool>`.
+    vec2b: (...args) => makeBoolVec(2, args),
+    vec3b: (...args) => makeBoolVec(3, args),
+    vec4b: (...args) => makeBoolVec(4, args),
+
     // ---------------------------------------------------------------------
     // Matrix constructors — column-major flat arrays. matCxR has C columns of R rows each,
     // for a total of C*R entries. Args may be scalars, column vectors, or a mix.
@@ -592,6 +635,8 @@ export const WGSLLanguageCore = {
 
     neg: (a) => unop(a, x => -x),
     not: (a) => unop(a, x => (~x) >>> 0),
+    // `!` on a vec<bool>; JS's raw `!` on the array is `false` whatever it holds
+    logical_not: (a) => unop(a, x => !x),
 
     // Bit-field extract / insert (WGSL §17.9). Component-wise over vectors; `offset` and
     // `count` are scalar u32 even when `e` / `newbits` are vectors, matching the WGSL
@@ -964,8 +1009,10 @@ export const WGSLLanguageCore = {
     },
 
     // ---------------------------------------------------------------------
-    // Texture intrinsics - backed by `CPUBitmapData` (1D / 2D / 3D inferred
-    // from the texture's `size`). Sampling routes through
+    // Texture intrinsics - backed by `CPUBitmapData`. A texture's dimension is the one its WGSL
+    // declaration names, never the bitmap's: a 1x1 bitmap may be bound to any texture type. The
+    // load and store builtins count the axes of their coordinate, and `textureDimensions` is
+    // compiled to the variant its declaration selects. Sampling routes through
     // `cpu_texture_sample`, which honours the bound `SamplerDescriptor`'s
     // address modes and filter. Mipmaps are not modelled (LOD 0 only) -
     // see cpu_texture_sample header for details.
@@ -974,8 +1021,8 @@ export const WGSLLanguageCore = {
     /**
      * `textureLoad(t, coords, level) -> vec4<T>`
      *
-     * Integer-coord fetch. `coords` is i32-vector matching the texture's
-     * dimensionality (1, 2, or 3 entries). Out-of-bounds reads return zero
+     * Integer-coord fetch. `coords` is a scalar for a texture_1d and a vector of the texture's
+     * dimension otherwise, so its length says which axes to bounds-check. Out-of-bounds reads return zero
      * across all channels (with alpha defaulting to 1.0 for textures with
      * fewer than 4 channels - matches WGSL semantics).
      *
@@ -992,9 +1039,9 @@ export const WGSLLanguageCore = {
     textureLoad(t, coords, _level_or_index = 0, _array_level = undefined) {
         assert.defined(t, 'texture');
         const out = new Float32Array(4);
-        const dim = t.dimensionality;
         // textureLoad on texture_1d takes a scalar i32 in WGSL (not vec1).
-        const x = (dim >= 1 ? (typeof coords === 'number' ? coords : coords[0]) : 0) | 0;
+        const dim = coordinate_axis_count(coords);
+        const x = (dim === 1 ? coords : coords[0]) | 0;
         const y = (dim >= 2 ? coords[1] : 0) | 0;
         /*
          Four arguments is the texture_2d_array form — (t, coords, array_index, level) — where the
@@ -1265,8 +1312,8 @@ export const WGSLLanguageCore = {
      * `textureStore(t, coords, value) -> ()`
      *
      * Integer-coord write into a storage texture. Out-of-bounds writes are
-     * silently dropped (WGSL semantics). `coords` length matches the
-     * texture dimensionality.
+     * silently dropped (WGSL semantics). `coords` is a scalar for a texture_storage_1d and a
+     * vector of the texture's dimension otherwise.
      *
      * Four arguments is the `texture_storage_2d_array` form — `(t, coords, array_index, value)` —
      * where the third argument selects the slice, stored along z as the sampling side reads it.
@@ -1282,8 +1329,8 @@ export const WGSLLanguageCore = {
             t.write(coords[0] | 0, coords[1] | 0, value_or_index | 0, array_value);
             return;
         }
-        const dim = t.dimensionality;
-        const x = (dim >= 1 ? (typeof coords === 'number' ? coords : coords[0]) : 0) | 0;
+        const dim = coordinate_axis_count(coords);
+        const x = (dim === 1 ? coords : coords[0]) | 0;
         const y = (dim >= 2 ? coords[1] : 0) | 0;
         const z = (dim >= 3 ? coords[2] : 0) | 0;
         t.write(x, y, z, value_or_index);
@@ -1292,23 +1339,44 @@ export const WGSLLanguageCore = {
     // CPUBitmapData models one stored mip level.
     textureNumLevels(_t) { return 1; },
 
+    /*
+     `textureDimensions(t, level)` comes in three variants, one per number of components it returns,
+     and the compiler picks the one the texture's declaration selects: `texture_1d` → `u32`; the 2D,
+     array, cube and multisampled types → `vec2<u32>`; `texture_3d` → `vec3<u32>`. The bound
+     bitmap's size cannot select it — a 1x1 `texture_2d` is still `vec2(1, 1)`.
+     */
+
     /**
-     * `textureDimensions(t, level) -> u32 | vec2<u32> | vec3<u32>`
-     *
-     * Returns the texture's size as a vector matching its dimensionality.
-     * 1D textures return a scalar `u32` in WGSL; we still hand back a
-     * length-1 Uint32Array so the calling shader can swizzle/index it
-     * uniformly with the multi-axis case.
-     *
+     * `textureDimensions` of a `texture_1d` or `texture_storage_1d`.
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
-     * @param {number} [_level]
+     * @param {number} [_level] - ignored, mipmaps are not modelled
+     * @returns {number}
+     */
+    textureDimensions_1d(t, _level = 0) {
+        assert.defined(t, 'texture');
+        return t.size[0];
+    },
+
+    /**
+     * `textureDimensions` of a 2D, array, cube or multisampled texture. An array texture's layers
+     * are not part of it.
+     * @param {import("./CPUBitmapData.js").CPUBitmapData} t
+     * @param {number} [_level] - ignored, mipmaps are not modelled
      * @returns {Uint32Array}
      */
-    textureDimensions(t, _level = 0) {
+    textureDimensions_2d(t, _level = 0) {
+        assert.defined(t, 'texture');
+        return new Uint32Array([t.size[0], t.size[1]]);
+    },
+
+    /**
+     * `textureDimensions` of a `texture_3d` or `texture_storage_3d`.
+     * @param {import("./CPUBitmapData.js").CPUBitmapData} t
+     * @param {number} [_level] - ignored, mipmaps are not modelled
+     * @returns {Uint32Array}
+     */
+    textureDimensions_3d(t, _level = 0) {
         assert.defined(t, 'texture');
-        const dim = t.dimensionality;
-        if (dim === 1) return new Uint32Array([t.size[0]]);
-        if (dim === 2) return new Uint32Array([t.size[0], t.size[1]]);
         return new Uint32Array([t.size[0], t.size[1], t.size[2]]);
     },
 

package/src/engine/network/transport/Channel.d.ts

@@ -1,85 +0,0 @@
-export class Channel {
-    /**
-     * @param {{
-     *   transport: { send(bytes: Uint8Array, length: number): void, onReceive: Signal },
-     *   max_in_flight?: number,
-     * }} options
-     *   `max_in_flight` hard-caps the number of unacked outgoing seqs. It exists
-     *   to keep the in-flight span well below the seq16 half-range (32768): once
-     *   an unacked seq falls more than half-range behind the newest sent, the
-     *   signed `seq16_distance` used for loss detection wraps and the entry can
-     *   neither be acked nor declared lost — a permanent leak (and a downstream
-     *   `seq_to_pending` leak in the orchestrator). Capping in-flight makes
-     *   that lap impossible. Default 1024 ≫ any realistic in-flight window
-     *   (RTT × send-rate) yet ≪ 32768. Only reached under a sustained one-way
-     *   stall, where eviction-as-lost is the correct verdict anyway.
-     */
-    constructor({ transport, max_in_flight }: {
-        transport: {
-            send(bytes: Uint8Array, length: number): void;
-            onReceive: Signal;
-        };
-        max_in_flight?: number;
-    });
-    /**
-     * @type {{ send(bytes: Uint8Array, length: number): void, onReceive: Signal }}
-     */
-    transport: {
-        send(bytes: Uint8Array, length: number): void;
-        onReceive: Signal;
-    };
-    /**
-     * Fired when an outgoing seq has been positively acknowledged by the peer.
-     * @type {Signal}
-     */
-    onPacketAcked: Signal;
-    /**
-     * Fired when an outgoing seq has aged out of the ack window without being acked.
-     * @type {Signal}
-     */
-    onPacketLost: Signal;
-    /**
-     * Fired when an inbound packet's payload is ready (header already stripped).
-     * Handler args: (payload: Uint8Array starting at offset 0, length: number).
-     * The Uint8Array is owned by the Channel and may be reused after the handler returns.
-     * @type {Signal}
-     */
-    onPayload: Signal;
-    /**
-     * Wrap and send a payload. Returns the seq number assigned to it.
-     *
-     * @param {Uint8Array} payload
-     * @param {number} length payload length in bytes
-     * @returns {number} seq
-     */
-    send(payload: Uint8Array, length: number): number;
-    /**
-     * Number of outgoing packets sent but not yet acked or marked lost.
-     * @returns {number}
-     */
-    unacked_count(): number;
-    /**
-     * Most recent seq received from the peer, or -1 if none yet.
-     * @returns {number}
-     */
-    latest_received_seq(): number;
-    /**
-     * Test-only: seed the next outgoing seq number. Used to fast-forward
-     * the seq counter so the seq16 wraparound can be exercised in
-     * unit tests without sending 65k packets. Do not call from production.
-     * @param {number} seq
-     */
-    seed_outgoing_seq_for_testing(seq: number): void;
-    /**
-     * Detach this Channel from its transport. The transport.onReceive subscription
-     * is removed so the Channel stops processing inbound bytes; the Channel's own
-     * Signals are left in place (callers usually hold no references to them after
-     * dispose, so they GC with the Channel). Required before discarding a Channel
-     * whose transport will be reused — otherwise the old Channel keeps consuming
-     * inbound packets in parallel with whatever replaces it.
-     */
-    dispose(): void;
-    #private;
-}
-import Signal from "../../../core/events/signal/Signal.js";
-//# sourceMappingURL=Channel.d.ts.map

package/src/engine/network/transport/Channel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Channel.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/Channel.js"],"names":[],"mappings":"AA6CA;IAWI;;;;;;;;;;;;;;OAcG;IACH,0CAdW;QACV,SAAa,EAAE;YAAE,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAC;QACpF,aAAiB,CAAC,EAAE,MAAM,CAAC;KACxB,EAuFH;IAnEG;;OAEG;IACH,WAFU;QAAE,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAEpD;IA6C1B;;;OAGG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,cAFU,MAAM,CAEgB;IAEhC;;;;;OAKG;IACH,WAFU,MAAM,CAEa;IAGjC;;;;;;OAMG;IACH,cAJW,UAAU,UACV,MAAM,GACJ,MAAM,CAiDlB;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,mCAFW,MAAM,QAIhB;IA+ED;;;;;;;OAOG;IACH,gBAEC;;CAiBJ;mBA9UkB,uCAAuC"}