@nnilky/structo 1.0.8 → 1.1.0

package/dist/datatypes/values/bytes.d.ts

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import * as st from "../../index.js";
 /**
  * Fixed length bytes
  *
@@ -6,4 +6,4 @@ import type { Serializer } from "../../types";
  * st.bytes(4)
  * ```
  */
-export declare function bytes(size: number): Serializer<ArrayBuffer>;
+export declare function bytes(size: number): st.Serializer<Uint8Array>;

package/dist/datatypes/values/bytes.js

@@ -1,3 +1,4 @@
+import * as st from "../../index.js";
 /**
  * Fixed length bytes
  *
@@ -9,17 +10,16 @@ export function bytes(size) {
     return {
         size,
         write: (ctx, value) => {
-            const bytes = new Uint8Array(value);
-            if (bytes.length !== size)
+            if (value.length !== size)
                 throw new Error("Invalid Length");
-            ctx.alloc(size);
-            new Uint8Array(ctx.buffer).set(bytes, ctx.offset);
+            ctx.reserve(size);
+            ctx.bytes.set(value, ctx.offset);
             ctx.offset += size;
         },
         read: (ctx) => {
-            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            const arr = ctx.bytes.subarray(ctx.offset, ctx.offset + size);
             ctx.offset += size;
-            return slice;
+            return arr.slice();
         },
     };
 }

package/dist/datatypes/values/bytes.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { bytes, encodeFailTest, encodeTest } from "../../utils.test";
-import * as st from "../../index";
+import { bytes, encodeFailTest, encodeTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.bytes", () => {
     const buffer = st.bytes(2);
     it("encode correctly", () => {
@@ -16,7 +16,7 @@ describe("st.bytes", () => {
         const data = new Uint8Array(size);
         data.set([3, 4], 1000);
         data.set([3, 4], 2000);
-        encodeTest(spec, data.buffer);
+        encodeTest(spec, data);
     });
     it("large data writes work", () => {
         const size = 1024 * 1024 * 8; // 8MB
@@ -30,7 +30,7 @@ describe("st.bytes", () => {
         data.set([3, 4], 2000);
         encodeTest(spec, {
             before: 1,
-            data: data.buffer,
+            data,
             after: 2,
         });
     });

package/dist/datatypes/values/sizedbytes.d.ts

@@ -1,2 +1,2 @@
-import type { Serializer } from "../../types";
-export declare function sizedBytes(length: Serializer<number>): Serializer<ArrayBuffer>;
+import type { Serializer } from "../../types.js";
+export declare function sizedBytes(length: Serializer<number>): Serializer<Uint8Array>;

package/dist/datatypes/values/sizedbytes.js

@@ -2,14 +2,13 @@ export function sizedBytes(length) {
     return {
         write: (ctx, value) => {
             length.write(ctx, value.byteLength);
-            const bytes = new Uint8Array(value);
-            ctx.alloc(value.byteLength);
-            new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);
+            ctx.reserve(value.byteLength);
+            ctx.bytes.set(value, ctx.offset);
             ctx.offset += value.byteLength;
         },
         read: (ctx) => {
             const size = length.read(ctx);
-            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            const slice = ctx.bytes.subarray(ctx.offset, ctx.offset + size);
             ctx.offset += size;
             return slice;
         },

package/dist/datatypes/values/sizedbytes.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { bytes, encodeFailTest, encodeTest } from "../../utils.test";
-import * as st from "../../index";
+import { bytes, encodeFailTest, encodeTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.sizedBytes", () => {
     it("encode correctly", () => {
         const buffer = st.sizedBytes(st.u8());
@@ -16,7 +16,7 @@ describe("st.sizedBytes", () => {
         const data = new Uint8Array(size);
         data.set([3, 4], 1000);
         data.set([3, 4], 2000);
-        encodeTest(spec, data.buffer);
+        encodeTest(spec, data);
     });
     it("errors on invalid length", () => {
         encodeFailTest(st.sizedBytes(st.u8()), //

package/dist/datatypes/values/string.d.ts

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /**
  * `st.json` stores string data by writing/reading the length and then reading that many bytes
  *

package/dist/datatypes/values/string.js

@@ -20,10 +20,9 @@ export function string(length) {
                 throw new Error("Expected String");
             const bytes = encoder.encode(value);
             const size = bytes.byteLength;
-            ctx.alloc(size + lengthSize);
+            ctx.reserve(size + lengthSize);
             length.write(ctx, size);
-            const arr = new Uint8Array(ctx.buffer, ctx.offset);
-            arr.set(bytes);
+            ctx.bytes.set(bytes, ctx.offset);
             ctx.offset += size;
         },
         read: (ctx) => {

package/dist/datatypes/values/string.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeFailTest, encodeTest } from "../../utils.test";
-import * as st from "../../index";
+import { encodeFailTest, encodeTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.string", () => {
     it("encode correctly", () => {
         encodeTest(st.string(st.u8()), "foo");

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export type { InferOutput as Infer, InferInput, InferOutput, ReaderContext, WriterContext, Serializer, } from "./types";
-export { read, createReaderContext } from "./read";
-export { write, createdWriterContext } from "./write";
-export * from "./datatypes/index";
-export * from "./transforms/index";
-export * from "./utilities/index";
+export type { InferOutput as Infer, InferInput, InferOutput, ReaderContext, WriterContext, Serializer, } from "./types.js";
+export { read } from "./read.js";
+export { write, writeInto } from "./write.js";
+export * from "./datatypes/index.js";
+export * from "./transforms/index.js";
+export * from "./utilities/index.js";

package/dist/index.js

@@ -1,5 +1,5 @@
-export { read, createReaderContext } from "./read";
-export { write, createdWriterContext } from "./write";
-export * from "./datatypes/index";
-export * from "./transforms/index";
-export * from "./utilities/index";
+export { read } from "./read.js";
+export { write, writeInto } from "./write.js";
+export * from "./datatypes/index.js";
+export * from "./transforms/index.js";
+export * from "./utilities/index.js";

package/dist/read.d.ts

@@ -1,3 +1,2 @@
-import type { Serializer, ReaderContext } from "./types";
-export declare function read<TIn, TOut>(serializer: Serializer<TIn, TOut>, buffer: ArrayBuffer): TOut;
-export declare function createReaderContext(buffer: ArrayBuffer): ReaderContext;
+import type { Serializer } from "./types.js";
+export declare function read<TIn, TOut>(serializer: Serializer<TIn, TOut>, buffer: ArrayBuffer | SharedArrayBuffer, offset?: number): TOut;

package/dist/read.js

@@ -1,18 +1,16 @@
-export function read(serializer, buffer) {
-    const ctx = createReaderContext(buffer);
+export function read(serializer, buffer, offset) {
+    const ctx = {
+        buffer: buffer,
+        view: new DataView(buffer),
+        bytes: new Uint8Array(buffer),
+        path: [],
+        offset: offset ?? 0,
+    };
     try {
         return serializer.read(ctx);
     }
     catch (e) {
-        const path = ctx.stack.join("") ?? "root";
-        throw new Error(`Deserialization error at serializer${path}`, { cause: e });
+        const path = ctx.path.join("") ?? "root";
+        throw new Error(`Deserialization error at serializer${path}\n${e}`, { cause: e });
     }
 }
-export function createReaderContext(buffer) {
-    return {
-        stack: [],
-        offset: 0,
-        buffer,
-        view: new DataView(buffer),
-    };
-}

package/dist/transforms/encode.d.ts

@@ -1,4 +1,4 @@
-import type { Transform } from "./pipe";
+import type { Transform } from "./pipe.js";
 export declare function encode<TIn, TOut>(options: {
     encode: (value: TOut) => TIn;
     decode: (value: TIn) => TOut;

package/dist/transforms/enum.d.ts

@@ -1,2 +1,2 @@
-export declare function enum_<const T>(values: T[]): import("./pipe").Transform<T, any>;
+export declare function enum_<const T>(values: T[]): import("./pipe.ts").Transform<T, any>;
 export { enum_ as enum };

package/dist/transforms/enum.js

@@ -1,4 +1,4 @@
-import { encode } from "./encode";
+import { encode } from "./encode.js";
 export function enum_(values) {
     return encode({
         encode: (v) => {

package/dist/transforms/enum.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
-import * as st from "../index";
-import { encodeTest, encodeFailTest } from "../utils.test";
+import * as st from "../index.js";
+import { encodeTest, encodeFailTest } from "../utils.test.js";
 describe("st.enum", () => {
     it("encode correctly", () => {
         encodeTest(st.pipe(st.u8(), st.enum([0, 1, 2])), //

package/dist/transforms/index.d.ts

@@ -1,11 +1,11 @@
-export { type Transform as Pipeline, pipe } from "./pipe";
-export { encode } from "./encode";
-export { modify } from "./modify";
-export { literal } from "./literal";
-export { enum } from "./enum";
-export { offset } from "./offset";
-export { toAscii } from "./toAscii";
-export { toBytes } from "./toBytes";
-export { toHex } from "./toHex";
-export { toBase64 } from "./toBase64";
-export { toTypedArray } from "./toTypedArray";
+export { type Transform as Pipeline, pipe } from "./pipe.js";
+export { encode } from "./encode.js";
+export { modify } from "./modify.js";
+export { literal } from "./literal.js";
+export { enum } from "./enum.js";
+export { offset } from "./offset.js";
+export { toAscii } from "./toAscii.js";
+export { toBytes } from "./toBytes.js";
+export { toHex } from "./toHex.js";
+export { toBase64 } from "./toBase64.js";
+export { toTypedArray } from "./toTypedArray.js";

package/dist/transforms/index.js

@@ -1,11 +1,11 @@
-export { pipe } from "./pipe";
-export { encode } from "./encode";
-export { modify } from "./modify";
-export { literal } from "./literal";
-export { enum } from "./enum";
-export { offset } from "./offset";
-export { toAscii } from "./toAscii";
-export { toBytes } from "./toBytes";
-export { toHex } from "./toHex";
-export { toBase64 } from "./toBase64";
-export { toTypedArray } from "./toTypedArray";
+export { pipe } from "./pipe.js";
+export { encode } from "./encode.js";
+export { modify } from "./modify.js";
+export { literal } from "./literal.js";
+export { enum } from "./enum.js";
+export { offset } from "./offset.js";
+export { toAscii } from "./toAscii.js";
+export { toBytes } from "./toBytes.js";
+export { toHex } from "./toHex.js";
+export { toBase64 } from "./toBase64.js";
+export { toTypedArray } from "./toTypedArray.js";

package/dist/transforms/literal.d.ts

@@ -1 +1 @@
-export declare function literal<const T>(value: T): import("./pipe").Transform<T, any>;
+export declare function literal<const T>(value: T): import("./pipe.ts").Transform<T, any>;

package/dist/transforms/literal.js

@@ -1,4 +1,4 @@
-import { encode } from "./encode";
+import { encode } from "./encode.js";
 export function literal(value) {
     return encode({
         encode: (v) => {

package/dist/transforms/literal.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
-import * as st from "../index";
-import { encodeTest, encodeFailTest } from "../utils.test";
+import * as st from "../index.js";
+import { encodeTest, encodeFailTest } from "../utils.test.js";
 describe("st.literal", () => {
     it("encode correctly", () => {
         encodeTest(st.pipe(st.u8(), st.literal(0)), //

package/dist/transforms/modify.d.ts

@@ -1,4 +1,4 @@
-import type { Transform } from "./pipe";
+import type { Transform } from "./pipe.js";
 /**
  * A readonly modification function, useful for sizes or offsets.
  *

package/dist/transforms/modify.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { encodeFailTest } from "../utils.test";
-import * as st from "../index";
+import { encodeFailTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.modify", () => {
     it("encodes correctly", () => {
         const data = st.write(st.u32(), 10);

package/dist/transforms/offset.d.ts

@@ -1,2 +1,2 @@
-import type { Serializer } from "../types";
+import type { Serializer } from "../types.js";
 export declare function offset<TIn, TOut>(behaviour: "relative" | "absolute", offset: Serializer<number> | number): (type: Serializer<TIn, TOut>) => Serializer<TIn, TOut>;

package/dist/transforms/offset.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeTest } from "../utils.test";
-import * as st from "../index";
+import { encodeTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.offset(relative)", () => {
     it("encodes correctly with fixed offset", () => {
         const spec = st.object({

package/dist/transforms/pipe.d.ts

@@ -1,4 +1,4 @@
-import type { Serializer } from "../types";
+import type { Serializer } from "../types.js";
 export type Transform<T = any, TNext = T> = (type: Serializer<TNext>) => Serializer<T>;
 export declare function pipe<TStart, T1>(type: Serializer<TStart>, p1: Transform<T1, TStart>): Serializer<T1>;
 export declare function pipe<TStart, T1, T2>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>): Serializer<T2>;

package/dist/transforms/toAscii.d.ts

@@ -1 +1 @@
-export declare function toAscii(): import("./pipe").Transform<string, ArrayBuffer>;
+export declare function toAscii(): import("./pipe.ts").Transform<string, Uint8Array<ArrayBufferLike>>;

package/dist/transforms/toAscii.js

@@ -1,8 +1,8 @@
-import { encode } from "./encode";
+import { encode } from "./encode.js";
 export function toAscii() {
     return encode({
-        encode: (v) => new Uint8Array(Array.from(v).map((char) => validateAscii(char.charCodeAt(0)))).buffer,
-        decode: (v) => Array.from(new Uint8Array(v))
+        encode: (v) => new Uint8Array(Array.from(v).map((char) => validateAscii(char.charCodeAt(0)))),
+        decode: (v) => Array.from(v)
             .map((v) => String.fromCharCode(v))
             .join(""),
     });

package/dist/transforms/toAscii.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
-import * as st from "../index";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.toAscii", () => {
     it("encode correctly", () => {
         encodeTest(st.pipe(st.bytes(5), st.toAscii()), //

package/dist/transforms/toBase64.d.ts

@@ -1 +1 @@
-export declare function toBase64(): import("./pipe").Transform<string, ArrayBuffer>;
+export declare function toBase64(): import("./pipe.ts").Transform<string, Uint8Array<ArrayBufferLike>>;

package/dist/transforms/toBase64.js

@@ -1,7 +1,7 @@
-import { encode } from "./encode";
+import { encode } from "./encode.js";
 export function toBase64() {
     return encode({
-        encode: (v) => Uint8Array.fromBase64(v).buffer,
-        decode: (v) => new Uint8Array(v).toBase64(),
+        encode: (v) => Uint8Array.fromBase64(v),
+        decode: (v) => v.toBase64(),
     });
 }

package/dist/transforms/toBase64.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
-import * as st from "../index";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.toBase64", () => {
     it("encode correctly", () => {
         encodeTest(st.pipe(st.bytes(1), st.toBase64()), //

package/dist/transforms/toBytes.d.ts

@@ -10,4 +10,4 @@
  *
  * `ArrayBuffer([0, 255, c])` => `[0, 255, ArrayBuffer([0, 255, 0])]`
  */
