typegpu 0.11.2 → 0.11.3

package/core/function/autoIO.js

@@ -37,7 +37,7 @@ var AutoFragmentFn = class {
 	autoOut;
 	constructor(impl, varyings, locations) {
 		if (!getName(impl)) setName(impl, "fragmentFn");
-		this.#core = createFnCore(impl, "@fragment ");
+		this.#core = createFnCore(impl, "fragment");
 		this.autoIn = new AutoStruct({
 			...builtinFragmentIn,
 			...varyings
@@ -64,7 +64,7 @@ var AutoVertexFn = class {
 	autoOut;
 	constructor(impl, attribs, locations) {
 		if (!getName(impl)) setName(impl, "vertexFn");
-		this.#core = createFnCore(impl, "@vertex ");
+		this.#core = createFnCore(impl, "vertex");
 		this.autoIn = new AutoStruct({
 			...builtinVertexIn,
 			...attribs

package/core/function/entryInputRouter.js

@@ -1,7 +1,5 @@
 import { $internal } from "../../shared/symbols.js";
 import { isWgslStruct } from "../../data/wgslTypes.js";
-import { undecorate } from "../../data/dataTypes.js";
-import { snip } from "../../data/snippet.js";
 
 //#region src/core/function/entryInputRouter.ts
 /**
@@ -12,28 +10,24 @@ import { snip } from "../../data/snippet.js";
 var EntryInputRouter = class {
 	[$internal] = {};
 	type = "entry-input-router";
-	structArgName;
-	dataSchema;
+	structArg;
 	/** Maps schemaKey → { WGSL arg name, type } */
 	positionalArgsMap;
-	constructor(structArgName, dataSchema, positionalArgs) {
-		this.structArgName = structArgName;
-		this.dataSchema = dataSchema;
-		this.positionalArgsMap = new Map(positionalArgs.map((a) => [a.schemaKey, {
-			argName: a.argName,
-			type: a.type
-		}]));
+	constructor(structArg, positionalArgs) {
+		this.structArg = structArg;
+		this.positionalArgsMap = new Map(positionalArgs.map((a) => [a.schemaKey, a.arg]));
 	}
 	toString() {
 		return "entry-input-router";
 	}
 	accessProp(propName) {
 		const positionalEntry = this.positionalArgsMap.get(propName);
-		if (positionalEntry) return snip(positionalEntry.argName, positionalEntry.type, "argument");
-		if (this.dataSchema && isWgslStruct(this.dataSchema)) {
-			const propType = this.dataSchema.propTypes[propName];
-			if (propType) return snip(`${this.structArgName}.${propName}`, undecorate(propType), "argument");
-		}
+		if (positionalEntry) return positionalEntry();
+		const structSnippet = this.structArg?.();
+		if (structSnippet && isWgslStruct(structSnippet.dataType)) return {
+			target: structSnippet,
+			prop: propName
+		};
 	}
 };
 

package/core/function/fnCore.js

@@ -9,7 +9,7 @@ import { applyExternals, replaceExternalsInWgsl } from "../resolve/externals.js"
 import { extractArgs } from "./extractArgs.js";
 
 //#region src/core/function/fnCore.ts
-function createFnCore(implementation, fnAttribute = "") {
+function createFnCore(implementation, functionType, workgroupSize) {
 	/**
 	* External application has to be deferred until resolution because
 	* some externals can reference the owner function which has not been
@@ -24,6 +24,10 @@ function createFnCore(implementation, fnAttribute = "") {
 		},
 		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.getUniqueName(this);
 			if (typeof implementation === "string") {
@@ -32,8 +36,8 @@ function createFnCore(implementation, fnAttribute = "") {
 				if (validArgNames && Object.keys(validArgNames).length > 0) applyExternals(externalMap, { in: validArgNames });
 				const replacedImpl = replaceExternalsInWgsl(ctx, externalMap, implementation);
 				let header = "";
-				let body$1 = "";
-				if (fnAttribute !== "" && entryInput && validArgNames) {
+				let body = "";
+				if (functionType !== "normal" && entryInput && validArgNames) {
 					const { dataSchema, positionalArgs } = entryInput;
 					const parts = [];
 					if (dataSchema && isArgUsedInBody("in", replacedImpl)) parts.push(`in: ${ctx.resolve(dataSchema).value}`);
@@ -42,16 +46,16 @@ function createFnCore(implementation, fnAttribute = "") {
 						if (argName !== "" && isArgUsedInBody(argName, replacedImpl)) parts.push(`${getAttributesString(a.type)}${argName}: ${ctx.resolve(a.type).value}`);
 					}
 					const input = `(${parts.join(", ")})`;
-					const attributes = isWgslData(returnType) ? getAttributesString(returnType) : "";
-					header = `${input}${returnType !== Void ? isWgslStruct(returnType) ? ` -> ${ctx.resolve(returnType).value} ` : ` -> ${attributes !== "" ? attributes : "@location(0)"} ${ctx.resolve(returnType).value} ` : " "}`;
-					body$1 = replacedImpl;
+					const attributes$1 = isWgslData(returnType) ? getAttributesString(returnType) : "";
+					header = `${input}${returnType !== Void ? isWgslStruct(returnType) ? ` -> ${ctx.resolve(returnType).value} ` : ` -> ${attributes$1 !== "" ? attributes$1 : "@location(0)"} ${ctx.resolve(returnType).value} ` : " "}`;
+					body = replacedImpl;
 				} else {
 					const providedArgs = extractArgs(replacedImpl);
 					if (providedArgs.args.length !== argTypes.length) throw new Error(`WGSL implementation has ${providedArgs.args.length} arguments, while the shell has ${argTypes.length} arguments.`);
 					header = `(${providedArgs.args.map((argInfo, i) => `${argInfo.identifier}: ${checkAndReturnType(ctx, `parameter ${argInfo.identifier}`, argInfo.type, argTypes[i])}`).join(", ")})${returnType === Void ? " " : ` -> ${checkAndReturnType(ctx, "return type", providedArgs.ret?.type, returnType)} `}`;
-					body$1 = replacedImpl.slice(providedArgs.range.end);
+					body = replacedImpl.slice(providedArgs.range.end);
 				}
-				ctx.addDeclaration(`${fnAttribute}fn ${id}${header}${body$1}`);
+				ctx.addDeclaration(`${attributes}fn ${id}${header}${body}`);
 				return snip(id, returnType, "runtime");
 			}
 			const pluginData = getMetaData(implementation);
@@ -62,9 +66,9 @@ function createFnCore(implementation, fnAttribute = "") {
 			const missingExternals = ast.externalNames.filter((name) => !(name in externalMap));
 			if (missingExternals.length > 0) throw new MissingLinksError(getName(this), missingExternals);
 			const maybeSecondArg = ast.params[1];
-			if (maybeSecondArg && maybeSecondArg.type === "i" && fnAttribute !== "") applyExternals(externalMap, { [maybeSecondArg.name]: undecorate(returnType) });
-			const { head, body, returnType: actualReturnType } = ctx.fnToWgsl({
-				functionType: fnAttribute.includes("@compute") ? "compute" : fnAttribute.includes("@vertex") ? "vertex" : fnAttribute.includes("@fragment") ? "fragment" : "normal",
+			if (maybeSecondArg && maybeSecondArg.type === "i" && functionType !== "normal") applyExternals(externalMap, { [maybeSecondArg.name]: undecorate(returnType) });
+			const { code, returnType: actualReturnType } = ctx.fnToWgsl({
+				functionType,
 				argTypes,
 				entryInput,
 				params: ast.params,
@@ -72,7 +76,7 @@ function createFnCore(implementation, fnAttribute = "") {
 				body: ast.body,
 				externalMap
 			});
-			ctx.addDeclaration(`${fnAttribute}fn ${id}${ctx.resolve(head).value}${ctx.resolve(body).value}`);
+			ctx.addDeclaration(`${attributes}fn ${id}${code}`);
 			return snip(id, actualReturnType, "runtime");
 		}
 	};

package/core/function/shelllessImpl.js

@@ -4,7 +4,7 @@ import { createFnCore } from "./fnCore.js";
 
 //#region src/core/function/shelllessImpl.ts
 function createShelllessImpl(argTypes, implementation) {
-	const core = createFnCore(implementation, "");
+	const core = createFnCore(implementation, "normal");
 	return {
 		[$internal]: true,
 		[$getNameForward]: core,

package/core/function/tgpuComputeFn.js

@@ -31,7 +31,7 @@ function isTgpuComputeFn(value) {
 	return value?.shell?.entryPoint === "compute";
 }
 function createComputeFn(shell, workgroupSize, implementation, entryInput) {
-	const core = createFnCore(implementation, `@compute @workgroup_size(${workgroupSize.join(", ")}) `);
+	const core = createFnCore(implementation, "compute", workgroupSize);
 	return {
 		shell,
 		$uses(newExternals) {

package/core/function/tgpuFn.js

@@ -40,7 +40,7 @@ function createFn(shell, _implementation) {
 		pairs = _implementation[$providing]?.pairs ?? [];
 		implementation = _implementation[$internal].inner;
 	} else implementation = _implementation;
-	const core = createFnCore(implementation, "");
+	const core = createFnCore(implementation, "normal");
 	const fnBase = {
 		shell,
 		resourceType: "function",

package/core/function/tgpuFragmentFn.js

@@ -32,7 +32,7 @@ function isTgpuFragmentFn(value) {
 	return value?.shell?.entryPoint === "fragment";
 }
 function createFragmentFn(shell, implementation) {
-	const core = createFnCore(implementation, "@fragment ");
+	const core = createFnCore(implementation, "fragment");
 	const outputType = shell.returnType;
 	if (typeof implementation === "string") addReturnTypeToExternals(implementation, outputType, (externals) => core.applyExternals(externals));
 	return {

package/core/function/tgpuVertexFn.js

@@ -32,7 +32,7 @@ function isTgpuVertexFn(value) {
 	return value?.shell?.entryPoint === "vertex";
 }
 function createVertexFn(shell, implementation) {
-	const core = createFnCore(implementation, "@vertex ");
+	const core = createFnCore(implementation, "vertex");
 	const entryInput = separateAllAsPositional(shell.in ?? {});
 	return {
 		shell,

package/data/index.d.ts

@@ -4,7 +4,7 @@ import { AnyAttribute, HasCustomLocation, IsBuiltin, align, interpolate, invaria
 import { memoryLayoutOf } from "./offsetUtils.js";
 import { FormatToAcceptedData, FormatToWGSLType, PackedData, TgpuVertexFormatData, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, isPackedData, packedFormats, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra } from "./vertexFormatData.js";
 import { _ref } from "./ref.js";
-import { Align, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, Bool, Builtin, Decorated, F16, F32, I32, Interpolate, Location, Mat2x2f, Mat3x3f, Mat4x4f, Ptr, Size, StorableData, U16, U32, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslStruct, atomicI32, atomicU32, isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, m2x2f, m3x3f, m4x4f, matBase, v2b, v2f, v2i, v2u, v3b, v3f, v3i, v3u, v4b, v4f, v4i, v4u, vecBase } from "./wgslTypes.js";
+import { Align, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, Bool, Builtin, Decorated, F16, F32, I32, Interpolate, Location, Mat2x2f, Mat3x3f, Mat4x4f, Ptr, Size, StorableData, U16, U32, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslStruct, atomicI32, atomicU32, isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, m2x2f, m3x3f, m4x4f, matBase, v2b, v2f, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, v4i, v4u, vecBase } from "./wgslTypes.js";
 import { WgslExternalTexture, WgslStorageTexture, WgslStorageTexture1d, WgslStorageTexture2d, WgslStorageTexture2dArray, WgslStorageTexture3d, WgslStorageTextureProps, WgslTexture, WgslTexture1d, WgslTexture2d, WgslTexture2dArray, WgslTexture3d, WgslTextureCube, WgslTextureCubeArray, WgslTextureDepth2d, WgslTextureDepth2dArray, WgslTextureDepthCube, WgslTextureDepthCubeArray, WgslTextureDepthMultisampled2d, WgslTextureMultisampled2d, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d } from "./texture.js";
 import { Infer, InferGPU, InferInput, InferPartial, InferPatch } from "../shared/repr.js";
 import { AnyData, AnyLooseData, Disarray, LooseDecorated, Unstruct, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct } from "./dataTypes.js";
@@ -25,7 +25,7 @@ import { deepEqual } from "./deepEqual.js";
 
 //#region src/data/index.d.ts
 declare namespace index_d_exports {
-  export { Align, AnyAttribute, AnyBuiltin, AnyData, AnyLooseData, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, BaseData as BaseWgslData, Bool, Builtin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumWorkgroups, BuiltinPosition, BuiltinSampleIndex, BuiltinSampleMask, BuiltinVertexIndex, BuiltinWorkgroupId, Decorated, Disarray, F16, F32, FormatToAcceptedData, FormatToWGSLType, HasCustomLocation, I32, Infer, InferGPU, InferInput, InferPartial, InferPatch, Interpolate, IsBuiltin, Location, LooseDecorated, Mat2x2f, Mat3x3f, Mat4x4f, PackedData, Ptr, Size, StorableData, TgpuVertexFormatData, U16, U32, Unstruct, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslComparisonSampler, WgslExternalTexture, WgslSampler, WgslStorageTexture, WgslStorageTexture1d, WgslStorageTexture2d, WgslStorageTexture2dArray, WgslStorageTexture3d, WgslStorageTextureProps, WgslStruct, WgslTexture, WgslTexture1d, WgslTexture2d, WgslTexture2dArray, WgslTexture3d, WgslTextureCube, WgslTextureCubeArray, WgslTextureDepth2d, WgslTextureDepth2dArray, WgslTextureDepthCube, WgslTextureDepthCubeArray, WgslTextureDepthMultisampled2d, WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, atomicI32, atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, m2x2f, m3x3f, m4x4f, mat2x2f, mat3x3f, mat4x4f, matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, v2b, v2f, v2i, v2u, v3b, v3f, v3i, v3u, v4b, v4f, v4i, v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, vecBase };
+  export { Align, AnyAttribute, AnyBuiltin, AnyData, AnyLooseData, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, BaseData, BaseData as BaseWgslData, Bool, Builtin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumWorkgroups, BuiltinPosition, BuiltinSampleIndex, BuiltinSampleMask, BuiltinVertexIndex, BuiltinWorkgroupId, Decorated, Disarray, F16, F32, FormatToAcceptedData, FormatToWGSLType, HasCustomLocation, I32, Infer, InferGPU, InferInput, InferPartial, InferPatch, Interpolate, IsBuiltin, Location, LooseDecorated, Mat2x2f, Mat3x3f, Mat4x4f, PackedData, Ptr, Size, StorableData, TgpuVertexFormatData, U16, U32, Unstruct, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, Void, WgslArray, WgslComparisonSampler, WgslExternalTexture, WgslSampler, WgslStorageTexture, WgslStorageTexture1d, WgslStorageTexture2d, WgslStorageTexture2dArray, WgslStorageTexture3d, WgslStorageTextureProps, WgslStruct, WgslTexture, WgslTexture1d, WgslTexture2d, WgslTexture2dArray, WgslTexture3d, WgslTextureCube, WgslTextureCubeArray, WgslTextureDepth2d, WgslTextureDepth2dArray, WgslTextureDepthCube, WgslTextureDepthCubeArray, WgslTextureDepthMultisampled2d, WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, atomicI32, atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, m2x2f, m3x3f, m4x4f, mat2x2f, mat3x3f, mat4x4f, matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, v2b, v2f, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, v4i, v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, vecBase };
 }
 //#endregion
-export { type Align, type AnyAttribute, type AnyBuiltin, type AnyData, type AnyLooseData, type AnyVecInstance, type AnyWgslData, type AnyWgslStruct, type Atomic, type BaseData, type BaseData as BaseWgslData, type Bool, type Builtin, type BuiltinClipDistances, type BuiltinFragDepth, type BuiltinFrontFacing, type BuiltinGlobalInvocationId, type BuiltinInstanceIndex, type BuiltinLocalInvocationId, type BuiltinLocalInvocationIndex, type BuiltinNumWorkgroups, type BuiltinPosition, type BuiltinSampleIndex, type BuiltinSampleMask, type BuiltinVertexIndex, type BuiltinWorkgroupId, type Decorated, type Disarray, type F16, type F32, FormatToAcceptedData, FormatToWGSLType, type HasCustomLocation, type I32, type Infer, type InferGPU, type InferInput, type InferPartial, type InferPatch, type Interpolate, type IsBuiltin, type Location, type LooseDecorated, type Mat2x2f, type Mat3x3f, type Mat4x4f, PackedData, type Ptr, type Size, type StorableData, TgpuVertexFormatData, type U16, type U32, type Unstruct, type Vec2b, type Vec2f, type Vec2h, type Vec2i, type Vec2u, type Vec3b, type Vec3f, type Vec3h, type Vec3i, type Vec3u, type Vec4b, type Vec4f, type Vec4h, type Vec4i, type Vec4u, Void, type WgslArray, type WgslComparisonSampler, type WgslExternalTexture, type WgslSampler, type WgslStorageTexture, type WgslStorageTexture1d, type WgslStorageTexture2d, type WgslStorageTexture2dArray, type WgslStorageTexture3d, type WgslStorageTextureProps, type WgslStruct, type WgslTexture, type WgslTexture1d, type WgslTexture2d, type WgslTexture2dArray, type WgslTexture3d, type WgslTextureCube, type WgslTextureCubeArray, type WgslTextureDepth2d, type WgslTextureDepth2dArray, type WgslTextureDepthCube, type WgslTextureDepthCubeArray, type WgslTextureDepthMultisampled2d, type WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, type atomicI32, type atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, index_d_exports, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, type m2x2f, type m3x3f, type m4x4f, mat2x2f, mat3x3f, mat4x4f, type matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, type v2b, type v2f, type v2i, type v2u, type v3b, type v3f, type v3i, type v3u, type v4b, type v4f, type v4i, type v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, type vecBase };
+export { type Align, type AnyAttribute, type AnyBuiltin, type AnyData, type AnyLooseData, type AnyVecInstance, type AnyWgslData, type AnyWgslStruct, type Atomic, type BaseData, type BaseData as BaseWgslData, type Bool, type Builtin, type BuiltinClipDistances, type BuiltinFragDepth, type BuiltinFrontFacing, type BuiltinGlobalInvocationId, type BuiltinInstanceIndex, type BuiltinLocalInvocationId, type BuiltinLocalInvocationIndex, type BuiltinNumWorkgroups, type BuiltinPosition, type BuiltinSampleIndex, type BuiltinSampleMask, type BuiltinVertexIndex, type BuiltinWorkgroupId, type Decorated, type Disarray, type F16, type F32, FormatToAcceptedData, FormatToWGSLType, type HasCustomLocation, type I32, type Infer, type InferGPU, type InferInput, type InferPartial, type InferPatch, type Interpolate, type IsBuiltin, type Location, type LooseDecorated, type Mat2x2f, type Mat3x3f, type Mat4x4f, PackedData, type Ptr, type Size, type StorableData, TgpuVertexFormatData, type U16, type U32, type Unstruct, type Vec2b, type Vec2f, type Vec2h, type Vec2i, type Vec2u, type Vec3b, type Vec3f, type Vec3h, type Vec3i, type Vec3u, type Vec4b, type Vec4f, type Vec4h, type Vec4i, type Vec4u, Void, type WgslArray, type WgslComparisonSampler, type WgslExternalTexture, type WgslSampler, type WgslStorageTexture, type WgslStorageTexture1d, type WgslStorageTexture2d, type WgslStorageTexture2dArray, type WgslStorageTexture3d, type WgslStorageTextureProps, type WgslStruct, type WgslTexture, type WgslTexture1d, type WgslTexture2d, type WgslTexture2dArray, type WgslTexture3d, type WgslTextureCube, type WgslTextureCubeArray, type WgslTextureDepth2d, type WgslTextureDepth2dArray, type WgslTextureDepthCube, type WgslTextureDepthCubeArray, type WgslTextureDepthMultisampled2d, type WgslTextureMultisampled2d, align, PUBLIC_alignmentOf as alignmentOf, arrayOf, atomic, type atomicI32, type atomicU32, bool, builtin, comparisonSampler, deepEqual, disarrayOf, f16, f32, float16, float16x2, float16x4, float32, float32x2, float32x3, float32x4, formatToWGSLType, PUBLIC_getLongestContiguousPrefix as getLongestContiguousPrefix, i32, index_d_exports, interpolate, invariant, isAlignAttrib, isAtomic, isBuiltin, isBuiltinAttrib, PUBLIC_isContiguous as isContiguous, isData, isDecorated, isDisarray, isInterpolateAttrib, isLocationAttrib, isLooseData, isLooseDecorated, isPackedData, isPtr, isSizeAttrib, isUnstruct, isWgslArray, isWgslData, isWgslStruct, location, type m2x2f, type m3x3f, type m4x4f, mat2x2f, mat3x3f, mat4x4f, type matBase, matToArray, memoryLayoutOf, packedFormats, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup, _ref as ref, sampler, sint16, sint16x2, sint16x4, sint32, sint32x2, sint32x3, sint32x4, sint8, sint8x2, sint8x4, size, PUBLIC_sizeOf as sizeOf, snorm16, snorm16x2, snorm16x4, snorm8, snorm8x2, snorm8x4, struct, texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, u16, u32, uint16, uint16x2, uint16x4, uint32, uint32x2, uint32x3, uint32x4, uint8, uint8x2, uint8x4, unorm10_10_10_2, unorm16, unorm16x2, unorm16x4, unorm8, unorm8x2, unorm8x4, unorm8x4_bgra, unstruct, type v2b, type v2f, type v2h, type v2i, type v2u, type v3b, type v3f, type v3h, type v3i, type v3u, type v4b, type v4f, type v4h, type v4i, type v4u, vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, type vecBase };

package/data/numeric.js

@@ -2,20 +2,6 @@ import { $internal } from "../shared/symbols.js";
 import { callableSchema } from "../core/function/createCallableSchema.js";
 
 //#region src/data/numeric.ts
-const abstractInt = {
-	[$internal]: {},
-	type: "abstractInt",
-	toString() {
-		return "abstractInt";
-	}
-};
-const abstractFloat = {
-	[$internal]: {},
-	type: "abstractFloat",
-	toString() {
-		return "abstractFloat";
-	}
-};
 const boolCast = callableSchema({
 	name: "bool",
 	schema: () => bool,
@@ -218,6 +204,22 @@ const f16 = Object.assign(f16Cast, {
 	[$internal]: {},
 	type: "f16"
 });
+const abstractInt = {
+	[$internal]: {},
+	type: "abstractInt",
+	toString() {
+		return "abstractInt";
+	},
+	concretized: i32
+};
+const abstractFloat = {
+	[$internal]: {},
+	type: "abstractFloat",
+	toString() {
+		return "abstractFloat";
+	},
+	concretized: f32
+};
 
 //#endregion
 export { abstractFloat, abstractInt, bool, f16, f32, i32, u16, u32 };

package/data/snippet.d.ts

@@ -12,14 +12,9 @@ interface Snippet {
   readonly dataType: BaseData | UnknownData;
   readonly origin: Origin;
 }
-interface ResolvedSnippet {
+interface ResolvedSnippet extends Snippet {
   readonly value: string;
-  /**
-   * The type that `value` is assignable to (not necessary exactly inferred as).
-   * E.g. `1.1` is assignable to `f32`, but `1.1` itself is an abstract float
-   */
   readonly dataType: BaseData;
-  readonly origin: Origin;
 }
 type MapValueToSnippet<T> = { [K in keyof T]: Snippet };
 //#endregion

package/data/wgslTypes.d.ts

@@ -72,6 +72,7 @@ interface matInfixNotation<T extends matBase> {
  */
 interface AbstractInt extends BaseData {
   readonly type: 'abstractInt';
+  readonly concretized: I32;
   readonly [$repr]: number;
   readonly [$invalidSchemaReason]: 'Abstract numerics are not host-shareable';
 }
@@ -80,6 +81,7 @@ interface AbstractInt extends BaseData {
  */
 interface AbstractFloat extends BaseData {
   readonly type: 'abstractFloat';
+  readonly concretized: F32;
   readonly [$repr]: number;
   readonly [$invalidSchemaReason]: 'Abstract numerics are not host-shareable';
 }

package/package.js

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

package/package.json

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

package/resolutionCtx.js

@@ -1,7 +1,7 @@
 import { $internal, $providing, $resolve, isMarkedInternal } from "./shared/symbols.js";
 import { getName, hasTinyestMetadata, setName } from "./shared/meta.js";
 import { Void, isPtr, isWgslArray, isWgslStruct } from "./data/wgslTypes.js";
-import { UnknownData, isData, undecorate } from "./data/dataTypes.js";
+import { UnknownData, isData } from "./data/dataTypes.js";
 import { snip } from "./data/snippet.js";
 import { MissingSlotValueError, ResolutionError, WgslTypeError, invariant } from "./errors.js";
 import { isLazy, isProviding, isSlot } from "./core/slot/slotTypes.js";
@@ -12,7 +12,6 @@ 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 { getAttributesString } from "./data/attributes.js";
 import { createIoSchema } from "./core/function/ioSchema.js";
 import { AutoStruct } from "./data/autoStruct.js";
 import { EntryInputRouter } from "./core/function/entryInputRouter.js";
@@ -64,12 +63,11 @@ var ItemStateStackImpl = class {
 			bindingMap: new WeakMap(pairs)
 		});
 	}
-	pushFunctionScope(functionType, args, argAliases, returnType, externalMap) {
+	pushFunctionScope(functionType, argAccess, returnType, externalMap) {
 		const scope = {
 			type: "functionScope",
 			functionType,
-			args,
-			argAliases,
+			argAccess,
 			returnType,
 			externalMap,
 			reportedReturnTypes: /* @__PURE__ */ new Set()
@@ -106,9 +104,8 @@ var ItemStateStackImpl = class {
 		for (let i = this._stack.length - 1; i >= 0; --i) {
 			const layer = this._stack[i];
 			if (layer?.type === "functionScope") {
-				const arg = layer.args.find((a) => a.value === id);
-				if (arg !== void 0) return arg;
-				if (layer.argAliases[id]) return layer.argAliases[id];
+				const access = layer.argAccess[id];
+				if (access) return access();
 				const external = layer.externalMap[id];
 				if (external !== void 0 && external !== null) return coerceToSnippet(external);
 				return;
@@ -189,6 +186,27 @@ var IndentController = class {
 		}
 	}
 };
+function createArgument(name, type, origin = "argument") {
+	let used = false;
+	return {
+		name,
+		access: () => {
+			used = true;
+			return snip(name, type, origin);
+		},
+		decoratedType: type,
+		get used() {
+			return used;
+		}
+	};
+}
+function createArgumentPropAccess(argAccess, prop) {
+	return () => {
+		const argSnippet = argAccess();
+		if (!argSnippet) return;
+		return accessProp(argSnippet, prop);
+	};
+}
 var ResolutionCtxImpl = class {
 	#namespaceInternal;
 	_indentController = new IndentController();
@@ -287,107 +305,93 @@ var ResolutionCtxImpl = class {
 		try {
 			this.#namespaceInternal.nameRegistry.pushFunctionScope();
 			const args = [];
-			const argAliases = [];
-			const pendingHeaderEntries = [];
+			const argAccess = {};
 			if (options.entryInput) {
 				const { dataSchema, positionalArgs } = options.entryInput;
 				const firstParam = options.params[0];
-				const structArgName = this.makeNameValid("_arg_0");
-				const structArg = dataSchema ? snip(structArgName, dataSchema, "argument") : void 0;
-				if (structArg) {
-					args.push(structArg);
-					pendingHeaderEntries.push({
-						argName: structArgName,
-						header: `${structArgName}: ${this.resolve(dataSchema).value}`
-					});
-				}
+				const structArg = dataSchema ? createArgument(this.makeNameValid("_arg_0"), 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 argName = this.makeNameValid(alias);
-						const argSnippet = snip(argName, argInfo.type, "argument");
-						args.push(argSnippet);
-						argAliases.push([alias, argSnippet]);
-						pendingHeaderEntries.push({
-							argName,
-							header: `${getAttributesString(argInfo.type)}${argName}: ${this.resolve(undecorate(argInfo.type)).value}`
-						});
-					} else if (structArg) {
-						const propSnippet = accessProp(structArg, name);
-						if (propSnippet) argAliases.push([alias, propSnippet]);
-					}
+						const arg = createArgument(this.makeNameValid(alias), argInfo.type);
+						args.push(arg);
+						argAccess[alias] = arg.access;
+					} else if (structArg) argAccess[alias] = createArgumentPropAccess(structArg.access, name);
 				}
 				else if (firstParam?.type === FuncParameterType.identifier) {
 					const proxyEntries = [];
 					for (const a of positionalArgs) {
-						const argName = this.makeNameValid(`_arg_${a.schemaKey}`);
-						const s = snip(argName, a.type, "argument");
-						args.push(s);
+						const arg = createArgument(this.makeNameValid(`_arg_${a.schemaKey}`), a.type);
+						args.push(arg);
 						proxyEntries.push({
 							schemaKey: a.schemaKey,
-							argName,
-							type: a.type
-						});
-						pendingHeaderEntries.push({
-							argName,
-							header: `${getAttributesString(a.type)}${argName}: ${this.resolve(undecorate(a.type)).value}`
+							arg: arg.access
 						});
 					}
-					const router = new EntryInputRouter(structArgName, dataSchema, proxyEntries);
-					argAliases.push([firstParam.name, snip(firstParam.name, router, "argument")]);
+					const router = new EntryInputRouter(structArg?.access, proxyEntries);
+					argAccess[firstParam.name] = () => snip("N/A", router, "argument");
 				} else for (const a of positionalArgs) {
 					const argName = this.makeNameValid(`_arg_${a.schemaKey}`);
-					args.push(snip(argName, a.type, "argument"));
-					pendingHeaderEntries.push({
-						argName,
-						header: `${getAttributesString(a.type)}${argName}: ${this.resolve(undecorate(a.type)).value}`
-					});
+					const arg = createArgument(argName, a.type);
+					args.push(arg);
+					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 rawName = astParam.name;
-						const snippet = snip(this.makeNameValid(rawName), argType, origin);
-						args.push(snippet);
-						if (snippet.value !== rawName) argAliases.push([rawName, snippet]);
+						const arg = createArgument(this.makeNameValid(astParam.name), argType, origin);
+						args.push(arg);
+						argAccess[astParam.name] = arg.access;
 						break;
 					}
 					case FuncParameterType.destructuredObject: {
-						const objSnippet = snip(`_arg_${i}`, argType, origin);
-						args.push(objSnippet);
-						argAliases.push(...astParam.props.map(({ name, alias }) => [alias, accessProp(objSnippet, name)]));
+						const objArg = createArgument(this.makeNameValid(`_arg_${i}`), argType, origin);
+						args.push(objArg);
+						for (const { name, alias } of astParam.props) argAccess[alias] = createArgumentPropAccess(objArg.access, name);
 						break;
 					}
-					case void 0: if (!(argType instanceof AutoStruct)) args.push(snip(`_arg_${i}`, argType, origin));
+					case void 0: if (!(argType instanceof AutoStruct)) args.push({
+						name: this.makeNameValid(`_arg_${i}`),
+						access: () => {
+							throw new Error(`Unreachable: Accessing an argument that wasn't named in the function signature`);
+						},
+						decoratedType: argType,
+						used: false
+					});
 				}
 			}
-			const scope = this._itemStateStack.pushFunctionScope(options.functionType, args, Object.fromEntries(argAliases), options.returnType, options.externalMap);
+			const scope = this._itemStateStack.pushFunctionScope(options.functionType, argAccess, options.returnType, options.externalMap);
 			fnScopePushed = true;
-			const body = this.gen.functionDefinition(options.body);
-			let returnType = options.returnType;
-			if (returnType instanceof AutoStruct) if (isWgslStruct(scope.reportedReturnTypes.values().next().value)) returnType = returnType.completeStruct;
-			else returnType = void 0;
-			if (!returnType) {
-				const returnTypes = [...scope.reportedReturnTypes];
-				if (returnTypes.length === 0) returnType = Void;
-				else {
-					const conversion = getBestConversion(returnTypes);
-					if (conversion && !conversion.hasImplicitConversions) returnType = conversion.targetType;
+			let returnType;
+			const code = this.gen.functionDefinition({
+				functionType: options.functionType,
+				args,
+				body: options.body,
+				determineReturnType: () => {
+					if (returnType) return returnType;
+					returnType = options.returnType;
+					if (returnType instanceof AutoStruct) if (isWgslStruct(scope.reportedReturnTypes.values().next().value)) returnType = returnType.completeStruct;
+					else returnType = void 0;
+					if (!returnType) {
+						const returnTypes = [...scope.reportedReturnTypes];
+						if (returnTypes.length === 0) returnType = Void;
+						else {
+							const conversion = getBestConversion(returnTypes);
+							if (conversion && !conversion.hasImplicitConversions) returnType = conversion.targetType;
+						}
+						if (!returnType) throw new Error(`Expected function to have a single return type, got [${returnTypes.join(", ")}]. Cast explicitly to the desired type.`);
+						returnType = concretize(returnType);
+						if (options.functionType === "vertex" || options.functionType === "fragment") returnType = createIoSchema(returnType);
+					}
+					return returnType;
 				}
-				if (!returnType) throw new Error(`Expected function to have a single return type, got [${returnTypes.join(", ")}]. Cast explicitly to the desired type.`);
-				returnType = concretize(returnType);
-				if (options.functionType === "vertex" || options.functionType === "fragment") returnType = createIoSchema(returnType);
-			}
-			if (options.entryInput) return {
-				head: `(${pendingHeaderEntries.filter(({ argName }) => isArgUsedInBody(argName, body)).map(({ header }) => header).join(", ")}) ${returnType.type !== "void" ? `-> ${getAttributesString(returnType)}${this.resolve(returnType).value} ` : ""}`,
-				body,
-				returnType
-			};
+			});
+			if (!returnType) throw new Error(`Failed to determine return type`);
 			return {
-				head: resolveFunctionHeader(this, args, returnType),
-				body,
+				code,
 				returnType
 			};
 		} finally {
@@ -602,13 +606,6 @@ function resolve(item, options) {
 		logResources: ctx.logResources
 	};
 }
-function isArgUsedInBody(argName, body) {
-	return (/* @__PURE__ */ new RegExp(`\\b${argName}\\b`)).test(body);
-}
-function resolveFunctionHeader(ctx, args, returnType) {
-	const argList = args.map((arg) => `${arg.value}: ${ctx.resolve(arg.dataType).value}`).join(", ");
-	return returnType.type !== "void" ? `(${argList}) -> ${getAttributesString(returnType)}${ctx.resolve(returnType).value} ` : `(${argList}) `;
-}
 
 //#endregion
 export { ResolutionCtxImpl, resolve };

package/tgsl/accessIndex.js

@@ -1,5 +1,5 @@
 import { isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { MatrixColumnsAccess, UnknownData, isDisarray } from "../data/dataTypes.js";
+import { MatrixColumnsAccess, isDisarray } from "../data/dataTypes.js";
 import { isEphemeralSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
@@ -37,7 +37,7 @@ function accessIndex(target, indexArg) {
 		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin);
 	}
 	if (target.dataType.type in indexableTypeToResult) throw new Error("The only way of accessing matrix elements in TypeGPU functions is through the 'columns' property.");
-	if (isKnownAtComptime(target) && isKnownAtComptime(index) || target.dataType === UnknownData) return coerceToSnippet(target.value[index.value]);
+	if (isKnownAtComptime(target) && isKnownAtComptime(index)) return coerceToSnippet(target.value[index.value]);
 	if (isWgslStruct(target.dataType) && isKnownAtComptime(index) && typeof index.value === "string") return accessProp(target, index.value);
 }
 

package/tgsl/accessProp.js

@@ -1,7 +1,7 @@
 import { $gpuCallable } from "../shared/symbols.js";
 import { isMat, isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
 import { InfixDispatch, MatrixColumnsAccess, UnknownData, isUnstruct, undecorate } from "../data/dataTypes.js";
-import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { isEphemeralSnippet, isSnippet, snip } from "../data/snippet.js";
 import { isKnownAtComptime } from "../types.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { derefSnippet } from "../data/ref.js";
@@ -92,7 +92,12 @@ function accessProp(target, propName) {
 		if (!result) return;
 		return snip(stitch`${target}.${result.prop}`, result.type, "argument");
 	}
-	if (target.dataType instanceof EntryInputRouter) return target.dataType.accessProp(propName);
+	if (target.dataType instanceof EntryInputRouter) {
+		const result = target.dataType.accessProp(propName);
+		if (isSnippet(result)) return result;
+		if (result) return accessProp(result.target, result.prop);
+		return;
+	}
 	if (isPtr(target.dataType)) {
 		const derefed = derefSnippet(target);
 		if (propName === "$") return derefed;

package/tgsl/consoleLog/logGenerator.js

@@ -1,10 +1,12 @@
 import { $internal } from "../../shared/symbols.js";
 import { Void } from "../../data/wgslTypes.js";
-import { UnknownData } from "../../data/dataTypes.js";
+import { UnknownData, unptr } from "../../data/dataTypes.js";
 import { snip } from "../../data/snippet.js";
+import { invariant } from "../../errors.js";
 import { stitch } from "../../core/resolve/stitch.js";
+import { convertToCommonType } from "../conversion.js";
 import { u32 } from "../../data/numeric.js";
-import { concretizeSnippets } from "../generationHelpers.js";
+import { concretizeSnippet } from "../generationHelpers.js";
 import { struct } from "../../data/struct.js";
 import { shaderStageSlot } from "../../core/slot/internalSlots.js";
 import { arrayOf } from "../../data/array.js";
@@ -61,16 +63,21 @@ var LogGeneratorImpl = class {
 			console.warn(`Unsupported log method '${op}'.`);
 			return fallbackSnippet;
 		}
-		const concreteArgs = concretizeSnippets(args);
 		const id = this.#firstUnusedId++;
-		const nonStringArgs = concreteArgs.filter((e) => e.dataType !== UnknownData);
-		const logFn = createLoggingFunction(id, nonStringArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
-		const argTypes = concreteArgs.map((e) => e.dataType === UnknownData ? e.value : e.dataType);
+		const concreteArgsWithStrings = args.map((arg) => {
+			if (arg.dataType === UnknownData) return arg;
+			const converted = convertToCommonType(ctx, [arg], [unptr(arg.dataType)])?.[0];
+			invariant(converted, `Internal error. Expected type ${arg.dataType} to be convertible to ${unptr(arg.dataType)}`);
+			return converted;
+		}).map(concretizeSnippet);
+		const concreteArgs = concreteArgsWithStrings.filter((arg) => arg.dataType !== UnknownData);
+		const logFn = createLoggingFunction(id, concreteArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
+		const functionSnippet = snip(stitch`${ctx.resolve(logFn).value}(${concreteArgs})`, Void, "runtime");
 		this.#logIdToMeta.set(id, {
 			op,
-			argTypes
+			argTypes: concreteArgsWithStrings.map((e) => e?.dataType === UnknownData ? e?.value : e?.dataType)
 		});
-		return snip(stitch`${ctx.resolve(logFn).value}(${nonStringArgs})`, Void, "runtime");
+		return functionSnippet;
 	}
 	get logResources() {
 		return this.#firstUnusedId === 1 ? void 0 : {

package/tgsl/conversion.js

@@ -90,14 +90,19 @@ function getImplicitConversionRank(src, dest) {
 			};
 		}
 	}
+	if ((trueSrc.type === "u32" || trueSrc.type === "i32") && trueDst.type === "abstractFloat") return {
+		rank: 1,
+		action: "cast",
+		targetType: trueDst.concretized
+	};
 	if (trueSrc.type === "abstractFloat") {
-		if (trueDst.type === "u32") return {
+		if (trueDst.type === "i32") return {
 			rank: 2,
 			action: "cast",
 			targetType: trueDst
 		};
-		if (trueDst.type === "i32") return {
-			rank: 1,
+		if (trueDst.type === "u32") return {
+			rank: 3,
 			action: "cast",
 			targetType: trueDst
 		};
@@ -113,6 +118,10 @@ function getConversionRank(src, dest, allowImplicit) {
 function findBestType(types, uniqueTypes, allowImplicit) {
 	let bestResult;
 	for (const targetType of uniqueTypes) {
+		/**
+		* The type we end up converting to. Will be different than `targetType` if `targetType === abstractFloat`
+		*/
+		let destType = targetType;
 		const details = [];
 		let sum = 0;
 		for (const sourceType of types) {
@@ -120,9 +129,10 @@ function findBestType(types, uniqueTypes, allowImplicit) {
 			sum += conversion.rank;
 			if (conversion.rank === Number.POSITIVE_INFINITY) break;
 			details.push(conversion);
+			if (conversion.action === "cast") destType = conversion.targetType;
 		}
 		if (sum < (bestResult?.sum ?? Number.POSITIVE_INFINITY)) bestResult = {
-			type: targetType,
+			type: destType,
 			details,
 			sum
 		};
@@ -168,7 +178,7 @@ function convertToCommonType(ctx, values, restrictTo, verbose = true) {
 	if (DEV && Array.isArray(restrictTo) && restrictTo.length === 0) console.warn("convertToCommonType was called with an empty restrictTo array, which prevents any conversions from being made. If you intend to allow all conversions, pass undefined instead. If this was intended call the function conditionally since the result will always be undefined.");
 	const conversion = getBestConversion(types, restrictTo);
 	if (!conversion) return;
-	if ((TEST || DEV) && verbose && conversion.hasImplicitConversions) console.warn(`Implicit conversions from [\n${values.map((v) => `  ${v.value}: ${safeStringify(v.dataType)}`).join(",\n")}\n] to ${conversion.targetType.type} are supported, but not recommended.
+	if ((TEST || DEV) && verbose && conversion.hasImplicitConversions) console.warn(`Implicit conversions from [\n${values.map((v) => `  ${ctx.resolveSnippet(v).value}: ${safeStringify(v.dataType)}`).join(",\n")}\n] to ${conversion.targetType.type} are supported, but not recommended.
 Consider using explicit conversions instead.`);
 	return values.map((value, index) => {
 		const action = conversion.actions[index];

package/tgsl/forOfUtils.js

@@ -33,12 +33,20 @@ function getElementType(elementSnippet, iterableSnippet) {
 }
 function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
 	const { value, dataType } = iterableSnippet;
-	if (isTgpuRange(value)) return {
-		start: snip(value.start, i32, "constant"),
-		end: snip(value.end, i32, "constant"),
-		step: snip(value.step, i32, "constant"),
-		comparison: value.step < 0 ? ">" : "<"
-	};
+	if (isTgpuRange(value)) {
+		const { start, end, step } = value;
+		const dataType$1 = [
+			start,
+			end,
+			step
+		].every((v) => v >= 0) ? u32 : i32;
+		return {
+			start: snip(start, dataType$1, "constant"),
+			end: snip(end, dataType$1, "constant"),
+			step: snip(step, dataType$1, "constant"),
+			comparison: step < 0 ? ">" : "<"
+		};
+	}
 	if (!unroll && isEphemeralSnippet(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
 -----
 You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.

package/tgsl/generationHelpers.js

@@ -25,9 +25,6 @@ function concretize(type) {
 function concretizeSnippet(snippet) {
 	return snip(snippet.value, concretize(snippet.dataType), snippet.origin);
 }
-function concretizeSnippets(args) {
-	return args.map(concretizeSnippet);
-}
 function coerceToSnippet(value) {
 	if (isSnippet(value)) return value;
 	if (isRef(value)) throw new Error("Cannot use refs (d.ref(...)) from the outer scope.");
@@ -66,4 +63,4 @@ var ArrayExpression = class {
 };
 
 //#endregion
-export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippets, numericLiteralToSnippet };
+export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippet, numericLiteralToSnippet };

package/tgsl/shaderGenerator.d.ts

@@ -1,8 +1,7 @@
 import { ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
-import "./shaderGenerator_members.js";
+import { FunctionDefinitionOptions } from "./shaderGenerator_members.js";
 import { BaseData } from "../data/wgslTypes.js";
-import { Block } from "tinyest";
 
 //#region src/tgsl/shaderGenerator.d.ts
 
@@ -14,7 +13,7 @@ import { Block } from "tinyest";
  */
 interface ShaderGenerator {
   initGenerator(ctx: GenerationCtx): void;
-  functionDefinition(body: Block): string;
+  functionDefinition(options: FunctionDefinitionOptions): string;
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
   typeAnnotation(schema: BaseData): string;
 }

package/tgsl/shaderGenerator_members.d.ts

@@ -1,2 +1,15 @@
-import { ResolutionCtx } from "../types.js";
-import { UnknownData } from "../data/dataTypes.js";
+import { Origin, Snippet } from "../data/snippet.js";
+import { FunctionArgument, ResolutionCtx, TgpuShaderStage } from "../types.js";
+import { BaseData } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { Block } from "tinyest";
+
+//#region src/tgsl/shaderGenerator_members.d.ts
+interface FunctionDefinitionOptions {
+  readonly functionType: 'normal' | TgpuShaderStage;
+  readonly args: readonly FunctionArgument[];
+  readonly body: Block;
+  determineReturnType(): BaseData;
+}
+//#endregion
+export { FunctionDefinitionOptions };

package/tgsl/wgslGenerator.d.ts

@@ -1,5 +1,6 @@
 import { Origin, ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
+import { FunctionDefinitionOptions } from "./shaderGenerator_members.js";
 import { ShaderGenerator } from "./shaderGenerator.js";
 import { BaseData, StorableData } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
@@ -22,7 +23,7 @@ declare class WgslGenerator implements ShaderGenerator {
    */
   _typedExpression(expression: tinyest.Expression, expectedType: BaseData | BaseData[]): Snippet;
   _expression(expression: tinyest.Expression): Snippet;
-  functionDefinition(body: tinyest.Block): string;
+  functionDefinition(options: FunctionDefinitionOptions): string;
   /**
    * Generates a WGSL type string for the given data type, and adds necessary
    * definitions to the shader preamble. This shouldn't be called directly, only
@@ -30,6 +31,7 @@ declare class WgslGenerator implements ShaderGenerator {
    */
   typeAnnotation(data: BaseData): string;
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
+  _return(statement: tinyest.Return): string;
   _statement(statement: tinyest.Statement): string;
 }
 //#endregion

package/tgsl/wgslGenerator.js

@@ -13,6 +13,7 @@ import { convertStructValues, convertToCommonType, tryConvertSnippet } from "./c
 import { bool, i32, u32 } from "../data/numeric.js";
 import { ArrayExpression, coerceToSnippet, concretize, numericLiteralToSnippet } from "./generationHelpers.js";
 import { vec2u, vec3u, vec4u } from "../data/vector.js";
+import { getAttributesString } from "../data/attributes.js";
 import { AutoStruct } from "../data/autoStruct.js";
 import { add, div, mul, neg, sub } from "../std/operators.js";
 import { accessProp } from "./accessProp.js";
@@ -292,7 +293,7 @@ ${this.ctx.pre}}`;
 			if (!accessed) {
 				const targetStr = this.ctx.resolve(target.value, target.dataType).value;
 				const propertyStr = this.ctx.resolve(property.value, property.dataType).value;
-				throw new Error(`Unable to index value ${targetStr} of unknown type with index ${propertyStr}. If the value is an array, to address this, consider one of the following approaches: (1) declare the array using 'tgpu.const', (2) store the array in a buffer, or (3) define the array within the GPU function scope.`);
+				throw new Error(`Index access '${targetStr}[${propertyStr}]' is invalid. If the value is an array, to address this, consider one of the following approaches: (1) declare the array using 'tgpu.const', (2) store the array in a buffer, or (3) define the array within the GPU function scope.`);
 			}
 			return accessed;
 		}
@@ -422,8 +423,13 @@ ${this.ctx.pre}}`;
 		if (expression[0] === NODE.preUpdate) throw new Error("Cannot use pre-updates in TypeGPU functions.");
 		assertExhaustive(expression);
 	}
-	functionDefinition(body) {
-		return this._block(body);
+	functionDefinition(options) {
+		const body = this._block(options.body);
+		const returnType = options.determineReturnType();
+		const argList = options.args.filter((arg) => arg.used || options.functionType === "normal").map((arg) => {
+			return `${getAttributesString(arg.decoratedType)}${arg.name}: ${this.ctx.resolve(arg.decoratedType).value}`;
+		}).join(", ");
+		return `${returnType.type !== "void" ? `(${argList}) -> ${getAttributesString(returnType)}${this.ctx.resolve(returnType).value} ` : `(${argList}) `}${body}`;
 	}
 	/**
 	* Generates a WGSL type string for the given data type, and adds necessary
@@ -437,6 +443,28 @@ ${this.ctx.pre}}`;
 		if (args.length === 1 && args[0]?.dataType === schema) return snip(stitch`${args[0]}`, schema, fallthroughCopyOrigin(args[0].origin));
 		return snip(stitch`${this.ctx.resolve(schema).value}(${args})`, schema, "runtime");
 	}
+	_return(statement) {
+		const returnNode = statement[1];
+		if (returnNode !== void 0) {
+			const expectedReturnType = this.ctx.topFunctionReturnType;
+			let returnSnippet = expectedReturnType ? this._typedExpression(returnNode, expectedReturnType) : this._expression(returnNode);
+			if (returnSnippet.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot return references, returning '${returnSnippet.value.snippet}'`);
+			if (returnSnippet.origin === "argument" && !isNaturallyEphemeral(returnSnippet.dataType) && this.ctx.topFunctionScope?.functionType === "normal") throw new WgslTypeError(stitch`Cannot return references to arguments, returning '${returnSnippet}'. Copy the argument before returning it.`);
+			if (!expectedReturnType && !isEphemeralSnippet(returnSnippet) && returnSnippet.origin !== "this-function") {
+				const str = this.ctx.resolve(returnSnippet.value, returnSnippet.dataType).value;
+				const typeStr = this.ctx.resolve(unptr(returnSnippet.dataType)).value;
+				throw new WgslTypeError(`'return ${str};' is invalid, cannot return references.
+-----
+Try 'return ${typeStr}(${str});' instead.
+-----`);
+			}
+			returnSnippet = tryConvertSnippet(this.ctx, returnSnippet, unptr(returnSnippet.dataType), false);
+			invariant(returnSnippet.dataType !== UnknownData, "Return type should be known");
+			this.ctx.reportReturnType(returnSnippet.dataType);
+			return stitch`${this.ctx.pre}return ${returnSnippet};`;
+		}
+		return `${this.ctx.pre}return;`;
+	}
 	_statement(statement) {
 		if (typeof statement === "string") {
 			const id = this._identifier(statement);
@@ -444,28 +472,7 @@ ${this.ctx.pre}}`;
 			return resolved$1 ? `${this.ctx.pre}${resolved$1};` : "";
 		}
 		if (typeof statement === "boolean") return `${this.ctx.pre}${statement ? "true" : "false"};`;
-		if (statement[0] === NODE.return) {
-			const returnNode = statement[1];
-			if (returnNode !== void 0) {
-				const expectedReturnType = this.ctx.topFunctionReturnType;
-				let returnSnippet = expectedReturnType ? this._typedExpression(returnNode, expectedReturnType) : this._expression(returnNode);
-				if (returnSnippet.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot return references, returning '${returnSnippet.value.snippet}'`);
-				if (returnSnippet.origin === "argument" && !isNaturallyEphemeral(returnSnippet.dataType) && this.ctx.topFunctionScope?.functionType === "normal") throw new WgslTypeError(stitch`Cannot return references to arguments, returning '${returnSnippet}'. Copy the argument before returning it.`);
-				if (!expectedReturnType && !isEphemeralSnippet(returnSnippet) && returnSnippet.origin !== "this-function") {
-					const str = this.ctx.resolve(returnSnippet.value, returnSnippet.dataType).value;
-					const typeStr = this.ctx.resolve(unptr(returnSnippet.dataType)).value;
-					throw new WgslTypeError(`'return ${str};' is invalid, cannot return references.
------
-Try 'return ${typeStr}(${str});' instead.
------`);
-				}
-				returnSnippet = tryConvertSnippet(this.ctx, returnSnippet, unptr(returnSnippet.dataType), false);
-				invariant(returnSnippet.dataType !== UnknownData, "Return type should be known");
-				this.ctx.reportReturnType(returnSnippet.dataType);
-				return stitch`${this.ctx.pre}return ${returnSnippet};`;
-			}
-			return `${this.ctx.pre}return;`;
-		}
+		if (statement[0] === NODE.return) return this._return(statement);
 		if (statement[0] === NODE.if) {
 			const [_, condNode, consNode, altNode] = statement;
 			const condition = this._typedExpression(condNode, bool);
@@ -600,7 +607,7 @@ ${this.ctx.pre}else ${alternate}`;
 				const index = this.ctx.makeNameValid("i");
 				const forHeaderStr = stitch`${this.ctx.pre}for (var ${index} = ${range.start}; ${index} ${range.comparison} ${range.end}; ${index} += ${range.step})`;
 				let bodyStr = "";
-				if (isTgpuRange(iterableSnippet.value)) bodyStr = this._block(blockified, { [originalLoopVarName]: snip(index, u32, "runtime") });
+				if (isTgpuRange(iterableSnippet.value)) bodyStr = this._block(blockified, { [originalLoopVarName]: snip(index, range.start.dataType, "runtime") });
 				else {
 					this.ctx.indent();
 					ctxIndent = true;

package/types.d.ts

@@ -49,11 +49,17 @@ type ItemLayer = {
   type: 'item';
   usedSlots: Set<TgpuSlot<unknown>>;
 };
+type FunctionArgumentAccess = () => Snippet | undefined;
+interface FunctionArgument {
+  name: string;
+  access: FunctionArgumentAccess;
+  decoratedType: BaseData;
+  used: boolean;
+}
 type FunctionScopeLayer = {
   type: 'functionScope';
   functionType: 'normal' | 'compute' | 'vertex' | 'fragment';
-  args: Snippet[];
-  argAliases: Record<string, Snippet>;
+  argAccess: Record<string, FunctionArgumentAccess>;
   externalMap: Record<string, unknown>;
   /**
    * The return type of the function. If undefined, the type should be inferred
@@ -81,7 +87,7 @@ interface ItemStateStack {
   readonly topFunctionScope: FunctionScopeLayer | undefined;
   pushItem(): void;
   pushSlotBindings(pairs: SlotValuePair[]): void;
-  pushFunctionScope(functionType: 'normal' | TgpuShaderStage, args: Snippet[], argAliases: Record<string, Snippet>,
+  pushFunctionScope(functionType: 'normal' | TgpuShaderStage, argAccess: Record<string, FunctionArgumentAccess>,
   /**
    * The return type of the function. If undefined, the type should be inferred
    * from the implementation (relevant for shellless functions).
@@ -217,8 +223,7 @@ interface ResolutionCtx {
    */
   resolveSnippet(snippet: Snippet): ResolvedSnippet;
   fnToWgsl(options: FnToWgslOptions): {
-    head: Wgsl;
-    body: Wgsl;
+    code: string;
     returnType: BaseData;
   };
   withVaryingLocations<T>(locations: Record<string, number>, callback: () => T): T;
@@ -261,4 +266,4 @@ type AnyFn = (...args: never[]) => unknown;
 type DualFn<T extends AnyFn> = T & GPUCallable<Parameters<T>>;
 type BindableBufferUsage = 'uniform' | 'readonly' | 'mutable';
 //#endregion
-export { BindableBufferUsage, DualFn, FunctionScopeLayer, GPUCallable, ResolutionCtx, ResolvableObject, SelfResolvable, TgpuShaderStage, Wgsl, WithCast };
+export { BindableBufferUsage, DualFn, FunctionArgument, FunctionScopeLayer, GPUCallable, ResolutionCtx, ResolvableObject, SelfResolvable, TgpuShaderStage, Wgsl, WithCast };