@bradensbay/globals-core 0.2.0

package/dist/src/tags.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Value tags.
+ *
+ * A slot is eight bytes, two 32 bit words: a tag word and a payload word. Small integers
+ * and the singletons live entirely in the slot. Everything else stores a byte offset into
+ * the arena, which is why every decode has to bounds check before it dereferences.
+ */
+export declare const Tag: {
+    /** No payload. */
+    readonly Undefined: 0;
+    /** No payload. */
+    readonly Null: 1;
+    /** No payload. */
+    readonly False: 2;
+    /** No payload. */
+    readonly True: 3;
+    /** Payload is the value itself, in the signed 32 bit range. */
+    readonly Int32: 4;
+    /** Payload is the byte offset of an eight byte float64. */
+    readonly Double: 5;
+    /** Payload is the byte offset of an interned string record. */
+    readonly String: 6;
+    /** Payload is the byte offset of a HAMT root. Added by the object layer. */
+    readonly Object: 7;
+    /** Payload is the byte offset of a vector header. Added by the object layer. */
+    readonly Array: 8;
+    /** Payload is the byte offset of a HAMT root with arbitrary keys. */
+    readonly Map: 9;
+    /** Payload is the byte offset of a HAMT root used as a set. */
+    readonly Set: 10;
+    /** Payload is the byte offset of an eight byte float64 holding epoch milliseconds. */
+    readonly Date: 11;
+    /** Payload is the byte offset of a two word record: source string, flags string. */
+    readonly RegExp: 12;
+    /** Payload is the byte offset of a length prefixed little endian byte sequence. */
+    readonly BigInt: 13;
+    /** Payload is the byte offset of a kind, length, and byte payload record. */
+    readonly TypedArray: 14;
+    /** Payload is a handle into the asynchronous tier. */
+    readonly External: 15;
+};
+export type TagValue = (typeof Tag)[keyof typeof Tag];
+export declare function tagName(tag: number): string;
+export declare function isKnownTag(tag: number): tag is TagValue;
+/** Tags whose payload is a byte offset that must be bounds checked before use. */
+export declare function payloadIsOffset(tag: number): boolean;
+//# sourceMappingURL=tags.d.ts.map

package/dist/src/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../src/tags.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,GAAG;IACd,kBAAkB;aAClB,SAAS,EAAE,CAAC;IACZ,kBAAkB;aAClB,IAAI,EAAE,CAAC;IACP,kBAAkB;aAClB,KAAK,EAAE,CAAC;IACR,kBAAkB;aAClB,IAAI,EAAE,CAAC;IACP,+DAA+D;aAC/D,KAAK,EAAE,CAAC;IACR,2DAA2D;aAC3D,MAAM,EAAE,CAAC;IACT,+DAA+D;aAC/D,MAAM,EAAE,CAAC;IACT,4EAA4E;aAC5E,MAAM,EAAE,CAAC;IACT,gFAAgF;aAChF,KAAK,EAAE,CAAC;IACR,qEAAqE;aACrE,GAAG,EAAE,CAAC;IACN,+DAA+D;aAC/D,GAAG,EAAE,EAAE;IACP,sFAAsF;aACtF,IAAI,EAAE,EAAE;IACR,oFAAoF;aACpF,MAAM,EAAE,EAAE;IACV,mFAAmF;aACnF,MAAM,EAAE,EAAE;IACV,6EAA6E;aAC7E,UAAU,EAAE,EAAE;IACd,sDAAsD;aACtD,QAAQ,EAAE,EAAE;CACJ,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC;AAMtD,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,QAAQ,CAEvD;AAED,kFAAkF;AAClF,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEpD"}

package/dist/src/tags.js

