@adobe/data 0.1.3 → 0.2.0

package/src/table/table.ts

@@ -0,0 +1,32 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { ReadonlyTypedBuffer, TypedBuffer } from "../typed-buffer/index.js";
+
+export interface ReadonlyTable<C> {
+    readonly columns: { readonly [K in keyof C]: ReadonlyTypedBuffer<C[K]> }
+    readonly rows: number;
+}
+
+export interface Table<C> extends ReadonlyTable<C> {
+    readonly columns: { readonly [K in keyof C]: TypedBuffer<C[K]> }
+    rows: number;
+}

package/src/table/update-row.ts

@@ -0,0 +1,35 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { RowIndex } from "./row-index.js";
+import { Table } from "./table.js";
+
+/**
+ * Adds a row to the end of the Table.
+ * @param Table 
+ * @param rowData 
+ */
+export const updateRow = <C>(archetype: Table<C>, row: RowIndex, rowData: Partial<C>) => {
+    for (const name in rowData) {
+        const column = archetype.columns[name];
+        column.set(row, rowData[name] as C[typeof name]);
+    }
+}

package/src/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../tsconfig-base.json",
+  "include": ["**/*"],
+  "exclude": ["assembly/*"],
+  "references": []
+}

package/src/typed-buffer/copy-to-gpu-buffer.ts

@@ -0,0 +1,23 @@
+import { TypedBuffer } from "./typed-buffer.js";
+
+export const copyToGPUBuffer = <T>(
+    typedBuffer: TypedBuffer<T>,
+    device: GPUDevice,
+    gpuBuffer: GPUBuffer,
+    byteLength?: number,
+    offset?: number,
+): GPUBuffer => {
+    const array = typedBuffer.getTypedArray();
+    byteLength ??= array.byteLength;
+    offset ??= 0;
+    if (gpuBuffer.size < byteLength) {
+        gpuBuffer.destroy();
+        gpuBuffer = device.createBuffer({
+            size: byteLength,
+            usage: gpuBuffer.usage,
+            mappedAtCreation: false,
+        });
+    }
+    device.queue.writeBuffer(gpuBuffer, 0, array.buffer, offset, byteLength);
+    return gpuBuffer;
+}

package/{cache/expiring-data-cache.js → src/typed-buffer/create-array-buffer.ts}

