typegpu 0.11.7 → 0.11.9

package/core/declare/tgpuDeclare.js

@@ -1,7 +1,7 @@
 import { $internal, $resolve } from "../../shared/symbols.js";
 import { Void } from "../../data/wgslTypes.js";
 import { snip } from "../../data/snippet.js";
-import { applyExternals, replaceExternalsInWgsl } from "../resolve/externals.js";
+import { replaceExternalsInWgsl } from "../resolve/externals.js";
 
 //#region src/core/declare/tgpuDeclare.ts
 /**
@@ -16,19 +16,18 @@ function declare(declaration) {
 }
 var TgpuDeclareImpl = class {
 	[$internal] = true;
-	#externalsToApply = [];
+	#externals;
 	#declaration;
 	constructor(declaration) {
 		this.#declaration = declaration;
 	}
 	$uses(dependencyMap) {
-		this.#externalsToApply.push(dependencyMap);
+		if (this.#externals !== void 0) throw new Error("Cannot call '$uses' multiple times. If you wish to override dependencies, use slots or accessors instead.");
+		this.#externals = dependencyMap;
 		return this;
 	}
 	[$resolve](ctx) {
-		const externalMap = {};
-		for (const externals of this.#externalsToApply) applyExternals(externalMap, externals);
-		const replacedDeclaration = replaceExternalsInWgsl(ctx, externalMap, this.#declaration);
+		const replacedDeclaration = replaceExternalsInWgsl(ctx, this.#externals ?? {}, this.#declaration);
 		ctx.addDeclaration(replacedDeclaration);
 		return snip("", Void, "constant");
 	}

package/core/function/fnCore.d.ts

@@ -0,0 +1,5 @@
+import "../../data/snippet.js";
+import "./fnTypes.js";
+import "../../types.js";
+import "../../data/wgslTypes.js";
+import "../resolve/externals.js";

package/core/function/fnCore.js

@@ -5,7 +5,7 @@ import { undecorate } from "../../data/dataTypes.js";
 import { snip } from "../../data/snippet.js";
 import { getAttributesString } from "../../data/attributes.js";
 import { validateIdentifier } from "../../nameUtils.js";
-import { applyExternals, replaceExternalsInWgsl } from "../resolve/externals.js";
+import { mergeFunctionExternals, replaceExternalsInWgsl } from "../resolve/externals.js";
 import { extractArgs } from "./extractArgs.js";
 
 //#region src/core/function/fnCore.ts
@@ -16,19 +16,19 @@ function createFnCore(implementation, functionType, workgroupSize) {
 	* initialized yet (like when accessing the Output struct of a vertex
 	* entry fn).
 	*/