@@ -0,0 +1,53 @@
+/**
+ * Value tags.
+ *
+ * A slot is eight bytes, two 32 bit words: a tag word and a payload word. Small integers
+ * and the singletons live entirely in the slot. Everything else stores a byte offset into
+ * the arena, which is why every decode has to bounds check before it dereferences.
+ */
+export const Tag = {
+    /** No payload. */
+    Undefined: 0,
+    /** No payload. */
+    Null: 1,
+    /** No payload. */
+    False: 2,
+    /** No payload. */
+    True: 3,
+    /** Payload is the value itself, in the signed 32 bit range. */
+    Int32: 4,
+    /** Payload is the byte offset of an eight byte float64. */
+    Double: 5,
+    /** Payload is the byte offset of an interned string record. */
+    String: 6,
+    /** Payload is the byte offset of a HAMT root. Added by the object layer. */
+    Object: 7,
+    /** Payload is the byte offset of a vector header. Added by the object layer. */
+    Array: 8,
+    /** Payload is the byte offset of a HAMT root with arbitrary keys. */
+    Map: 9,
+    /** Payload is the byte offset of a HAMT root used as a set. */
+    Set: 10,
+    /** Payload is the byte offset of an eight byte float64 holding epoch milliseconds. */
+    Date: 11,
+    /** Payload is the byte offset of a two word record: source string, flags string. */
+    RegExp: 12,
+    /** Payload is the byte offset of a length prefixed little endian byte sequence. */
+    BigInt: 13,
+    /** Payload is the byte offset of a kind, length, and byte payload record. */
+    TypedArray: 14,
+    /** Payload is a handle into the asynchronous tier. */
+    External: 15,
+};
+const NAMES = Object.fromEntries(Object.entries(Tag).map(([name, value]) => [value, name]));
+export function tagName(tag) {
+    return NAMES[tag] ?? `unknown(${tag})`;
+}
+export function isKnownTag(tag) {
+    return tag >= Tag.Undefined && tag <= Tag.External;
+}
+/** Tags whose payload is a byte offset that must be bounds checked before use. */
+export function payloadIsOffset(tag) {
+    return tag >= Tag.Double && tag <= Tag.TypedArray;
+}
+//# sourceMappingURL=tags.js.map

package/dist/src/tags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.js","sourceRoot":"","sources":["../../src/tags.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,kBAAkB;IAClB,SAAS,EAAE,CAAC;IACZ,kBAAkB;IAClB,IAAI,EAAE,CAAC;IACP,kBAAkB;IAClB,KAAK,EAAE,CAAC;IACR,kBAAkB;IAClB,IAAI,EAAE,CAAC;IACP,+DAA+D;IAC/D,KAAK,EAAE,CAAC;IACR,2DAA2D;IAC3D,MAAM,EAAE,CAAC;IACT,+DAA+D;IAC/D,MAAM,EAAE,CAAC;IACT,4EAA4E;IAC5E,MAAM,EAAE,CAAC;IACT,gFAAgF;IAChF,KAAK,EAAE,CAAC;IACR,qEAAqE;IACrE,GAAG,EAAE,CAAC;IACN,+DAA+D;IAC/D,GAAG,EAAE,EAAE;IACP,sFAAsF;IACtF,IAAI,EAAE,EAAE;IACR,oFAAoF;IACpF,MAAM,EAAE,EAAE;IACV,mFAAmF;IACnF,MAAM,EAAE,EAAE;IACV,6EAA6E;IAC7E,UAAU,EAAE,EAAE;IACd,sDAAsD;IACtD,QAAQ,EAAE,EAAE;CACJ,CAAC;AAIX,MAAM,KAAK,GAA2B,MAAM,CAAC,WAAW,CACtD,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAC1D,CAAC;AAEF,MAAM,UAAU,OAAO,CAAC,GAAW;IACjC,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,WAAW,GAAG,GAAG,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,GAAW;IACpC,OAAO,GAAG,IAAI,GAAG,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC;AACrD,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC;AACpD,CAAC"}

package/dist/src/values.d.ts

