@graphty/graph-format 0.0.0 → 0.2.0

package/dist/src/util/typed-array.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Low-level typed-array helpers shared by every module of @graphty/graph-format (design sections 5.7,
+ * 6.2, 9.5, 10.2 and 10.3): rounding and alignment arithmetic, arena segment layout, the 4-byte
+ * padding rules of I10, the u8 adoption predicate, the wire buffer-range check, per-dtype
+ * typed-array constructors, and the growth primitive of the builder staging (doubling into a
+ * resizable ArrayBuffer when the engine has one, allocate-and-copy doubling otherwise).
+ *
+ * Nothing here knows about graphs; everything is arithmetic over byte lengths and typed arrays.
+ */
+import { type Dtype, type TypedArrayData, type U8, type U32 } from "../types/index.js";
+/**
+ * Whether resizable ArrayBuffer is available, detected once at module load (design section 6.2). The
+ * growth helpers take it as their default; tests pass an explicit value to exercise both paths.
+ */
+export declare const HAS_RESIZABLE_ARRAY_BUFFER: boolean;
+/** Staging capacities are rounded up to this many elements (design section 6.2). */
+export declare const STAGING_ELEMENT_GRANULE = 16;
+/** Staging backing buffers are a multiple of this many bytes (design section 6.2). */
+export declare const STAGING_BYTE_GRANULE = 64;
+/**
+ * Virtual address space reserved (`maxByteLength`) for a fresh resizable staging buffer: 256 MiB, so
+ * a staging array grows in place without copying up to 64M u32 elements. Reservations are
+ * address-space only (pages are committed as the buffer grows), and a buffer that outgrows its
+ * reservation is reallocated with a doubled one, so the constant bounds the number of copies rather
+ * than the size of anything.
+ */
+export declare const STAGING_RESERVE_BYTES: number;
+/**
+ * Round `value` up to the next multiple of `multiple`. Written with `%`, not bit masks, because arc
+ * counts and byte lengths exceed 2^31 (invariant I3, design section 10.6).
+ * @param value - a non-negative integer
+ * @param multiple - a positive integer
+ * @returns the smallest multiple of `multiple` that is >= value
+ */
+export declare function roundUp(value: number, multiple: number): number;
+/**
+ * Pad a byte length to the next multiple of 4: the size of the padded u32 view of a u8 column and
+ * the rule every GPU-bound array satisfies (design sections 5.7 and 10.2).
+ * @param byteLength - a non-negative byte count
+ * @returns roundUp(byteLength, 4)
+ */
+export declare function padTo4(byteLength: number): number;
+/**
+ * The number of u32 words that span a byte range: ceil(byteLength / 4) (design section 10.2).
+ * @param byteLength - a non-negative byte count
+ * @returns the word count of the padded u32 view
+ */
+export declare function paddedWordCount(byteLength: number): number;
+/**
+ * Align a byte offset up to the next arena segment boundary (design section 10.3; 256 bytes, the
+ * WebGPU minStorageBufferOffsetAlignment default).
+ * @param byteOffset - a non-negative byte offset
+ * @param alignment - the alignment in bytes; defaults to ALIGNMENT (256)
+ * @returns roundUp(byteOffset, alignment)
+ */
+export declare function alignUp(byteOffset: number, alignment?: number): number;
+/**
+ * The result of laying out consecutive segments at aligned offsets (design section 10.3).
+ */
+interface SegmentLayout {
+    /**
+     * One entry per input length: the segment's byte offset relative to the start of the arena, or null for
+     * a zero-length segment, which occupies nothing.
+     */
+    readonly offsets: readonly (number | null)[];
+    /** One entry per input length: offset + length, or null for a zero-length segment. */
+    readonly ends: readonly (number | null)[];
+    /** The end of the last non-empty segment; 0 when every segment is empty. No trailing padding is added. */
+    readonly byteLength: number;
+    /** The bytes spent on inter-segment padding. */
+    readonly padding: number;
+}
+/**
+ * Lay out segments back to back, each non-empty one starting at a multiple of `alignment`, in the
+ * given order (design section 10.3: hot to cold). Zero-length segments get a null offset and occupy
+ * nothing, which is how an absent `weights`, a zero-arc `colIdx` and an identity permutation stay out
+ * of the arena. For the worked example of section 10.3 (400,004 / 8,000,000 / 8,000,000 / 8,000,000 /
+ * 4,000,000) the offsets are 0 / 400,128 / 8,400,128 / 16,400,128 / 24,400,128 and the total is
+ * 28,400,128 with 124 bytes of padding.
+ * @param byteLengths - the unpadded byte length of every segment in arena order (0 = absent)
+ * @param alignment - the segment alignment in bytes; defaults to ALIGNMENT (256)
+ * @returns the offsets, ends, total byte length and padding of the layout
+ */
+export declare function layoutSegments(byteLengths: readonly number[], alignment?: number): SegmentLayout;
+/**
+ * The I10 predicate for a GPU-bound array: a view whose byteOffset and byteLength are both multiples
+ * of 4 (design section 10.2).
+ * @param view - any ArrayBufferView
+ * @returns true when both byteOffset and byteLength are multiples of 4
+ */
+export declare function isFourByteAligned(view: ArrayBufferView): boolean;
+/**
+ * The "plain ArrayBuffer" half of invariant I10 (decision D-SAB, design section 9.4): the view's
+ * buffer is an `ArrayBuffer` that is neither a `SharedArrayBuffer` nor resizable, so its bytes are a
+ * `BufferSource` for `GPUQueue.writeBuffer`, transferable, and of fixed length for the life of the
+ * snapshot (invariant I17).
+ * @param view - any ArrayBufferView
+ * @returns true when the buffer is a plain, fixed-length ArrayBuffer
+ */
+export declare function isOverPlainBuffer(view: ArrayBufferView): boolean;
+/**
+ * The u8 adoption predicate of design section 5.7: "a zero-copy padded Uint32Array view is
+ * constructible", i.e. `byteOffset % 4 === 0 && byteOffset + roundUp(byteLength, 4) <=
+ * buffer.byteLength`.
+ * @param data - the u8 array a column would adopt
+ * @returns true when paddedU32View(data) can be built without copying
+ */
+export declare function canViewAsPaddedU32(data: U8): boolean;
+/**
+ * The zero-copy Uint32Array of ceil(byteLength / 4) words over a u8 array's own byte range (design
+ * sections 5.7 and 10.2); the trailing lanes of the last word are whatever the buffer holds there.
+ * @param data - a u8 array satisfying canViewAsPaddedU32()
+ * @returns the padded u32 view; E_COLUMN_ALIGNMENT when the view is not constructible
+ */
+export declare function paddedU32View(data: U8): U32;
+/**
+ * Copy a u8 array into a fresh store over which the padded u32 view is constructible: a new
+ * ArrayBuffer of roundUp(length, 4) bytes viewed at offset 0 with the original length (design section
+ * 5.7, the `adopt: "copy"` path). The padding bytes are zero.
+ * @param data - the u8 array to copy
+ * @returns a new U8 of the same length whose store satisfies canViewAsPaddedU32()
+ */
+export declare function copyToPaddedStore(data: U8): U8;
+/**
+ * The dtypes whose storage is one flat typed array: the five numeric dtypes plus bool (packed u32
+ * words) and dict (u32 codes). string, list and json have offsets, children or JS values instead.
+ */
+export type TypedDtype = Exclude<Dtype, "string" | "list" | "json">;
+/**
+ * A typed-array class as the helpers use it: BYTES_PER_ELEMENT plus the (buffer, byteOffset, length)
+ * constructor. Every concrete typed-array constructor satisfies it with T fixed to its
+ * ArrayBuffer-parameterised instance type.
+ */
+export interface TypedArrayCtor<T extends TypedArrayData> {
+    /** Bytes per element. */
+    readonly BYTES_PER_ELEMENT: number;
+    /**
+     * Construct a view of `length` elements over `buffer` starting at `byteOffset`.
+     * @param buffer - the backing buffer
+     * @param byteOffset - the start of the view in bytes
+     * @param length - the element count of the view
+     */
+    new (buffer: ArrayBuffer, byteOffset: number, length: number): T;
+}
+/**
+ * Throw E_UNSUPPORTED for a dtype value outside the union; the `default` branch of every dtype switch
+ * (design section 13.4) calls this so an unknown dtype coming from untrusted data fails loudly. Always
+ * throws.
+ * @param dtype - the value that reached the default branch
+ */
+export declare function unsupportedDtype(dtype: never): never;
+/**
+ * The typed-array class that stores a flat dtype (design section 5.1): Float32Array for f32,
+ * Float64Array for f64, Int32Array for i32, Uint8Array for u8, and Uint32Array for u32, for the packed
+ * words of bool and for the codes of dict.
+ * @param dtype - a flat dtype
+ * @returns the constructor; E_UNSUPPORTED for an unknown dtype
+ */
+export declare function typedArrayCtorOf(dtype: TypedDtype): TypedArrayCtor<TypedArrayData>;
+/**
+ * The next staging capacity, in elements, that holds at least `needed`: doubling from `current`,
+ * rounded up to STAGING_ELEMENT_GRANULE (design section 6.2). A capacity of 0 grows to the granule.
+ * @param current - the present capacity in elements
+ * @param needed - the minimum capacity required
+ * @returns the new capacity, >= needed, >= 2 * current, a multiple of 16
+ */
+export declare function growCapacity(current: number, needed: number): number;
+/**
+ * The byte length of a staging backing buffer for `capacity` elements of `bytesPerElement` bytes each:
+ * rounded up to STAGING_BYTE_GRANULE (design section 6.2). Because every element size divides 64 the
+ * result is always a whole number of elements.
+ * @param capacity - the capacity in elements
+ * @param bytesPerElement - the element size in bytes (1, 4 or 8)
+ * @returns the buffer byte length, a multiple of 64
+ */
+export declare function stagingByteLength(capacity: number, bytesPerElement: number): number;
+/**
+ * Allocate a staging buffer of `byteLength` bytes. With `resizable` true the buffer is created with a
+ * `maxByteLength` of at least `reserveBytes` (and at least `byteLength`) so it can later grow in place;
+ * should the engine refuse that reservation with a RangeError (an address-space limit, not a missing
+ * capability) the buffer is created resizable with `maxByteLength === byteLength`, which simply means
+ * its next growth reallocates. With `resizable` false a plain fixed-length buffer is returned.
+ * @param byteLength - the initial byte length
+ * @param resizable - whether to create a resizable buffer; defaults to HAS_RESIZABLE_ARRAY_BUFFER
+ * @param reserveBytes - the address space to reserve for in-place growth; defaults to STAGING_RESERVE_BYTES
+ * @returns the new buffer
+ */
+export declare function allocateStagingBuffer(byteLength: number, resizable?: boolean, reserveBytes?: number): ArrayBuffer;
+/**
+ * Grow a staging array so it holds at least `minLength` elements, preserving its contents (design
+ * section 6.2). When the array is the leading view of a resizable buffer with room left, the buffer is
+ * resized in place and no bytes move; otherwise a new buffer is allocated (resizable per `resizable`,
+ * with a reservation of at least twice the old one so repeated overflow stays amortised) and the
+ * contents copied. Either way the returned array is a fresh view object of exactly the new capacity;
+ * the caller replaces its reference. Elements beyond the old length are zero on the copy path and on a
+ * freshly resized region.
+ * @param array - the current staging array, viewed from byteOffset 0 of its buffer
+ * @param ctor - the array's constructor
+ * @param minLength - the minimum element count required
+ * @param resizable - whether new buffers are resizable; defaults to HAS_RESIZABLE_ARRAY_BUFFER
+ * @returns a view of growCapacity(array.length, minLength) elements holding the old contents
+ */
+export declare function growTypedArray<T extends TypedArrayData>(array: T, ctor: TypedArrayCtor<T>, minLength: number, resizable?: boolean): T;
+export {};
+//# sourceMappingURL=typed-array.d.ts.map

