typegpu 0.11.4 → 0.11.6

package/{nameRegistry.js → nameUtils.js}

@@ -1,6 +1,4 @@
-import { invariant } from "./errors.js";
-
-//#region src/nameRegistry.ts
+//#region src/nameUtils.ts
 const bannedTokens = new Set([
 	"alias",
 	"break",
@@ -344,106 +342,64 @@ const builtins = new Set([
 	"quadSwapX",
 	"quadSwapY"
 ]);
+/* @__NO_SIDE_EFFECTS__ */
 function sanitizePrimer(primer) {
-	if (primer) return primer.replaceAll(/\s/g, "_").replaceAll(/[^\w\d]/g, "");
+	if (primer) {
+		const base = primer.replaceAll(/\s/g, "_").replaceAll(/[^\w\d]/g, "");
+		if (base === "_" || base === "" || base.startsWith("__")) return "item";
+		return base;
+	}
 	return "item";
 }
 /**
 * A function for checking whether an identifier needs renaming.
 * Throws if provided with an invalid identifier that cannot be easily renamed.
 * @example
-* isValidIdentifier("ident"); // true
-* isValidIdentifier("struct"); // false
-* isValidIdentifier("struct_1"); // false
-* isValidIdentifier("_"); // ERROR
-* isValidIdentifier("my variable"); // ERROR
+* validateIdentifier("ident"); // { success: true }
+* validateIdentifier("struct"); // { success: false, error: "Identifiers cannot start with reserved keywords." }
+* validateIdentifier("struct_1"); { success: false, error: "Identifiers cannot start with reserved keywords." }
+* validateIdentifier("_"); // { success: false }
+* validateIdentifier("my variable"); // { success: false, error: "Identifiers cannot contain whitespace." }
 */
-function isValidIdentifier(ident) {
-	if (ident === "_" || ident.startsWith("__") || /\s/.test(ident)) throw new Error(`Invalid identifier '${ident}'. Choose an identifier without whitespaces or leading underscores.`);
+/* @__NO_SIDE_EFFECTS__ */
+function validateIdentifier(ident) {
+	if (ident === "_") return { success: false };
+	if (/\s/.test(ident)) return {
+		success: false,
+		error: `Identifiers cannot contain whitespace.`
+	};
+	if (ident.startsWith("__")) return {
+		success: false,
+		error: `Identifiers cannot start with double underscores.`
+	};
 	const prefix = ident.split("_")[0];
-	return !bannedTokens.has(prefix) && !builtins.has(prefix);
+	if (bannedTokens.has(prefix) || builtins.has(prefix)) return {
+		success: false,
+		error: `Identifiers cannot start with reserved keywords.`
+	};
+	return { success: true };
 }
 /**
-* Same as `isValidIdentifier`, except does not check for builtin clashes.
+* Same as `validateIdentifier`, except does not check for builtin clashes.
 */
-function isValidProp(ident) {
-	if (ident === "_" || ident.startsWith("__") || /\s/.test(ident)) throw new Error(`Invalid identifier '${ident}'. Choose an identifier without whitespaces or leading underscores.`);
+/* @__NO_SIDE_EFFECTS__ */
+function validateProp(ident) {
+	if (ident === "_") return { success: false };
+	if (/\s/.test(ident)) return {
+		success: false,
+		error: `Identifiers cannot contain whitespace.`
+	};
+	if (ident.startsWith("__")) return {
+		success: false,
+		error: `Identifiers cannot start with double underscores.`
+	};
 	const prefix = ident.split("_")[0];
-	return !bannedTokens.has(prefix);
+	if (bannedTokens.has(prefix)) return {
+		success: false,
+		error: `Identifiers cannot start with reserved keywords.`
+	};
+	return { success: true };
 }
-var NameRegistryImpl = class {
-	#usedNames;
-	#scopeStack;
-	constructor() {
-		this.#usedNames = new Set([...bannedTokens, ...builtins]);
-		this.#scopeStack = [];
-	}
-	get #usedBlockScopeNames() {
-		return this.#scopeStack[this.#scopeStack.length - 1]?.usedBlockScopeNames;
-	}
-	makeUnique(primer, global) {
-		const sanitizedPrimer = sanitizePrimer(primer);
-		const name = this.getUniqueVariant(sanitizedPrimer);
-		if (global) this.#usedNames.add(name);
-		else this.#usedBlockScopeNames?.add(name);
-		return name;
-	}
-	#isUsedInBlocksBefore(name) {
-		const functionScopeIndex = this.#scopeStack.findLastIndex((scope) => scope.type === "functionScope");
-		return this.#scopeStack.slice(functionScopeIndex + 1).some((scope) => scope.usedBlockScopeNames.has(name));
-	}
-	makeValid(primer) {
-		if (isValidIdentifier(primer) && !this.#usedNames.has(primer) && !this.#isUsedInBlocksBefore(primer)) {
-			this.#usedBlockScopeNames?.add(primer);
-			return primer;
-		}
-		return this.makeUnique(primer, false);
-	}
-	isUsed(name) {
-		return this.#usedNames.has(name) || this.#isUsedInBlocksBefore(name);
-	}
-	pushFunctionScope() {
-		this.#scopeStack.push({ type: "functionScope" });
-		this.#scopeStack.push({
-			type: "blockScope",
-			usedBlockScopeNames: /* @__PURE__ */ new Set()
-		});
-	}
-	popFunctionScope() {
-		const functionScopeIndex = this.#scopeStack.findLastIndex((scope) => scope.type === "functionScope");
-		if (functionScopeIndex === -1) throw new Error("Tried to pop function scope when no scope was present.");
-		this.#scopeStack.splice(functionScopeIndex);
-	}
-	pushBlockScope() {
-		this.#scopeStack.push({
-			type: "blockScope",
-			usedBlockScopeNames: /* @__PURE__ */ new Set()
-		});
-	}
-	popBlockScope() {
-		invariant(this.#scopeStack[this.#scopeStack.length - 1]?.type === "blockScope", "Tried to pop block scope, but it is not present");
-		this.#scopeStack.pop();
-	}
-};
-var RandomNameRegistry = class extends NameRegistryImpl {
-	#lastUniqueId = 0;
-	getUniqueVariant(base) {
-		let name = `${base}_${this.#lastUniqueId++}`;
-		while (this.isUsed(name)) name = `${base}_${this.#lastUniqueId++}`;
-		return name;
-	}
-};
-var StrictNameRegistry = class extends NameRegistryImpl {
-	getUniqueVariant(base) {
-		let index = 0;
-		let name = base;
-		while (this.isUsed(name)) {
-			index++;
-			name = `${base}_${index}`;
-		}
-		return name;
-	}
-};
 
 //#endregion
-export { RandomNameRegistry, StrictNameRegistry, isValidProp };
+export { bannedTokens, builtins, sanitizePrimer, validateIdentifier, validateProp };

package/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.11.4";
+var version = "0.11.6";
 
 //#endregion
 export { version };

package/package.json

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

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(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) {

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/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/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 };