@@ -0,0 +1,90 @@
+import type { SharedArena } from "./arena.js";
+import type { Allocator } from "./allocator.js";
+import type { StringTable } from "./strings.js";
+import { type HamtContext } from "./hamt.js";
+/** A tagged eight byte slot, as a pair of 32 bit words. */
+export interface Slot {
+    readonly tag: number;
+    readonly payload: number;
+}
+export declare const UNDEFINED_SLOT: Slot;
+export declare const NULL_SLOT: Slot;
+export declare const TRUE_SLOT: Slot;
+/** Typed array kinds, by index. The index is stored, so this list is append only. */
+export declare const TYPED_ARRAY_KINDS: readonly ["Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array"];
+export type TypedArrayKind = (typeof TYPED_ARRAY_KINDS)[number];
+/**
+ * An opaque handle into the asynchronous tier.
+ *
+ * Values that cannot be encoded are reached through a visibly different API rather than
+ * throwing at some later point. The boundary between synchronous and asynchronous is meant
+ * to be legible in the calling code, not a runtime surprise.
+ */
+export declare class ExternalRef {
+    readonly handle: number;
+    constructor(handle: number);
+    toJSON(): {
+        external: number;
+    };
+}
+export interface EncodeContext extends HamtContext {
+    readonly arena: SharedArena;
+    readonly allocator: Allocator;
+    readonly strings: StringTable;
+    /** Blocks the encoder allocated, so a failed commit can release them. */
+    readonly allocated: number[];
+    /** Nodes replaced on a copied path, retired when the superseded version is unreadable. */
+    readonly retired: number[];
+    /** Strings this commit newly interned, so a rejected commit can release them. */
+    readonly interned: string[];
+    /** The bump pointer before this commit, so a rejected commit can rewind to it. */
+    readonly bumpBefore: number;
+}
+export declare function encodeNumber(context: EncodeContext, value: number): Slot;
+export declare function encodeString(context: EncodeContext, value: string): Slot;
+/**
+ * Encode a value into a slot.
+ *
+ * Containers are built from the bottom up, so a partially built structure is never
+ * reachable from a published root. Anything outside the ladder raises
+ * UnencodableValueError, which is the boundary the asynchronous tier exists to cover.
+ */
+export declare function encodeValue(context: EncodeContext, value: unknown): Slot;
+/**
+ * A budget for one whole decode, measured in units of output rather than in calls.
+ *
+ * Counting calls is not enough, and the reason is worth writing down because it is the same
+ * shape as several bugs above. The depth bound and the per node budgets are all per call. A
+ * correct structure is a tree, but a corrupt one can be a graph, and a graph materialises a
+ * shared subtree once per reference. A trie whose entries all point at one large string
+ * record decodes that string once per entry: a few thousand references to a hundred kilobyte
+ * record is a gigabyte of output from a quarter megabyte arena.
+ *
+ * Note that this is not purely a corruption problem. A correct arena can do it too, because
+ * interned strings are shared in the arena and materialised separately by an eager decode.
+ * A structure with a thousand references to one long string legitimately decodes to a
+ * thousand copies. So the budget is generous rather than tight: it exists to turn an
+ * unbounded decode into a typed error, not to second guess a caller who really does want
+ * their data.
+ *
+ * The lazy read path has none of this to worry about, because it decodes what is touched.
+ */
+interface DecodeBudget {
+    remaining: number;
+}
+export declare function decodeValue(arena: SharedArena, slot: Slot, depth?: number, budget?: DecodeBudget): unknown;
+/**
+ * Every block reachable from a slot, for retiring a structure the writer is replacing
+ * outright.
+ *
+ * Interned strings are deliberately absent. They are shared between versions and freed only
+ * when the arena is discarded, which is the documented cost of interning.
+ *
+ * This is the wholesale path. A targeted update collects retired nodes from the path copies
+ * it performs, which is bounded rather than proportional to the structure.
+ */
+export declare function collectBlocks(arena: SharedArena, slot: Slot, out?: number[]): number[];
+/** The element or entry count of a container, without materialising it. */
+export declare function containerSize(arena: SharedArena, slot: Slot): number;
+export {};
+//# sourceMappingURL=values.d.ts.map