package/dist/src/util/typed-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array.d.ts","sourceRoot":"","sources":["../../../src/util/typed-array.ts"],"names":[],"mappings":"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"}

package/dist/src/util/typed-array.js

@@ -0,0 +1,289 @@
+/**
+ * Low-level typed-array helpers shared by every module of @graphty/graph-format (design sections 5.7,
+ * 6.2, 9.5, 10.2 and 10.3): rounding and alignment arithmetic, arena segment layout, the 4-byte
+ * padding rules of I10, the u8 adoption predicate, the wire buffer-range check, per-dtype
+ * typed-array constructors, and the growth primitive of the builder staging (doubling into a
+ * resizable ArrayBuffer when the engine has one, allocate-and-copy doubling otherwise).
+ *
+ * Nothing here knows about graphs; everything is arithmetic over byte lengths and typed arrays.
+ */
+import { ALIGNMENT } from "../constants.js";
+import { GraphFormatError } from "../errors.js";
+// ============================================================ resizable ArrayBuffer detection
+/**
+ * Probe once whether this engine supports resizable ArrayBuffer (ES2024: Node 20+, Chrome 111+,
+ * Safari 16.4+, Firefox 128+). The probe constructs a tiny resizable buffer and grows it; any throw or
+ * missing member means "not supported", in which case staging grows by allocate-and-copy (design
+ * section 6.2).
+ * @returns true when `new ArrayBuffer(n, { maxByteLength })` and `resize()` work
+ */
+function detectResizableArrayBuffer() {
+    try {
+        const probe = new ArrayBuffer(0, { maxByteLength: 64 });
+        if (!probe.resizable || typeof probe.resize !== "function") {
+            return false;
+        }
+        probe.resize(64);
+        return probe.byteLength === 64 && probe.maxByteLength === 64;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether resizable ArrayBuffer is available, detected once at module load (design section 6.2). The
+ * growth helpers take it as their default; tests pass an explicit value to exercise both paths.
+ */
+export const HAS_RESIZABLE_ARRAY_BUFFER = detectResizableArrayBuffer();
+// ============================================================ staging growth constants
+/** Staging capacities are rounded up to this many elements (design section 6.2). */
+export const STAGING_ELEMENT_GRANULE = 16;
+/** Staging backing buffers are a multiple of this many bytes (design section 6.2). */
+export const STAGING_BYTE_GRANULE = 64;
+/**
+ * Virtual address space reserved (`maxByteLength`) for a fresh resizable staging buffer: 256 MiB, so
+ * a staging array grows in place without copying up to 64M u32 elements. Reservations are
+ * address-space only (pages are committed as the buffer grows), and a buffer that outgrows its
+ * reservation is reallocated with a doubled one, so the constant bounds the number of copies rather
+ * than the size of anything.
+ */
+export const STAGING_RESERVE_BYTES = 256 * 1024 * 1024;
+// ============================================================ rounding and alignment
+/**
+ * Round `value` up to the next multiple of `multiple`. Written with `%`, not bit masks, because arc
+ * counts and byte lengths exceed 2^31 (invariant I3, design section 10.6).
+ * @param value - a non-negative integer
+ * @param multiple - a positive integer
+ * @returns the smallest multiple of `multiple` that is >= value
+ */
+export function roundUp(value, multiple) {
+    const remainder = value % multiple;
+    return remainder === 0 ? value : value + multiple - remainder;
+}
+/**
+ * Pad a byte length to the next multiple of 4: the size of the padded u32 view of a u8 column and
+ * the rule every GPU-bound array satisfies (design sections 5.7 and 10.2).
+ * @param byteLength - a non-negative byte count
+ * @returns roundUp(byteLength, 4)
+ */
+export function padTo4(byteLength) {
+    return roundUp(byteLength, 4);
+}
+/**
+ * The number of u32 words that span a byte range: ceil(byteLength / 4) (design section 10.2).
+ * @param byteLength - a non-negative byte count
+ * @returns the word count of the padded u32 view
+ */
+export function paddedWordCount(byteLength) {
+    return Math.ceil(byteLength / 4);
+}
+/**
+ * Align a byte offset up to the next arena segment boundary (design section 10.3; 256 bytes, the
+ * WebGPU minStorageBufferOffsetAlignment default).
+ * @param byteOffset - a non-negative byte offset
+ * @param alignment - the alignment in bytes; defaults to ALIGNMENT (256)
+ * @returns roundUp(byteOffset, alignment)
+ */
+export function alignUp(byteOffset, alignment = ALIGNMENT) {
+    return roundUp(byteOffset, alignment);
+}
+/**
+ * Lay out segments back to back, each non-empty one starting at a multiple of `alignment`, in the
+ * given order (design section 10.3: hot to cold). Zero-length segments get a null offset and occupy
+ * nothing, which is how an absent `weights`, a zero-arc `colIdx` and an identity permutation stay out
+ * of the arena. For the worked example of section 10.3 (400,004 / 8,000,000 / 8,000,000 / 8,000,000 /
+ * 4,000,000) the offsets are 0 / 400,128 / 8,400,128 / 16,400,128 / 24,400,128 and the total is
+ * 28,400,128 with 124 bytes of padding.
+ * @param byteLengths - the unpadded byte length of every segment in arena order (0 = absent)
+ * @param alignment - the segment alignment in bytes; defaults to ALIGNMENT (256)
+ * @returns the offsets, ends, total byte length and padding of the layout
+ */
+export function layoutSegments(byteLengths, alignment = ALIGNMENT) {
+    const offsets = [];
+    const ends = [];
+    let cursor = 0;
+    let padding = 0;
+    for (const byteLength of byteLengths) {
+        if (byteLength === 0) {
+            offsets.push(null);
+            ends.push(null);
+            continue;
+        }
+        const offset = alignUp(cursor, alignment);
+        padding += offset - cursor;
+        offsets.push(offset);
+        cursor = offset + byteLength;
+        ends.push(cursor);
+    }
+    return { offsets, ends, byteLength: cursor, padding };
+}
+// ============================================================ 4-byte rules and adoption (I10, 5.7)
+/**
+ * The I10 predicate for a GPU-bound array: a view whose byteOffset and byteLength are both multiples
+ * of 4 (design section 10.2).
+ * @param view - any ArrayBufferView
+ * @returns true when both byteOffset and byteLength are multiples of 4
+ */
+export function isFourByteAligned(view) {
+    return view.byteOffset % 4 === 0 && view.byteLength % 4 === 0;
+}
+/**
+ * The "plain ArrayBuffer" half of invariant I10 (decision D-SAB, design section 9.4): the view's
+ * buffer is an `ArrayBuffer` that is neither a `SharedArrayBuffer` nor resizable, so its bytes are a
+ * `BufferSource` for `GPUQueue.writeBuffer`, transferable, and of fixed length for the life of the
+ * snapshot (invariant I17).
+ * @param view - any ArrayBufferView
+ * @returns true when the buffer is a plain, fixed-length ArrayBuffer
+ */
+export function isOverPlainBuffer(view) {
+    const { buffer } = view;
+    return buffer instanceof ArrayBuffer && !buffer.resizable;
+}
+/**
+ * The u8 adoption predicate of design section 5.7: "a zero-copy padded Uint32Array view is
+ * constructible", i.e. `byteOffset % 4 === 0 && byteOffset + roundUp(byteLength, 4) <=
+ * buffer.byteLength`.
+ * @param data - the u8 array a column would adopt
+ * @returns true when paddedU32View(data) can be built without copying
+ */
+export function canViewAsPaddedU32(data) {
+    return data.byteOffset % 4 === 0 && data.byteOffset + padTo4(data.byteLength) <= data.buffer.byteLength;
+}
+/**
+ * The zero-copy Uint32Array of ceil(byteLength / 4) words over a u8 array's own byte range (design
+ * sections 5.7 and 10.2); the trailing lanes of the last word are whatever the buffer holds there.
+ * @param data - a u8 array satisfying canViewAsPaddedU32()
+ * @returns the padded u32 view; E_COLUMN_ALIGNMENT when the view is not constructible
+ */
+export function paddedU32View(data) {
+    if (!canViewAsPaddedU32(data)) {
+        throw new GraphFormatError("E_COLUMN_ALIGNMENT", `u8 array at byteOffset ${data.byteOffset} with byteLength ${data.byteLength} has no zero-copy padded u32 view`, { byteOffset: data.byteOffset, byteLength: data.byteLength, bufferByteLength: data.buffer.byteLength });
+    }
+    return new Uint32Array(data.buffer, data.byteOffset, paddedWordCount(data.byteLength));
+}
+/**
+ * Copy a u8 array into a fresh store over which the padded u32 view is constructible: a new
+ * ArrayBuffer of roundUp(length, 4) bytes viewed at offset 0 with the original length (design section
+ * 5.7, the `adopt: "copy"` path). The padding bytes are zero.
+ * @param data - the u8 array to copy
+ * @returns a new U8 of the same length whose store satisfies canViewAsPaddedU32()
+ */
+export function copyToPaddedStore(data) {
+    const store = new Uint8Array(new ArrayBuffer(padTo4(data.byteLength)), 0, data.byteLength);
+    store.set(data);
+    return store;
+}
+/**
+ * Throw E_UNSUPPORTED for a dtype value outside the union; the `default` branch of every dtype switch
+ * (design section 13.4) calls this so an unknown dtype coming from untrusted data fails loudly. Always
+ * throws.
+ * @param dtype - the value that reached the default branch
+ */
+export function unsupportedDtype(dtype) {
+    throw new GraphFormatError("E_UNSUPPORTED", `unsupported dtype ${String(dtype)}`, { dtype });
+}
+/**
+ * The typed-array class that stores a flat dtype (design section 5.1): Float32Array for f32,
+ * Float64Array for f64, Int32Array for i32, Uint8Array for u8, and Uint32Array for u32, for the packed
+ * words of bool and for the codes of dict.
+ * @param dtype - a flat dtype
+ * @returns the constructor; E_UNSUPPORTED for an unknown dtype
+ */
+export function typedArrayCtorOf(dtype) {
+    switch (dtype) {
+        case "f32":
+            return Float32Array;
+        case "f64":
+            return Float64Array;
+        case "i32":
+            return Int32Array;
+        case "u8":
+            return Uint8Array;
+        case "u32":
+        case "bool":
+        case "dict":
+            return Uint32Array;
+        default:
+            return unsupportedDtype(dtype);
+    }
+}
+// ============================================================ staging growth
+/**
+ * The next staging capacity, in elements, that holds at least `needed`: doubling from `current`,
+ * rounded up to STAGING_ELEMENT_GRANULE (design section 6.2). A capacity of 0 grows to the granule.
+ * @param current - the present capacity in elements
+ * @param needed - the minimum capacity required
+ * @returns the new capacity, >= needed, >= 2 * current, a multiple of 16
+ */
+export function growCapacity(current, needed) {
+    return roundUp(Math.max(needed, current * 2, STAGING_ELEMENT_GRANULE), STAGING_ELEMENT_GRANULE);
+}
+/**
+ * The byte length of a staging backing buffer for `capacity` elements of `bytesPerElement` bytes each:
+ * rounded up to STAGING_BYTE_GRANULE (design section 6.2). Because every element size divides 64 the
+ * result is always a whole number of elements.
+ * @param capacity - the capacity in elements
+ * @param bytesPerElement - the element size in bytes (1, 4 or 8)
+ * @returns the buffer byte length, a multiple of 64
+ */
+export function stagingByteLength(capacity, bytesPerElement) {
+    return roundUp(capacity * bytesPerElement, STAGING_BYTE_GRANULE);
+}
+/**
+ * Allocate a staging buffer of `byteLength` bytes. With `resizable` true the buffer is created with a
+ * `maxByteLength` of at least `reserveBytes` (and at least `byteLength`) so it can later grow in place;
+ * should the engine refuse that reservation with a RangeError (an address-space limit, not a missing
+ * capability) the buffer is created resizable with `maxByteLength === byteLength`, which simply means
+ * its next growth reallocates. With `resizable` false a plain fixed-length buffer is returned.
+ * @param byteLength - the initial byte length
+ * @param resizable - whether to create a resizable buffer; defaults to HAS_RESIZABLE_ARRAY_BUFFER
+ * @param reserveBytes - the address space to reserve for in-place growth; defaults to STAGING_RESERVE_BYTES
+ * @returns the new buffer
+ */
+export function allocateStagingBuffer(byteLength, resizable = HAS_RESIZABLE_ARRAY_BUFFER, reserveBytes = STAGING_RESERVE_BYTES) {
+    if (!resizable) {
+        return new ArrayBuffer(byteLength);
+    }
+    const maxByteLength = Math.max(byteLength, reserveBytes);
+    try {
+        return new ArrayBuffer(byteLength, { maxByteLength });
+    }
+    catch (err) {
+        if (err instanceof RangeError && maxByteLength > byteLength) {
+            return new ArrayBuffer(byteLength, { maxByteLength: byteLength });
+        }
+        throw err;
+    }
+}
+/**
+ * Grow a staging array so it holds at least `minLength` elements, preserving its contents (design
+ * section 6.2). When the array is the leading view of a resizable buffer with room left, the buffer is
+ * resized in place and no bytes move; otherwise a new buffer is allocated (resizable per `resizable`,
+ * with a reservation of at least twice the old one so repeated overflow stays amortised) and the
+ * contents copied. Either way the returned array is a fresh view object of exactly the new capacity;
+ * the caller replaces its reference. Elements beyond the old length are zero on the copy path and on a
+ * freshly resized region.
+ * @param array - the current staging array, viewed from byteOffset 0 of its buffer
+ * @param ctor - the array's constructor
+ * @param minLength - the minimum element count required
+ * @param resizable - whether new buffers are resizable; defaults to HAS_RESIZABLE_ARRAY_BUFFER
+ * @returns a view of growCapacity(array.length, minLength) elements holding the old contents
+ */
+export function growTypedArray(array, ctor, minLength, resizable = HAS_RESIZABLE_ARRAY_BUFFER) {
+    if (minLength <= array.length) {
+        return array;
+    }
+    const bytesPerElement = ctor.BYTES_PER_ELEMENT;
+    const byteLength = stagingByteLength(growCapacity(array.length, minLength), bytesPerElement);
+    const capacity = byteLength / bytesPerElement;
+    const { buffer } = array;
+    if (buffer.resizable && array.byteOffset === 0 && byteLength <= buffer.maxByteLength) {
+        buffer.resize(byteLength);
+        return new ctor(buffer, 0, capacity);
+    }
+    const reserve = Math.max(buffer.maxByteLength * 2, STAGING_RESERVE_BYTES);
+    const next = new ctor(allocateStagingBuffer(byteLength, resizable, reserve), 0, capacity);
+    next.set(array);
+    return next;
+}
+//# sourceMappingURL=typed-array.js.map

package/dist/src/util/typed-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array.js","sourceRoot":"","sources":["../../../src/util/typed-array.ts"],"names":[],"mappings":"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"}

package/dist/src/wire/bytes.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The GSNP byte container (design section 9.2): `toBytes()` writes one contiguous buffer,
+ * `toByteChunks()` the same bytes as a sequence (header + manifest, then every 256-padded segment
+ * in manifest order), `fromBytes()` adopts a container's buffer region as the arena and
+ * `fromByteChunks()` adopts each chunk's buffer per segment. The snapshot's `toBytes` /
+ * `toByteChunks` methods call the functions of this module directly.
+ *
+ * Layout, all integers little-endian:
+ *
+ * ```
+ * offset  size   field
+ * 0       4      magic "GSNP"
+ * 4       2      wire major (u16)
+ * 6       2      wire minor (u16)
+ * 8       4      endianness probe: 0x01020304 written through a host-order Uint32Array
+ * 12      4      manifest byte length L (u32)
+ * 16      L      manifest: UTF-8 JSON of the WireManifest, every reference into buffer 0 with a
+ *                region-relative byteOffset
+ * 16+L    pad    zero padding to the next multiple of 256
+ * B       ...    buffer region: each array at a 256-aligned offset in manifest order, core arrays
+ *                first so the region's prefix is the arena; every segment padded to 256 bytes
+ * ```
+ *
+ * The reader refuses a bad magic, an unexpected probe, a truncated header or manifest, a manifest
+ * whose versions disagree with the header (E_BAD_SERIALIZATION), an unknown wire major
+ * (E_UNSUPPORTED_VERSION) and everything the manifest reader of from-wire.ts refuses.
+ */
+import { type GraphSnapshot } from "../snapshot/graph-snapshot.js";
+import { type FromWireOptions, type ToBytesOptions, type U8 } from "../types/index.js";
+/** Bytes before the manifest: magic, major, minor, probe and manifest length. */
+export declare const CONTAINER_HEADER_BYTES = 16;
+/**
+ * The GSNP container of a snapshot as one contiguous buffer (design section 9.2).
+ * @param snapshot - the snapshot
+ * @param options - the cached views to carry
+ * @returns the container bytes at offset 0 of a fresh ArrayBuffer; E_UNSUPPORTED on a big-endian host
+ */
+export declare function toBytes(snapshot: GraphSnapshot, options?: ToBytesOptions): U8;
+/**
+ * The GSNP container as a sequence of chunks whose concatenation equals `toBytes()` (design section
+ * 9.2): the header + manifest padded to 256, then each non-empty segment padded to 256, in manifest
+ * order. The layout is computed when this function is called; the chunk copies are made lazily.
+ * @param snapshot - the snapshot
+ * @param options - the cached views to carry
+ * @returns the chunks; E_UNSUPPORTED on a big-endian host
+ */
+export declare function toByteChunks(snapshot: GraphSnapshot, options?: ToBytesOptions): Iterable<U8>;
+/**
+ * Rebuild a snapshot from a GSNP container (design section 9.2). Defaults: `validate: "full"` and
+ * `copy: false`. The buffer region is adopted as the arena when the container is a plain
+ * ArrayBuffer viewed at a byteOffset that is a multiple of 8 (so f64 segments align); a
+ * SharedArrayBuffer, an odd offset or `copy: true` take the copy path into a fresh 256-aligned
+ * buffer.
+ * @param bytes - the container: a Uint8Array, an ArrayBuffer or a SharedArrayBuffer
+ * @param options - validation level, copy and unknown-column policy
+ * @returns the snapshot; E_BAD_SERIALIZATION / E_UNSUPPORTED_VERSION / E_UNSUPPORTED / E_INVALID_SNAPSHOT on bad input
+ */
+export declare function fromBytes(bytes: Uint8Array | ArrayBufferLike, options?: FromWireOptions): GraphSnapshot;
+/**
+ * Rebuild a snapshot from the chunks `toByteChunks()` produced (or any split of a container's
+ * bytes): each segment is adopted as a view into the chunk that holds it (a segment spanning two
+ * chunks, or one in a SharedArrayBuffer, is copied) and the snapshot has `arena === null` (design
+ * section 9.2). Defaults: `validate: "full"`, `copy: false`.
+ * @param chunks - the chunks in order
+ * @param options - validation level, copy and unknown-column policy
+ * @returns the snapshot
+ */
+export declare function fromByteChunks(chunks: Iterable<Uint8Array>, options?: FromWireOptions): GraphSnapshot;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/src/wire/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../../src/wire/bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAuB,KAAK,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAiB5G,iFAAiF;AACjF,eAAO,MAAM,sBAAsB,KAAK,CAAC;AA2DzC;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,GAAE,cAAmB,GAAG,EAAE,CASjF;AAuBD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,GAAE,cAAmB,GAAG,QAAQ,CAAC,EAAE,CAAC,CAEhG;AAuGD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,eAAe,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,aAAa,CAsBvG;AA6HD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,aAAa,CAcrG"}