typegpu 0.12.6 → 0.12.7

package/shared/tseynit.js

@@ -2,90 +2,94 @@ import * as tinyest from 'tinyest';
 const { NodeTypeCatalog: NODE } = tinyest;
 export function stringifyNode(node) {
     if (isExpression(node)) {
-        return stringifyExpression(node, '');
+        return stringifyExpression(node);
     }
     return stringifyStatement(node, '');
 }
-function stringifyStatement(node, ident) {
+function stringifyStatement(node, indent) {
     if (isExpression(node)) {
-        return `${ident}${stringifyExpression(node, ident)};`;
+        return `${indent}${stringifyExpression(node)};`;
     }
     if (node[0] === NODE.block) {
-        const statements = node[1].map((n) => stringifyStatement(n, ident + '  '));
-        return `{\n${statements.join('\n')}\n${ident}}`;
+        const statements = node[1].map((n) => stringifyStatement(n, indent + '  '));
+        return `{\n${statements.join('\n')}\n${indent}}`;
     }
     if (node[0] === NODE.return) {
-        const expr = node[1] === undefined ? '' : ` ${stringifyExpression(node[1], '')}`;
-        return `${ident}return${expr};`;
+        const expr = node[1] === undefined ? '' : ` ${stringifyExpression(node[1])}`;
+        return `${indent}return${expr};`;
     }
     if (node[0] === NODE.if) {
-        const cond = stringifyExpression(node[1], ident);
-        const then = stringifyStatement(node[2], ident);
-        const base = `${ident}if (${cond}) ${then}`;
+        const cond = stringifyExpression(node[1]);
+        const then = stringifyStatement(node[2], indent);
+        const base = `${indent}if (${cond}) ${then}`;
         if (node[3] !== undefined) {
-            return `${base} else ${stringifyStatement(node[3], ident)}`;
+            return `${base} else ${stringifyStatement(node[3], indent)}`;
         }
         return base;
     }
     if (node[0] === NODE.let) {
-        const decl = `${ident}let ${stringifyExpression(node[1], ident)}`;
+        const decl = `${indent}let ${stringifyExpression(node[1])}`;
         if (node[2] !== undefined) {
-            return `${decl} = ${stringifyExpression(node[2], ident)};`;
+            return `${decl} = ${stringifyExpression(node[2])};`;
         }
         return `${decl};`;
     }
     if (node[0] === NODE.const) {
-        const decl = `${ident}const ${stringifyExpression(node[1], ident)}`;
+        const decl = `${indent}const ${stringifyExpression(node[1])}`;
         if (node[2] !== undefined) {
-            return `${decl} = ${stringifyExpression(node[2], ident)};`;
+            return `${decl} = ${stringifyExpression(node[2])};`;
         }
         return `${decl};`;
     }
     if (node[0] === NODE.for) {
         const init = node[1] ? stringifyStatement(node[1], '') : ';';
-        const cond = node[2] ? stringifyExpression(node[2], ident) : '';
+        const cond = node[2] ? stringifyExpression(node[2]) : '';
         const update = node[3] ? stringifyStatement(node[3], '') : '';
-        const body = stringifyStatement(node[4], ident);
-        return `${ident}for (${init} ${cond}; ${update.slice(0, -1) /* trim the ';' */}) ${body}`;
+        const body = stringifyStatement(node[4], indent);
+        return `${indent}for (${init} ${cond}; ${update.slice(0, -1) /* trim the ';' */}) ${body}`;
     }
     if (node[0] === NODE.while) {
-        const cond = stringifyExpression(node[1], ident);
-        const body = stringifyStatement(node[2], ident);
-        return `${ident}while (${cond}) ${body}`;
+        const cond = stringifyExpression(node[1]);
+        const body = stringifyStatement(node[2], indent);
+        return `${indent}while (${cond}) ${body}`;
     }
     if (node[0] === NODE.continue) {
-        return `${ident}continue;`;
+        return `${indent}continue;`;
     }
     if (node[0] === NODE.break) {
-        return `${ident}break;`;
+        return `${indent}break;`;
     }
     if (node[0] === NODE.forOf) {
         const leftKind = node[1][0] === NODE.const ? 'const' : 'let';
-        const leftName = stringifyExpression(node[1][1], ident);
-        const right = stringifyExpression(node[2], ident);
-        const body = stringifyStatement(node[3], ident);
-        return `${ident}for (${leftKind} ${leftName} of ${right}) ${body}`;
+        const leftName = stringifyExpression(node[1][1]);
+        const right = stringifyExpression(node[2]);
+        const body = stringifyStatement(node[3], indent);
+        return `${indent}for (${leftKind} ${leftName} of ${right}) ${body}`;
     }
     if (node[0] === NODE.switch) {
-        const discriminant = stringifyExpression(node[1], ident);
+        const discriminant = stringifyExpression(node[1]);
         const cases = node[2].map((c) => {
-            const test = c[0] === null ? 'default' : `case ${stringifyExpression(c[0], ident)}`;
+            const test = c[0] === null ? 'default' : `case ${stringifyExpression(c[0])}`;
             if (c[1].length === 0) {
                 return `${test}:`;
             }
-            const consequents = c[1].map((s) => stringifyStatement(s, ident + '    '));
+            const consequents = c[1].map((s) => stringifyStatement(s, indent + '    '));
             return `${test}:\n${consequents.join('\n')}`;
         });
-        return `${ident}switch (${discriminant}) {\n${cases.map((c) => `${ident + '  '}${c}`).join('\n')}\n${ident}}`;
+        return `${indent}switch (${discriminant}) {\n${cases.map((c) => `${indent + '  '}${c}`).join('\n')}\n${indent}}`;
     }
     assertExhaustive(node);
 }
+const JS_IDENTIFIER = /^[$_\p{ID_Start}][$_\u{200c}\u{200d}\p{ID_Continue}]*$/u;
+function stringifyObjectPropertyKey(key) {
+    return JS_IDENTIFIER.test(key) ? key : JSON.stringify(key);
+}
 export function stringifyObjectProperty([key, value, computed]) {
-    const keyStr = computed ? `[${stringifyExpression(key, '')}]` : stringifyExpression(key, '');
-    const valueStr = stringifyExpression(value, '');
+    const keyStr = computed ? `[${stringifyExpression(key)}]` : stringifyObjectPropertyKey(key);
+    const valueStr = stringifyExpression(value);
     return `${keyStr}: ${valueStr}`;
 }
-function stringifyExpression(node, ident) {
+function stringifyExpression(node) {
     if (typeof node === 'string') {
         return node;
     }
@@ -105,52 +109,52 @@ function stringifyExpression(node, ident) {
         return JSON.stringify(node[1]);
     }
     if (node[0] === NODE.arrayExpr) {
-        const elements = node[1].map((n) => stringifyExpression(n, ident));
+        const elements = node[1].map((n) => stringifyExpression(n));
         return `[${elements.join(', ')}]`;
     }
     if (node[0] === NODE.binaryExpr) {
-        return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ${node[2]} ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.assignmentExpr) {
-        return `${stringifyExpression(node[1], ident)} ${node[2]} ${stringifyExpression(node[3], ident)}`;
+        return `${stringifyExpression(node[1])} ${node[2]} ${stringifyExpression(node[3])}`;
     }
     if (node[0] === NODE.logicalExpr) {
-        return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ${node[2]} ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.unaryExpr) {
         // Unary word operators like void, instanceof and delete require a space
         const sep = node[1].length > 1 ? ' ' : '';
-        return `${node[1]}${sep}${wrapIfComplex(node[2], ident)}`;
+        return `${node[1]}${sep}${wrapIfComplex(node[2])}`;
     }
     if (node[0] === NODE.call) {
-        const callee = wrapIfComplex(node[1], ident);
-        const args = node[2].map((n) => stringifyExpression(n, ident)).join(', ');
+        const callee = wrapIfComplex(node[1]);
+        const args = node[2].map((n) => stringifyExpression(n)).join(', ');
         return `${callee}(${args})`;
     }
     if (node[0] === NODE.memberAccess) {
         if (Array.isArray(node[1]) && node[1][0] === NODE.numericLiteral) {
-            return `(${stringifyExpression(node[1], ident)}).${stringifyExpression(node[2], ident)}`;
+            return `(${stringifyExpression(node[1])}).${stringifyExpression(node[2])}`;
         }
-        return `${wrapIfComplex(node[1], ident)}.${stringifyExpression(node[2], ident)}`;
+        return `${wrapIfComplex(node[1])}.${stringifyExpression(node[2])}`;
     }
     if (node[0] === NODE.indexAccess) {
-        return `${wrapIfComplex(node[1], ident)}[${stringifyExpression(node[2], ident)}]`;
+        return `${wrapIfComplex(node[1])}[${stringifyExpression(node[2])}]`;
     }
     if (node[0] === NODE.preUpdate) {
-        return `${node[1]}${wrapIfComplex(node[2], ident)}`;
+        return `${node[1]}${wrapIfComplex(node[2])}`;
     }
     if (node[0] === NODE.postUpdate) {
-        return `${wrapIfComplex(node[2], ident)}${node[1]}`;
+        return `${wrapIfComplex(node[2])}${node[1]}`;
     }
     if (node[0] === NODE.objectExpr) {
         if (Array.isArray(node[1])) {
             return `{ ${node[1].map(stringifyObjectProperty).join(', ')} }`;
         }
-        const entries = Object.entries(node[1]).map(([key, val]) => `${key}: ${stringifyExpression(val, ident)}`);
+        const entries = Object.entries(node[1]).map(([key, val]) => `${stringifyObjectPropertyKey(key)}: ${stringifyExpression(val)}`);
         return `{ ${entries.join(', ')} }`;
     }
     if (node[0] === NODE.conditionalExpr) {
-        return `${wrapIfComplex(node[1], ident)} ? ${wrapIfComplex(node[2], ident)} : ${wrapIfComplex(node[3], ident)}`;
+        return `${wrapIfComplex(node[1])} ? ${wrapIfComplex(node[2])} : ${wrapIfComplex(node[3])}`;
     }
     if (node[0] === NODE.nullLiteral) {
         return 'null';
@@ -199,8 +203,8 @@ const SIMPLE_NODES = [
 /**
  * Stringifies expression, and wraps it in parentheses if they cannot be trivially omitted
  */
-function wrapIfComplex(node, ident) {
-    const s = stringifyExpression(node, ident);
+function wrapIfComplex(node) {
+    const s = stringifyExpression(node);
     if (typeof node === 'string' || typeof node === 'boolean') {
         return s;
     }

package/std/boolean.js

@@ -9,6 +9,7 @@ import { isBool, isVecBool, isVecInstance, } from "../data/wgslTypes.js";
 import { SignatureNotSupportedError, WgslTypeError } from "../errors.js";
 import { unify } from "../tgsl/conversion.js";
 import { cpuCopy } from "./copy.js";
+import { coerceToSnippet } from "../tgsl/generationHelpers.js";
 function correspondingBooleanVectorSchema(dataType) {
     if (dataType.type.includes('2')) {
         return vec2b;
@@ -30,7 +31,7 @@ export const allEq = dualImpl({
     name: 'allEq',
     signature: (...argTypes) => ({ argTypes, returnType: bool }),
     normalImpl: (lhs, rhs) => cpuAll(cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `all(${lhs} == ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => stitch `all(${ctx.gen.emitBinaryOp(lhs, '==', rhs)})`,
     sideEffects: false,
 });
 const cpuEq = (lhs, rhs) => {
@@ -54,7 +55,7 @@ export const eq = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: cpuEq,
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} == ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '==', rhs),
     sideEffects: false,
 });
 /**
@@ -72,7 +73,7 @@ export const ne = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuNot(cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} != ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '!=', rhs),
     sideEffects: false,
 });
 const cpuLt = (lhs, rhs) => {
@@ -95,7 +96,7 @@ export const lt = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: cpuLt,
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} < ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '<', rhs),
     sideEffects: false,
 });
 /**
@@ -113,7 +114,7 @@ export const le = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuOr(cpuLt(lhs, rhs), cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} <= ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '<=', rhs),
     sideEffects: false,
 });
 /**
@@ -131,7 +132,7 @@ export const gt = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuAnd(cpuNot(cpuLt(lhs, rhs)), cpuNot(cpuEq(lhs, rhs))),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} > ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '>', rhs),
     sideEffects: false,
 });
 /**
@@ -149,7 +150,7 @@ export const ge = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuNot(cpuLt(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} >= ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '>=', rhs),
     sideEffects: false,
 });
 function cpuNot(value) {
@@ -274,9 +275,7 @@ export const isCloseTo = dualImpl({
             return stitch `(abs(f32(${lhs}) - f32(${rhs})) <= ${precision})`;
         }
         if (!isSnippetNumeric(lhs) && !isSnippetNumeric(rhs)) {
-            // https://www.w3.org/TR/WGSL/#vector-multi-component:~:text=Binary%20arithmetic%20expressions%20with%20mixed%20scalar%20and%20vector%20operands
-            // (a-a)+prec creates a vector of a.length elements, all equal to prec
-            return stitch `all(abs(${lhs} - ${rhs}) <= (${lhs} - ${lhs}) + ${precision})`;
+            return stitch `all(abs(${lhs} - ${rhs}) <= ${_ctx.gen.typeInstantiation(lhs.dataType, [coerceToSnippet(precision)])})`;
         }
         return 'false';
     },

package/std/operators.js

@@ -160,10 +160,15 @@ function cpuNeg(value) {
 }
 export const neg = dualImpl({
     name: 'neg',
-    signature: (arg) => ({
-        argTypes: [arg],
-        returnType: arg,
-    }),
+    signature: (arg) => {
+        if (getPrimitive(arg) === u32) {
+            throw new WgslTypeError(`Unsupported signature. Unary operator - cannot be applied to argument of kind '${arg.type}'.`);
+        }
+        return {
+            argTypes: [arg],
+            returnType: arg,
+        };
+    },
     normalImpl: cpuNeg,
     codegenImpl: (_ctx, [arg]) => stitch `-(${arg})`,
     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/tgsl/accessIndex.js

@@ -12,33 +12,31 @@ 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;
     // 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];
         }
+        const origin = deriveIndexAccessOrigin(target.origin, index.origin);
         return snip(isKnownAtComptime(target) && isKnownAtComptime(index)
             ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, it's there
                 target.value[index.value]
@@ -50,8 +48,7 @@ export function accessIndex(target, indexArg) {
         return snip(isKnownAtComptime(target) && isKnownAtComptime(index)
             ? // 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);
+            : 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,8 +58,7 @@ 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) {

package/tgsl/forOfUtils.js

@@ -1,5 +1,5 @@
 import { UnknownData } from "../data/dataTypes.js";
-import { isAlias, snip } from "../data/snippet.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";
@@ -31,10 +31,7 @@ export function getElementType(elementSnippet, iterableSnippet) {
         throw new WgslTypeError(stitch `The elements in iterable ${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.js

@@ -1,7 +1,7 @@
 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 { WgslTypeError } from "../errors.js";
@@ -81,7 +81,7 @@ export class ArrayExpression {
     [$resolve](ctx) {
         for (const elem of this.elements) {
             // We check if there are no references among the elements
-            if (isAlias(elem) && !isNaturallyEphemeral(elem.dataType)) {
+            if (isStoredInMemory(elem) && !isNaturallyEphemeral(elem.dataType)) {
                 const snippetStr = ctx.resolveSnippet(elem).value;
                 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-----`);