package/dist/src/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../src/values.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAKhD,OAAO,EAQL,KAAK,WAAW,EACjB,MAAM,WAAW,CAAC;AASnB,2DAA2D;AAC3D,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,cAAc,EAAE,IAAyC,CAAC;AACvE,eAAO,MAAM,SAAS,EAAE,IAAoC,CAAC;AAC7D,eAAO,MAAM,SAAS,EAAE,IAAoC,CAAC;AAE7D,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,YAC5B,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,CACR,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AA8BhE;;;;;;GAMG;AACH,qBAAa,WAAW;IACV,QAAQ,CAAC,MAAM,EAAE,MAAM;IAAnC,YAAqB,MAAM,EAAE,MAAM,EAAI;IACvC,MAAM,IAAI;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAE7B;CACF;AAED,MAAM,WAAW,aAAc,SAAQ,WAAW;IAChD,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC5B,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAYD,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAOxE;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAKxE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAuCxE;AA0ID;;;;;;;;;;;;;;;;;;GAkBG;AACH,UAAU,YAAY;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAiBD,wBAAgB,WAAW,CACzB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,IAAI,EACV,KAAK,SAAI,EACT,MAAM,GAAE,YAA+B,GACtC,OAAO,CA0ET;AAqGD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,GAAE,MAAM,EAAO,GAAG,MAAM,EAAE,CA+B1F;AAED,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAWpE"}

package/dist/src/values.js

