typegpu 0.10.2 → 0.11.0

package/data/matrix.d.ts

@@ -1,54 +1,52 @@
 import { DualFn } from "../types.js";
 import { Mat2x2f, Mat3x3f, Mat4x4f, m2x2f, m3x3f, m4x4f, v3f } from "./wgslTypes.js";
 import { TgpuComptime } from "../core/function/comptime.js";
-import "../indexNamedExports.js";
-
 //#region src/data/matrix.d.ts
 /**
  * Returns a 2-by-2 identity matrix.
  * @returns {m2x2f} The result matrix.
  */
-declare const identity2: TgpuComptime<() => m2x2f>;
+declare const identity2: TgpuComptime;
 /**
  * Returns a 3-by-3 identity matrix.
  * @returns {m3x3f} The result matrix.
  */
-declare const identity3: TgpuComptime<() => m3x3f>;
+declare const identity3: TgpuComptime;
 /**
  * Returns a 4-by-4 identity matrix.
  * @returns {m4x4f} The result matrix.
  */
-declare const identity4: TgpuComptime<() => m4x4f>;
+declare const identity4: TgpuComptime;
 /**
  * Creates a 4-by-4 matrix which translates by the given vector v.
  * @param {v3f} vector - The vector by which to translate.
  * @returns {m4x4f} The translation matrix.
  */
-declare const translation4: DualFn<(vector: v3f) => m4x4f>;
+declare const translation4: DualFn;
 /**
  * Creates a 4-by-4 matrix which scales in each dimension by an amount given by the corresponding entry in the given vector.
  * @param {v3f} vector - A vector of three entries specifying the factor by which to scale in each dimension.
  * @returns {m4x4f} The scaling matrix.
  */
-declare const scaling4: DualFn<(vector: v3f) => m4x4f>;
+declare const scaling4: DualFn;
 /**
  * Creates a 4-by-4 matrix which rotates around the x-axis by the given angle.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotation matrix.
  */
-declare const rotationX4: DualFn<(a: number) => m4x4f>;
+declare const rotationX4: DualFn;
 /**
  * Creates a 4-by-4 matrix which rotates around the y-axis by the given angle.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotation matrix.
  */
-declare const rotationY4: DualFn<(a: number) => m4x4f>;
+declare const rotationY4: DualFn;
 /**
  * Creates a 4-by-4 matrix which rotates around the z-axis by the given angle.
  * @param {number} angle - The angle by which to rotate (in radians).
  * @returns {m4x4f} The rotation matrix.
  */
