typegpu 0.12.7 → 0.12.8

package/data/snippet.js

@@ -49,9 +49,18 @@ export const originToPtrParams = {
     // Local declarations are also in the `function` address space
     'local-def': { space: 'function', access: 'read-write' },
 };
+/**
+ * Whether values of this origin can have their address taken.
+ */
 export function isAddressableOrigin(origin) {
     return origin in originToPtrParams;
 }
+/**
+ * Whether values of this origin can be mutated.
+ */
+export function isMutableOrigin(origin) {
+    return isAddressableOrigin(origin) && originToPtrParams[origin].access === 'read-write';
+}
 class SnippetImpl {
     value;
     dataType;

package/data/struct.js

@@ -17,6 +17,9 @@ import { schemaCallWrapper } from "./schemaCallWrapper.js";
  * each entry describing one struct member.
  */
 export function struct(props) {
+    if (Object.keys(props).length === 0) {
+        throw new Error('Cannot create struct schema with no properties.');
+    }
     return INTERNAL_createStruct(props, false);
 }
 export function abstruct(props) {

package/data/wgslTypes.d.ts

@@ -704,7 +704,7 @@ export interface Mat2x2f extends BaseData {
     readonly type: 'mat2x2f';
     readonly primitive: F32;
     readonly [$repr]: m2x2f;
-    readonly [$inRepr]: m2x2f | readonly number[] | Float32Array;
+    readonly [$inRepr]: m2x2f | readonly [number, number, number, number] | Float32Array;
     readonly [$validStorageSchema]: true;
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number]): m2x2f;
@@ -720,7 +720,7 @@ export interface Mat3x3f extends BaseData {
     readonly type: 'mat3x3f';
     readonly primitive: F32;
     readonly [$repr]: m3x3f;
-    readonly [$inRepr]: m3x3f | readonly number[] | Float32Array;
+    readonly [$inRepr]: m3x3f | readonly [number, number, number, number, number, number, number, number, number] | Float32Array;
     readonly [$validStorageSchema]: true;
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number, number, number, number, number, number]): m3x3f;
@@ -736,7 +736,7 @@ export interface Mat4x4f extends BaseData {
     readonly type: 'mat4x4f';
     readonly primitive: F32;
     readonly [$repr]: m4x4f;
-    readonly [$inRepr]: m4x4f | readonly number[] | Float32Array;
+    readonly [$inRepr]: m4x4f | readonly [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number] | Float32Array;
     readonly [$validStorageSchema]: true;
     readonly [$validUniformSchema]: true;
     (...elements: [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number]): m4x4f;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.12.7",
+  "version": "0.12.8",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",

package/resolutionCtx.js

@@ -417,7 +417,7 @@ export class ResolutionCtxImpl {
         return this._indentController.dedent();
     }
     getDedented(code) {
-        return code.replaceAll(`\n${INDENT[1]}`, '\n');
+        return code.replaceAll(`\n${INDENT[1]}`, '\n').replaceAll(new RegExp(`^${INDENT[1]}`, 'g'), '');
     }
     withResetIndentLevel(callback) {
         return this._indentController.withResetLevel(callback);

package/shared/meta.js

@@ -1,4 +1,4 @@
-const version = "0.12.7";
+const version = "0.12.8";
 import { DEV, TEST } from "./env.js";
 import { $getNameForward, $soul, isMarkedInternal } from "./symbols.js";
 import { normalizeMetadata } from "./normalizeMetadata.js";

package/shared/symbols.d.ts

@@ -18,6 +18,11 @@ export declare const $providing: unique symbol;
  * Objects can provide the snippet that represents them.
  */
 export declare const $ownSnippet: unique symbol;
+/**
+ * Objects can provide the value that they represent at comptime (e.g. when passed
+ * into comptime functions), or signal that they are not known at comptime.
+ */
+export declare const $comptimeValueOf: unique symbol;
 export declare const $resolve: unique symbol;
 /**
  * A way for a schema to provide casting behavior, without the need to be explicitly

package/shared/symbols.js

@@ -1,4 +1,4 @@
-const version = "0.12.7";
+const version = "0.12.8";
 export const $internal = Symbol(`typegpu:${version}:$internal`);
 /** A plain record of all definitional state of a resource, surviving transfer between runtimes */
 export const $soul = Symbol(`typegpu:${version}:$soul`);
@@ -19,6 +19,11 @@ export const $providing = Symbol(`typegpu:${version}:$providing`);
  * Objects can provide the snippet that represents them.
  */
 export const $ownSnippet = Symbol(`typegpu:${version}:$ownSnippet`);
+/**
+ * Objects can provide the value that they represent at comptime (e.g. when passed
+ * into comptime functions), or signal that they are not known at comptime.
+ */
+export const $comptimeValueOf = Symbol(`typegpu:${version}:$comptimeValueOf`);
 export const $resolve = Symbol(`typegpu:${version}:$resolve`);
 /**
  * A way for a schema to provide casting behavior, without the need to be explicitly

package/std/numeric.js

@@ -747,10 +747,7 @@ export const round = dualImpl({
 });
 function cpuSaturate(value) {
     assertKind(value, floatKind);
-    if (typeof value === 'number') {
-        return Math.max(0, Math.min(1, value));
-    }
-    throw new MissingCpuImplError('CPU implementation for saturate on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues');
+    return generalizeFn((value) => clampScalar(value, 0, 1), [value]);
 }
 export const saturate = dualImpl({
     name: 'saturate',

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/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 = {
@@ -30,24 +31,27 @@ function deriveIndexAccessOrigin(targetOrigin, indexOrigin) {
 }
 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;
-        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];
         }
         const origin = deriveIndexAccessOrigin(target.origin, index.origin);
-        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]
+                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]
+                knownTarget.value[knownIndex.value]
             : stitch `${target}[${index}]`, target.dataType.primitive, deriveIndexAccessOrigin(target.origin, index.origin), target.possibleSideEffects || index.possibleSideEffects);
     }
     if (isPtr(target.dataType)) {
@@ -64,16 +68,15 @@ export function accessIndex(target, indexArg) {
     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 { isAddressableOrigin, isStoredInMemory, snip } from "../data/snippet.js";
-import { stitch } from "../core/resolve/stitch.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,7 +28,7 @@ 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) ||
         !isAddressableOrigin(elementSnippet.origin)) {

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

@@ -3,10 +3,11 @@ import { abstractFloat, abstractInt, bool, f32, i32 } from "../data/numeric.js";
 import { isRef } from "../data/ref.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 (isStoredInMemory(elem) && !isNaturallyEphemeral(elem.dataType)) {
-                const snippetStr = ctx.resolveSnippet(elem).value;
+                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;