typegpu 0.11.2 → 0.11.4

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/partialIO.d.ts

@@ -0,0 +1,8 @@
+import { BaseData } from "./wgslTypes.js";
+import { InferPatch } from "../shared/repr.js";
+
+//#region src/data/partialIO.d.ts
+
+declare function patchArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T, data: InferPatch<T>): void;
+//#endregion
+export { patchArrayBuffer };

package/data/partialIO.js

@@ -110,6 +110,11 @@ function getPatchInstructions(schema, data, targetBuffer) {
 	});
 	return instructions;
 }
+function patchArrayBuffer(buffer, schema, data) {
+	const instructions = getPatchInstructions(schema, data, buffer);
+	const mappedView = new Uint8Array(buffer);
+	for (const { data: data$1, gpuOffset } of instructions) mappedView.set(data$1, gpuOffset);
+}
 
 //#endregion
-export { convertPartialToPatch, getPatchInstructions };
+export { convertPartialToPatch, getPatchInstructions, patchArrayBuffer };

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/index.d.ts

@@ -38,6 +38,8 @@ import { index_d_exports as index_d_exports$2 } from "./std/index.js";
 import { index_d_exports } from "./common/index.js";
 import { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
 import { WgslGenerator } from "./tgsl/wgslGenerator.js";
+import { readFromArrayBuffer, writeToArrayBuffer } from "./data/dataIO.js";
+import { patchArrayBuffer } from "./data/partialIO.js";
 import { TgpuRenderPipelineDescriptor } from "./indexNamedExports.js";
 
 //#region src/index.d.ts
@@ -68,4 +70,4 @@ declare const tgpu: {
   '~unstable': typeof tgpuUnstable_d_exports;
 };
 //#endregion
-export { AutoFragmentIn, AutoFragmentOut, _AutoVertexIn as AutoVertexIn, AutoVertexOut, BindLayoutEntry, ColorAttachment, Configurable, Eventual, ExtractBindGroupInputFromLayout, INTERNAL_GlobalExt, IndexFlag, InitFromDeviceOptions, InitOptions, LayoutEntryToInput, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, Namespace, NotUniformError, RawCodeSnippetOrigin, RenderFlag, ResolutionError, SampledFlag, ShaderGenerator, Storage, StorageFlag, TextureProps, TgpuAccessor, TgpuBindGroup, TgpuBindGroupLayout, TgpuBuffer, TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, TgpuComparisonSampler, TgpuComptime, TgpuComputeFn, TgpuComputeFnShell, TgpuComputePipeline, TgpuConst, TgpuDeclare, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuFn, TgpuFnShell, TgpuFragmentFn, TgpuFragmentFnShell, TgpuGenericFn, TgpuGuardedComputePipeline, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, TgpuLazy, TgpuMutable, TgpuMutableAccessor, TgpuPrimitiveState, TgpuQuerySet, TgpuRawCodeSnippet, TgpuReadonly, TgpuRenderPipeline, TgpuRenderPipelineDescriptor, TgpuRoot, TgpuSampler, TgpuSlot, TgpuTexture, TgpuTextureView, TgpuUniform, TgpuVar, TgpuVertexFn, TgpuVertexFnShell, TgpuVertexLayout, Uniform, UniformFlag, ValidUsagesFor, ValidateBufferSchema, ValidateStorageSchema, ValidateUniformSchema, VariableScope, Vertex, VertexFlag, WgslGenerator, WithBinding, WithCompute, WithFragment, WithVertex, Withable, index_d_exports as common, index_d_exports$1 as d, tgpu as default, tgpu, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, index_d_exports$2 as std };
+export { AutoFragmentIn, AutoFragmentOut, _AutoVertexIn as AutoVertexIn, AutoVertexOut, BindLayoutEntry, ColorAttachment, Configurable, Eventual, ExtractBindGroupInputFromLayout, INTERNAL_GlobalExt, IndexFlag, InitFromDeviceOptions, InitOptions, LayoutEntryToInput, MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, Namespace, NotUniformError, RawCodeSnippetOrigin, RenderFlag, ResolutionError, SampledFlag, ShaderGenerator, Storage, StorageFlag, TextureProps, TgpuAccessor, TgpuBindGroup, TgpuBindGroupLayout, TgpuBuffer, TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, TgpuComparisonSampler, TgpuComptime, TgpuComputeFn, TgpuComputeFnShell, TgpuComputePipeline, TgpuConst, TgpuDeclare, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuFn, TgpuFnShell, TgpuFragmentFn, TgpuFragmentFnShell, TgpuGenericFn, TgpuGuardedComputePipeline, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, TgpuLazy, TgpuMutable, TgpuMutableAccessor, TgpuPrimitiveState, TgpuQuerySet, TgpuRawCodeSnippet, TgpuReadonly, TgpuRenderPipeline, TgpuRenderPipelineDescriptor, TgpuRoot, TgpuSampler, TgpuSlot, TgpuTexture, TgpuTextureView, TgpuUniform, TgpuVar, TgpuVertexFn, TgpuVertexFnShell, TgpuVertexLayout, Uniform, UniformFlag, ValidUsagesFor, ValidateBufferSchema, ValidateStorageSchema, ValidateUniformSchema, VariableScope, Vertex, VertexFlag, WgslGenerator, WithBinding, WithCompute, WithFragment, WithVertex, Withable, index_d_exports as common, index_d_exports$1 as d, tgpu as default, tgpu, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, patchArrayBuffer, readFromArrayBuffer, index_d_exports$2 as std, writeToArrayBuffer };

package/index.js

@@ -2,6 +2,8 @@ import { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, Missi
 import { isAccessor, isLazy, isMutableAccessor, isSlot } from "./core/slot/slotTypes.js";
 import { shaderGenerator_members_exports } from "./tgsl/shaderGenerator_members.js";
 import { isTgpuFn } from "./core/function/tgpuFn.js";
+import { readFromArrayBuffer, writeToArrayBuffer } from "./data/dataIO.js";
+import { patchArrayBuffer } from "./data/partialIO.js";
 import { isUsableAsStorage } from "./extension.js";
 import { isUsableAsUniform } from "./core/buffer/bufferUsage.js";
 import { isBuffer, isUsableAsVertex } from "./core/buffer/buffer.js";
@@ -23,4 +25,4 @@ import { common_exports } from "./common/index.js";
 var src_default = tgpu_exports;
 
 //#endregion
-export { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, shaderGenerator_members_exports as ShaderGenerator, WgslGenerator, common_exports as common, data_exports as d, src_default as default, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, std_exports as std, tgpu_exports as tgpu };
+export { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, shaderGenerator_members_exports as ShaderGenerator, WgslGenerator, common_exports as common, data_exports as d, src_default as default, isAccessor, isBuffer, isBufferShorthand, isComparisonSampler, isLazy, isMutableAccessor, isSampler, isSlot, isTexture, isTgpuComputeFn, isTgpuFn, isTgpuFragmentFn, isTgpuVertexFn, isUsableAsRender, isUsableAsSampled, isUsableAsStorage, isUsableAsUniform, isUsableAsVertex, isVariable, patchArrayBuffer, readFromArrayBuffer, std_exports as std, tgpu_exports as tgpu, writeToArrayBuffer };

package/indexNamedExports.d.ts

@@ -32,6 +32,8 @@ import { index_d_exports as index_d_exports$1 } from "./std/index.js";
 import { index_d_exports as index_d_exports$2 } from "./common/index.js";
 import { MissingBindGroupsError, MissingLinksError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
 import { WgslGenerator } from "./tgsl/wgslGenerator.js";
+import { readFromArrayBuffer, writeToArrayBuffer } from "./data/dataIO.js";
+import { patchArrayBuffer } from "./data/partialIO.js";
 
 //#region src/indexNamedExports.d.ts
 

package/package.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "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 {
@@ -556,9 +560,8 @@ var ResolutionCtxImpl = class {
 			if (schema.elementCount !== item.length) throw new WgslTypeError(`Cannot create value of type '${schema}' from an array of length: ${item.length}`);
 			return snip(stitch`array<${this.resolve(schema.elementType)}, ${schema.elementCount}>(${item.map((element) => snip(element, schema.elementType, "runtime"))})`, schema, "runtime");
 		}
-		if (Array.isArray(item)) return snip(stitch`array(${item.map((element) => this.resolve(element))})`, UnknownData, "runtime");
 		if (schema && isWgslStruct(schema)) return snip(stitch`${this.resolve(schema)}(${Object.entries(schema.propTypes).map(([key, propType]) => snip(item[key], propType, "runtime"))})`, schema, "runtime");
-		throw new WgslTypeError(`Value ${item} (as json: ${safeStringify(item)}) is not resolvable${schema ? ` to type ${safeStringify(schema)}` : ""}`);
+		throw new WgslTypeError(`Value ${safeStringify(item)} is not resolvable${schema ? ` to type ${safeStringify(schema)}` : ""}`);
 	}
 	resolveSnippet(snippet) {
 		return snip(this.resolve(snippet.value, snippet.dataType).value, snippet.dataType, snippet.origin);
@@ -602,13 +605,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/shared/stringify.js

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

package/shared/tseynit.js

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

package/tgsl/accessIndex.js

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

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