@@ -0,0 +1,458 @@
+import { decodeString } from "./strings.js";
+import { ArenaCorruptError, UnencodableValueError } from "./errors.js";
+import { Tag, isKnownTag, tagName } from "./tags.js";
+import { WORD } from "./layout.js";
+import { EMPTY_NODE, emptyNode, hamtAssoc, hamtEntries, hamtNodes, hamtSize, keyHash, } from "./hamt.js";
+import { EMPTY_VECTOR, vectorFromSlots, vectorLength, vectorNodes, vectorSlots, } from "./vector.js";
+export const UNDEFINED_SLOT = { tag: Tag.Undefined, payload: 0 };
+export const NULL_SLOT = { tag: Tag.Null, payload: 0 };
+export const TRUE_SLOT = { tag: Tag.True, payload: 0 };
+/** Typed array kinds, by index. The index is stored, so this list is append only. */
+export const TYPED_ARRAY_KINDS = [
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt64Array",
+    "BigUint64Array",
+];
+const TYPED_ARRAY_ELEMENT_BYTES = {
+    Int8Array: 1,
+    Uint8Array: 1,
+    Uint8ClampedArray: 1,
+    Int16Array: 2,
+    Uint16Array: 2,
+    Int32Array: 4,
+    Uint32Array: 4,
+    Float32Array: 4,
+    Float64Array: 8,
+    BigInt64Array: 8,
+    BigUint64Array: 8,
+};
+const TYPED_ARRAY_CONSTRUCTORS = {
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    BigInt64Array,
+    BigUint64Array,
+};
+/**
+ * An opaque handle into the asynchronous tier.
+ *
+ * Values that cannot be encoded are reached through a visibly different API rather than
+ * throwing at some later point. The boundary between synchronous and asynchronous is meant
+ * to be legible in the calling code, not a runtime surprise.
+ */
+export class ExternalRef {
+    handle;
+    constructor(handle) {
+        this.handle = handle;
+    }
+    toJSON() {
+        return { external: this.handle };
+    }
+}
+function isInt32(value) {
+    return Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+}
+function allocate(context, bytes) {
+    const offset = context.allocator.allocate(bytes);
+    context.allocated.push(offset);
+    return offset;
+}
+export function encodeNumber(context, value) {
+    // Negative zero has to take the double path. Encoded as an int32 it would read back as
+    // positive zero, and Object.is would disagree with the value that went in.
+    if (isInt32(value) && !Object.is(value, -0))
+        return { tag: Tag.Int32, payload: value };
+    const offset = allocate(context, 8);
+    context.arena.floats[offset / 8] = value;
+    return { tag: Tag.Double, payload: offset };
+}
+export function encodeString(context, value) {
+    // Interned, so the offset may be one the table already held. It goes on the interning
+    // journal rather than the allocated list: a rollback must release only the records this
+    // commit created, never one an earlier version already references.
+    return { tag: Tag.String, payload: context.strings.intern(value, context.interned) };
+}
+/**
+ * Encode a value into a slot.
+ *
+ * Containers are built from the bottom up, so a partially built structure is never
+ * reachable from a published root. Anything outside the ladder raises
+ * UnencodableValueError, which is the boundary the asynchronous tier exists to cover.
+ */
+export function encodeValue(context, value) {
+    switch (typeof value) {
+        case "undefined":
+            return UNDEFINED_SLOT;
+        case "boolean":
+            return { tag: value ? Tag.True : Tag.False, payload: 0 };
+        case "number":
+            return encodeNumber(context, value);
+        case "string":
+            return encodeString(context, value);
+        case "bigint":
+            return encodeBigInt(context, value);
+        case "symbol":
+            throw new UnencodableValueError(value, "symbols have no cross process identity");
+        case "function":
+            throw new UnencodableValueError(value, "functions cannot cross a process boundary");
+        case "object":
+            break;
+        default:
+            throw new UnencodableValueError(value, `unsupported typeof result ${typeof value}`);
+    }
+    if (value === null)
+        return NULL_SLOT;
+    if (value instanceof ExternalRef)
+        return { tag: Tag.External, payload: value.handle };
+    if (value instanceof Date)
+        return encodeDate(context, value);
+    if (value instanceof RegExp)
+        return encodeRegExp(context, value);
+    if (Array.isArray(value))
+        return encodeArray(context, value);
+    if (value instanceof Map)
+        return encodeMap(context, value);
+    if (value instanceof Set)
+        return encodeSet(context, value);
+    if (ArrayBuffer.isView(value))
+        return encodeTypedArray(context, value);
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new UnencodableValueError(value, "only plain objects are encodable, a class instance loses its prototype and its identity");
+    }
+    return encodeObject(context, value);
+}
+function encodeDate(context, value) {
+    const offset = allocate(context, 8);
+    context.arena.floats[offset / 8] = value.getTime();
+    return { tag: Tag.Date, payload: offset };
+}
+function encodeRegExp(context, value) {
+    const source = context.strings.intern(value.source, context.interned);
+    const flags = context.strings.intern(value.flags, context.interned);
+    const offset = allocate(context, 2 * WORD);
+    context.arena.words[offset / WORD] = source;
+    context.arena.words[offset / WORD + 1] = flags;
+    return { tag: Tag.RegExp, payload: offset };
+}
+function encodeBigInt(context, value) {
+    const negative = value < 0n;
+    let magnitude = negative ? -value : value;
+    const digits = [];
+    while (magnitude > 0n) {
+        digits.push(Number(magnitude & 0xffn));
+        magnitude >>= 8n;
+    }
+    const offset = allocate(context, 2 * WORD + Math.max(digits.length, 1));
+    const words = context.arena.words;
+    words[offset / WORD] = negative ? 1 : 0;
+    words[offset / WORD + 1] = digits.length;
+    const bytes = context.arena.bytes;
+    for (let i = 0; i < digits.length; i += 1)
+        bytes[offset + 2 * WORD + i] = digits[i];
+    return { tag: Tag.BigInt, payload: offset };
+}
+function encodeTypedArray(context, value) {
+    const kind = value.constructor.name;
+    const kindIndex = TYPED_ARRAY_KINDS.indexOf(kind);
+    if (kindIndex === -1) {
+        throw new UnencodableValueError(value, `${kind} is not on the typed array ladder`);
+    }
+    const source = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    const offset = allocate(context, 2 * WORD + Math.max(value.byteLength, 1));
+    const words = context.arena.words;
+    words[offset / WORD] = kindIndex;
+    words[offset / WORD + 1] = value.byteLength;
+    context.arena.bytes.set(source, offset + 2 * WORD);
+    return { tag: Tag.TypedArray, payload: offset };
+}
+function encodeArray(context, value) {
+    const slots = value.map((element) => encodeValue(context, element));
+    return { tag: Tag.Array, payload: vectorFromSlots(context, slots) };
+}
+function encodeObject(context, value) {
+    let node = emptyNode(context);
+    for (const key of Object.keys(value)) {
+        const keySlot = encodeString(context, key);
+        const valueSlot = encodeValue(context, value[key]);
+        node = hamtAssoc(context, node, keySlot, keyHash(context.arena, keySlot), valueSlot);
+    }
+    return { tag: Tag.Object, payload: node };
+}
+function encodeMap(context, value) {
+    let node = emptyNode(context);
+    for (const [key, entry] of value) {
+        const keySlot = encodeValue(context, key);
+        assertKeyable(keySlot, key);
+        node = hamtAssoc(context, node, keySlot, keyHash(context.arena, keySlot), encodeValue(context, entry));
+    }
+    return { tag: Tag.Map, payload: node };
+}
+function encodeSet(context, value) {
+    let node = emptyNode(context);
+    for (const member of value) {
+        const keySlot = encodeValue(context, member);
+        assertKeyable(keySlot, member);
+        node = hamtAssoc(context, node, keySlot, keyHash(context.arena, keySlot), TRUE_SLOT);
+    }
+    return { tag: Tag.Set, payload: node };
+}
+/**
+ * Keys have to be comparable by their slot, so a container cannot be one.
+ *
+ * Object identity does not survive a process boundary, so a map keyed on an object would be
+ * a map nobody could look anything up in. Rejecting it is better than encoding it into
+ * something that silently never matches.
+ */
+function assertKeyable(slot, original) {
+    const keyable = slot.tag === Tag.String ||
+        slot.tag === Tag.Int32 ||
+        slot.tag === Tag.Double ||
+        slot.tag === Tag.True ||
+        slot.tag === Tag.False ||
+        slot.tag === Tag.Null ||
+        slot.tag === Tag.Undefined;
+    if (!keyable) {
+        throw new UnencodableValueError(original, "map and set keys must be primitives, because object identity does not cross a process");
+    }
+}
+// ---------------------------------------------------------------------------
+// Decoding
+// ---------------------------------------------------------------------------
+/**
+ * Decode a slot eagerly, materialising the whole structure.
+ *
+ * Used by `toJSON`, by tests, and by any caller that wants a detached plain value. The lazy
+ * proxy path in snapshot-proxy.ts is what a render actually uses, because it decodes only
+ * the properties that are touched.
+ *
+ * Every branch that dereferences an offset validates it first. Any window mapping the arena
+ * can write a slot, so a wild offset is a reachable state rather than a bug that cannot
+ * happen.
+ */
+/**
+ * How deeply a decode will nest before it gives up.
+ *
+ * A corrupt offset can make a value contain itself, and that recursion is not covered by the
+ * depth bound inside a single trie: each level is a separate structure. Without this, a cycle
+ * across containers runs the stack out and produces a RangeError rather than a typed one.
+ */
+const MAX_DECODE_DEPTH = 512;
+/** Sixteen times the arena, and never less than a megabyte of output. */
+function newBudget(arena) {
+    return { remaining: Math.max(1 << 20, arena.byteLength * 16) };
+}
+function spend(budget, units) {
+    budget.remaining -= units;
+    if (budget.remaining >= 0)
+        return;
+    throw new ArenaCorruptError("decoding produced more output than the budget allows, which means the structure shares " +
+        "nodes far more heavily than its size can explain. Read through a snapshot view instead " +
+        "of materialising it, or raise the arena size if the data really is this shape.");
+}
+export function decodeValue(arena, slot, depth = 0, budget = newBudget(arena)) {
+    const { tag, payload } = slot;
+    if (depth > MAX_DECODE_DEPTH) {
+        throw new ArenaCorruptError(`decoding nested past ${MAX_DECODE_DEPTH} levels, which means a cycle`, { actual: depth });
+    }
+    spend(budget, 1);
+    if (!isKnownTag(tag)) {
+        throw new ArenaCorruptError(`slot carries an unknown tag ${tag}`, { actual: tag });
+    }
+    switch (tag) {
+        case Tag.Undefined:
+            return undefined;
+        case Tag.Null:
+            return null;
+        case Tag.False:
+            return false;
+        case Tag.True:
+            return true;
+        case Tag.Int32:
+            return payload;
+        case Tag.Double:
+            arena.checkBlock(payload, "double");
+            return arena.floats[payload / 8];
+        case Tag.String: {
+            const text = decodeString(arena, payload);
+            spend(budget, text.length);
+            return text;
+        }
+        case Tag.Date:
+            arena.checkBlock(payload, "date");
+            return new Date(arena.floats[payload / 8]);
+        case Tag.RegExp:
+            return decodeRegExp(arena, payload);
+        case Tag.BigInt: {
+            const value = decodeBigInt(arena, payload);
+            spend(budget, arena.checkBlock(payload, "bigint"));
+            return value;
+        }
+        case Tag.TypedArray: {
+            const view = decodeTypedArray(arena, payload);
+            spend(budget, view.byteLength);
+            return view;
+        }
+        case Tag.Object:
+            return decodeObject(arena, payload, depth, budget);
+        case Tag.Array:
+            return vectorSlots(arena, payload).map((element) => decodeValue(arena, element, depth + 1, budget));
+        case Tag.Map:
+            return new Map(hamtEntries(arena, payload).map((entry) => [
+                decodeValue(arena, entry.key, depth + 1, budget),
+                decodeValue(arena, entry.value, depth + 1, budget),
+            ]));
+        case Tag.Set:
+            return new Set(hamtEntries(arena, payload).map((entry) => decodeValue(arena, entry.key, depth + 1, budget)));
+        case Tag.External:
+            return new ExternalRef(payload);
+        default:
+            throw new ArenaCorruptError(`tag ${tagName(tag)} has no decoder`, { actual: tag });
+    }
+}
+function decodeObject(arena, node, depth, budget) {
+    const out = {};
+    for (const entry of hamtEntries(arena, node)) {
+        if (entry.key.tag !== Tag.String) {
+            throw new ArenaCorruptError("object key is not a string", { actual: entry.key.tag });
+        }
+        out[decodeString(arena, entry.key.payload)] = decodeValue(arena, entry.value, depth + 1, budget);
+    }
+    return out;
+}
+function decodeRegExp(arena, offset) {
+    const byteSize = arena.checkBlock(offset, "regexp");
+    if (byteSize < 2 * WORD) {
+        throw new ArenaCorruptError(`regexp record at ${offset} is too small`, { offset });
+    }
+    const source = decodeString(arena, arena.words[offset / WORD]);
+    const flags = decodeString(arena, arena.words[offset / WORD + 1]);
+    try {
+        return new RegExp(source, flags);
+    }
+    catch (error) {
+        throw new ArenaCorruptError(`regexp record at ${offset} does not describe a valid expression: ${error instanceof Error ? error.message : String(error)}`, { offset });
+    }
+}
+function decodeBigInt(arena, offset) {
+    const byteSize = arena.checkBlock(offset, "bigint");
+    const negative = arena.words[offset / WORD] === 1;
+    const length = arena.words[offset / WORD + 1];
+    if (length < 0 || 2 * WORD + length > byteSize) {
+        throw new ArenaCorruptError(`bigint at ${offset} claims ${length} bytes`, { offset });
+    }
+    if (length === 0)
+        return 0n;
+    // Built through a hex string rather than by shifting a BigInt one byte at a time. The
+    // shifting version allocates a new BigInt per byte, each one longer than the last, so it is
+    // quadratic in both time and allocation. A corrupt length of a quarter megabyte made it
+    // churn tens of gigabytes and take the process down, which the fuzzer found as an out of
+    // memory crash rather than as an error.
+    const bytes = arena.bytes;
+    const digits = new Array(length);
+    for (let i = 0; i < length; i += 1) {
+        digits[length - 1 - i] = bytes[offset + 2 * WORD + i].toString(16).padStart(2, "0");
+    }
+    const value = BigInt(`0x${digits.join("")}`);
+    return negative ? -value : value;
+}
+function decodeTypedArray(arena, offset) {
+    const byteSize = arena.checkBlock(offset, "typed array");
+    const kindIndex = arena.words[offset / WORD];
+    const byteLength = arena.words[offset / WORD + 1];
+    const kind = TYPED_ARRAY_KINDS[kindIndex];
+    if (kind === undefined) {
+        throw new ArenaCorruptError(`typed array at ${offset} has kind ${kindIndex}`, { offset });
+    }
+    if (byteLength < 0 || 2 * WORD + byteLength > byteSize) {
+        throw new ArenaCorruptError(`typed array at ${offset} claims ${byteLength} bytes`, { offset });
+    }
+    const Constructor = TYPED_ARRAY_CONSTRUCTORS[kind];
+    const elementBytes = TYPED_ARRAY_ELEMENT_BYTES[kind];
+    if (Constructor === undefined || elementBytes === undefined) {
+        throw new ArenaCorruptError(`typed array kind ${kind} is not constructible here`, { offset });
+    }
+    if (byteLength % elementBytes !== 0) {
+        throw new ArenaCorruptError(`typed array at ${offset} has ${byteLength} bytes, which is not a whole number of ` +
+            `${kind} elements`, { offset });
+    }
+    const result = new Constructor(byteLength / elementBytes);
+    new Uint8Array(result.buffer).set(arena.bytes.subarray(offset + 2 * WORD, offset + 2 * WORD + byteLength));
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Retirement
+// ---------------------------------------------------------------------------
+/**
+ * Every block reachable from a slot, for retiring a structure the writer is replacing
+ * outright.
+ *
+ * Interned strings are deliberately absent. They are shared between versions and freed only
+ * when the arena is discarded, which is the documented cost of interning.
+ *
+ * This is the wholesale path. A targeted update collects retired nodes from the path copies
+ * it performs, which is bounded rather than proportional to the structure.
+ */
+export function collectBlocks(arena, slot, out = []) {
+    // The writer only ever walks structures it built, so this needs no budget of its own. The
+    // walks it delegates to carry theirs.
+    switch (slot.tag) {
+        case Tag.Double:
+        case Tag.Date:
+        case Tag.RegExp:
+        case Tag.BigInt:
+        case Tag.TypedArray:
+            out.push(slot.payload);
+            return out;
+        case Tag.Object:
+        case Tag.Map:
+        case Tag.Set: {
+            if (slot.payload === EMPTY_NODE)
+                return out;
+            for (const entry of hamtEntries(arena, slot.payload)) {
+                collectBlocks(arena, entry.key, out);
+                collectBlocks(arena, entry.value, out);
+            }
+            hamtNodes(arena, slot.payload, out);
+            return out;
+        }
+        case Tag.Array: {
+            if (slot.payload === EMPTY_VECTOR)
+                return out;
+            for (const element of vectorSlots(arena, slot.payload))
+                collectBlocks(arena, element, out);
+            vectorNodes(arena, slot.payload, out);
+            return out;
+        }
+        default:
+            return out;
+    }
+}
+/** The element or entry count of a container, without materialising it. */
+export function containerSize(arena, slot) {
+    switch (slot.tag) {
+        case Tag.Object:
+        case Tag.Map:
+        case Tag.Set:
+            return hamtSize(arena, slot.payload);
+        case Tag.Array:
+            return vectorLength(arena, slot.payload);
+        default:
+            return 0;
+    }
+}
+//# sourceMappingURL=values.js.map