@woosh/meep-engine 3.14.1 → 3.14.3

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

@@ -18,6 +18,7 @@ import LineBuilder from "../../../core/codegen/LineBuilder.js";
  */
 
 const T_UNKNOWN = Object.freeze({ kind: 'unknown' });
+const T_I32 = Object.freeze({ kind: 'primitive', name: 'i32' });
 
 const VECTOR_ALIASES = {
     vec2i: { size: 2, scalar: 'i32' },
@@ -1098,9 +1099,10 @@ function emitVariableOrValueStatement(c, node) {
 
     if (expr_node !== null) {
         const expr = compileExpression(c, expr_node);
-        // Infer the type from the RHS when no explicit annotation is present.
+        // Infer the type from the RHS when no explicit annotation is present. A bare integer
+        // literal concretises to i32 here, as WGSL does for `let x = 3;`.
         if (type === T_UNKNOWN || type.kind === 'unknown') {
-            type = expr.type;
+            type = expr.abstract_int === true ? T_I32 : expr.type;
         }
         c.scope.declare(name, type);
         c.out.add(`${kind} ${name} = ${expr.code};`);
@@ -1296,9 +1298,14 @@ function emitForInitInline(c, node) {
         const ident = namedChildByType(opt_ident, 'ident');
         const type_spec = namedChildByType(opt_ident, 'type_specifier');
         const name = ident.text;
-        const type = type_spec !== null ? parseTypeSpecifier(type_spec) : T_UNKNOWN;
+        const init = expr_node !== null ? compileExpression(c, expr_node) : null;
+        let type = type_spec !== null ? parseTypeSpecifier(type_spec) : T_UNKNOWN;
+        if (type.kind === 'unknown' && init !== null) {
+            // `for (var i = 0; ...)`: a bare integer literal concretises to i32, as in a `let`
+            type = init.abstract_int === true ? T_I32 : init.type;
+        }
         c.scope.declare(name, type);
-        const value = expr_node !== null ? compileExpression(c, expr_node).code : defaultValueForType(type);
+        const value = init !== null ? init.code : defaultValueForType(type);
         // `var i = …` (mutable, common in `for (var i = 0; ...; i = i + 1)`) → JS `let`.
         // `let i = …` / `const i = …` (immutable) → JS `const`.
         const kind = var_decl !== null ? 'let' : 'const';
@@ -1560,12 +1567,15 @@ function compileExpression(c, node) {
 
     // Primary subkinds
     if (u.type === 'literal' || u.type === 'int_literal' || u.type === 'float_literal' || u.type === 'bool_literal') {
-        return { code: literalToJs(u.text), type: literalType(u.text) };
+        // A bare integer literal is WGSL's AbstractInt. Its concrete type comes from context this
+        // compiler does not track, so the type stays unknown, but operator selection still needs
+        // to know it is an integer: see integerDivision().
+        return { code: literalToJs(u.text), type: literalType(u.text), abstract_int: isBareIntLiteral(u.text) };
     }
     if (u.type === 'paren_expression') {
         const inner = namedChildByType(u, 'expression');
         const e = compileExpression(c, inner);
-        return { code: `(${e.code})`, type: e.type };
+        return { code: `(${e.code})`, type: e.type, abstract_int: e.abstract_int };
     }
     if (u.type === 'call_expression') {
         const call_phrase = namedChildByType(u, 'call_phrase');
@@ -1631,16 +1641,18 @@ function compileBinaryExpression(c, node, op_type, mode) {
                 const dispatched = dispatchMatrixMul(left, right);
                 if (dispatched !== null) return dispatched;
             }
-            // WGSL `/` on integer types is truncated integer division. Detect when both
-            // operands' tracked types are integer (i32 / u32 scalars or matching int vecs)
-            // and route through the integer-truncating helper; otherwise use float div.
+            // WGSL `/` on integer types is truncated integer division. Route through the
+            // integer-truncating helper when WGSL would type the division as integer;
+            // otherwise use float div.
             let actual_helper = helper;
-            if (op_text === '/' && bothOperandsInteger(left.type, right.type)) {
+            if (op_text === '/' && integerDivision(left, right)) {
                 actual_helper = 'idiv';
             }
             return {
                 code: `wgsl.${actual_helper}(${left.code}, ${right.code})`,
                 type: inferBinaryArithResultType(left.type, right.type),
+                // arithmetic on two AbstractInts is still AbstractInt: `(1 + 2) / 2` is 1
+                abstract_int: left.abstract_int === true && right.abstract_int === true,
             };
         }
     }
@@ -1710,15 +1722,29 @@ function isScalarUnsigned(t) {
     return t && t.kind === 'primitive' && t.name === 'u32';
 }
 
-/** True if both operands are integer-typed (scalar or vec of i32/u32). */
-function bothOperandsInteger(a, b) {
-    const isInt = (t) => {
-        if (!t) return false;
-        if (t.kind === 'primitive') return t.name === 'i32' || t.name === 'u32';
-        if (t.kind === 'vec' || t.kind === 'mat') return t.scalar === 'i32' || t.scalar === 'u32';
-        return false;
-    };
-    return isInt(a) && isInt(b);
+/** True if `t` is an integer type (scalar or vec/mat of i32/u32). */
+function isIntegerType(t) {
+    if (!t) return false;
+    if (t.kind === 'primitive') return t.name === 'i32' || t.name === 'u32';
+    if (t.kind === 'vec' || t.kind === 'mat') return t.scalar === 'i32' || t.scalar === 'u32';
+    return false;
+}
+
+/** True if the literal's spelling is a bare integer: no suffix, no fraction, no exponent. */
+function isBareIntLiteral(text) {
+    return /^(0[xX][0-9a-fA-F]+|[0-9]+)$/.test(text.trim());
+}
+
+/**
+ * True if WGSL evaluates `left / right` as integer division. Both operands integer-typed is the
+ * obvious case. A bare literal is AbstractInt and takes the other operand's integer type, so
+ * `index / 3` truncates; two bare literals divide as AbstractInt, so `7 / 2` is 3 even where an
+ * f32 is expected. Negation and parentheses keep a literal abstract: `index / -3` and
+ * `index / (3)` truncate too.
+ */
+function integerDivision(left, right) {
+    const isInt = (operand) => isIntegerType(operand.type) || operand.abstract_int === true;
+    return isInt(left) && isInt(right);
 }
 
 /**
@@ -1827,7 +1853,7 @@ function compileUnaryExpression(c, node) {
 
     const operand = compileExpression(c, named[named.length - 1]);
 
-    if (prefix === '-') return { code: `wgsl.neg(${operand.code})`, type: operand.type };
+    if (prefix === '-') return { code: `wgsl.neg(${operand.code})`, type: operand.type, abstract_int: operand.abstract_int };
     if (prefix === '!') return { code: `!${operand.code}`, type: operand.type };
     if (prefix === '~') return { code: `wgsl.not(${operand.code})`, type: operand.type };
     if (prefix === '*' || prefix === '&') return { code: operand.code, type: operand.type };
@@ -1853,7 +1879,9 @@ function compileSingularExpression(c, node) {
         type = next.type;
     }
 
-    return { code, type };
+    // a bare literal reached through a singular expression is still AbstractInt; anything with an
+    // access specifier on it is not a literal
+    return { code, type, abstract_int: named.length === 1 ? head_result.abstract_int : undefined };
 }
 
 /**

package/src/avif/encode_image_source.d.ts

@@ -1,70 +0,0 @@
-/**
- * Encoding one image source, whichever side of a worker boundary it happens on.
- *
- * The encoder is meep's own, under `./native` — pure JavaScript, synchronous and portable — so the
- * same two functions serve the worker pool and the fallback for environments that have no workers.
- * Keeping them here rather than in the worker is what stops the two paths from drifting apart.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-/**
- * The effort a caller's `speed` asks for.
- *
- * `speed` is the dial the WebAssembly encoder took: zero is slowest and best, ten is fastest. The
- * native encoder names three points on that curve instead of eleven, because those are the three
- * that measure differently; this maps one onto the other so that existing callers keep meaning what
- * they meant.
- *
- * @param {number} [speed] `0 .. 10`
- * @returns {number} one of the `EFFORT_*` constants
- */
-export function effort_of_speed(speed?: number): number;
-/**
- * An encode context to hand back to the functions below.
- *
- * One per worker, or one per process for the inline path: it holds the planes and contexts an
- * encode needs, and reusing it is what keeps a run of encodes from allocating a fresh set each time.
- *
- * @returns {Av1EncodeContext}
- */
-export function create_encoder(): Av1EncodeContext;
-/**
- * Encode an image bitmap.
- *
- * Needs a canvas to read the bitmap's samples back out — a bitmap is an opaque handle, and drawing
- * it is the only way to see it. That is a platform capability rather than a codec one, which is why
- * this is the operation that can be unavailable where the other cannot.
- *
- * @param {{bitmap: ImageBitmap, quality: number, speed: (number|undefined)}} request the bitmap is
- *   closed once it has been read
- * @param {Av1EncodeContext} encoder
- * @returns {ArrayBuffer}
- */
-export function encode_bitmap_source(request: {
-    bitmap: ImageBitmap;
-    quality: number;
-    speed: (number | undefined);
-}, encoder: Av1EncodeContext): ArrayBuffer;
-/**
- * Encode a sampler.
- *
- * Half float samplers are taken as linear light in the renderer's normalisation and coded through
- * the PQ transfer function; eight bit ones are coded as ordinary sRGB. Which of the two it is comes
- * from the data itself, so it survives being posted to a worker.
- *
- * @param {{data: TypedArray, width: number, height: number, item_size: number, quality: number,
- *   speed: (number|undefined)}} request
- * @param {Av1EncodeContext} encoder
- * @returns {ArrayBuffer}
- */
-export function encode_sampler_source(request: {
-    data: TypedArray;
-    width: number;
-    height: number;
-    item_size: number;
-    quality: number;
-    speed: (number | undefined);
-}, encoder: Av1EncodeContext): ArrayBuffer;
-import { Av1EncodeContext } from './native/av1/encode/Av1EncodeContext.js';
-//# sourceMappingURL=encode_image_source.d.ts.map

package/src/avif/encode_image_source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encode_image_source.d.ts","sourceRoot":"","sources":["../../../src/avif/encode_image_source.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AAEH;;;;;;;;;;GAUG;AACH,wCAHW,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;GAOG;AACH,kCAFa,gBAAgB,CAI5B;AAED;;;;;;;;;;;GAWG;AACH;YALoB,WAAW;aAAW,MAAM;WAAS,CAAC,MAAM,GAAC,SAAS,CAAC;YAEhE,gBAAgB,GACd,WAAW,CA6BvB;AAED;;;;;;;;;;;GAWG;AACH;;WALqC,MAAM;YAAU,MAAM;eAAa,MAAM;aAAW,MAAM;WACnF,CAAC,MAAM,GAAC,SAAS,CAAC;YACnB,gBAAgB,GACd,WAAW,CAUvB;iCApHgC,yCAAyC"}

package/src/avif/encode_image_source.js

@@ -1,117 +0,0 @@
-import { Av1EncodeContext } from './native/av1/encode/Av1EncodeContext.js';
-import { EFFORT_BALANCED, EFFORT_FAST, EFFORT_THOROUGH, apply_effort } from './native/av1/encode/encode_effort.js';
-import { encode_avif } from './native/api/encode_avif.js';
-import { sampler2d_to_avif } from './native/api/sampler2d_to_avif.js';
-
-/**
- * Encoding one image source, whichever side of a worker boundary it happens on.
- *
- * The encoder is meep's own, under `./native` — pure JavaScript, synchronous and portable — so the
- * same two functions serve the worker pool and the fallback for environments that have no workers.
- * Keeping them here rather than in the worker is what stops the two paths from drifting apart.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-/**
- * The effort a caller's `speed` asks for.
- *
- * `speed` is the dial the WebAssembly encoder took: zero is slowest and best, ten is fastest. The
- * native encoder names three points on that curve instead of eleven, because those are the three
- * that measure differently; this maps one onto the other so that existing callers keep meaning what
- * they meant.
- *
- * @param {number} [speed] `0 .. 10`
- * @returns {number} one of the `EFFORT_*` constants
- */
-export function effort_of_speed(speed) {
-    if (speed === undefined) {
-        return EFFORT_BALANCED;
-    }
-
-    if (speed <= 2) {
-        return EFFORT_THOROUGH;
-    }
-
-    if (speed <= 7) {
-        return EFFORT_BALANCED;
-    }
-
-    return EFFORT_FAST;
-}
-
-/**
- * An encode context to hand back to the functions below.
- *
- * One per worker, or one per process for the inline path: it holds the planes and contexts an
- * encode needs, and reusing it is what keeps a run of encodes from allocating a fresh set each time.
- *
- * @returns {Av1EncodeContext}
- */
-export function create_encoder() {
-    return new Av1EncodeContext();
-}
-
-/**
- * Encode an image bitmap.
- *
- * Needs a canvas to read the bitmap's samples back out — a bitmap is an opaque handle, and drawing
- * it is the only way to see it. That is a platform capability rather than a codec one, which is why
- * this is the operation that can be unavailable where the other cannot.
- *
- * @param {{bitmap: ImageBitmap, quality: number, speed: (number|undefined)}} request the bitmap is
- *   closed once it has been read
- * @param {Av1EncodeContext} encoder
- * @returns {ArrayBuffer}
- */
-export function encode_bitmap_source(request, encoder) {
-    const { bitmap, quality, speed } = request;
-
-    if (typeof OffscreenCanvas === 'undefined') {
-        bitmap.close();
-
-        throw new Error('encoding an ImageBitmap needs OffscreenCanvas, which this environment does not have');
-    }
-
-    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
-    const context = canvas.getContext('2d');
-
-    context.drawImage(bitmap, 0, 0);
-
-    const image_data = context.getImageData(0, 0, canvas.width, canvas.height);
-
-    bitmap.close();
-
-    apply_effort(encoder, effort_of_speed(speed));
-
-    const file = encode_avif({
-        data: image_data.data,
-        width: image_data.width,
-        height: image_data.height
-    }, { quality: Math.ceil(quality * 100) }, encoder);
-
-    return file.buffer;
-}
-
-/**
- * Encode a sampler.
- *
- * Half float samplers are taken as linear light in the renderer's normalisation and coded through
- * the PQ transfer function; eight bit ones are coded as ordinary sRGB. Which of the two it is comes
- * from the data itself, so it survives being posted to a worker.
- *
- * @param {{data: TypedArray, width: number, height: number, item_size: number, quality: number,
- *   speed: (number|undefined)}} request
- * @param {Av1EncodeContext} encoder
- * @returns {ArrayBuffer}
- */
-export function encode_sampler_source(request, encoder) {
-    const { data, width, height, item_size, quality, speed } = request;
-
-    apply_effort(encoder, effort_of_speed(speed));
-
-    const file = sampler2d_to_avif({ data, width, height, itemSize: item_size }, quality, {}, encoder);
-
-    return file.buffer;
-}

package/src/avif/encoder_worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoder_worker.d.ts","sourceRoot":"","sources":["../../../src/avif/encoder_worker.js"],"names":[],"mappings":""}

package/src/avif/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./native/index.js";
-export { decode_avif as decode } from "./native/api/decode_avif.js";
-export { encode_avif as encode } from "./native/api/encode_avif.js";
-export { ThreadedImageEncoder, get_threaded_image_encoder } from "./threaded_image_encoder.js";
-//# sourceMappingURL=index.d.ts.map

package/src/avif/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/avif/index.js"],"names":[],"mappings":""}

package/src/avif/index.js

@@ -1,21 +0,0 @@
-/**
- * AVIF, as meep does it.
- *
- * The codec is `./native`: pure JavaScript, synchronous, no WebAssembly and no worker of its own.
- * This is its public face, plus the pool dispatcher for callers that would rather not encode on the
- * thread they are on.
- *
- * `decode` and `encode` keep the names the WebAssembly wrappers used, and hand back the same shapes
- * — a decode is `{ data, width, height }`. They are synchronous now, which an `await` on the result
- * does not notice; a caller holding one as a promise does.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-export * from './native/index.js';
-
-export { decode_avif as decode } from './native/api/decode_avif.js';
-export { encode_avif as encode } from './native/api/encode_avif.js';
-
-export { ThreadedImageEncoder, get_threaded_image_encoder } from './threaded_image_encoder.js';