atchara 0.1.1

package/dist/release/index.cjs

@@ -0,0 +1,2119 @@
+'use strict';
+
+var core = require('@atcharajs/core');
+var buffer = require('buffer');
+var native = require('@atcharajs/native');
+
+// src/index.ts
+
+// src/decoder/reader.ts
+var ByteReader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.offset = 0;
+    this.textDecoder = new TextDecoder("utf-8");
+  }
+  view;
+  offset;
+  textDecoder;
+  /**
+   * Reset with new bytes and reset position to start.
+   * Avoids allocation overhead by reusing the reader instance.
+   */
+  reset(bytes) {
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.offset = 0;
+  }
+  /** Seek to a specific offset in the byte stream */
+  seek(offset) {
+    this.offset = offset;
+  }
+  /** Get current read position */
+  getOffset() {
+    return this.offset;
+  }
+  /** Get number of bytes remaining */
+  getRemainingBytes() {
+    return this.bytes.length - this.offset;
+  }
+  /** Get the underlying bytes */
+  getBytes() {
+    return this.bytes;
+  }
+  /** Get the DataView for direct access when needed */
+  getView() {
+    return this.view;
+  }
+  // ============================================================================
+  // Primitive Reads (all big-endian)
+  // ============================================================================
+  readU8() {
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readU16() {
+    const value = this.view.getUint16(this.offset, false);
+    this.offset += 2;
+    return value;
+  }
+  readU32() {
+    const value = this.view.getUint32(this.offset, false);
+    this.offset += 4;
+    return value;
+  }
+  /** Read u32 at specific offset without advancing position */
+  readU32At(offset) {
+    return this.view.getUint32(offset, false);
+  }
+  /** Read u16 at specific offset without advancing position */
+  readU16At(offset) {
+    return this.view.getUint16(offset, false);
+  }
+  /** Read u8 at specific offset without advancing position */
+  readU8At(offset) {
+    return this.view.getUint8(offset);
+  }
+  readF64() {
+    const value = this.view.getFloat64(this.offset, false);
+    this.offset += 8;
+    return value;
+  }
+  readBoolean() {
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value !== 0;
+  }
+  /**
+   * Read a length-prefixed string (u32 length + UTF-8 bytes).
+   * Uses zero-copy subarray view for efficiency.
+   */
+  readString() {
+    const length = this.view.getUint32(this.offset, false);
+    this.offset += 4;
+    const stringBytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return this.textDecoder.decode(stringBytes);
+  }
+  /** Skip past a length-prefixed string without decoding */
+  skipString() {
+    const length = this.view.getUint32(this.offset, false);
+    this.offset += 4 + length;
+  }
+  /** Skip n bytes */
+  skip(n) {
+    this.offset += n;
+  }
+  /**
+   * Read raw bytes as a subarray (zero-copy view).
+   * Advances position by length.
+   */
+  readBytes(length) {
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return bytes;
+  }
+  /**
+   * Decode a string from bytes at specific offset with given length.
+   * Does not advance position.
+   */
+  decodeStringAt(offset, length) {
+    const stringBytes = this.bytes.subarray(offset, offset + length);
+    return this.textDecoder.decode(stringBytes);
+  }
+};
+
+// src/decoder/buffer.ts
+var BufferDecoder = class {
+  reader;
+  defs;
+  constructor(bytes, defs = []) {
+    this.reader = new ByteReader(bytes);
+    this.defs = defs;
+  }
+  /**
+   * Reset the decoder with new bytes and reset state.
+   * Avoids allocation overhead by reusing the decoder instance.
+   */
+  reset(bytes) {
+    this.reader.reset(bytes);
+  }
+  /** Seek to a specific offset in the byte stream */
+  seek(offset) {
+    this.reader.seek(offset);
+  }
+  getOffset() {
+    return this.reader.getOffset();
+  }
+  getRemainingBytes() {
+    return this.reader.getRemainingBytes();
+  }
+  // ==========================================================================
+  // Primitives (BufferDecoder interface)
+  // ==========================================================================
+  /** Read null flag (0x00 = null, 0x01 = present) */
+  readNullFlag() {
+    return this.reader.readU8() === native.NULL_FLAG;
+  }
+  /** Read a boolean value */
+  readBoolean() {
+    return this.reader.readBoolean();
+  }
+  /** Read a number value (f64) */
+  readNumber() {
+    return this.reader.readF64();
+  }
+  /** Read a length-prefixed string */
+  readString() {
+    return this.reader.readString();
+  }
+  /** Read union variant index (u8) */
+  readVariantIndex() {
+    return this.reader.readU8();
+  }
+  // ==========================================================================
+  // Schema-driven read
+  // ==========================================================================
+  /**
+   * Read and deserialize based on schema type
+   */
+  read(schema) {
+    switch (schema.kind) {
+      case "string":
+        return this.reader.readString();
+      case "number":
+      case "integer":
+        return this.reader.readF64();
+      case "boolean":
+        return this.reader.readBoolean();
+      case "literal":
+        return this.readLiteral(schema);
+      case "object":
+        return this.readObject(schema);
+      case "array":
+        return this.readArray(schema);
+      case "tuple":
+        return this.readTuple(schema);
+      case "nullable":
+        return this.readNullable(schema);
+      case "optional":
+        return this.read(schema.inner);
+      case "record":
+        return this.readRecord(schema);
+      case "union":
+        return this.readUnion(schema);
+      case "ref":
+        return this.read(this.defs[schema.defId]);
+      default: {
+        const exhaustiveCheck = schema;
+        throw new Error(`Unknown schema type: ${String(exhaustiveCheck)}`);
+      }
+    }
+  }
+  /** Read array length at current position without decoding elements */
+  readArrayLength() {
+    return this.reader.readU32At(this.reader.getOffset());
+  }
+  /** Read record keys at current position, skipping values */
+  readRecordKeys(valueSchema) {
+    const offset = this.reader.getOffset();
+    const keyCount = this.reader.readU32At(offset);
+    if (keyCount === 0) {
+      this.reader.seek(offset + 8);
+      return [];
+    }
+    this.reader.seek(offset + 8);
+    const keys = new Array(keyCount);
+    for (let i = 0; i < keyCount; i++) {
+      const keyLen = this.reader.readU16();
+      keys[i] = this.reader.decodeStringAt(this.reader.getOffset(), keyLen);
+      this.reader.skip(keyLen);
+      this.skip(valueSchema);
+    }
+    this.reader.skip(keyCount * 12);
+    return keys;
+  }
+  // ============================================================================
+  // Array Operations (at specific offset)
+  // ============================================================================
+  /** Read array length at a specific offset without modifying decoder position */
+  getArrayLengthAt(arrayOffset) {
+    return this.reader.readU32At(arrayOffset);
+  }
+  /**
+   * Get offset of array element at index by skipping preceding elements.
+   * Returns undefined if index is out of bounds.
+   */
+  getArrayElementOffset(arrayOffset, index, elementSchema) {
+    const length = this.reader.readU32At(arrayOffset);
+    if (index >= length) return void 0;
+    this.reader.seek(arrayOffset + 4);
+    for (let i = 0; i < index; i++) {
+      this.skip(elementSchema);
+    }
+    return this.reader.getOffset();
+  }
+  /** Read array element at index */
+  readArrayElementAt(arrayOffset, index, elementSchema) {
+    const length = this.reader.readU32At(arrayOffset);
+    if (index >= length) return void 0;
+    this.reader.seek(arrayOffset + 4);
+    for (let i = 0; i < index; i++) {
+      this.skip(elementSchema);
+    }
+    return this.read(elementSchema);
+  }
+  // ============================================================================
+  // Record Operations (hash-based O(log n) lookup)
+  // ============================================================================
+  /** Read record key count at a specific offset */
+  getRecordKeyCountAt(recordOffset) {
+    return this.reader.readU32At(recordOffset);
+  }
+  /**
+   * Find offset of record value by key using hash-based binary search.
+   * Returns the offset where the value begins, or undefined if key not found.
+   */
+  findRecordValueOffset(recordOffset, key) {
+    const view = this.reader.getView();
+    const keyCount = view.getUint32(recordOffset, false);
+    if (keyCount === 0) return void 0;
+    const kvDataSize = view.getUint32(recordOffset + 4, false);
+    const targetHash = native.fnv1A64(key);
+    const indexStart = recordOffset + 8 + kvDataSize;
+    let lo = 0;
+    let hi = keyCount - 1;
+    while (lo <= hi) {
+      const mid = lo + hi >>> 1;
+      const entryOffset = indexStart + mid * 12;
+      const hashHigh = view.getUint32(entryOffset, false);
+      const hashLow = view.getUint32(entryOffset + 4, false);
+      const entryHash = BigInt(hashHigh) << 32n | BigInt(hashLow);
+      if (targetHash === entryHash) {
+        const kvOffset = view.getUint32(entryOffset + 8, false);
+        const keyLen = view.getUint16(kvOffset, false);
+        return kvOffset + 2 + keyLen;
+      } else if (targetHash < entryHash) {
+        hi = mid - 1;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    return void 0;
+  }
+  /** Read record value by key using hash-based binary search */
+  readRecordValueAt(recordOffset, key, valueSchema) {
+    const valueOffset = this.findRecordValueOffset(recordOffset, key);
+    if (valueOffset === void 0) return void 0;
+    this.reader.seek(valueOffset);
+    return this.read(valueSchema);
+  }
+  // ============================================================================
+  // Object Operations (O(1) offset table lookup)
+  // ============================================================================
+  /** Check if object contains a field by reading offset table entry - O(1) */
+  hasObjectFieldAt(objectOffset, fieldIndex, _schema) {
+    const relativeOffset = this.reader.readU32At(objectOffset + fieldIndex * 4);
+    return relativeOffset !== native.ABSENT_FIELD_MARKER;
+  }
+  /**
+   * Find offset of object field value by field index - O(1).
+   * Returns undefined if field is not present.
+   */
+  findObjectFieldOffset(objectOffset, fieldIndex, schema) {
+    const fieldCount = schema.objectFields.length;
+    const relativeOffset = this.reader.readU32At(objectOffset + fieldIndex * 4);
+    if (relativeOffset === native.ABSENT_FIELD_MARKER) return void 0;
+    const valuesStart = objectOffset + fieldCount * 4;
+    return valuesStart + relativeOffset;
+  }
+  /** Read object field value by field index - O(1) */
+  readObjectFieldAt(objectOffset, fieldIndex, schema) {
+    const fieldOffset = this.findObjectFieldOffset(objectOffset, fieldIndex, schema);
+    if (fieldOffset === void 0) return void 0;
+    const field = schema.objectFields[fieldIndex];
+    if (!field) return void 0;
+    this.reader.seek(fieldOffset);
+    return this.read(field.schema);
+  }
+  /**
+   * Advance past a value without materializing it.
+   * Used for efficient iteration when only partial data is needed.
+   */
+  skip(schema) {
+    switch (schema.kind) {
+      case "string":
+        this.reader.skipString();
+        break;
+      case "number":
+      case "integer":
+        this.reader.skip(8);
+        break;
+      case "boolean":
+        this.reader.skip(1);
+        break;
+      case "literal":
+        this.skipLiteral(schema);
+        break;
+      case "object":
+        this.skipObject(schema);
+        break;
+      case "array":
+        this.skipArray(schema);
+        break;
+      case "tuple":
+        this.skipTuple(schema);
+        break;
+      case "nullable":
+        this.skipNullable(schema);
+        break;
+      case "optional":
+        this.skip(schema.inner);
+        break;
+      case "record":
+        this.skipRecord();
+        break;
+      case "union":
+        this.skipUnion(schema);
+        break;
+      case "ref":
+        this.skip(this.defs[schema.defId]);
+        break;
+      default: {
+        const exhaustiveCheck = schema;
+        throw new Error(`Unknown schema type: ${String(exhaustiveCheck)}`);
+      }
+    }
+  }
+  // ============================================================================
+  // Private Read Methods
+  // ============================================================================
+  readLiteral(schema) {
+    if (schema.value === null) {
+      return null;
+    }
+    switch (typeof schema.value) {
+      case "string":
+        return this.reader.readString();
+      case "number":
+        return this.reader.readF64();
+      case "boolean":
+        return this.reader.readBoolean();
+      default:
+        throw new Error(`Unknown literal type: ${typeof schema.value}`);
+    }
+  }
+  readNullable(schema) {
+    const flag = this.reader.readU8();
+    return flag === native.NULL_FLAG ? null : this.read(schema.inner);
+  }
+  readArray(schema) {
+    const length = this.reader.readU32();
+    const array2 = new Array(length);
+    for (let i = 0; i < length; i++) {
+      array2[i] = this.read(schema.elements);
+    }
+    return array2;
+  }
+  readTuple(schema) {
+    const elements = schema.elements;
+    const result = new Array(elements.length);
+    for (let i = 0; i < elements.length; i++) {
+      result[i] = this.read(elements[i]);
+    }
+    return result;
+  }
+  readRecord(schema) {
+    const keyCount = this.reader.readU32();
+    if (keyCount === 0) {
+      this.reader.skip(4);
+      return {};
+    }
+    this.reader.skip(4);
+    const result = {};
+    for (let i = 0; i < keyCount; i++) {
+      const keyLen = this.reader.readU16();
+      const key = this.reader.decodeStringAt(this.reader.getOffset(), keyLen);
+      this.reader.skip(keyLen);
+      result[key] = this.read(schema.valueSchema);
+    }
+    this.reader.skip(keyCount * 12);
+    return result;
+  }
+  readObject(schema) {
+    const result = {};
+    const fieldCount = schema.objectFields.length;
+    const objectStart = this.reader.getOffset();
+    const valuesStart = objectStart + fieldCount * 4;
+    let maxEnd = valuesStart;
+    for (let i = 0; i < fieldCount; i++) {
+      const relativeOffset = this.reader.readU32At(objectStart + i * 4);
+      if (relativeOffset === native.ABSENT_FIELD_MARKER) continue;
+      const field = schema.objectFields[i];
+      if (!field) {
+        throw new Error(`Invalid field index: ${i}`);
+      }
+      this.reader.seek(valuesStart + relativeOffset);
+      result[field.key] = this.read(field.schema);
+      const currentOffset = this.reader.getOffset();
+      if (currentOffset > maxEnd) maxEnd = currentOffset;
+    }
+    this.reader.seek(maxEnd);
+    return result;
+  }
+  readUnion(schema) {
+    const variantIndex = this.reader.readU8();
+    const variantSchema = schema.variants[variantIndex];
+    if (variantSchema === void 0) {
+      throw new Error(`Invalid union variant index: ${variantIndex}`);
+    }
+    return this.read(variantSchema);
+  }
+  // ============================================================================
+  // Private Skip Methods
+  // ============================================================================
+  skipLiteral(schema) {
+    if (schema.value === null) return;
+    if (typeof schema.value === "string") this.reader.skipString();
+    else if (typeof schema.value === "number") this.reader.skip(8);
+    else if (typeof schema.value === "boolean") this.reader.skip(1);
+  }
+  skipNullable(schema) {
+    const flag = this.reader.readU8();
+    if (flag !== native.NULL_FLAG) this.skip(schema.inner);
+  }
+  skipArray(schema) {
+    const length = this.reader.readU32();
+    for (let i = 0; i < length; i++) {
+      this.skip(schema.elements);
+    }
+  }
+  skipTuple(schema) {
+    for (const element of schema.elements) {
+      this.skip(element);
+    }
+  }
+  skipRecord() {
+    const offset = this.reader.getOffset();
+    const keyCount = this.reader.readU32At(offset);
+    const kvDataSize = this.reader.readU32At(offset + 4);
+    this.reader.seek(offset + 8 + kvDataSize + keyCount * 12);
+  }
+  skipObject(schema) {
+    const fieldCount = schema.objectFields.length;
+    const objectStart = this.reader.getOffset();
+    const valuesStart = objectStart + fieldCount * 4;
+    let maxEnd = valuesStart;
+    for (let i = 0; i < fieldCount; i++) {
+      const relativeOffset = this.reader.readU32At(objectStart + i * 4);
+      if (relativeOffset === native.ABSENT_FIELD_MARKER) continue;
+      const field = schema.objectFields[i];
+      if (!field) throw new Error(`Invalid field index: ${i}`);
+      this.reader.seek(valuesStart + relativeOffset);
+      this.skip(field.schema);
+      const currentOffset = this.reader.getOffset();
+      if (currentOffset > maxEnd) maxEnd = currentOffset;
+    }
+    this.reader.seek(maxEnd);
+  }
+  skipUnion(schema) {
+    const variantIndex = this.reader.readU8();
+    const variantSchema = schema.variants[variantIndex];
+    if (variantSchema === void 0) {
+      throw new Error(`Invalid union variant index: ${variantIndex}`);
+    }
+    this.skip(variantSchema);
+  }
+};
+
+// src/decoder/offset.ts
+var OffsetIndex = class {
+  view;
+  tableCount;
+  tableStartOffset;
+  valueDataLength;
+  cache;
+  // schema_index → offset cache
+  constructor(binary) {
+    this.view = new DataView(binary.buffer, binary.byteOffset, binary.byteLength);
+    this.cache = /* @__PURE__ */ new Map();
+    this.tableCount = this.view.getUint32(binary.length - 4, false);
+    this.tableStartOffset = binary.length - 4 - this.tableCount * 4;
+    this.valueDataLength = this.tableStartOffset;
+  }
+  /**
+   * Get the offset for a given schema index.
+   * Uses lazy reading and caching for performance.
+   */
+  getOffset(schemaIndex) {
+    if (this.cache.has(schemaIndex)) {
+      return this.cache.get(schemaIndex);
+    }
+    if (schemaIndex >= this.tableCount || schemaIndex < 0) {
+      return void 0;
+    }
+    const offsetPos = this.tableStartOffset + schemaIndex * 4;
+    const offset = this.view.getUint32(offsetPos, false);
+    this.cache.set(schemaIndex, offset);
+    return offset;
+  }
+  /**
+   * Get the length of the value data (before offset table)
+   */
+  getValueDataLength() {
+    return this.valueDataLength;
+  }
+  /**
+   * Get the total number of offsets in the table
+   */
+  getCount() {
+    return this.tableCount;
+  }
+};
+
+// src/path.ts
+function encodePath(path) {
+  return path.map((p) => p + "\0").join("");
+}
+
+// src/store/memory.ts
+var MemoryStore = class {
+  defs;
+  decoder;
+  offsetIndex;
+  schema;
+  indexMap;
+  schemaCache = /* @__PURE__ */ new Map();
+  getDefs() {
+    return this.defs;
+  }
+  constructor(bytes, schema, indexMap, defs = []) {
+    this.defs = defs;
+    this.schema = schema;
+    this.indexMap = indexMap;
+    this.offsetIndex = new OffsetIndex(bytes);
+    const valueDataLength = this.offsetIndex.getValueDataLength();
+    const valueData = bytes.subarray(0, valueDataLength);
+    this.decoder = new BufferDecoder(valueData, defs);
+  }
+  get(path) {
+    const pathKey = encodePath(path);
+    const offsetIdx = this.indexMap.get(pathKey);
+    if (offsetIdx === void 0) {
+      if (path.length > 0) {
+        const parentPath = path.slice(0, -1);
+        const parentSchema = core.resolveRef(
+          path.length === 1 ? this.schema : core.schemaAtPath(this.schema, parentPath, this.defs),
+          this.defs
+        );
+        const key = path[path.length - 1];
+        if (parentSchema.kind === "array" && key !== void 0) {
+          const index = parseInt(key, 10);
+          if (isNaN(index) || index < 0) return void 0;
+          const parentOffset = this.getOffsetForDynamicPath(parentPath);
+          if (parentOffset === void 0) return void 0;
+          return this.decoder.readArrayElementAt(parentOffset, index, parentSchema.elements);
+        }
+        if (parentSchema.kind === "record" && key !== void 0) {
+          const parentOffset = this.getOffsetForDynamicPath(parentPath);
+          if (parentOffset === void 0) return void 0;
+          return this.decoder.readRecordValueAt(parentOffset, key, parentSchema.valueSchema);
+        }
+        if (parentSchema.kind === "object" && key !== void 0) {
+          const parentOffset = this.getOffsetForDynamicPath(parentPath);
+          if (parentOffset === void 0) return void 0;
+          const fieldDef = parentSchema.objectFields.find((f) => f.key === key);
+          if (!fieldDef) return void 0;
+          return this.decoder.readObjectFieldAt(parentOffset, fieldDef.index, parentSchema);
+        }
+      }
+      return void 0;
+    }
+    const offset = this.offsetIndex.getOffset(offsetIdx);
+    if (offset === void 0) return void 0;
+    this.decoder.seek(offset);
+    const schema = this.getCachedSchema(path);
+    return this.decoder.read(schema);
+  }
+  has(path) {
+    if (path.length === 0) {
+      return true;
+    }
+    const parentPath = path.slice(0, -1);
+    const parentSchema = core.resolveRef(
+      path.length === 1 ? this.schema : core.schemaAtPath(this.schema, parentPath, this.defs),
+      this.defs
+    );
+    const key = path[path.length - 1];
+    if (key === void 0) return false;
+    if (parentSchema.kind === "object") {
+      const parentOffset = this.getOffsetForDynamicPath(parentPath);
+      if (parentOffset === void 0) return false;
+      const fieldDef = parentSchema.objectFields.find((f) => f.key === key);
+      if (!fieldDef) return false;
+      return this.decoder.hasObjectFieldAt(parentOffset, fieldDef.index, parentSchema);
+    }
+    if (parentSchema.kind === "array") {
+      const index = parseInt(key, 10);
+      if (isNaN(index) || index < 0) return false;
+      const parentOffset = this.getOffsetForDynamicPath(parentPath);
+      if (parentOffset === void 0) return false;
+      const length = this.decoder.getArrayLengthAt(parentOffset);
+      return index < length;
+    }
+    if (parentSchema.kind === "record") {
+      const parentOffset = this.getOffsetForDynamicPath(parentPath);
+      if (parentOffset === void 0) return false;
+      return this.decoder.findRecordValueOffset(parentOffset, key) !== void 0;
+    }
+    return false;
+  }
+  getFieldMetadata(path, key) {
+    const fullPath = [...path, key];
+    const pathKey = encodePath(fullPath);
+    const exists = this.indexMap.has(pathKey);
+    return {
+      exists,
+      schema: exists ? this.getCachedSchema(fullPath) : { kind: "string" }
+    };
+  }
+  getArrayLength(path) {
+    const offset = this.getOffsetForDynamicPath(path);
+    if (offset === void 0) return 0;
+    this.decoder.seek(offset);
+    return this.decoder.readArrayLength();
+  }
+  getRecordKeys(path) {
+    const offset = this.getOffsetForDynamicPath(path);
+    if (offset === void 0) return [];
+    const schema = this.getCachedSchema(path);
+    if (schema.kind !== "record") return [];
+    this.decoder.seek(offset);
+    return this.decoder.readRecordKeys(schema.valueSchema);
+  }
+  getOffsetForPath(path) {
+    const pathKey = encodePath(path);
+    const offsetIdx = this.indexMap.get(pathKey);
+    if (offsetIdx === void 0) return void 0;
+    return this.offsetIndex.getOffset(offsetIdx);
+  }
+  /**
+   * Get offset for a path that may contain dynamic segments (array indices, record keys, object fields).
+   * Recursively resolves each path segment, handling both schema-indexed and dynamic paths.
+   */
+  getOffsetForDynamicPath(path) {
+    const directOffset = this.getOffsetForPath(path);
+    if (directOffset !== void 0) return directOffset;
+    if (path.length === 0) return void 0;
+    const parentPath = path.slice(0, -1);
+    const parentOffset = this.getOffsetForDynamicPath(parentPath);
+    if (parentOffset === void 0) return void 0;
+    const parentSchema = core.resolveRef(
+      path.length === 1 ? this.schema : core.schemaAtPath(this.schema, parentPath, this.defs),
+      this.defs
+    );
+    const key = path[path.length - 1];
+    if (key === void 0) return void 0;
+    if (parentSchema.kind === "array") {
+      const index = parseInt(key, 10);
+      if (isNaN(index) || index < 0) return void 0;
+      return this.decoder.getArrayElementOffset(parentOffset, index, parentSchema.elements);
+    }
+    if (parentSchema.kind === "record") {
+      return this.decoder.findRecordValueOffset(parentOffset, key);
+    }
+    if (parentSchema.kind === "object") {
+      const fieldDef = parentSchema.objectFields.find((f) => f.key === key);
+      if (!fieldDef) return void 0;
+      return this.decoder.findObjectFieldOffset(parentOffset, fieldDef.index, parentSchema);
+    }
+    return void 0;
+  }
+  /**
+   * Get schema at path with caching for repeated access
+   */
+  getCachedSchema(path) {
+    if (path.length === 0) {
+      return core.resolveRef(this.schema, this.defs);
+    }
+    const pathKey = encodePath(path);
+    let schema = this.schemaCache.get(pathKey);
+    if (schema === void 0) {
+      schema = core.schemaAtPath(this.schema, path, this.defs);
+      this.schemaCache.set(pathKey, schema);
+    }
+    return schema;
+  }
+};
+var ErrorDecoder = class {
+  reader;
+  constructor(bytes) {
+    this.reader = new ByteReader(bytes);
+  }
+  /**
+   * Decode the binary error and return an AtcharaError ready to be thrown.
+   */
+  decode() {
+    const code = this.reader.readU8();
+    switch (code) {
+      case native.ERROR_CODE_UNEXPECTED_EOF:
+        return core.createAtcharaError("Unexpected end of input", {
+          code: "UNEXPECTED_EOF"
+        });
+      case native.ERROR_CODE_INVALID_UTF8: {
+        const line = this.reader.readU32();
+        const column = this.reader.readU32();
+        const rawMessage = this.reader.readString();
+        return core.createAtcharaError(
+          `Invalid UTF-8 at line ${line}, column ${column}: ${rawMessage}`,
+          {
+            code: "INVALID_UTF8",
+            position: { line, column },
+            details: { rawMessage }
+          }
+        );
+      }
+      case native.ERROR_CODE_UNEXPECTED_CHARACTER: {
+        const line = this.reader.readU32();
+        const column = this.reader.readU32();
+        const character = this.reader.readString();
+        return core.createAtcharaError(
+          `Unexpected character '${character}' at line ${line}, column ${column}`,
+          {
+            code: "UNEXPECTED_CHARACTER",
+            position: { line, column },
+            details: { character }
+          }
+        );
+      }
+      case native.ERROR_CODE_VALIDATION_ERROR: {
+        const line = this.reader.readU32();
+        const column = this.reader.readU32();
+        const expected = this.reader.readString();
+        const found = this.reader.readString();
+        return core.createAtcharaError(
+          `Expected ${expected}, found ${found} at line ${line}, column ${column}`,
+          {
+            code: "VALIDATION_ERROR",
+            position: { line, column },
+            details: { expected, found }
+          }
+        );
+      }
+      case native.ERROR_CODE_MISSING_REQUIRED: {
+        const line = this.reader.readU32();
+        const column = this.reader.readU32();
+        const field = this.reader.readString();
+        return core.createAtcharaError(
+          `Missing required field '${field}' in object at line ${line}, column ${column}`,
+          {
+            code: "MISSING_REQUIRED",
+            position: { line, column },
+            details: { field }
+          }
+        );
+      }
+      case native.ERROR_CODE_UNEXPECTED_FIELD: {
+        const line = this.reader.readU32();
+        const column = this.reader.readU32();
+        const field = this.reader.readString();
+        return core.createAtcharaError(
+          `Unexpected field '${field}' at line ${line}, column ${column}`,
+          {
+            code: "UNEXPECTED_FIELD",
+            position: { line, column },
+            details: { field }
+          }
+        );
+      }
+      case native.ERROR_CODE_UNION_NO_MATCH: {
+        const line = this.reader.readU32();
+        const column = this.reader.readU32();
+        const count = this.reader.readU32();
+        const variantErrors = [];
+        for (let i = 0; i < count; i++) {
+          variantErrors.push(this.decode());
+        }
+        const variantSummary = variantErrors.map((e, i) => `[${i}] ${e.message}`).join("; ");
+        return core.createAtcharaError(
+          `No union variant matched at line ${line}, column ${column}. Variant errors: ${variantSummary}`,
+          {
+            code: "UNION_NO_MATCH",
+            position: { line, column },
+            details: { variantErrors }
+          }
+        );
+      }
+      case native.ERROR_CODE_INVALID_SCHEMA: {
+        const message = this.reader.readString();
+        return core.createAtcharaError(`Invalid schema: ${message}`, {
+          code: "INVALID_SCHEMA"
+        });
+      }
+      default:
+        throw new Error(`Unknown error code: ${code}`);
+    }
+  }
+};
+function unwrapSchema(schema, defs) {
+  if (schema.kind === "ref" && defs) {
+    return unwrapSchema(defs[schema.defId], defs);
+  }
+  if (schema.kind === "optional" || schema.kind === "nullable") {
+    return unwrapSchema(schema.inner, defs);
+  }
+  return schema;
+}
+function isPackable(schema, defs) {
+  const inner = unwrapSchema(schema, defs);
+  switch (inner.kind) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "literal":
+      return true;
+    default:
+      return false;
+  }
+}
+function decodePackedBlob(blob, objectFields) {
+  const result = /* @__PURE__ */ new Map();
+  const view = new DataView(blob.buffer, blob.byteOffset, blob.byteLength);
+  let offset = 0;
+  const entryCount = view.getUint16(offset);
+  offset += 2;
+  const decoder = new TextDecoder();
+  for (let i = 0; i < entryCount; i++) {
+    const fieldIndex = view.getUint16(offset);
+    offset += 2;
+    const tag = blob[offset++];
+    if (tag === 2) {
+      result.set(fieldIndex, null);
+      continue;
+    }
+    if (tag !== 1) {
+      result.set(fieldIndex, void 0);
+      continue;
+    }
+    const field = objectFields.find((f) => f.index === fieldIndex);
+    if (!field) continue;
+    const innerSchema = unwrapSchema(field.schema);
+    switch (innerSchema.kind) {
+      case "boolean": {
+        result.set(fieldIndex, blob[offset++] === 1);
+        break;
+      }
+      case "number":
+      case "integer": {
+        result.set(fieldIndex, view.getFloat64(offset));
+        offset += 8;
+        break;
+      }
+      case "string": {
+        const len = view.getUint32(offset);
+        offset += 4;
+        result.set(fieldIndex, decoder.decode(blob.subarray(offset, offset + len)));
+        offset += len;
+        break;
+      }
+      case "literal": {
+        if (innerSchema.value === null) {
+          result.set(fieldIndex, null);
+        } else if (typeof innerSchema.value === "boolean") {
+          result.set(fieldIndex, blob[offset++] === 1);
+        } else if (typeof innerSchema.value === "number") {
+          result.set(fieldIndex, view.getFloat64(offset));
+          offset += 8;
+        } else if (typeof innerSchema.value === "string") {
+          const len = view.getUint32(offset);
+          offset += 4;
+          result.set(fieldIndex, decoder.decode(blob.subarray(offset, offset + len)));
+          offset += len;
+        }
+        break;
+      }
+    }
+  }
+  return result;
+}
+var RedbStore = class {
+  constructor(session, schema, indexMap, defs = []) {
+    this.session = session;
+    this.schema = schema;
+    this.indexMap = indexMap;
+    this.defs = defs;
+  }
+  schemaCache = /* @__PURE__ */ new Map();
+  closed = false;
+  defs;
+  getDefs() {
+    return this.defs;
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  close() {
+    if (!this.closed) {
+      this.session.close();
+      this.closed = true;
+    }
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new Error("RedbStore is closed");
+    }
+  }
+  /**
+   * Check if data exists at a path based on the schema type.
+   * For primitives: check d:{path}
+   * For objects/arrays/tuples/records: check m:{path}:len
+   * For unions: check m:{path}:var
+   * For nullable: check m:{path}:nul
+   * For optional: recursively check inner schema
+   */
+  hasDataAtPath(path, schema) {
+    const resolved = core.resolveRef(schema, this.defs);
+    const innerSchema = resolved.kind === "optional" ? resolved.inner : resolved;
+    switch (innerSchema.kind) {
+      case "object": {
+        const dataKey = this.pathToKey(path);
+        if (this.session.get(dataKey) !== null) return true;
+        const objMetaKey = this.pathToMetaKey(path, "len");
+        return this.session.get(objMetaKey) !== null;
+      }
+      case "array":
+      case "tuple":
+      case "record": {
+        const metaKey = this.pathToMetaKey(path, "len");
+        return this.session.get(metaKey) !== null;
+      }
+      case "union": {
+        const metaKey = this.pathToMetaKey(path, "var");
+        return this.session.get(metaKey) !== null;
+      }
+      case "nullable": {
+        const metaKey = this.pathToMetaKey(path, "nul");
+        return this.session.get(metaKey) !== null;
+      }
+      default: {
+        const dataKey = this.pathToKey(path);
+        return this.session.get(dataKey) !== null;
+      }
+    }
+  }
+  /**
+   * Convert a user path to a metadata key with given suffix.
+   * Reuses pathToKey logic but produces m:{path}:{suffix} format.
+   */
+  pathToMetaKey(path, suffix) {
+    const dataKey = this.pathToKey(path);
+    if (dataKey === "d:") {
+      return `m::${suffix}`;
+    }
+    return `m:${dataKey.slice(2)}:${suffix}`;
+  }
+  /**
+   * Convert a user path to a storage key.
+   * Handles record keys by adding k: prefix.
+   */
+  pathToKey(path) {
+    if (path.length === 0) return "d:";
+    const parts = [];
+    let currentSchema = core.resolveRef(this.schema, this.defs);
+    for (const segment of path) {
+      currentSchema = core.resolveRef(currentSchema, this.defs);
+      switch (currentSchema.kind) {
+        case "object": {
+          parts.push(segment);
+          const field = currentSchema.objectFields.find(
+            (f) => f.key === segment
+          );
+          if (field) {
+            currentSchema = field.schema;
+          }
+          break;
+        }
+        case "array":
+          parts.push(segment);
+          currentSchema = currentSchema.elements;
+          break;
+        case "tuple": {
+          parts.push(segment);
+          const idx = parseInt(segment, 10);
+          const elem = currentSchema.elements[idx];
+          if (elem) {
+            currentSchema = elem;
+          }
+          break;
+        }
+        case "record":
+          parts.push(`k:${segment}`);
+          currentSchema = currentSchema.valueSchema;
+          break;
+        case "union": {
+          parts.push(segment);
+          if (segment.startsWith("v")) {
+            const variantIdx = parseInt(segment.slice(1), 10);
+            const variant = currentSchema.variants[variantIdx];
+            if (variant) {
+              currentSchema = variant;
+            }
+          }
+          break;
+        }
+        case "nullable":
+        case "optional":
+          currentSchema = currentSchema.inner;
+          return this.pathToKeyWithSchema(path, this.schema);
+        default:
+          parts.push(segment);
+      }
+    }
+    return `d:${parts.join(":")}`;
+  }
+  /**
+   * Convert path to storage key with explicit schema tracking for nullable/optional handling.
+   */
+  pathToKeyWithSchema(path, rootSchema) {
+    if (path.length === 0) return "d:";
+    const parts = [];
+    let currentSchema = rootSchema;
+    currentSchema = core.resolveRef(currentSchema, this.defs);
+    while (currentSchema.kind === "nullable" || currentSchema.kind === "optional") {
+      currentSchema = core.resolveRef(currentSchema.inner, this.defs);
+    }
+    for (const segment of path) {
+      currentSchema = core.resolveRef(currentSchema, this.defs);
+      while (currentSchema.kind === "nullable" || currentSchema.kind === "optional") {
+        currentSchema = core.resolveRef(currentSchema.inner, this.defs);
+      }
+      switch (currentSchema.kind) {
+        case "object": {
+          parts.push(segment);
+          const field = currentSchema.objectFields.find(
+            (f) => f.key === segment
+          );
+          if (field) {
+            currentSchema = field.schema;
+          }
+          break;
+        }
+        case "array":
+          parts.push(segment);
+          currentSchema = currentSchema.elements;
+          break;
+        case "tuple": {
+          parts.push(segment);
+          const idx = parseInt(segment, 10);
+          const elem = currentSchema.elements[idx];
+          if (elem) {
+            currentSchema = elem;
+          }
+          break;
+        }
+        case "record":
+          parts.push(`k:${segment}`);
+          currentSchema = currentSchema.valueSchema;
+          break;
+        default:
+          parts.push(segment);
+      }
+    }
+    return `d:${parts.join(":")}`;
+  }
+  get(path) {
+    this.ensureOpen();
+    if (path.length > 0) {
+      const parentPath = path.slice(0, -1);
+      const parentSchema = this.getUnwrappedSchemaAtPath(parentPath);
+      if (parentSchema.kind === "object") {
+        const fieldKey = path[path.length - 1];
+        const field = parentSchema.objectFields.find((f) => f.key === fieldKey);
+        if (field && isPackable(field.schema, this.defs)) {
+          return this.readPackedField(parentPath, parentSchema, field);
+        }
+      }
+    }
+    const schema = this.getCachedSchema(path);
+    return this.readValue(path, schema);
+  }
+  /**
+   * Recursively read and materialize a value from storage.
+   * This fully materializes complex types (objects, arrays, records).
+   */
+  readValue(path, schema) {
+    const key = this.pathToKey(path);
+    switch (schema.kind) {
+      case "string": {
+        const bytes = this.session.get(key);
+        if (!bytes) return void 0;
+        return new TextDecoder().decode(bytes);
+      }
+      case "number":
+      case "integer": {
+        const bytes = this.session.get(key);
+        if (!bytes) return void 0;
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getFloat64(0);
+      }
+      case "boolean": {
+        const bytes = this.session.get(key);
+        if (!bytes) return void 0;
+        return bytes[0] === 1;
+      }
+      case "literal": {
+        if (schema.value === null) {
+          return null;
+        }
+        const bytes = this.session.get(key);
+        if (!bytes) return schema.value;
+        if (typeof schema.value === "string") {
+          return new TextDecoder().decode(bytes);
+        }
+        if (typeof schema.value === "number") {
+          const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+          return view.getFloat64(0);
+        }
+        if (typeof schema.value === "boolean") {
+          return bytes[0] === 1;
+        }
+        return schema.value;
+      }
+      case "nullable": {
+        const metaKey = this.pathToMetaKey(path, "nul");
+        const bytes = this.session.get(metaKey);
+        if (!bytes) return void 0;
+        const isNull = bytes[0] === 1;
+        if (isNull) return null;
+        return this.readValue(path, schema.inner);
+      }
+      case "optional":
+        return this.readValue(path, schema.inner);
+      case "union": {
+        const metaKey = this.pathToMetaKey(path, "var");
+        const bytes = this.session.get(metaKey);
+        if (!bytes) return void 0;
+        const variantIndex = bytes[0];
+        if (variantIndex === void 0 || variantIndex >= schema.variants.length) {
+          return void 0;
+        }
+        const variantSchema = schema.variants[variantIndex];
+        if (!variantSchema) return void 0;
+        const variantPath = [...path, `v${variantIndex}`];
+        return this.readValue(variantPath, variantSchema);
+      }
+      case "object": {
+        const result = {};
+        const blobKey = this.pathToKey(path);
+        const blob = this.session.get(blobKey);
+        let packedData = null;
+        if (blob) {
+          packedData = decodePackedBlob(new Uint8Array(blob), schema.objectFields);
+        }
+        for (const field of schema.objectFields) {
+          const fieldSchema = field.schema;
+          if (packedData && isPackable(fieldSchema, this.defs)) {
+            const entry = packedData.get(field.index);
+            result[field.key] = entry;
+          } else {
+            const fieldPath = [...path, field.key];
+            const isOptional = fieldSchema.kind === "optional";
+            if (isOptional) {
+              const hasField = this.hasDataAtPath(fieldPath, fieldSchema);
+              if (hasField) {
+                result[field.key] = this.readValue(fieldPath, fieldSchema);
+              } else {
+                result[field.key] = void 0;
+              }
+            } else {
+              result[field.key] = this.readValue(fieldPath, fieldSchema);
+            }
+          }
+        }
+        return result;
+      }
+      case "array": {
+        const length = this.getArrayLength(path);
+        const result = new Array(length);
+        for (let i = 0; i < length; i++) {
+          const elemPath = [...path, String(i)];
+          result[i] = this.readValue(elemPath, schema.elements);
+        }
+        return result;
+      }
+      case "tuple": {
+        const result = new Array(schema.elements.length);
+        for (let i = 0; i < schema.elements.length; i++) {
+          const elemPath = [...path, String(i)];
+          const elemSchema = schema.elements[i];
+          if (elemSchema) {
+            result[i] = this.readValue(elemPath, elemSchema);
+          }
+        }
+        return result;
+      }
+      case "record": {
+        const keys = this.getRecordKeys(path);
+        const result = {};
+        for (const k of keys) {
+          const valuePath = [...path, k];
+          result[k] = this.readValue(valuePath, schema.valueSchema);
+        }
+        return result;
+      }
+      case "ref":
+        return this.readValue(path, this.defs[schema.defId]);
+    }
+  }
+  has(path) {
+    this.ensureOpen();
+    if (path.length === 0) {
+      return true;
+    }
+    const parentPath = path.slice(0, -1);
+    const parentSchema = path.length === 1 ? this.schema : core.schemaAtPath(this.schema, parentPath, this.defs);
+    const key = path[path.length - 1];
+    if (key === void 0) return false;
+    if (parentSchema.kind === "object") {
+      const field = parentSchema.objectFields.find((f) => f.key === key);
+      if (!field) return false;
+      if (isPackable(field.schema, this.defs)) {
+        const blobKey = this.pathToKey(parentPath);
+        const blob = this.session.get(blobKey);
+        if (blob) {
+          const packedData = decodePackedBlob(new Uint8Array(blob), parentSchema.objectFields);
+          return packedData.has(field.index) && packedData.get(field.index) !== void 0;
+        }
+        return false;
+      }
+      return this.hasDataAtPath(path, field.schema);
+    }
+    if (parentSchema.kind === "array") {
+      const index = parseInt(key, 10);
+      if (isNaN(index) || index < 0) return false;
+      const length = this.getArrayLength(parentPath);
+      return index < length;
+    }
+    if (parentSchema.kind === "record") {
+      const recordKey = parentPath.length === 0 ? `d:k:${key}` : `d:${parentPath.join(":")}:k:${key}`;
+      return this.session.get(recordKey) !== null;
+    }
+    return false;
+  }
+  getFieldMetadata(path, key) {
+    const fullPath = [...path, key];
+    const pathKey = encodePath(fullPath);
+    const exists = this.indexMap.has(pathKey);
+    return {
+      exists,
+      schema: exists ? this.getCachedSchema(fullPath) : { kind: "string" }
+    };
+  }
+  getArrayLength(path) {
+    this.ensureOpen();
+    const metaKey = this.pathToMetaKey(path, "len");
+    const bytes = this.session.get(metaKey);
+    if (!bytes) return 0;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return view.getUint32(0);
+  }
+  getRecordKeys(path) {
+    this.ensureOpen();
+    const dataKey = this.pathToKey(path);
+    const dataPrefix = dataKey === "d:" ? "d:k:" : `${dataKey}:k:`;
+    const metaPrefix = dataKey === "d:" ? "m:k:" : `m:${dataKey.slice(2)}:k:`;
+    const keys = /* @__PURE__ */ new Set();
+    for (const k of this.session.keysWithPrefix(dataPrefix)) {
+      const keyPart = k.slice(dataPrefix.length);
+      const colonIdx = keyPart.indexOf(":");
+      const immediateKey = colonIdx === -1 ? keyPart : keyPart.slice(0, colonIdx);
+      keys.add(immediateKey);
+    }
+    for (const k of this.session.keysWithPrefix(metaPrefix)) {
+      const keyPart = k.slice(metaPrefix.length);
+      const colonIdx = keyPart.indexOf(":");
+      const immediateKey = colonIdx === -1 ? keyPart : keyPart.slice(0, colonIdx);
+      keys.add(immediateKey);
+    }
+    return Array.from(keys);
+  }
+  /**
+   * Navigate to a path and unwrap any nullable/optional wrappers on the result.
+   */
+  getUnwrappedSchemaAtPath(path) {
+    let schema = path.length === 0 ? this.schema : core.schemaAtPath(this.schema, path, this.defs);
+    schema = core.resolveRef(schema, this.defs);
+    while (schema.kind === "nullable" || schema.kind === "optional") {
+      schema = core.resolveRef(schema.inner, this.defs);
+    }
+    return schema;
+  }
+  /**
+   * Read a single packable field from the parent object's packed blob.
+   */
+  readPackedField(parentPath, parentSchema, field) {
+    const blobKey = this.pathToKey(parentPath);
+    const blob = this.session.get(blobKey);
+    if (!blob) return void 0;
+    const packedData = decodePackedBlob(new Uint8Array(blob), parentSchema.objectFields);
+    return packedData.get(field.index);
+  }
+  /**
+   * Get schema at path with caching
+   */
+  getCachedSchema(path) {
+    if (path.length === 0) {
+      return this.schema;
+    }
+    const pathKey = encodePath(path);
+    let schema = this.schemaCache.get(pathKey);
+    if (schema === void 0) {
+      schema = core.schemaAtPath(this.schema, path, this.defs);
+      this.schemaCache.set(pathKey, schema);
+    }
+    return schema;
+  }
+};
+
+// src/native.ts
+var NativeParser = class {
+  constructor(schema) {
+    this.schema = schema;
+    const counter = { value: 0 };
+    const lazy2 = { seen: /* @__PURE__ */ new Map(), defs: [] };
+    this.root = schema.serializeSchema(counter, lazy2);
+    if (lazy2.defs.some((d) => d === void 0)) {
+      throw new Error(
+        "Incomplete lazy defs: some definitions were not resolved during serialization"
+      );
+    }
+    this.defs = lazy2.defs;
+    this.native = new native.Atchara(this.root, this.defs.length > 0 ? this.defs : void 0);
+    this.indexMap = buildIndexMap(this.root, this.defs);
+  }
+  root;
+  defs;
+  native;
+  indexMap;
+  parse(input) {
+    const [isError, bytes] = this.native.parse(input);
+    if (isError) {
+      const errorDecoder = new ErrorDecoder(bytes);
+      throw errorDecoder.decode();
+    }
+    const store = new MemoryStore(bytes, this.root, this.indexMap, this.defs);
+    return core.wrapDeferred(store, [], this.root);
+  }
+  /**
+   * Parse a JSON array from a stream, yielding each element as it is parsed.
+   * Only valid when the root schema is an array.
+   * Yielded deferreds become invalid after the iterator completes.
+   */
+  async *parseEach(stream) {
+    const [session, redbClient] = this.native.createIteratingSession();
+    const arraySchema = this.root;
+    const store = new RedbStore(redbClient, this.root, this.indexMap, this.defs);
+    try {
+      let complete = false;
+      for await (const chunk of stream) {
+        const bytes = buffer.Buffer.isBuffer(chunk) ? chunk : buffer.Buffer.from(chunk);
+        const result = session.feed(bytes);
+        for (const index of result.readyIndices) {
+          yield core.wrapDeferred(store, [String(index)], arraySchema.elements);
+        }
+        if (result.status === -1) {
+          const errorDecoder = new ErrorDecoder(result.errorBytes);
+          throw errorDecoder.decode();
+        }
+        if (result.status === 0) {
+          complete = true;
+          break;
+        }
+      }
+      if (!complete) {
+        const result = session.finish();
+        for (const index of result.readyIndices) {
+          yield core.wrapDeferred(store, [String(index)], arraySchema.elements);
+        }
+        if (result.status === -1) {
+          const errorDecoder = new ErrorDecoder(result.errorBytes);
+          throw errorDecoder.decode();
+        }
+      }
+    } finally {
+      session.abort();
+      store.close();
+    }
+  }
+  /**
+   * Parse large JSON documents incrementally from a readable stream.
+   * Parses and stores to redb as chunks arrive - never buffers the entire document.
+   * Enables parsing files larger than available RAM.
+   * Returns a result object with explicit close() for resource management.
+   */
+  async parseLarge(stream) {
+    const session = this.native.createStreamingSession();
+    try {
+      for await (const chunk of stream) {
+        const bytes = buffer.Buffer.isBuffer(chunk) ? chunk : buffer.Buffer.from(chunk);
+        const [status, errorBytes2] = session.feed(bytes);
+        if (status === -1) {
+          const errorDecoder = new ErrorDecoder(errorBytes2);
+          throw errorDecoder.decode();
+        }
+        if (status === 0) break;
+      }
+      const [isError, errorBytes, redbClient] = session.finish();
+      if (isError || !redbClient) {
+        const errorDecoder = new ErrorDecoder(errorBytes);
+        throw errorDecoder.decode();
+      }
+      const store = new RedbStore(redbClient, this.root, this.indexMap, this.defs);
+      const deferred = core.wrapDeferred(store, [], this.root);
+      return {
+        data: deferred,
+        close: () => store.close(),
+        get isClosed() {
+          return store.isClosed;
+        }
+      };
+    } catch (error) {
+      session.abort();
+      throw error;
+    }
+  }
+};
+function buildIndexMap(schema, defs) {
+  const map = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const traverse = (s, pathParts) => {
+    if (s.schemaIndex !== void 0) {
+      const pathKey = encodePath(pathParts);
+      map.set(pathKey, s.schemaIndex);
+    }
+    switch (s.kind) {
+      case "optional":
+      case "nullable":
+        break;
+      case "object":
+        for (const field of s.objectFields) {
+          const fieldPath = [...pathParts, field.key];
+          traverse(field.schema, fieldPath);
+        }
+        break;
+      case "array":
+        break;
+      case "tuple":
+        for (let i = 0; i < s.elements.length; i++) {
+          const element = s.elements[i];
+          if (!element) continue;
+          const elementPath = [...pathParts, String(i)];
+          traverse(element, elementPath);
+        }
+        break;
+      case "record":
+        break;
+      case "union":
+        break;
+      case "ref": {
+        if (!visited.has(s.defId)) {
+          visited.add(s.defId);
+          const target = defs[s.defId];
+          if (target) {
+            traverse(target, pathParts);
+          }
+        }
+        break;
+      }
+    }
+  };
+  traverse(schema, []);
+  return map;
+}
+
+// src/schema/string.ts
+var StringSchema = class _StringSchema {
+  _output;
+  _input;
+  _deferred;
+  _constraints;
+  _parser;
+  get schema() {
+    return this;
+  }
+  get constraints() {
+    return this._constraints;
+  }
+  min(n) {
+    const s = new _StringSchema();
+    s._constraints = { ...this._constraints, min: n };
+    return s;
+  }
+  max(n) {
+    const s = new _StringSchema();
+    s._constraints = { ...this._constraints, max: n };
+    return s;
+  }
+  pattern(regex) {
+    const s = new _StringSchema();
+    s._constraints = {
+      ...this._constraints,
+      pattern: typeof regex === "string" ? regex : regex.source
+    };
+    return s;
+  }
+  parse(input) {
+    return this.getParser().parse(input);
+  }
+  parseLarge(stream) {
+    return this.getParser().parseLarge(stream);
+  }
+  getParser() {
+    if (!this._parser) {
+      this._parser = new NativeParser(this);
+    }
+    return this._parser;
+  }
+  serializeSchema(counter, _lazy) {
+    return {
+      kind: "string",
+      schemaIndex: counter ? counter.value++ : void 0,
+      ...this._constraints && { constraints: this._constraints }
+    };
+  }
+};
+
+// src/schema/object.ts
+var ObjectSchema = class {
+  // can't make it private: https://github.com/microsoft/TypeScript/issues/35822
+  constructor(_shape) {
+    this._shape = _shape;
+  }
+  _output;
+  _input;
+  _deferred;
+  serializeSchema(counter, lazy2) {
+    return {
+      kind: "object",
+      schemaIndex: counter ? counter.value++ : void 0,
+      objectFields: Object.entries(this._shape).map(([key, parser], index) => ({
+        key,
+        index,
+        schema: parser.schema.serializeSchema(counter, lazy2)
+      }))
+    };
+  }
+};
+
+// src/schema/number.ts
+var NumberSchema = class _NumberSchema {
+  _output;
+  _input;
+  _deferred;
+  _constraints;
+  _parser;
+  get schema() {
+    return this;
+  }
+  get constraints() {
+    return this._constraints;
+  }
+  min(n) {
+    const s = new _NumberSchema();
+    s._constraints = { ...this._constraints, min: n };
+    return s;
+  }
+  max(n) {
+    const s = new _NumberSchema();
+    s._constraints = { ...this._constraints, max: n };
+    return s;
+  }
+  gt(n) {
+    const s = new _NumberSchema();
+    s._constraints = { ...this._constraints, gt: n };
+    return s;
+  }
+  lt(n) {
+    const s = new _NumberSchema();
+    s._constraints = { ...this._constraints, lt: n };
+    return s;
+  }
+  multipleOf(n) {
+    const s = new _NumberSchema();
+    s._constraints = { ...this._constraints, multipleOf: n };
+    return s;
+  }
+  parse(input) {
+    return this.getParser().parse(input);
+  }
+  parseLarge(stream) {
+    return this.getParser().parseLarge(stream);
+  }
+  getParser() {
+    if (!this._parser) {
+      this._parser = new NativeParser(this);
+    }
+    return this._parser;
+  }
+  serializeSchema(counter, _lazy) {
+    return {
+      kind: "number",
+      schemaIndex: counter ? counter.value++ : void 0,
+      ...this._constraints && { constraints: this._constraints }
+    };
+  }
+};
+
+// src/schema/integer.ts
+var IntegerSchema = class _IntegerSchema {
+  _output;
+  _input;
+  _deferred;
+  _constraints;
+  _parser;
+  get schema() {
+    return this;
+  }
+  get constraints() {
+    return this._constraints;
+  }
+  min(n) {
+    const s = new _IntegerSchema();
+    s._constraints = { ...this._constraints, min: n };
+    return s;
+  }
+  max(n) {
+    const s = new _IntegerSchema();
+    s._constraints = { ...this._constraints, max: n };
+    return s;
+  }
+  gt(n) {
+    const s = new _IntegerSchema();
+    s._constraints = { ...this._constraints, gt: n };
+    return s;
+  }
+  lt(n) {
+    const s = new _IntegerSchema();
+    s._constraints = { ...this._constraints, lt: n };
+    return s;
+  }
+  multipleOf(n) {
+    const s = new _IntegerSchema();
+    s._constraints = { ...this._constraints, multipleOf: n };
+    return s;
+  }
+  parse(input) {
+    return this.getParser().parse(input);
+  }
+  parseLarge(stream) {
+    return this.getParser().parseLarge(stream);
+  }
+  getParser() {
+    if (!this._parser) {
+      this._parser = new NativeParser(this);
+    }
+    return this._parser;
+  }
+  serializeSchema(counter, _lazy) {
+    return {
+      kind: "integer",
+      schemaIndex: counter ? counter.value++ : void 0,
+      ...this._constraints && { constraints: this._constraints }
+    };
+  }
+};
+
+// src/schema/boolean.ts
+var BooleanSchema = class {
+  _output;
+  _input;
+  _deferred;
+  serializeSchema(counter, _lazy) {
+    return { kind: "boolean", schemaIndex: counter ? counter.value++ : void 0 };
+  }
+};
+
+// src/schema/nullable.ts
+var NullableSchema = class {
+  // can't make it private: https://github.com/microsoft/TypeScript/issues/35822
+  constructor(_valueParser) {
+    this._valueParser = _valueParser;
+  }
+  _output;
+  _input;
+  _deferred;
+  // Brand to distinguish from OptionalSchema (which has identical structure)
+  _brand = "nullable";
+  serializeSchema(counter, lazy2) {
+    return {
+      kind: "nullable",
+      schemaIndex: counter ? counter.value++ : void 0,
+      inner: this._valueParser.schema.serializeSchema(null, lazy2)
+    };
+  }
+};
+
+// src/schema/optional.ts
+var OptionalSchema = class {
+  // can't make it private: https://github.com/microsoft/TypeScript/issues/35822
+  constructor(_valueParser) {
+    this._valueParser = _valueParser;
+  }
+  _output;
+  _input;
+  _deferred;
+  // Brand to distinguish from NullableSchema (which has identical structure)
+  _brand = "optional";
+  serializeSchema(counter, lazy2) {
+    return {
+      kind: "optional",
+      schemaIndex: counter ? counter.value++ : void 0,
+      inner: this._valueParser.schema.serializeSchema(null, lazy2)
+    };
+  }
+};
+
+// src/schema/literal.ts
+var LiteralSchema = class {
+  // can't make it private: https://github.com/microsoft/TypeScript/issues/35822
+  constructor(_value) {
+    this._value = _value;
+  }
+  _output;
+  _input;
+  _deferred;
+  serializeSchema(counter, _lazy) {
+    return {
+      kind: "literal",
+      value: this._value,
+      schemaIndex: counter ? counter.value++ : void 0
+    };
+  }
+};
+
+// src/schema/tuple.ts
+var TupleSchema = class {
+  // can't make it private: https://github.com/microsoft/TypeScript/issues/35822
+  constructor(_elements) {
+    this._elements = _elements;
+  }
+  _output;
+  _input;
+  _deferred;
+  serializeSchema(counter, lazy2) {
+    return {
+      kind: "tuple",
+      schemaIndex: counter ? counter.value++ : void 0,
+      elements: this._elements.map((e) => e.schema.serializeSchema(counter, lazy2))
+    };
+  }
+};
+
+// src/schema/record.ts
+var RecordSchema = class _RecordSchema {
+  // can't make it private: https://github.com/microsoft/TypeScript/issues/35822
+  constructor(_valueSchema) {
+    this._valueSchema = _valueSchema;
+  }
+  _output;
+  _input;
+  _deferred;
+  _constraints;
+  _parser;
+  get schema() {
+    return this;
+  }
+  get constraints() {
+    return this._constraints;
+  }
+  min(n) {
+    const s = new _RecordSchema(this._valueSchema);
+    s._constraints = { ...this._constraints, min: n };
+    return s;
+  }
+  max(n) {
+    const s = new _RecordSchema(this._valueSchema);
+    s._constraints = { ...this._constraints, max: n };
+    return s;
+  }
+  parse(input) {
+    return this.getParser().parse(input);
+  }
+  parseLarge(stream) {
+    return this.getParser().parseLarge(stream);
+  }
+  getParser() {
+    if (!this._parser) {
+      this._parser = new NativeParser(this);
+    }
+    return this._parser;
+  }
+  serializeSchema(counter, lazy2) {
+    return {
+      kind: "record",
+      schemaIndex: counter ? counter.value++ : void 0,
+      valueSchema: this._valueSchema.schema.serializeSchema(null, lazy2),
+      ...this._constraints && { constraints: this._constraints }
+    };
+  }
+};
+var UnionSchema = class {
+  constructor(_variants) {
+    this._variants = _variants;
+    for (const variant of _variants) {
+      if (variant.schema instanceof OptionalSchema) {
+        throw core.createAtcharaError(
+          "optional() cannot be used as a union variant. optional() is for object fields that may be absent. Use nullable() if you want a value that can be null.",
+          {
+            code: "INVALID_SCHEMA"
+          }
+        );
+      }
+    }
+  }
+  _output;
+  _input;
+  _deferred;
+  serializeSchema(counter, lazy2) {
+    return {
+      kind: "union",
+      schemaIndex: counter ? counter.value++ : void 0,
+      variants: this._variants.map((v) => v.schema.serializeSchema(null, lazy2))
+    };
+  }
+};
+
+// src/schema/array.ts
+var ArraySchema = class _ArraySchema {
+  // can't make it private: https://github.com/microsoft/TypeScript/issues/35822
+  constructor(_elements) {
+    this._elements = _elements;
+  }
+  _output;
+  _input;
+  _deferred;
+  _constraints;
+  _parser;
+  get schema() {
+    return this;
+  }
+  get constraints() {
+    return this._constraints;
+  }
+  min(n) {
+    const s = new _ArraySchema(this._elements);
+    s._constraints = { ...this._constraints, min: n };
+    return s;
+  }
+  max(n) {
+    const s = new _ArraySchema(this._elements);
+    s._constraints = { ...this._constraints, max: n };
+    return s;
+  }
+  parse(input) {
+    return this.getParser().parse(input);
+  }
+  parseLarge(stream) {
+    return this.getParser().parseLarge(stream);
+  }
+  /**
+   * Parse a JSON array from a stream, yielding each element's deferred wrapper as it is parsed.
+   * Yielded deferreds become invalid after the iterator completes.
+   */
+  parseEach(stream) {
+    return this.getParser().parseEach(stream);
+  }
+  getParser() {
+    if (!this._parser) {
+      this._parser = new NativeParser(this);
+    }
+    return this._parser;
+  }
+  serializeSchema(counter, lazy2) {
+    return {
+      kind: "array",
+      schemaIndex: counter ? counter.value++ : void 0,
+      elements: this._elements.schema.serializeSchema(null, lazy2),
+      ...this._constraints && { constraints: this._constraints }
+    };
+  }
+};
+
+// src/schema/lazy.ts
+var LazySchema = class {
+  constructor(_thunk) {
+    this._thunk = _thunk;
+  }
+  _output;
+  _input;
+  _deferred;
+  _resolved;
+  _parser;
+  // Guards against re-entrant thunk resolution (e.g., object() inside thunk
+  // eagerly creates NativeParser which re-enters serializeSchema)
+  _resolving = false;
+  get schema() {
+    return this;
+  }
+  parse(input) {
+    return this.getParser().parse(input);
+  }
+  parseLarge(stream) {
+    return this.getParser().parseLarge(stream);
+  }
+  getParser() {
+    if (!this._parser) {
+      this._parser = new NativeParser(this);
+    }
+    return this._parser;
+  }
+  resolve() {
+    if (!this._resolved) {
+      this._resolved = this._thunk();
+    }
+    return this._resolved;
+  }
+  serializeSchema(counter, lazy2) {
+    if (lazy2?.seen.has(this)) {
+      return { kind: "ref", defId: lazy2.seen.get(this) };
+    }
+    if (this._resolving) {
+      return { kind: "ref", defId: 0 };
+    }
+    let defId;
+    if (lazy2) {
+      defId = lazy2.defs.length;
+      lazy2.seen.set(this, defId);
+      lazy2.defs.push(void 0);
+    }
+    this._resolving = true;
+    const resolved = this.resolve();
+    this._resolving = false;
+    const inner = resolved.schema.serializeSchema(counter, lazy2);
+    if (lazy2 && defId !== void 0) {
+      lazy2.defs[defId] = inner;
+      return { kind: "ref", defId };
+    }
+    return inner;
+  }
+};
+
+// src/base.ts
+async function initialize() {
+}
+function string() {
+  return new StringSchema();
+}
+function number() {
+  return new NumberSchema();
+}
+function integer() {
+  return new IntegerSchema();
+}
+function boolean() {
+  const schema = new BooleanSchema();
+  const parser = new NativeParser(schema);
+  return parser;
+}
+function nullable(valueParser) {
+  const schema = new NullableSchema(valueParser);
+  const parser = new NativeParser(schema);
+  return parser;
+}
+function optional(valueParser) {
+  const schema = new OptionalSchema(valueParser);
+  const parser = new NativeParser(schema);
+  return parser;
+}
+function object(shape) {
+  const schema = new ObjectSchema(shape);
+  const parser = new NativeParser(schema);
+  return parser;
+}
+function array(elements) {
+  return new ArraySchema(elements);
+}
+function literal(value) {
+  const schema = new LiteralSchema(value);
+  const parser = new NativeParser(schema);
+  return parser;
+}
+function tuple(elements) {
+  const schema = new TupleSchema(elements);
+  const parser = new NativeParser(schema);
+  return parser;
+}
+function record(valueSchema) {
+  return new RecordSchema(valueSchema);
+}
+function union(variants) {
+  const schema = new UnionSchema(variants);
+  const parser = new NativeParser(schema);
+  return parser;
+}
+function lazy(fn) {
+  return new LazySchema(fn);
+}
+
+Object.defineProperty(exports, "DeferredArray", {
+  enumerable: true,
+  get: function () { return core.DeferredArray; }
+});
+Object.defineProperty(exports, "DeferredNullable", {
+  enumerable: true,
+  get: function () { return core.DeferredNullable; }
+});
+Object.defineProperty(exports, "DeferredObject", {
+  enumerable: true,
+  get: function () { return core.DeferredObject; }
+});
+Object.defineProperty(exports, "DeferredPrimitive", {
+  enumerable: true,
+  get: function () { return core.DeferredPrimitive; }
+});
+Object.defineProperty(exports, "DeferredRecord", {
+  enumerable: true,
+  get: function () { return core.DeferredRecord; }
+});
+Object.defineProperty(exports, "DeferredTuple", {
+  enumerable: true,
+  get: function () { return core.DeferredTuple; }
+});
+Object.defineProperty(exports, "DeferredUnion", {
+  enumerable: true,
+  get: function () { return core.DeferredUnion; }
+});
+Object.defineProperty(exports, "isAtcharaError", {
+  enumerable: true,
+  get: function () { return core.isAtcharaError; }
+});
+Object.defineProperty(exports, "toBytes", {
+  enumerable: true,
+  get: function () { return core.toBytes; }
+});
+Object.defineProperty(exports, "wrapDeferred", {
+  enumerable: true,
+  get: function () { return core.wrapDeferred; }
+});
+exports.ArraySchema = ArraySchema;
+exports.IntegerSchema = IntegerSchema;
+exports.LazySchema = LazySchema;
+exports.NumberSchema = NumberSchema;
+exports.StringSchema = StringSchema;
+exports.array = array;
+exports.boolean = boolean;
+exports.initialize = initialize;
+exports.integer = integer;
+exports.lazy = lazy;
+exports.literal = literal;
+exports.nullable = nullable;
+exports.number = number;
+exports.object = object;
+exports.optional = optional;
+exports.record = record;
+exports.string = string;
+exports.tuple = tuple;
+exports.union = union;