-export declare function toBytes(): import("./pipe").Transform<number[], ArrayBuffer>;
+export declare function toBytes(): import("./pipe.ts").Transform<number[], Uint8Array<ArrayBufferLike>>;

package/dist/transforms/toBytes.js

@@ -1,4 +1,4 @@
-import { encode } from "./encode";
+import { encode } from "./encode.js";
 /**
  * Converts an ArrayBuffer to the byte digits
  *
@@ -13,8 +13,8 @@ import { encode } from "./encode";
  */
 export function toBytes() {
     return encode({
-        encode: (v) => new Uint8Array(v.map(validateByte)).buffer,
-        decode: (v) => Array.from(new Uint8Array(v)),
+        encode: (v) => new Uint8Array(v.map(validateByte)),
+        decode: (v) => Array.from(v),
     });
 }
 const validateByte = (v) => {

package/dist/transforms/toBytes.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
-import * as st from "../index";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.toBytes", () => {
     it("encode correctly", () => {
         encodeTest(st.pipe(st.bytes(3), st.toBytes()), //

package/dist/transforms/toHex.d.ts

@@ -1,5 +1,5 @@
 /**
- * Converts an ArrayBuffer to uppercase hex
+ * Converts an Uint8Array to uppercase hex
  *
  * ```ts
  * st.pipe(
@@ -8,6 +8,6 @@
  * )
  * ```
  *
- * `ArrayBuffer([0, 255, 0])` => `00FF00`
+ * `Uint8Array([0, 255, 0])` => `00FF00`
  */
-export declare function toHex(): import("./pipe").Transform<string, ArrayBuffer>;
+export declare function toHex(): import("./pipe.ts").Transform<string, Uint8Array<ArrayBufferLike>>;

package/dist/transforms/toHex.js

@@ -1,6 +1,6 @@
-import { encode } from "./encode";
+import { encode } from "./encode.js";
 /**
- * Converts an ArrayBuffer to uppercase hex
+ * Converts an Uint8Array to uppercase hex
  *
  * ```ts
  * st.pipe(
@@ -9,11 +9,11 @@ import { encode } from "./encode";
  * )
  * ```
  *
- * `ArrayBuffer([0, 255, 0])` => `00FF00`
+ * `Uint8Array([0, 255, 0])` => `00FF00`
  */
 export function toHex() {
     return encode({
-        encode: (v) => Uint8Array.fromHex(v).buffer,
-        decode: (v) => new Uint8Array(v).toHex().toUpperCase(),
+        encode: (v) => Uint8Array.fromHex(v),
+        decode: (v) => v.toHex().toUpperCase(),
     });
 }

package/dist/transforms/toHex.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
-import * as st from "../index";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.toHex", () => {
     it("encode correctly", () => {
         encodeTest(st.pipe(st.bytes(3), st.toHex()), //

package/dist/transforms/toTypedArray.d.ts

@@ -1,16 +1,21 @@
-type TypedArray = {
-    buffer: ArrayBuffer;
+type TypedArrayLike = {
+    buffer: ArrayBuffer | SharedArrayBuffer;
+    byteOffset: number;
+    byteLength: number;
+    BYTES_PER_ELEMENT: number;
 };
-type TypedArrayConstructor<T extends TypedArray> = new (array: ArrayBuffer) => T;
+type TypedArray<T extends TypedArrayLike> = {
+    BYTES_PER_ELEMENT: number;
+} & (new (array: ArrayBuffer | SharedArrayBuffer, offset?: number, length?: number) => T);
 /**
- * Converts an `ArrayBuffer` to a `TypedArray`
+ * Converts a `Uint8Array` into the provided `TypedArray`, etc Float64Arrayt
  *
  * ```
  * st.pipe(
  *     st.bytes(16),
- *     toTypedArray(Uint8Array),
+ *     toTypedArray(Float32Array),
  * )
  * ```
  */
-export declare function toTypedArray<T extends TypedArray>(arrayType: TypedArrayConstructor<T>): import("./pipe").Transform<T, ArrayBuffer>;
+export declare function toTypedArray<T extends TypedArrayLike>(Array: TypedArray<T>): import("./pipe.ts").Transform<T, Uint8Array<ArrayBufferLike>>;
 export {};

package/dist/transforms/toTypedArray.js

@@ -1,17 +1,22 @@
-import { encode } from "./encode";
+import { encode } from "./encode.js";
 /**
- * Converts an `ArrayBuffer` to a `TypedArray`
+ * Converts a `Uint8Array` into the provided `TypedArray`, etc Float64Arrayt
  *
  * ```
  * st.pipe(
  *     st.bytes(16),
- *     toTypedArray(Uint8Array),
+ *     toTypedArray(Float32Array),
  * )
  * ```
  */
-export function toTypedArray(arrayType) {
+export function toTypedArray(Array) {
     return encode({
-        encode: (v) => v.buffer,
-        decode: (v) => new arrayType(v),
+        encode: (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength / Uint8Array.BYTES_PER_ELEMENT),
+        decode: (bytes) => {
+            if (bytes.byteLength % Array.BYTES_PER_ELEMENT !== 0) {
+                throw new Error(`Provided a ${bytes.byteLength} buffer to a TypedArray that uses ${bytes.BYTES_PER_ELEMENT} bytes per element`);
+            }
+            return new Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / Array.BYTES_PER_ELEMENT);
+        },
     });
 }

package/dist/transforms/toTypedArray.test.js

@@ -1,23 +1,32 @@
 import { describe, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest, expectError } from "../utils.test";
-import * as st from "../index";
-describe("st.toArrayBuffer", () => {
+import { encodeTest, encodeSnapshotTest, expectError } from "../utils.test.js";
+import * as st from "../index.js";
+describe("st.toTypedArray", () => {
     it("encode correctly", () => {
         encodeTest(st.pipe(st.bytes(6), //
         st.toTypedArray(Uint8Array)), new Uint8Array([1, 2, 3, 4, 5, 6]));
     });
     it("encode different types correctly", () => {
-        encodeTest(st.pipe(st.bytes(3), //
-        st.toTypedArray(Uint8Array)), new Uint8Array([1, 2, 3]));
-        encodeTest(st.pipe(st.bytes(5 * 2), //
-        st.toTypedArray(Uint16Array)), new Uint16Array([1, 2, 3, 63, 74]));
-        encodeTest(st.pipe(st.bytes(3 * 8), //
-        st.toTypedArray(Float64Array)), new Float64Array([Math.random(), Math.random(), Math.random()]));
+        encodeTest(st.object({
+            padding: st.u64(),
+            data: st.pipe(st.bytes(3), //
+            st.toTypedArray(Uint8Array)),
+        }), { padding: 0, data: new Uint8Array([1, 2, 3]) });
+        encodeTest(st.object({
+            padding: st.u64(),
+            data: st.pipe(st.bytes(5 * 2), //
+            st.toTypedArray(Uint16Array)),
+        }), { padding: 0, data: new Uint16Array([1, 2, 3, 63, 74]) });
+        encodeTest(st.object({
+            padding: st.u64(),
+            data: st.pipe(st.bytes(3 * 8), //
+            st.toTypedArray(Float64Array)),
+        }), { padding: 0, data: new Float64Array([Math.random(), Math.random(), Math.random()]) });
     });
-    it("errors on different types", () => {
+    it("errors when non-standard size", () => {
         expectError(() => {
             st.write(st.pipe(st.bytes(3), //
-            st.toTypedArray(Uint16Array)), new Uint16Array([1]));
+            st.toTypedArray(Uint16Array)), new Uint16Array([1, 2]));
         });
     });
     it("snapshot tests", () => {

package/dist/types.d.ts

@@ -4,18 +4,20 @@ export type Serializer<TIn, TOut = TIn> = {
     read: (ctx: ReaderContext) => TOut;
 };
 export type SerializationContext = WriterContext | ReaderContext;
-export interface WriterContext {
-    stack: string[];
-    buffer: ArrayBuffer;
-    view: DataView;
+export interface WriterContext<TBuffer extends ArrayBuffer | SharedArrayBuffer = ArrayBuffer | SharedArrayBuffer> {
     offset: number;
-    alloc: (length: number) => void;
-}
-export interface ReaderContext {
-    stack: string[];
-    buffer: ArrayBuffer;
+    buffer: TBuffer;
     view: DataView;
+    bytes: Uint8Array;
+    path: string[];
+    reserve: (length: number) => void;
+}
+export interface ReaderContext<TBuffer extends ArrayBuffer | SharedArrayBuffer = ArrayBuffer | SharedArrayBuffer> {
     offset: number;
+    buffer: TBuffer;
+    view: DataView;
+    bytes: Uint8Array;
+    path: string[];
 }
 export type InferInput<T> = T extends Serializer<infer V> ? V : never;
 export type InferOutput<T> = T extends Serializer<any, infer V> ? V : never;

package/dist/utilities/index.d.ts

@@ -1,3 +1,3 @@
-export { lazy } from "./lazy";
-export { createReference } from "./reference";
-export { createRememberedValue } from "./remember";
+export { lazy } from "./lazy.js";
+export { createReference } from "./reference.js";
+export { createRememberedValue } from "./remember.js";