@cardanowall/poe-standard 0.2.0 → 0.4.0

package/dist/carriage.js

@@ -0,0 +1,1967 @@
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/constants.js
+var f = { POS_INT: 0, NEG_INT: 1, BYTE_STRING: 2, UTF8_STRING: 3, ARRAY: 4, MAP: 5, TAG: 6, SIMPLE_FLOAT: 7 };
+var T = { DATE_STRING: 0, DATE_EPOCH: 1, POS_BIGINT: 2, NEG_BIGINT: 3, CBOR: 24, URI: 32, BASE64URL: 33, BASE64: 34, DATE_EPOCH_DAYS: 100, SET: 258, JSON: 262, WTF8: 273, SYMBOL: 280, DATE_FULL: 1004, REGEXP: 21066, SELF_DESCRIBED: 55799, INVALID_16: 65535, INVALID_32: 4294967295, INVALID_64: 0xffffffffffffffffn };
+var I = { ZERO: 0, ONE: 24, TWO: 25, FOUR: 26, EIGHT: 27, INDEFINITE: 31 };
+var o = { FALSE: 20, TRUE: 21, NULL: 22, UNDEFINED: 23 };
+var A = class {
+  static BREAK = /* @__PURE__ */ Symbol.for("github.com/hildjj/cbor2/break");
+  static ENCODED = /* @__PURE__ */ Symbol.for("github.com/hildjj/cbor2/cbor-encoded");
+  static LENGTH = /* @__PURE__ */ Symbol.for("github.com/hildjj/cbor2/length");
+};
+var S = { MIN: -(2n ** 63n), MAX: 2n ** 64n - 1n };
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/tag.js
+var o2 = class _o {
+  static #e = /* @__PURE__ */ new Map();
+  tag;
+  contents;
+  constructor(e2, t3 = void 0) {
+    this.tag = e2, this.contents = t3;
+  }
+  get noChildren() {
+    return !!_o.#e.get(this.tag)?.noChildren;
+  }
+  static registerDecoder(e2, t3, n2) {
+    const i = this.#e.get(e2);
+    return this.#e.set(e2, t3), i && ("comment" in t3 || (t3.comment = i.comment), "noChildren" in t3 || (t3.noChildren = i.noChildren)), n2 && !t3.comment && (t3.comment = () => `(${n2})`), i;
+  }
+  static clearDecoder(e2) {
+    const t3 = this.#e.get(e2);
+    return this.#e.delete(e2), t3;
+  }
+  static getDecoder(e2) {
+    return this.#e.get(e2);
+  }
+  static getAllDecoders() {
+    return new Map(this.#e);
+  }
+  *[Symbol.iterator]() {
+    yield this.contents;
+  }
+  push(e2) {
+    return this.contents = e2, 1;
+  }
+  decode(e2) {
+    const t3 = e2?.tags?.get(this.tag) ?? (e2?.ignoreGlobalTags ? void 0 : _o.#e.get(this.tag));
+    return t3 ? t3(this, e2) : this;
+  }
+  comment(e2, t3) {
+    const n2 = e2?.tags?.get(this.tag) ?? (e2?.ignoreGlobalTags ? void 0 : _o.#e.get(this.tag));
+    if (n2?.comment) return n2.comment(this, e2, t3);
+  }
+  toCBOR() {
+    return [this.tag, this.contents];
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](e2, t3, n2) {
+    return `${this.tag}(${n2(this.contents, t3)})`;
+  }
+};
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/box.js
+function f2(n2) {
+  if (n2 != null && typeof n2 == "object") return n2[A.ENCODED];
+}
+function s(n2) {
+  if (n2 != null && typeof n2 == "object") return n2[A.LENGTH];
+}
+function u(n2, e2) {
+  Object.defineProperty(n2, A.ENCODED, { configurable: true, enumerable: false, value: e2 });
+}
+function d(n2, e2) {
+  const r2 = Object(n2);
+  return u(r2, e2), r2;
+}
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/utils.js
+var g = /* @__PURE__ */ Symbol("CBOR_RANGES");
+function c(r2, n2) {
+  Object.defineProperty(r2, g, { configurable: false, enumerable: false, writable: false, value: n2 });
+}
+function f3(r2) {
+  return r2[g];
+}
+function l(r2) {
+  return f3(r2) !== void 0;
+}
+function R(r2, n2 = 0, t3 = r2.length - 1) {
+  const o5 = r2.subarray(n2, t3), a4 = f3(r2);
+  if (a4) {
+    const s3 = [];
+    for (const e2 of a4) if (e2[0] >= n2 && e2[0] + e2[1] <= t3) {
+      const i = [...e2];
+      i[0] -= n2, s3.push(i);
+    }
+    s3.length && c(o5, s3);
+  }
+  return o5;
+}
+function b(r2) {
+  let n2 = Math.ceil(r2.length / 2);
+  const t3 = new Uint8Array(n2);
+  n2--;
+  for (let o5 = r2.length, a4 = o5 - 2; o5 >= 0; o5 = a4, a4 -= 2, n2--) t3[n2] = parseInt(r2.substring(a4, o5), 16);
+  return t3;
+}
+function A2(r2) {
+  return r2.reduce((n2, t3) => n2 + t3.toString(16).padStart(2, "0"), "");
+}
+function d2(r2) {
+  const n2 = r2.reduce((e2, i) => e2 + i.length, 0), t3 = r2.some((e2) => l(e2)), o5 = [], a4 = new Uint8Array(n2);
+  let s3 = 0;
+  for (const e2 of r2) {
+    if (!(e2 instanceof Uint8Array)) throw new TypeError(`Invalid array: ${e2}`);
+    if (a4.set(e2, s3), t3) {
+      const i = e2[g] ?? [[0, e2.length]];
+      for (const u3 of i) u3[0] += s3;
+      o5.push(...i);
+    }
+    s3 += e2.length;
+  }
+  return t3 && c(a4, o5), a4;
+}
+function y(r2) {
+  const n2 = atob(r2);
+  return Uint8Array.from(n2, (t3) => t3.codePointAt(0));
+}
+var p = { "-": "+", _: "/" };
+function x(r2) {
+  const n2 = r2.replace(/[_-]/g, (t3) => p[t3]);
+  return y(n2.padEnd(Math.ceil(n2.length / 4) * 4, "="));
+}
+function h() {
+  const r2 = new Uint8Array(4), n2 = new Uint32Array(r2.buffer);
+  return !((n2[0] = 1) & r2[0]);
+}
+function U(r2) {
+  let n2 = "";
+  for (const t3 of r2) {
+    const o5 = t3.codePointAt(0)?.toString(16).padStart(4, "0");
+    n2 && (n2 += ", "), n2 += `U+${o5}`;
+  }
+  return n2;
+}
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/typeEncoderMap.js
+var s2 = class {
+  #e = /* @__PURE__ */ new Map();
+  registerEncoder(e2, t3) {
+    const n2 = this.#e.get(e2);
+    return this.#e.set(e2, t3), n2;
+  }
+  get(e2) {
+    return this.#e.get(e2);
+  }
+  delete(e2) {
+    return this.#e.delete(e2);
+  }
+  clear() {
+    this.#e.clear();
+  }
+};
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/sorts.js
+function f4(c5, d6) {
+  const [u3, a4, n2] = c5, [l6, s3, t3] = d6, r2 = Math.min(n2.length, t3.length);
+  for (let o5 = 0; o5 < r2; o5++) {
+    const e2 = n2[o5] - t3[o5];
+    if (e2 !== 0) return e2;
+  }
+  return 0;
+}
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/writer.js
+var e = class _e {
+  static defaultOptions = { chunkSize: 4096 };
+  #r;
+  #i = [];
+  #s = null;
+  #t = 0;
+  #a = 0;
+  constructor(t3 = {}) {
+    if (this.#r = { ..._e.defaultOptions, ...t3 }, this.#r.chunkSize < 8) throw new RangeError(`Expected size >= 8, got ${this.#r.chunkSize}`);
+    this.#n();
+  }
+  get length() {
+    return this.#a;
+  }
+  read() {
+    this.#o();
+    const t3 = new Uint8Array(this.#a);
+    let i = 0;
+    for (const s3 of this.#i) t3.set(s3, i), i += s3.length;
+    return this.#n(), t3;
+  }
+  write(t3) {
+    const i = t3.length;
+    i > this.#l() ? (this.#o(), i > this.#r.chunkSize ? (this.#i.push(t3), this.#n()) : (this.#n(), this.#i[this.#i.length - 1].set(t3), this.#t = i)) : (this.#i[this.#i.length - 1].set(t3, this.#t), this.#t += i), this.#a += i;
+  }
+  writeUint8(t3) {
+    this.#e(1), this.#s.setUint8(this.#t, t3), this.#h(1);
+  }
+  writeUint16(t3, i = false) {
+    this.#e(2), this.#s.setUint16(this.#t, t3, i), this.#h(2);
+  }
+  writeUint32(t3, i = false) {
+    this.#e(4), this.#s.setUint32(this.#t, t3, i), this.#h(4);
+  }
+  writeBigUint64(t3, i = false) {
+    this.#e(8), this.#s.setBigUint64(this.#t, t3, i), this.#h(8);
+  }
+  writeInt16(t3, i = false) {
+    this.#e(2), this.#s.setInt16(this.#t, t3, i), this.#h(2);
+  }
+  writeInt32(t3, i = false) {
+    this.#e(4), this.#s.setInt32(this.#t, t3, i), this.#h(4);
+  }
+  writeBigInt64(t3, i = false) {
+    this.#e(8), this.#s.setBigInt64(this.#t, t3, i), this.#h(8);
+  }
+  writeFloat32(t3, i = false) {
+    this.#e(4), this.#s.setFloat32(this.#t, t3, i), this.#h(4);
+  }
+  writeFloat64(t3, i = false) {
+    this.#e(8), this.#s.setFloat64(this.#t, t3, i), this.#h(8);
+  }
+  clear() {
+    this.#a = 0, this.#i = [], this.#n();
+  }
+  #n() {
+    const t3 = new Uint8Array(this.#r.chunkSize);
+    this.#i.push(t3), this.#t = 0, this.#s = new DataView(t3.buffer, t3.byteOffset, t3.byteLength);
+  }
+  #o() {
+    if (this.#t === 0) {
+      this.#i.pop();
+      return;
+    }
+    const t3 = this.#i.length - 1;
+    this.#i[t3] = this.#i[t3].subarray(0, this.#t), this.#t = 0, this.#s = null;
+  }
+  #l() {
+    const t3 = this.#i.length - 1;
+    return this.#i[t3].length - this.#t;
+  }
+  #e(t3) {
+    this.#l() < t3 && (this.#o(), this.#n());
+  }
+  #h(t3) {
+    this.#t += t3, this.#a += t3;
+  }
+};
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/float.js
+var w = 1n << 15n;
+var f5 = 0b11111n << 10n;
+var b2 = 1n << 9n;
+var d3 = b2 - 1n;
+var I2 = b2 | d3;
+var g2 = 1n << 31n;
+var l2 = 0b11111111n << 23n;
+var A3 = 1n << 22n;
+var E = A3 - 1n;
+var p2 = A3 | E;
+var N = 1n << 63n;
+var a = 0b11111111111n << 52n;
+var c2 = 1n << 51n;
+var u2 = c2 - 1n;
+var F = c2 | u2;
+var _ = u2 - (d3 << 42n);
+var S2 = u2 - (E << 29n);
+var m = { 2: "0b", 8: "0o", 16: "0x" };
+var x2 = ((t3) => (t3[t3.NATURAL = -2] = "NATURAL", t3[t3.UNKNOWN = -1] = "UNKNOWN", t3[t3.F16 = 2] = "F16", t3[t3.F32 = 4] = "F32", t3[t3.F64 = 8] = "F64", t3))(x2 || {});
+function U2(i, n2, e2, r2) {
+  let o5 = "nan'";
+  return i.quiet || (o5 += "!"), i.sign === -1 && (o5 += "-"), o5 += r2(Math.abs(i.payload), e2), o5 += "'", o5 += i.encodingIndicator, o5;
+}
+var O = class extends Number {
+  #n;
+  #t = -1;
+  constructor(n2, e2 = true, r2 = -1) {
+    super(NaN);
+    const o5 = n2;
+    if (typeof n2 == "number") {
+      if (!Number.isSafeInteger(n2)) throw new Error(`Invalid NAN payload: ${n2}`);
+      n2 = BigInt(n2);
+      let t3 = 0n;
+      if (n2 < 0 && (t3 = N, n2 = -n2), n2 >= c2) throw new Error(`Payload too large: ${o5}`);
+      const s3 = e2 ? c2 : 0n;
+      switch (this.#n = t3 | a | s3 | n2, r2) {
+        case -2:
+          throw new Error("NAN_SIZE.NATURAL only valid for bigint constructor");
+        case -1:
+          r2 = this.preferredSize;
+          break;
+        case 2:
+          if (this.#n & _) throw new Error("Invalid size for payload");
+          break;
+        case 4:
+          if (this.#n & S2) throw new Error("Invalid size for payload");
+          break;
+        case 8:
+          break;
+        default:
+          throw new Error(`Invalid size: ${r2}`);
+      }
+      this.#t = r2;
+    } else if (typeof n2 == "bigint") {
+      let t3 = -1;
+      if ((n2 & a) === a) this.#n = n2, t3 = 8;
+      else if ((n2 & l2) === l2) {
+        const s3 = (n2 & g2) << 32n;
+        this.#n = s3 | a | (n2 & p2) << 29n, t3 = 4;
+      } else if ((n2 & f5) === f5) {
+        const s3 = (n2 & w) << 48n;
+        this.#n = s3 | a | (n2 & I2) << 42n, t3 = 2;
+      } else throw new Error(`Invalid raw NaN value: ${n2}`);
+      if (r2 === -1) this.#t = this.preferredSize;
+      else if (r2 === -2) this.#t = t3;
+      else {
+        if (r2 < t3) throw new Error("Invalid bigint NaN size");
+        this.#t = r2;
+      }
+    } else {
+      const t3 = new DataView(n2.buffer, n2.byteOffset, n2.byteLength);
+      switch (n2.length) {
+        case 3: {
+          if (n2[0] !== 249) throw new Error("Invalid CBOR encoding for half float");
+          const s3 = BigInt(t3.getUint16(1, false));
+          if ((s3 & f5) !== f5) throw new Error("Not a NaN");
+          const h4 = (s3 & w) << 48n;
+          this.#n = h4 | a | (s3 & I2) << 42n, this.#t = 2;
+          break;
+        }
+        case 5: {
+          if (n2[0] !== 250) throw new Error("Invalid CBOR encoding for single float");
+          const s3 = BigInt(t3.getUint32(1, false));
+          if ((s3 & l2) !== l2) throw new Error("Not a NaN");
+          const h4 = (s3 & g2) << 32n;
+          this.#n = h4 | a | (s3 & p2) << 29n, this.#t = 4;
+          break;
+        }
+        case 9: {
+          if (n2[0] !== 251) throw new Error("Invalid CBOR encoding for double float");
+          if (this.#n = t3.getBigUint64(1, false), (this.#n & a) !== a) throw new Error("Not a NaN (NaNaN)");
+          this.#t = 8;
+          break;
+        }
+        default:
+          throw new RangeError(`Invalid NAN size (should be 2, 4, or 8): ${n2.length - 1}`);
+      }
+    }
+    if (!this.payload && !this.quiet) throw new Error("Signalling NaN with zero payload");
+  }
+  get bytes() {
+    const n2 = new ArrayBuffer(this.#t + 1), e2 = new DataView(n2);
+    switch (this.#t) {
+      case 2: {
+        e2.setUint8(0, 249);
+        const o5 = (this.#n & N ? w : 0n) | f5 | (this.#n & F) >> 42n;
+        e2.setUint16(1, Number(o5), false);
+        break;
+      }
+      case 4: {
+        e2.setUint8(0, 250);
+        const o5 = (this.#n & N ? g2 : 0n) | l2 | (this.#n & F) >> 29n;
+        e2.setUint32(1, Number(o5), false);
+        break;
+      }
+      case 8:
+        e2.setUint8(0, 251), e2.setBigUint64(1, this.#n);
+        break;
+    }
+    return new Uint8Array(n2);
+  }
+  get quiet() {
+    return !!(this.#n & c2);
+  }
+  get sign() {
+    return this.#n & N ? -1 : 1;
+  }
+  get payload() {
+    return Number(this.#n & u2) * this.sign;
+  }
+  get raw() {
+    return this.#n;
+  }
+  get encodingIndicator() {
+    switch (this.#t) {
+      case 2:
+        return "_1";
+      case 4:
+        return "_2";
+    }
+    return "_3";
+  }
+  get size() {
+    return this.#t;
+  }
+  get preferredSize() {
+    return (this.#n & _) === 0n ? 2 : (this.#n & S2) === 0n ? 4 : 8;
+  }
+  get isShortestEncoding() {
+    return this.preferredSize === this.#t;
+  }
+  toCBOR(n2) {
+    n2.write(this.bytes);
+  }
+  toString(n2 = 10) {
+    return U2(this, 1, {}, (e2) => (m[n2] ?? "") + e2.toString(n2));
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](n2, e2, r2) {
+    return U2(this, n2, e2, r2);
+  }
+};
+function v(i, n2 = 0, e2 = false) {
+  const r2 = i[n2] & 128 ? -1 : 1, o5 = (i[n2] & 124) >> 2, t3 = (i[n2] & 3) << 8 | i[n2 + 1];
+  if (o5 === 0) {
+    if (e2 && t3 !== 0) throw new Error(`Unwanted subnormal: ${r2 * 5960464477539063e-23 * t3}`);
+    return r2 * 5960464477539063e-23 * t3;
+  } else if (o5 === 31) return t3 ? NaN : r2 * (1 / 0);
+  return r2 * 2 ** (o5 - 25) * (1024 + t3);
+}
+function Z(i) {
+  const n2 = new DataView(new ArrayBuffer(4));
+  n2.setFloat32(0, i, false);
+  const e2 = n2.getUint32(0, false);
+  if ((e2 & 8191) !== 0) return null;
+  let r2 = e2 >> 16 & 32768;
+  const o5 = e2 >> 23 & 255, t3 = e2 & 8388607;
+  if (!(o5 === 0 && t3 === 0)) if (o5 >= 113 && o5 <= 142) r2 += (o5 - 112 << 10) + (t3 >> 13);
+  else if (o5 >= 103 && o5 < 113) {
+    if (t3 & (1 << 126 - o5) - 1) return null;
+    r2 += t3 + 8388608 >> 126 - o5;
+  } else if (o5 === 255) r2 |= 31744, r2 |= t3 >> 13;
+  else return null;
+  return r2;
+}
+function k(i) {
+  if (i !== 0) {
+    const n2 = new ArrayBuffer(8), e2 = new DataView(n2);
+    e2.setFloat64(0, i, false);
+    const r2 = e2.getBigUint64(0, false);
+    if ((r2 & 0x7ff0000000000000n) === 0n) return r2 & 0x8000000000000000n ? -0 : 0;
+  }
+  return i;
+}
+function B(i) {
+  switch (i.length) {
+    case 2:
+      v(i, 0, true);
+      break;
+    case 4: {
+      const n2 = new DataView(i.buffer, i.byteOffset, i.byteLength), e2 = n2.getUint32(0, false);
+      if ((e2 & 2139095040) === 0 && e2 & 8388607) throw new Error(`Unwanted subnormal: ${n2.getFloat32(0, false)}`);
+      break;
+    }
+    case 8: {
+      const n2 = new DataView(i.buffer, i.byteOffset, i.byteLength), e2 = n2.getBigUint64(0, false);
+      if ((e2 & 0x7ff0000000000000n) === 0n && e2 & 0x000fffffffffffn) throw new Error(`Unwanted subnormal: ${n2.getFloat64(0, false)}`);
+      break;
+    }
+    default:
+      throw new TypeError(`Bad input to isSubnormal: ${i}`);
+  }
+}
+
+// ../../node_modules/.pnpm/@cto.af+wtf8@0.0.5/node_modules/@cto.af/wtf8/lib/errors.js
+var DecodeError = class extends TypeError {
+  code = "ERR_ENCODING_INVALID_ENCODED_DATA";
+  constructor() {
+    super("The encoded data was not valid for encoding wtf-8");
+  }
+};
+var InvalidEncodingError = class extends RangeError {
+  code = "ERR_ENCODING_NOT_SUPPORTED";
+  constructor(label) {
+    super(`Invalid encoding: "${label}"`);
+  }
+};
+
+// ../../node_modules/.pnpm/@cto.af+wtf8@0.0.5/node_modules/@cto.af/wtf8/lib/const.js
+var BOM = 65279;
+var EMPTY = new Uint8Array(0);
+var MIN_HIGH_SURROGATE = 55296;
+var MIN_LOW_SURROGATE = 56320;
+var REPLACEMENT = 65533;
+var WTF8 = "wtf-8";
+
+// ../../node_modules/.pnpm/@cto.af+wtf8@0.0.5/node_modules/@cto.af/wtf8/lib/decode.js
+function isArrayBufferView(input) {
+  return input && typeof input === "object" && !(input instanceof ArrayBuffer) && !(input instanceof SharedArrayBuffer) && input.buffer instanceof ArrayBuffer;
+}
+function getUint8(input) {
+  if (!input) {
+    return EMPTY;
+  }
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  if (isArrayBufferView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  return new Uint8Array(input);
+}
+var REMAINDER = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  1,
+  2,
+  3
+];
+var Wtf8Decoder = class _Wtf8Decoder {
+  static DEFAULT_BUFFERSIZE = 4096;
+  encoding = WTF8;
+  fatal;
+  ignoreBOM;
+  bufferSize;
+  #left = 0;
+  #cur = 0;
+  #pending = 0;
+  #first = true;
+  #buf;
+  constructor(label = "wtf8", options = void 0) {
+    if (label.toLowerCase().replace("-", "") !== "wtf8") {
+      throw new InvalidEncodingError(label);
+    }
+    this.fatal = Boolean(options?.fatal);
+    this.ignoreBOM = Boolean(options?.ignoreBOM);
+    this.bufferSize = Math.floor(options?.bufferSize ?? _Wtf8Decoder.DEFAULT_BUFFERSIZE);
+    if (isNaN(this.bufferSize) || this.bufferSize < 1) {
+      throw new RangeError(`Invalid buffer size: ${options?.bufferSize}`);
+    }
+    this.#buf = new Uint16Array(this.bufferSize);
+  }
+  decode(input, options) {
+    const streaming = Boolean(options?.stream);
+    const bytes = getUint8(input);
+    const res = [];
+    const out = this.#buf;
+    const maxSize = this.bufferSize - 3;
+    let pos = 0;
+    const fatal = () => {
+      this.#cur = 0;
+      this.#left = 0;
+      this.#pending = 0;
+      if (this.fatal) {
+        throw new DecodeError();
+      }
+      out[pos++] = REPLACEMENT;
+    };
+    const fatals = () => {
+      const p5 = this.#pending;
+      for (let i = 0; i < p5; i++) {
+        fatal();
+      }
+    };
+    const oneByte = (b5) => {
+      if (this.#left === 0) {
+        const n2 = REMAINDER[b5 >> 4];
+        switch (n2) {
+          case -1:
+            fatal();
+            break;
+          case 0:
+            out[pos++] = b5;
+            break;
+          case 1:
+            this.#cur = b5 & 31;
+            if ((this.#cur & 30) === 0) {
+              fatal();
+            } else {
+              this.#left = 1;
+              this.#pending = 1;
+            }
+            break;
+          case 2:
+            this.#cur = b5 & 15;
+            this.#left = 2;
+            this.#pending = 1;
+            break;
+          case 3:
+            if (b5 & 8) {
+              fatal();
+            } else {
+              this.#cur = b5 & 7;
+              this.#left = 3;
+              this.#pending = 1;
+            }
+            break;
+        }
+      } else {
+        if ((b5 & 192) !== 128) {
+          fatals();
+          return oneByte(b5);
+        }
+        if (this.#pending === 1 && this.#left === 2 && this.#cur === 0 && (b5 & 32) === 0) {
+          fatals();
+          return oneByte(b5);
+        }
+        if (this.#left === 3 && this.#cur === 0 && (b5 & 48) === 0) {
+          fatals();
+          return oneByte(b5);
+        }
+        this.#cur = this.#cur << 6 | b5 & 63;
+        this.#pending++;
+        if (--this.#left === 0) {
+          if (this.ignoreBOM || !this.#first || this.#cur !== BOM) {
+            if (this.#cur < 65536) {
+              out[pos++] = this.#cur;
+            } else {
+              const cp = this.#cur - 65536;
+              out[pos++] = cp >>> 10 & 1023 | MIN_HIGH_SURROGATE;
+              out[pos++] = cp & 1023 | MIN_LOW_SURROGATE;
+            }
+          }
+          this.#cur = 0;
+          this.#pending = 0;
+          this.#first = false;
+        }
+      }
+    };
+    for (const b5 of bytes) {
+      if (pos >= maxSize) {
+        res.push(String.fromCharCode.apply(null, out.subarray(0, pos)));
+        pos = 0;
+      }
+      oneByte(b5);
+    }
+    if (!streaming) {
+      this.#first = true;
+      if (this.#cur || this.#left) {
+        fatals();
+      }
+    }
+    if (pos > 0) {
+      res.push(String.fromCharCode.apply(null, out.subarray(0, pos)));
+    }
+    return res.join("");
+  }
+};
+
+// ../../node_modules/.pnpm/@cto.af+wtf8@0.0.5/node_modules/@cto.af/wtf8/lib/encode.js
+function utf8length(str) {
+  let len = 0;
+  for (const s3 of str) {
+    const cp = s3.codePointAt(0);
+    if (cp < 128) {
+      len++;
+    } else if (cp < 2048) {
+      len += 2;
+    } else if (cp < 65536) {
+      len += 3;
+    } else {
+      len += 4;
+    }
+  }
+  return len;
+}
+var Wtf8Encoder = class {
+  encoding = WTF8;
+  encode(input) {
+    if (!input) {
+      return EMPTY;
+    }
+    const buf = new Uint8Array(utf8length(String(input)));
+    this.encodeInto(input, buf);
+    return buf;
+  }
+  encodeInto(source, destination) {
+    const str = String(source);
+    const len = str.length;
+    const outLen = destination.length;
+    let written = 0;
+    let read = 0;
+    for (read = 0; read < len; read++) {
+      const c5 = str.codePointAt(read);
+      if (c5 < 128) {
+        if (written >= outLen) {
+          break;
+        }
+        destination[written++] = c5;
+      } else if (c5 < 2048) {
+        if (written >= outLen - 1) {
+          break;
+        }
+        destination[written++] = 192 | c5 >> 6;
+        destination[written++] = 128 | c5 & 63;
+      } else if (c5 < 65536) {
+        if (written >= outLen - 2) {
+          break;
+        }
+        destination[written++] = 224 | c5 >> 12;
+        destination[written++] = 128 | c5 >> 6 & 63;
+        destination[written++] = 128 | c5 & 63;
+      } else {
+        if (written >= outLen - 3) {
+          break;
+        }
+        destination[written++] = 240 | c5 >> 18;
+        destination[written++] = 128 | c5 >> 12 & 63;
+        destination[written++] = 128 | c5 >> 6 & 63;
+        destination[written++] = 128 | c5 & 63;
+        read++;
+      }
+    }
+    return {
+      read,
+      written
+    };
+  }
+};
+var U3 = f.SIMPLE_FLOAT << 5 | I.TWO;
+var h2 = f.SIMPLE_FLOAT << 5 | I.FOUR;
+var B2 = f.SIMPLE_FLOAT << 5 | I.EIGHT;
+var j = f.SIMPLE_FLOAT << 5 | o.TRUE;
+var q = f.SIMPLE_FLOAT << 5 | o.FALSE;
+var $ = f.SIMPLE_FLOAT << 5 | o.UNDEFINED;
+var z = f.SIMPLE_FLOAT << 5 | o.NULL;
+var H = new TextEncoder();
+var K = new Wtf8Encoder();
+var k2 = { ...e.defaultOptions, avoidInts: false, cde: false, collapseBigInts: true, dateTag: T.DATE_EPOCH, dcbor: false, float64: false, flushToZero: false, forceEndian: null, ignoreOriginalEncoding: false, largeNegativeAsBigInt: false, reduceUnsafeNumbers: false, rejectBigInts: false, rejectCustomSimples: false, rejectDuplicateKeys: false, rejectFloats: false, rejectUndefined: false, simplifyNegativeZero: false, sortKeys: null, stringNormalization: null, types: null, wtf8: false, ignoreGlobalTags: false };
+var F2 = { cde: true, ignoreOriginalEncoding: true, sortKeys: f4 };
+var Y = { ...F2, dcbor: true, largeNegativeAsBigInt: true, reduceUnsafeNumbers: true, rejectCustomSimples: true, rejectDuplicateKeys: true, rejectUndefined: true, simplifyNegativeZero: true, stringNormalization: "NFC" };
+function y2(e2) {
+  const n2 = e2 < 0;
+  return typeof e2 == "bigint" ? [n2 ? -e2 - 1n : e2, n2] : [n2 ? -e2 - 1 : e2, n2];
+}
+function N2(e2, n2, i) {
+  if (i.rejectFloats) throw new Error(`Attempt to encode an unwanted floating point number: ${e2}`);
+  if (isNaN(e2)) n2.writeUint8(U3), n2.writeUint16(32256);
+  else if (!i.float64 && Math.fround(e2) === e2) {
+    const r2 = Z(e2);
+    r2 === null ? (n2.writeUint8(h2), n2.writeFloat32(e2)) : (n2.writeUint8(U3), n2.writeUint16(r2));
+  } else n2.writeUint8(B2), n2.writeFloat64(e2);
+}
+function a2(e2, n2, i) {
+  const [r2, t3] = y2(e2);
+  if (t3 && i) throw new TypeError(`Negative size: ${e2}`);
+  i ??= t3 ? f.NEG_INT : f.POS_INT, i <<= 5, r2 < 24 ? n2.writeUint8(i | r2) : r2 <= 255 ? (n2.writeUint8(i | I.ONE), n2.writeUint8(r2)) : r2 <= 65535 ? (n2.writeUint8(i | I.TWO), n2.writeUint16(r2)) : r2 <= 4294967295 ? (n2.writeUint8(i | I.FOUR), n2.writeUint32(r2)) : (n2.writeUint8(i | I.EIGHT), n2.writeBigUint64(BigInt(r2)));
+}
+function m2(e2, n2, i) {
+  typeof e2 == "number" ? a2(e2, n2, f.TAG) : typeof e2 == "object" && !i.ignoreOriginalEncoding && A.ENCODED in e2 ? n2.write(e2[A.ENCODED]) : e2 <= Number.MAX_SAFE_INTEGER ? a2(Number(e2), n2, f.TAG) : (n2.writeUint8(f.TAG << 5 | I.EIGHT), n2.writeBigUint64(BigInt(e2)));
+}
+function O2(e2, n2, i) {
+  const [r2, t3] = y2(e2);
+  if (i.collapseBigInts && (!i.largeNegativeAsBigInt || e2 >= -0x8000000000000000n)) {
+    if (r2 <= 0xffffffffn) {
+      a2(Number(e2), n2);
+      return;
+    }
+    if (r2 <= 0xffffffffffffffffn) {
+      const l6 = (t3 ? f.NEG_INT : f.POS_INT) << 5;
+      n2.writeUint8(l6 | I.EIGHT), n2.writeBigUint64(r2);
+      return;
+    }
+  }
+  if (i.rejectBigInts) throw new Error(`Attempt to encode unwanted bigint: ${e2}`);
+  const o5 = t3 ? T.NEG_BIGINT : T.POS_BIGINT, c5 = r2.toString(16), s3 = c5.length % 2 ? "0" : "";
+  m2(o5, n2, i);
+  const u3 = b(s3 + c5);
+  a2(u3.length, n2, f.BYTE_STRING), n2.write(u3);
+}
+function Z2(e2, n2, i) {
+  i.flushToZero && (e2 = k(e2)), Object.is(e2, -0) ? i.simplifyNegativeZero ? i.avoidInts ? N2(0, n2, i) : a2(0, n2) : N2(e2, n2, i) : !i.avoidInts && Number.isSafeInteger(e2) ? a2(e2, n2) : i.reduceUnsafeNumbers && Math.floor(e2) === e2 && e2 >= S.MIN && e2 <= S.MAX ? O2(BigInt(e2), n2, i) : N2(e2, n2, i);
+}
+function R2(e2, n2, i) {
+  const r2 = i.stringNormalization ? e2.normalize(i.stringNormalization) : e2;
+  if (i.wtf8 && !e2.isWellFormed()) {
+    const t3 = K.encode(r2);
+    m2(T.WTF8, n2, i), a2(t3.length, n2, f.BYTE_STRING), n2.write(t3);
+  } else {
+    const t3 = H.encode(r2);
+    a2(t3.length, n2, f.UTF8_STRING), n2.write(t3);
+  }
+}
+function J(e2, n2, i) {
+  const r2 = e2;
+  L(r2, r2.length, f.ARRAY, n2, i);
+  for (const t3 of r2) g3(t3, n2, i);
+}
+function V(e2, n2) {
+  a2(e2.length, n2, f.BYTE_STRING), n2.write(e2);
+}
+var b3 = new s2();
+b3.registerEncoder(Array, J), b3.registerEncoder(Uint8Array, V);
+function ue(e2, n2) {
+  return b3.registerEncoder(e2, n2);
+}
+function L(e2, n2, i, r2, t3) {
+  const o5 = s(e2);
+  o5 && !t3.ignoreOriginalEncoding ? r2.write(o5) : a2(n2, r2, i);
+}
+function X(e2, n2, i) {
+  if (e2 === null) {
+    n2.writeUint8(z);
+    return;
+  }
+  if (!i.ignoreOriginalEncoding && A.ENCODED in e2) {
+    n2.write(e2[A.ENCODED]);
+    return;
+  }
+  const r2 = e2.constructor;
+  if (r2) {
+    const o5 = i.types?.get(r2) ?? (i.ignoreGlobalTags ? void 0 : b3.get(r2));
+    if (o5) {
+      const c5 = o5(e2, n2, i);
+      if (c5 !== void 0) {
+        if (!Array.isArray(c5) || c5.length !== 2) throw new Error("Invalid encoder return value");
+        (typeof c5[0] == "bigint" || isFinite(Number(c5[0]))) && m2(c5[0], n2, i), g3(c5[1], n2, i);
+      }
+      return;
+    }
+  }
+  if (typeof e2.toCBOR == "function") {
+    const o5 = e2.toCBOR(n2, i);
+    o5 && ((typeof o5[0] == "bigint" || isFinite(Number(o5[0]))) && m2(o5[0], n2, i), g3(o5[1], n2, i));
+    return;
+  }
+  if (typeof e2.toJSON == "function") {
+    g3(e2.toJSON(), n2, i);
+    return;
+  }
+  const t3 = Object.entries(e2).map((o5) => [o5[0], o5[1], v2(o5[0], i)]);
+  i.sortKeys && t3.sort(i.sortKeys), L(e2, t3.length, f.MAP, n2, i);
+  for (const [o5, c5, s3] of t3) n2.write(s3), g3(c5, n2, i);
+}
+function Q(e2, n2, i) {
+  if (!e2.description || e2 !== Symbol.for(e2.description)) throw new TypeError(`Private or empty symbol: ${e2.toString()}`);
+  m2(280, n2, i), R2(e2.description, n2, i);
+}
+function g3(e2, n2, i) {
+  switch (typeof e2) {
+    case "number":
+      Z2(e2, n2, i);
+      break;
+    case "bigint":
+      O2(e2, n2, i);
+      break;
+    case "string":
+      R2(e2, n2, i);
+      break;
+    case "boolean":
+      n2.writeUint8(e2 ? j : q);
+      break;
+    case "undefined":
+      if (i.rejectUndefined) throw new Error("Attempt to encode unwanted undefined.");
+      n2.writeUint8($);
+      break;
+    case "object":
+      X(e2, n2, i);
+      break;
+    case "symbol":
+      Q(e2, n2, i);
+      break;
+    default:
+      throw new TypeError(`Unknown type: ${typeof e2}, ${String(e2)}`);
+  }
+}
+function v2(e2, n2 = {}) {
+  const i = { ...k2 };
+  n2.dcbor ? Object.assign(i, Y) : n2.cde && Object.assign(i, F2), Object.assign(i, n2);
+  const r2 = new e(i);
+  return g3(e2, r2, i), r2.read();
+}
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/options.js
+var o3 = ((e2) => (e2[e2.NEVER = -1] = "NEVER", e2[e2.PREFERRED = 0] = "PREFERRED", e2[e2.ALWAYS = 1] = "ALWAYS", e2))(o3 || {});
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/simple.js
+var t = class _t {
+  static KnownSimple = /* @__PURE__ */ new Map([[o.FALSE, false], [o.TRUE, true], [o.NULL, null], [o.UNDEFINED, void 0]]);
+  value;
+  constructor(e2) {
+    this.value = e2;
+  }
+  static create(e2) {
+    return _t.KnownSimple.has(e2) ? _t.KnownSimple.get(e2) : new _t(e2);
+  }
+  toCBOR(e2, i) {
+    if (i.rejectCustomSimples) throw new Error(`Cannot encode non-standard Simple value: ${this.value}`);
+    a2(this.value, e2, f.SIMPLE_FLOAT);
+  }
+  toString() {
+    return `simple(${this.value})`;
+  }
+  decode() {
+    return _t.KnownSimple.has(this.value) ? _t.KnownSimple.get(this.value) : this;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](e2, i, r2) {
+    return `simple(${r2(this.value, i)})`;
+  }
+};
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/decodeStream.js
+var p3 = new TextDecoder("utf8", { fatal: true, ignoreBOM: true });
+var y3 = class _y {
+  static defaultOptions = { maxDepth: 1024, encoding: "hex", requirePreferred: false };
+  #t;
+  #r;
+  #e = 0;
+  #i;
+  constructor(t3, r2) {
+    if (this.#i = { ..._y.defaultOptions, ...r2 }, typeof t3 == "string") switch (this.#i.encoding) {
+      case "hex":
+        this.#t = b(t3);
+        break;
+      case "base64":
+        this.#t = y(t3);
+        break;
+      default:
+        throw new TypeError(`Encoding not implemented: "${this.#i.encoding}"`);
+    }
+    else this.#t = t3;
+    this.#r = new DataView(this.#t.buffer, this.#t.byteOffset, this.#t.byteLength);
+  }
+  toHere(t3) {
+    return R(this.#t, t3, this.#e);
+  }
+  *[Symbol.iterator]() {
+    if (yield* this.#n(0), this.#e !== this.#t.length) throw new Error("Extra data in input");
+  }
+  *seq() {
+    for (; this.#e < this.#t.length; ) yield* this.#n(0);
+  }
+  *#n(t3) {
+    if (t3++ > this.#i.maxDepth) throw new Error(`Maximum depth ${this.#i.maxDepth} exceeded`);
+    const r2 = this.#e, c5 = this.#r.getUint8(this.#e++), i = c5 >> 5, n2 = c5 & 31;
+    let e2 = n2, f7 = false, a4 = 0;
+    switch (n2) {
+      case I.ONE:
+        if (a4 = 1, e2 = this.#r.getUint8(this.#e), i === f.SIMPLE_FLOAT) {
+          if (e2 < 32) throw new Error(`Invalid simple encoding in extra byte: ${e2}`);
+          f7 = true;
+        } else if (this.#i.requirePreferred && e2 < 24) throw new Error(`Unexpectedly long integer encoding (1) for ${e2}`);
+        break;
+      case I.TWO:
+        if (a4 = 2, i === f.SIMPLE_FLOAT) e2 = v(this.#t, this.#e);
+        else if (e2 = this.#r.getUint16(this.#e, false), this.#i.requirePreferred && e2 <= 255) throw new Error(`Unexpectedly long integer encoding (2) for ${e2}`);
+        break;
+      case I.FOUR:
+        if (a4 = 4, i === f.SIMPLE_FLOAT) e2 = this.#r.getFloat32(this.#e, false);
+        else if (e2 = this.#r.getUint32(this.#e, false), this.#i.requirePreferred && e2 <= 65535) throw new Error(`Unexpectedly long integer encoding (4) for ${e2}`);
+        break;
+      case I.EIGHT: {
+        if (a4 = 8, i === f.SIMPLE_FLOAT) e2 = this.#r.getFloat64(this.#e, false);
+        else if (e2 = this.#r.getBigUint64(this.#e, false), e2 <= Number.MAX_SAFE_INTEGER && (e2 = Number(e2)), this.#i.requirePreferred && e2 <= 4294967295) throw new Error(`Unexpectedly long integer encoding (8) for ${e2}`);
+        break;
+      }
+      case 28:
+      case 29:
+      case 30:
+        throw new Error(`Additional info not implemented: ${n2}`);
+      case I.INDEFINITE:
+        switch (i) {
+          case f.POS_INT:
+          case f.NEG_INT:
+          case f.TAG:
+            throw new Error(`Invalid indefinite encoding for MT ${i}`);
+          case f.SIMPLE_FLOAT:
+            yield [i, n2, A.BREAK, r2, 0];
+            return;
+        }
+        e2 = 1 / 0;
+        break;
+      default:
+        f7 = true;
+    }
+    switch (this.#e += a4, i) {
+      case f.POS_INT:
+        yield [i, n2, e2, r2, a4];
+        break;
+      case f.NEG_INT:
+        yield [i, n2, typeof e2 == "bigint" ? -1n - e2 : -1 - Number(e2), r2, a4];
+        break;
+      case f.BYTE_STRING:
+        e2 === 1 / 0 ? yield* this.#s(i, t3, r2) : yield [i, n2, this.#a(e2), r2, e2];
+        break;
+      case f.UTF8_STRING:
+        e2 === 1 / 0 ? yield* this.#s(i, t3, r2) : yield [i, n2, p3.decode(this.#a(e2)), r2, e2];
+        break;
+      case f.ARRAY:
+        if (e2 === 1 / 0) yield* this.#s(i, t3, r2, false);
+        else {
+          const o5 = Number(e2);
+          yield [i, n2, o5, r2, a4];
+          for (let h4 = 0; h4 < o5; h4++) yield* this.#n(t3 + 1);
+        }
+        break;
+      case f.MAP:
+        if (e2 === 1 / 0) yield* this.#s(i, t3, r2, false);
+        else {
+          const o5 = Number(e2);
+          yield [i, n2, o5, r2, a4];
+          for (let h4 = 0; h4 < o5; h4++) yield* this.#n(t3), yield* this.#n(t3);
+        }
+        break;
+      case f.TAG:
+        yield [i, n2, e2, r2, a4], yield* this.#n(t3);
+        break;
+      case f.SIMPLE_FLOAT: {
+        const o5 = e2;
+        f7 && (e2 = t.create(Number(e2))), yield [i, n2, e2, r2, o5];
+        break;
+      }
+    }
+  }
+  #a(t3) {
+    const r2 = R(this.#t, this.#e, this.#e += t3);
+    if (r2.length !== t3) throw new Error(`Unexpected end of stream reading ${t3} bytes, got ${r2.length}`);
+    return r2;
+  }
+  *#s(t3, r2, c5, i = true) {
+    for (yield [t3, I.INDEFINITE, 1 / 0, c5, 1 / 0]; ; ) {
+      const n2 = this.#n(r2), e2 = n2.next(), [f7, a4, o5] = e2.value;
+      if (o5 === A.BREAK) {
+        yield e2.value, n2.next();
+        return;
+      }
+      if (i) {
+        if (f7 !== t3) throw new Error(`Unmatched major type.  Expected ${t3}, got ${f7}.`);
+        if (a4 === I.INDEFINITE) throw new Error("New stream started in typed stream");
+      }
+      yield e2.value, yield* n2;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/container.js
+var A4 = /* @__PURE__ */ new Map([[I.ZERO, 1], [I.ONE, 2], [I.TWO, 3], [I.FOUR, 5], [I.EIGHT, 9]]);
+var R3 = new Uint8Array(0);
+function F3(h4, r2) {
+  return !r2.boxed && !r2.preferMap && h4.every(([i]) => typeof i == "string") ? Object.fromEntries(h4) : new Map(h4);
+}
+var y4 = class _y {
+  static defaultDecodeOptions = { ...y3.defaultOptions, ParentType: _y, boxed: false, cde: false, dcbor: false, diagnosticSizes: o3.PREFERRED, collapseBigInts: false, convertUnsafeIntsToFloat: false, createObject: F3, keepNanPayloads: false, pretty: false, preferBigInt: false, preferMap: false, rejectLargeNegatives: false, rejectBigInts: false, rejectDuplicateKeys: false, rejectFloats: false, rejectInts: false, rejectLongLoundNaN: false, rejectLongFloats: false, rejectNegativeZero: false, rejectSimple: false, rejectStreaming: false, rejectStringsNotNormalizedAs: null, rejectSubnormals: false, rejectUndefined: false, rejectUnsafeFloatInts: false, saveOriginal: false, sortKeys: null, tags: null, ignoreGlobalTags: false };
+  static cdeDecodeOptions = { cde: true, rejectStreaming: true, requirePreferred: true, sortKeys: f4 };
+  static dcborDecodeOptions = { ...this.cdeDecodeOptions, dcbor: true, convertUnsafeIntsToFloat: true, rejectDuplicateKeys: true, rejectLargeNegatives: true, rejectLongLoundNaN: true, rejectLongFloats: true, rejectNegativeZero: true, rejectSimple: true, rejectUndefined: true, rejectUnsafeFloatInts: true, rejectStringsNotNormalizedAs: "NFC" };
+  parent;
+  mt;
+  ai;
+  left;
+  offset;
+  count = 0;
+  children = [];
+  depth = 0;
+  #e;
+  #t = null;
+  constructor(r2, i, e2, t3) {
+    if ([this.mt, this.ai, , this.offset] = r2, this.left = i, this.parent = e2, this.#e = t3, e2 && (this.depth = e2.depth + 1), this.mt === f.MAP && (this.#e.sortKeys || this.#e.rejectDuplicateKeys) && (this.#t = []), this.#e.rejectStreaming && this.ai === I.INDEFINITE) throw new Error("Streaming not supported");
+  }
+  get isStreaming() {
+    return this.left === 1 / 0;
+  }
+  get done() {
+    return this.left === 0;
+  }
+  static create(r2, i, e2, t3) {
+    const [s3, u3, n2, c5] = r2;
+    switch (s3) {
+      case f.POS_INT:
+      case f.NEG_INT: {
+        if (e2.rejectInts) throw new Error(`Unexpected integer: ${n2}`);
+        if (e2.rejectLargeNegatives && n2 < -0x8000000000000000n) throw new Error(`Invalid 65bit negative number: ${n2}`);
+        let o5 = n2;
+        return e2.preferBigInt ? o5 = BigInt(o5) : e2.convertUnsafeIntsToFloat && o5 >= S.MIN && o5 <= S.MAX && (o5 = Number(n2)), e2.boxed ? d(o5, t3.toHere(c5)) : o5;
+      }
+      case f.SIMPLE_FLOAT:
+        if (u3 > I.ONE) {
+          if (typeof n2 == "symbol") return n2;
+          if (e2.rejectFloats) throw new Error(`Decoding unwanted floating point number: ${n2}`);
+          if (e2.rejectNegativeZero && Object.is(n2, -0)) throw new Error("Decoding negative zero");
+          if (isNaN(n2)) {
+            const o5 = t3.toHere(c5), f7 = new O(o5);
+            if (e2.rejectLongLoundNaN) {
+              if (f7.payload || o5.length > 3) throw new Error(`Invalid NaN encoding: "${A2(o5)}"`);
+            } else if (e2.keepNanPayloads && (f7.payload || f7.sign === -1)) {
+              if (e2.rejectLongFloats && !f7.isShortestEncoding) throw new Error(`NaN should have been encoded shorter: ${n2}`);
+              return f7;
+            }
+          }
+          if (e2.rejectSubnormals && B(t3.toHere(c5 + 1)), e2.rejectLongFloats) {
+            const o5 = v2(n2, { chunkSize: 9, reduceUnsafeNumbers: e2.rejectUnsafeFloatInts });
+            if (o5[0] >> 5 !== s3) throw new Error(`Should have been encoded as int, not float: ${n2}`);
+            if (o5.length < A4.get(u3)) throw new Error(`Number should have been encoded shorter: ${n2}`);
+          }
+          if (typeof n2 == "number" && e2.boxed) return d(n2, t3.toHere(c5));
+        } else {
+          if (e2.rejectSimple && n2 instanceof t) throw new Error(`Invalid simple value: ${n2}`);
+          if (e2.rejectUndefined && n2 === void 0) throw new Error("Unexpected undefined");
+        }
+        return n2;
+      case f.BYTE_STRING:
+      case f.UTF8_STRING:
+        if (n2 === 1 / 0) return new e2.ParentType(r2, 1 / 0, i, e2);
+        if (e2.rejectStringsNotNormalizedAs && typeof n2 == "string") {
+          const o5 = n2.normalize(e2.rejectStringsNotNormalizedAs);
+          if (n2 !== o5) throw new Error(`String not normalized as "${e2.rejectStringsNotNormalizedAs}", got [${U(n2)}] instead of [${U(o5)}]`);
+        }
+        return e2.boxed ? d(n2, t3.toHere(c5)) : n2;
+      case f.ARRAY:
+        return new e2.ParentType(r2, n2, i, e2);
+      case f.MAP:
+        return new e2.ParentType(r2, n2 * 2, i, e2);
+      case f.TAG: {
+        const o5 = new e2.ParentType(r2, 1, i, e2);
+        return o5.children = new o2(n2), o5;
+      }
+    }
+    throw new TypeError(`Invalid major type: ${s3}`);
+  }
+  static decodeToEncodeOpts(r2) {
+    return { ...k2, avoidInts: r2.rejectInts, float64: !r2.rejectLongFloats, flushToZero: r2.rejectSubnormals, largeNegativeAsBigInt: r2.rejectLargeNegatives, sortKeys: r2.sortKeys };
+  }
+  push(r2, i, e2) {
+    if (this.children.push(r2), this.#t) {
+      const t3 = f2(r2) || i.toHere(e2);
+      this.#t.push(t3);
+    }
+    return --this.left;
+  }
+  replaceLast(r2, i, e2) {
+    let t3, s3 = -1 / 0;
+    if (this.children instanceof o2 ? (s3 = 0, t3 = this.children.contents, this.children.contents = r2) : (s3 = this.children.length - 1, t3 = this.children[s3], this.children[s3] = r2), this.#t) {
+      const u3 = f2(r2) || e2.toHere(i.offset);
+      this.#t[s3] = u3;
+    }
+    return t3;
+  }
+  convert(r2) {
+    let i;
+    switch (this.mt) {
+      case f.ARRAY:
+        i = this.children;
+        break;
+      case f.MAP: {
+        const e2 = this.#r();
+        if (this.#e.sortKeys) {
+          let t3;
+          for (const s3 of e2) {
+            if (t3 && this.#e.sortKeys(t3, s3) >= 0) throw new Error(`Duplicate or out of order key: "0x${s3[2]}"`);
+            t3 = s3;
+          }
+        } else if (this.#e.rejectDuplicateKeys) {
+          const t3 = /* @__PURE__ */ new Set();
+          for (const [s3, u3, n2] of e2) {
+            const c5 = A2(n2);
+            if (t3.has(c5)) throw new Error(`Duplicate key: "0x${c5}"`);
+            t3.add(c5);
+          }
+        }
+        i = this.#e.createObject(e2, this.#e);
+        break;
+      }
+      case f.BYTE_STRING:
+        return d2(this.children);
+      case f.UTF8_STRING: {
+        const e2 = this.children.join("");
+        i = this.#e.boxed ? d(e2, r2.toHere(this.offset)) : e2;
+        break;
+      }
+      case f.TAG:
+        i = this.children.decode(this.#e);
+        break;
+      default:
+        throw new TypeError(`Invalid mt on convert: ${this.mt}`);
+    }
+    return this.#e.saveOriginal && i && typeof i == "object" && u(i, r2.toHere(this.offset)), i;
+  }
+  #r() {
+    const r2 = this.children, i = r2.length;
+    if (i % 2) throw new Error("Missing map value");
+    const e2 = new Array(i / 2);
+    if (this.#t) for (let t3 = 0; t3 < i; t3 += 2) e2[t3 >> 1] = [r2[t3], r2[t3 + 1], this.#t[t3]];
+    else for (let t3 = 0; t3 < i; t3 += 2) e2[t3 >> 1] = [r2[t3], r2[t3 + 1], R3];
+    return e2;
+  }
+};
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/diagnostic.js
+var O3 = "  ";
+var y5 = new TextEncoder();
+var g4 = class extends y4 {
+  close = "";
+  quote = '"';
+  get isEmptyStream() {
+    return (this.mt === f.UTF8_STRING || this.mt === f.BYTE_STRING) && this.count === 0;
+  }
+};
+function a3(m4, l6, n2, p5) {
+  let t3 = "";
+  if (l6 === I.INDEFINITE) t3 += "_";
+  else {
+    if (p5.diagnosticSizes === o3.NEVER) return "";
+    {
+      let r2 = p5.diagnosticSizes === o3.ALWAYS;
+      if (!r2) {
+        let e2 = I.ZERO;
+        if (Object.is(n2, -0)) e2 = I.TWO;
+        else if (m4 === f.POS_INT || m4 === f.NEG_INT) {
+          const T2 = n2 < 0, u3 = typeof n2 == "bigint" ? 1n : 1, o5 = T2 ? -n2 - u3 : n2;
+          o5 <= 23 ? e2 = Number(o5) : o5 <= 255 ? e2 = I.ONE : o5 <= 65535 ? e2 = I.TWO : o5 <= 4294967295 ? e2 = I.FOUR : e2 = I.EIGHT;
+        } else isFinite(n2) ? Math.fround(n2) === n2 ? Z(n2) == null ? e2 = I.FOUR : e2 = I.TWO : e2 = I.EIGHT : e2 = I.TWO;
+        r2 = e2 !== l6;
+      }
+      r2 && (t3 += "_", l6 < I.ONE ? t3 += "i" : t3 += String(l6 - 24));
+    }
+  }
+  return t3;
+}
+function M(m4, l6) {
+  const n2 = { ...y4.defaultDecodeOptions, ...l6, ParentType: g4 }, p5 = new y3(m4, n2);
+  let t3, r2, e2 = "";
+  for (const T2 of p5) {
+    const [u3, o5, i] = T2;
+    switch (t3 && (t3.count > 0 && i !== A.BREAK && (t3.mt === f.MAP && t3.count % 2 ? e2 += ": " : (e2 += ",", n2.pretty || (e2 += " "))), n2.pretty && (t3.mt !== f.MAP || t3.count % 2 === 0) && (e2 += `
+${O3.repeat(t3.depth + 1)}`)), r2 = y4.create(T2, t3, n2, p5), u3) {
+      case f.POS_INT:
+      case f.NEG_INT:
+        e2 += String(i), e2 += a3(u3, o5, i, n2);
+        break;
+      case f.SIMPLE_FLOAT:
+        if (i !== A.BREAK) if (typeof i == "number") {
+          const c5 = Object.is(i, -0) ? "-0.0" : String(i);
+          e2 += c5, isFinite(i) && !/[.e]/.test(c5) && (e2 += ".0"), e2 += a3(u3, o5, i, n2);
+        } else i instanceof t ? (e2 += "simple(", e2 += String(i.value), e2 += a3(f.POS_INT, o5, i.value, n2), e2 += ")") : e2 += String(i);
+        break;
+      case f.BYTE_STRING:
+        i === 1 / 0 ? (e2 += "(_ ", r2.close = ")", r2.quote = "'") : (e2 += "h'", e2 += A2(i), e2 += "'", e2 += a3(f.POS_INT, o5, i.length, n2));
+        break;
+      case f.UTF8_STRING:
+        i === 1 / 0 ? (e2 += "(_ ", r2.close = ")") : (e2 += JSON.stringify(i), e2 += a3(f.POS_INT, o5, y5.encode(i).length, n2));
+        break;
+      case f.ARRAY: {
+        e2 += "[";
+        const c5 = a3(f.POS_INT, o5, i, n2);
+        e2 += c5, c5 && (e2 += " "), n2.pretty && i ? r2.close = `
+${O3.repeat(r2.depth)}]` : r2.close = "]";
+        break;
+      }
+      case f.MAP: {
+        e2 += "{";
+        const c5 = a3(f.POS_INT, o5, i, n2);
+        e2 += c5, c5 && (e2 += " "), n2.pretty && i ? r2.close = `
+${O3.repeat(r2.depth)}}` : r2.close = "}";
+        break;
+      }
+      case f.TAG:
+        e2 += String(i), e2 += a3(f.POS_INT, o5, i, n2), e2 += "(", r2.close = ")";
+        break;
+    }
+    if (r2 === A.BREAK) if (t3?.isStreaming) t3.left = 0;
+    else throw new Error("Unexpected BREAK");
+    else t3 && (t3.count++, t3.left--);
+    for (r2 instanceof g4 && (t3 = r2); t3?.done; ) {
+      if (t3.isEmptyStream) e2 = e2.slice(0, -3), e2 += `${t3.quote}${t3.quote}_`;
+      else {
+        if (t3.mt === f.MAP && t3.count % 2 !== 0) throw new Error(`Odd streaming map size: ${t3.count}`);
+        e2 += t3.close;
+      }
+      t3 = t3.parent;
+    }
+  }
+  return e2;
+}
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/comment.js
+var H2 = new TextDecoder();
+var A5 = class extends y4 {
+  depth = 0;
+  leaf = false;
+  value;
+  length;
+  [A.ENCODED];
+  constructor(a4, f7, e2, n2) {
+    super(a4, f7, e2, n2), this.parent ? this.depth = this.parent.depth + 1 : this.depth = n2.initialDepth, [, , this.value, , this.length] = a4;
+  }
+  numBytes() {
+    switch (this.ai) {
+      case I.ONE:
+        return 1;
+      case I.TWO:
+        return 2;
+      case I.FOUR:
+        return 4;
+      case I.EIGHT:
+        return 8;
+    }
+    return 0;
+  }
+};
+function k3(t3) {
+  return t3 instanceof A5;
+}
+function O4(t3, a4) {
+  return t3 === 1 / 0 ? "Indefinite" : a4 ? `${t3} ${a4}${t3 !== 1 && t3 !== 1n ? "s" : ""}` : String(t3);
+}
+function y6(t3) {
+  return "".padStart(t3, " ");
+}
+function x3(t3, a4, f7) {
+  let e2 = "";
+  e2 += y6(t3.depth * 2);
+  const n2 = f2(t3);
+  e2 += A2(n2.subarray(0, 1));
+  const r2 = t3.numBytes();
+  r2 && (e2 += " ", e2 += A2(n2.subarray(1, r2 + 1))), e2 = e2.padEnd(a4.minCol + 1, " "), e2 += "-- ", f7 !== void 0 && (e2 += y6(t3.depth * 2), f7 !== "" && (e2 += `[${f7}] `));
+  let p5 = false;
+  const [s3] = t3.children;
+  switch (t3.mt) {
+    case f.POS_INT:
+      e2 += `Unsigned: ${s3}`, typeof s3 == "bigint" && (e2 += "n");
+      break;
+    case f.NEG_INT:
+      e2 += `Negative: ${s3}`, typeof s3 == "bigint" && (e2 += "n");
+      break;
+    case f.BYTE_STRING:
+      e2 += `Bytes (Length: ${O4(t3.length)})`;
+      break;
+    case f.UTF8_STRING:
+      e2 += `UTF8 (Length: ${O4(t3.length)})`, t3.length !== 1 / 0 && (e2 += `: ${JSON.stringify(s3)}`);
+      break;
+    case f.ARRAY:
+      e2 += `Array (Length: ${O4(t3.value, "item")})`;
+      break;
+    case f.MAP:
+      e2 += `Map (Length: ${O4(t3.value, "pair")})`;
+      break;
+    case f.TAG: {
+      e2 += `Tag #${t3.value}`;
+      const o5 = t3.children, [m4] = o5.contents.children, i = new o2(o5.tag, m4);
+      u(i, n2);
+      const l6 = i.comment(a4, t3.depth);
+      l6 && (e2 += ": ", e2 += l6), p5 ||= i.noChildren;
+      break;
+    }
+    case f.SIMPLE_FLOAT:
+      s3 === A.BREAK ? e2 += "BREAK" : t3.ai > I.ONE ? Object.is(s3, -0) ? e2 += "Float: -0" : e2 += `Float: ${s3}` : (e2 += "Simple: ", s3 instanceof t ? e2 += s3.value : e2 += s3);
+      break;
+  }
+  if (!p5) if (t3.leaf) {
+    if (e2 += `
+`, n2.length > r2 + 1) {
+      const o5 = y6((t3.depth + 1) * 2), m4 = f3(n2);
+      if (m4?.length) {
+        m4.sort((l6, c5) => {
+          const g5 = l6[0] - c5[0];
+          return g5 || c5[1] - l6[1];
+        });
+        let i = 0;
+        for (const [l6, c5, g5] of m4) if (!(l6 < i)) {
+          if (i = l6 + c5, g5 === "<<") {
+            e2 += y6(a4.minCol + 1), e2 += "--", e2 += o5, e2 += "<< ";
+            const d6 = R(n2, l6, l6 + c5), h4 = f3(d6);
+            if (h4) {
+              const $3 = h4.findIndex(([w3, D, v3]) => w3 === 0 && D === c5 && v3 === "<<");
+              $3 >= 0 && h4.splice($3, 1);
+            }
+            e2 += M(d6), e2 += ` >>
+`, e2 += L2(d6, { initialDepth: t3.depth + 1, minCol: a4.minCol, noPrefixHex: true });
+            continue;
+          } else g5 === "'" && (e2 += y6(a4.minCol + 1), e2 += "--", e2 += o5, e2 += "'", e2 += H2.decode(n2.subarray(l6, l6 + c5)), e2 += `'
+`);
+          if (l6 > r2) for (let d6 = l6; d6 < l6 + c5; d6 += 8) {
+            const h4 = Math.min(d6 + 8, l6 + c5);
+            e2 += o5, e2 += A2(n2.subarray(d6, h4)), e2 += `
+`;
+          }
+        }
+      } else for (let i = r2 + 1; i < n2.length; i += 8) e2 += o5, e2 += A2(n2.subarray(i, i + 8)), e2 += `
+`;
+    }
+  } else {
+    e2 += `
+`;
+    let o5 = 0;
+    for (const m4 of t3.children) {
+      if (k3(m4)) {
+        let i = String(o5);
+        t3.mt === f.MAP ? i = o5 % 2 ? `val ${(o5 - 1) / 2}` : `key ${o5 / 2}` : t3.mt === f.TAG && (i = ""), e2 += x3(m4, a4, i);
+      }
+      o5++;
+    }
+  }
+  return e2;
+}
+var q2 = { ...y4.defaultDecodeOptions, initialDepth: 0, noPrefixHex: false, minCol: 0 };
+function L2(t3, a4) {
+  const f7 = { ...q2, ...a4, ParentType: A5, saveOriginal: true }, e2 = new y3(t3, f7);
+  let n2, r2;
+  for (const s3 of e2) {
+    if (r2 = y4.create(s3, n2, f7, e2), s3[2] === A.BREAK) if (n2?.isStreaming) n2.left = 1;
+    else throw new Error("Unexpected BREAK");
+    if (!k3(r2)) {
+      const i = new A5(s3, 0, n2, f7);
+      i.leaf = true, i.children.push(r2), u(i, e2.toHere(s3[3])), r2 = i;
+    }
+    let o5 = (r2.depth + 1) * 2;
+    const m4 = r2.numBytes();
+    for (m4 && (o5 += 1, o5 += m4 * 2), f7.minCol = Math.max(f7.minCol, o5), n2 && n2.push(r2, e2, s3[3]), n2 = r2; n2?.done; ) r2 = n2, r2.leaf || u(r2, e2.toHere(r2.offset)), { parent: n2 } = n2;
+  }
+  a4 && (a4.minCol = f7.minCol);
+  let p5 = f7.noPrefixHex ? "" : `0x${A2(e2.toHere(0))}
+`;
+  return p5 += x3(r2, f7), p5;
+}
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/types.js
+var U4 = !h();
+function I3(e2) {
+  if (typeof e2 == "object" && e2) {
+    if (e2.constructor !== Number) throw new Error(`Expected number: ${e2}`);
+  } else if (typeof e2 != "number") throw new Error(`Expected number: ${e2}`);
+}
+function f6(e2) {
+  if (typeof e2 == "object" && e2) {
+    if (e2.constructor !== String) throw new Error(`Expected string: ${e2}`);
+  } else if (typeof e2 != "string") throw new Error(`Expected string: ${e2}`);
+}
+function E2(e2) {
+  if (!(e2 instanceof Uint8Array)) throw new Error(`Expected Uint8Array: ${e2}`);
+}
+function _2(e2) {
+  if (!Array.isArray(e2)) throw new Error(`Expected Array: ${e2}`);
+}
+ue(Map, (e2, r2, n2) => {
+  const i = [...e2.entries()].map((a4) => [a4[0], a4[1], v2(a4[0], n2)]);
+  if (n2.rejectDuplicateKeys) {
+    const a4 = /* @__PURE__ */ new Set();
+    for (const [d6, u3, g5] of i) {
+      const y7 = A2(g5);
+      if (a4.has(y7)) throw new Error(`Duplicate map key: 0x${y7}`);
+      a4.add(y7);
+    }
+  }
+  n2.sortKeys && i.sort(n2.sortKeys), L(e2, e2.size, f.MAP, r2, n2);
+  for (const [a4, d6, u3] of i) r2.write(u3), g3(d6, r2, n2);
+});
+function w2(e2) {
+  return f6(e2.contents), new Date(e2.contents);
+}
+w2.comment = (e2) => {
+  f6(e2.contents);
+  const r2 = new Date(e2.contents);
+  return `(String ${e2.tag === T.DATE_FULL ? "Full " : ""}Date) ${r2.toISOString()}`;
+}, o2.registerDecoder(T.DATE_STRING, w2), o2.registerDecoder(T.DATE_FULL, w2);
+function N3(e2) {
+  return I3(e2.contents), new Date(e2.contents * 1e3);
+}
+N3.comment = (e2) => (I3(e2.contents), `(Epoch Date) ${new Date(e2.contents * 1e3).toISOString()}`), o2.registerDecoder(T.DATE_EPOCH, N3);
+var S3 = 1e3 * 60 * 60 * 24;
+function $2(e2) {
+  return I3(e2.contents), new Date(e2.contents * S3);
+}
+$2.comment = (e2) => (I3(e2.contents), `(Epoch Date) ${new Date(e2.contents * S3).toISOString()}`), o2.registerDecoder(T.DATE_EPOCH_DAYS, $2), ue(Date, (e2, r2, n2) => {
+  switch (n2.dateTag) {
+    case T.DATE_EPOCH:
+      return [n2.dateTag, e2.valueOf() / 1e3];
+    case T.DATE_STRING:
+      return [n2.dateTag, e2.toISOString().replace(/\.000Z$/, "Z")];
+    case T.DATE_EPOCH_DAYS:
+      return [n2.dateTag, Math.floor(e2.valueOf() / S3)];
+    case T.DATE_FULL:
+      return [n2.dateTag, e2.toISOString().split("T")[0]];
+    default:
+      throw new Error(`Unsupported date tag: ${n2.dateTag}`);
+  }
+});
+function m3(e2, r2, n2) {
+  if (E2(r2.contents), n2.rejectBigInts) throw new Error(`Decoding unwanted big integer: ${r2}(h'${A2(r2.contents)}')`);
+  if (n2.requirePreferred && r2.contents[0] === 0) throw new Error(`Decoding overly-large bigint: ${r2.tag}(h'${A2(r2.contents)})`);
+  let i = r2.contents.reduce((d6, u3) => d6 << 8n | BigInt(u3), 0n);
+  e2 && (i = -1n - i);
+  const a4 = i >= Number.MIN_SAFE_INTEGER && i <= Number.MAX_SAFE_INTEGER;
+  if (n2.requirePreferred && a4) throw new Error(`Decoding bigint that could have been int: ${i}n`);
+  return n2.collapseBigInts && a4 && (i = Number(i)), n2.boxed ? d(i, r2.contents) : i;
+}
+var L3 = m3.bind(null, false);
+var x4 = m3.bind(null, true);
+L3.comment = (e2, r2) => `(Positive BigInt) ${m3(false, e2, r2)}n`, x4.comment = (e2, r2) => `(Negative BigInt) ${m3(true, e2, r2)}n`, o2.registerDecoder(T.POS_BIGINT, L3), o2.registerDecoder(T.NEG_BIGINT, x4);
+function R4(e2, r2) {
+  return E2(e2.contents), e2;
+}
+R4.comment = (e2, r2, n2) => {
+  E2(e2.contents);
+  const i = { ...r2, initialDepth: n2 + 2, noPrefixHex: true }, a4 = f2(e2);
+  let u3 = 2 ** ((a4[0] & 31) - 24) + 1;
+  const g5 = a4[u3] & 31;
+  let y7 = A2(a4.subarray(u3, ++u3));
+  g5 >= 24 && (y7 += " ", y7 += A2(a4.subarray(u3, u3 + 2 ** (g5 - 24)))), i.minCol = Math.max(i.minCol, (n2 + 1) * 2 + y7.length);
+  const D = L2(e2.contents, i);
+  let T2 = `Embedded CBOR
+`;
+  return T2 += `${"".padStart((n2 + 1) * 2, " ")}${y7}`.padEnd(i.minCol + 1, " "), T2 += `-- Bytes (Length: ${e2.contents.length})
+`, T2 += D, T2;
+}, R4.noChildren = true, o2.registerDecoder(T.CBOR, R4), o2.registerDecoder(T.URI, (e2) => (f6(e2.contents), new URL(e2.contents)), "URI"), ue(URL, (e2) => [T.URI, e2.toString()]), o2.registerDecoder(T.BASE64URL, (e2) => (f6(e2.contents), x(e2.contents)), "Base64url-encoded"), o2.registerDecoder(T.BASE64, (e2) => (f6(e2.contents), y(e2.contents)), "Base64-encoded"), o2.registerDecoder(35, (e2) => (f6(e2.contents), new RegExp(e2.contents)), "RegExp"), o2.registerDecoder(21065, (e2) => {
+  f6(e2.contents);
+  const r2 = `^(?:${e2.contents})$`;
+  return new RegExp(r2, "u");
+}, "I-RegExp"), o2.registerDecoder(T.REGEXP, (e2) => {
+  if (_2(e2.contents), e2.contents.length < 1 || e2.contents.length > 2) throw new Error(`Invalid RegExp Array: ${e2.contents}`);
+  return new RegExp(e2.contents[0], e2.contents[1]);
+}, "RegExp"), ue(RegExp, (e2) => [T.REGEXP, [e2.source, e2.flags]]), o2.registerDecoder(64, (e2) => (E2(e2.contents), e2.contents), "uint8 Typed Array");
+function c3(e2, r2, n2) {
+  E2(e2.contents);
+  let i = e2.contents.length;
+  if (i % r2.BYTES_PER_ELEMENT !== 0) throw new Error(`Number of bytes must be divisible by ${r2.BYTES_PER_ELEMENT}, got: ${i}`);
+  i /= r2.BYTES_PER_ELEMENT;
+  const a4 = new r2(i), d6 = new DataView(e2.contents.buffer, e2.contents.byteOffset, e2.contents.byteLength), u3 = d6[`get${r2.name.replace(/Array/, "")}`].bind(d6);
+  for (let g5 = 0; g5 < i; g5++) a4[g5] = u3(g5 * r2.BYTES_PER_ELEMENT, n2);
+  return a4;
+}
+function l3(e2, r2, n2, i, a4) {
+  const d6 = a4.forceEndian ?? U4;
+  if (m2(d6 ? r2 : n2, e2, a4), a2(i.byteLength, e2, f.BYTE_STRING), U4 === d6) e2.write(new Uint8Array(i.buffer, i.byteOffset, i.byteLength));
+  else {
+    const g5 = `write${i.constructor.name.replace(/Array/, "")}`, y7 = e2[g5].bind(e2);
+    for (const D of i) y7(D, d6);
+  }
+}
+o2.registerDecoder(65, (e2) => c3(e2, Uint16Array, false), "uint16, big endian, Typed Array"), o2.registerDecoder(66, (e2) => c3(e2, Uint32Array, false), "uint32, big endian, Typed Array"), o2.registerDecoder(67, (e2) => c3(e2, BigUint64Array, false), "uint64, big endian, Typed Array"), o2.registerDecoder(68, (e2) => (E2(e2.contents), new Uint8ClampedArray(e2.contents)), "uint8 Typed Array, clamped arithmetic"), ue(Uint8ClampedArray, (e2) => [68, new Uint8Array(e2.buffer, e2.byteOffset, e2.byteLength)]), o2.registerDecoder(69, (e2) => c3(e2, Uint16Array, true), "uint16, little endian, Typed Array"), ue(Uint16Array, (e2, r2, n2) => l3(r2, 69, 65, e2, n2)), o2.registerDecoder(70, (e2) => c3(e2, Uint32Array, true), "uint32, little endian, Typed Array"), ue(Uint32Array, (e2, r2, n2) => l3(r2, 70, 66, e2, n2)), o2.registerDecoder(71, (e2) => c3(e2, BigUint64Array, true), "uint64, little endian, Typed Array"), ue(BigUint64Array, (e2, r2, n2) => l3(r2, 71, 67, e2, n2)), o2.registerDecoder(72, (e2) => (E2(e2.contents), new Int8Array(e2.contents)), "sint8 Typed Array"), ue(Int8Array, (e2) => [72, new Uint8Array(e2.buffer, e2.byteOffset, e2.byteLength)]), o2.registerDecoder(73, (e2) => c3(e2, Int16Array, false), "sint16, big endian, Typed Array"), o2.registerDecoder(74, (e2) => c3(e2, Int32Array, false), "sint32, big endian, Typed Array"), o2.registerDecoder(75, (e2) => c3(e2, BigInt64Array, false), "sint64, big endian, Typed Array"), o2.registerDecoder(77, (e2) => c3(e2, Int16Array, true), "sint16, little endian, Typed Array"), ue(Int16Array, (e2, r2, n2) => l3(r2, 77, 73, e2, n2)), o2.registerDecoder(78, (e2) => c3(e2, Int32Array, true), "sint32, little endian, Typed Array"), ue(Int32Array, (e2, r2, n2) => l3(r2, 78, 74, e2, n2)), o2.registerDecoder(79, (e2) => c3(e2, BigInt64Array, true), "sint64, little endian, Typed Array"), ue(BigInt64Array, (e2, r2, n2) => l3(r2, 79, 75, e2, n2)), o2.registerDecoder(81, (e2) => c3(e2, Float32Array, false), "IEEE 754 binary32, big endian, Typed Array"), o2.registerDecoder(82, (e2) => c3(e2, Float64Array, false), "IEEE 754 binary64, big endian, Typed Array"), o2.registerDecoder(85, (e2) => c3(e2, Float32Array, true), "IEEE 754 binary32, little endian, Typed Array"), ue(Float32Array, (e2, r2, n2) => l3(r2, 85, 81, e2, n2)), o2.registerDecoder(86, (e2) => c3(e2, Float64Array, true), "IEEE 754 binary64, big endian, Typed Array"), ue(Float64Array, (e2, r2, n2) => l3(r2, 86, 82, e2, n2)), o2.registerDecoder(T.SET, (e2, r2) => {
+  if (_2(e2.contents), r2.sortKeys) {
+    const n2 = y4.decodeToEncodeOpts(r2);
+    let i = null;
+    for (const a4 of e2.contents) {
+      const d6 = [a4, void 0, v2(a4, n2)];
+      if (i && r2.sortKeys(i, d6) >= 0) throw new Error(`Set items out of order in tag #${T.SET}`);
+      i = d6;
+    }
+  }
+  return new Set(e2.contents);
+}, "Set"), ue(Set, (e2, r2, n2) => {
+  let i = [...e2];
+  if (n2.sortKeys) {
+    const a4 = i.map((d6) => [d6, void 0, v2(d6, n2)]);
+    a4.sort(n2.sortKeys), i = a4.map(([d6]) => d6);
+  }
+  return [T.SET, i];
+}), o2.registerDecoder(T.JSON, (e2) => (f6(e2.contents), JSON.parse(e2.contents)), "JSON-encoded");
+function C(e2) {
+  return E2(e2.contents), new Wtf8Decoder().decode(e2.contents);
+}
+C.comment = (e2) => {
+  E2(e2.contents);
+  const r2 = new Wtf8Decoder();
+  return `(WTF8 string): ${JSON.stringify(r2.decode(e2.contents))}`;
+}, o2.registerDecoder(T.WTF8, C), o2.registerDecoder(T.SELF_DESCRIBED, (e2) => e2.contents, "Self-Described"), o2.registerDecoder(T.INVALID_16, () => {
+  throw new Error(`Tag always invalid: ${T.INVALID_16}`);
+}, "Invalid"), o2.registerDecoder(T.INVALID_32, () => {
+  throw new Error(`Tag always invalid: ${T.INVALID_32}`);
+}, "Invalid"), o2.registerDecoder(T.INVALID_64, () => {
+  throw new Error(`Tag always invalid: ${T.INVALID_64}`);
+}, "Invalid"), o2.registerDecoder(T.SYMBOL, (e2) => {
+  let r2 = e2.contents;
+  if (Array.isArray(e2.contents)) {
+    if (e2.contents.length !== 1) throw new Error(`Expected Array of size 1: ${e2.contents}`);
+    [r2] = e2.contents;
+  }
+  if (f6(r2), !r2.length) throw new Error(`Expected non-empty string: ${e2.contents}`);
+  return Symbol.for(r2);
+}, "Symbol");
+function h3(e2) {
+  throw new Error(`Encoding ${e2.constructor.name} intentionally unimplmented.  It is not concrete enough to interoperate.  Convert to Uint8Array first.`);
+}
+ue(ArrayBuffer, h3), ue(DataView, h3), typeof SharedArrayBuffer < "u" && ue(SharedArrayBuffer, h3);
+function p4(e2) {
+  return [NaN, e2.valueOf()];
+}
+ue(Boolean, p4), ue(Number, p4), ue(String, p4), ue(BigInt, p4);
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/decoder.js
+function c4(i) {
+  const e2 = { ...y4.defaultDecodeOptions };
+  if (i.dcbor ? Object.assign(e2, y4.dcborDecodeOptions) : i.cde && Object.assign(e2, y4.cdeDecodeOptions), Object.assign(e2, i), Object.hasOwn(e2, "rejectLongNumbers")) throw new TypeError("rejectLongNumbers has changed to requirePreferred");
+  return e2.boxed && (e2.saveOriginal = true), e2;
+}
+var d4 = class {
+  parent = void 0;
+  ret = void 0;
+  step(e2, n2, t3) {
+    if (this.ret = y4.create(e2, this.parent, n2, t3), e2[2] === A.BREAK) if (this.parent?.isStreaming) this.parent.left = 0;
+    else throw new Error("Unexpected BREAK");
+    else this.parent && this.parent.push(this.ret, t3, e2[3]);
+    for (this.ret instanceof y4 && (this.parent = this.ret); this.parent?.done; ) {
+      this.ret = this.parent.convert(t3);
+      const r2 = this.parent.parent;
+      r2?.replaceLast(this.ret, this.parent, t3), this.parent = r2;
+    }
+  }
+};
+function l4(i, e2 = {}) {
+  const n2 = c4(e2), t3 = new y3(i, n2), r2 = new d4();
+  for (const o5 of t3) r2.step(o5, n2, t3);
+  return r2.ret;
+}
+
+// ../../node_modules/.pnpm/cbor2@2.3.0/node_modules/cbor2/lib/index.js
+var { cdeDecodeOptions: r, dcborDecodeOptions: n, defaultDecodeOptions: d5 } = y4;
+
+// ../crypto-core/dist/cbor.js
+var CanonicalCborError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "CanonicalCborError";
+    this.code = code;
+  }
+};
+function encodeCanonicalCbor(value) {
+  return v2(value, {
+    cde: true,
+    collapseBigInts: true,
+    rejectDuplicateKeys: true,
+    sortKeys: f4
+  });
+}
+function decodeCanonicalCbor(bytes) {
+  try {
+    return l4(bytes, {
+      ...r,
+      rejectStreaming: true,
+      rejectDuplicateKeys: true,
+      // A Label 309 record carries integers, byte/text strings, arrays, maps and
+      // `null` — and nothing else. Without these rejections the major-type-7
+      // surface leaks into the decoder: a float16/32/64 that happens to hold an
+      // integral value (e.g. 1.0) silently decodes to the integer 1 and passes
+      // a `z.literal(1)` / Number.isInteger schema check, so two byte strings
+      // that are NOT byte-identical canonicalise to the same record. That
+      // breaks the cross-implementation parity invariant (the Python twin
+      // already rejects non-integer `v` / `enc.scheme` outright). Reject the
+      // whole non-record surface — floats, negative zero, undefined, and
+      // non-{true,false,null} simple values — so any such input surfaces as
+      // MALFORMED_CBOR via mapDecodeError rather than decoding to a look-alike.
+      rejectFloats: true,
+      rejectNegativeZero: true,
+      rejectUndefined: true,
+      rejectSimple: true
+    });
+  } catch (cause) {
+    throw mapDecodeError(cause);
+  }
+}
+function mapDecodeError(cause) {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  const lower = message.toLowerCase();
+  const isIndefinite = lower.includes("streaming") || lower.includes("indefinite");
+  const detail = isIndefinite ? `indefinite-length items are not permitted in canonical CBOR: ${message}` : message;
+  return new CanonicalCborError("MALFORMED_CBOR", `cbor decode failed: ${detail}`, { cause });
+}
+
+// src/error-codes.ts
+var ERROR_CODES = [
+  "MALFORMED_CBOR",
+  "SCHEMA_TYPE_MISMATCH",
+  "SCHEMA_MISSING_REQUIRED",
+  "SCHEMA_UNKNOWN_FIELD",
+  "SCHEMA_INVALID_LITERAL",
+  "SCHEMA_EMPTY_RECORD",
+  "HASH_DIGEST_LENGTH_MISMATCH",
+  "UNSUPPORTED_HASH_ALG",
+  "UNSUPPORTED_MERKLE_COMMIT_ALG",
+  "SCHEMA_MERKLE_LEAF_COUNT_INVALID",
+  "INVALID_URI",
+  "CHUNK_TOO_LARGE",
+  "UNAUTHENTICATED_CIPHER_FORBIDDEN",
+  "UNSUPPORTED_AEAD_ALG",
+  "NONCE_LENGTH_MISMATCH",
+  "UNSUPPORTED_ENVELOPE_SCHEME",
+  "ENC_UNSUPPORTED",
+  "ENC_SLOTS_EMPTY",
+  "ENC_SLOT_INVALID_SHAPE",
+  "UNSUPPORTED_KEM_ALG",
+  "ENC_KEM_REQUIRED",
+  "KEM_EPK_LENGTH_MISMATCH",
+  "KEM_CT_LENGTH_MISMATCH",
+  "WRAP_LENGTH_MISMATCH",
+  "ENC_SLOTS_MAC_INVALID_LENGTH",
+  "ENC_SLOTS_MAC_REQUIRED",
+  "ENC_SLOTS_REQUIRED",
+  "ENC_SLOTS_DUPLICATE_KEM_MATERIAL",
+  "ENC_SLOTS_TOO_MANY",
+  "ENC_ENVELOPE_TOO_LARGE",
+  "ENC_EXCLUSIVITY_VIOLATION",
+  "ENC_NO_KEY_PATH",
+  "ENC_REQUIRES_CONTENT_HASH",
+  "ENC_PASSPHRASE_ALG_UNSUPPORTED",
+  "ENC_PASSPHRASE_SALT_TOO_SHORT",
+  "ENC_PASSPHRASE_SALT_TOO_LONG",
+  "ENC_PASSPHRASE_ARGON2_PARAMS_TOO_LOW",
+  "ENC_PASSPHRASE_PARAMS_EXCEED_POLICY",
+  "MALFORMED_SIG_COSE_SIGN1",
+  "SIGNATURE_UNSUPPORTED",
+  "SIG_ENTRY_INVALID_SHAPE",
+  "SIG_ENTRY_KID_COSE_KEY_CONFLICT",
+  "SIG_PRIVATE_KEY_LEAKED",
+  "SUPERSEDES_TX_INVALID_LENGTH",
+  "EXTENSION_UNSUPPORTED_CRITICAL",
+  "CRIT_SHAPE_INVALID",
+  "TX_NOT_FOUND",
+  "PROVIDER_UNAVAILABLE",
+  "TX_INTEGRITY_MISMATCH",
+  "METADATA_NOT_FOUND",
+  "INSUFFICIENT_CONFIRMATIONS",
+  "SIGNATURE_INVALID",
+  "SIGNER_KEY_UNRESOLVED",
+  "WALLET_ADDRESS_MISMATCH",
+  "URI_TARGET_FORBIDDEN",
+  "URI_INTEGRITY_MISMATCH",
+  "URI_PROVIDER_INTEGRITY_MISMATCH",
+  "URI_FETCH_FAILED",
+  "CONTENT_UNAVAILABLE",
+  "CONTENT_FETCH_LIMIT_EXCEEDED",
+  "CIPHERTEXT_UNAVAILABLE",
+  "SERVICE_INDEPENDENCE_VIOLATION",
+  "WRONG_DECRYPTION_INPUT_SHAPE",
+  "WRONG_RECIPIENT_KEY",
+  "TAMPERED_HEADER",
+  "TAMPERED_CIPHERTEXT",
+  "KDF_DERIVATION_FAILED",
+  "ENC_PASSPHRASE_UNNORMALIZABLE",
+  "ENC_PASSPHRASE_EMPTY",
+  "SCHEMA_MERKLE_LEAF_COUNT_MISMATCH",
+  "SCHEMA_MERKLE_LEAVES_FORMAT_UNSUPPORTED",
+  "SCHEMA_MERKLE_LEAVES_MALFORMED",
+  "MERKLE_ROOT_MISMATCH",
+  "MERKLE_LEAVES_UNAVAILABLE",
+  "MERKLE_UNSUPPORTED",
+  "OUT_OF_PROFILE_SKIPPED"
+];
+var ERROR_CODE_PART = Object.freeze({
+  MALFORMED_CBOR: "A",
+  SCHEMA_TYPE_MISMATCH: "A",
+  SCHEMA_MISSING_REQUIRED: "A",
+  SCHEMA_UNKNOWN_FIELD: "A",
+  SCHEMA_INVALID_LITERAL: "A",
+  SCHEMA_EMPTY_RECORD: "A",
+  HASH_DIGEST_LENGTH_MISMATCH: "A",
+  UNSUPPORTED_HASH_ALG: "A",
+  UNSUPPORTED_MERKLE_COMMIT_ALG: "A",
+  SCHEMA_MERKLE_LEAF_COUNT_INVALID: "A",
+  INVALID_URI: "A",
+  CHUNK_TOO_LARGE: "carriage",
+  UNAUTHENTICATED_CIPHER_FORBIDDEN: "A",
+  UNSUPPORTED_AEAD_ALG: "A",
+  NONCE_LENGTH_MISMATCH: "A",
+  UNSUPPORTED_ENVELOPE_SCHEME: "A",
+  ENC_UNSUPPORTED: "A",
+  ENC_SLOTS_EMPTY: "A",
+  ENC_SLOT_INVALID_SHAPE: "A",
+  UNSUPPORTED_KEM_ALG: "A",
+  ENC_KEM_REQUIRED: "A",
+  KEM_EPK_LENGTH_MISMATCH: "A",
+  KEM_CT_LENGTH_MISMATCH: "A",
+  WRAP_LENGTH_MISMATCH: "A",
+  ENC_SLOTS_MAC_INVALID_LENGTH: "A",
+  ENC_SLOTS_MAC_REQUIRED: "A",
+  ENC_SLOTS_REQUIRED: "A",
+  ENC_SLOTS_DUPLICATE_KEM_MATERIAL: "A",
+  ENC_SLOTS_TOO_MANY: "A",
+  ENC_ENVELOPE_TOO_LARGE: "A",
+  ENC_EXCLUSIVITY_VIOLATION: "A",
+  ENC_NO_KEY_PATH: "A",
+  ENC_REQUIRES_CONTENT_HASH: "A",
+  ENC_PASSPHRASE_ALG_UNSUPPORTED: "A",
+  ENC_PASSPHRASE_SALT_TOO_SHORT: "A",
+  ENC_PASSPHRASE_SALT_TOO_LONG: "A",
+  ENC_PASSPHRASE_ARGON2_PARAMS_TOO_LOW: "A",
+  ENC_PASSPHRASE_PARAMS_EXCEED_POLICY: "A",
+  MALFORMED_SIG_COSE_SIGN1: "A",
+  SIGNATURE_UNSUPPORTED: "A",
+  SIG_ENTRY_INVALID_SHAPE: "A",
+  SIG_ENTRY_KID_COSE_KEY_CONFLICT: "A",
+  SIG_PRIVATE_KEY_LEAKED: "A",
+  SUPERSEDES_TX_INVALID_LENGTH: "A",
+  EXTENSION_UNSUPPORTED_CRITICAL: "A",
+  CRIT_SHAPE_INVALID: "A",
+  TX_NOT_FOUND: "B",
+  PROVIDER_UNAVAILABLE: "B",
+  TX_INTEGRITY_MISMATCH: "B",
+  METADATA_NOT_FOUND: "B",
+  INSUFFICIENT_CONFIRMATIONS: "B",
+  SIGNATURE_INVALID: "B",
+  SIGNER_KEY_UNRESOLVED: "B",
+  WALLET_ADDRESS_MISMATCH: "B",
+  URI_TARGET_FORBIDDEN: "B",
+  URI_INTEGRITY_MISMATCH: "B",
+  URI_PROVIDER_INTEGRITY_MISMATCH: "B",
+  URI_FETCH_FAILED: "B",
+  CONTENT_UNAVAILABLE: "B",
+  CONTENT_FETCH_LIMIT_EXCEEDED: "B",
+  CIPHERTEXT_UNAVAILABLE: "B",
+  SERVICE_INDEPENDENCE_VIOLATION: "B",
+  WRONG_DECRYPTION_INPUT_SHAPE: "B",
+  WRONG_RECIPIENT_KEY: "B",
+  TAMPERED_HEADER: "B",
+  TAMPERED_CIPHERTEXT: "B",
+  KDF_DERIVATION_FAILED: "B",
+  ENC_PASSPHRASE_UNNORMALIZABLE: "B",
+  ENC_PASSPHRASE_EMPTY: "B",
+  SCHEMA_MERKLE_LEAF_COUNT_MISMATCH: "B",
+  SCHEMA_MERKLE_LEAVES_FORMAT_UNSUPPORTED: "B",
+  SCHEMA_MERKLE_LEAVES_MALFORMED: "B",
+  MERKLE_ROOT_MISMATCH: "B",
+  MERKLE_LEAVES_UNAVAILABLE: "B",
+  MERKLE_UNSUPPORTED: "B",
+  OUT_OF_PROFILE_SKIPPED: "B"
+});
+Object.freeze(
+  ERROR_CODES.filter((code) => ERROR_CODE_PART[code] === "A")
+);
+Object.freeze(
+  ERROR_CODES.filter((code) => ERROR_CODE_PART[code] === "carriage")
+);
+Object.freeze(
+  ERROR_CODES.filter((code) => ERROR_CODE_PART[code] === "B")
+);
+var SEVERITY = Object.freeze({
+  MALFORMED_CBOR: "error",
+  SCHEMA_TYPE_MISMATCH: "error",
+  SCHEMA_MISSING_REQUIRED: "error",
+  SCHEMA_UNKNOWN_FIELD: "error",
+  SCHEMA_INVALID_LITERAL: "error",
+  SCHEMA_EMPTY_RECORD: "error",
+  HASH_DIGEST_LENGTH_MISMATCH: "error",
+  UNSUPPORTED_HASH_ALG: "error",
+  UNSUPPORTED_MERKLE_COMMIT_ALG: "error",
+  SCHEMA_MERKLE_LEAF_COUNT_INVALID: "error",
+  INVALID_URI: "error",
+  CHUNK_TOO_LARGE: "error",
+  UNAUTHENTICATED_CIPHER_FORBIDDEN: "error",
+  UNSUPPORTED_AEAD_ALG: "error",
+  NONCE_LENGTH_MISMATCH: "error",
+  UNSUPPORTED_ENVELOPE_SCHEME: "error",
+  ENC_UNSUPPORTED: "info",
+  ENC_SLOTS_EMPTY: "error",
+  ENC_SLOT_INVALID_SHAPE: "error",
+  UNSUPPORTED_KEM_ALG: "error",
+  ENC_KEM_REQUIRED: "error",
+  KEM_EPK_LENGTH_MISMATCH: "error",
+  KEM_CT_LENGTH_MISMATCH: "error",
+  WRAP_LENGTH_MISMATCH: "error",
+  ENC_SLOTS_MAC_INVALID_LENGTH: "error",
+  ENC_SLOTS_MAC_REQUIRED: "error",
+  ENC_SLOTS_REQUIRED: "error",
+  ENC_SLOTS_DUPLICATE_KEM_MATERIAL: "error",
+  ENC_SLOTS_TOO_MANY: "error",
+  ENC_ENVELOPE_TOO_LARGE: "error",
+  ENC_EXCLUSIVITY_VIOLATION: "error",
+  ENC_NO_KEY_PATH: "error",
+  ENC_REQUIRES_CONTENT_HASH: "error",
+  ENC_PASSPHRASE_ALG_UNSUPPORTED: "error",
+  ENC_PASSPHRASE_SALT_TOO_SHORT: "error",
+  ENC_PASSPHRASE_SALT_TOO_LONG: "error",
+  ENC_PASSPHRASE_ARGON2_PARAMS_TOO_LOW: "error",
+  ENC_PASSPHRASE_PARAMS_EXCEED_POLICY: "error",
+  MALFORMED_SIG_COSE_SIGN1: "error",
+  SIGNATURE_UNSUPPORTED: "info",
+  SIG_ENTRY_INVALID_SHAPE: "error",
+  SIG_ENTRY_KID_COSE_KEY_CONFLICT: "error",
+  SIG_PRIVATE_KEY_LEAKED: "error",
+  SUPERSEDES_TX_INVALID_LENGTH: "error",
+  EXTENSION_UNSUPPORTED_CRITICAL: "error",
+  CRIT_SHAPE_INVALID: "error",
+  TX_NOT_FOUND: "error",
+  PROVIDER_UNAVAILABLE: "error",
+  TX_INTEGRITY_MISMATCH: "error",
+  METADATA_NOT_FOUND: "error",
+  INSUFFICIENT_CONFIRMATIONS: "info",
+  SIGNATURE_INVALID: "error",
+  SIGNER_KEY_UNRESOLVED: "error",
+  WALLET_ADDRESS_MISMATCH: "error",
+  URI_TARGET_FORBIDDEN: "error",
+  URI_INTEGRITY_MISMATCH: "error",
+  URI_PROVIDER_INTEGRITY_MISMATCH: "warning",
+  URI_FETCH_FAILED: "warning",
+  CONTENT_UNAVAILABLE: "error",
+  CONTENT_FETCH_LIMIT_EXCEEDED: "error",
+  CIPHERTEXT_UNAVAILABLE: "error",
+  SERVICE_INDEPENDENCE_VIOLATION: "error",
+  WRONG_DECRYPTION_INPUT_SHAPE: "error",
+  WRONG_RECIPIENT_KEY: "error",
+  TAMPERED_HEADER: "error",
+  TAMPERED_CIPHERTEXT: "error",
+  KDF_DERIVATION_FAILED: "error",
+  ENC_PASSPHRASE_UNNORMALIZABLE: "error",
+  ENC_PASSPHRASE_EMPTY: "error",
+  SCHEMA_MERKLE_LEAF_COUNT_MISMATCH: "error",
+  SCHEMA_MERKLE_LEAVES_FORMAT_UNSUPPORTED: "error",
+  SCHEMA_MERKLE_LEAVES_MALFORMED: "error",
+  MERKLE_ROOT_MISMATCH: "error",
+  MERKLE_LEAVES_UNAVAILABLE: "warning",
+  MERKLE_UNSUPPORTED: "info",
+  OUT_OF_PROFILE_SKIPPED: "info"
+});
+new Map(
+  ERROR_CODES.map((code, index) => [code, index])
+);
+
+// src/carriage.ts
+var TRANSPORT_CHUNK_MAX_BYTES = 64;
+function chunkRecordBody(body) {
+  if (body.length === 0) {
+    throw new RangeError("record body must be non-empty; a CBOR value is at least one byte");
+  }
+  const chunks = [];
+  for (let offset = 0; offset < body.length; offset += TRANSPORT_CHUNK_MAX_BYTES) {
+    chunks.push(body.slice(offset, Math.min(offset + TRANSPORT_CHUNK_MAX_BYTES, body.length)));
+  }
+  return chunks;
+}
+function encodeLabel309Value(body) {
+  return encodeCanonicalCbor(chunkRecordBody(body));
+}
+function reassembleLabel309Value(valueBytes) {
+  let decoded;
+  try {
+    decoded = decodeCanonicalCbor(valueBytes);
+  } catch (cause) {
+    return failure(
+      "MALFORMED_CBOR",
+      `label-309 value failed to decode: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+  }
+  if (!Array.isArray(decoded)) {
+    return failure(
+      "MALFORMED_CBOR",
+      "label-309 value must be the whole-body chunk array (a CBOR array of byte strings), regardless of body length"
+    );
+  }
+  let total = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    const element = decoded[i];
+    if (!(element instanceof Uint8Array)) {
+      return failure("MALFORMED_CBOR", `chunk array element ${i} is not a byte string`);
+    }
+    if (element.length > TRANSPORT_CHUNK_MAX_BYTES) {
+      return failure(
+        "CHUNK_TOO_LARGE",
+        `chunk array element ${i} is ${element.length} bytes; the ledger caps metadata byte strings at ${TRANSPORT_CHUNK_MAX_BYTES}`
+      );
+    }
+    total += element.length;
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const element of decoded) {
+    body.set(element, offset);
+    offset += element.length;
+  }
+  return { ok: true, body };
+}
+function failure(code, message) {
+  return { ok: false, issue: { code, path: [], message, severity: SEVERITY[code] } };
+}
+
+export { TRANSPORT_CHUNK_MAX_BYTES, chunkRecordBody, encodeLabel309Value, reassembleLabel309Value };
+//# sourceMappingURL=carriage.js.map
+//# sourceMappingURL=carriage.js.map