-declare const rotationZ4: DualFn<(a: number) => m4x4f>;
+declare const rotationZ4: DualFn;
 /**
  * Schema representing mat2x2f - a matrix with 2 rows and 2 columns, with elements of type f32.
  * Also a constructor function for this matrix type.

package/data/matrix.js

@@ -1,18 +1,18 @@
 import { $internal, $resolve } from "../shared/symbols.js";
 import { isVec } from "./wgslTypes.js";
-import { snip } from "./snippet.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { callableSchema } from "../core/function/createCallableSchema.js";
 import { f32 } from "./numeric.js";
+import { numericLiteralToSnippet } from "../tgsl/generationHelpers.js";
 import { vec2f, vec3f, vec4f } from "./vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
 import { comptime } from "../core/function/comptime.js";
-
 //#region src/data/matrix.ts
 var MatBase = class {};
 function createMatSchema(options) {
 	const construct = callableSchema({
 		name: options.type,
+		schema: () => schema,
 		normalImpl: (...args) => {
 			const elements = [];
 			for (const arg of args) if (typeof arg === "number") elements.push(arg);
@@ -21,11 +21,8 @@ function createMatSchema(options) {
 			for (let i = elements.length; i < options.columns * options.rows; ++i) elements.push(0);
 			return new options.MatImpl(...elements);
 		},
-		signature: (...args) => ({
-			argTypes: args.map((arg) => isVec(arg) ? arg : f32),
-			returnType: schema
-		}),
-		codegenImpl: (_ctx, args) => stitch`${options.type}(${args})`
+		argTypes: (...args) => args.map((arg) => isVec(arg) ? arg : f32),
+		codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(schema, args)
 	});
 	const schema = Object.assign(construct, {
 		[$internal]: {},
@@ -41,6 +38,12 @@ function createMatSchema(options) {
 	options.MatImpl.prototype.schema = schema;
 	return schema;
 }
+const VALID_MAT2x2_ELEMENTS = [
+	0,
+	1,
+	2,
+	3
+];
 var mat2x2Impl = class extends MatBase {
 	[$internal] = true;
 	columns;
@@ -79,11 +82,11 @@ var mat2x2Impl = class extends MatBase {
 		yield this[2];
 		yield this[3];
 	}
-	[$resolve]() {
-		return snip(`${this.kind}(${Array.from({ length: this.length }).map((_, i) => this[i]).join(", ")})`, mat2x2f, "runtime");
+	[$resolve](ctx) {
+		return ctx.gen.typeInstantiation(mat2x2f, VALID_MAT2x2_ELEMENTS.map((i) => numericLiteralToSnippet(this[i])));
 	}
 	toString() {
-		return this[$resolve]().value;
+		return `${this.kind}(${VALID_MAT2x2_ELEMENTS.map((i) => this[i]).join(", ")})`;
 	}
 };
 var mat2x2fImpl = class extends mat2x2Impl {
@@ -92,6 +95,17 @@ var mat2x2fImpl = class extends mat2x2Impl {
 		return vec2f(e0, e1);
 	}
 };
+const VALID_MAT3x3_ELEMENTS = [
+	0,
+	1,
+	2,
+	4,
+	5,
+	6,
+	8,
+	9,
+	10
+];
 var mat3x3Impl = class extends MatBase {
 	[$internal] = true;
 	columns;
@@ -173,11 +187,11 @@ var mat3x3Impl = class extends MatBase {
 	*[Symbol.iterator]() {
 		for (let i = 0; i < 12; i++) yield this[i];
 	}
-	[$resolve]() {
-		return snip(`${this.kind}(${this[0]}, ${this[1]}, ${this[2]}, ${this[4]}, ${this[5]}, ${this[6]}, ${this[8]}, ${this[9]}, ${this[10]})`, mat3x3f, "runtime");
+	[$resolve](ctx) {
+		return ctx.gen.typeInstantiation(mat3x3f, VALID_MAT3x3_ELEMENTS.map((i) => numericLiteralToSnippet(this[i])));
 	}
 	toString() {
-		return this[$resolve]().value;
+		return `${this.kind}(${VALID_MAT3x3_ELEMENTS.map((i) => this[i]).join(", ")})`;
 	}
 };
 var mat3x3fImpl = class extends mat3x3Impl {
@@ -186,6 +200,7 @@ var mat3x3fImpl = class extends mat3x3Impl {
 		return vec3f(x, y, z);
 	}
 };
+const VALID_MAT4x4_ELEMENTS = Array.from({ length: 16 }, (_, i) => i);
 var mat4x4Impl = class extends MatBase {
 	[$internal] = true;
 	columns;
@@ -298,11 +313,11 @@ var mat4x4Impl = class extends MatBase {
 	*[Symbol.iterator]() {
 		for (let i = 0; i < 16; i++) yield this[i];
 	}
-	[$resolve]() {
-		return snip(`${this.kind}(${Array.from({ length: this.length }).map((_, i) => this[i]).join(", ")})`, mat4x4f, "runtime");
+	[$resolve](ctx) {
+		return ctx.gen.typeInstantiation(mat4x4f, VALID_MAT4x4_ELEMENTS.map((i) => numericLiteralToSnippet(this[i])));
 	}
 	toString() {
-		return this[$resolve]().value;
+		return `${this.kind}(${VALID_MAT4x4_ELEMENTS.map((i) => this[i]).join(", ")})`;
 	}
 };
 var mat4x4fImpl = class extends mat4x4Impl {
@@ -512,6 +527,5 @@ function matToArray(mat) {
 	];
 	return Array.from({ length: mat.length }).map((_, idx) => mat[idx]);
 }
-
 //#endregion
-export { MatBase, identity2, identity3, identity4, mat2x2f, mat3x3f, mat4x4f, matToArray, rotationX4, rotationY4, rotationZ4, scaling4, translation4 };
+export { MatBase, identity2, identity3, identity4, mat2x2f, mat3x3f, mat4x4f, matToArray, rotationX4, rotationY4, rotationZ4, scaling4, translation4 };

package/data/numberOps.js

@@ -19,6 +19,5 @@ function bitcastU32toI32Impl(n) {
 	dataView.setUint32(0, n, true);
 	return dataView.getInt32(0, true);
 }
-
 //#endregion
-export { bitcastU32toF32Impl, bitcastU32toI32Impl, clamp, divInteger, smoothstepScalar };
+export { bitcastU32toF32Impl, bitcastU32toI32Impl, clamp, divInteger, smoothstepScalar };

package/data/numeric.js

@@ -1,7 +1,5 @@
 import { $internal } from "../shared/symbols.js";
-import { stitch } from "../core/resolve/stitch.js";
 import { callableSchema } from "../core/function/createCallableSchema.js";
-
 //#region src/data/numeric.ts
 const abstractInt = {
 	[$internal]: {},
@@ -19,16 +17,14 @@ const abstractFloat = {
 };
 const boolCast = callableSchema({
 	name: "bool",
-	signature: (arg) => ({
-		argTypes: arg ? [arg] : [],
-		returnType: bool
-	}),
+	schema: () => bool,
+	argTypes: (arg) => arg ? [arg] : [],
 	normalImpl(v) {
 		if (v === void 0) return false;
 		if (typeof v === "boolean") return v;
 		return !!v;
 	},
-	codegenImpl: (_ctx, [arg]) => arg?.dataType === bool ? stitch`${arg}` : stitch`bool(${arg})`
+	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(bool, args)
 });
 /**
 * A schema that represents a boolean value. (equivalent to `bool` in WGSL)
@@ -50,10 +46,8 @@ const bool = Object.assign(boolCast, {
 });
 const u32Cast = callableSchema({
 	name: "u32",
-	signature: (arg) => ({
-		argTypes: arg ? [arg] : [],
-		returnType: u32
-	}),
+	schema: () => u32,
+	argTypes: (arg) => arg ? [arg] : [],
 	normalImpl(v) {
 		if (v === void 0) return 0;
 		if (typeof v === "boolean") return v ? 1 : 0;
@@ -65,7 +59,7 @@ const u32Cast = callableSchema({
 		}
 		return (v & 4294967295) >>> 0;
 	},
-	codegenImpl: (_ctx, [arg]) => arg?.dataType === u32 ? stitch`${arg}` : stitch`u32(${arg})`
+	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(u32, args)
 });
 /**
 * A schema that represents an unsigned 32-bit integer value. (equivalent to `u32` in WGSL)
@@ -89,16 +83,14 @@ const u32 = Object.assign(u32Cast, {
 });
 const i32Cast = callableSchema({
 	name: "i32",
-	signature: (arg) => ({
-		argTypes: arg ? [arg] : [],
-		returnType: i32
-	}),
+	schema: () => i32,
+	argTypes: (arg) => arg ? [arg] : [],
 	normalImpl(v) {
 		if (v === void 0) return 0;
 		if (typeof v === "boolean") return v ? 1 : 0;
 		return v | 0;
 	},
-	codegenImpl: (_ctx, [arg]) => arg?.dataType === i32 ? stitch`${arg}` : stitch`i32(${arg})`
+	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(i32, args)
 });
 const u16 = {
 	[$internal]: {},
@@ -124,16 +116,14 @@ const i32 = Object.assign(i32Cast, {
 });
 const f32Cast = callableSchema({
 	name: "f32",
-	signature: (arg) => ({
-		argTypes: arg ? [arg] : [],
-		returnType: f32
-	}),
+	schema: () => f32,
+	argTypes: (arg) => arg ? [arg] : [],
 	normalImpl(v) {
 		if (v === void 0) return 0;
 		if (typeof v === "boolean") return v ? 1 : 0;
 		return Math.fround(v);
 	},
-	codegenImpl: (_ctx, [arg]) => arg?.dataType === f32 ? stitch`${arg}` : stitch`f32(${arg})`
+	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(f32, args)
 });
 /**
 * A schema that represents a 32-bit float value. (equivalent to `f32` in WGSL)
@@ -200,16 +190,14 @@ function roundToF16(x) {
 }
 const f16Cast = callableSchema({
 	name: "f16",
-	signature: (arg) => ({
-		argTypes: arg ? [arg] : [],
-		returnType: f16
-	}),
+	schema: () => f16,
+	argTypes: (arg) => arg ? [arg] : [],
 	normalImpl(v) {
 		if (v === void 0) return 0;
 		if (typeof v === "boolean") return v ? 1 : 0;
 		return roundToF16(v);
 	},
-	codegenImpl: (_ctx, [arg]) => arg?.dataType === f16 ? stitch`${arg}` : stitch`f16(${arg})`
+	codegenImpl: (ctx, args) => ctx.gen.typeInstantiation(f16, args)
 });
 /**
 * A schema that represents a 16-bit float value. (equivalent to `f16` in WGSL)
@@ -229,6 +217,5 @@ const f16 = Object.assign(f16Cast, {
 	[$internal]: {},
 	type: "f16"
 });
-
 //#endregion
-export { abstractFloat, abstractInt, bool, f16, f32, i32, u16, u32 };
+export { abstractFloat, abstractInt, bool, f16, f32, i32, u16, u32 };

package/data/offsetUtils.d.ts

@@ -25,9 +25,9 @@ interface PrimitiveOffsetInfo {
  * ```
  *
  * @param schema - The data schema to analyze.
- * @param accessor - Optional function that accesses a specific primitive within the schema. If omitted, uses the root offset (0).
+ * @param accessor - Optional function that accesses a specific element within the schema. If omitted, uses the root offset (0).
  * @returns An object containing the offset and contiguous byte information.
  */
