typegpu 0.11.9 → 0.12.1

package/bin.mjs

@@ -21,8 +21,11 @@ if (major === undefined || minor === undefined) {
  */
 const semver = `^${major}.${minor}.0`;
 
+/**
+ * @returns {Promise<number | undefined>}
+ */
 function asyncSpawn(...args) {
-  return new Promise((resolve, _reject) => {
+  return new Promise((resolve, reject) => {
     const child = spawn(...args);
 
     child.on('exit', (code, signal) => {
@@ -34,22 +37,41 @@ function asyncSpawn(...args) {
 
       resolve(code);
     });
+
+    child.on('error', (err) => {
+      reject(err);
+    });
   });
 }
 
+/**
+ * @param {string} label
+ */
+function failedToRunErrHandler(label) {
+  return (err) => {
+    console.error(`Failed to run '${label}':`, err);
+    process.exit(1);
+  };
+}
+
 (async () => {
-  const code = await asyncSpawn('npx', [`@typegpu/cli@${semver}`, ...process.argv.slice(2)], {
-    stdio: ['inherit', 'inherit', 'ignore'],
-  });
+  const windows = process.platform === 'win32';
+  const npxCommand = windows ? 'npx.cmd' : 'npx';
+
+  const code = await asyncSpawn(npxCommand, [`@typegpu/cli@${semver}`, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    shell: windows, // needs to be ran through the shell on Windows
+  }).catch(failedToRunErrHandler(`npx @typegpu/cli@${semver}`));
 
   if (code !== 0) {
     console.warn(
       `Couldn't find @typegpu/cli version matching ${semver}, falling back to latest...`,
     );
     // Fallback to latest
-    const code = await asyncSpawn('npx', [`@typegpu/cli@latest`, ...process.argv.slice(2)], {
+    const code = await asyncSpawn(npxCommand, [`@typegpu/cli@latest`, ...process.argv.slice(2)], {
       stdio: 'inherit',
-    });
+      shell: windows, // needs to be ran through the shell on Windows
+    }).catch(failedToRunErrHandler('npx @typegpu/cli@latest'));
     process.exit(code ?? 0);
   }
 

package/builtin.d.ts

@@ -1,54 +1,52 @@
-import { BaseData, Bool, Builtin, Decorated, F32, U32, Vec3u, Vec4f, WgslArray } from "./data/wgslTypes.js";
-
-//#region src/builtin.d.ts
-type BuiltinVertexIndex = Decorated<U32, [Builtin<'vertex_index'>]>;
-type BuiltinInstanceIndex = Decorated<U32, [Builtin<'instance_index'>]>;
-type BuiltinClipDistances = Decorated<WgslArray<U32>, [Builtin<'clip_distances'>]>;
-type BuiltinPosition = Decorated<Vec4f, [Builtin<'position'>]>;
-type BuiltinFrontFacing = Decorated<Bool, [Builtin<'front_facing'>]>;
-type BuiltinFragDepth = Decorated<F32, [Builtin<'frag_depth'>]>;
-type BuiltinPrimitiveIndex = Decorated<U32, [Builtin<'primitive_index'>]>;
-type BuiltinSampleIndex = Decorated<U32, [Builtin<'sample_index'>]>;
-type BuiltinSampleMask = Decorated<U32, [Builtin<'sample_mask'>]>;
-type BuiltinLocalInvocationId = Decorated<Vec3u, [Builtin<'local_invocation_id'>]>;
-type BuiltinLocalInvocationIndex = Decorated<U32, [Builtin<'local_invocation_index'>]>;
-type BuiltinGlobalInvocationId = Decorated<Vec3u, [Builtin<'global_invocation_id'>]>;
-type BuiltinGlobalInvocationIndex = Decorated<U32, [Builtin<'global_invocation_index'>]>;
-type BuiltinWorkgroupId = Decorated<Vec3u, [Builtin<'workgroup_id'>]>;
-type BuiltinWorkgroupIndex = Decorated<U32, [Builtin<'workgroup_index'>]>;
-type BuiltinNumWorkgroups = Decorated<Vec3u, [Builtin<'num_workgroups'>]>;
-type BuiltinSubgroupInvocationId = Decorated<U32, [Builtin<'subgroup_invocation_id'>]>;
-type BuiltinSubgroupSize = Decorated<U32, [Builtin<'subgroup_size'>]>;
-type BuiltinSubgroupId = Decorated<U32, [Builtin<'subgroup_id'>]>;
-type BuiltinNumSubgroups = Decorated<U32, [Builtin<'num_subgroups'>]>;
-declare const builtin: {
-  readonly vertexIndex: BuiltinVertexIndex;
-  readonly instanceIndex: BuiltinInstanceIndex;
-  readonly clipDistances: BuiltinClipDistances;
-  readonly position: BuiltinPosition;
-  readonly frontFacing: BuiltinFrontFacing;
-  readonly fragDepth: BuiltinFragDepth;
-  readonly primitiveIndex: BuiltinPrimitiveIndex;
-  readonly sampleIndex: BuiltinSampleIndex;
-  readonly sampleMask: BuiltinSampleMask;
-  readonly localInvocationId: BuiltinLocalInvocationId;
-  readonly localInvocationIndex: BuiltinLocalInvocationIndex;
-  readonly globalInvocationId: BuiltinGlobalInvocationId;
-  readonly globalInvocationIndex: BuiltinGlobalInvocationIndex;
-  readonly workgroupId: BuiltinWorkgroupId;
-  readonly workgroupIndex: BuiltinWorkgroupIndex;
-  readonly numWorkgroups: BuiltinNumWorkgroups;
-  readonly subgroupInvocationId: BuiltinSubgroupInvocationId;
-  readonly subgroupSize: BuiltinSubgroupSize;
-  readonly subgroupId: BuiltinSubgroupId;
-  readonly numSubgroups: BuiltinNumSubgroups;
+import type { BaseData, Bool, Builtin, Decorated, F32, U32, Vec3u, Vec4f, WgslArray } from './data/wgslTypes.ts';
+export type BuiltinVertexIndex = Decorated<U32, [Builtin<'vertex_index'>]>;
+export type BuiltinInstanceIndex = Decorated<U32, [Builtin<'instance_index'>]>;
+export type BuiltinClipDistances = Decorated<WgslArray<U32>, [Builtin<'clip_distances'>]>;
+export type BuiltinPosition = Decorated<Vec4f, [Builtin<'position'>]>;
+export type BuiltinFrontFacing = Decorated<Bool, [Builtin<'front_facing'>]>;
+export type BuiltinFragDepth = Decorated<F32, [Builtin<'frag_depth'>]>;
+export type BuiltinPrimitiveIndex = Decorated<U32, [Builtin<'primitive_index'>]>;
+export type BuiltinSampleIndex = Decorated<U32, [Builtin<'sample_index'>]>;
+export type BuiltinSampleMask = Decorated<U32, [Builtin<'sample_mask'>]>;
+export type BuiltinLocalInvocationId = Decorated<Vec3u, [Builtin<'local_invocation_id'>]>;
+export type BuiltinLocalInvocationIndex = Decorated<U32, [Builtin<'local_invocation_index'>]>;
+export type BuiltinGlobalInvocationId = Decorated<Vec3u, [Builtin<'global_invocation_id'>]>;
+export type BuiltinGlobalInvocationIndex = Decorated<U32, [Builtin<'global_invocation_index'>]>;
+export type BuiltinWorkgroupId = Decorated<Vec3u, [Builtin<'workgroup_id'>]>;
+export type BuiltinWorkgroupIndex = Decorated<U32, [Builtin<'workgroup_index'>]>;
+export type BuiltinNumWorkgroups = Decorated<Vec3u, [Builtin<'num_workgroups'>]>;
+export type BuiltinSubgroupInvocationId = Decorated<U32, [Builtin<'subgroup_invocation_id'>]>;
+export type BuiltinSubgroupSize = Decorated<U32, [Builtin<'subgroup_size'>]>;
+export type BuiltinSubgroupId = Decorated<U32, [Builtin<'subgroup_id'>]>;
+export type BuiltinNumSubgroups = Decorated<U32, [Builtin<'num_subgroups'>]>;
+export declare const builtin: {
+    readonly vertexIndex: BuiltinVertexIndex;
+    readonly instanceIndex: BuiltinInstanceIndex;
+    readonly clipDistances: BuiltinClipDistances;
+    readonly position: BuiltinPosition;
+    readonly frontFacing: BuiltinFrontFacing;
+    readonly fragDepth: BuiltinFragDepth;
+    readonly primitiveIndex: BuiltinPrimitiveIndex;
+    readonly sampleIndex: BuiltinSampleIndex;
+    readonly sampleMask: BuiltinSampleMask;
+    readonly localInvocationId: BuiltinLocalInvocationId;
+    readonly localInvocationIndex: BuiltinLocalInvocationIndex;
+    readonly globalInvocationId: BuiltinGlobalInvocationId;
+    readonly globalInvocationIndex: BuiltinGlobalInvocationIndex;
+    readonly workgroupId: BuiltinWorkgroupId;
+    readonly workgroupIndex: BuiltinWorkgroupIndex;
+    readonly numWorkgroups: BuiltinNumWorkgroups;
+    readonly subgroupInvocationId: BuiltinSubgroupInvocationId;
+    readonly subgroupSize: BuiltinSubgroupSize;
+    readonly subgroupId: BuiltinSubgroupId;
+    readonly numSubgroups: BuiltinNumSubgroups;
+};
+export type AnyBuiltin = (typeof builtin)[keyof typeof builtin];
+export type AnyComputeBuiltin = BuiltinLocalInvocationId | BuiltinLocalInvocationIndex | BuiltinGlobalInvocationId | BuiltinGlobalInvocationIndex | BuiltinWorkgroupId | BuiltinWorkgroupIndex | BuiltinNumWorkgroups | BuiltinSubgroupInvocationId | BuiltinSubgroupSize | BuiltinSubgroupId | BuiltinNumSubgroups;
+export type AnyVertexInputBuiltin = BuiltinVertexIndex | BuiltinInstanceIndex;
+export type AnyVertexOutputBuiltin = BuiltinClipDistances | BuiltinPosition;
+export type AnyFragmentInputBuiltin = BuiltinPosition | BuiltinFrontFacing | BuiltinPrimitiveIndex | BuiltinSampleIndex | BuiltinSampleMask | BuiltinSubgroupInvocationId | BuiltinSubgroupSize;
+export type AnyFragmentOutputBuiltin = BuiltinFragDepth | BuiltinSampleMask;
+export type OmitBuiltins<S> = S extends AnyBuiltin ? never : S extends BaseData ? S : {
+    [Key in keyof S as S[Key] extends AnyBuiltin ? never : Key extends `$${string}` ? never : Key]: S[Key];
 };
-type AnyBuiltin = (typeof builtin)[keyof typeof builtin];
-type AnyComputeBuiltin = BuiltinLocalInvocationId | BuiltinLocalInvocationIndex | BuiltinGlobalInvocationId | BuiltinGlobalInvocationIndex | BuiltinWorkgroupId | BuiltinWorkgroupIndex | BuiltinNumWorkgroups | BuiltinSubgroupInvocationId | BuiltinSubgroupSize | BuiltinSubgroupId | BuiltinNumSubgroups;
-type AnyVertexInputBuiltin = BuiltinVertexIndex | BuiltinInstanceIndex;
-type AnyVertexOutputBuiltin = BuiltinClipDistances | BuiltinPosition;
-type AnyFragmentInputBuiltin = BuiltinPosition | BuiltinFrontFacing | BuiltinPrimitiveIndex | BuiltinSampleIndex | BuiltinSampleMask | BuiltinSubgroupInvocationId | BuiltinSubgroupSize;
-type AnyFragmentOutputBuiltin = BuiltinFragDepth | BuiltinSampleMask;
-type OmitBuiltins<S> = S extends AnyBuiltin ? never : S extends BaseData ? S : { [Key in keyof S as S[Key] extends AnyBuiltin ? never : Key extends `$${string}` ? never : Key]: S[Key] };
-//#endregion
-export { AnyBuiltin, AnyComputeBuiltin, AnyFragmentInputBuiltin, AnyFragmentOutputBuiltin, AnyVertexInputBuiltin, AnyVertexOutputBuiltin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumWorkgroups, BuiltinPosition, BuiltinPrimitiveIndex, BuiltinSampleIndex, BuiltinSampleMask, BuiltinSubgroupInvocationId, BuiltinSubgroupSize, BuiltinVertexIndex, BuiltinWorkgroupId, OmitBuiltins, builtin };

package/builtin.js

@@ -1,39 +1,35 @@
-import { $internal } from "./shared/symbols.js";
+import { arrayOf } from "./data/array.js";
+import { attribute } from "./data/attributes.js";
 import { bool, f32, u32 } from "./data/numeric.js";
 import { vec3u, vec4f } from "./data/vector.js";
-import { attribute } from "./data/attributes.js";
-import { arrayOf } from "./data/array.js";
-
-//#region src/builtin.ts
+import { $internal } from "./shared/symbols.js";
 function defineBuiltin(dataType, value) {
-	return attribute(dataType, {
-		[$internal]: true,
-		type: "@builtin",
-		params: [value]
-	});
+    return attribute(dataType, {
+        [$internal]: true,
+        type: '@builtin',
+        // oxlint-disable-next-line typescript/no-explicit-any -- it's fine
+        params: [value],
+    });
 }
-const builtin = {
-	vertexIndex: defineBuiltin(u32, "vertex_index"),
-	instanceIndex: defineBuiltin(u32, "instance_index"),
-	clipDistances: defineBuiltin(arrayOf(u32, 8), "clip_distances"),
-	position: defineBuiltin(vec4f, "position"),
-	frontFacing: defineBuiltin(bool, "front_facing"),
-	fragDepth: defineBuiltin(f32, "frag_depth"),
-	primitiveIndex: defineBuiltin(u32, "primitive_index"),
-	sampleIndex: defineBuiltin(u32, "sample_index"),
-	sampleMask: defineBuiltin(u32, "sample_mask"),
-	localInvocationId: defineBuiltin(vec3u, "local_invocation_id"),
-	localInvocationIndex: defineBuiltin(u32, "local_invocation_index"),
-	globalInvocationId: defineBuiltin(vec3u, "global_invocation_id"),
-	globalInvocationIndex: defineBuiltin(u32, "global_invocation_index"),
-	workgroupId: defineBuiltin(vec3u, "workgroup_id"),
-	workgroupIndex: defineBuiltin(u32, "workgroup_index"),
-	numWorkgroups: defineBuiltin(vec3u, "num_workgroups"),
-	subgroupInvocationId: defineBuiltin(u32, "subgroup_invocation_id"),
-	subgroupSize: defineBuiltin(u32, "subgroup_size"),
-	subgroupId: defineBuiltin(u32, "subgroup_id"),
-	numSubgroups: defineBuiltin(u32, "num_subgroups")
+export const builtin = {
+    vertexIndex: defineBuiltin(u32, 'vertex_index'),
+    instanceIndex: defineBuiltin(u32, 'instance_index'),
+    clipDistances: defineBuiltin(arrayOf(u32, 8), 'clip_distances'),
+    position: defineBuiltin(vec4f, 'position'),
+    frontFacing: defineBuiltin(bool, 'front_facing'),
+    fragDepth: defineBuiltin(f32, 'frag_depth'),
+    primitiveIndex: defineBuiltin(u32, 'primitive_index'),
+    sampleIndex: defineBuiltin(u32, 'sample_index'),
+    sampleMask: defineBuiltin(u32, 'sample_mask'),
+    localInvocationId: defineBuiltin(vec3u, 'local_invocation_id'),
+    localInvocationIndex: defineBuiltin(u32, 'local_invocation_index'),
+    globalInvocationId: defineBuiltin(vec3u, 'global_invocation_id'),
+    globalInvocationIndex: defineBuiltin(u32, 'global_invocation_index'),
+    workgroupId: defineBuiltin(vec3u, 'workgroup_id'),
+    workgroupIndex: defineBuiltin(u32, 'workgroup_index'),
+    numWorkgroups: defineBuiltin(vec3u, 'num_workgroups'),
+    subgroupInvocationId: defineBuiltin(u32, 'subgroup_invocation_id'),
+    subgroupSize: defineBuiltin(u32, 'subgroup_size'),
+    subgroupId: defineBuiltin(u32, 'subgroup_id'),
+    numSubgroups: defineBuiltin(u32, 'num_subgroups'),
 };
-
-//#endregion
-export { builtin };

package/common/fullScreenTriangle.d.ts

@@ -1,9 +1,3 @@
-import { TgpuVertexFn } from "../core/function/tgpuVertexFn.js";
-import { Vec2f } from "../data/wgslTypes.js";
-import "../indexNamedExports.js";
-
-//#region src/common/fullScreenTriangle.d.ts
-
 /**
  * A vertex function that defines a single full-screen triangle out
  * of three points.
@@ -20,8 +14,6 @@ import "../indexNamedExports.js";
  * pipeline.draw(3);
  * ```
  */
-declare const fullScreenTriangle: TgpuVertexFn<{}, {
-  uv: Vec2f;
+export declare const fullScreenTriangle: import("../indexNamedExports.ts").TgpuVertexFn<{}, {
+    uv: import("../data/wgslTypes.ts").Vec2f;
 }>;
-//#endregion
-export { fullScreenTriangle };

package/common/fullScreenTriangle.js

@@ -1,36 +1,28 @@
-import { vec2f } from "../data/vector.js";
 import { builtin } from "../builtin.js";
 import { vertexFn } from "../core/function/tgpuVertexFn.js";
-
-//#region src/common/fullScreenTriangle.ts
+import { vec2f } from "../data/vector.js";
 /**
-* A vertex function that defines a single full-screen triangle out
-* of three points.
-*
-* @example
-* ```ts
-* import { common } from 'typegpu';
-*
-* const pipeline = root.createRenderPipeline({
-*   vertex: common.fullScreenTriangle,
-*   fragment: yourFragmentShader,
-* });
-*
-* pipeline.draw(3);
-* ```
-*/
-const fullScreenTriangle = vertexFn({
-	in: { vertexIndex: builtin.vertexIndex },
-	out: {
-		pos: builtin.position,
-		uv: vec2f
-	}
-})`{
+ * A vertex function that defines a single full-screen triangle out
+ * of three points.
+ *
+ * @example
+ * ```ts
+ * import { common } from 'typegpu';
+ *
+ * const pipeline = root.createRenderPipeline({
+ *   vertex: common.fullScreenTriangle,
+ *   fragment: yourFragmentShader,
+ * });
+ *
+ * pipeline.draw(3);
+ * ```
+ */
+export const fullScreenTriangle = vertexFn({
+    in: { vertexIndex: builtin.vertexIndex },
+    out: { pos: builtin.position, uv: vec2f },
+}) `{
   const pos = array<vec2f, 3>(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3));
   const uv = array<vec2f, 3>(vec2f(0, 1), vec2f(2, 1), vec2f(0, -1));
 
   return Out(vec4f(pos[in.vertexIndex], 0, 1), uv[in.vertexIndex]);
 }`;
-
-//#endregion
-export { fullScreenTriangle };

package/common/index.d.ts

@@ -1,9 +1,2 @@
-import { fullScreenTriangle } from "./fullScreenTriangle.js";
-import { writeSoA } from "./writeSoA.js";
-
-//#region src/common/index.d.ts
-declare namespace index_d_exports {
-  export { fullScreenTriangle, writeSoA };
-}
-//#endregion
-export { fullScreenTriangle, index_d_exports, writeSoA };
+export { fullScreenTriangle } from './fullScreenTriangle.ts';
+export { writeSoA } from './writeSoA.ts';

package/common/index.js

@@ -1,12 +1,3 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
-import { fullScreenTriangle } from "./fullScreenTriangle.js";
-import { writeSoA } from "./writeSoA.js";
-
-//#region src/common/index.ts
-var common_exports = /* @__PURE__ */ __export({
-	fullScreenTriangle: () => fullScreenTriangle,
-	writeSoA: () => writeSoA
-});
-
-//#endregion
-export { common_exports, fullScreenTriangle, writeSoA };
+// NOTE: This is a barrel file, internal files should not import things from this file
+export { fullScreenTriangle } from "./fullScreenTriangle.js";
+export { writeSoA } from "./writeSoA.js";

package/common/writeSoA.d.ts

@@ -1,16 +1,15 @@
-import { Prettify } from "../shared/utilityTypes.js";
-import { BufferWriteOptions, TgpuBuffer } from "../core/buffer/buffer.js";
-import { BaseData, TypedArrayFor, WgslArray, WgslStruct } from "../data/wgslTypes.js";
-import { Undecorate } from "../data/dataTypes.js";
-
-//#region src/common/writeSoA.d.ts
+import type { Undecorate } from '../data/dataTypes.ts';
+import type { BaseData, TypedArrayFor, WgslArray, WgslStruct } from '../data/wgslTypes.ts';
+import type { BufferWriteOptions, TgpuBuffer } from '../core/buffer/buffer.ts';
+import type { Prettify } from '../shared/utilityTypes.ts';
 type PackedScalarFor<T> = Undecorate<T> extends WgslArray<infer TElement> ? PackedScalarFor<TElement> : Undecorate<T>;
 type PackedSoAInputFor<T> = TypedArrayFor<PackedScalarFor<T>>;
-type SoAFieldsFor<T extends Record<string, BaseData>> = { [K in keyof T as [PackedSoAInputFor<T[K]>] extends [never] ? never : K]: PackedSoAInputFor<T[K]> };
+type SoAFieldsFor<T extends Record<string, BaseData>> = {
+    [K in keyof T as [PackedSoAInputFor<T[K]>] extends [never] ? never : K]: PackedSoAInputFor<T[K]>;
+};
 type SoAInputFor<T extends Record<string, BaseData>> = [keyof T] extends [keyof SoAFieldsFor<T>] ? Prettify<SoAFieldsFor<T>> : never;
-declare function writeSoA<TProps extends Record<string, BaseData>>(buffer: TgpuBuffer<WgslArray<WgslStruct<TProps>>>, data: SoAInputFor<TProps>, options?: BufferWriteOptions): void;
-declare namespace writeSoA {
-  type InputFor<TProps extends Record<string, BaseData>> = SoAInputFor<TProps>;
+export declare function writeSoA<TProps extends Record<string, BaseData>>(buffer: TgpuBuffer<WgslArray<WgslStruct<TProps>>>, data: SoAInputFor<TProps>, options?: BufferWriteOptions): void;
+export declare namespace writeSoA {
+    type InputFor<TProps extends Record<string, BaseData>> = SoAInputFor<TProps>;
 }
-//#endregion
-export { writeSoA };
+export {};

package/common/writeSoA.js

@@ -1,92 +1,104 @@
-import { isAtomic, isMat, isMat2x2f, isMat3x3f, isWgslArray } from "../data/wgslTypes.js";
-import { undecorate } from "../data/dataTypes.js";
 import { invariant } from "../errors.js";
-import { alignmentOf } from "../data/alignmentOf.js";
 import { roundUp } from "../mathUtils.js";
-import { sizeOf } from "../data/sizeOf.js";
+import { alignmentOf } from "../data/alignmentOf.js";
+import { undecorate } from "../data/dataTypes.js";
 import { offsetsForProps } from "../data/offsets.js";
-
-//#region src/common/writeSoA.ts
+import { sizeOf } from "../data/sizeOf.js";
+import { isAtomic, isMat, isMat2x2f, isMat3x3f, isWgslArray } from "../data/wgslTypes.js";
 function packedSchemaOf(schema) {
-	const unpackedSchema = undecorate(schema);
-	return isAtomic(unpackedSchema) ? unpackedSchema.inner : unpackedSchema;
+    const unpackedSchema = undecorate(schema);
+    return isAtomic(unpackedSchema) ? unpackedSchema.inner : unpackedSchema;
 }
 function packedMatrixDimOf(schema) {
-	return isMat3x3f(schema) ? 3 : isMat2x2f(schema) ? 2 : isMat(schema) ? 4 : void 0;
+    return isMat3x3f(schema) ? 3 : isMat2x2f(schema) ? 2 : isMat(schema) ? 4 : undefined;
 }
 function packedSizeOf(schema) {
-	const packedSchema = packedSchemaOf(schema);
-	const matrixDim = packedMatrixDimOf(packedSchema);
-	if (matrixDim) return matrixDim * matrixDim * 4;
-	if (isWgslArray(packedSchema)) return packedSchema.elementCount * packedSizeOf(packedSchema.elementType);
-	return sizeOf(packedSchema);
+    const packedSchema = packedSchemaOf(schema);
+    const matrixDim = packedMatrixDimOf(packedSchema);
+    if (matrixDim) {
+        return matrixDim * matrixDim * 4;
+    }
+    if (isWgslArray(packedSchema)) {
+        return packedSchema.elementCount * packedSizeOf(packedSchema.elementType);
+    }
+    return sizeOf(packedSchema);
 }
 function computeSoAByteLength(arraySchema, soaData) {
-	const structSchema = arraySchema.elementType;
-	let inferredCount;
-	for (const key in structSchema.propTypes) {
-		const srcArray = soaData[key];
-		const fieldSchema = structSchema.propTypes[key];
-		if (srcArray === void 0 || fieldSchema === void 0) continue;
-		const packedFieldSize = packedSizeOf(fieldSchema);
-		if (packedFieldSize === 0) continue;
-		const fieldElementCount = Math.floor(srcArray.byteLength / packedFieldSize);
-		inferredCount = inferredCount === void 0 ? fieldElementCount : Math.min(inferredCount, fieldElementCount);
-	}
-	if (inferredCount === void 0) return;
-	const elementStride = roundUp(sizeOf(structSchema), alignmentOf(structSchema));
-	return inferredCount * elementStride;
+    const structSchema = arraySchema.elementType;
+    let inferredCount;
+    for (const key in structSchema.propTypes) {
+        const srcArray = soaData[key];
+        const fieldSchema = structSchema.propTypes[key];
+        if (srcArray === undefined || fieldSchema === undefined) {
+            continue;
+        }
+        const packedFieldSize = packedSizeOf(fieldSchema);
+        if (packedFieldSize === 0) {
+            continue;
+        }
+        const fieldElementCount = Math.floor(srcArray.byteLength / packedFieldSize);
+        inferredCount =
+            inferredCount === undefined ? fieldElementCount : Math.min(inferredCount, fieldElementCount);
+    }
+    if (inferredCount === undefined) {
+        return undefined;
+    }
+    const elementStride = roundUp(sizeOf(structSchema), alignmentOf(structSchema));
+    return inferredCount * elementStride;
 }
 function writePackedValue(target, schema, srcBytes, dstOffset, srcOffset) {
-	const unpackedSchema = undecorate(schema);
-	const packedSchema = isAtomic(unpackedSchema) ? unpackedSchema.inner : unpackedSchema;
-	const matrixDim = packedMatrixDimOf(packedSchema);
-	if (matrixDim) {
-		const packedColumnSize = matrixDim * 4;
-		const gpuColumnStride = roundUp(packedColumnSize, alignmentOf(schema));
-		for (let col = 0; col < matrixDim; col++) target.set(srcBytes.subarray(srcOffset + col * packedColumnSize, srcOffset + col * packedColumnSize + packedColumnSize), dstOffset + col * gpuColumnStride);
-		return;
-	}
-	if (isWgslArray(unpackedSchema)) {
-		const packedElementSize = packedSizeOf(unpackedSchema.elementType);
-		const gpuElementStride = roundUp(sizeOf(unpackedSchema.elementType), alignmentOf(unpackedSchema.elementType));
-		for (let i = 0; i < unpackedSchema.elementCount; i++) writePackedValue(target, unpackedSchema.elementType, srcBytes, dstOffset + i * gpuElementStride, srcOffset + i * packedElementSize);
-		return;
-	}
-	target.set(srcBytes.subarray(srcOffset, srcOffset + sizeOf(packedSchema)), dstOffset);
+    const unpackedSchema = undecorate(schema);
+    const packedSchema = isAtomic(unpackedSchema) ? unpackedSchema.inner : unpackedSchema;
+    const matrixDim = packedMatrixDimOf(packedSchema);
+    if (matrixDim) {
+        const packedColumnSize = matrixDim * 4;
+        const gpuColumnStride = roundUp(packedColumnSize, alignmentOf(schema));
+        for (let col = 0; col < matrixDim; col++) {
+            target.set(srcBytes.subarray(srcOffset + col * packedColumnSize, srcOffset + col * packedColumnSize + packedColumnSize), dstOffset + col * gpuColumnStride);
+        }
+        return;
+    }
+    if (isWgslArray(unpackedSchema)) {
+        const packedElementSize = packedSizeOf(unpackedSchema.elementType);
+        const gpuElementStride = roundUp(sizeOf(unpackedSchema.elementType), alignmentOf(unpackedSchema.elementType));
+        for (let i = 0; i < unpackedSchema.elementCount; i++) {
+            writePackedValue(target, unpackedSchema.elementType, srcBytes, dstOffset + i * gpuElementStride, srcOffset + i * packedElementSize);
+        }
+        return;
+    }
+    target.set(srcBytes.subarray(srcOffset, srcOffset + sizeOf(packedSchema)), dstOffset);
 }
 function scatterSoA(target, arraySchema, soaData, startOffset, endOffset) {
-	const structSchema = arraySchema.elementType;
-	const elementStride = roundUp(sizeOf(structSchema), alignmentOf(structSchema));
-	invariant(startOffset % elementStride === 0, `startOffset (${startOffset}) must be aligned to the element stride (${elementStride})`);
-	const startElement = Math.floor(startOffset / elementStride);
-	const endElement = Math.min(arraySchema.elementCount, Math.ceil(endOffset / elementStride));
-	const elementCount = Math.max(0, endElement - startElement);
-	const offsets = offsetsForProps(structSchema);
-	for (const key in structSchema.propTypes) {
-		const fieldSchema = structSchema.propTypes[key];
-		if (fieldSchema === void 0) continue;
-		const srcArray = soaData[key];
-		invariant(srcArray !== void 0, `Missing SoA data for field '${key}'`);
-		const fieldOffset = offsets[key]?.offset;
-		invariant(fieldOffset !== void 0, `Field ${key} not found in struct schema`);
-		const packedFieldSize = packedSizeOf(fieldSchema);
-		const srcBytes = new Uint8Array(srcArray.buffer, srcArray.byteOffset, srcArray.byteLength);
-		for (let i = 0; i < elementCount; i++) writePackedValue(target, fieldSchema, srcBytes, (startElement + i) * elementStride + fieldOffset, i * packedFieldSize);
-	}
+    const structSchema = arraySchema.elementType;
+    const elementStride = roundUp(sizeOf(structSchema), alignmentOf(structSchema));
+    invariant(startOffset % elementStride === 0, `startOffset (${startOffset}) must be aligned to the element stride (${elementStride})`);
+    const startElement = Math.floor(startOffset / elementStride);
+    const endElement = Math.min(arraySchema.elementCount, Math.ceil(endOffset / elementStride));
+    const elementCount = Math.max(0, endElement - startElement);
+    const offsets = offsetsForProps(structSchema);
+    for (const key in structSchema.propTypes) {
+        const fieldSchema = structSchema.propTypes[key];
+        if (fieldSchema === undefined) {
+            continue;
+        }
+        const srcArray = soaData[key];
+        invariant(srcArray !== undefined, `Missing SoA data for field '${key}'`);
+        const fieldOffset = offsets[key]?.offset;
+        invariant(fieldOffset !== undefined, `Field ${key} not found in struct schema`);
+        const packedFieldSize = packedSizeOf(fieldSchema);
+        const srcBytes = new Uint8Array(srcArray.buffer, srcArray.byteOffset, srcArray.byteLength);
+        for (let i = 0; i < elementCount; i++) {
+            writePackedValue(target, fieldSchema, srcBytes, (startElement + i) * elementStride + fieldOffset, i * packedFieldSize);
+        }
+    }
 }
-function writeSoA(buffer, data, options) {
-	const arrayBuffer = buffer.arrayBuffer;
-	const startOffset = options?.startOffset ?? 0;
-	const bufferSize = sizeOf(buffer.dataType);
-	const naturalSize = computeSoAByteLength(buffer.dataType, data);
-	const endOffset = options?.endOffset ?? (naturalSize === void 0 ? bufferSize : Math.min(startOffset + naturalSize, bufferSize));
-	scatterSoA(new Uint8Array(arrayBuffer), buffer.dataType, data, startOffset, endOffset);
-	buffer.write(arrayBuffer, {
-		startOffset,
-		endOffset
-	});
+export function writeSoA(buffer, data, options) {
+    const arrayBuffer = buffer.arrayBuffer;
+    const startOffset = options?.startOffset ?? 0;
+    const bufferSize = sizeOf(buffer.dataType);
+    const naturalSize = computeSoAByteLength(buffer.dataType, data);
+    const endOffset = options?.endOffset ??
+        (naturalSize === undefined ? bufferSize : Math.min(startOffset + naturalSize, bufferSize));
+    scatterSoA(new Uint8Array(arrayBuffer), buffer.dataType, data, startOffset, endOffset);
+    buffer.write(arrayBuffer, { startOffset, endOffset });
 }
-
-//#endregion
-export { writeSoA };