typegpu 0.11.3 → 0.11.5

package/resolutionCtx.js

@@ -12,12 +12,12 @@ import { safeStringify } from "./shared/stringify.js";
 import { getBestConversion } from "./tgsl/conversion.js";
 import { bool } from "./data/numeric.js";
 import { coerceToSnippet, concretize, numericLiteralToSnippet } from "./tgsl/generationHelpers.js";
+import { sanitizePrimer, validateIdentifier } from "./nameUtils.js";
 import { createIoSchema } from "./core/function/ioSchema.js";
 import { AutoStruct } from "./data/autoStruct.js";
 import { EntryInputRouter } from "./core/function/entryInputRouter.js";
 import { accessProp } from "./tgsl/accessProp.js";
 import { isTgpuFn } from "./core/function/tgpuFn.js";
-import { getUniqueName } from "./core/resolve/namespace.js";
 import { ConfigurableImpl } from "./core/root/configurableImpl.js";
 import { naturalsExcept } from "./shared/generators.js";
 import { TgpuBindGroupImpl, bindGroupLayout } from "./tgpuBindGroupLayout.js";
@@ -50,6 +50,9 @@ var ItemStateStackImpl = class {
 	get topFunctionScope() {
 		return this._stack.findLast((e) => e.type === "functionScope");
 	}
+	get topBlockScope() {
+		return this._stack.findLast((e) => e.type === "blockScope");
+	}
 	pushItem() {
 		this._itemDepth++;
 		this._stack.push({
@@ -70,7 +73,9 @@ var ItemStateStackImpl = class {
 			argAccess,
 			returnType,
 			externalMap,
-			reportedReturnTypes: /* @__PURE__ */ new Set()
+			reportedReturnTypes: /* @__PURE__ */ new Set(),
+			placeholderForVariable: /* @__PURE__ */ new Map(),
+			modifiedVariables: /* @__PURE__ */ new Set()
 		};
 		this._stack.push(scope);
 		return scope;
@@ -78,6 +83,7 @@ var ItemStateStackImpl = class {
 	pushBlockScope() {
 		this._stack.push({
 			type: "blockScope",
+			takenLocalIdentifiers: /* @__PURE__ */ new Set(),
 			declarations: /* @__PURE__ */ new Map(),
 			externals: /* @__PURE__ */ new Map()
 		});
@@ -116,6 +122,16 @@ var ItemStateStackImpl = class {
 			}
 		}
 	}
+	isIdentifierTakenLocally(id) {
+		for (let i = this._stack.length - 1; i >= 0; --i) {
+			const layer = this._stack[i];
+			if (layer?.type === "functionScope") return false;
+			if (layer?.type === "blockScope") {
+				if (layer.takenLocalIdentifiers.has(id)) return true;
+			}
+		}
+		return false;
+	}
 	defineBlockVariable(id, snippet) {
 		if (snippet.dataType === UnknownData) throw Error(`Tried to define variable '${id}' of unknown type`);
 		for (let i = this._stack.length - 1; i >= 0; --i) {
@@ -232,17 +248,41 @@ var ResolutionCtxImpl = class {
 	fixedBindings = [];
 	enableExtensions;
 	expectedType;
+	/**
+	* A counter used to generate unique identifiers for globally-scoped definitions in the 'random' strategy.
+	*/
+	#lastUniqueId = 0;
 	constructor(opts) {
 		this.enableExtensions = opts.enableExtensions;
 		this.gen = opts.shaderGenerator ?? wgslGenerator_default;
 		this.#logGenerator = opts.root ? new LogGeneratorImpl(opts.root) : new LogGeneratorNullImpl();
 		this.#namespaceInternal = opts.namespace[$internal];
 	}
-	getUniqueName(resource) {
-		return getUniqueName(this.#namespaceInternal, resource);
+	isIdentifierTaken(name) {
+		return this.#namespaceInternal.takenGlobalIdentifiers.has(name) || this._itemStateStack.isIdentifierTakenLocally(name);
 	}
-	makeNameValid(name) {
-		return this.#namespaceInternal.nameRegistry.makeValid(name);
+	makeUniqueIdentifier(primer = "item", scope) {
+		if (scope === "block" && (/* @__PURE__ */ validateIdentifier(primer)).success && !this.isIdentifierTaken(primer)) {
+			this.reserveIdentifier(primer, "block");
+			return primer;
+		}
+		const base = /* @__PURE__ */ sanitizePrimer(primer);
+		let index = 0;
+		const random = this.#namespaceInternal.strategy === "random";
+		let name = random ? `${base}_${this.#lastUniqueId++}` : base;
+		while (this.isIdentifierTaken(name)) name = random ? `${base}_${this.#lastUniqueId++}` : `${base}_${++index}`;
+		this.reserveIdentifier(name, scope);
+		return name;
+	}
+	reserveIdentifier(name, scope) {
+		if (scope === "block") {
+			const blockScope = this._itemStateStack.topBlockScope;
+			if (blockScope) {
+				blockScope.takenLocalIdentifiers.add(name);
+				return;
+			}
+		}
+		this.#namespaceInternal.takenGlobalIdentifiers.add(name);
 	}
 	get pre() {
 		return this._indentController.pre;
@@ -281,11 +321,9 @@ var ResolutionCtxImpl = class {
 		scope.reportedReturnTypes.add(dataType);
 	}
 	pushBlockScope() {
-		this.#namespaceInternal.nameRegistry.pushBlockScope();
 		this._itemStateStack.pushBlockScope();
 	}
 	popBlockScope() {
-		this.#namespaceInternal.nameRegistry.popBlockScope();
 		this._itemStateStack.pop("blockScope");
 	}
 	setBlockExternals(externals) {
@@ -301,28 +339,27 @@ var ResolutionCtxImpl = class {
 		return this.#logGenerator.logResources;
 	}
 	fnToWgsl(options) {
-		let fnScopePushed = false;
 		try {
-			this.#namespaceInternal.nameRegistry.pushFunctionScope();
+			const scope = this._itemStateStack.pushFunctionScope(options.functionType, {}, options.returnType, options.externalMap);
+			this._itemStateStack.pushBlockScope();
 			const args = [];
-			const argAccess = {};
 			if (options.entryInput) {
 				const { dataSchema, positionalArgs } = options.entryInput;
 				const firstParam = options.params[0];
-				const structArg = dataSchema ? createArgument(this.makeNameValid("_arg_0"), dataSchema) : void 0;
+				const structArg = dataSchema ? createArgument(this.makeUniqueIdentifier("_arg_0", "block"), dataSchema) : void 0;
 				if (structArg) args.push(structArg);
 				if (firstParam?.type === FuncParameterType.destructuredObject) for (const { name, alias } of firstParam.props) {
 					const argInfo = positionalArgs.find((a) => a.schemaKey === name);
 					if (argInfo) {
-						const arg = createArgument(this.makeNameValid(alias), argInfo.type);
+						const arg = createArgument(this.makeUniqueIdentifier(alias, "block"), argInfo.type);
 						args.push(arg);
-						argAccess[alias] = arg.access;
-					} else if (structArg) argAccess[alias] = createArgumentPropAccess(structArg.access, name);
+						scope.argAccess[alias] = arg.access;
+					} else if (structArg) scope.argAccess[alias] = createArgumentPropAccess(structArg.access, name);
 				}
 				else if (firstParam?.type === FuncParameterType.identifier) {
 					const proxyEntries = [];
 					for (const a of positionalArgs) {
-						const arg = createArgument(this.makeNameValid(`_arg_${a.schemaKey}`), a.type);
+						const arg = createArgument(this.makeUniqueIdentifier(`_arg_${a.schemaKey}`, "block"), a.type);
 						args.push(arg);
 						proxyEntries.push({
 							schemaKey: a.schemaKey,
@@ -330,31 +367,31 @@ var ResolutionCtxImpl = class {
 						});
 					}
 					const router = new EntryInputRouter(structArg?.access, proxyEntries);
-					argAccess[firstParam.name] = () => snip("N/A", router, "argument");
+					scope.argAccess[firstParam.name] = () => snip("N/A", router, "argument");
 				} else for (const a of positionalArgs) {
-					const argName = this.makeNameValid(`_arg_${a.schemaKey}`);
+					const argName = this.makeUniqueIdentifier(`_arg_${a.schemaKey}`, "block");
 					const arg = createArgument(argName, a.type);
 					args.push(arg);
-					argAccess[argName] = arg.access;
+					scope.argAccess[argName] = arg.access;
 				}
 			} else for (const [i, argType] of options.argTypes.entries()) {
 				const astParam = options.params[i];
 				const origin = isPtr(argType) ? argType.addressSpace === "storage" ? argType.access === "read" ? "readonly" : "mutable" : argType.addressSpace : "argument";
 				switch (astParam?.type) {
 					case FuncParameterType.identifier: {
-						const arg = createArgument(this.makeNameValid(astParam.name), argType, origin);
+						const arg = createArgument(this.makeUniqueIdentifier(astParam.name, "block"), argType, origin);
 						args.push(arg);
-						argAccess[astParam.name] = arg.access;
+						scope.argAccess[astParam.name] = arg.access;
 						break;
 					}
 					case FuncParameterType.destructuredObject: {
-						const objArg = createArgument(this.makeNameValid(`_arg_${i}`), argType, origin);
+						const objArg = createArgument(this.makeUniqueIdentifier(`_arg_${i}`, "block"), argType, origin);
 						args.push(objArg);
-						for (const { name, alias } of astParam.props) argAccess[alias] = createArgumentPropAccess(objArg.access, name);
+						for (const { name, alias } of astParam.props) scope.argAccess[alias] = createArgumentPropAccess(objArg.access, name);
 						break;
 					}
 					case void 0: if (!(argType instanceof AutoStruct)) args.push({
-						name: this.makeNameValid(`_arg_${i}`),
+						name: this.makeUniqueIdentifier(`_arg_${i}`, "block"),
 						access: () => {
 							throw new Error(`Unreachable: Accessing an argument that wasn't named in the function signature`);
 						},
@@ -363,8 +400,6 @@ var ResolutionCtxImpl = class {
 					});
 				}
 			}
-			const scope = this._itemStateStack.pushFunctionScope(options.functionType, argAccess, options.returnType, options.externalMap);
-			fnScopePushed = true;
 			let returnType;
 			const code = this.gen.functionDefinition({
 				functionType: options.functionType,
@@ -395,8 +430,8 @@ var ResolutionCtxImpl = class {
 				returnType
 			};
 		} finally {
-			if (fnScopePushed) this._itemStateStack.pop("functionScope");
-			this.#namespaceInternal.nameRegistry.popFunctionScope();
+			this._itemStateStack.pop("blockScope");
+			this._itemStateStack.pop("functionScope");
 		}
 	}
 	addDeclaration(declaration) {
@@ -560,9 +595,8 @@ var ResolutionCtxImpl = class {
 			if (schema.elementCount !== item.length) throw new WgslTypeError(`Cannot create value of type '${schema}' from an array of length: ${item.length}`);
 			return snip(stitch`array<${this.resolve(schema.elementType)}, ${schema.elementCount}>(${item.map((element) => snip(element, schema.elementType, "runtime"))})`, schema, "runtime");
 		}
-		if (Array.isArray(item)) return snip(stitch`array(${item.map((element) => this.resolve(element))})`, UnknownData, "runtime");
 		if (schema && isWgslStruct(schema)) return snip(stitch`${this.resolve(schema)}(${Object.entries(schema.propTypes).map(([key, propType]) => snip(item[key], propType, "runtime"))})`, schema, "runtime");
-		throw new WgslTypeError(`Value ${item} (as json: ${safeStringify(item)}) is not resolvable${schema ? ` to type ${safeStringify(schema)}` : ""}`);
+		throw new WgslTypeError(`Value ${safeStringify(item)} is not resolvable${schema ? ` to type ${safeStringify(schema)}` : ""}`);
 	}
 	resolveSnippet(snippet) {
 		return snip(this.resolve(snippet.value, snippet.dataType).value, snippet.dataType, snippet.origin);

package/shared/stringify.js

@@ -2,6 +2,7 @@ import { isMatInstance, isVecInstance } from "../data/wgslTypes.js";
 
 //#region src/shared/stringify.ts
 function safeStringify(item) {
+	if (Array.isArray(item)) return `[${item.map(safeStringify).join(", ")}]`;
 	const asString = String(item);
 	if (asString !== "[object Object]") return asString;
 	try {

package/shared/tseynit.js

@@ -0,0 +1,90 @@
+import * as tinyest from "tinyest";
+
+//#region src/shared/tseynit.ts
+const { NodeTypeCatalog: NODE } = tinyest;
+function stringifyNode(node) {
+	if (isExpression(node)) return stringifyExpression(node, "");
+	return stringifyStatement(node, "");
+}
+function stringifyStatement(node, ident) {
+	if (isExpression(node)) return `${ident}${stringifyExpression(node, ident)};`;
+	if (node[0] === NODE.block) return `{\n${node[1].map((n) => stringifyStatement(n, ident + "  ")).join("\n")}\n${ident}}`;
+	if (node[0] === NODE.return) return `${ident}return${node[1] === void 0 ? "" : ` ${stringifyExpression(node[1], "")}`};`;
+	if (node[0] === NODE.if) {
+		const base = `${ident}if (${stringifyExpression(node[1], ident)}) ${stringifyStatement(node[2], ident)}`;
+		if (node[3] !== void 0) return `${base} else ${stringifyStatement(node[3], ident)}`;
+		return base;
+	}
+	if (node[0] === NODE.let) {
+		if (node[2] !== void 0) return `${ident}let ${node[1]} = ${stringifyExpression(node[2], ident)};`;
+		return `${ident}let ${node[1]};`;
+	}
+	if (node[0] === NODE.const) {
+		if (node[2] !== void 0) return `${ident}const ${node[1]} = ${stringifyExpression(node[2], ident)};`;
+		return `${ident}const ${node[1]};`;
+	}
+	if (node[0] === NODE.for) {
+		const init = node[1] ? stringifyStatement(node[1], "") : ";";
+		const cond = node[2] ? stringifyExpression(node[2], ident) : "";
+		const update = node[3] ? stringifyStatement(node[3], "") : "";
+		const body = stringifyStatement(node[4], ident);
+		return `${ident}for (${init} ${cond}; ${update.slice(0, -1)}) ${body}`;
+	}
+	if (node[0] === NODE.while) return `${ident}while (${stringifyExpression(node[1], ident)}) ${stringifyStatement(node[2], ident)}`;
+	if (node[0] === NODE.continue) return `${ident}continue;`;
+	if (node[0] === NODE.break) return `${ident}break;`;
+	if (node[0] === NODE.forOf) return `${ident}for (${node[1][0] === NODE.const ? "const" : "let"} ${node[1][1]} of ${stringifyExpression(node[2], ident)}) ${stringifyStatement(node[3], ident)}`;
+	assertExhaustive(node);
+}
+function stringifyExpression(node, ident) {
+	if (typeof node === "string") return node;
+	if (typeof node === "boolean") return `${node}`;
+	if (node[0] === NODE.numericLiteral) return node[1];
+	if (node[0] === NODE.stringLiteral) return JSON.stringify(node[1]);
+	if (node[0] === NODE.arrayExpr) return `[${node[1].map((n) => stringifyExpression(n, ident)).join(", ")}]`;
+	if (node[0] === NODE.binaryExpr) return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+	if (node[0] === NODE.assignmentExpr) return `${stringifyExpression(node[1], ident)} ${node[2]} ${stringifyExpression(node[3], ident)}`;
+	if (node[0] === NODE.logicalExpr) return `${wrapIfComplex(node[1], ident)} ${node[2]} ${wrapIfComplex(node[3], ident)}`;
+	if (node[0] === NODE.unaryExpr) {
+		const sep = node[1].length > 1 ? " " : "";
+		return `${node[1]}${sep}${wrapIfComplex(node[2], ident)}`;
+	}
+	if (node[0] === NODE.call) return `${wrapIfComplex(node[1], ident)}(${node[2].map((n) => stringifyExpression(n, ident)).join(", ")})`;
+	if (node[0] === NODE.memberAccess) {
+		if (Array.isArray(node[1]) && node[1][0] === NODE.numericLiteral) return `(${stringifyExpression(node[1], ident)}).${node[2]}`;
+		return `${wrapIfComplex(node[1], ident)}.${node[2]}`;
+	}
+	if (node[0] === NODE.indexAccess) return `${wrapIfComplex(node[1], ident)}[${stringifyExpression(node[2], ident)}]`;
+	if (node[0] === NODE.preUpdate) return `${node[1]}${wrapIfComplex(node[2], ident)}`;
+	if (node[0] === NODE.postUpdate) return `${wrapIfComplex(node[2], ident)}${node[1]}`;
+	if (node[0] === NODE.objectExpr) return `{ ${Object.entries(node[1]).map(([key, val]) => `${key}: ${stringifyExpression(val, ident)}`).join(", ")} }`;
+	if (node[0] === NODE.conditionalExpr) return `${wrapIfComplex(node[1], ident)} ? ${wrapIfComplex(node[2], ident)} : ${wrapIfComplex(node[3], ident)}`;
+	assertExhaustive(node);
+}
+function assertExhaustive(value) {
+	throw new Error(`'${JSON.stringify(value)}' was not handled by the stringify function.`);
+}
+function isExpression(node) {
+	if (typeof node === "string" || typeof node === "boolean" || node[0] === NODE.numericLiteral || node[0] === NODE.stringLiteral || node[0] === NODE.arrayExpr || node[0] === NODE.binaryExpr || node[0] === NODE.assignmentExpr || node[0] === NODE.logicalExpr || node[0] === NODE.unaryExpr || node[0] === NODE.call || node[0] === NODE.memberAccess || node[0] === NODE.indexAccess || node[0] === NODE.preUpdate || node[0] === NODE.postUpdate || node[0] === NODE.objectExpr || node[0] === NODE.conditionalExpr) return true;
+	return false;
+}
+const SIMPLE_NODES = [
+	NODE.memberAccess,
+	NODE.indexAccess,
+	NODE.call,
+	NODE.arrayExpr,
+	NODE.stringLiteral,
+	NODE.numericLiteral
+];
+/**
+* Stringifies expression, and wraps it in parentheses if they cannot be trivially omitted
+*/
+function wrapIfComplex(node, ident) {
+	const s = stringifyExpression(node, ident);
+	if (typeof node === "string" || typeof node === "boolean") return s;
+	if (SIMPLE_NODES.includes(node[0])) return s;
+	return `(${s})`;
+}
+
+//#endregion
+export { stringifyNode };

package/std/copy.d.ts

@@ -0,0 +1,7 @@
+import { DualFn } from "../types.js";
+
+//#region src/std/copy.d.ts
+declare function cpuCopy<T>(e: T): T;
+declare const copy: DualFn<typeof cpuCopy>;
+//#endregion
+export { copy };

package/std/copy.js

@@ -0,0 +1,27 @@
+import { WORKAROUND_getSchema, isMatInstance, isVecInstance } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+
+//#region src/std/copy.ts
+function cpuCopy(e) {
+	if (isVecInstance(e) || isMatInstance(e)) return WORKAROUND_getSchema(e)(e);
+	if (Array.isArray(e)) return e.map(cpuCopy);
+	if (typeof e === "object" && e !== null) return Object.fromEntries(Object.entries(e).map(([key, value]) => [key, cpuCopy(value)]));
+	return e;
+}
+const copy = dualImpl({
+	name: "copy",
+	signature: (arg) => {
+		return {
+			argTypes: [arg],
+			returnType: arg
+		};
+	},
+	normalImpl: cpuCopy,
+	codegenImpl(_ctx, [a]) {
+		return stitch`${a}`;
+	}
+});
+
+//#endregion
+export { copy };

package/std/index.d.ts

@@ -1,4 +1,5 @@
 import { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4 } from "../data/matrix.js";
+import { copy } from "./copy.js";
 import { discard } from "./discard.js";
 import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc } from "./numeric.js";
 import { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from "./operators.js";
@@ -16,7 +17,7 @@ import { range } from "./range.js";
 
 //#region src/std/index.d.ts
 declare namespace index_d_exports {
-  export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+  export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
 }
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

package/std/index.js

@@ -7,6 +7,7 @@ import { range } from "./range.js";
 import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
 import { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm } from "./packing.js";
 import { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.js";
+import { copy } from "./copy.js";
 import { discard } from "./discard.js";
 import { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
 import { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier } from "./atomic.js";
@@ -46,6 +47,7 @@ var std_exports = /* @__PURE__ */ __export({
 	bitcastU32toI32: () => bitcastU32toI32,
 	ceil: () => ceil,
 	clamp: () => clamp,
+	copy: () => copy,
 	cos: () => cos,
 	cosh: () => cosh,
 	countLeadingZeros: () => countLeadingZeros,
@@ -179,4 +181,4 @@ var std_exports = /* @__PURE__ */ __export({
 });
 
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, std_exports, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, std_exports, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

package/tgpuUnstable.js

@@ -2,9 +2,9 @@ import { __export } from "./_virtual/rolldown_runtime.js";
 import { comptime } from "./core/function/comptime.js";
 import { constant } from "./core/constant/tgpuConstant.js";
 import { fn } from "./core/function/tgpuFn.js";
-import { namespace } from "./core/resolve/namespace.js";
 import { slot } from "./core/slot/slot.js";
 import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
+import { namespace } from "./core/resolve/namespace.js";
 import { computeFn } from "./core/function/tgpuComputeFn.js";
 import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
 import { lazy } from "./core/slot/lazy.js";

package/tgsl/accessIndex.js

@@ -4,7 +4,7 @@ import { isEphemeralSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
-import { coerceToSnippet } from "./generationHelpers.js";
+import { ArrayExpression, coerceToSnippet } from "./generationHelpers.js";
 import { vec2f, vec3f, vec4f } from "../data/vector.js";
 import { accessProp } from "./accessProp.js";
 
@@ -28,6 +28,7 @@ function accessIndex(target, indexArg) {
 		else if (!isTargetEphemeral && !isElementNatEph) origin = target.origin;
 		else if (isIndexConstant && target.origin === "constant") origin = "constant";
 		else origin = "runtime";
+		if (target.value instanceof ArrayExpression && isKnownAtComptime(index)) return target.value.elements[index.value];
 		return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, elementType, origin);
 	}
 	if (isVec(target.dataType)) return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, target.dataType.primitive, target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");

package/tgsl/consoleLog/deserializers.js

@@ -103,7 +103,7 @@ function logDataFromGPU(resources) {
 			const { argTypes, op } = logIdToMeta.get(id);
 			const results = deserializeAndStringify(new Uint32Array(serializedData), argTypes);
 			if (results.length === 0) results.push("");
-			console[op](`%c${options.messagePrefix}%c ${results[0]}`, "background: #936ff5; color: white;", "color: inherit; background: none", ...results.slice(1));
+			op.bind(console)(`%c${options.messagePrefix}%c ${results[0]}`, "background: #936ff5; color: white;", "color: inherit; background: none", ...results.slice(1));
 		});
 	});
 	indexBuffer.read().then((totalCalls) => {

package/tgsl/consoleLog/logGenerator.js

@@ -12,7 +12,6 @@ import { shaderStageSlot } from "../../core/slot/internalSlots.js";
 import { arrayOf } from "../../data/array.js";
 import { atomic } from "../../data/atomic.js";
 import { createLoggingFunction } from "./serializers.js";
-import { supportedLogOps } from "./types.js";
 
 //#region src/tgsl/consoleLog/logGenerator.ts
 const defaultOptions = {
@@ -56,11 +55,7 @@ var LogGeneratorImpl = class {
 	*/
 	generateLog(ctx, op, args) {
 		if (shaderStageSlot.$ === "vertex") {
-			console.warn(`'console.${op}' is not supported in vertex shaders.`);
-			return fallbackSnippet;
-		}
-		if (!supportedLogOps.includes(op)) {
-			console.warn(`Unsupported log method '${op}'.`);
+			console.warn(`'console' operations are not supported in vertex shaders.`);
 			return fallbackSnippet;
 		}
 		const id = this.#firstUnusedId++;

package/tgsl/consoleLog/types.d.ts

@@ -1,10 +1,11 @@
 import "../../data/snippet.js";
 import { TgpuMutable } from "../../core/buffer/bufferShorthand.js";
 import "../generationHelpers.js";
+import { supportedLogOps } from "../jsPolyfills.js";
 import { AnyWgslData, Atomic, U32, WgslArray, WgslStruct } from "../../data/wgslTypes.js";
 
 //#region src/tgsl/consoleLog/types.d.ts
-
+type SupportedLogOp = ReturnType<typeof supportedLogOps>[number];
 /**
  * Options for configuring GPU log generation.
  */
@@ -32,7 +33,7 @@ type SerializedLogCallData = WgslStruct<{
   serializedData: WgslArray<U32>;
 }>;
 interface LogMeta {
-  op: SupportedLogOps;
+  op: SupportedLogOp;
   argTypes: (string | AnyWgslData)[];
 }
 /**
@@ -49,7 +50,5 @@ interface LogResources {
   options: Required<LogGeneratorOptions>;
   logIdToMeta: Map<number, LogMeta>;
 }
-declare const supportedLogOps: readonly ["log", "debug", "info", "warn", "error", "clear"];
-type SupportedLogOps = (typeof supportedLogOps)[number];
 //#endregion
-export { LogGeneratorOptions, LogResources };
+export { LogGeneratorOptions, LogResources, SupportedLogOp };

package/tgsl/conversion.js

@@ -158,7 +158,10 @@ function getBestConversion(types, targetTypes) {
 	if (implicitResult) return implicitResult;
 }
 function applyActionToSnippet(ctx, snippet, action, targetType) {
-	if (action.action === "none") return snip(snippet.value, targetType, snippet.origin);
+	if (action.action === "none") {
+		if (targetType === snippet.dataType) return snippet;
+		return snip(snippet.value, targetType, snippet.origin);
+	}
 	switch (action.action) {
 		case "ref": return snip(new RefOperator(snippet, targetType), targetType, snippet.origin);
 		case "deref": return derefSnippet(snippet);

package/tgsl/generationHelpers.d.ts

@@ -1,5 +1,6 @@
 import { Snippet } from "../data/snippet.js";
 import { ShelllessRepository } from "./shellless.js";
+import { SupportedLogOp } from "./consoleLog/types.js";
 import { FunctionScopeLayer, ResolutionCtx } from "../types.js";
 import { BaseData } from "../data/wgslTypes.js";
 
@@ -21,7 +22,7 @@ type GenerationCtx = ResolutionCtx & {
   dedent(): string;
   pushBlockScope(): void;
   popBlockScope(): void;
-  generateLog(op: string, args: Snippet[]): Snippet;
+  generateLog(op: SupportedLogOp, args: Snippet[]): Snippet;
   getById(id: string): Snippet | null;
   defineVariable(id: string, snippet: Snippet): void;
   setBlockExternals(externals: Record<string, Snippet>): void;

package/tgsl/jsPolyfills.d.ts

@@ -0,0 +1,25 @@
+import "../core/function/fnTypes.js";
+import "../types.js";
+
+//#region src/tgsl/jsPolyfills.d.ts
+declare const supportedLogOps: () => readonly [{
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (): void;
+  (): void;
+}];
+//#endregion
+export { supportedLogOps };

package/tgsl/jsPolyfills.js

@@ -0,0 +1,44 @@
+import { f32 } from "../data/numeric.js";
+import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, cos, cosh, countLeadingZeros, exp, floor, log, log2, max, min, pow, sign, sin, sinh, sqrt, tan, tanh, trunc } from "../std/numeric.js";
+
+//#region src/tgsl/jsPolyfills.ts
+const mathToStd = new Map([
+	[Math.abs, abs],
+	[Math.acos, acos],
+	[Math.acosh, acosh],
+	[Math.asin, asin],
+	[Math.asinh, asinh],
+	[Math.atan, atan],
+	[Math.atan2, atan2],
+	[Math.atanh, atanh],
+	[Math.ceil, ceil],
+	[Math.cos, cos],
+	[Math.cosh, cosh],
+	[Math.exp, exp],
+	[Math.floor, floor],
+	[Math.fround, f32],
+	[Math.clz32, countLeadingZeros],
+	[Math.trunc, trunc],
+	[Math.log, log],
+	[Math.log2, log2],
+	[Math.pow, pow],
+	[Math.sign, sign],
+	[Math.sin, sin],
+	[Math.sinh, sinh],
+	[Math.sqrt, sqrt],
+	[Math.tan, tan],
+	[Math.tanh, tanh],
+	[Math.max, max],
+	[Math.min, min]
+]);
+const supportedLogOps = () => [
+	console.log,
+	console.debug,
+	console.info,
+	console.warn,
+	console.error,
+	console.clear
+];
+
+//#endregion
+export { mathToStd, supportedLogOps };

package/tgsl/wgslGenerator.d.ts

@@ -13,9 +13,14 @@ declare class WgslGenerator implements ShaderGenerator {
   initGenerator(ctx: GenerationCtx): void;
   protected get ctx(): GenerationCtx;
   _block([_, statements]: tinyest.Block, externalMap?: ExternalMap): string;
+  _blockStatement(block: tinyest.Block, externalMap?: ExternalMap): string;
   refVariable(id: string, dataType: StorableData): string;
-  blockVariable(varType: 'var' | 'let' | 'const', id: string, dataType: BaseData | UnknownData, origin: Origin): Snippet;
-  protected emitVarDecl(pre: string, keyword: 'var' | 'let' | 'const', name: string, _dataType: BaseData | UnknownData, rhsStr: string): string;
+  blockVariable(varType: 'var' | 'let' | 'const' | '<deferred>', id: string, dataType: BaseData | UnknownData, origin: Origin): Snippet;
+  /**
+   * Creates a variable declaration string.
+   * `keyword` may be a placeholder filled in later.
+   */
+  protected emitVarDecl(pre: string, keyword: 'var' | 'let' | 'const' | `#VAR_${number}#`, name: string, _dataType: BaseData | UnknownData, rhsStr: string): string;
   _identifier(id: string): Snippet;
   /**
    * A wrapper for `generateExpression` that updates `ctx.expectedType`
@@ -33,6 +38,19 @@ declare class WgslGenerator implements ShaderGenerator {
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
   _return(statement: tinyest.Return): string;
   _statement(statement: tinyest.Statement): string;
+  /**
+   * Attempts a member access lookup to mark a variable as modified.
+   * @example
+   * // given `let a; a = 1;`
+   * tryMarkModified('a') // `a` is marked in the function scope
+   *
+   * // given `const obj; obj.prop = 1;`
+   * tryMarkModified('obj.prop') // `obj` is marked in the function scope
+   *
+   * // given `this.buffer.$;`
+   * tryMarkModified('this.buffer.$') // `this` is not marked, since there is no placeholder for it
+   */
+  private tryMarkModified;
 }
 //#endregion
 export { WgslGenerator };