-	const externalsToApply = [];
+	const externals = {};
 	return {
 		[$getNameForward]: typeof implementation === "function" ? implementation : void 0,
-		applyExternals(newExternals) {
-			externalsToApply.push(newExternals);
+		setExternals(key, newExternal) {
+			if (key === "userProvided" && "userProvided" in externals) throw new Error("Cannot call '$uses' multiple times. If you wish to override dependencies, use slots or accessors instead.");
+			externals[key] = newExternal;
+			if (externals.userProvided && externals.pluginProvided) throw new Error("Cannot call '$uses' on functions whose metadata was provided by unplugin-typegpu.");
 		},
 		resolve(ctx, argTypes, returnType, entryInput) {
-			const externalMap = {};
 			let attributes = "";
 			if (functionType === "compute") attributes = `@compute @workgroup_size(${workgroupSize?.join(", ")}) `;
 			else if (functionType === "vertex") attributes = `@vertex `;
 			else if (functionType === "fragment") attributes = `@fragment `;
-			for (const externals of externalsToApply) applyExternals(externalMap, externals);
 			const id = ctx.makeUniqueIdentifier(getName(this), "global");
 			if (typeof implementation === "string") {
 				if (!returnType) throw new Error("Explicit return type is required for string implementation");
@@ -36,10 +36,11 @@ function createFnCore(implementation, functionType, workgroupSize) {
 					for (const arg of entryInput.positionalArgs) {
 						const result = /* @__PURE__ */ validateIdentifier(arg.schemaKey);
 						if (!result.success) throw new Error(`Invalid argument name "${arg.schemaKey}"${result.error ? `: ${result.error}` : ""}`);
+						if (ctx.isIdentifierBanned(arg.schemaKey)) throw new Error(`Invalid argument name "${arg.schemaKey}", the identifier is a reserved keyword.`);
 					}
-					applyExternals(externalMap, { in: Object.fromEntries(entryInput.positionalArgs.map((a) => [a.schemaKey, a.schemaKey])) });
+					this.setExternals("args", { in: Object.fromEntries(entryInput.positionalArgs.map((a) => [a.schemaKey, a.schemaKey])) });
 				}
-				const replacedImpl = replaceExternalsInWgsl(ctx, externalMap, implementation);
+				const replacedImpl = replaceExternalsInWgsl(ctx, mergeFunctionExternals(externals), implementation);
 				let header = "";
 				let body = "";
 				if (functionType !== "normal" && entryInput) {
@@ -64,12 +65,12 @@ function createFnCore(implementation, functionType, workgroupSize) {
 				return snip(id, returnType, "runtime");
 			}
 			const pluginData = getFunctionMetadata(implementation);
-			const pluginExternals = pluginData?.externals;
-			if (pluginExternals) applyExternals(externalMap, Object.fromEntries(Object.entries(pluginExternals).filter(([name]) => !(name in externalMap))));
+			const pluginExternals = pluginData?.externals();
+			if (pluginExternals) this.setExternals("pluginProvided", pluginExternals);
 			const ast = pluginData?.ast;
 			if (!ast) throw new Error("Missing metadata for tgpu.fn function body (either missing 'use gpu' directive, or misconfigured `unplugin-typegpu`)");
 			const maybeSecondArg = ast.params[1];
-			if (maybeSecondArg && maybeSecondArg.type === "i" && functionType !== "normal") applyExternals(externalMap, { [maybeSecondArg.name]: undecorate(returnType) });
+			if (maybeSecondArg && maybeSecondArg.type === "i" && functionType !== "normal") this.setExternals("out", { [maybeSecondArg.name]: undecorate(returnType) });
 			const { code, returnType: actualReturnType } = ctx.resolveFunction({
 				functionType,
 				name: id,
@@ -79,7 +80,7 @@ function createFnCore(implementation, functionType, workgroupSize) {
 				params: ast.params,
 				returnType,
 				body: ast.body,
-				externalMap
+				externalMap: mergeFunctionExternals(externals)
 			});
 			ctx.addDeclaration(code);
 			return snip(id, actualReturnType, "runtime");

package/core/function/shelllessImpl.js

@@ -3,6 +3,9 @@ import { getName } from "../../shared/meta.js";
 import { createFnCore } from "./fnCore.js";
 
 //#region src/core/function/shelllessImpl.ts
+function isShelllessImpl(value) {
+	return value?.resourceType === "shellless-impl";
+}
 function createShelllessImpl(argTypes, implementation) {
 	const core = createFnCore(implementation, "normal");
 	return {
@@ -20,4 +23,4 @@ function createShelllessImpl(argTypes, implementation) {
 }
 
 //#endregion
-export { createShelllessImpl };
+export { createShelllessImpl, isShelllessImpl };

package/core/function/tgpuComputeFn.js

@@ -35,7 +35,7 @@ function createComputeFn(shell, workgroupSize, implementation, entryInput) {
 	return {
 		shell,
 		$uses(newExternals) {
-			core.applyExternals(newExternals);
+			core.setExternals("userProvided", newExternals);
 			return this;
 		},
 		[$internal]: true,

package/core/function/tgpuFn.js

@@ -46,7 +46,7 @@ function createFn(shell, _implementation) {
 		resourceType: "function",
 		[$internal]: { implementation },
 		$uses(newExternals) {
-			core.applyExternals(newExternals);
+			core.setExternals("userProvided", newExternals);
 			return this;
 		},
 		[$getNameForward]: core,
@@ -59,8 +59,8 @@ function createFn(shell, _implementation) {
 		}),
 		[$resolve](ctx) {
 			if (typeof implementation === "string") {
-				addArgTypesToExternals(implementation, shell.argTypes, core.applyExternals);
-				addReturnTypeToExternals(implementation, shell.returnType, core.applyExternals);
+				addArgTypesToExternals(implementation, shell.argTypes, core);
+				addReturnTypeToExternals(implementation, shell.returnType, core);
 			}
 			return core.resolve(ctx, shell.argTypes, shell.returnType);
 		}

package/core/function/tgpuFragmentFn.js

@@ -34,12 +34,12 @@ function isTgpuFragmentFn(value) {
 function createFragmentFn(shell, implementation) {
 	const core = createFnCore(implementation, "fragment");
 	const outputType = shell.returnType;
-	if (typeof implementation === "string") addReturnTypeToExternals(implementation, outputType, (externals) => core.applyExternals(externals));
+	if (typeof implementation === "string") addReturnTypeToExternals(implementation, outputType, core);
 	return {
 		shell,
 		outputType,
 		$uses(newExternals) {
-			core.applyExternals(newExternals);
+			core.setExternals("userProvided", newExternals);
 			return this;
 		},
 		[$internal]: true,
@@ -52,7 +52,7 @@ function createFragmentFn(shell, implementation) {
 		[$resolve](ctx) {
 			const entryInput = separateBuiltins(shell.in ?? {}, ctx.varyingLocations ?? {});
 			if (entryInput.dataSchema && isNamable(entryInput.dataSchema)) entryInput.dataSchema.$name(`${getName(this) ?? ""}_Input`);
-			core.applyExternals({ Out: outputType });
+			if (typeof implementation === "string") core.setExternals("out", { Out: outputType });
 			return ctx.withSlots([[shaderStageSlot, "fragment"]], () => core.resolve(ctx, [], shell.returnType, entryInput));
 		},
 		toString() {

package/core/function/tgpuVertexFn.js

@@ -37,7 +37,7 @@ function createVertexFn(shell, implementation) {
 	return {
 		shell,
 		$uses(newExternals) {
-			core.applyExternals(newExternals);
+			core.setExternals("userProvided", newExternals);
 			return this;
 		},
 		[$internal]: true,
@@ -48,7 +48,7 @@ function createVertexFn(shell, implementation) {
 		},
 		[$resolve](ctx) {
 			const outputWithLocation = createIoSchema(shell.out, ctx.varyingLocations).$name(`${getName(this) ?? ""}_Output`);
-			if (typeof implementation === "string") core.applyExternals({ Out: outputWithLocation });
+			if (typeof implementation === "string") core.setExternals("out", { Out: outputWithLocation });
 			return ctx.withSlots([[shaderStageSlot, "vertex"]], () => core.resolve(ctx, [], outputWithLocation, entryInput));
 		},
 		toString() {

package/core/rawCodeSnippet/tgpuRawCodeSnippet.js

@@ -2,7 +2,7 @@ import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symb
 import { snip } from "../../data/snippet.js";
 import { inCodegenMode } from "../../execMode.js";
 import { valueProxyHandler } from "../valueProxyUtils.js";
-import { applyExternals, replaceExternalsInWgsl } from "../resolve/externals.js";
+import { replaceExternalsInWgsl } from "../resolve/externals.js";
 
 //#region src/core/rawCodeSnippet/tgpuRawCodeSnippet.ts
 /**
@@ -51,22 +51,20 @@ var TgpuRawCodeSnippetImpl = class {
 	dataType;
 	origin;
 	#expression;
-	#externalsToApply;
+	#externals;
 	constructor(expression, type, origin) {
 		this[$internal] = true;
 		this.dataType = type;
 		this.origin = origin;
 		this.#expression = expression;
-		this.#externalsToApply = [];
 	}
 	$uses(dependencyMap) {
-		this.#externalsToApply.push(dependencyMap);
+		if (this.#externals !== void 0) throw new Error("Cannot call '$uses' multiple times. If you wish to override dependencies, use slots or accessors instead.");
+		this.#externals = dependencyMap;
 		return this;
 	}
 	[$resolve](ctx) {
-		const externalMap = {};
-		for (const externals of this.#externalsToApply) applyExternals(externalMap, externals);
-		return snip(replaceExternalsInWgsl(ctx, externalMap, this.#expression), this.dataType, this.origin);
+		return snip(replaceExternalsInWgsl(ctx, this.#externals ?? {}, this.#expression), this.dataType, this.origin);
 	}
 	toString() {
 		return `raw(${String(this.dataType)}): "${this.#expression}"`;

package/core/resolve/externals.d.ts

@@ -1,10 +1,11 @@
 import "../../types.js";
+import "../function/fnCore.js";
 
 //#region src/core/resolve/externals.d.ts
 
 /**
  * A key-value mapping where keys represent identifiers within shader code,
- * and values can be any type that can be resolved to a code string.
+ * and values can either be another ExternalMap, or be any type that can be resolved to a code string.
  */
 type ExternalMap = Record<string, unknown>;
 //#endregion

package/core/resolve/externals.js

@@ -1,32 +1,36 @@
 import { isWgslStruct } from "../../data/wgslTypes.js";
-import { getName, hasTinyestMetadata, setName } from "../../shared/meta.js";
+import { getName, hasTinyestMetadata, isNamable, setName } from "../../shared/meta.js";
 import { isLooseData } from "../../data/dataTypes.js";
 import { isWgsl } from "../../types.js";
 
 //#region src/core/resolve/externals.ts
+function isResolvable(value) {
+	return isWgsl(value) || isLooseData(value) || hasTinyestMetadata(value);
+}
 /**
-* Merges two external maps into one. If a key is present in both maps, the value from the new map is used.
-* If the external value is a namable object, it is given a name if it does not already have one.
-* @param existing - The existing external map.
-* @param newExternals - The new external map.
+* Merges function externals into one map.
 */
-function applyExternals(existing, newExternals) {
-	for (const [key, value] of Object.entries(newExternals)) {
-		existing[key] = value;
-		if (value && (typeof value === "object" || typeof value === "function") && getName(value) === void 0) setName(value, key);
+function mergeFunctionExternals(fnExternals) {
+	const base = fnExternals.pluginProvided ?? fnExternals.userProvided ?? {};
+	const result = Object.defineProperties({}, Object.getOwnPropertyDescriptors(base));
+	for (const flatExternal of [fnExternals.args, fnExternals.out].filter((e) => e !== void 0)) for (const [key, value] of Object.entries(flatExternal)) {
+		if (key in result && result[key] !== value) throw new Error(`Key '${key}' appears in externals despite already being used for argument/return type. Please rename this external.`);
+		result[key] = value;
 	}
+	return result;
 }
-function addArgTypesToExternals(implementation, argTypes, applyExternals$1) {
-	const argTypeNames = [...implementation.matchAll(/:\s*(?<arg>.*?)\s*[,)]/g)].map((found) => found ? found[1] : void 0);
-	applyExternals$1(Object.fromEntries(argTypes.flatMap((argType, i) => {
-		const argTypeName = argTypeNames ? argTypeNames[i] : void 0;
+function addArgTypesToExternals(implementation, argTypes, core) {
+	const argTypeNames = [...implementation.matchAll(/:\s*(?<arg>.*?)\s*[,)]/g)].map((found) => found?.[1]);
+	const args = Object.fromEntries(argTypes.flatMap((argType, i) => {
+		const argTypeName = argTypeNames?.[i];
 		return isWgslStruct(argType) && argTypeName !== void 0 ? [[argTypeName, argType]] : [];
-	})));
+	}));
+	core.setExternals("args", args);
 }
-function addReturnTypeToExternals(implementation, returnType, applyExternals$1) {
+function addReturnTypeToExternals(implementation, returnType, core) {
 	const matched = implementation.match(/->\s(?<output>[\w\d_]+)\s{/);
 	const outputName = matched ? matched[1]?.trim() : void 0;
-	if (isWgslStruct(returnType) && outputName && !/\s/g.test(outputName)) applyExternals$1({ [outputName]: returnType });
+	if (isWgslStruct(returnType) && outputName && !/\s/g.test(outputName)) core.setExternals("out", { [outputName]: returnType });
 }
 function identifierRegex(name) {
 	return new RegExp(`(?<![\\w\\$_.])${name.replaceAll(".", "\\.").replaceAll("$", "\\$")}(?![\\w\\$_])`, "g");
@@ -44,7 +48,10 @@ function replaceExternalsInWgsl(ctx, externalMap, wgsl) {
 	return Object.entries(externalMap).reduce((acc, [externalName, external]) => {
 		const externalRegex = identifierRegex(externalName);
 		if (wgsl && externalName !== "Out" && externalName !== "in" && !externalRegex.test(wgsl)) console.warn(`The external '${externalName}' wasn't used in the resolved template.`);
-		if (isWgsl(external) || isLooseData(external) || hasTinyestMetadata(external)) return acc.replaceAll(externalRegex, ctx.resolve(external).value);
+		if (isResolvable(external)) {
+			if (isNamable(external) && getName(external) === void 0) setName(external, externalName.split(".").at(-1));
+			return acc.replaceAll(externalRegex, ctx.resolve(external).value);
+		}
 		if (external !== null && typeof external === "object") {
 			const foundProperties = [...wgsl.matchAll(new RegExp(`${externalName.replaceAll(".", "\\.").replaceAll("$", "\\$")}\\.(?<prop>.*?)(?![\\w\\$_])`, "g"))].map((found) => found[1]);
 			return [...new Set(foundProperties)].reduce((innerAcc, prop) => prop && prop in external ? replaceExternalsInWgsl(ctx, { [`${externalName}.${prop}`]: external[prop] }, innerAcc) : innerAcc, acc);
@@ -55,4 +62,4 @@ function replaceExternalsInWgsl(ctx, externalMap, wgsl) {
 }
 
 //#endregion
-export { addArgTypesToExternals, addReturnTypeToExternals, applyExternals, replaceExternalsInWgsl };
+export { addArgTypesToExternals, addReturnTypeToExternals, mergeFunctionExternals, replaceExternalsInWgsl };

package/core/resolve/tgpuResolve.js

@@ -1,7 +1,7 @@
 import { $internal, $resolve } from "../../shared/symbols.js";
 import { Void } from "../../data/wgslTypes.js";
 import { snip } from "../../data/snippet.js";
-import { applyExternals, replaceExternalsInWgsl } from "./externals.js";
+import { replaceExternalsInWgsl } from "./externals.js";
 import { isBindGroupLayout } from "../../tgpuBindGroupLayout.js";
 import { resolve } from "../../resolutionCtx.js";
 import { isPipeline } from "../pipeline/typeGuards.js";
@@ -19,12 +19,10 @@ function resolve$1(arg, options) {
 function resolveFromTemplate(options) {
 	const { template, externals, unstable_shaderGenerator: shaderGenerator, names = "strict", config, enableExtensions } = options;
 	if (!template) console.warn("Calling resolve with an empty template is deprecated and will soon return an empty string. Consider using the 'tgpu.resolve(resolvableArray, options)' API instead.");
-	const dependencies = {};
-	applyExternals(dependencies, externals ?? {});
 	return resolve({
 		[$internal]: true,
 		[$resolve](ctx) {
-			return snip(replaceExternalsInWgsl(ctx, dependencies, template ?? ""), Void, "runtime");
+			return snip(replaceExternalsInWgsl(ctx, externals, template ?? ""), Void, "runtime");
 		},
 		toString: () => "<root>"
 	}, {

package/core/root/init.js

@@ -1,5 +1,5 @@
 import { $getNameForward, $internal } from "../../shared/symbols.js";
-import { setName } from "../../shared/meta.js";
+import { getName, setName } from "../../shared/meta.js";
 import { invariant } from "../../errors.js";
 import { isAccessor, isMutableAccessor } from "../slot/slotTypes.js";
 import { u32 } from "../../data/numeric.js";
@@ -116,6 +116,7 @@ var WithBindingImpl = class WithBindingImpl {
 			u32,
 			u32
 		])(callback);
+		if (getName(wrappedCallback) === void 0) wrappedCallback.$name("wrappedCallback");
 		const sizeUniform = root.createUniform(vec3u);
 		const mainCompute = computeFn({
 			workgroupSize,

package/core/root/rootTypes.d.ts

@@ -355,6 +355,15 @@ interface RenderBundleEncoderPass {
    */
   drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
 }
+type Replace<T$1, R> = Omit<T$1, keyof R> & R;
+/**
+ * The same as {@link GPURenderPassDescriptor}, but accepting readonly tuples as the clearValue
+ */
+type TgpuRenderPassDescriptor = Replace<GPURenderPassDescriptor, {
+  colorAttachments: (Replace<GPURenderPassColorAttachment, {
+    clearValue?: readonly [number, number, number, number] | GPUColor | undefined;
+  }> | null)[];
+}>;
 interface RenderPass extends RenderBundleEncoderPass {
   /**
    * Sets the viewport used during the rasterization stage to linearly map from
@@ -611,7 +620,7 @@ interface ExperimentalTgpuRoot extends Omit<TgpuRoot, 'with'>, Withable_Deprecat
   readonly shaderGenerator?: ShaderGenerator | undefined;
   /** @deprecated Use `root.createTexture` instead. */
   createTexture<TWidth extends number, THeight extends number, TDepth extends number, TSize extends readonly [TWidth] | readonly [TWidth, THeight] | readonly [TWidth, THeight, TDepth], TFormat extends GPUTextureFormat, TMipLevelCount extends number, TSampleCount extends number, TViewFormats extends GPUTextureFormat[], TDimension extends GPUTextureDimension>(props: CreateTextureOptions<TSize, TFormat, TMipLevelCount, TSampleCount, TViewFormats, TDimension>): TgpuTexture<CreateTextureResult<TSize, TFormat, TMipLevelCount, TSampleCount, TViewFormats, TDimension>>;
-  beginRenderPass(descriptor: GPURenderPassDescriptor, callback: (pass: RenderPass) => void): void;
+  beginRenderPass(descriptor: TgpuRenderPassDescriptor, callback: (pass: RenderPass) => void): void;
   /**
    * Creates a {@link GPURenderBundle} by recording draw commands into a
    * {@link GPURenderBundleEncoder}. The resulting bundle can be replayed in a

package/core/slot/accessor.js

@@ -79,7 +79,7 @@ var TgpuAccessorImpl = class extends AccessorBase {
 	}
 	get $() {
 		if (inCodegenMode()) return this[$gpuValueOf];
-		throw new Error("`tgpu.accessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call");
+		throw new Error("`tgpu.accessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call. Use `tgpu.slot` for non-WGSL values instead.");
 	}
 };
 var TgpuMutableAccessorImpl = class extends AccessorBase {
@@ -89,7 +89,7 @@ var TgpuMutableAccessorImpl = class extends AccessorBase {
 	}
 	get $() {
 		if (inCodegenMode()) return this[$gpuValueOf];
-		throw new Error("`tgpu.mutableAccessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call");
+		throw new Error("`tgpu.mutableAccessor` relies on GPU resources and cannot be accessed outside of a compute dispatch or draw call. Use `tgpu.slot` for non-WGSL values instead.");
 	}
 };
 

package/data/compiledIO.js

@@ -139,6 +139,7 @@ function buildWriter(node, offsetExpr, valueExpr, depth = 0, partial = false) {
 			return subSchema ? go(subSchema, `(${offsetExpr$1} + ${propOffset.offset})`, `${valueExpr$1}.${key}`, depth$1) : "";
 		}).join("");
 		if (isWgslArray(node$1) || isDisarray(node$1)) {
+			if (node$1.elementCount === 0) throw new Error("Cannot write using a runtime-sized schema.");
 			const elementSize = roundUp(sizeOf(node$1.elementType), alignmentOf(node$1));
 			const totalSize = node$1.elementCount * elementSize;
 			const copyLen = partial ? `Math.min(${valueExpr$1}.byteLength, Math.max(0, endOffset - (${offsetExpr$1})))` : `Math.min(${valueExpr$1}.byteLength, ${totalSize})`;

package/data/numeric.js

@@ -1,4 +1,5 @@
 import { $internal } from "../shared/symbols.js";
+import { FiniteMathAssumptionError } from "../errors.js";
 import { callableSchema } from "../core/function/createCallableSchema.js";
 
 //#region src/data/numeric.ts
@@ -11,7 +12,7 @@ const boolCast = callableSchema({
 		if (typeof v === "boolean") return v;
 		return !!v;
 	},
-	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(bool, args)
+	codegenImpl: (ctx, [v]) => ctx.gen.typeInstantiation(bool, v ? [v] : [])
 });
 /**
 * A schema that represents a boolean value. (equivalent to `bool` in WGSL)
@@ -38,6 +39,7 @@ const u32Cast = callableSchema({
 	normalImpl(v) {
 		if (v === void 0) return 0;
 		if (typeof v === "boolean") return v ? 1 : 0;
+		if (!Number.isFinite(v)) throw new FiniteMathAssumptionError(v, u32);
 		if (!Number.isInteger(v)) {
 			const truncated = Math.trunc(v);
 			if (truncated < 0) return 0;
@@ -46,7 +48,7 @@ const u32Cast = callableSchema({
 		}
 		return (v & 4294967295) >>> 0;
 	},
-	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(u32, args)
+	codegenImpl: (ctx, [v]) => ctx.gen.typeInstantiation(u32, v ? [v] : [])
 });
 /**
 * A schema that represents an unsigned 32-bit integer value. (equivalent to `u32` in WGSL)
@@ -75,9 +77,10 @@ const i32Cast = callableSchema({
 	normalImpl(v) {
 		if (v === void 0) return 0;
 		if (typeof v === "boolean") return v ? 1 : 0;
+		if (!Number.isFinite(v)) throw new FiniteMathAssumptionError(v, i32);
 		return v | 0;
 	},
-	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(i32, args)
+	codegenImpl: (ctx, [v]) => ctx.gen.typeInstantiation(i32, v ? [v] : [])
 });
 const u16 = {
 	[$internal]: {},
@@ -108,9 +111,10 @@ const f32Cast = callableSchema({
 	normalImpl(v) {
 		if (v === void 0) return 0;
 		if (typeof v === "boolean") return v ? 1 : 0;
+		if (!Number.isFinite(v)) throw new FiniteMathAssumptionError(v, f32);
 		return Math.fround(v);
 	},
-	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(f32, args)
+	codegenImpl: (ctx, [v]) => ctx.gen.typeInstantiation(f32, v ? [v] : [])
 });
 /**
 * A schema that represents a 32-bit float value. (equivalent to `f32` in WGSL)
@@ -182,9 +186,10 @@ const f16Cast = callableSchema({
 	normalImpl(v) {
 		if (v === void 0) return 0;
 		if (typeof v === "boolean") return v ? 1 : 0;
+		if (!Number.isFinite(v)) throw new FiniteMathAssumptionError(v, f16);
 		return roundToF16(v);
 	},
-	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(f16, args)
+	codegenImpl: (ctx, [v]) => ctx.gen.typeInstantiation(f16, v ? [v] : [])
 });
 /**
 * A schema that represents a 16-bit float value. (equivalent to `f16` in WGSL)

package/errors.js

@@ -122,6 +122,12 @@ var SignatureNotSupportedError = class SignatureNotSupportedError extends Error
 		Object.setPrototypeOf(this, SignatureNotSupportedError.prototype);
 	}
 };
+var FiniteMathAssumptionError = class FiniteMathAssumptionError extends Error {
+	constructor(value, type) {
+		super(`Cannot convert value '${value}' to type ${type.type} because of the Finite Math Assumption (see: https://www.w3.org/TR/WGSL/#finite-math-assumption)`);
+		Object.setPrototypeOf(this, FiniteMathAssumptionError.prototype);
+	}
+};
 
 //#endregion
-export { ExecutionError, IllegalBufferAccessError, IllegalVarAccessError, MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, SignatureNotSupportedError, WgslTypeError, invariant };
+export { ExecutionError, FiniteMathAssumptionError, IllegalBufferAccessError, IllegalVarAccessError, MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, SignatureNotSupportedError, WgslTypeError, invariant };

package/nameUtils.js

@@ -342,28 +342,34 @@ const builtins = new Set([
 	"quadSwapX",
 	"quadSwapY"
 ]);
+/**
+* Sanitizes the primer so that it is compliant with WGSL guidelines.
+* This primer is not necessarily a valid identifier yet, as it may still collide with other idents or reserved keywords.
+*/
 /* @__NO_SIDE_EFFECTS__ */
 function sanitizePrimer(primer) {
 	if (primer) {
-		const base = primer.replaceAll(/\s/g, "_").replaceAll(/[^\w\d]/g, "");
-		if (base === "_" || base === "" || base.startsWith("__")) return "item";
+		const base = primer.replaceAll(/\s/g, "_").replaceAll(/[^\w]/g, "");
+		if (!(/* @__PURE__ */ validateIdentifier(base)).success) 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.
+* A function for checking whether an identifier is valid.
+* If `ident` passes the checks, it is not necessarily a valid identifier yet, as it may still collide with other idents or reserved keywords.
 * @example
 * 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("_"); // { success: false, error: `Identifiers cannot be equal to '' or '_'` }
 * validateIdentifier("my variable"); // { success: false, error: "Identifiers cannot contain whitespace." }
+* validateIdentifier("0"); // { success: false, error: "Identifier is not compliant with the WGSL guideline." }
 */
 /* @__NO_SIDE_EFFECTS__ */
 function validateIdentifier(ident) {
-	if (ident === "_") return { success: false };
+	if (ident === "_" || ident === "") return {
+		success: false,
+		error: `Identifiers cannot be equal to '' or '_'`
+	};
 	if (/\s/.test(ident)) return {
 		success: false,
 		error: `Identifiers cannot contain whitespace.`
@@ -372,29 +378,20 @@ function validateIdentifier(ident) {
 		success: false,
 		error: `Identifiers cannot start with double underscores.`
 	};
-	const prefix = ident.split("_")[0];
-	if (bannedTokens.has(prefix) || builtins.has(prefix)) return {
+	if (!/^(([_\p{XID_Start}][\p{XID_Continue}]+)|([\p{XID_Start}]))$/u.test(ident)) return {
 		success: false,
-		error: `Identifiers cannot start with reserved keywords.`
+		error: `Not compliant with WGSL guidelines.`
 	};
 	return { success: true };
 }
 /**
-* Same as `validateIdentifier`, except does not check for builtin clashes.
+* Same as `validateIdentifier`, except also checks for bannedToken clashes.
 */
 /* @__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];
-	if (bannedTokens.has(prefix)) return {
+	const identResult = /* @__PURE__ */ validateIdentifier(ident);
+	if (!identResult.success) return identResult;
+	if (bannedTokens.has(ident)) return {
 		success: false,
 		error: `Identifiers cannot start with reserved keywords.`
 	};

package/package.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.11.7",
+  "version": "0.11.9",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",
@@ -22,7 +22,6 @@
     "url": "git+https://github.com/software-mansion/TypeGPU.git",
     "directory": "packages/typegpu"
   },
-  "bin": "./bin.mjs",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -55,5 +54,8 @@
   "main": "./index.js",
   "types": "./index.d.ts",
   "private": false,
-  "scripts": {}
+  "scripts": {},
+  "bin": {
+    "typegpu": "./bin.mjs"
+  }
 }

package/resolutionCtx.js

@@ -1,7 +1,7 @@
 import { $internal, $providing, $resolve, isMarkedInternal } from "./shared/symbols.js";
 import { Void, isPtr, isWgslArray, isWgslStruct } from "./data/wgslTypes.js";
 import { safeStringify } from "./shared/stringify.js";
-import { getName, hasTinyestMetadata, setName } from "./shared/meta.js";
+import { getName, hasTinyestMetadata, isNamable, setName } from "./shared/meta.js";
 import { UnknownData, isData } from "./data/dataTypes.js";
 import { snip } from "./data/snippet.js";
 import { MissingSlotValueError, ResolutionError, WgslTypeError, invariant } from "./errors.js";
@@ -11,7 +11,7 @@ import { provideCtx, topLevelState } from "./execMode.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 { bannedTokens, 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";
@@ -22,6 +22,7 @@ import { naturalsExcept } from "./shared/generators.js";
 import { TgpuBindGroupImpl, bindGroupLayout } from "./tgpuBindGroupLayout.js";
 import { LogGeneratorImpl, LogGeneratorNullImpl } from "./tgsl/consoleLog/logGenerator.js";
 import wgslGenerator_default from "./tgsl/wgslGenerator.js";
+import { isShelllessImpl } from "./core/function/shelllessImpl.js";
 import { FuncParameterType } from "tinyest";
 
 //#region src/resolutionCtx.ts
@@ -112,6 +113,7 @@ var ItemStateStackImpl = class {
 				const access = layer.argAccess[id];
 				if (access) return access();
 				const external = layer.externalMap[id];
+				if (isNamable(external) && getName(external) === void 0) setName(external, id);
 				if (external !== void 0 && external !== null) return coerceToSnippet(external);
 				return;
 			}
@@ -257,6 +259,9 @@ var ResolutionCtxImpl = class {
 		this.#logGenerator = opts.root ? new LogGeneratorImpl(opts.root) : new LogGeneratorNullImpl();
 		this.#namespaceInternal = opts.namespace[$internal];
 	}
+	isIdentifierBanned(name) {
+		return bannedTokens.has(name);
+	}
 	isIdentifierTaken(name) {
 		return this.#namespaceInternal.takenGlobalIdentifiers.has(name) || this._itemStateStack.isIdentifierTakenLocally(name);
 	}
@@ -558,7 +563,7 @@ var ResolutionCtxImpl = class {
 		}
 	}
 	resolve(item, schema) {
-		if (isTgpuFn(item) || hasTinyestMetadata(item)) {
+		if (isTgpuFn(item) || isShelllessImpl(item)) {
 			if (this.#currentlyResolvedItems.has(item) && !this.#namespaceInternal.memoizedResolves.has(item)) throw new Error(`Recursive function ${item} detected. Recursion is not allowed on the GPU.`);
 			this.#currentlyResolvedItems.add(item);
 		}

package/shared/normalizeMetadata.js

@@ -20,7 +20,8 @@ function normalizeExternalsV2(externals) {
 }
 function normalizeMetadata(meta) {
 	if (meta.v === 1) {
-		const externals = typeof meta?.externals === "function" ? meta.externals() : meta?.externals;
+		const rawExternals = meta.externals;
+		const externals = typeof rawExternals === "function" ? rawExternals : () => rawExternals;
 		return {
 			...meta,
 			externals
@@ -30,7 +31,7 @@ function normalizeMetadata(meta) {
 		const externals = normalizeExternalsV2(meta?.externals);
 		return {
 			...meta,
-			externals
+			externals: () => externals
 		};
 	}
 	throw new Error(`Unrecognized TypeGPU metadata format: ${safeStringify(meta)}`);

package/tgsl/accessProp.js

@@ -1,9 +1,11 @@
 import { isMat, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { MatrixColumnsAccess, UnknownData, isUnstruct, undecorate } from "../data/dataTypes.js";
+import { getName, isNamable, setName } from "../shared/meta.js";
+import { MatrixColumnsAccess, UnknownData, isUnstruct } from "../data/dataTypes.js";
 import { isSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
+import { accessStructProp } from "./accessStructProp.js";
 import { bool, f16, f32, i32, u32 } from "../data/numeric.js";
 import { coerceToSnippet, numericLiteralToSnippet } from "./generationHelpers.js";
 import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../data/vector.js";
@@ -71,12 +73,7 @@ function accessProp(target, propName) {
 		return numericLiteralToSnippet(target.dataType.elementCount);
 	}
 	if (isMat(target.dataType) && propName === "columns") return snip(new MatrixColumnsAccess(target), UnknownData, target.origin, target.possibleSideEffects);
-	if (isWgslStruct(target.dataType) || isUnstruct(target.dataType)) {
-		let propType = target.dataType.propTypes[propName];
-		if (!propType) return;
-		propType = undecorate(propType);
-		return snip(stitch`${target}.${propName}`, propType, target.origin, target.possibleSideEffects);
-	}
+	if (isWgslStruct(target.dataType) || isUnstruct(target.dataType)) return accessStructProp(target, propName);
 	if (target.dataType instanceof AutoStruct) {
 		const result = target.dataType.accessProp(propName);
 		if (!result) return;
@@ -102,7 +99,11 @@ function accessProp(target, propName) {
 		if (!swizzleType) return;
 		return snip(isKnownAtComptime(target) ? target.value[propName] : stitch`${target}.${propName}`, swizzleType, propLength === 1 ? target.origin : target.origin === "constant" || target.origin === "constant-immutable-def" ? "constant" : "runtime", target.possibleSideEffects);
 	}
-	if (isKnownAtComptime(target) || target.dataType === UnknownData) return coerceToSnippet(target.value[propName]);
+	if (isKnownAtComptime(target) || target.dataType === UnknownData) {
+		const prop = target.value[propName];
+		if (isNamable(prop) && getName(prop) === void 0) setName(prop, propName);
+		return coerceToSnippet(prop);
+	}
 }
 
 //#endregion

package/tgsl/accessStructProp.js

@@ -0,0 +1,20 @@
+import { isWgslStruct } from "../data/wgslTypes.js";
+import { isUnstruct, undecorate } from "../data/dataTypes.js";
+import { snip } from "../data/snippet.js";
+import { invariant } from "../errors.js";
+import { stitch } from "../core/resolve/stitch.js";
+
+//#region src/tgsl/accessStructProp.ts
+/**
+* This function is separate from `accessProp` to avoid a circular dependency.
+*/
+function accessStructProp(target, propName) {
+	invariant(isWgslStruct(target.dataType) || isUnstruct(target.dataType), "Expected snippet type to be struct/unstruct.");
+	let propType = target.dataType.propTypes[propName];
+	if (!propType) return;
+	propType = undecorate(propType);
+	return snip(stitch`${target}.${propName}`, propType, target.origin, target.possibleSideEffects);
+}
+
+//#endregion
+export { accessStructProp };

package/tgsl/conversion.js

@@ -1,13 +1,15 @@
 import { DEV, TEST } from "../shared/env.js";
-import { isMat, isPtr, isVec } from "../data/wgslTypes.js";
+import { isMat, isPtr, isVec, isWgslStruct } from "../data/wgslTypes.js";
 import { safeStringify } from "../shared/stringify.js";
+import { getName } from "../shared/meta.js";
 import { UnknownData, undecorate } from "../data/dataTypes.js";
-import { snip, withDataType } from "../data/snippet.js";
+import { isAlias, snip, withDataType } from "../data/snippet.js";
 import { WgslTypeError, invariant } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { RefOperator, derefSnippet } from "../data/ref.js";
 import { schemaCallWrapperGPU } from "../data/schemaCallWrapper.js";
 import { assertExhaustive } from "../shared/utilityTypes.js";
+import { accessStructProp } from "./accessStructProp.js";
 
 //#region src/tgsl/conversion.ts
 const INFINITE_RANK = {
@@ -17,10 +19,17 @@ const INFINITE_RANK = {
 function getAutoConversionRank(src, dest) {
 	const trueSrc = undecorate(src);
 	const trueDst = undecorate(dest);
-	if (trueSrc.type === trueDst.type) return {
-		rank: 0,
-		action: "none"
-	};
+	if (trueSrc.type === trueDst.type) {
+		if (trueSrc.type === "struct" && trueSrc !== trueDst) return {
+			rank: 1,
+			action: "cast",
+			targetType: dest
+		};
+		return {
+			rank: 0,
+			action: "none"
+		};
+	}
 	if (trueSrc.type === "abstractFloat") {
 		if (trueDst.type === "f32") return {
 			rank: 1,
@@ -165,7 +174,22 @@ function applyActionToSnippet(ctx, snippet, action, targetType) {
 	switch (action.action) {
 		case "ref": return snip(new RefOperator(snippet, targetType), targetType, snippet.origin);
 		case "deref": return derefSnippet(snippet);
-		case "cast": return schemaCallWrapperGPU(ctx, targetType, snippet);
+		case "cast":
+			if (isWgslStruct(snippet.dataType) && isWgslStruct(targetType)) {
+				const typeName = getName(snippet.dataType) ?? "<unnamed>";
+				const targetName = getName(targetType) ?? "<unnamed>";
+				if (!isAlias(snippet)) throw new Error(`Cannot resolve struct cast from '${typeName}' to '${targetName}'. Store the value to a variable first, then cast it.`);
+				const propSnips = Object.entries(targetType.propTypes).map(([key, dataType]) => {
+					const accessedProp = accessStructProp(snippet, key);
+					if (!accessedProp) throw new Error(`Cannot auto-convert struct '${typeName}' to '${targetName}' because the property '${key}' is missing.`);
+					const converted = convertToCommonType(ctx, [accessedProp], [dataType]);
+					if (!converted || !converted[0]) throw new Error(`Cannot auto-convert struct '${typeName}' to '${targetName}' because type '${getName(accessedProp.dataType) ?? "<unnamed>"}' is not convertible to '${getName(undecorate(dataType)) ?? "<unnamed>"}'.`);
+					return converted[0];
+				});
+				const targetSnippet = ctx.resolve(targetType).value;
+				return snip(`${targetSnippet}(${propSnips.map((snip$1) => snip$1.value).join(", ")})`, targetType, "runtime", false);
+			}
+			return schemaCallWrapperGPU(ctx, targetType, snippet);
 		default: assertExhaustive(action.action, "applyActionToSnippet");
 	}
 }

package/tgsl/wgslGenerator.js

@@ -232,7 +232,19 @@ ${this.ctx.pre}}`;
 			if (rhsExpr.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot assign a ref to an existing variable '${stringifyNode(lhs)}', define a new variable instead.`);
 			if (op === "==") throw new Error("Please use the === operator instead of ==");
 			if (op === "!=") throw new Error("Please use the !== operator instead of !=");
-			if (op === "===" && isKnownAtComptime(lhsExpr) && isKnownAtComptime(rhsExpr)) return snip(lhsExpr.value === rhsExpr.value, bool, "constant");
+			if (op === "===" && isKnownAtComptime(lhsExpr) && isKnownAtComptime(rhsExpr)) return snip(lhsExpr.value === rhsExpr.value, bool, "constant", false);
+			if (op === "!==" && isKnownAtComptime(lhsExpr) && isKnownAtComptime(rhsExpr)) return snip(lhsExpr.value !== rhsExpr.value, bool, "constant", false);
+			if ((op === "<" || op === "<=" || op === ">" || op === ">=") && isKnownAtComptime(lhsExpr) && isKnownAtComptime(rhsExpr)) {
+				const left = lhsExpr.value;
+				const right = rhsExpr.value;
+				if (typeof left !== "number" || typeof right !== "number") throw new WgslTypeError(`Inequality comparison '${op}' requires numeric operands, got '${typeof left}' and '${typeof right}'`);
+				switch (op) {
+					case "<": return snip(left < right, bool, "constant", false);
+					case "<=": return snip(left <= right, bool, "constant", false);
+					case ">": return snip(left > right, bool, "constant", false);
+					case ">=": return snip(left >= right, bool, "constant", false);
+				}
+			}
 			if (lhsExpr.dataType === UnknownData) throw new WgslTypeError(`Left-hand side of '${op}' is of unknown type`);
 			if (rhsExpr.dataType === UnknownData) throw new WgslTypeError(`Right-hand side of '${op}' is of unknown type`);
 			const codegen = binaryOpCodeToCodegen[op];
@@ -475,6 +487,7 @@ ${this.ctx.pre}}`;
 		return snip(stitch`${this.ctx.resolve(schema).value}(${args})`, schema, "runtime");
 	}
 	numericLiteral(value, schema) {
+		if (!Number.isFinite(value)) throw new Error(`Value '${value}' (${schema.type}) cannot be resolved due to WGSL's Finite Math Assumption (see: https://www.w3.org/TR/WGSL/#finite-math-assumption). This value might be a result of a comptime-evaluated operation.`);
 		if (schema.type === "abstractInt") return snip(`${value}`, schema, "constant");
 		if (schema.type === "u32") return snip(`${value}u`, schema, "constant");
 		if (schema.type === "i32") return snip(`${value}i`, schema, "constant");

package/types.d.ts

@@ -260,6 +260,7 @@ interface ResolutionCtx {
    * @returns an identifier that is unique within the given scope
    */
   makeUniqueIdentifier(primer: string | undefined, scope: 'global' | 'block'): string;
+  isIdentifierBanned(name: string): boolean;
   isIdentifierTaken(name: string): boolean;
   /**
    * Makes sure the given identifier cannot be generated by {@link makeUniqueIdentifier}