typegpu 0.11.3 → 0.11.4

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-![TypeGPU (light mode)](/apps/typegpu-docs/public/typegpu-logo-light.svg#gh-light-mode-only)
+![TypeGPU (light mode)](https://typegpu.com/typegpu-logo-light.svg#gh-light-mode-only)
 
 
 [Website](https://docs.swmansion.com/TypeGPU) —

package/core/buffer/buffer.js

@@ -1,15 +1,12 @@
 import { $internal } from "../../shared/symbols.js";
 import { getName, setName } from "../../shared/meta.js";
-import { isWgslArray, isWgslData } from "../../data/wgslTypes.js";
+import { isWgslData } from "../../data/wgslTypes.js";
 import { isGPUBuffer } from "../../types.js";
-import { alignmentOf } from "../../data/alignmentOf.js";
-import { roundUp } from "../../mathUtils.js";
 import { sizeOf } from "../../data/sizeOf.js";
 import { getCompiledWriter } from "../../data/compiledIO.js";
-import { readData, writeData } from "../../data/dataIO.js";
-import { convertPartialToPatch, getPatchInstructions } from "../../data/partialIO.js";
+import { calculateOffsets, readFromArrayBuffer, writeToArrayBuffer } from "../../data/dataIO.js";
+import { convertPartialToPatch, getPatchInstructions, patchArrayBuffer } from "../../data/partialIO.js";
 import { mutable, readonly, uniform } from "./bufferUsage.js";
-import { BufferReader, BufferWriter, getSystemEndianness } from "typed-binary";
 
 //#region src/core/buffer/buffer.ts
 const usageToUsageConstructor = {
@@ -27,7 +24,6 @@ function isBuffer(value) {
 function isUsableAsVertex(buffer) {
 	return !!buffer.usableAsVertex;
 }
-const endianness = getSystemEndianness();
 var TgpuBufferImpl = class {
 	[$internal] = true;
 	resourceType = "buffer";
@@ -74,7 +70,7 @@ var TgpuBufferImpl = class {
 			});
 			if (this.initial || this.#initialCallback) {
 				if (this.#initialCallback) this.#initialCallback(this);
-				else if (this.initial) this.#writeToTarget(this.#getMappedRange(), this.initial);
+				else if (this.initial) writeToArrayBuffer(this.#getMappedRange(), this.dataType, this.initial);
 				this.#unmapBuffer();
 			}
 		}
@@ -134,62 +130,30 @@ var TgpuBufferImpl = class {
 	compileWriter() {
 		getCompiledWriter(this.dataType);
 	}
-	#writeToTarget(target, data, options) {
-		const startOffset = options?.startOffset ?? 0;
-		const endOffset = options?.endOffset ?? target.byteLength;
-		if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
-			const src = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-			const regionSize = endOffset - startOffset;
-			if (src.byteLength !== regionSize) console.warn(`Buffer size mismatch: expected ${regionSize} bytes, got ${src.byteLength}. ` + (src.byteLength < regionSize ? "Data truncated." : "Excess ignored."));
-			const copyLen = Math.min(src.byteLength, regionSize);
-			new Uint8Array(target).set(src.subarray(0, copyLen), startOffset);
-			return;
-		}
-		const dataView = new DataView(target);
-		const isLittleEndian = endianness === "little";
-		const compiledWriter = getCompiledWriter(this.dataType);
-		if (compiledWriter) try {
-			compiledWriter(dataView, startOffset, data, isLittleEndian, endOffset);
-			return;
-		} catch (error) {
-			console.error(`Error when using compiled writer for buffer ${getName(this) ?? "<unnamed>"} - this is likely a bug, please submit an issue at https://github.com/software-mansion/TypeGPU/issues\nUsing fallback writer instead.`, error);
-		}
-		const writer = new BufferWriter(target);
-		writer.seekTo(startOffset);
-		writeData(writer, this.dataType, data);
-	}
 	write(data, options) {
 		const gpuBuffer = this.buffer;
-		const bufferSize = sizeOf(this.dataType);
-		const startOffset = options?.startOffset ?? 0;
-		let naturalSize = void 0;
-		if (isWgslArray(this.dataType) && Array.isArray(data)) naturalSize = data.length * roundUp(sizeOf(this.dataType.elementType), alignmentOf(this.dataType.elementType));
-		else if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) naturalSize = data.byteLength;
-		const naturalEndOffset = naturalSize !== void 0 ? Math.min(startOffset + naturalSize, bufferSize) : void 0;
-		const size = (options?.endOffset ?? naturalEndOffset ?? bufferSize) - startOffset;
 		if (gpuBuffer.mapState === "mapped") {
 			const mapped = this.#getMappedRange();
 			if (data instanceof ArrayBuffer && data === mapped) return;
-			this.#writeToTarget(mapped, data, options);
+			writeToArrayBuffer(mapped, this.dataType, data, options);
 			return;
 		}
-		if (!(data instanceof ArrayBuffer && data === this.#hostBuffer)) this.#writeToTarget(this.#hostBuffer, data, options);
+		if (!(data instanceof ArrayBuffer && data === this.#hostBuffer)) writeToArrayBuffer(this.#hostBuffer, this.dataType, data, options);
+		const { startOffset, endOffset } = calculateOffsets(options, this.dataType, data);
+		const size = endOffset - startOffset;
 		this.#device.queue.writeBuffer(gpuBuffer, startOffset, this.#hostBuffer, startOffset, size);
 	}
 	/** @deprecated Use {@link patch} instead. */
 	writePartial(data) {
-		this.#applyInstructions(getPatchInstructions(this.dataType, convertPartialToPatch(this.dataType, data), this.#hostBuffer));
+		this.patch(convertPartialToPatch(this.dataType, data));
 	}
 	patch(data) {
-		this.#applyInstructions(getPatchInstructions(this.dataType, data, this.#hostBuffer));
-	}
-	#applyInstructions(instructions) {
 		const gpuBuffer = this.buffer;
-		if (gpuBuffer.mapState === "mapped") {
-			const mappedRange = this.#getMappedRange();
-			const mappedView = new Uint8Array(mappedRange);
-			for (const { data, gpuOffset } of instructions) mappedView.set(data, gpuOffset);
-		} else for (const { data, gpuOffset } of instructions) this.#device.queue.writeBuffer(gpuBuffer, gpuOffset, data);
+		if (gpuBuffer.mapState === "mapped") patchArrayBuffer(this.#getMappedRange(), this.dataType, data);
+		else {
+			const instructions = getPatchInstructions(this.dataType, data, this.#hostBuffer);
+			for (const { data: data$1, gpuOffset } of instructions) this.#device.queue.writeBuffer(gpuBuffer, gpuOffset, data$1);
+		}
 	}
 	clear() {
 		const gpuBuffer = this.buffer;
@@ -210,10 +174,10 @@ var TgpuBufferImpl = class {
 	}
 	async read() {
 		const gpuBuffer = this.buffer;
-		if (gpuBuffer.mapState === "mapped") return readData(new BufferReader(this.#getMappedRange()), this.dataType);
+		if (gpuBuffer.mapState === "mapped") return readFromArrayBuffer(this.#getMappedRange(), this.dataType);
 		if (gpuBuffer.usage & GPUBufferUsage.MAP_READ) {
 			await gpuBuffer.mapAsync(GPUMapMode.READ);
-			const res$1 = readData(new BufferReader(this.#getMappedRange()), this.dataType);
+			const res$1 = readFromArrayBuffer(this.#getMappedRange(), this.dataType);
 			this.#unmapBuffer();
 			return res$1;
 		}
@@ -225,7 +189,7 @@ var TgpuBufferImpl = class {
 		commandEncoder.copyBufferToBuffer(gpuBuffer, 0, stagingBuffer, 0, sizeOf(this.dataType));
 		this.#device.queue.submit([commandEncoder.finish()]);
 		await stagingBuffer.mapAsync(GPUMapMode.READ, 0, sizeOf(this.dataType));
-		const res = readData(new BufferReader(stagingBuffer.getMappedRange()), this.dataType);
+		const res = readFromArrayBuffer(stagingBuffer.getMappedRange(), this.dataType);
 		stagingBuffer.unmap();
 		stagingBuffer.destroy();
 		return res;

package/core/function/tgpuFragmentFn.d.ts

@@ -2,9 +2,9 @@ import { TgpuNamable } from "../../shared/meta.js";
 import { $internal } from "../../shared/symbols.js";
 import { Prettify } from "../../shared/utilityTypes.js";
 import { AnyFragmentInputBuiltin, AnyFragmentOutputBuiltin, OmitBuiltins } from "../../builtin.js";
+import { InstanceToSchema } from "../../data/instanceToSchema.js";
 import { BaseIOData, IOLayout, IORecord, InferIO } from "./fnTypes.js";
 import { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut } from "./autoIO.js";
-import { InstanceToSchema } from "../../data/instanceToSchema.js";
 import { IOLayoutToSchema } from "./ioSchema.js";
 import { BaseData, Decorated, Interpolate, Location, Vec4f, Vec4i, Vec4u, WgslStruct } from "../../data/wgslTypes.js";
 import { UndecorateRecord } from "../../data/dataTypes.js";

package/core/pipeline/computePipeline.d.ts

@@ -3,8 +3,8 @@ import { $internal } from "../../shared/symbols.js";
 import { AnyComputeBuiltin } from "../../builtin.js";
 import "../querySet/querySet.js";
 import "../../data/snippet.js";
-import "../../tgsl/consoleLog/types.js";
 import { IORecord } from "../function/fnTypes.js";
+import "../../tgsl/consoleLog/types.js";
 import { TgpuComputeFn } from "../function/tgpuComputeFn.js";
 import "../slot/slotTypes.js";
 import { PrimitiveOffsetInfo } from "../../data/offsetUtils.js";

package/core/root/init.d.ts

@@ -1,3 +1,4 @@
+import "../querySet/querySet.js";
 import "../buffer/bufferShorthand.js";
 import { LogGeneratorOptions } from "../../tgsl/consoleLog/types.js";
 import "../pipeline/computePipeline.js";

package/core/root/init.js

@@ -54,6 +54,12 @@ var TgpuGuardedComputePipelineImpl = class TgpuGuardedComputePipelineImpl {
 	with(bindGroupOrEncoder) {
 		return new TgpuGuardedComputePipelineImpl(this.#root, this.#pipeline.with(bindGroupOrEncoder), this.#sizeUniform, this.#workgroupSize);
 	}
+	withPerformanceCallback(callback) {
+		return new TgpuGuardedComputePipelineImpl(this.#root, this.#pipeline.withPerformanceCallback(callback), this.#sizeUniform, this.#workgroupSize);
+	}
+	withTimestampWrites(options) {
+		return new TgpuGuardedComputePipelineImpl(this.#root, this.#pipeline.withTimestampWrites(options), this.#sizeUniform, this.#workgroupSize);
+	}
 	dispatchThreads(...threads) {
 		const sanitizedSize = toVec3(threads);
 		const workgroupCount = ceil(vec3f(sanitizedSize).div(vec3f(this.#workgroupSize)));

package/core/root/rootTypes.d.ts

@@ -4,14 +4,14 @@ import { Assume, Mutable, OmitProps, Prettify } from "../../shared/utilityTypes.
 import { WgslComparisonSamplerProps, WgslSamplerProps } from "../../data/sampler.js";
 import { AnyComputeBuiltin, AnyFragmentInputBuiltin, OmitBuiltins } from "../../builtin.js";
 import { TgpuQuerySet } from "../querySet/querySet.js";
+import { InstanceToSchema } from "../../data/instanceToSchema.js";
 import { TgpuMutable, TgpuReadonly, TgpuUniform } from "../buffer/bufferShorthand.js";
-import { LogGeneratorOptions } from "../../tgsl/consoleLog/types.js";
 import { IORecord } from "../function/fnTypes.js";
+import { LogGeneratorOptions } from "../../tgsl/consoleLog/types.js";
 import { TgpuComputeFn } from "../function/tgpuComputeFn.js";
 import { Eventual, TgpuAccessor, TgpuMutableAccessor, TgpuSlot } from "../slot/slotTypes.js";
 import { TgpuComputePipeline } from "../pipeline/computePipeline.js";
 import { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut, AutoVertexIn, AutoVertexOut } from "../function/autoIO.js";
-import { InstanceToSchema } from "../../data/instanceToSchema.js";
 import { FragmentInConstrained, FragmentOutConstrained, TgpuFragmentFn, VertexOutToVarying } from "../function/tgpuFragmentFn.js";
 import { TgpuVertexFn } from "../function/tgpuVertexFn.js";
 import { AttribRecordToDefaultDataTypes, LayoutToAllowedAttribs } from "../vertexLayout/vertexAttribute.js";
@@ -40,6 +40,20 @@ interface TgpuGuardedComputePipeline<TArgs extends number[] = number[]> extends
    * Analogous to `TgpuComputePipeline.with(encoder)`.
    */
   with(encoder: GPUCommandEncoder): TgpuGuardedComputePipeline<TArgs>;
+  /**
+   * Returns a pipeline wrapper with the given performance callback attached.
+   * Analogous to `TgpuComputePipeline.withPerformanceCallback(callback)`.
+   */
+  withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): TgpuGuardedComputePipeline<TArgs>;
+  /**
+   * Returns a pipeline wrapper with the given timestamp writes configuration.
+   * Analogous to `TgpuComputePipeline.withTimestampWrites(options)`.
+   */
+  withTimestampWrites(options: {
+    querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;
+    beginningOfPassWriteIndex?: number;
+    endOfPassWriteIndex?: number;
+  }): TgpuGuardedComputePipeline<TArgs>;
   /**
    * Dispatches the pipeline.
    * Unlike `TgpuComputePipeline.dispatchWorkgroups()`, this method takes in the
@@ -166,7 +180,7 @@ interface WithBinding extends Withable<WithBinding> {
   })): TgpuRenderPipeline<NormalizeOutput<TFragmentOut>> | TgpuRenderPipeline<Void>;
   /**
    * Creates a compute pipeline that executes the given callback in an exact number of threads.
-   * This is different from `withCompute(...).createPipeline()` in that it does a bounds check on the
+   * This is different from `createComputePipeline()` in that it does a bounds check on the
    * thread id, where as regular pipelines do not and work in units of workgroups.
    *
    * @param callback A function converted to WGSL and executed on the GPU.
@@ -473,10 +487,8 @@ interface TgpuRoot extends Unwrapper, WithBinding {
    * Typed wrapper around a GPUBuffer.
    *
    * @param typeSchema The type of data that this buffer will hold.
-   * @param initial The initial value of the buffer. (optional)
+   * @param initial Either initial value of the buffer, or an initializer to execute on the mapped buffer. (optional)
    */
-  createBuffer<TData extends AnyData>(typeSchema: ValidateBufferSchema<TData>, initializer: (buffer: TgpuBuffer<NoInfer<TData>>) => void): TgpuBuffer<TData>;
-  createBuffer<TData extends AnyData>(typeSchema: ValidateBufferSchema<TData>, initial?: InferInput<NoInfer<TData>>): TgpuBuffer<TData>;
   createBuffer<TData extends AnyData>(typeSchema: ValidateBufferSchema<TData>, initial?: ((buffer: TgpuBuffer<NoInfer<TData>>) => void) | InferInput<NoInfer<TData>>): TgpuBuffer<TData>;
   /**
    * Allocates memory on the GPU, allows passing data between host and shader.
@@ -494,10 +506,8 @@ interface TgpuRoot extends Unwrapper, WithBinding {
    * use {@link TgpuRoot.createBuffer}.
    *
    * @param typeSchema The type of data that this buffer will hold.
-   * @param initial The initial value of the buffer. (optional)
+   * @param initial Either initial value of the buffer, or an initializer to execute on the mapped buffer. (optional)
    */
-  createUniform<TData extends AnyWgslData>(typeSchema: ValidateUniformSchema<TData>, initializer: (buffer: TgpuBuffer<NoInfer<TData>>) => void): TgpuUniform<TData>;
-  createUniform<TData extends AnyWgslData>(typeSchema: ValidateUniformSchema<TData>, initial?: InferInput<NoInfer<TData>>): TgpuUniform<TData>;
   createUniform<TData extends AnyWgslData>(typeSchema: ValidateUniformSchema<TData>, initial?: ((buffer: TgpuBuffer<NoInfer<TData>>) => void) | InferInput<NoInfer<TData>>): TgpuUniform<TData>;
   /**
    * Allocates memory on the GPU, allows passing data between host and shader.
@@ -514,10 +524,8 @@ interface TgpuRoot extends Unwrapper, WithBinding {
    * use {@link TgpuRoot.createBuffer}.
    *
    * @param typeSchema The type of data that this buffer will hold.
-   * @param initial The initial value of the buffer. (optional)
+   * @param initial Either initial value of the buffer, or an initializer to execute on the mapped buffer. (optional)
    */
-  createMutable<TData extends AnyWgslData>(typeSchema: ValidateStorageSchema<TData>, initializer: (buffer: TgpuBuffer<NoInfer<TData>>) => void): TgpuMutable<TData>;
-  createMutable<TData extends AnyWgslData>(typeSchema: ValidateStorageSchema<TData>, initial?: InferInput<NoInfer<TData>>): TgpuMutable<TData>;
   createMutable<TData extends AnyWgslData>(typeSchema: ValidateStorageSchema<TData>, initial?: ((buffer: TgpuBuffer<NoInfer<TData>>) => void) | InferInput<NoInfer<TData>>): TgpuMutable<TData>;
   /**
    * Allocates memory on the GPU, allows passing data between host and shader.
@@ -534,10 +542,8 @@ interface TgpuRoot extends Unwrapper, WithBinding {
    * use {@link TgpuRoot.createBuffer}.
    *
    * @param typeSchema The type of data that this buffer will hold.
-   * @param initial The initial value of the buffer. (optional)
+   * @param initial Either initial value of the buffer, or an initializer to execute on the mapped buffer. (optional)
    */
-  createReadonly<TData extends AnyWgslData>(typeSchema: ValidateStorageSchema<TData>, initializer: (buffer: TgpuBuffer<NoInfer<TData>>) => void): TgpuReadonly<TData>;
-  createReadonly<TData extends AnyWgslData>(typeSchema: ValidateStorageSchema<TData>, initial?: InferInput<NoInfer<TData>>): TgpuReadonly<TData>;
   createReadonly<TData extends AnyWgslData>(typeSchema: ValidateStorageSchema<TData>, initial?: ((buffer: TgpuBuffer<NoInfer<TData>>) => void) | InferInput<NoInfer<TData>>): TgpuReadonly<TData>;
   /**
    * Allocates memory on the GPU, allows passing data between host and shader.

package/core/slot/accessor.js

@@ -25,7 +25,7 @@ var AccessorBase = class {
 	constructor(schemaOrConstructor, defaultValue = void 0) {
 		this.schema = isData(schemaOrConstructor) ? schemaOrConstructor : schemaOrConstructor(0);
 		this.defaultValue = defaultValue;
-		this.slot = slot(defaultValue);
+		this.slot = (() => slot(defaultValue))();
 		this[$getNameForward] = this.slot;
 	}
 	get [$gpuValueOf]() {

package/data/dataIO.d.ts

@@ -0,0 +1,11 @@
+import { BufferWriteOptions } from "../core/buffer/buffer.js";
+import { BaseData } from "./wgslTypes.js";
+import { Infer, InferInput } from "../shared/repr.js";
+import "typed-binary";
+
+//#region src/data/dataIO.d.ts
+
+declare function writeToArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T, data: InferInput<T> | ArrayBuffer, options?: BufferWriteOptions): void;
+declare function readFromArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T): Infer<T>;
+//#endregion
+export { readFromArrayBuffer, writeToArrayBuffer };

package/data/dataIO.js

@@ -1,8 +1,13 @@
+import { getName } from "../shared/meta.js";
+import { isWgslArray } from "./wgslTypes.js";
 import { vec2f, vec2h, vec2i, vec2u, vec3f, vec3h, vec3i, vec3u, vec4f, vec4h, vec4i, vec4u } from "./vector.js";
 import { alignmentOf, customAlignmentOf } from "./alignmentOf.js";
+import { roundUp } from "../mathUtils.js";
 import { sizeOf } from "./sizeOf.js";
 import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
 import alignIO_default from "./alignIO.js";
+import { getCompiledWriter } from "./compiledIO.js";
+import { BufferReader, BufferWriter, getSystemEndianness } from "typed-binary";
 
 //#region src/data/dataIO.ts
 const dataWriters = {
@@ -553,6 +558,45 @@ function readData(input, schema) {
 	if (!reader) throw new Error(`Cannot read data of type '${schema.type}'.`);
 	return reader(input, schema);
 }
+const endianness = getSystemEndianness();
+function calculateOffsets(options, schema, data) {
+	const bufferSize = sizeOf(schema);
+	const startOffset = options?.startOffset ?? 0;
+	let naturalSize = void 0;
+	if (isWgslArray(schema) && Array.isArray(data)) naturalSize = data.length * roundUp(sizeOf(schema.elementType), alignmentOf(schema.elementType));
+	else if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) naturalSize = data.byteLength;
+	const naturalEndOffset = naturalSize !== void 0 ? Math.min(startOffset + naturalSize, bufferSize) : void 0;
+	return {
+		startOffset,
+		endOffset: options?.endOffset ?? naturalEndOffset ?? bufferSize
+	};
+}
+function writeToArrayBuffer(buffer, schema, data, options) {
+	const { startOffset, endOffset } = calculateOffsets(options, schema, data);
+	if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+		const src = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		const regionSize = endOffset - startOffset;
+		if (src.byteLength !== regionSize) console.warn(`Buffer size mismatch: expected ${regionSize} bytes, got ${src.byteLength}. ` + (src.byteLength < regionSize ? "Data truncated." : "Excess ignored."));
+		const copyLen = Math.min(src.byteLength, regionSize);
+		new Uint8Array(buffer).set(src.subarray(0, copyLen), startOffset);
+		return;
+	}
+	const dataView = new DataView(buffer);
+	const isLittleEndian = endianness === "little";
+	const compiledWriter = getCompiledWriter(schema);
+	if (compiledWriter) try {
+		compiledWriter(dataView, startOffset, data, isLittleEndian, endOffset);
+		return;
+	} catch (error) {
+		console.error(`Error when using compiled writer for data type '${schema.type}' (${getName(schema) ?? "unnamed"}) - this is likely a bug, please submit an issue at https://github.com/software-mansion/TypeGPU/issues\nUsing fallback writer instead.`, error);
+	}
+	const writer = new BufferWriter(buffer);
+	writer.seekTo(startOffset);
+	writeData(writer, schema, data);
+}
+function readFromArrayBuffer(buffer, schema) {
+	return readData(new BufferReader(buffer), schema);
+}
 
 //#endregion
-export { readData, writeData };
+export { calculateOffsets, readFromArrayBuffer, writeData, writeToArrayBuffer };

package/data/dataTypes.js

@@ -1,5 +1,4 @@
-import { $internal, isMarkedInternal } from "../shared/symbols.js";
-import { setName } from "../shared/meta.js";
+import { isMarkedInternal } from "../shared/symbols.js";
 import { vertexFormats } from "../shared/vertexFormat.js";
 import { isAlignAttrib, isDecorated, isLocationAttrib, isPtr, isSizeAttrib, isWgslData } from "./wgslTypes.js";
 
@@ -89,14 +88,6 @@ var MatrixColumnsAccess = class {
 		this.matrix = matrix;
 	}
 };
-var ConsoleLog = class {
-	[$internal] = true;
-	op;
-	constructor(op) {
-		this.op = op;
-		setName(this, "consoleLog");
-	}
-};
 
 //#endregion
-export { ConsoleLog, InfixDispatch, MatrixColumnsAccess, UnknownData, getCustomAlignment, getCustomLocation, getCustomSize, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct, undecorate, unptr };
+export { InfixDispatch, MatrixColumnsAccess, UnknownData, getCustomAlignment, getCustomLocation, getCustomSize, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct, undecorate, unptr };

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/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.3";
+var version = "0.11.4";
 
 //#endregion
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.11.3",
+  "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

@@ -560,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);

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

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

package/tgsl/consoleLog/deserializers.js

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

package/tgsl/consoleLog/logGenerator.js

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

package/tgsl/consoleLog/types.d.ts

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

package/tgsl/generationHelpers.d.ts

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

package/tgsl/jsPolyfills.d.ts

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

package/tgsl/jsPolyfills.js

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

package/tgsl/wgslGenerator.js

@@ -1,7 +1,7 @@
 import { $gpuCallable, $internal, $providing, isMarkedInternal } from "../shared/symbols.js";
 import { getName } from "../shared/meta.js";
 import { Void, isBool, isNaturallyEphemeral, isNumericSchema, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { ConsoleLog, InfixDispatch, UnknownData, isLooseData, unptr } from "../data/dataTypes.js";
+import { InfixDispatch, UnknownData, unptr } from "../data/dataTypes.js";
 import { fallthroughCopyOrigin, isEphemeralOrigin, isEphemeralSnippet, snip } from "../data/snippet.js";
 import { ResolutionError, WgslTypeError, invariant } from "../errors.js";
 import { isGPUCallable, isKnownAtComptime } from "../types.js";
@@ -24,9 +24,10 @@ import { arrayOf } from "../data/array.js";
 import { pow } from "../std/numeric.js";
 import { resolveData } from "../core/resolve/resolveData.js";
 import { UnrollableIterable } from "../core/unroll/tgpuUnroll.js";
-import { mathToStd } from "./math.js";
+import { mathToStd, supportedLogOps } from "./jsPolyfills.js";
 import { isTgpuRange } from "../std/range.js";
 import { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets } from "./forOfUtils.js";
+import { stringifyNode } from "../shared/tseynit.js";
 import * as tinyest from "tinyest";
 
 //#region src/tgsl/wgslGenerator.ts
@@ -225,8 +226,9 @@ ${this.ctx.pre}}`;
 				return snip(rhsStr$1, bool, "runtime");
 			}
 			const rhsExpr = this._expression(rhs);
-			if (rhsExpr.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot assign a ref to an existing variable '${lhsExpr}', define a new variable instead.`);
+			if (rhsExpr.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot assign a ref to an existing variable '${stringifyNode(lhs)}', define a new variable instead.`);
 			if (op === "==") throw new Error("Please use the === operator instead of ==");
+			if (op === "!=") throw new Error("Please use the !== operator instead of !=");
 			if (op === "===" && isKnownAtComptime(lhsExpr) && isKnownAtComptime(rhsExpr)) return snip(lhsExpr.value === rhsExpr.value, bool, "constant");
 			if (lhsExpr.dataType === UnknownData) throw new WgslTypeError(`Left-hand side of '${op}' is of unknown type`);
 			if (rhsExpr.dataType === UnknownData) throw new WgslTypeError(`Right-hand side of '${op}' is of unknown type`);
@@ -250,10 +252,13 @@ ${this.ctx.pre}}`;
 			const rhsStr = this.ctx.resolve(convRhs.value, convRhs.dataType).value;
 			const type = operatorToType(convLhs.dataType, op, convRhs.dataType);
 			if (exprType === NODE.assignmentExpr) {
-				if (convLhs.origin === "constant" || convLhs.origin === "constant-tgpu-const-ref" || convLhs.origin === "runtime-tgpu-const-ref") throw new WgslTypeError(`'${lhsStr} = ${rhsStr}' is invalid, because ${lhsStr} is a constant. This error may also occur when assigning to a value defined outside of a TypeGPU function's scope.`);
-				if (lhsExpr.origin === "argument") throw new WgslTypeError(`'${lhsStr} ${op} ${rhsStr}' is invalid, because non-pointer arguments cannot be mutated.`);
-				if (op === "=" && rhsExpr.origin === "argument" && !isNaturallyEphemeral(rhsExpr.dataType)) throw new WgslTypeError(`'${lhsStr} = ${rhsStr}' is invalid, because argument references cannot be assigned.\n-----\nTry '${lhsStr} = ${this.ctx.resolve(rhsExpr.dataType).value}(${rhsStr})' to copy the value instead.\n-----`);
-				if (op === "=" && !isEphemeralSnippet(rhsExpr)) throw new WgslTypeError(`'${lhsStr} = ${rhsStr}' is invalid, because references cannot be assigned.\n-----\nTry '${lhsStr} = ${this.ctx.resolve(rhsExpr.dataType).value}(${rhsStr})' to copy the value instead.\n-----`);
+				if (convLhs.origin === "constant" || convLhs.origin === "constant-tgpu-const-ref" || convLhs.origin === "runtime-tgpu-const-ref") {
+					if (isKnownAtComptime(convLhs)) throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because the left side is defined outside of the shader, and therefore is immutable during its execution. Try using tgpu.privateVar or buffers.`);
+					throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because the left side is a constant.`);
+				}
+				if (lhsExpr.origin === "argument") throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because non-pointer arguments cannot be mutated.`);
+				if (op === "=" && rhsExpr.origin === "argument" && !isNaturallyEphemeral(rhsExpr.dataType)) throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because argument references cannot be assigned.\n-----\nTry '${stringifyNode(lhs)} = ${this.ctx.resolve(rhsExpr.dataType).value}(${stringifyNode(rhs)})' to copy the value instead.\n-----`);
+				if (op === "=" && !isEphemeralSnippet(rhsExpr)) throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because references cannot be assigned.\n-----\nTry '${stringifyNode(lhs)} = ${this.ctx.resolve(rhsExpr.dataType).value}(${stringifyNode(rhs)})' to copy the value instead.\n-----`);
 			}
 			return snip(parenthesizedOps.includes(op) ? `(${lhsStr} ${OP_MAP[op] ?? op} ${rhsStr})` : `${lhsStr} ${OP_MAP[op] ?? op} ${rhsStr}`, type, "runtime");
 		}
@@ -274,37 +279,28 @@ ${this.ctx.pre}}`;
 		}
 		if (expression[0] === NODE.memberAccess) {
 			const [_, targetNode, property] = expression;
-			const target = this._expression(targetNode);
-			if (target.value === console) return snip(new ConsoleLog(property), UnknownData, "runtime");
-			if (target.value === Math) {
-				if (property in mathToStd && mathToStd[property]) return snip(mathToStd[property], UnknownData, "runtime");
-				if (typeof Math[property] === "function") throw new Error(`Unsupported functionality 'Math.${property}'. Use an std alternative, or implement the function manually.`);
-			}
-			const accessed = accessProp(target, property);
-			if (!accessed) throw new Error(stitch`Property '${property}' not found on value '${target}' of type ${this.ctx.resolve(target.dataType)}`);
+			const accessed = accessProp(this._expression(targetNode), property);
+			if (!accessed) throw new Error(`Property '${property}' not found on '${stringifyNode(targetNode)}'`);
 			return accessed;
 		}
 		if (expression[0] === NODE.indexAccess) {
 			const [_, targetNode, propertyNode] = expression;
 			const target = this._expression(targetNode);
 			const inProperty = this._expression(propertyNode);
-			const property = convertToCommonType(this.ctx, [inProperty], [u32, i32], false)?.[0] ?? inProperty;
-			const accessed = accessIndex(target, property);
-			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(`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.`);
-			}
+			const accessed = accessIndex(target, convertToCommonType(this.ctx, [inProperty], [u32, i32], false)?.[0] ?? inProperty);
+			if (!accessed) throw new Error(`Index access '${stringifyNode(expression)}' 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;
 		}
 		if (expression[0] === NODE.numericLiteral) {
 			const type = typeof expression[1] === "string" ? numericLiteralToSnippet(parseNumericString(expression[1])) : numericLiteralToSnippet(expression[1]);
-			if (!type) throw new Error(`Invalid numeric literal ${expression[1]}`);
+			invariant(type, `Expected ${stringifyNode(expression)} to be valid numeric literal`);
 			return type;
 		}
 		if (expression[0] === NODE.call) {
 			const [_, calleeNode, argNodes] = expression;
-			const callee = this._expression(calleeNode);
+			const _callee = this._expression(calleeNode);
+			const callee = mathToStd.has(_callee.value) ? snip(mathToStd.get(_callee.value), UnknownData, "runtime") : _callee;
+			if (supportedLogOps().includes(callee.value)) return this.ctx.generateLog(callee.value, argNodes.map((arg) => this._expression(arg)));
 			if (isWgslStruct(callee.value)) {
 				if (argNodes.length > 1) throw new WgslTypeError("Struct schemas should always be called with at most 1 argument");
 				if (!argNodes[0]) return snip(`${this.ctx.resolve(callee.value).value}()`, callee.value, "runtime");
@@ -324,14 +320,13 @@ ${this.ctx.pre}}`;
 				const rhs = this._expression(argNodes[0]);
 				return callee.value.operator(this.ctx, [callee.value.lhs, rhs]);
 			}
-			if (callee.value instanceof ConsoleLog) return this.ctx.generateLog(callee.value.op, argNodes.map((arg) => this._expression(arg)));
 			if (isGPUCallable(callee.value)) {
 				const callable = callee.value[$gpuCallable];
 				const strictSignature = callable.strictSignature;
 				let convertedArguments;
 				if (strictSignature) convertedArguments = argNodes.map((arg, i) => {
 					const argType = strictSignature.argTypes[i];
-					if (!argType) throw new WgslTypeError(`Function '${getName(callee.value)}' was called with too many arguments`);
+					if (!argType) throw new WgslTypeError(`Call '${stringifyNode(expression)}' is invalid since the function expected fewer arguments`);
 					return this._typedExpression(arg, argType);
 				});
 				else convertedArguments = argNodes.map((arg) => this._expression(arg));
@@ -361,6 +356,10 @@ ${this.ctx.pre}}`;
 				}));
 				if (shelllessCall) return shelllessCall;
 			}
+			const maybeMathMethod = Object.getOwnPropertyNames(Math).find((prop) => Math[prop] === callee.value);
+			if (maybeMathMethod) throw new Error(`Unsupported Math functionality 'Math.${maybeMathMethod}()'. Use an std alternative, or implement the function manually.`);
+			const maybeConsoleMethod = Object.getOwnPropertyNames(console).find((prop) => console[prop] === callee.value);
+			if (maybeConsoleMethod) throw new Error(`Unsupported console functionality 'console.${maybeConsoleMethod}()'.`);
 			throw new Error(`Function '${getName(callee.value) ?? String(callee.value)}' is not marked with the 'use gpu' directive and cannot be used in a shader`);
 		}
 		if (expression[0] === NODE.objectExpr) {
@@ -391,7 +390,7 @@ ${this.ctx.pre}}`;
 				const convertedSnippets = convertStructValues(this.ctx, structType, entries);
 				return snip(stitch`${this.ctx.resolve(structType).value}(${convertedSnippets})`, structType, "runtime");
 			}
-			throw new WgslTypeError(`No target type could be inferred for object with keys [${Object.keys(obj).join(", ")}], please wrap the object in the corresponding schema.`);
+			throw new WgslTypeError(`No target type could be inferred for object '${stringifyNode(expression)}', please wrap the object in the corresponding schema.`);
 		}
 		if (expression[0] === NODE.arrayExpr) {
 			const [_, valueNodes] = expression;
@@ -406,7 +405,7 @@ ${this.ctx.pre}}`;
 				const valuesSnippets = valueNodes.map((value) => this._expression(value));
 				if (valuesSnippets.length === 0) throw new WgslTypeError("Cannot infer the type of an empty array literal.");
 				const converted = convertToCommonType(this.ctx, valuesSnippets);
-				if (!converted) throw new WgslTypeError("The given values cannot be automatically converted to a common type. Consider wrapping the array in an appropriate schema");
+				if (!converted) throw new WgslTypeError(`Values '${stringifyNode(expression)}' cannot be automatically converted to a common type. Consider wrapping the array in an appropriate schema`);
 				values = converted;
 				elemType = concretize(values[0]?.dataType);
 			}
@@ -417,7 +416,7 @@ ${this.ctx.pre}}`;
 			const [_, test, consequent, alternative] = expression;
 			const testExpression = this._expression(test);
 			if (isKnownAtComptime(testExpression)) return testExpression.value ? this._expression(consequent) : this._expression(alternative);
-			else throw new Error(`Ternary operator is only supported for comptime-known checks (used with '${testExpression.value}'). For runtime checks, please use 'std.select' or if/else statements.`);
+			else throw new Error(`Ternary operator '${stringifyNode(expression)}' is invalid, because only comptime-known checks are supported. For runtime checks, please use 'std.select' or if/else statements.`);
 		}
 		if (expression[0] === NODE.stringLiteral) return snip(expression[1], UnknownData, "constant");
 		if (expression[0] === NODE.preUpdate) throw new Error("Cannot use pre-updates in TypeGPU functions.");
@@ -448,10 +447,10 @@ ${this.ctx.pre}}`;
 		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 (returnSnippet.value instanceof RefOperator) throw new WgslTypeError(`Cannot return '${stringifyNode(returnNode)}' because it is a d.ref`);
+			if (returnSnippet.origin === "argument" && !isNaturallyEphemeral(returnSnippet.dataType) && this.ctx.topFunctionScope?.functionType === "normal") throw new WgslTypeError(`'${stringifyNode(statement)}' is invalid, cannot return references to arguments. 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 str = stringifyNode(returnNode);
 				const typeStr = this.ctx.resolve(unptr(returnSnippet.dataType)).value;
 				throw new WgslTypeError(`'return ${str};' is invalid, cannot return references.
 -----
@@ -495,11 +494,10 @@ ${this.ctx.pre}else ${alternate}`;
 			let varType = "var";
 			const [stmtType, rawId, rawValue] = statement;
 			const eq = rawValue !== void 0 ? this._expression(rawValue) : void 0;
-			if (!eq) throw new Error(`Cannot create variable '${rawId}' without an initial value.`);
+			if (!eq) throw new Error(`'${stringifyNode(statement)}' is invalid because all variables need initializers.`);
 			const ephemeral = isEphemeralSnippet(eq);
 			let dataType = eq.dataType;
 			const naturallyEphemeral = isNaturallyEphemeral(dataType);
-			if (isLooseData(eq.dataType)) throw new Error(`Cannot create variable '${rawId}' with loose data type.`);
 			if (eq.value instanceof RefOperator) {
 				if (eq.dataType !== UnknownData) throw new WgslTypeError(`Cannot store d.ref() in a variable if it references another value. Copy the value passed into d.ref() instead.`);
 				const refSnippet = eq.value.snippet;
@@ -508,7 +506,7 @@ ${this.ctx.pre}else ${alternate}`;
 			}
 			if (!ephemeral) {
 				if (stmtType === NODE.let) {
-					const rhsStr$1 = this.ctx.resolve(eq.value).value;
+					const rhsStr$1 = stringifyNode(rawValue ?? "");
 					const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
 					throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, because references cannot be assigned to 'let' variable declarations.
 -----
@@ -532,7 +530,7 @@ ${this.ctx.pre}else ${alternate}`;
 				else if (naturallyEphemeral) varType = eq.origin === "constant" ? "const" : "let";
 			} else if (eq.origin === "argument") {
 				if (!naturallyEphemeral) {
-					const rhsStr$1 = this.ctx.resolve(eq.value).value;
+					const rhsStr$1 = stringifyNode(rawValue ?? "");
 					const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
 					throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, because references to arguments cannot be assigned to 'let' variable declarations.
   -----
@@ -600,7 +598,7 @@ ${this.ctx.pre}else ${alternate}`;
 					if (length === 0) return "";
 					const { value } = iterableSnippet;
 					const elements = isTgpuRange(value) ? value.map((i) => coerceToSnippet(i)) : value instanceof ArrayExpression ? value.elements : Array.from({ length }, (_$1, i) => getElementSnippet(iterableSnippet, snip(i, u32, "constant")));
-					if (isEphemeralSnippet(elements[0]) && !isNaturallyEphemeral(elements[0]?.dataType)) throw new WgslTypeError("Cannot unroll loop. The elements of iterable are emphemeral but not naturally ephemeral.");
+					if (isEphemeralSnippet(elements[0]) && !isNaturallyEphemeral(elements[0]?.dataType)) throw new WgslTypeError(`Cannot unroll '${stringifyNode(iterable)}'. The elements of iterable are constructed in place but are not value types.`);
 					return elements.map((e, i) => `${this.ctx.pre}// unrolled iteration #${i}\n${this.ctx.pre}${this._block(blockified, { [originalLoopVarName]: e })}`).join("\n");
 				}
 				this.#unrolling = false;

package/tgsl/consoleLog/types.js

@@ -1,12 +0,0 @@
-//#region src/tgsl/consoleLog/types.ts
-const supportedLogOps = [
-	"log",
-	"debug",
-	"info",
-	"warn",
-	"error",
-	"clear"
-];
-
-//#endregion
-export { supportedLogOps };

package/tgsl/math.js

@@ -1,45 +0,0 @@
-import { f32 } from "../data/numeric.js";
-import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, cos, cosh, countLeadingZeros, exp, floor, log, log2, max, min, pow, sign, sin, sinh, sqrt, tan, tanh, trunc } from "../std/numeric.js";
-
-//#region src/tgsl/math.ts
-const mathToStd = {
-	abs,
-	acos,
-	acosh,
-	asin,
-	asinh,
-	atan,
-	atan2,
-	atanh,
-	ceil,
-	cos,
-	cosh,
-	exp,
-	floor,
-	fround: f32,
-	clz32: countLeadingZeros,
-	trunc,
-	log,
-	log2,
-	pow,
-	sign,
-	sin,
-	sinh,
-	sqrt,
-	tan,
-	tanh,
-	max,
-	min,
-	cbrt: void 0,
-	log10: void 0,
-	log1p: void 0,
-	f16round: void 0,
-	hypot: void 0,
-	expm1: void 0,
-	random: void 0,
-	imul: void 0,
-	round: void 0
-};
-
-//#endregion
-export { mathToStd };