@sofa-buffers/corelib 0.8.0

package/dist/index.js

@@ -0,0 +1,1936 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/public.ts
+var public_exports = {};
+__export(public_exports, {
+  API_VERSION: () => API_VERSION,
+  ARRAY_MAX: () => ARRAY_MAX,
+  ArrayKind: () => ArrayKind,
+  Cursor: () => Cursor,
+  DecodeStatus: () => DecodeStatus,
+  FIXLEN_MAX: () => FIXLEN_MAX,
+  FixlenSubtype: () => FixlenSubtype,
+  I64_MAX: () => I64_MAX,
+  I64_MIN: () => I64_MIN,
+  ID_MAX: () => ID_MAX,
+  IStream: () => IStream,
+  Long: () => Long,
+  MAX_DEPTH: () => MAX_DEPTH,
+  OStream: () => OStream,
+  SofabError: () => SofabError,
+  SofabErrorCode: () => SofabErrorCode,
+  U64_MAX: () => U64_MAX,
+  WireType: () => WireType,
+  decode: () => decode,
+  getKernel: () => getKernel,
+  jsKernel: () => jsKernel,
+  loadNativeKernel: () => loadNativeKernel,
+  loadWasmKernel: () => loadWasmKernel,
+  setKernel: () => setKernel
+});
+
+// src/constants.ts
+var API_VERSION = 1;
+var WireType = {
+  /** Unsigned varint scalar. */
+  Unsigned: 0,
+  /** Signed varint scalar (zig-zag encoded). */
+  Signed: 1,
+  /** Fixed-length value: fp32, fp64, string or blob (see {@link FixlenSubtype}). */
+  Fixlen: 2,
+  /** Array of unsigned varints. */
+  ArrayUnsigned: 3,
+  /** Array of signed (zig-zag) varints. */
+  ArraySigned: 4,
+  /** Array of fixed-length values (fp32 / fp64 only). */
+  ArrayFixlen: 5,
+  /** Opens a nested sequence (new id scope). */
+  SequenceStart: 6,
+  /** Closes the current sequence. Encoded as the single byte `0x07`. */
+  SequenceEnd: 7
+};
+var FixlenSubtype = {
+  /** IEEE-754 32-bit float, little-endian. */
+  Fp32: 0,
+  /** IEEE-754 64-bit double, little-endian. */
+  Fp64: 1,
+  /** UTF-8 string (no null terminator). */
+  String: 2,
+  /** Arbitrary binary data. */
+  Blob: 3
+};
+var ArrayKind = {
+  /** Unsigned-integer elements. */
+  Unsigned: 0,
+  /** Signed-integer (zig-zag) elements. */
+  Signed: 1,
+  /** IEEE-754 32-bit float elements. */
+  Fp32: 2,
+  /** IEEE-754 64-bit double elements. */
+  Fp64: 3
+};
+var ID_MAX = 2147483647;
+var FIXLEN_MAX = 2147483647;
+var ARRAY_MAX = 2147483647;
+var U64_MAX = 0xffffffffffffffffn;
+var I64_MIN = -0x8000000000000000n;
+var I64_MAX = 0x7fffffffffffffffn;
+var VARINT_MAX_BYTES = 10;
+var MAX_DEPTH = 255;
+var DecodeStatus = {
+  /** The bytes ended exactly at a field boundary — a valid message. */
+  Complete: "COMPLETE",
+  /** The bytes ended inside a field; more bytes could complete it (not an error). */
+  Incomplete: "INCOMPLETE",
+  /** The bytes are malformed regardless of what follows. */
+  Invalid: "INVALID"
+};
+
+// src/errors.ts
+var SofabErrorCode = {
+  /** A caller argument was invalid (e.g. id out of range, empty array). */
+  Argument: "ARGUMENT",
+  /** The API was used incorrectly (e.g. unbalanced sequence end). */
+  Usage: "USAGE",
+  /** The output buffer is full and no flush sink was provided. */
+  BufferFull: "BUFFER_FULL",
+  /** The input being decoded is malformed regardless of what follows (`INVALID`). */
+  InvalidMsg: "INVALID_MSG",
+  /**
+   * The input being decoded ends inside a field (`INCOMPLETE`, MESSAGE_SPEC §7):
+   * an unterminated varint, a payload shorter than its declared length, an array
+   * that runs off the end, or a nested sequence never closed. Not a malformed
+   * message — more bytes could complete it, and the caller owns end-of-input.
+   */
+  Incomplete: "INCOMPLETE",
+  /**
+   * A receiver-configured decode limit was exceeded — a dynamic array, string or
+   * blob on the wire claims more elements / bytes than the caller's
+   * {@link DecodeLimits} (`maxArrayCount` / `maxStringLen` / `maxBlobLen`)
+   * allows. Deliberately distinct from {@link SofabErrorCode.InvalidMsg}:
+   * exceeding a limit is *policy*, not wire malformation — the identical bytes
+   * decode fine under a looser limit — so differential fuzzing must not read it
+   * as a conformance divergence. The decoder never clamps or truncates; it
+   * rejects, before the offending field is materialized.
+   */
+  LimitExceeded: "LIMIT_EXCEEDED"
+};
+var SofabError = class _SofabError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "SofabError";
+    this.code = code;
+    Object.setPrototypeOf(this, _SofabError.prototype);
+  }
+};
+function argumentError(message) {
+  return new SofabError(SofabErrorCode.Argument, message);
+}
+function usageError(message) {
+  return new SofabError(SofabErrorCode.Usage, message);
+}
+function bufferFullError(message) {
+  return new SofabError(SofabErrorCode.BufferFull, message);
+}
+function invalidMsgError(message) {
+  return new SofabError(SofabErrorCode.InvalidMsg, message);
+}
+function incompleteError(message) {
+  return new SofabError(SofabErrorCode.Incomplete, message);
+}
+function limitExceededError(message) {
+  return new SofabError(SofabErrorCode.LimitExceeded, message);
+}
+
+// src/long.ts
+var _Long = class _Long {
+  constructor(low, high) {
+    this.low = low >>> 0;
+    this.high = high >>> 0;
+  }
+  /** Construct from raw 32-bit halves. */
+  static fromBits(low, high) {
+    return new _Long(low, high);
+  }
+  /** Split a `bigint` into its low/high 32-bit halves (two's complement). */
+  static fromBigInt(value) {
+    return new _Long(Number(value & 0xffffffffn) >>> 0, Number(value >> 32n & 0xffffffffn) >>> 0);
+  }
+  /** From an integer `number` (`|n| < 2^53`); sign handled via `bigint` once. */
+  static fromNumber(n) {
+    return _Long.fromBigInt(BigInt(Math.trunc(n)));
+  }
+  /** Accept a `Long` as-is, or convert a `bigint` / `number` once. */
+  static fromValue(v) {
+    if (v instanceof _Long) return v;
+    return typeof v === "bigint" ? _Long.fromBigInt(v) : _Long.fromNumber(v);
+  }
+  /** Materialise as a `bigint`. `signed` reads the high bit as two's complement. */
+  toBigInt(signed = false) {
+    let r = BigInt(this.high >>> 0) << 32n | BigInt(this.low >>> 0);
+    if (signed && (this.high & 2147483648) !== 0) r -= 0x10000000000000000n;
+    return r;
+  }
+  /** Decimal string (`signed` interprets the high bit as two's complement). */
+  toString(signed = false) {
+    return this.toBigInt(signed).toString();
+  }
+};
+/**
+ * The 64-bit zero. `Long` is immutable (readonly halves), so this single shared
+ * instance is safe to reuse anywhere a zero default is needed — generated code
+ * uses it for fixed-count array defaults and pad-fill instead of
+ * `Long.fromValue(0)`, which would run `bigint` arithmetic per call on the hot
+ * decode/encode path.
+ */
+_Long.ZERO = new _Long(0, 0);
+var Long = _Long;
+
+// src/varint/leb128.ts
+function varintSize(value) {
+  let lo = Number(value & 0xffffffffn) >>> 0;
+  let hi = Number(value >> 32n & 0xffffffffn) >>> 0;
+  let n = 0;
+  while (hi !== 0) {
+    n++;
+    const next = (lo >>> 7 | hi << 25) >>> 0;
+    hi >>>= 7;
+    lo = next;
+  }
+  while (lo > 127) {
+    n++;
+    lo >>>= 7;
+  }
+  return n + 1;
+}
+function encodeVarint(value, out, pos) {
+  let lo = Number(value & 0xffffffffn) >>> 0;
+  let hi = Number(value >> 32n & 0xffffffffn) >>> 0;
+  while (hi !== 0) {
+    out[pos++] = lo & 127 | 128;
+    lo = (lo >>> 7 | hi << 25) >>> 0;
+    hi >>>= 7;
+  }
+  while (lo > 127) {
+    out[pos++] = lo & 127 | 128;
+    lo >>>= 7;
+  }
+  out[pos++] = lo;
+  return pos;
+}
+function encodeVarintLoHi(lo, hi, out, pos) {
+  lo >>>= 0;
+  hi >>>= 0;
+  while (hi !== 0) {
+    out[pos++] = lo & 127 | 128;
+    lo = (lo >>> 7 | hi << 25) >>> 0;
+    hi >>>= 7;
+  }
+  while (lo > 127) {
+    out[pos++] = lo & 127 | 128;
+    lo >>>= 7;
+  }
+  out[pos++] = lo;
+  return pos;
+}
+function varintSizeNum(value) {
+  let n = 1;
+  while (value > 127) {
+    n++;
+    value = Math.floor(value / 128);
+  }
+  return n;
+}
+function encodeVarintNum(value, out, pos) {
+  if (value < 4294967296) {
+    let v = value;
+    while (v > 127) {
+      out[pos++] = v & 127 | 128;
+      v >>>= 7;
+    }
+    out[pos++] = v;
+    return pos;
+  }
+  while (value > 127) {
+    out[pos++] = value % 128 | 128;
+    value = Math.floor(value / 128);
+  }
+  out[pos++] = value;
+  return pos;
+}
+
+// src/varint/num64.ts
+var SCRATCH = new DataView(new ArrayBuffer(8));
+function toBigInt(value) {
+  if (typeof value === "bigint") return value;
+  if (!Number.isInteger(value)) {
+    throw new RangeError(`expected an integer, got ${value}`);
+  }
+  return BigInt(value);
+}
+function inU64(value) {
+  return value >= 0n && value <= U64_MAX;
+}
+function inI64(value) {
+  return value >= I64_MIN && value <= I64_MAX;
+}
+function packFp32(out, pos, value) {
+  SCRATCH.setFloat32(0, value, true);
+  out[pos] = SCRATCH.getUint8(0);
+  out[pos + 1] = SCRATCH.getUint8(1);
+  out[pos + 2] = SCRATCH.getUint8(2);
+  out[pos + 3] = SCRATCH.getUint8(3);
+  return pos + 4;
+}
+function packFp64(out, pos, value) {
+  SCRATCH.setFloat64(0, value, true);
+  for (let i = 0; i < 8; i++) out[pos + i] = SCRATCH.getUint8(i);
+  return pos + 8;
+}
+function unpackFp32(buf, pos) {
+  SCRATCH.setUint8(0, buf[pos]);
+  SCRATCH.setUint8(1, buf[pos + 1]);
+  SCRATCH.setUint8(2, buf[pos + 2]);
+  SCRATCH.setUint8(3, buf[pos + 3]);
+  return SCRATCH.getFloat32(0, true);
+}
+function unpackFp64(buf, pos) {
+  for (let i = 0; i < 8; i++) SCRATCH.setUint8(i, buf[pos + i]);
+  return SCRATCH.getFloat64(0, true);
+}
+
+// src/varint/zigzag.ts
+function zigzagEncode(value) {
+  return (value << 1n ^ value >> 63n) & U64_MAX;
+}
+function zigzagDecode(value) {
+  return value >> 1n ^ -(value & 1n);
+}
+
+// src/backend/js.ts
+var SIGNED_FAST_MAX = 4503599627370496;
+var jsKernel = {
+  name: "js",
+  encodeUnsignedVarints(values, out, pos) {
+    for (let i = 0; i < values.length; i++) {
+      const v = values[i];
+      if (typeof v === "number" && v >= 0 && v <= Number.MAX_SAFE_INTEGER && Number.isInteger(v)) {
+        pos = encodeVarintNum(v, out, pos);
+      } else {
+        pos = encodeVarint(toBigInt(v), out, pos);
+      }
+    }
+    return pos;
+  },
+  encodeSignedVarints(values, out, pos) {
+    for (let i = 0; i < values.length; i++) {
+      const v = values[i];
+      if (typeof v === "number" && v >= -SIGNED_FAST_MAX && v <= SIGNED_FAST_MAX && Number.isInteger(v)) {
+        pos = encodeVarintNum(v >= 0 ? v * 2 : -v * 2 - 1, out, pos);
+      } else {
+        pos = encodeVarint(zigzagEncode(toBigInt(v)), out, pos);
+      }
+    }
+    return pos;
+  },
+  packFp32Array(values, out, pos) {
+    for (let i = 0; i < values.length; i++) {
+      pos = packFp32(out, pos, values[i]);
+    }
+    return pos;
+  },
+  packFp64Array(values, out, pos) {
+    for (let i = 0; i < values.length; i++) {
+      pos = packFp64(out, pos, values[i]);
+    }
+    return pos;
+  }
+};
+
+// src/backend/kernel.ts
+var active = jsKernel;
+function setKernel(kernel) {
+  validateKernel(kernel);
+  active = kernel;
+}
+function getKernel() {
+  return active;
+}
+function validateKernel(kernel) {
+  const required = [
+    "encodeUnsignedVarints",
+    "encodeSignedVarints",
+    "packFp32Array",
+    "packFp64Array"
+  ];
+  for (const m of required) {
+    if (typeof kernel[m] !== "function") {
+      throw new TypeError(`kernel "${kernel?.name}" is missing ${String(m)}()`);
+    }
+  }
+}
+
+// src/encode/fixlen.ts
+var UTF8 = new TextEncoder();
+function unpairedSurrogate(index) {
+  return argumentError(
+    `unpaired surrogate at index ${index}: string value is not valid UTF-8`
+  );
+}
+function encodeUtf8(text) {
+  utf8Length(text);
+  return UTF8.encode(text);
+}
+function utf8Length(text) {
+  let len = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c < 128) {
+      len += 1;
+    } else if (c < 2048) {
+      len += 2;
+    } else if (c >= 55296 && c <= 56319) {
+      const c2 = i + 1 < text.length ? text.charCodeAt(i + 1) : 0;
+      if (c2 >= 56320 && c2 <= 57343) {
+        i++;
+        len += 4;
+      } else {
+        throw unpairedSurrogate(i);
+      }
+    } else if (c >= 56320 && c <= 57343) {
+      throw unpairedSurrogate(i);
+    } else {
+      len += 3;
+    }
+  }
+  return len;
+}
+function utf8Write(text, out, pos) {
+  for (let i = 0; i < text.length; i++) {
+    let c = text.charCodeAt(i);
+    if (c < 128) {
+      out[pos++] = c;
+    } else if (c < 2048) {
+      out[pos++] = 192 | c >> 6;
+      out[pos++] = 128 | c & 63;
+    } else if (c >= 55296 && c <= 56319) {
+      const c2 = i + 1 < text.length ? text.charCodeAt(i + 1) : 0;
+      if (c2 >= 56320 && c2 <= 57343) {
+        i++;
+        c = 65536 + (c - 55296 << 10) + (c2 - 56320);
+        out[pos++] = 240 | c >> 18;
+        out[pos++] = 128 | c >> 12 & 63;
+        out[pos++] = 128 | c >> 6 & 63;
+        out[pos++] = 128 | c & 63;
+      } else {
+        throw unpairedSurrogate(i);
+      }
+    } else if (c >= 56320 && c <= 57343) {
+      throw unpairedSurrogate(i);
+    } else {
+      out[pos++] = 224 | c >> 12;
+      out[pos++] = 128 | c >> 6 & 63;
+      out[pos++] = 128 | c & 63;
+    }
+  }
+  return pos;
+}
+
+// src/encode/ostream.ts
+var DEFAULT_CAPACITY = 256;
+var SIGNED_FAST_MAX2 = 4503599627370496;
+var OStream = class {
+  constructor(buffer, offset = 0, flush) {
+    this.depth = 0;
+    this.kernel = getKernel();
+    if (buffer === void 0) {
+      this.buf = new Uint8Array(DEFAULT_CAPACITY);
+      this.start = 0;
+      this.pos = 0;
+      this.flushSink = void 0;
+      this.canGrow = true;
+    } else {
+      if (offset < 0 || offset > buffer.length) {
+        throw argumentError(`offset ${offset} out of range`);
+      }
+      this.buf = buffer;
+      this.start = offset;
+      this.pos = offset;
+      this.flushSink = flush;
+      this.canGrow = false;
+    }
+  }
+  /** Bytes currently held in the buffer (since construction or the last flush). */
+  get bytesUsed() {
+    return this.pos - this.start;
+  }
+  /**
+   * The encoded message so far, as a view into the working buffer.
+   * Meaningful for the in-memory mode; in streaming mode it is only the
+   * not-yet-flushed tail. The view is valid until the next write.
+   */
+  bytes() {
+    return this.buf.subarray(this.start, this.pos);
+  }
+  /** Drain buffered bytes to the flush sink (no-op without one). */
+  flush() {
+    if (this.flushSink && this.pos > this.start) {
+      this.flushSink(this.buf.subarray(this.start, this.pos));
+      this.pos = this.start;
+    }
+  }
+  /**
+   * Install a fresh output buffer to write into, mid-stream. Intended for the
+   * streaming (flush-sink) mode: call it from inside your flush callback to hand
+   * the encoder a new buffer for the next batch of bytes, so encoding continues
+   * without interruption. `offset` reserves space at the front of the new
+   * buffer. Any not-yet-flushed bytes in the old buffer are dropped, so
+   * {@link flush} first (the flush callback fires before you swap).
+   */
+  setBuffer(buffer, offset = 0) {
+    if (offset < 0 || offset > buffer.length) {
+      throw argumentError(`offset ${offset} out of range`);
+    }
+    this.buf = buffer;
+    this.start = offset;
+    this.pos = offset;
+  }
+  /**
+   * Rewind the encoder to empty, reusing the existing buffer. Lets a caller pool
+   * one OStream across many messages instead of allocating a fresh buffer per
+   * encode. Any view previously returned by {@link bytes} is invalidated.
+   */
+  reset() {
+    this.pos = this.start;
+    this.depth = 0;
+  }
+  // --- scalars ------------------------------------------------------------
+  /** Write an unsigned integer field. */
+  writeUnsigned(id, value) {
+    if (typeof value === "number" && value >= 0 && value <= Number.MAX_SAFE_INTEGER && Number.isInteger(value)) {
+      this.header(id, WireType.Unsigned);
+      this.putVarintNum(value);
+      return;
+    }
+    const v = toBigInt(value);
+    if (!inU64(v)) throw argumentError(`unsigned value ${v} out of 64-bit range`);
+    this.header(id, WireType.Unsigned);
+    this.putVarint(v);
+  }
+  /** Write a signed integer field (zig-zag encoded). */
+  writeSigned(id, value) {
+    if (typeof value === "number" && value >= -SIGNED_FAST_MAX2 && value <= SIGNED_FAST_MAX2 && Number.isInteger(value)) {
+      this.header(id, WireType.Signed);
+      this.putVarintNum(value >= 0 ? value * 2 : -value * 2 - 1);
+      return;
+    }
+    const v = toBigInt(value);
+    if (!inI64(v)) throw argumentError(`signed value ${v} out of 64-bit range`);
+    this.header(id, WireType.Signed);
+    this.putVarint(zigzagEncode(v));
+  }
+  /** Write a boolean field (encoded as the unsigned value 0 or 1). */
+  writeBoolean(id, value) {
+    this.header(id, WireType.Unsigned);
+    this.putVarintNum(value ? 1 : 0);
+  }
+  /** Write an IEEE-754 32-bit float field. */
+  writeFp32(id, value) {
+    this.fixlenHead(id, 4, FixlenSubtype.Fp32);
+    this.ensure(4);
+    this.pos = packFp32(this.buf, this.pos, value);
+  }
+  /** Write an IEEE-754 64-bit double field. */
+  writeFp64(id, value) {
+    this.fixlenHead(id, 8, FixlenSubtype.Fp64);
+    this.ensure(8);
+    this.pos = packFp64(this.buf, this.pos, value);
+  }
+  /** Write a UTF-8 string field. */
+  writeString(id, text) {
+    if (this.canGrow) {
+      const byteLen = utf8Length(text);
+      if (byteLen > FIXLEN_MAX) {
+        throw argumentError(`fixlen length ${byteLen} exceeds ${FIXLEN_MAX}`);
+      }
+      this.fixlenHead(id, byteLen, FixlenSubtype.String);
+      this.ensure(byteLen);
+      this.pos = utf8Write(text, this.buf, this.pos);
+      return;
+    }
+    this.writeFixlen(id, encodeUtf8(text), FixlenSubtype.String);
+  }
+  /** Write a blob (arbitrary bytes) field. */
+  writeBlob(id, data) {
+    this.writeFixlen(id, data, FixlenSubtype.Blob);
+  }
+  /** Write a fixed-length field of the given subtype from raw bytes. */
+  writeFixlen(id, data, subtype) {
+    if (data.length > FIXLEN_MAX) {
+      throw argumentError(`fixlen length ${data.length} exceeds ${FIXLEN_MAX}`);
+    }
+    this.fixlenHead(id, data.length, subtype);
+    this.writeRaw(data);
+  }
+  // --- arrays -------------------------------------------------------------
+  /** Write an array of unsigned integers (each a varint). */
+  writeUnsignedArray(id, values) {
+    this.arrayHead(id, WireType.ArrayUnsigned, values.length);
+    if (this.canGrow) {
+      this.ensure(values.length * VARINT_MAX_BYTES);
+      this.pos = this.kernel.encodeUnsignedVarints(values, this.buf, this.pos);
+    } else {
+      for (let i = 0; i < values.length; i++) {
+        const v = toBigInt(values[i]);
+        if (!inU64(v)) throw argumentError(`unsigned value ${v} out of range`);
+        this.ensure(VARINT_MAX_BYTES);
+        this.pos = encodeVarint(v, this.buf, this.pos);
+      }
+    }
+  }
+  /** Write an array of signed integers (each zig-zag + varint). */
+  writeSignedArray(id, values) {
+    this.arrayHead(id, WireType.ArraySigned, values.length);
+    if (this.canGrow) {
+      this.ensure(values.length * VARINT_MAX_BYTES);
+      this.pos = this.kernel.encodeSignedVarints(values, this.buf, this.pos);
+    } else {
+      for (let i = 0; i < values.length; i++) {
+        const v = toBigInt(values[i]);
+        if (!inI64(v)) throw argumentError(`signed value ${v} out of range`);
+        this.ensure(VARINT_MAX_BYTES);
+        this.pos = encodeVarint(zigzagEncode(v), this.buf, this.pos);
+      }
+    }
+  }
+  /**
+   * Write an unsigned 64-bit array from {@link Long}[] — the `bigint`-free path.
+   * Produces the identical wire to {@link writeUnsignedArray}; reads each Long's
+   * 32-bit halves directly, so no `bigint` is created per element.
+   */
+  writeUnsignedArrayLong(id, values) {
+    this.arrayHead(id, WireType.ArrayUnsigned, values.length);
+    this.ensure(values.length * VARINT_MAX_BYTES);
+    let pos = this.pos;
+    const buf = this.buf;
+    for (let i = 0; i < values.length; i++) {
+      const v = values[i];
+      pos = encodeVarintLoHi(v.low, v.high, buf, pos);
+    }
+    this.pos = pos;
+  }
+  /**
+   * Write a signed 64-bit array (zig-zag) from {@link Long}[] — the `bigint`-free
+   * path. Zig-zag `(n << 1) ^ (n >> 63)` is computed on the lo/hi pair.
+   */
+  writeSignedArrayLong(id, values) {
+    this.arrayHead(id, WireType.ArraySigned, values.length);
+    this.ensure(values.length * VARINT_MAX_BYTES);
+    let pos = this.pos;
+    const buf = this.buf;
+    for (let i = 0; i < values.length; i++) {
+      const v = values[i];
+      const lo = v.low;
+      const hi = v.high;
+      const sgn = -(hi >>> 31) >>> 0;
+      const zLo = (lo << 1 >>> 0 ^ sgn) >>> 0;
+      const zHi = ((hi << 1 | lo >>> 31) >>> 0 ^ sgn) >>> 0;
+      pos = encodeVarintLoHi(zLo, zHi, buf, pos);
+    }
+    this.pos = pos;
+  }
+  /** Write an array of IEEE-754 32-bit floats. */
+  writeFp32Array(id, values) {
+    this.arrayHead(id, WireType.ArrayFixlen, values.length);
+    this.putVarintNum(4 * 8 + FixlenSubtype.Fp32);
+    if (this.canGrow) {
+      this.ensure(values.length * 4);
+      this.pos = this.kernel.packFp32Array(values, this.buf, this.pos);
+    } else {
+      for (let i = 0; i < values.length; i++) {
+        this.ensure(4);
+        this.pos = packFp32(this.buf, this.pos, values[i]);
+      }
+    }
+  }
+  /** Write an array of IEEE-754 64-bit doubles. */
+  writeFp64Array(id, values) {
+    this.arrayHead(id, WireType.ArrayFixlen, values.length);
+    this.putVarintNum(8 * 8 + FixlenSubtype.Fp64);
+    if (this.canGrow) {
+      this.ensure(values.length * 8);
+      this.pos = this.kernel.packFp64Array(values, this.buf, this.pos);
+    } else {
+      for (let i = 0; i < values.length; i++) {
+        this.ensure(8);
+        this.pos = packFp64(this.buf, this.pos, values[i]);
+      }
+    }
+  }
+  // --- sequences ----------------------------------------------------------
+  /** Open a nested sequence (a fresh id scope). */
+  writeSequenceBegin(id) {
+    if (this.depth >= MAX_DEPTH) {
+      throw usageError(`nesting exceeds MAX_DEPTH (${MAX_DEPTH})`);
+    }
+    this.header(id, WireType.SequenceStart);
+    this.depth++;
+  }
+  /** Close the current sequence. */
+  writeSequenceEnd() {
+    if (this.depth <= 0) throw usageError("sequence end without matching begin");
+    this.ensure(1);
+    this.buf[this.pos++] = WireType.SequenceEnd;
+    this.depth--;
+  }
+  // --- internals ----------------------------------------------------------
+  /** Ensure exactly `value`'s varint size, then write it (bigint path). */
+  putVarint(value) {
+    this.ensure(varintSize(value));
+    this.pos = encodeVarint(value, this.buf, this.pos);
+  }
+  /** Ensure exactly `value`'s varint size, then write it (number fast path). */
+  putVarintNum(value) {
+    this.ensure(varintSizeNum(value));
+    this.pos = encodeVarintNum(value, this.buf, this.pos);
+  }
+  header(id, type) {
+    if (id < 0 || id > ID_MAX || !Number.isInteger(id)) {
+      throw argumentError(`field id ${id} out of range 0..${ID_MAX}`);
+    }
+    this.putVarintNum(id * 8 + type);
+  }
+  fixlenHead(id, length, subtype) {
+    this.header(id, WireType.Fixlen);
+    this.putVarintNum(length * 8 + subtype);
+  }
+  arrayHead(id, type, count) {
+    if (count < 0 || count > ARRAY_MAX) {
+      throw argumentError(`array count ${count} out of range 0..${ARRAY_MAX}`);
+    }
+    this.header(id, type);
+    this.putVarintNum(count);
+  }
+  /** Copy `data` out, flushing/growing as needed (large payloads stay chunked). */
+  writeRaw(data) {
+    let off = 0;
+    while (off < data.length) {
+      const room = this.ensureSome(data.length - off);
+      this.buf.set(data.subarray(off, off + room), this.pos);
+      this.pos += room;
+      off += room;
+    }
+  }
+  /** Ensure `n` contiguous bytes are free at `pos`; returns `pos` for chaining. */
+  ensure(n) {
+    if (this.buf.length - this.pos >= n) return this.pos;
+    this.flush();
+    if (this.buf.length - this.pos >= n) return this.pos;
+    if (this.canGrow) {
+      this.growTo(this.pos + n);
+      return this.pos;
+    }
+    throw bufferFullError(
+      `output buffer full: need ${n} more bytes, have ${this.buf.length - this.pos}`
+    );
+  }
+  /** Ensure *some* room (up to `want`); returns how many bytes are available. */
+  ensureSome(want) {
+    let room = this.buf.length - this.pos;
+    if (room === 0) {
+      this.flush();
+      room = this.buf.length - this.pos;
+      if (room === 0) {
+        if (this.canGrow) {
+          this.growTo(this.pos + want);
+          room = this.buf.length - this.pos;
+        } else {
+          throw bufferFullError("output buffer full");
+        }
+      }
+    }
+    return Math.min(room, want);
+  }
+  growTo(needed) {
+    let cap = this.buf.length * 2;
+    if (cap < needed) cap = needed;
+    const next = new Uint8Array(cap);
+    next.set(this.buf.subarray(0, this.pos));
+    this.buf = next;
+  }
+};
+
+// src/decode/fast.ts
+var TWO32 = 4294967296;
+function decodeContiguous(buf, root, limits) {
+  new FastDecoder(buf, limits).run(root);
+}
+var FastDecoder = class {
+  constructor(buf, limits) {
+    this.p = 0;
+    // Last varint, as two unsigned 32-bit halves (see readVarint).
+    this.lo = 0;
+    this.hi = 0;
+    this.buf = buf;
+    this.n = buf.length;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.length);
+    this.maxArrayCount = limits?.maxArrayCount ?? Infinity;
+    this.maxStringLen = limits?.maxStringLen ?? Infinity;
+    this.maxBlobLen = limits?.maxBlobLen ?? Infinity;
+  }
+  run(root) {
+    const stack = [root];
+    let top = root;
+    while (this.p < this.n) {
+      this.readVarint();
+      const type = this.lo & 7;
+      if (type === WireType.SequenceEnd) {
+        if (stack.length <= 1) throw invalidMsgError("unbalanced sequence end");
+        top.sequenceEnd?.();
+        stack.pop();
+        top = stack[stack.length - 1];
+        continue;
+      }
+      const id = this.upper();
+      if (id > ID_MAX) throw invalidMsgError(`field id ${id} out of range`);
+      switch (type) {
+        case WireType.Unsigned: {
+          this.readVarint();
+          top.unsigned?.(id, this.unsignedValue());
+          break;
+        }
+        case WireType.Signed: {
+          this.readVarint();
+          top.signed?.(id, this.signedValue());
+          break;
+        }
+        case WireType.Fixlen: {
+          this.readVarint();
+          const sub = this.lo & 7;
+          const len = this.upper();
+          if (sub > FixlenSubtype.Blob) throw invalidMsgError(`invalid fixlen subtype ${sub}`);
+          if (len > FIXLEN_MAX) throw invalidMsgError("fixlen length out of range");
+          if (sub === FixlenSubtype.String && len > this.maxStringLen) {
+            throw limitExceededError(`string length ${len} exceeds maxStringLen ${this.maxStringLen}`);
+          }
+          if (sub === FixlenSubtype.Blob && len > this.maxBlobLen) {
+            throw limitExceededError(`blob length ${len} exceeds maxBlobLen ${this.maxBlobLen}`);
+          }
+          if (sub === FixlenSubtype.Fp32 || sub === FixlenSubtype.Fp64) {
+            const want = sub === FixlenSubtype.Fp32 ? 4 : 8;
+            if (len !== want) throw invalidMsgError("fixlen float length mismatch");
+            const value = sub === FixlenSubtype.Fp32 ? this.readFp32() : this.readFp64();
+            if (sub === FixlenSubtype.Fp32) top.fp32?.(id, value);
+            else top.fp64?.(id, value);
+          } else {
+            const chunk = this.take(len);
+            if (sub === FixlenSubtype.String) top.string?.(id, len, 0, chunk);
+            else top.blob?.(id, len, 0, chunk);
+          }
+          break;
+        }
+        case WireType.ArrayUnsigned: {
+          const count = this.arrayCount();
+          top.arrayBegin?.(id, ArrayKind.Unsigned, count);
+          for (let i = 0; i < count; i++) {
+            this.readVarint();
+            top.arrayUnsigned?.(id, i, this.unsignedValue());
+          }
+          top.arrayEnd?.(id);
+          break;
+        }
+        case WireType.ArraySigned: {
+          const count = this.arrayCount();
+          top.arrayBegin?.(id, ArrayKind.Signed, count);
+          for (let i = 0; i < count; i++) {
+            this.readVarint();
+            top.arraySigned?.(id, i, this.signedValue());
+          }
+          top.arrayEnd?.(id);
+          break;
+        }
+        case WireType.ArrayFixlen: {
+          const count = this.arrayCount();
+          this.readVarint();
+          const sub = this.lo & 7;
+          const size = this.upper();
+          let kind;
+          if (sub === FixlenSubtype.Fp32 && size === 4) kind = ArrayKind.Fp32;
+          else if (sub === FixlenSubtype.Fp64 && size === 8) kind = ArrayKind.Fp64;
+          else throw invalidMsgError("invalid fixlen array element type");
+          top.arrayBegin?.(id, kind, count);
+          if (kind === ArrayKind.Fp32) {
+            for (let i = 0; i < count; i++) {
+              const value = this.readFp32();
+              top.arrayFp32?.(id, i, value);
+            }
+          } else {
+            for (let i = 0; i < count; i++) {
+              const value = this.readFp64();
+              top.arrayFp64?.(id, i, value);
+            }
+          }
+          top.arrayEnd?.(id);
+          break;
+        }
+        case WireType.SequenceStart: {
+          if (stack.length - 1 >= MAX_DEPTH) {
+            throw invalidMsgError(`nesting exceeds MAX_DEPTH (${MAX_DEPTH})`);
+          }
+          const child = top.sequenceBegin?.(id);
+          top = child ?? top;
+          stack.push(top);
+          break;
+        }
+        default:
+          throw invalidMsgError(`invalid wire type ${type}`);
+      }
+    }
+    if (stack.length > 1) throw incompleteError("truncated message: unbalanced sequence");
+  }
+  // --- field helpers ------------------------------------------------------
+  /** Read and validate an array count word (0..ARRAY_MAX; §4.7/§4.8). */
+  arrayCount() {
+    this.readVarint();
+    const count = this.num();
+    if (count > ARRAY_MAX) throw invalidMsgError("array count out of range");
+    if (count > this.maxArrayCount) {
+      throw limitExceededError(`array count ${count} exceeds maxArrayCount ${this.maxArrayCount}`);
+    }
+    return count;
+  }
+  /** Hand back a zero-copy view of the next `len` bytes, advancing the cursor. */
+  take(len) {
+    const start = this.p;
+    const end = start + len;
+    if (end > this.n) throw incompleteError("truncated fixlen payload");
+    this.p = end;
+    return this.buf.subarray(start, end);
+  }
+  readFp32() {
+    const p = this.p;
+    if (p + 4 > this.n) throw incompleteError("truncated fp32");
+    this.p = p + 4;
+    return this.view.getFloat32(p, true);
+  }
+  readFp64() {
+    const p = this.p;
+    if (p + 8 > this.n) throw incompleteError("truncated fp64");
+    this.p = p + 8;
+    return this.view.getFloat64(p, true);
+  }
+  // --- varint reading -----------------------------------------------------
+  /** The last varint's full value as a `bigint` (64-bit fidelity). */
+  big() {
+    return this.hi === 0 ? BigInt(this.lo >>> 0) : BigInt(this.hi >>> 0) << 32n | BigInt(this.lo >>> 0);
+  }
+  /**
+   * The last varint as an unsigned value, number-first: a `number` when it fits
+   * exactly (`≤ 2^53-1` — all ids, u8..u32 and small u64s), a `bigint` only
+   * beyond that. Skips the per-value bigint allocation on the common path.
+   */
+  unsignedValue() {
+    const hi = this.hi >>> 0;
+    return hi <= 2097151 ? hi * TWO32 + (this.lo >>> 0) : this.big();
+  }
+  /** The last zig-zag varint as a signed value, number-first (see {@link unsignedValue}). */
+  signedValue() {
+    const hi = this.hi >>> 0;
+    if (hi <= 2097151) {
+      const r = hi * TWO32 + (this.lo >>> 0);
+      return r % 2 === 0 ? r / 2 : -(r + 1) / 2;
+    }
+    return zigzagDecode(this.big());
+  }
+  /** The last varint's value as a JS number — exact for ids/lengths/counts. */
+  num() {
+    return this.hi * TWO32 + (this.lo >>> 0);
+  }
+  /** The last varint with its low 3 tag bits stripped (`value >> 3`). */
+  upper() {
+    return (this.hi >>> 0) * (TWO32 / 8) + (this.lo >>> 3);
+  }
+  /**
+   * Decode one LEB128 varint at the cursor into {@link lo} / {@link hi} (each an
+   * unsigned 32-bit half), advancing {@link p}. Throws on truncation or a value
+   * spilling past 64 bits (>10 bytes). Unrolled, number-only — no `bigint`.
+   */
+  readVarint() {
+    const buf = this.buf;
+    const n = this.n;
+    let p = this.p;
+    let b;
+    let lo;
+    let hi = 0;
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo = b & 127;
+    if (b < 128) return this.set(lo, 0, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo |= (b & 127) << 7;
+    if (b < 128) return this.set(lo, 0, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo |= (b & 127) << 14;
+    if (b < 128) return this.set(lo, 0, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo |= (b & 127) << 21;
+    if (b < 128) return this.set(lo, 0, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo |= (b & 15) << 28;
+    hi = b >> 4 & 7;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    hi |= (b & 127) << 3;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    hi |= (b & 127) << 10;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    hi |= (b & 127) << 17;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    hi |= (b & 127) << 24;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    if ((b & 127) >> 1 !== 0) throw invalidMsgError("varint overflow");
+    hi |= (b & 127) << 31;
+    if (b < 128) return this.set(lo, hi, p);
+    throw invalidMsgError("varint overflow");
+  }
+  set(lo, hi, p) {
+    this.lo = lo;
+    this.hi = hi;
+    this.p = p;
+  }
+};
+
+// src/decode/state.ts
+var TWO322 = 4294967296;
+var DecoderState = class {
+  constructor(limits) {
+    this.state = 0 /* Header */;
+    this.stack = [];
+    // current field
+    this.id = 0;
+    // Resumable varint accumulator, as two unsigned 32-bit halves (vLo / vHi)
+    // plus the byte count so far. Number-only: a `bigint` is built once, at the
+    // end, and only for full 64-bit *values* (not ids, lengths or counts).
+    this.vLo = 0;
+    this.vHi = 0;
+    this.vBytes = 0;
+    this.vComplete = false;
+    // fixlen / fp scratch
+    this.scratch = new Uint8Array(8);
+    this.need = 0;
+    this.have = 0;
+    // fixlen string/blob streaming
+    this.fixSub = FixlenSubtype.String;
+    this.fixLen = 0;
+    this.fixOff = 0;
+    // array
+    this.arrKind = ArrayKind.Unsigned;
+    this.arrIsFixlen = false;
+    this.arrCount = 0;
+    this.arrIndex = 0;
+    this.maxArrayCount = limits?.maxArrayCount ?? Infinity;
+    this.maxStringLen = limits?.maxStringLen ?? Infinity;
+    this.maxBlobLen = limits?.maxBlobLen ?? Infinity;
+  }
+  /** Feed `input` to the machine, dispatching to `root` and its sub-visitors. */
+  push(input, root) {
+    if (this.stack.length === 0) this.stack.push(root);
+    let i = 0;
+    const n = input.length;
+    while (i < n) {
+      switch (this.state) {
+        case 0 /* Header */: {
+          i = this.varintStep(input, i);
+          if (!this.vComplete) return;
+          const type = this.vTag();
+          if (type === WireType.SequenceEnd) {
+            this.resetVarint();
+            this.endSequence();
+            break;
+          }
+          const id = this.vUpper();
+          this.resetVarint();
+          if (id > ID_MAX) throw invalidMsgError(`field id ${id} out of range`);
+          this.id = id;
+          this.dispatch(type);
+          break;
+        }
+        case 1 /* ScalarU */: {
+          i = this.varintStep(input, i);
+          if (!this.vComplete) return;
+          const value = this.vUnsigned();
+          this.resetVarint();
+          this.top().unsigned?.(this.id, value);
+          this.state = 0 /* Header */;
+          break;
+        }
+        case 2 /* ScalarS */: {
+          i = this.varintStep(input, i);
+          if (!this.vComplete) return;
+          const value = this.vSigned();
+          this.resetVarint();
+          this.top().signed?.(this.id, value);
+          this.state = 0 /* Header */;
+          break;
+        }
+        case 3 /* FixlenLen */: {
+          i = this.varintStep(input, i);
+          if (!this.vComplete) return;
+          const sub = this.vTag();
+          const len = this.vUpper();
+          this.resetVarint();
+          if (sub > FixlenSubtype.Blob) throw invalidMsgError(`invalid fixlen subtype ${sub}`);
+          if (len > FIXLEN_MAX) throw invalidMsgError("fixlen length out of range");
+          if (sub === FixlenSubtype.String && len > this.maxStringLen) {
+            throw limitExceededError(`string length ${len} exceeds maxStringLen ${this.maxStringLen}`);
+          }
+          if (sub === FixlenSubtype.Blob && len > this.maxBlobLen) {
+            throw limitExceededError(`blob length ${len} exceeds maxBlobLen ${this.maxBlobLen}`);
+          }
+          this.fixSub = sub;
+          this.fixLen = len;
+          this.fixOff = 0;
+          if (sub === FixlenSubtype.Fp32 || sub === FixlenSubtype.Fp64) {
+            const want = sub === FixlenSubtype.Fp32 ? 4 : 8;
+            if (this.fixLen !== want) throw invalidMsgError("fixlen float length mismatch");
+            this.need = want;
+            this.have = 0;
+            this.state = 4 /* FixlenFp */;
+          } else {
+            if (this.fixLen === 0) {
+              this.emitBytes(input.subarray(0, 0));
+              this.state = 0 /* Header */;
+            } else {
+              this.state = 5 /* FixlenBytes */;
+            }
+          }
+          break;
+        }
+        case 4 /* FixlenFp */: {
+          i = this.fpStep(input, i);
+          if (this.have < this.need) return;
+          const value = this.fixSub === FixlenSubtype.Fp32 ? unpackFp32(this.scratch, 0) : unpackFp64(this.scratch, 0);
+          if (this.fixSub === FixlenSubtype.Fp32) this.top().fp32?.(this.id, value);
+          else this.top().fp64?.(this.id, value);
+          this.state = 0 /* Header */;
+          break;
+        }
+        case 5 /* FixlenBytes */: {
+          const take = Math.min(n - i, this.fixLen - this.fixOff);
+          this.emitBytes(input.subarray(i, i + take));
+          i += take;
+          this.fixOff += take;
+          if (this.fixOff === this.fixLen) this.state = 0 /* Header */;
+          break;
+        }
+        case 6 /* ArrayCount */: {
+          i = this.varintStep(input, i);
+          if (!this.vComplete) return;
+          const count = this.vNum();
+          this.resetVarint();
+          if (count > ARRAY_MAX) throw invalidMsgError("array count out of range");
+          if (count > this.maxArrayCount) {
+            throw limitExceededError(`array count ${count} exceeds maxArrayCount ${this.maxArrayCount}`);
+          }
+          this.arrCount = count;
+          this.arrIndex = 0;
+          if (this.arrIsFixlen) {
+            this.state = 9 /* ArrayElemLen */;
+          } else if (count === 0) {
+            this.top().arrayBegin?.(this.id, this.arrKind, 0);
+            this.top().arrayEnd?.(this.id);
+            this.state = 0 /* Header */;
+          } else {
+            this.top().arrayBegin?.(this.id, this.arrKind, this.arrCount);
+            this.state = this.arrKind === ArrayKind.Unsigned ? 7 /* ArrayUElem */ : 8 /* ArraySElem */;
+          }
+          break;
+        }
+        case 7 /* ArrayUElem */: {
+          i = this.varintStep(input, i);
+          if (!this.vComplete) return;
+          const value = this.vUnsigned();
+          this.resetVarint();
+          this.top().arrayUnsigned?.(this.id, this.arrIndex, value);
+          this.advanceArray();
+          break;
+        }
+        case 8 /* ArraySElem */: {
+          i = this.varintStep(input, i);
+          if (!this.vComplete) return;
+          const value = this.vSigned();
+          this.resetVarint();
+          this.top().arraySigned?.(this.id, this.arrIndex, value);
+          this.advanceArray();
+          break;
+        }
+        case 9 /* ArrayElemLen */: {
+          i = this.varintStep(input, i);
+          if (!this.vComplete) return;
+          const sub = this.vTag();
+          const size = this.vUpper();
+          this.resetVarint();
+          if (sub === FixlenSubtype.Fp32 && size === 4) {
+            this.arrKind = ArrayKind.Fp32;
+            this.need = 4;
+          } else if (sub === FixlenSubtype.Fp64 && size === 8) {
+            this.arrKind = ArrayKind.Fp64;
+            this.need = 8;
+          } else {
+            throw invalidMsgError("invalid fixlen array element type");
+          }
+          this.top().arrayBegin?.(this.id, this.arrKind, this.arrCount);
+          if (this.arrCount === 0) {
+            this.top().arrayEnd?.(this.id);
+            this.state = 0 /* Header */;
+          } else {
+            this.have = 0;
+            this.state = 10 /* ArrayFp */;
+          }
+          break;
+        }
+        case 10 /* ArrayFp */: {
+          i = this.fpStep(input, i);
+          if (this.have < this.need) return;
+          const value = this.arrKind === ArrayKind.Fp32 ? unpackFp32(this.scratch, 0) : unpackFp64(this.scratch, 0);
+          if (this.arrKind === ArrayKind.Fp32) this.top().arrayFp32?.(this.id, this.arrIndex, value);
+          else this.top().arrayFp64?.(this.id, this.arrIndex, value);
+          this.have = 0;
+          this.advanceArray();
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * Report the terminal decode outcome (MESSAGE_SPEC §7) *without* promoting it
+   * to an error. Returns {@link DecodeStatus.Complete} when the stream ended
+   * exactly at a field boundary, or {@link DecodeStatus.Incomplete} when it
+   * ended inside a field (a partial varint, an unfinished payload / array, or a
+   * still-open nested sequence). This is a pure accessor — the finish-less spec
+   * has no finalize step, and a trailing `Incomplete` is a truncation the caller
+   * decides how to treat, not an error this machine raises. A genuinely
+   * malformed message has already thrown from {@link push}.
+   */
+  finish() {
+    const atBoundary = this.state === 0 /* Header */ && this.vBytes === 0 && this.stack.length <= 1;
+    return atBoundary ? DecodeStatus.Complete : DecodeStatus.Incomplete;
+  }
+  // --- helpers ------------------------------------------------------------
+  dispatch(type) {
+    switch (type) {
+      case WireType.Unsigned:
+        this.state = 1 /* ScalarU */;
+        break;
+      case WireType.Signed:
+        this.state = 2 /* ScalarS */;
+        break;
+      case WireType.Fixlen:
+        this.state = 3 /* FixlenLen */;
+        break;
+      case WireType.ArrayUnsigned:
+        this.arrKind = ArrayKind.Unsigned;
+        this.arrIsFixlen = false;
+        this.state = 6 /* ArrayCount */;
+        break;
+      case WireType.ArraySigned:
+        this.arrKind = ArrayKind.Signed;
+        this.arrIsFixlen = false;
+        this.state = 6 /* ArrayCount */;
+        break;
+      case WireType.ArrayFixlen:
+        this.arrIsFixlen = true;
+        this.state = 6 /* ArrayCount */;
+        break;
+      case WireType.SequenceStart: {
+        if (this.stack.length - 1 >= MAX_DEPTH) {
+          throw invalidMsgError(`nesting exceeds MAX_DEPTH (${MAX_DEPTH})`);
+        }
+        const child = this.top().sequenceBegin?.(this.id);
+        this.stack.push(child ?? this.top());
+        this.state = 0 /* Header */;
+        break;
+      }
+      default:
+        throw invalidMsgError(`invalid wire type ${type}`);
+    }
+  }
+  endSequence() {
+    if (this.stack.length <= 1) throw invalidMsgError("unbalanced sequence end");
+    this.top().sequenceEnd?.();
+    this.stack.pop();
+    this.state = 0 /* Header */;
+  }
+  advanceArray() {
+    this.arrIndex++;
+    if (this.arrIndex === this.arrCount) {
+      this.top().arrayEnd?.(this.id);
+      this.state = 0 /* Header */;
+    }
+  }
+  emitBytes(chunk) {
+    const v = this.top();
+    if (this.fixSub === FixlenSubtype.String) v.string?.(this.id, this.fixLen, this.fixOff, chunk);
+    else v.blob?.(this.id, this.fixLen, this.fixOff, chunk);
+  }
+  top() {
+    return this.stack[this.stack.length - 1];
+  }
+  /**
+   * Consume varint bytes from `input` at `i` into the {@link vLo} / {@link vHi}
+   * accumulator, resuming across chunk boundaries; sets {@link vComplete} when a
+   * terminator byte arrives. Number-only — no per-byte `bigint`.
+   */
+  varintStep(input, i) {
+    let lo = this.vLo;
+    let hi = this.vHi;
+    let k = this.vBytes;
+    const n = input.length;
+    while (i < n) {
+      if (k >= VARINT_MAX_BYTES) throw invalidMsgError("varint overflow");
+      const b = input[i++];
+      if (k < 4) lo |= (b & 127) << 7 * k;
+      else if (k === 4) {
+        lo |= (b & 15) << 28;
+        hi |= b >> 4 & 7;
+      } else {
+        if (k === 9 && (b & 127) >> 1 !== 0) throw invalidMsgError("varint overflow");
+        hi |= (b & 127) << 7 * k - 32;
+      }
+      k++;
+      if ((b & 128) === 0) {
+        this.vLo = lo;
+        this.vHi = hi;
+        this.vBytes = k;
+        this.vComplete = true;
+        return i;
+      }
+    }
+    this.vLo = lo;
+    this.vHi = hi;
+    this.vBytes = k;
+    this.vComplete = false;
+    return i;
+  }
+  resetVarint() {
+    this.vLo = 0;
+    this.vHi = 0;
+    this.vBytes = 0;
+    this.vComplete = false;
+  }
+  /** The accumulated varint as a `bigint` (full 64-bit fidelity). */
+  vBig() {
+    return this.vHi === 0 ? BigInt(this.vLo >>> 0) : BigInt(this.vHi >>> 0) << 32n | BigInt(this.vLo >>> 0);
+  }
+  /**
+   * The accumulated varint as an unsigned value, number-first: a `number` when
+   * it fits exactly (`≤ 2^53-1`, which covers all ids, u8..u32 and small u64s),
+   * a `bigint` only beyond that. Avoids a bigint allocation on the common path.
+   */
+  vUnsigned() {
+    const hi = this.vHi >>> 0;
+    return hi <= 2097151 ? hi * TWO322 + (this.vLo >>> 0) : this.vBig();
+  }
+  /** The accumulated zig-zag varint as a signed value, number-first (see {@link vUnsigned}). */
+  vSigned() {
+    const hi = this.vHi >>> 0;
+    if (hi <= 2097151) {
+      const r = hi * TWO322 + (this.vLo >>> 0);
+      return r % 2 === 0 ? r / 2 : -(r + 1) / 2;
+    }
+    return zigzagDecode(this.vBig());
+  }
+  /** The accumulated varint as a JS number — exact for ids/lengths/counts. */
+  vNum() {
+    return this.vHi * TWO322 + (this.vLo >>> 0);
+  }
+  /** The accumulated varint's low 3 tag bits (the wire type / fixlen subtype). */
+  vTag() {
+    return this.vLo & 7;
+  }
+  /** The accumulated varint with its low 3 tag bits stripped (`value >> 3`). */
+  vUpper() {
+    return (this.vHi >>> 0) * (TWO322 / 8) + (this.vLo >>> 3);
+  }
+  /** Accumulate `need` raw bytes into {@link scratch}. */
+  fpStep(input, i) {
+    while (this.have < this.need && i < input.length) {
+      this.scratch[this.have++] = input[i++];
+    }
+    return i;
+  }
+};
+
+// src/decode/istream.ts
+var IStream = class {
+  /**
+   * @param limits Optional opt-in decode caps ({@link DecodeLimits}). An
+   * over-limit array count or string / blob length throws {@link SofabError}
+   * (`LIMIT_EXCEEDED`) from {@link feed}, at the offending field's header and
+   * before any of its payload is streamed to the visitor. Omit for no caps.
+   */
+  constructor(limits) {
+    this.state = new DecoderState(limits);
+  }
+  /**
+   * Feed a chunk of bytes, dispatching decoded fields to `visitor`. Throws
+   * {@link SofabError} (`INVALID_MSG`) only if the bytes are *malformed*;
+   * running out of bytes mid-field is not an error — it simply suspends until
+   * the next chunk (see {@link end}).
+   */
+  feed(chunk, visitor) {
+    this.state.push(chunk, visitor);
+  }
+  /**
+   * Report whether the stream ended exactly at a field boundary. Call after the
+   * final {@link feed}: returns {@link DecodeStatus.Complete} at a clean field
+   * boundary, or {@link DecodeStatus.Incomplete} if the last chunk ended inside
+   * a field (a partial varint, an unfinished payload / array, or a still-open
+   * nested sequence).
+   *
+   * Per the finish-less spec (MESSAGE_SPEC §7) this is a pure accessor: it never
+   * throws and never promotes an incomplete decode to an error — the caller owns
+   * end-of-input and decides whether a trailing `Incomplete` is a truncation
+   * error. (A *malformed* message has already thrown from {@link feed}.)
+   */
+  end() {
+    return this.state.finish();
+  }
+};
+function decode(bytes, visitor, limits) {
+  decodeContiguous(bytes, visitor, limits);
+}
+
+// src/decode/cursor.ts
+var TWO323 = 4294967296;
+var _utf8 = new TextDecoder("utf-8", { fatal: true });
+var Cursor = class {
+  constructor(buf, limits) {
+    /** Field id of the header last accepted by {@link readHeader}. */
+    this.id = 0;
+    /** Wire type of the header last accepted by {@link readHeader}. */
+    this.wire = 0;
+    /**
+     * Fixlen subtype of the header last accepted by {@link readHeader} — one of
+     * {@link FixlenSubtype} — when its {@link wire} is {@link WireType.Fixlen} or
+     * {@link WireType.ArrayFixlen}; `-1` otherwise (a non-fixlen field, or a
+     * fixlen field whose subtype word is truncated away).
+     *
+     * The four fixlen subtypes (`fp32`, `fp64`, `string`, `blob`) all share one
+     * {@link wire} type, so {@link wire} alone cannot separate them. This is the
+     * companion accessor that can: a generated guard reads it right after
+     * {@link readHeader} to skip a field whose delivered subtype contradicts the
+     * schema (MESSAGE_SPEC §7.3), exactly as it already does on {@link wire} for
+     * the other kinds:
+     *
+     * ```ts
+     * case 9: if (c.wire !== WireType.Fixlen || c.fixSub !== FixlenSubtype.Fp64) {
+     *   c.skip(c.wire); break;
+     * } o.somefp64 = c.readFp64(); break;
+     * ```
+     *
+     * It is *peeked* — the subtype word is not consumed — so the matching typed
+     * reader (or {@link skip}) still reads and validates it, and a malformed or
+     * truncated word surfaces `INVALID` / `INCOMPLETE` there as before.
+     */
+    this.fixSub = -1;
+    this.p = 0;
+    // Last varint, as two unsigned 32-bit halves (see readVarint).
+    this.lo = 0;
+    this.hi = 0;
+    // Number of nested sequences currently open (0 = root). Incremented when
+    // readHeader accepts a SequenceStart, decremented when it consumes the matching
+    // SequenceEnd (or when skip() discards a whole nested sequence). Lets the pull
+    // parser tell a root-level dangling sequence-end (INVALID) and an unclosed
+    // sequence at end-of-buffer (INCOMPLETE) apart from a clean boundary.
+    this.depth = 0;
+    this.buf = buf;
+    this.n = buf.length;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.length);
+    this.maxArrayCount = limits?.maxArrayCount ?? Infinity;
+    this.maxStringLen = limits?.maxStringLen ?? Infinity;
+    this.maxBlobLen = limits?.maxBlobLen ?? Infinity;
+  }
+  /**
+   * Advance to the next field header. Returns `true` and sets {@link id} /
+   * {@link wire} when a field follows; returns `false` — consuming the marker —
+   * at the end of the buffer *or* at the sequence-end that closes the sequence
+   * this decoder is reading. So a generated per-type decoder loops uniformly:
+   *
+   * ```ts
+   * while (c.readHeader()) {
+   *   switch (c.id) {
+   *     case 4: this.u32 = Number(c.readUnsigned()); break;
+   *     case 10: this.child = Child.decodeFrom(c); break; // nested sequence
+   *     default: c.skip(c.wire); break;                   // unknown field
+   *   }
+   * }
+   * ```
+   *
+   * At the root the loop ends at end-of-buffer; inside a nested sequence it ends
+   * at the matching {@link WireType.SequenceEnd} (which is consumed). A field
+   * whose id is out of range throws {@link SofabError} (`INVALID_MSG`).
+   */
+  readHeader() {
+    if (this.p >= this.n) {
+      if (this.depth > 0) {
+        throw incompleteError("truncated message: unbalanced sequence");
+      }
+      return false;
+    }
+    this.readVarint();
+    const wire = this.lo & 7;
+    if (wire === WireType.SequenceEnd) {
+      if (this.depth === 0) {
+        throw invalidMsgError("unbalanced sequence end");
+      }
+      this.depth--;
+      return false;
+    }
+    const id = this.upper();
+    if (id > ID_MAX) throw invalidMsgError(`field id ${id} out of range`);
+    if (wire === WireType.SequenceStart) this.depth++;
+    this.id = id;
+    this.wire = wire;
+    this.fixSub = this.peekFixSub(wire);
+    return true;
+  }
+  /** Read an unsigned scalar (wire {@link WireType.Unsigned}), number-first. */
+  readUnsigned() {
+    this.readVarint();
+    return this.unsignedValue();
+  }
+  /** Read a signed scalar (wire {@link WireType.Signed}), zig-zag, number-first. */
+  readSigned() {
+    this.readVarint();
+    return this.signedValue();
+  }
+  /** Read a 32-bit float scalar (wire {@link WireType.Fixlen}, subtype fp32). */
+  readFp32() {
+    this.fixlenHeader(FixlenSubtype.Fp32, 4);
+    return this.rawFp32();
+  }
+  /** Read a 64-bit float scalar (wire {@link WireType.Fixlen}, subtype fp64). */
+  readFp64() {
+    this.fixlenHeader(FixlenSubtype.Fp64, 8);
+    return this.rawFp64();
+  }
+  /** Read a UTF-8 string scalar (wire {@link WireType.Fixlen}, subtype string). */
+  readString() {
+    const len = this.fixlenLen(FixlenSubtype.String);
+    const bytes = this.take(len);
+    try {
+      return _utf8.decode(bytes);
+    } catch {
+      throw invalidMsgError("invalid UTF-8 in string");
+    }
+  }
+  /**
+   * Read a blob scalar (wire {@link WireType.Fixlen}, subtype blob) as a
+   * zero-copy {@link Uint8Array} view into the source buffer.
+   */
+  readBlob() {
+    const len = this.fixlenLen(FixlenSubtype.Blob);
+    return this.take(len);
+  }
+  /** Read an unsigned array (wire {@link WireType.ArrayUnsigned}), number-first per element. */
+  readUnsignedArray() {
+    const count = this.arrayCount();
+    const out = new Array(count);
+    for (let i = 0; i < count; i++) {
+      this.readVarint();
+      out[i] = this.unsignedValue();
+    }
+    return out;
+  }
+  /** Read a signed array (wire {@link WireType.ArraySigned}), zig-zag, number-first per element. */
+  readSignedArray() {
+    const count = this.arrayCount();
+    const out = new Array(count);
+    for (let i = 0; i < count; i++) {
+      this.readVarint();
+      out[i] = this.signedValue();
+    }
+    return out;
+  }
+  /**
+   * Read an unsigned 64-bit array into {@link Long}[] — the `bigint`-free path.
+   * Each element keeps the raw lo/hi halves; call {@link Long.toBigInt} to
+   * materialise only the values the caller actually needs.
+   */
+  readUnsignedArrayLong() {
+    const count = this.arrayCount();
+    const out = new Array(count);
+    for (let i = 0; i < count; i++) {
+      this.readVarint();
+      out[i] = new Long(this.lo, this.hi);
+    }
+    return out;
+  }
+  /** Read a signed 64-bit array (zig-zag) into {@link Long}[] — the `bigint`-free path. */
+  readSignedArrayLong() {
+    const count = this.arrayCount();
+    const out = new Array(count);
+    for (let i = 0; i < count; i++) {
+      this.readVarint();
+      const lo = this.lo >>> 0;
+      const hi = this.hi >>> 0;
+      const mask = -(lo & 1) >>> 0;
+      out[i] = new Long((lo >>> 1 | hi << 31) >>> 0 ^ mask, hi >>> 1 >>> 0 ^ mask);
+    }
+    return out;
+  }
+  /** Read an fp32 array (wire {@link WireType.ArrayFixlen}, element subtype fp32). */
+  readFp32Array() {
+    const count = this.arrayFixlenHeader(FixlenSubtype.Fp32, 4);
+    const out = new Array(count);
+    for (let i = 0; i < count; i++) out[i] = this.rawFp32();
+    return out;
+  }
+  /** Read an fp64 array (wire {@link WireType.ArrayFixlen}, element subtype fp64). */
+  readFp64Array() {
+    const count = this.arrayFixlenHeader(FixlenSubtype.Fp64, 8);
+    const out = new Array(count);
+    for (let i = 0; i < count; i++) out[i] = this.rawFp64();
+    return out;
+  }
+  /**
+   * Consume the value of the field whose header {@link readHeader} just accepted,
+   * discarding it — for a `default:` branch that keeps the cursor in sync on an
+   * unknown id. Pass {@link wire}. A {@link WireType.SequenceStart} skips the
+   * whole nested sequence.
+   */
+  skip(wire) {
+    if (wire === WireType.SequenceStart) {
+      this.skipSequence();
+      this.depth--;
+      return;
+    }
+    this.skipValue(wire);
+  }
+  // --- value skipping -----------------------------------------------------
+  skipValue(wire) {
+    switch (wire) {
+      case WireType.Unsigned:
+      case WireType.Signed:
+        this.readVarint();
+        return;
+      case WireType.Fixlen: {
+        this.readVarint();
+        const sub = this.lo & 7;
+        const len = this.upper();
+        if (sub > FixlenSubtype.Blob) throw invalidMsgError(`invalid fixlen subtype ${sub}`);
+        if (sub === FixlenSubtype.Fp32 || sub === FixlenSubtype.Fp64) {
+          if (len !== (sub === FixlenSubtype.Fp32 ? 4 : 8)) {
+            throw invalidMsgError("fixlen float length mismatch");
+          }
+        } else if (len > FIXLEN_MAX) {
+          throw invalidMsgError("fixlen length out of range");
+        }
+        this.take(len);
+        return;
+      }
+      case WireType.ArrayUnsigned:
+      case WireType.ArraySigned: {
+        const count = this.arrayCount();
+        for (let i = 0; i < count; i++) this.readVarint();
+        return;
+      }
+      case WireType.ArrayFixlen: {
+        this.readVarint();
+        const count = this.num();
+        if (count > ARRAY_MAX) throw invalidMsgError("array count out of range");
+        if (count > this.maxArrayCount) {
+          throw limitExceededError(
+            `array count ${count} exceeds maxArrayCount ${this.maxArrayCount}`
+          );
+        }
+        this.readVarint();
+        const sub = this.lo & 7;
+        const size = this.upper();
+        const ok = sub === FixlenSubtype.Fp32 && size === 4 || sub === FixlenSubtype.Fp64 && size === 8;
+        if (!ok) throw invalidMsgError("invalid fixlen array element type");
+        this.take(count * size);
+        return;
+      }
+      default:
+        throw invalidMsgError(`invalid wire type ${wire}`);
+    }
+  }
+  skipSequence() {
+    let depth = 1;
+    while (depth > 0) {
+      if (this.p >= this.n) throw incompleteError("truncated message: unbalanced sequence");
+      this.readVarint();
+      const wire = this.lo & 7;
+      if (wire === WireType.SequenceEnd) {
+        depth--;
+        continue;
+      }
+      const id = this.upper();
+      if (id > ID_MAX) throw invalidMsgError(`field id ${id} out of range`);
+      if (wire === WireType.SequenceStart) depth++;
+      else this.skipValue(wire);
+    }
+  }
+  // --- field helpers ------------------------------------------------------
+  /**
+   * Peek the delivered fixlen subtype of the field {@link readHeader} just
+   * accepted, **without advancing the cursor** — the readers / {@link skip}
+   * still re-read and validate the word. Returns one of {@link FixlenSubtype}
+   * (0..3), a reserved value (4..7), or `-1` when the wire is not a fixlen kind
+   * or the subtype word is truncated away.
+   *
+   * The subtype is the low 3 bits of the fixlen sub-header word, and the low
+   * bits of a LEB128 word live entirely in its **first** byte — so this only
+   * reads one byte, it never decodes a varint.
+   */
+  peekFixSub(wire) {
+    if (wire === WireType.Fixlen) {
+      return this.p < this.n ? this.buf[this.p] & 7 : -1;
+    }
+    if (wire === WireType.ArrayFixlen) {
+      let p = this.p;
+      while (p < this.n && this.buf[p] >= 128) p++;
+      p++;
+      return p < this.n ? this.buf[p] & 7 : -1;
+    }
+    return -1;
+  }
+  /** Read and validate an array count word (0..ARRAY_MAX; §4.7/§4.8). */
+  arrayCount() {
+    this.readVarint();
+    const count = this.num();
+    if (count > ARRAY_MAX) throw invalidMsgError("array count out of range");
+    if (count > this.maxArrayCount) {
+      throw limitExceededError(
+        `array count ${count} exceeds maxArrayCount ${this.maxArrayCount}`
+      );
+    }
+    if (count > this.n - this.p) throw incompleteError("truncated array");
+    return count;
+  }
+  /** Read a scalar fixlen sub-header, asserting subtype and exact byte length (floats). */
+  fixlenHeader(wantSub, wantLen) {
+    this.readVarint();
+    const sub = this.lo & 7;
+    const len = this.upper();
+    if (sub !== wantSub) throw invalidMsgError(`invalid fixlen subtype ${sub}`);
+    if (len !== wantLen) throw invalidMsgError("fixlen float length mismatch");
+  }
+  /** Read a scalar fixlen sub-header for a string/blob, asserting subtype; returns byte length. */
+  fixlenLen(wantSub) {
+    this.readVarint();
+    const sub = this.lo & 7;
+    const len = this.upper();
+    if (sub !== wantSub) throw invalidMsgError(`invalid fixlen subtype ${sub}`);
+    if (len > FIXLEN_MAX) throw invalidMsgError("fixlen length out of range");
+    const limit = wantSub === FixlenSubtype.String ? this.maxStringLen : this.maxBlobLen;
+    if (len > limit) {
+      const what = wantSub === FixlenSubtype.String ? "string" : "blob";
+      const name = wantSub === FixlenSubtype.String ? "maxStringLen" : "maxBlobLen";
+      throw limitExceededError(
+        `${what} length ${len} exceeds ${name} ${limit}`
+      );
+    }
+    return len;
+  }
+  /** Read an array fixlen element header (count + element type); returns the count. */
+  arrayFixlenHeader(wantSub, wantSize) {
+    this.readVarint();
+    const count = this.num();
+    if (count > ARRAY_MAX) throw invalidMsgError("array count out of range");
+    if (count > this.maxArrayCount) {
+      throw limitExceededError(
+        `array count ${count} exceeds maxArrayCount ${this.maxArrayCount}`
+      );
+    }
+    this.readVarint();
+    const sub = this.lo & 7;
+    const size = this.upper();
+    if (sub !== wantSub || size !== wantSize) {
+      throw invalidMsgError("invalid fixlen array element type");
+    }
+    if (count > (this.n - this.p) / wantSize) {
+      throw incompleteError("truncated fixlen array");
+    }
+    return count;
+  }
+  /** Hand back a zero-copy view of the next `len` bytes, advancing the cursor. */
+  take(len) {
+    const start = this.p;
+    const end = start + len;
+    if (end > this.n) throw incompleteError("truncated fixlen payload");
+    this.p = end;
+    return this.buf.subarray(start, end);
+  }
+  rawFp32() {
+    const p = this.p;
+    if (p + 4 > this.n) throw incompleteError("truncated fp32");
+    this.p = p + 4;
+    return this.view.getFloat32(p, true);
+  }
+  rawFp64() {
+    const p = this.p;
+    if (p + 8 > this.n) throw incompleteError("truncated fp64");
+    this.p = p + 8;
+    return this.view.getFloat64(p, true);
+  }
+  // --- varint reading (shared verbatim with ./fast) -----------------------
+  /**
+   * The last varint's full value as a `bigint` (64-bit fidelity). Only ever
+   * called from {@link unsignedValue} / {@link signedValue} on the `hi` overflow
+   * path (`this.hi >>> 0 > 0x1fffff`), so `hi` is always non-zero here.
+   */
+  big() {
+    return BigInt(this.hi >>> 0) << 32n | BigInt(this.lo >>> 0);
+  }
+  /**
+   * The last varint as an unsigned value, number-first: a `number` when it fits
+   * exactly (`≤ 2^53-1`), a `bigint` only beyond that.
+   */
+  unsignedValue() {
+    const hi = this.hi >>> 0;
+    return hi <= 2097151 ? hi * TWO323 + (this.lo >>> 0) : this.big();
+  }
+  /** The last zig-zag varint as a signed value, number-first. */
+  signedValue() {
+    const hi = this.hi >>> 0;
+    if (hi <= 2097151) {
+      const r = hi * TWO323 + (this.lo >>> 0);
+      return r % 2 === 0 ? r / 2 : -(r + 1) / 2;
+    }
+    return zigzagDecode(this.big());
+  }
+  /** The last varint's value as a JS number — exact for ids/lengths/counts. */
+  num() {
+    return this.hi * TWO323 + (this.lo >>> 0);
+  }
+  /** The last varint with its low 3 tag bits stripped (`value >> 3`). */
+  upper() {
+    return (this.hi >>> 0) * (TWO323 / 8) + (this.lo >>> 3);
+  }
+  /**
+   * Decode one LEB128 varint at the cursor into {@link lo} / {@link hi} (each an
+   * unsigned 32-bit half), advancing {@link p}. Throws on truncation or a value
+   * spilling past 64 bits (>10 bytes). Unrolled, number-only — no `bigint`.
+   */
+  readVarint() {
+    const buf = this.buf;
+    const n = this.n;
+    let p = this.p;
+    let b;
+    let lo;
+    let hi = 0;
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo = b & 127;
+    if (b < 128) return this.set(lo, 0, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo |= (b & 127) << 7;
+    if (b < 128) return this.set(lo, 0, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo |= (b & 127) << 14;
+    if (b < 128) return this.set(lo, 0, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo |= (b & 127) << 21;
+    if (b < 128) return this.set(lo, 0, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    lo |= (b & 15) << 28;
+    hi = b >> 4 & 7;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    hi |= (b & 127) << 3;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    hi |= (b & 127) << 10;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    hi |= (b & 127) << 17;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    hi |= (b & 127) << 24;
+    if (b < 128) return this.set(lo, hi, p);
+    if (p >= n) throw incompleteError("truncated varint");
+    b = buf[p++];
+    if ((b & 127) >> 1 !== 0) throw invalidMsgError("varint overflow");
+    hi |= (b & 127) << 31;
+    if (b < 128) return this.set(lo, hi, p);
+    throw invalidMsgError("varint overflow");
+  }
+  set(lo, hi, p) {
+    this.lo = lo;
+    this.hi = hi;
+    this.p = p;
+  }
+};
+
+// src/backend/native.ts
+var NATIVE_PACKAGE = "@sofa-buffers/corelib-native";
+function isNode() {
+  return typeof process !== "undefined" && !!process.versions?.node;
+}
+async function loadNativeKernel() {
+  if (!isNode()) return false;
+  try {
+    const { createRequire } = await import('module');
+    const require2 = createRequire(import.meta.url);
+    const mod = require2(NATIVE_PACKAGE);
+    const kernel = mod.kernel ?? mod;
+    setKernel(kernel);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/backend/wasm.ts
+async function loadWasmKernel(source, factory, imports = {}) {
+  let instance;
+  if (source instanceof WebAssembly.Module) {
+    instance = await WebAssembly.instantiate(source, imports);
+  } else if (typeof Response !== "undefined" && (source instanceof Response || isThenable(source))) {
+    const result = await WebAssembly.instantiateStreaming(
+      source,
+      imports
+    );
+    instance = result.instance;
+  } else {
+    const result = await WebAssembly.instantiate(source, imports);
+    instance = result.instance;
+  }
+  setKernel(factory(instance.exports));
+  return true;
+}
+function isThenable(x) {
+  return typeof x === "object" && x !== null && typeof x.then === "function";
+}
+
+export { API_VERSION, ARRAY_MAX, ArrayKind, Cursor, DecodeStatus, FIXLEN_MAX, FixlenSubtype, I64_MAX, I64_MIN, ID_MAX, IStream, Long, MAX_DEPTH, OStream, SofabError, SofabErrorCode, U64_MAX, WireType, decode, getKernel, jsKernel, loadNativeKernel, loadWasmKernel, setKernel, public_exports as sofab };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map