@@ -19,31 +19,37 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.*/
-/**
- * Creates a new expiring data cache with the specified underlying cache.
- */
-export function createExpiringDataCache(baseCache, getTime = () => Date.now()) {
-    const cache = baseCache;
-    return {
-        async match(key) {
-            const entry = await cache.match(key);
-            if (!entry) {
-                return undefined;
-            }
-            if (entry.expiration != null && entry.expiration <= getTime()) {
-                await cache.delete(key);
-                return undefined;
-            }
-            return entry.value;
+import { TypedBuffer } from "./typed-buffer.js";
+
+export const createArrayBuffer = <T>(args: {
+    length?: number,
+}): TypedBuffer<T> => {
+    const {
+        length = 16,
+    } = args;
+    const array = new Array<T>(length);
+    const typedBuffer = {
+        getTypedArray() {
+            throw new Error("Typed array not supported");
+        },
+        get size(): number {
+            return array.length;
+        },
+        set size(value: number) {
+            array.length = value;
+        },
+        get(index: number): T {
+            return array[index];
+        },
+        set(index: number, value: T): void {
+            array[index] = value;
         },
-        async put(key, value, options) {
-            const { maximumDuration: maxDuration } = options || {};
-            const expiration = (maxDuration !== undefined) && maxDuration >= 0 ? getTime() + maxDuration : null;
-            await cache.put(key, { value, expiration });
+        copyWithin(target: number, start: number, end: number): void {
+            array.copyWithin(target, start, end);
         },
-        async delete(key) {
-            await cache.delete(key);
+        [Symbol.iterator](): IterableIterator<T> {
+            return array[Symbol.iterator]();
         },
-    };
-}
-//# sourceMappingURL=expiring-data-cache.js.map
+    } as const satisfies TypedBuffer<T>;
+    return typedBuffer;
+}

package/src/typed-buffer/create-number-buffer.ts

@@ -0,0 +1,90 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { grow } from "../internal/array-buffer-like/grow.js";
+import { I32Schema } from "../schema/i32.js";
+import { Schema } from "../schema/schema.js";
+import { TypedArrayConstructor } from "../internal/typed-array/index.js";
+import { U32Schema } from "../schema/u32.js";
+import { TypedBuffer } from "./typed-buffer.js";
+
+const getTypedArrayConstructor = (schema: Schema): TypedArrayConstructor => {
+    if (schema.type === 'number' || schema.type === 'integer') {
+        if (schema.type === "integer") {
+            if (schema.minimum !== undefined && schema.maximum !== undefined) {
+                if (schema.minimum >= U32Schema.minimum && schema.maximum <= U32Schema.maximum) {
+                    return Uint32Array;
+                }
+                if (schema.minimum >= I32Schema.minimum && schema.maximum <= I32Schema.maximum) {
+                    return Int32Array;
+                }
+            }
+        }
+        else if (schema.precision === 1) {
+            return Float32Array;
+        }
+        return Float64Array;
+    }
+    throw new Error("Schema is not a valid number schema");
+}
+
+export const createNumberBuffer = (args: {
+    schema: Schema,
+    length?: number,
+    maxLength?: number,
+    arrayBuffer?: ArrayBufferLike,
+}): TypedBuffer<number> => {
+    const {
+        schema,
+        length = 16,
+        maxLength = length,
+    } = args;
+    const typedArrayConstructor = getTypedArrayConstructor(schema);
+    const stride = typedArrayConstructor.BYTES_PER_ELEMENT;
+    const {
+        arrayBuffer = new ArrayBuffer(stride * length, { maxByteLength: stride * maxLength }),
+    } = args;
+    const array = new typedArrayConstructor(arrayBuffer);
+    const typedBuffer = {
+        getTypedArray() {
+            return array;
+        },
+        get size(): number {
+            return array.length;
+        },
+        set size(value: number) {
+            grow(arrayBuffer, value * stride);
+        },
+        get(index: number): number {
+            return array[index];
+        },
+        set(index: number, value: number): void {
+            array[index] = value;
+        },
+        copyWithin(target: number, start: number, end: number): void {
+            array.copyWithin(target, start, end);
+        },
+        [Symbol.iterator](): IterableIterator<number> {
+            return array[Symbol.iterator]();
+        },
+    } as const satisfies TypedBuffer<number>;
+    return typedBuffer;
+}

package/src/typed-buffer/create-struct-buffer.ts

@@ -0,0 +1,93 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { grow } from "../internal/array-buffer-like/grow.js";
+import { DataView32 } from "../internal/data-view-32/data-view-32.js";
+import { createDataView32 } from "../internal/data-view-32/create-data-view-32.js";
+import { FromSchema, Schema } from "../schema/schema.js";
+import { createReadStruct } from "./structs/create-read-struct.js";
+import { createWriteStruct } from "./structs/create-write-struct.js";
+import { getStructLayout } from "./structs/get-struct-layout.js";
+import { TypedBuffer } from "./typed-buffer.js";
+import { TypedArray } from "../internal/typed-array/index.js";
+
+export const createStructBuffer = <S extends Schema, ArrayType extends keyof DataView32 = "f32">(
+    args: {
+        schema: S,
+        length?: number,
+        maxLength?: number,
+        arrayBuffer?: ArrayBufferLike,
+        arrayType?: ArrayType
+    }
+): TypedBuffer<FromSchema<S>> => {
+    const { schema } = args;
+    const layout = getStructLayout(schema);
+    if (!layout) {
+        throw new Error("Schema is not a valid struct schema");
+    }
+    const { length = 16, arrayType = 'f32' } = args;
+    let arrayBuffer = args.arrayBuffer ?? new ArrayBuffer(length * layout.size);
+    const read = createReadStruct<FromSchema<S>>(layout);
+    const write = createWriteStruct<FromSchema<S>>(layout);
+
+    let dataView = createDataView32(arrayBuffer);
+    const sizeInQuads = layout.size / 4;
+
+    let typedArray: TypedArray = dataView[arrayType];
+
+    const buffer: TypedBuffer<FromSchema<S>> = {
+        getTypedArray() {
+            return typedArray;
+        },
+        get size() {
+            return arrayBuffer.byteLength / layout.size;
+        },
+        set size(length: number) {
+            // attempts to grow the array buffer in place, throws if it can't
+            arrayBuffer = grow(arrayBuffer, length * layout.size, true);
+            dataView = createDataView32(arrayBuffer);
+            typedArray = dataView[arrayType] as DataView32[ArrayType];
+        },
+        get: (index: number) => read(dataView, index),
+        set: (index: number, value: FromSchema<S>) => write(dataView, index, value),
+        copyWithin: (target: number, start: number, end: number) => {
+            dataView[arrayType].copyWithin(target * sizeInQuads, start * sizeInQuads, end * sizeInQuads);
+        },
+        [Symbol.iterator](): IterableIterator<FromSchema<S>> {
+            let index = 0;
+            const length = buffer.size;
+            return {
+                next(): IteratorResult<FromSchema<S>> {
+                    if (index < length) {
+                        const value = read(dataView, index);
+                        index++;
+                        return { value, done: false };
+                    }
+                    return { value: undefined, done: true };
+                },
+                [Symbol.iterator]() {
+                    return this;
+                }
+            };
+        },
+    };
+    return buffer;
+}

package/src/typed-buffer/create-typed-buffer.ts

@@ -0,0 +1,49 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { FromSchema, Schema } from "../schema/schema.js";
+import { createStructBuffer } from "./create-struct-buffer.js";
+import { getStructLayout } from "./structs/get-struct-layout.js";
+import { TypedBuffer } from "./typed-buffer.js";
+import { createNumberBuffer } from "./create-number-buffer.js";
+import { createArrayBuffer } from "./create-array-buffer.js";
+
+export const createTypedBuffer = <S extends Schema, T = FromSchema<S>>(
+    args: {
+        schema: S,
+        length?: number,
+        maxLength?: number,
+    }
+): TypedBuffer<FromSchema<S>> => {
+    const { schema } = args;
+    args.maxLength ??= 10_0000_000;
+
+    if (schema.type === 'number' || schema.type === 'integer') {
+        return createNumberBuffer(args) as TypedBuffer<FromSchema<S>>;
+    }
+
+    const structLayout = getStructLayout(schema, false);
+    if (structLayout) {
+        return createStructBuffer(args);
+    }
+
+    return createArrayBuffer<FromSchema<S>>(args);
+}

package/src/typed-buffer/index.ts

@@ -0,0 +1,26 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+export * from './typed-buffer.js';
+export * from './create-typed-buffer.js';
+export * from './create-struct-buffer.js';
+export { getStructLayout } from './structs/index.js';
+export { copyToGPUBuffer } from './copy-to-gpu-buffer.js';

package/src/typed-buffer/structs/assert-struct.ts

@@ -0,0 +1,37 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { Schema } from "../../schema/schema.js";
+import { getStructLayout } from "./get-struct-layout.js";
+
+/**
+ * Asserts that the schema is a valid struct schema.
+ * @param schema - The schema to assert.
+ * @returns The schema.
+ * @throws An error if the schema is not a valid struct schema.
+ */
+export const assertStruct = <S extends Schema>(schema: S): S => {
+    const layout = getStructLayout(schema);
+    if (!layout) {
+        throw new Error("Invalid structure schema");
+    }
+    return schema;
+};

package/src/typed-buffer/structs/create-read-struct.test.ts

@@ -0,0 +1,202 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { describe, it, expect } from "vitest";
+import { createReadStruct } from "./create-read-struct.js";
+import { createDataView32 } from "../../internal/data-view-32/create-data-view-32.js";
+import type { StructLayout } from "./struct-layout.js";
+
+describe("ReadStruct", () => {
+    it("Vec2 array root", () => {
+        const layout = {
+            "type": "array",
+            "size": 8,
+            "fields": {
+                "0": {
+                    "offset": 0,
+                    "type": "f32"
+                },
+                "1": {
+                    "offset": 4,
+                    "type": "f32"
+                }
+            }
+        } as const satisfies StructLayout;
+        const read = createReadStruct(layout);
+
+        const data = createDataView32(new ArrayBuffer(16));
+        data.f32[0] = 1.5;
+        data.f32[1] = 2.5;
+        data.f32[2] = 3.5;
+        data.f32[3] = 4.5;
+        const result = read(data, 0);
+        expect(result).toEqual([1.5, 2.5]);
+
+        // Test with offset
+        const result2 = read(data, 1);
+        expect(result2).toEqual([3.5, 4.5]);
+    });
+
+    it("Vec2 object root", () => {
+        const layout = {
+            "type": "object",
+            "size": 8,
+            "fields": {
+                "x": {
+                    "offset": 0,
+                    "type": "f32"
+                },
+                "y": {
+                    "offset": 4,
+                    "type": "f32"
+                }
+            }
+        } as const satisfies StructLayout;
+        const read = createReadStruct(layout);
+
+        const data = createDataView32(new ArrayBuffer(16));
+        data.f32[0] = 1.5;
+        data.f32[1] = 2.5;
+        data.f32[2] = 3.5;
+        data.f32[3] = 4.5;
+        const result = read(data, 0);
+        expect(result).toEqual({ x: 1.5, y: 2.5 });
+
+        // Test with offset
+        const result2 = read(data, 1);
+        expect(result2).toEqual({ x: 3.5, y: 4.5 });
+    });
+
+    it("Complex struct with nested arrays and primitives", () => {
+        const layout = {
+            type: "object",
+            size: 48,  // Total size rounded to vec4 (16 bytes)
+            fields: {
+                position: {
+                    offset: 0,
+                    type: {
+                        type: "array",
+                        size: 16,  // vec3 padded to vec4
+                        fields: {
+                            "0": { offset: 0, type: "f32" },
+                            "1": { offset: 4, type: "f32" },
+                            "2": { offset: 8, type: "f32" }
+                        }
+                    }
+                },
+                color: {
+                    offset: 16,  // Aligned to vec4
+                    type: {
+                        type: "array",
+                        size: 16,
+                        fields: {
+                            "0": { offset: 0, type: "f32" },
+                            "1": { offset: 4, type: "f32" },
+                            "2": { offset: 8, type: "f32" },
+                            "3": { offset: 12, type: "f32" }
+                        }
+                    }
+                },
+                age: {
+                    offset: 32,  // Aligned to vec4
+                    type: "u32"
+                },
+                charge: {
+                    offset: 36,
+                    type: "i32"
+                }
+            }
+        } as const satisfies StructLayout;
+        const read = createReadStruct(layout);
+
+        const data = createDataView32(new ArrayBuffer(96));  // Space for 2 structs
+        // position
+        data.f32[0] = 1;
+        data.f32[1] = 2;
+        data.f32[2] = 3;
+        // color
+        data.f32[4] = 1;
+        data.f32[5] = 0;
+        data.f32[6] = 0;
+        data.f32[7] = 1;
+        // age
+        data.u32[8] = 42;
+        // charge
+        data.i32[9] = -5;
+
+        // Second struct for offset testing
+        data.f32[12] = 4;
+        data.f32[13] = 5;
+        data.f32[14] = 6;
+        data.f32[16] = 0;
+        data.f32[17] = 1;
+        data.f32[18] = 0;
+        data.f32[19] = 1;
+        data.u32[20] = 24;
+        data.i32[21] = 3;
+
+        const result = read(data, 0);
+        expect(result).toEqual({
+            position: [1, 2, 3],
+            color: [1, 0, 0, 1],
+            age: 42,
+            charge: -5
+        });
+
+        // Test with offset
+        const result2 = read(data, 1);
+        expect(result2).toEqual({
+            position: [4, 5, 6],
+            color: [0, 1, 0, 1],
+            age: 24,
+            charge: 3
+        });
+    });
+
+    it("should only destructure used view types", () => {
+        // f32 only
+        const vec2Layout = {
+            type: "array",
+            size: 8,
+            fields: {
+                "0": { offset: 0, type: "f32" },
+                "1": { offset: 4, type: "f32" }
+            }
+        } as const satisfies StructLayout;
+        const readVec2 = createReadStruct(vec2Layout);
+        expect(readVec2.toString()).toMatch(/const { f32: __f32 } = data/);
+        expect(readVec2.toString()).not.toMatch(/i32: __i32/);
+        expect(readVec2.toString()).not.toMatch(/u32: __u32/);
+
+        // i32 and u32 only
+        const mixedLayout = {
+            type: "object",
+            size: 8,
+            fields: {
+                a: { offset: 0, type: "i32" },
+                b: { offset: 4, type: "u32" }
+            }
+        } as const satisfies StructLayout;
+        const readMixed = createReadStruct(mixedLayout);
+        expect(readMixed.toString()).not.toMatch(/f32: __f32/);
+        expect(readMixed.toString()).toMatch(/const { (?=.*i32: __i32)(?=.*u32: __u32).*? } = data/);
+    });
+});