typegpu 0.12.6 → 0.12.8

package/std/packing.js

@@ -96,7 +96,7 @@ export const unpack4x8unorm = dualImpl({
         return vec4f(reader.readUint8() / 255, reader.readUint8() / 255, reader.readUint8() / 255, reader.readUint8() / 255);
     },
     signature: { argTypes: [u32], returnType: vec4f },
-    codegenImpl: (_ctx, [e]) => stitch `unpack4x8unorm(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('unpack4x8unorm', [], [e]),
     sideEffects: false,
 });
 /**
@@ -110,7 +110,7 @@ export const unpack4x8snorm = dualImpl({
         return vec4f(Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1));
     },
     signature: { argTypes: [u32], returnType: vec4f },
-    codegenImpl: (_ctx, [e]) => stitch `unpack4x8snorm(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('unpack4x8snorm', [], [e]),
     sideEffects: false,
 });
 /**
@@ -124,7 +124,7 @@ export const unpack4xI8 = dualImpl({
         return vec4i(reader.readInt8(), reader.readInt8(), reader.readInt8(), reader.readInt8());
     },
     signature: { argTypes: [u32], returnType: vec4i },
-    codegenImpl: (_ctx, [e]) => stitch `unpack4xI8(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('unpack4xI8', [], [e]),
     sideEffects: false,
 });
 /**
@@ -138,7 +138,7 @@ export const unpack4xU8 = dualImpl({
         return vec4u(reader.readUint8(), reader.readUint8(), reader.readUint8(), reader.readUint8());
     },
     signature: { argTypes: [u32], returnType: vec4u },
-    codegenImpl: (_ctx, [e]) => stitch `unpack4xU8(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('unpack4xU8', [], [e]),
     sideEffects: false,
 });
 /**
@@ -182,7 +182,7 @@ export const pack4x8unorm = dualImpl({
         writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.w, 0, 1)));
     }),
     signature: { argTypes: [vec4f], returnType: u32 },
-    codegenImpl: (_ctx, [e]) => stitch `pack4x8unorm(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('pack4x8unorm', [], [e]),
     sideEffects: false,
 });
 /**
@@ -198,7 +198,7 @@ export const pack4x8snorm = dualImpl({
         writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.w, -1, 1)));
     }),
     signature: { argTypes: [vec4f], returnType: u32 },
-    codegenImpl: (_ctx, [e]) => stitch `pack4x8snorm(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('pack4x8snorm', [], [e]),
     sideEffects: false,
 });
 /**
@@ -214,7 +214,7 @@ export const pack4xI8 = dualImpl({
         writer.writeInt8(e.w);
     }),
     signature: { argTypes: [vec4i], returnType: u32 },
-    codegenImpl: (_ctx, [e]) => stitch `pack4xI8(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('pack4xI8', [], [e]),
     sideEffects: false,
 });
 /**
@@ -230,7 +230,7 @@ export const pack4xU8 = dualImpl({
         writer.writeUint8(e.w);
     }),
     signature: { argTypes: [vec4u], returnType: u32 },
-    codegenImpl: (_ctx, [e]) => stitch `pack4xU8(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('pack4xU8', [], [e]),
     sideEffects: false,
 });
 /**
@@ -246,7 +246,7 @@ export const pack4xI8Clamp = dualImpl({
         writer.writeInt8(clampScalar(e.w, -128, 127));
     }),
     signature: { argTypes: [vec4i], returnType: u32 },
-    codegenImpl: (_ctx, [e]) => stitch `pack4xI8Clamp(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('pack4xI8Clamp', [], [e]),
     sideEffects: false,
 });
 /**
@@ -262,6 +262,6 @@ export const pack4xU8Clamp = dualImpl({
         writer.writeUint8(clampScalar(e.w, 0, 255));
     }),
     signature: { argTypes: [vec4u], returnType: u32 },
-    codegenImpl: (_ctx, [e]) => stitch `pack4xU8Clamp(${e})`,
+    codegenImpl: (ctx, [e]) => ctx.gen.emitCall('pack4xU8Clamp', [], [e]),
     sideEffects: false,
 });

package/std/texture.d.ts

@@ -61,8 +61,8 @@ declare function textureStoreCpu<T extends textureStorage3d>(texture: T, coords:
 export declare const textureStore: import("../types.ts").DualFn<typeof textureStoreCpu>;
 declare function textureDimensionsCpu<T extends texture1d | textureStorage1d>(texture: T): number;
 declare function textureDimensionsCpu<T extends texture1d>(texture: T, level: number): number;
-declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureStorage2d | textureStorage2dArray | textureExternal>(texture: T): v2u;
-declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray>(texture: T, level: number): v2u;
+declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureMultisampled2d | textureDepth2d | textureDepth2dArray | textureDepthCube | textureDepthCubeArray | textureDepthMultisampled2d | textureStorage2d | textureStorage2dArray | textureExternal>(texture: T): v2u;
+declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureDepth2d | textureDepth2dArray | textureDepthCube | textureDepthCubeArray>(texture: T, level: number): v2u;
 declare function textureDimensionsCpu<T extends texture3d | textureStorage3d>(texture: T): v3u;
 declare function textureDimensionsCpu<T extends texture3d>(texture: T, level: number): v3u;
 export declare const textureDimensions: import("../types.ts").DualFn<typeof textureDimensionsCpu>;

package/tgpuLogger.d.ts

@@ -1,4 +1,4 @@
-declare const warningTypes: readonly ["deprecated", "suspicious", "fallback", "precision-loss", "implicit-conversion", "webgpu-feature-missing", "webgpu-limits-exceeded", "locations-mismatched", "log-limit-exceeded", "external-omitted", "uniform-schema-misaligned"];
+declare const warningTypes: readonly ["deprecated", "suspicious", "fallback", "precision-loss", "implicit-conversion", "webgpu-feature-missing", "webgpu-limits-exceeded", "log-limit-exceeded", "external-omitted", "uniform-schema-misaligned"];
 type WarningType = (typeof warningTypes)[number];
 interface Logger {
     warn(type: WarningType, ...args: unknown[]): void;

package/tgpuLogger.js

@@ -7,7 +7,6 @@ const warningTypes = [
     'implicit-conversion',
     'webgpu-feature-missing',
     'webgpu-limits-exceeded',
-    'locations-mismatched',
     'log-limit-exceeded',
     'external-omitted',
     'uniform-schema-misaligned',
@@ -21,7 +20,6 @@ export class TgpuLogger {
             this.#initialEnabledWarnings = [
                 'webgpu-feature-missing',
                 'webgpu-limits-exceeded',
-                'locations-mismatched',
                 'log-limit-exceeded',
                 'external-omitted',
             ];

package/tgsl/accessIndex.js

@@ -1,10 +1,11 @@
 import { stitch } from "../core/resolve/stitch.js";
-import { isDisarray, MatrixColumnsAccess } from "../data/dataTypes.js";
+import { isDisarray } from "../data/dataTypes.js";
+import { MatrixColumnsAccess } from "../data/matrixColumnsAccess.js";
 import { derefSnippet } from "../data/ref.js";
 import { snip } from "../data/snippet.js";
 import { vec2f, vec3f, vec4f } from "../data/vector.js";
-import { isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { isKnownAtComptime } from "../types.js";
+import { isPtr, isVec, isWgslArray } from "../data/wgslTypes.js";
+import { asComptime } from "../types.js";
 import { accessProp } from "./accessProp.js";
 import { ArrayExpression, coerceToSnippet } from "./generationHelpers.js";
 const indexableTypeToResult = {
@@ -12,46 +13,46 @@ const indexableTypeToResult = {
     mat3x3f: vec3f,
     mat4x4f: vec4f,
 };
+function deriveIndexAccessOrigin(targetOrigin, indexOrigin) {
+    if (targetOrigin === 'constant-immutable-def') {
+        // Constant refs stay const unless the index forces runtime materialization
+        return indexOrigin === 'constant' || indexOrigin === 'constant-immutable-def'
+            ? 'constant-immutable-def'
+            : 'runtime-immutable-def';
+    }
+    if (targetOrigin === 'constant') {
+        // Ephemeral constants indexed with constants stay constant, otherwise they become runtime-known
+        return indexOrigin === 'constant' || indexOrigin === 'constant-immutable-def'
+            ? 'constant'
+            : 'runtime';
+    }
+    // Fallthrough
+    return targetOrigin;
+}
 export function accessIndex(target, indexArg) {
     const index = typeof indexArg === 'number' ? coerceToSnippet(indexArg) : indexArg;
+    const knownIndex = asComptime(index);
     // array
     if (isWgslArray(target.dataType) || isDisarray(target.dataType)) {
         const elementType = target.dataType.elementType;
-        let origin;
-        if (target.origin === 'constant-immutable-def') {
-            // Constant refs stay const unless the element/index forces runtime materialization
-            origin =
-                index.origin === 'constant' || index.origin === 'constant-immutable-def'
-                    ? 'constant-immutable-def'
-                    : 'runtime-immutable-def';
-        }
-        else if (target.origin === 'constant') {
-            // Ephemeral constants indexed with constants stay constant, otherwise they become runtime-known
-            origin =
-                index.origin === 'constant' || index.origin === 'constant-immutable-def'
-                    ? 'constant'
-                    : 'runtime';
-        }
-        else {
-            // Fallthrough
-            origin = target.origin;
-        }
-        if (target.value instanceof ArrayExpression && isKnownAtComptime(index)) {
-            return target.value.elements[index.value];
+        if (target.value instanceof ArrayExpression && knownIndex) {
+            return target.value.elements[knownIndex.value];
         }
-        return snip(isKnownAtComptime(target) && isKnownAtComptime(index)
+        const origin = deriveIndexAccessOrigin(target.origin, index.origin);
+        const knownTarget = knownIndex && asComptime(target);
+        return snip(knownTarget && knownIndex
             ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, it's there
-                target.value[index.value]
+                knownTarget.value[knownIndex.value]
             : stitch `${target}[${index}]`, elementType, 
         /* origin */ origin, target.possibleSideEffects || index.possibleSideEffects);
     }
     // vector
     if (isVec(target.dataType)) {
-        return snip(isKnownAtComptime(target) && isKnownAtComptime(index)
+        const knownTarget = knownIndex && asComptime(target);
+        return snip(knownTarget && knownIndex
             ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, it's there
-                target.value[index.value]
-            : stitch `${target}[${index}]`, target.dataType.primitive, 
-        /* origin */ target.origin, target.possibleSideEffects || index.possibleSideEffects);
+                knownTarget.value[knownIndex.value]
+            : stitch `${target}[${index}]`, target.dataType.primitive, deriveIndexAccessOrigin(target.origin, index.origin), target.possibleSideEffects || index.possibleSideEffects);
     }
     if (isPtr(target.dataType)) {
         // Sometimes values that are typed as pointers aren't instances of `d.ref`, so we
@@ -61,23 +62,21 @@ export function accessIndex(target, indexArg) {
     // matrix.columns
     if (target.value instanceof MatrixColumnsAccess) {
         const propType = indexableTypeToResult[target.value.matrix.dataType.type];
-        return snip(stitch `${target.value.matrix}[${index}]`, propType, 
-        /* origin */ target.origin, target.possibleSideEffects || index.possibleSideEffects);
+        return snip(stitch `${target.value.matrix}[${index}]`, propType, deriveIndexAccessOrigin(target.origin, index.origin), target.possibleSideEffects || index.possibleSideEffects);
     }
     // matrix
     if (target.dataType.type in indexableTypeToResult) {
         throw new Error("The only way of accessing matrix elements in TypeGPU functions is through the 'columns' property.");
     }
-    if (isKnownAtComptime(target) && isKnownAtComptime(index)) {
+    const knownTarget = knownIndex && asComptime(target);
+    if (knownTarget && knownIndex) {
         // No idea what the type is, so we act on the snippet's value and try to guess
         return coerceToSnippet(
         // oxlint-disable-next-line typescript/no-explicit-any -- we're inspecting the value, and it could be any value
-        target.value[index.value]);
+        knownTarget.value[knownIndex.value]);
     }
-    if (isWgslStruct(target.dataType) &&
-        isKnownAtComptime(index) &&
-        typeof index.value === 'string') {
-        return accessProp(target, index.value);
+    if (typeof knownIndex?.value === 'string') {
+        return accessProp(target, knownIndex.value);
     }
     return undefined;
 }

package/tgsl/accessProp.js

@@ -1,13 +1,14 @@
 import { stitch } from "../core/resolve/stitch.js";
 import { AutoStruct } from "../data/autoStruct.js";
 import { EntryInputRouter } from "../core/function/entryInputRouter.js";
-import { isUnstruct, MatrixColumnsAccess, UnknownData } from "../data/dataTypes.js";
+import { isUnstruct, UnknownData } from "../data/dataTypes.js";
+import { MatrixColumnsAccess } from "../data/matrixColumnsAccess.js";
 import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
 import { derefSnippet } from "../data/ref.js";
 import { isSnippet, snip } from "../data/snippet.js";
 import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from "../data/vector.js";
 import { isMat, isPtr, isVec, isWgslArray, isWgslStruct, } from "../data/wgslTypes.js";
-import { isKnownAtComptime } from "../types.js";
+import { asComptime } from "../types.js";
 import { coerceToSnippet, numericLiteralToSnippet } from "./generationHelpers.js";
 import { InfixDispatch, infixOperators } from "./infixDispatch.js";
 import { accessStructProp } from "./accessStructProp.js";
@@ -128,9 +129,10 @@ export function accessProp(target, propName) {
         if (!swizzleType) {
             return undefined;
         }
-        return snip(isKnownAtComptime(target)
+        const knownTarget = asComptime(target);
+        return snip(knownTarget
             ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, the prop is there
-                target.value[propName]
+                knownTarget.value[propName]
             : stitch `${target}.${propName}`, swizzleType, 
         // Swizzling creates new vectors (unless they're on the lhs of an assignment, but that's not yet supported in WGSL)
         /* origin */ propLength === 1
@@ -139,9 +141,10 @@ export function accessProp(target, propName) {
                 ? 'constant'
                 : 'runtime', target.possibleSideEffects);
     }
-    if (isKnownAtComptime(target) || target.dataType === UnknownData) {
-        // oxlint-disable-next-line typescript/no-explicit-any -- we either know exactly what it is, or have no idea at all
-        const prop = target.value[propName];
+    const knownTarget = asComptime(target);
+    if (knownTarget) {
+        // oxlint-disable-next-line typescript/no-explicit-any
+        const prop = knownTarget.value[propName];
         if (isNamable(prop) && getName(prop) === undefined) {
             setName(prop, propName);
         }

package/tgsl/conversion.js

@@ -10,6 +10,7 @@ import { safeStringify } from "../shared/stringify.js";
 import { assertExhaustive } from "../shared/utilityTypes.js";
 import { logger } from "../tgpuLogger.js";
 import { accessStructProp } from "./accessStructProp.js";
+import { stringifySnippet } from "./stringifySnippet.js";
 const INFINITE_RANK = {
     rank: Number.POSITIVE_INFINITY,
     action: 'none',
@@ -254,7 +255,7 @@ export function convertToCommonType(ctx, values, restrictTo, verbose = true) {
     }
     if (verbose && conversion.hasImplicitConversions) {
         logger.warn('implicit-conversion', `Implicit conversions from [\n${values
-            .map((v) => `  ${ctx.resolveSnippet(v).value}: ${safeStringify(v.dataType)}`)
+            .map((v) => `  ${stringifySnippet(v)}: ${safeStringify(v.dataType)}`)
             .join(',\n')}\n] to ${conversion.targetType.type} are supported, but not recommended.
 Consider using explicit conversions instead.`);
     }
@@ -281,7 +282,7 @@ export function tryConvertSnippet(ctx, snippet, targetDataTypes, verbose = true)
     if (converted) {
         return converted[0];
     }
-    throw new WgslTypeError(`Cannot convert value of type '${String(dataType)}' to any of the target types: [${targets.map((t) => t.type).join(', ')}]`);
+    throw new WgslTypeError(`Cannot convert '${stringifySnippet(snippet)}' of type '${String(dataType)}' to any of the target types: [${targets.map((t) => t.type).join(', ')}]`);
 }
 export function convertStructValues(ctx, structType, values) {
     return Object.entries(structType.propTypes).map(([key, targetType]) => {

package/tgsl/forOfUtils.js

@@ -1,6 +1,5 @@
 import { UnknownData } from "../data/dataTypes.js";
-import { isAlias, snip } from "../data/snippet.js";
-import { stitch } from "../core/resolve/stitch.js";
+import { isAddressableOrigin, isStoredInMemory, snip } from "../data/snippet.js";
 import * as wgsl from "../data/wgslTypes.js";
 import { i32, u32 } from "../data/numeric.js";
 import { invariant, WgslTypeError } from "../errors.js";
@@ -9,6 +8,7 @@ import { accessIndex } from "./accessIndex.js";
 import { createPtrFromOrigin, implicitFrom } from "../data/ptr.js";
 import { $gpuCallable } from "../shared/symbols.js";
 import { ArrayExpression, concretize } from "./generationHelpers.js";
+import { stringifySnippet } from "./stringifySnippet.js";
 import { isTgpuRange } from "../std/range.js";
 export function getLoopVarKind(elementSnippet) {
     // If it's ephemeral, it's a value that cannot change. If it's a reference, we take
@@ -28,13 +28,10 @@ export function getElementSnippet(iterableSnippet, index) {
 export function getElementType(elementSnippet, iterableSnippet) {
     let elementType = elementSnippet.dataType;
     if (elementType === UnknownData) {
-        throw new WgslTypeError(stitch `The elements in iterable ${iterableSnippet} are of unknown type`);
+        throw new WgslTypeError(`The elements in iterable '${stringifySnippet(iterableSnippet)}' are of unknown type`);
     }
     if (wgsl.isNaturallyEphemeral(elementSnippet.dataType) ||
-        elementSnippet.origin === 'runtime' ||
-        elementSnippet.origin === 'constant' ||
-        elementSnippet.origin === 'constant-immutable-def' ||
-        elementSnippet.origin === 'runtime-immutable-def') {
+        !isAddressableOrigin(elementSnippet.origin)) {
         return elementType;
     }
     if (!wgsl.isPtr(elementType)) {
@@ -56,7 +53,10 @@ export function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
             comparison: step < 0 ? '>' : '<',
         };
     }
-    if (!unroll && !isAlias(iterableSnippet)) {
+    if (iterableSnippet.possibleSideEffects) {
+        throw new Error('`for ... of ...` loops do not support iterables with possible side effects. Store the iterable in a variable first.');
+    }
+    if (!unroll && !isStoredInMemory(iterableSnippet)) {
         throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
 -----
 You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.

package/tgsl/generationHelpers.d.ts

@@ -1,7 +1,7 @@
 import type { ResolvedSnippet, Snippet } from '../data/snippet.ts';
 import { type AnyWgslData, type BaseData, type F32, type I32, type WgslArray } from '../data/wgslTypes.ts';
-import { type ResolutionCtx, type SelfResolvable } from '../types.ts';
-import { $internal, $resolve } from '../shared/symbols.ts';
+import { type ComptimeValue, type ResolutionCtx, type SelfResolvable, type WithComptimeValue } from '../types.ts';
+import { $comptimeValueOf, $internal, $resolve } from '../shared/symbols.ts';
 export declare function numericLiteralToSnippet(value: number): Snippet;
 export declare function concretize<T extends BaseData>(type: T): T | F32 | I32;
 export declare function concretizeSnippet(snippet: Snippet): Snippet;
@@ -12,11 +12,12 @@ export declare function coerceToSnippet(value: unknown): Snippet;
  * Defers resolution. Stores array elements as snippets so the
  * generator can access them when needed.
  */
-export declare class ArrayExpression implements SelfResolvable {
+export declare class ArrayExpression implements SelfResolvable, WithComptimeValue {
     readonly [$internal] = true;
     readonly type: WgslArray<AnyWgslData>;
     readonly elements: Snippet[];
     constructor(type: WgslArray<AnyWgslData>, elements: Snippet[]);
     toString(): string;
+    [$comptimeValueOf](): ComptimeValue;
     [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
 }

package/tgsl/generationHelpers.js

@@ -1,12 +1,13 @@
 import { UnknownData } from "../data/dataTypes.js";
 import { abstractFloat, abstractInt, bool, f32, i32 } from "../data/numeric.js";
 import { isRef } from "../data/ref.js";
-import { isAlias, isSnippet, snip, withDataType } from "../data/snippet.js";
+import { isStoredInMemory, isSnippet, snip, withDataType } from "../data/snippet.js";
 import { isMatInstance, isNaturallyEphemeral, isVecInstance, WORKAROUND_getSchema, } from "../data/wgslTypes.js";
-import { getOwnSnippet } from "../types.js";
+import { asComptime, getOwnSnippet, } from "../types.js";
 import { WgslTypeError } from "../errors.js";
-import { $internal, $resolve } from "../shared/symbols.js";
+import { $comptimeValueOf, $internal, $resolve } from "../shared/symbols.js";
 import { logger } from "../tgpuLogger.js";
+import { stringifySnippet } from "./stringifySnippet.js";
 export function numericLiteralToSnippet(value) {
     if (value >= 2 ** 63 || value < -(2 ** 63)) {
         return snip(value, abstractFloat, /* origin */ 'constant', /* possibleSideEffects */ false);
@@ -78,11 +79,23 @@ export class ArrayExpression {
     toString() {
         return 'ArrayExpression';
     }
+    [$comptimeValueOf]() {
+        // The array is known at comptime only if every element is known at comptime
+        const values = [];
+        for (const elem of this.elements) {
+            const known = asComptime(elem);
+            if (!known) {
+                return { comptime: false };
+            }
+            values.push(known.value);
+        }
+        return { comptime: true, value: values };
+    }
     [$resolve](ctx) {
         for (const elem of this.elements) {
             // We check if there are no references among the elements
-            if (isAlias(elem) && !isNaturallyEphemeral(elem.dataType)) {
-                const snippetStr = ctx.resolveSnippet(elem).value;
+            if (isStoredInMemory(elem) && !isNaturallyEphemeral(elem.dataType)) {
+                const snippetStr = stringifySnippet(elem);
                 const snippetType = ctx.resolve(concretize(elem.dataType)).value;
                 throw new WgslTypeError(`'${snippetStr}' reference cannot be used in an array constructor.\n-----\nTry '${snippetType}(${snippetStr})' or 'arrayOf(${snippetType}, count)([...])' to copy the value instead.\n-----`);
             }

package/tgsl/infixDispatch.d.ts

@@ -2,6 +2,8 @@ import type { MatBase } from '../data/matrix.ts';
 import { type Snippet } from '../data/snippet.ts';
 import type { VecBase } from '../data/vectorImpl.ts';
 import type { AnyMatInstance, AnyNumericVecInstance } from '../data/wgslTypes.ts';
+import { $comptimeValueOf } from '../shared/symbols.ts';
+import { type ComptimeValue, type WithComptimeValue } from '../types.ts';
 export declare const infixOperators: {
     readonly add: import("../types.ts").DualFn<{
         (lhs: number, rhs: number): number;
@@ -56,10 +58,11 @@ export type InfixOperator = (typeof infixOperators)[InfixOperatorName];
  *    d.vec2u(1).mul(2) // lhs is a snippet
  * }
  */
-export declare class InfixDispatch {
+export declare class InfixDispatch implements WithComptimeValue {
     readonly lhs: Snippet | Numeric;
     readonly operator: InfixOperator;
     constructor(lhs: Snippet | Numeric, operator: InfixOperator);
+    [$comptimeValueOf](): ComptimeValue;
 }
 export declare function isInfixDispatch(o: unknown): o is InfixDispatch;
 /**

package/tgsl/infixDispatch.js

@@ -1,5 +1,7 @@
-import {} from "../data/snippet.js";
+import { isSnippet } from "../data/snippet.js";
 import { inCodegenMode } from "../execMode.js";
+import { $comptimeValueOf } from "../shared/symbols.js";
+import { asComptime } from "../types.js";
 import { add, bitShiftLeft, bitShiftRight, div, mod, mul, sub } from "../std/operators.js";
 export const infixOperators = {
     add,
@@ -28,6 +30,16 @@ export class InfixDispatch {
         this.lhs = lhs;
         this.operator = operator;
     }
+    [$comptimeValueOf]() {
+        const known = isSnippet(this.lhs) ? asComptime(this.lhs) : { value: this.lhs };
+        if (!known) {
+            return { comptime: false };
+        }
+        // Same as accessing e.g. `.mul` on a vector in JS, but bound to `lhs`
+        const lhs = known.value;
+        const operator = this.operator;
+        return { comptime: true, value: (rhs) => operator(lhs, rhs) };
+    }
 }
 export function isInfixDispatch(o) {
     return o instanceof InfixDispatch;

package/tgsl/makeDereferenceable.d.ts

@@ -1,5 +1,5 @@
 import type { Snippet } from '../data/snippet.ts';
-import type { SimulationState } from '../types.ts';
+import { type SimulationState } from '../types.ts';
 import type { makeResolvable } from './makeResolvable.ts';
 /**
  * WARNING: This is an API that touches a lot of internals, and is not stable

package/tgsl/makeDereferenceable.js

@@ -1,5 +1,6 @@
-import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../shared/symbols.js";
+import { $comptimeValueOf, $gpuValueOf, $internal, $ownSnippet, $resolve, } from "../shared/symbols.js";
 import { valueProxyHandler } from "../core/valueProxyUtils.js";
+import { runtimeOnly } from "../types.js";
 import { getExecMode } from "../execMode.js";
 import { assertExhaustive } from "../shared/utilityTypes.js";
 /**
@@ -30,6 +31,7 @@ export function makeDereferenceable(value, options) {
                     }
                     return options.codegenMode.getBaseSnippet.apply(resource, [this]);
                 },
+                [$comptimeValueOf]: runtimeOnly,
                 [$resolve]: (ctx) => ctx.resolve(resource),
                 toString: () => `${resource.toString()}.$`,
             }, valueProxyHandler);

package/tgsl/shellless.js

@@ -1,10 +1,9 @@
 import { createShelllessImpl } from "../core/function/shelllessImpl.js";
 import { UnknownData } from "../data/dataTypes.js";
-import { RefOperator } from "../data/ref.js";
 import { isPtr, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { WgslTypeError } from "../errors.js";
 import { getFunctionMetadata, getName } from "../shared/meta.js";
 import { concretize } from "./generationHelpers.js";
+import { stringifySnippet } from "./stringifySnippet.js";
 function shallowEqualSchemas(a, b) {
     if (a.type !== b.type)
         return false;
@@ -34,14 +33,11 @@ export class ShelllessRepository {
             throw new Error(`Cannot resolve '${getName(fn)}' directly, because it expects arguments. Either call it from another function, or wrap it in a shell`);
         }
         const argTypes = (argSnippets ?? []).map((s, index) => {
-            if (s.value instanceof RefOperator) {
-                if (s.dataType === UnknownData) {
-                    throw new WgslTypeError(`d.ref() created with primitive types must be stored in a variable before use`);
-                }
-                return s.dataType;
-            }
             if (s.dataType === UnknownData) {
-                throw new Error(`Passed illegal value ${s.value} as the #${index} argument to ${getName(fn) ?? '<unnamed>'}(...)\n` +
+                const snippetStr = stringifySnippet(s);
+                const valueStr = String(s.value);
+                const description = snippetStr === valueStr ? `'${snippetStr}'` : `'${snippetStr}' (${valueStr})`;
+                throw new Error(`Passed illegal value ${description} as the #${index} argument to ${getName(fn) ?? '<unnamed>'}(...)\n` +
                     `Shellless functions can only accept arguments representing WGSL resources: constructible WGSL types, d.refs, samplers or texture views.\n` +
                     `Remember, that arguments such as samplers, texture views, accessors, slots etc. should be dereferenced via '.$' first.`);
             }

package/tgsl/stringifySnippet.d.ts

@@ -0,0 +1,9 @@
+import type * as tinyest from 'tinyest';
+import type { Snippet } from '../data/snippet.ts';
+export declare function setSourceNode(snippet: Snippet, node: tinyest.Expression): Snippet;
+export declare function getSourceNode(snippet: Snippet): tinyest.Expression | undefined;
+/**
+ * Describes a snippet in a human-readable way, meant to be used in error messages.
+ * Prefers the JS expression that produced the snippet, falling back to its value.
+ */
+export declare function stringifySnippet(snippet: Snippet): string;

package/tgsl/stringifySnippet.js

@@ -0,0 +1,24 @@
+import { stringifyNode } from "../shared/tseynit.js";
+/**
+ * The JS expression that first produced a given snippet.
+ * Snippets can be shared (e.g. every reference to a variable returns the same snippet),
+ * so only the first, most specific node is remembered.
+ */
+const sourceNodes = new WeakMap();
+export function setSourceNode(snippet, node) {
+    if (!sourceNodes.has(snippet)) {
+        sourceNodes.set(snippet, node);
+    }
+    return snippet;
+}
+export function getSourceNode(snippet) {
+    return sourceNodes.get(snippet);
+}
+/**
+ * Describes a snippet in a human-readable way, meant to be used in error messages.
+ * Prefers the JS expression that produced the snippet, falling back to its value.
+ */
+export function stringifySnippet(snippet) {
+    const node = getSourceNode(snippet);
+    return node !== undefined ? stringifyNode(node) : String(snippet.value);
+}

package/tgsl/wgslGenerator.d.ts

@@ -27,6 +27,7 @@ export declare class WgslGenerator implements ShaderGenerator {
      */
     protected _typedExpression(expression: tinyest.Expression, expectedType: wgsl.BaseData | wgsl.BaseData[]): Snippet;
     protected _expression(expression: tinyest.Expression): Snippet;
+    private _expressionImpl;
     declareGlobalConst(options: ConstantDefinitionOptions): ResolvedSnippet;
     declareGlobalVar(options: VariableDefinitionOptions): ResolvedSnippet;
     functionDefinition(options: FunctionDefinitionOptions): string;