-declare function memoryLayoutOf<T extends BaseData>(schema: T, accessor?: (proxy: Infer<T>) => number): PrimitiveOffsetInfo;
+declare function memoryLayoutOf<T extends BaseData>(schema: T, accessor?: (proxy: Infer<T>) => unknown): PrimitiveOffsetInfo;
 //#endregion
 export { PrimitiveOffsetInfo, memoryLayoutOf };

package/data/offsetUtils.js

@@ -6,7 +6,6 @@ import { sizeOf } from "./sizeOf.js";
 import { offsetsForProps } from "./offsets.js";
 import { isContiguous } from "./isContiguous.js";
 import { getLongestContiguousPrefix } from "./getLongestContiguousPrefix.js";
-
 //#region src/data/offsetUtils.ts
 const OFFSET_MARKER = Symbol("indirectOffset");
 const CONTIGUOUS_MARKER = Symbol("indirectContiguous");
@@ -147,7 +146,7 @@ function getRootContiguous(schema) {
 * ```
 *
 * @param schema - The data schema to analyze.
-* @param accessor - Optional function that accesses a specific primitive within the schema. If omitted, uses the root offset (0).
+* @param accessor - Optional function that accesses a specific element within the schema. If omitted, uses the root offset (0).
 * @returns An object containing the offset and contiguous byte information.
 */
 function memoryLayoutOf(schema, accessor) {
@@ -160,8 +159,7 @@ function memoryLayoutOf(schema, accessor) {
 		offset: result[OFFSET_MARKER],
 		contiguous: result[CONTIGUOUS_MARKER]
 	};
-	throw new Error("Invalid accessor result. Expected an offset proxy with markers.");
+	throw new Error("memoryLayoutOf: accessor did not return a schema element. Make sure the accessor navigates to a field or element of the schema (e.g. `(s) => s.position.x`).");
 }
-
 //#endregion
-export { memoryLayoutOf };
+export { memoryLayoutOf };

package/data/offsets.js

@@ -4,7 +4,6 @@ import { roundUp } from "../mathUtils.js";
 import { sizeOf } from "./sizeOf.js";
 import alignIO from "./alignIO.js";
 import { Measurer } from "typed-binary";
-
 //#region src/data/offsets.ts
 const cachedOffsets = /* @__PURE__ */ new WeakMap();
 function offsetsForProps(struct) {
@@ -31,6 +30,5 @@ function offsetsForProps(struct) {
 	cachedOffsets.set(struct, offsets);
 	return offsets;
 }
-
 //#endregion
-export { offsetsForProps };
+export { offsetsForProps };

package/data/partialIO.js

@@ -4,65 +4,110 @@ import { alignmentOf } from "./alignmentOf.js";
 import { roundUp } from "../mathUtils.js";
 import { sizeOf } from "./sizeOf.js";
 import { offsetsForProps } from "./offsets.js";
+import { getCompiledWriter } from "./compiledIO.js";
 import { writeData } from "./dataIO.js";
-import { BufferWriter } from "typed-binary";
-
+import { BufferWriter, getSystemEndianness } from "typed-binary";
 //#region src/data/partialIO.ts
-function getWriteInstructions(schema, data) {
+/**
+* Converts `{idx, value}[]` sparse arrays into `Record<number, T>` format.
+*/
+function convertPartialToPatch(schema, data) {
+	if (data === void 0 || data === null) return data;
+	if (isWgslStruct(schema) || isUnstruct(schema)) {
+		const result = {};
+		const record = data;
+		for (const key of Object.keys(schema.propTypes)) {
+			const subSchema = schema.propTypes[key];
+			const value = record[key];
+			if (value !== void 0 && subSchema) result[key] = convertPartialToPatch(subSchema, value);
+		}
+		return result;
+	}
+	if (isWgslArray(schema) || isDisarray(schema)) {
+		const arrSchema = schema;
+		const result = {};
+		for (const { idx, value } of data) result[idx] = convertPartialToPatch(arrSchema.elementType, value);
+		return result;
+	}
+	return data;
+}
+const isLittleEndian = getSystemEndianness() === "little";
+function getPatchInstructions(schema, data, targetBuffer) {
 	const totalSize = sizeOf(schema);
 	if (totalSize === 0 || data === void 0 || data === null) return [];
-	const bigBuffer = new ArrayBuffer(totalSize);
-	const writer = new BufferWriter(bigBuffer);
+	const buf = targetBuffer ?? new ArrayBuffer(totalSize);
+	const writer = new BufferWriter(buf);
+	const compiledView = new DataView(buf);
 	const segments = [];
-	function gatherAndWrite(node, partialValue, offset, padding) {
-		if (partialValue === void 0 || partialValue === null) return;
+	function collect(node, value, offset, padding) {
+		if (value === void 0 || value === null) return;
 		if (isWgslStruct(node) || isUnstruct(node)) {
 			const propOffsets = offsetsForProps(node);
 			for (const [key, propOffset] of Object.entries(propOffsets)) {
+				const childValue = value[key];
 				const subSchema = node.propTypes[key];
-				if (!subSchema) continue;
-				const childValue = partialValue[key];
-				if (childValue !== void 0) gatherAndWrite(subSchema, childValue, offset + propOffset.offset, propOffset.padding ?? padding);
+				if (childValue !== void 0 && subSchema) collect(subSchema, childValue, offset + propOffset.offset, propOffset.padding ?? padding);
 			}
 			return;
 		}
 		if (isWgslArray(node) || isDisarray(node)) {
 			const arrSchema = node;
 			const elementSize = roundUp(sizeOf(arrSchema.elementType), alignmentOf(arrSchema.elementType));
-			if (!Array.isArray(partialValue)) throw new Error("Partial value for array must be an array");
-			const arrayPartialValue = partialValue ?? [];
-			arrayPartialValue.sort((a, b) => a.idx - b.idx);
-			for (const { idx, value } of arrayPartialValue) gatherAndWrite(arrSchema.elementType, value, offset + idx * elementSize, elementSize - sizeOf(arrSchema.elementType));
-		} else {
-			const leafSize = sizeOf(node);
+			const elementPadding = elementSize - sizeOf(arrSchema.elementType);
+			if (ArrayBuffer.isView(value)) {
+				const copyLen = Math.min(value.byteLength, arrSchema.elementCount * elementSize);
+				new Uint8Array(buf, offset, copyLen).set(new Uint8Array(value.buffer, value.byteOffset, copyLen));
+				segments.push({
+					start: offset,
+					end: offset + copyLen,
+					padding
+				});
+				return;
+			}
+			if (Array.isArray(value)) {
+				for (let i = 0; i < Math.min(arrSchema.elementCount, value.length); i++) collect(arrSchema.elementType, value[i], offset + i * elementSize, elementPadding);
+				return;
+			}
+			const sparse = value;
+			for (const key of Object.keys(sparse)) {
+				const idx = Number(key);
+				if (!Number.isNaN(idx)) collect(arrSchema.elementType, sparse[key], offset + idx * elementSize, elementPadding);
+			}
+			return;
+		}
+		const leafSize = sizeOf(node);
+		const compiledWriter = getCompiledWriter(node);
+		if (compiledWriter) compiledWriter(compiledView, offset, value, isLittleEndian, offset + leafSize);
+		else {
 			writer.seekTo(offset);
-			writeData(writer, node, partialValue);
-			segments.push({
-				start: offset,
-				end: offset + leafSize,
-				padding
-			});
+			writeData(writer, node, value);
 		}
+		segments.push({
+			start: offset,
+			end: offset + leafSize,
+			padding
+		});
 	}
-	gatherAndWrite(schema, data, 0);
-	if (segments.length === 0) return [];
+	collect(schema, data, 0);
 	const instructions = [];
-	let current = segments[0];
-	for (let i = 1; i < segments.length; i++) {
-		const next = segments[i];
-		if (!next || !current) throw new Error("Internal error: missing segment");
-		if (next.start === current.end + (current.padding ?? 0)) {
-			current.end = next.end;
-			current.padding = next.padding;
-		} else {
-			instructions.push({ data: new Uint8Array(bigBuffer, current.start, current.end - current.start) });
-			current = next;
-		}
+	let run = null;
+	for (const seg of segments) if (run && seg.start === run.end + (run.padding ?? 0)) run = {
+		start: run.start,
+		end: seg.end,
+		padding: seg.padding
+	};
+	else {
+		if (run) instructions.push({
+			gpuOffset: run.start,
+			data: new Uint8Array(buf, run.start, run.end - run.start).slice()
+		});
+		run = seg;
 	}
-	if (!current) throw new Error("Internal error: missing segment");
-	instructions.push({ data: new Uint8Array(bigBuffer, current.start, current.end - current.start) });
+	if (run) instructions.push({
+		gpuOffset: run.start,
+		data: new Uint8Array(buf, run.start, run.end - run.start).slice()
+	});
 	return instructions;
 }
-
 //#endregion
-export { getWriteInstructions };
+export { convertPartialToPatch, getPatchInstructions };

package/data/ptr.d.ts

@@ -1,4 +1,3 @@
-import "./snippet.js";
 import { Ptr, StorableData } from "./wgslTypes.js";
 
 //#region src/data/ptr.d.ts

package/data/ptr.js

@@ -1,6 +1,5 @@
 import { $internal } from "../shared/symbols.js";
 import { originToPtrParams } from "./snippet.js";
-
 //#region src/data/ptr.ts
 function ptrFn(inner) {
 	return INTERNAL_createPtr("function", inner, "read-write");
@@ -41,6 +40,5 @@ function implicitFrom(ptr) {
 function explicitFrom(ptr) {
 	return INTERNAL_createPtr(ptr.addressSpace, ptr.inner, ptr.access, false);
 }
-
 //#endregion
-export { createPtrFromOrigin, explicitFrom, implicitFrom, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup };
+export { createPtrFromOrigin, explicitFrom, implicitFrom, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup };

package/data/ref.d.ts

@@ -1,8 +1,5 @@
 import { $internal } from "../shared/symbols.js";
-import "./snippet.js";
 import { DualFn } from "../types.js";
-import "./wgslTypes.js";
-
 //#region src/data/ref.d.ts
 interface ref<T> {
   readonly [$internal]: {

package/data/ref.js

@@ -6,7 +6,6 @@ import { snip } from "./snippet.js";
 import { WgslTypeError } from "../errors.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { createPtrFromOrigin, explicitFrom } from "./ptr.js";
-
 //#region src/data/ref.ts
 const _ref = (() => {
 	const impl = ((value) => INTERNAL_createRef(value));
@@ -91,6 +90,5 @@ function derefSnippet(snippet) {
 	if (snippet.value instanceof RefOperator) return snip(stitch`${snippet.value.snippet}`, innerType, origin);
 	return snip(stitch`(*${snippet})`, innerType, origin);
 }
-
 //#endregion
-export { RefOperator, _ref, derefSnippet, isRef };
+export { RefOperator, _ref, derefSnippet, isRef };

package/data/sampler.js

@@ -1,5 +1,4 @@
 import { $internal, $repr } from "../shared/symbols.js";
-
 //#region src/data/sampler.ts
 function sampler() {
 	return {
@@ -21,6 +20,5 @@ function isWgslSampler(value) {
 function isWgslComparisonSampler(value) {
 	return !!value[$internal] && value.type === "sampler_comparison";
 }
-
 //#endregion
-export { comparisonSampler, isWgslComparisonSampler, isWgslSampler, sampler };
+export { comparisonSampler, isWgslComparisonSampler, isWgslSampler, sampler };

package/data/schemaCallWrapper.js

@@ -1,6 +1,5 @@
 import { $cast, $gpuCallable } from "../shared/symbols.js";
 import { hasCast, isGPUCallable } from "../types.js";
-
 //#region src/data/schemaCallWrapper.ts
 /**
 * A wrapper for `schema(item)` or `schema()` call on JS side.
@@ -27,6 +26,5 @@ function schemaCallWrapperGPU(ctx, schema, item) {
 	const callSchema = schema;
 	return item === void 0 || item.value === void 0 ? callSchema[$gpuCallable].call(ctx, []) : callSchema[$gpuCallable].call(ctx, [item]);
 }
-
 //#endregion
-export { schemaCallWrapper, schemaCallWrapperGPU };
+export { schemaCallWrapper, schemaCallWrapperGPU };

package/data/schemaMemoryLayout.js

@@ -2,7 +2,6 @@ import { isDecorated, isWgslArray, isWgslStruct } from "./wgslTypes.js";
 import { getCustomSize, isDisarray, isLooseDecorated, isUnstruct, undecorate } from "./dataTypes.js";
 import { alignmentOf, customAlignmentOf } from "./alignmentOf.js";
 import { roundUp } from "../mathUtils.js";
-
 //#region src/data/schemaMemoryLayout.ts
 const knownSizesMap = {
 	bool: 4,
@@ -195,6 +194,5 @@ function getLayoutInfo(schema, key) {
 	}
 	return layout[key];
 }
-
 //#endregion
-export { getLayoutInfo };
+export { getLayoutInfo };

package/data/sizeOf.d.ts

@@ -1,4 +1,3 @@
-import "./wgslTypes.js";
 import { AnyData } from "./dataTypes.js";
 
 //#region src/data/sizeOf.d.ts

package/data/sizeOf.js

@@ -1,5 +1,4 @@
 import { getLayoutInfo } from "./schemaMemoryLayout.js";
-
 //#region src/data/sizeOf.ts
 function sizeOf(schema) {
 	return getLayoutInfo(schema, "size");
@@ -10,6 +9,5 @@ function sizeOf(schema) {
 function PUBLIC_sizeOf(schema) {
 	return sizeOf(schema);
 }
-
 //#endregion
-export { PUBLIC_sizeOf, sizeOf };
+export { PUBLIC_sizeOf, sizeOf };