@cardanowall/poe-standard 0.0.0

package/dist/validator.cjs

@@ -0,0 +1,3283 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/validator.ts
+
+// ../../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 h5 = (s3 & w) << 48n;
+          this.#n = h5 | 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 h5 = (s3 & g2) << 32n;
+          this.#n = h5 | 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 h5 = 0; h5 < o5; h5++) 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 h5 = 0; h5 < o5; h5++) 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(h5, r2) {
+  return !r2.boxed && !r2.preferMap && h5.every(([i]) => typeof i == "string") ? Object.fromEntries(h5) : new Map(h5);
+}
+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), h5 = f3(d6);
+            if (h5) {
+              const $3 = h5.findIndex(([w3, D, v3]) => w3 === 0 && D === c5 && v3 === "<<");
+              $3 >= 0 && h5.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 h5 = Math.min(d6 + 8, l6 + c5);
+            e2 += o5, e2 += A2(n2.subarray(d6, h5)), 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 decodeCanonicalCbor(bytes) {
+  try {
+    return l4(bytes, {
+      ...r,
+      rejectStreaming: true,
+      rejectDuplicateKeys: true,
+      // A CIP-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 });
+}
+
+// ../../node_modules/.pnpm/@noble+ed25519@3.1.0/node_modules/@noble/ed25519/index.js
+var ed25519_CURVE = Object.freeze({
+  p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
+  n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
+  h: 8n,
+  a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
+  d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
+  Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
+  Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
+});
+var { p: P, n: N4, Gx, Gy, a: _a, d: _d, h: h4 } = ed25519_CURVE;
+var L4 = 32;
+var captureTrace = (...args) => {
+  if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
+    Error.captureStackTrace(...args);
+  }
+};
+var err = (message = "") => {
+  const e2 = new Error(message);
+  captureTrace(e2, err);
+  throw e2;
+};
+var isBig = (n2) => typeof n2 === "bigint";
+var isStr = (s3) => typeof s3 === "string";
+var isBytes2 = (a4) => a4 instanceof Uint8Array || ArrayBuffer.isView(a4) && a4.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a4 && a4.BYTES_PER_ELEMENT === 1;
+var abytes2 = (value, length, title = "") => {
+  const bytes = isBytes2(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    const msg = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+    throw bytes ? new RangeError(msg) : new TypeError(msg);
+  }
+  return value;
+};
+var u8n = (len) => new Uint8Array(len);
+var u8fr = (buf) => Uint8Array.from(buf);
+var padh = (n2, pad) => n2.toString(16).padStart(pad, "0");
+var bytesToHex = (b5) => Array.from(abytes2(b5)).map((e2) => padh(e2, 2)).join("");
+var C2 = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+var _ch = (ch) => {
+  if (ch >= C2._0 && ch <= C2._9)
+    return ch - C2._0;
+  if (ch >= C2.A && ch <= C2.F)
+    return ch - (C2.A - 10);
+  if (ch >= C2.a && ch <= C2.f)
+    return ch - (C2.a - 10);
+  return;
+};
+var hexToBytes = (hex) => {
+  const e2 = "hex invalid";
+  if (!isStr(hex))
+    return err(e2);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    return err(e2);
+  const array = u8n(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = _ch(hex.charCodeAt(hi));
+    const n2 = _ch(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0)
+      return err(e2);
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+};
+var big = BigInt;
+var assertRange = (n2, min, max, msg = "bad number: out of range") => {
+  if (!isBig(n2))
+    throw new TypeError(msg);
+  if (min <= n2 && n2 < max)
+    return n2;
+  throw new RangeError(msg);
+};
+var M2 = (a4, b5 = P) => {
+  const r2 = a4 % b5;
+  return r2 >= 0n ? r2 : b5 + r2;
+};
+var P_MASK = (1n << 255n) - 1n;
+var modP = (num) => {
+  if (num < 0n)
+    err("negative coordinate");
+  let r2 = (num >> 255n) * 19n + (num & P_MASK);
+  r2 = (r2 >> 255n) * 19n + (r2 & P_MASK);
+  return r2 % P;
+};
+var invert = (num, md) => {
+  if (num === 0n || md <= 0n)
+    err("no inverse n=" + num + " mod=" + md);
+  let a4 = M2(num, md), b5 = md, x5 = 0n, u3 = 1n;
+  while (a4 !== 0n) {
+    const q3 = b5 / a4, r2 = b5 % a4;
+    const m4 = x5 - u3 * q3;
+    b5 = a4, a4 = r2, x5 = u3, u3 = m4;
+  }
+  return b5 === 1n ? M2(x5, md) : err("no inverse");
+};
+var apoint = (p5) => p5 instanceof Point ? p5 : err("Point expected");
+var B256 = 2n ** 256n;
+var Point = class _Point {
+  static BASE;
+  static ZERO;
+  X;
+  Y;
+  Z;
+  T;
+  // Constructor only bounds-checks and freezes XYZT coordinates; it does not prove the point is
+  // on-curve or that T matches X*Y/Z.
+  constructor(X2, Y2, Z3, T2) {
+    const max = B256;
+    this.X = assertRange(X2, 0n, max);
+    this.Y = assertRange(Y2, 0n, max);
+    this.Z = assertRange(Z3, 1n, max);
+    this.T = assertRange(T2, 0n, max);
+    Object.freeze(this);
+  }
+  static CURVE() {
+    return ed25519_CURVE;
+  }
+  static fromAffine(p5) {
+    return new _Point(p5.x, p5.y, 1n, modP(p5.x * p5.y));
+  }
+  /** RFC8032 5.1.3: Bytes to Point. */
+  static fromBytes(hex, zip215 = false) {
+    const d6 = _d;
+    const normed = u8fr(abytes2(hex, L4));
+    const lastByte = hex[31];
+    normed[31] = lastByte & -129;
+    const y7 = bytesToNumberLE(normed);
+    const max = zip215 ? B256 : P;
+    assertRange(y7, 0n, max);
+    const y22 = modP(y7 * y7);
+    const u3 = M2(y22 - 1n);
+    const v3 = modP(d6 * y22 + 1n);
+    let { isValid, value: x5 } = uvRatio(u3, v3);
+    if (!isValid)
+      err("bad point: y not sqrt");
+    const isXOdd = (x5 & 1n) === 1n;
+    const isLastByteOdd = (lastByte & 128) !== 0;
+    if (!zip215 && x5 === 0n && isLastByteOdd)
+      err("bad point: x==0, isLastByteOdd");
+    if (isLastByteOdd !== isXOdd)
+      x5 = M2(-x5);
+    return new _Point(x5, y7, 1n, modP(x5 * y7));
+  }
+  static fromHex(hex, zip215) {
+    return _Point.fromBytes(hexToBytes(hex), zip215);
+  }
+  get x() {
+    return this.toAffine().x;
+  }
+  get y() {
+    return this.toAffine().y;
+  }
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const a4 = _a;
+    const d6 = _d;
+    const p5 = this;
+    if (p5.is0())
+      return err("bad point: ZERO");
+    const { X: X2, Y: Y2, Z: Z3, T: T2 } = p5;
+    const X22 = modP(X2 * X2);
+    const Y22 = modP(Y2 * Y2);
+    const Z22 = modP(Z3 * Z3);
+    const Z4 = modP(Z22 * Z22);
+    const aX2 = modP(X22 * a4);
+    const left = modP(Z22 * (aX2 + Y22));
+    const right = M2(Z4 + modP(d6 * modP(X22 * Y22)));
+    if (left !== right)
+      return err("bad point: equation left != right (1)");
+    const XY = modP(X2 * Y2);
+    const ZT = modP(Z3 * T2);
+    if (XY !== ZT)
+      return err("bad point: equation left != right (2)");
+    return this;
+  }
+  /** Equality check: compare points P&Q. */
+  equals(other) {
+    const { X: X1, Y: Y1, Z: Z1 } = this;
+    const { X: X2, Y: Y2, Z: Z22 } = apoint(other);
+    const X1Z2 = modP(X1 * Z22);
+    const X2Z1 = modP(X2 * Z1);
+    const Y1Z2 = modP(Y1 * Z22);
+    const Y2Z1 = modP(Y2 * Z1);
+    return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+  }
+  is0() {
+    return this.equals(I4);
+  }
+  /** Flip point over y coordinate. */
+  negate() {
+    return new _Point(M2(-this.X), this.Y, this.Z, M2(-this.T));
+  }
+  /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+  double() {
+    const { X: X1, Y: Y1, Z: Z1 } = this;
+    const a4 = _a;
+    const A6 = modP(X1 * X1);
+    const B3 = modP(Y1 * Y1);
+    const C3 = modP(2n * Z1 * Z1);
+    const D = modP(a4 * A6);
+    const x1y1 = M2(X1 + Y1);
+    const E3 = M2(modP(x1y1 * x1y1) - A6 - B3);
+    const G2 = M2(D + B3);
+    const F4 = M2(G2 - C3);
+    const H3 = M2(D - B3);
+    const X3 = modP(E3 * F4);
+    const Y3 = modP(G2 * H3);
+    const T3 = modP(E3 * H3);
+    const Z3 = modP(F4 * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
+  add(other) {
+    const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
+    const { X: X2, Y: Y2, Z: Z22, T: T2 } = apoint(other);
+    const a4 = _a;
+    const d6 = _d;
+    const A6 = modP(X1 * X2);
+    const B3 = modP(Y1 * Y2);
+    const C3 = modP(modP(T1 * d6) * T2);
+    const D = modP(Z1 * Z22);
+    const E3 = M2(modP(M2(X1 + Y1) * M2(X2 + Y2)) - A6 - B3);
+    const F4 = M2(D - C3);
+    const G2 = M2(D + C3);
+    const H3 = M2(B3 - modP(a4 * A6));
+    const X3 = modP(E3 * F4);
+    const Y3 = modP(G2 * H3);
+    const T3 = modP(E3 * H3);
+    const Z3 = modP(F4 * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  subtract(other) {
+    return this.add(apoint(other).negate());
+  }
+  /**
+   * Point-by-scalar multiplication. Safe mode requires `1 <= n < CURVE.n`.
+   * Unsafe mode additionally permits `n = 0` and returns the identity point for that case.
+   * Uses {@link wNAF} for base point.
+   * Uses fake point to mitigate side-channel leakage.
+   * @param n - scalar by which point is multiplied
+   * @param safe - safe mode guards against timing attacks; unsafe mode is faster
+   */
+  multiply(n2, safe = true) {
+    if (!safe && n2 === 0n)
+      return I4;
+    assertRange(n2, 1n, N4);
+    if (!safe && this.is0())
+      return I4;
+    if (n2 === 1n)
+      return this;
+    if (this.equals(G))
+      return wNAF(n2).p;
+    let p5 = I4;
+    let f7 = G;
+    for (let d6 = this; n2 > 0n; d6 = d6.double(), n2 >>= 1n) {
+      if (n2 & 1n)
+        p5 = p5.add(d6);
+      else if (safe)
+        f7 = f7.add(d6);
+    }
+    return p5;
+  }
+  multiplyUnsafe(scalar) {
+    return this.multiply(scalar, false);
+  }
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { X: X2, Y: Y2, Z: Z3 } = this;
+    if (this.equals(I4))
+      return { x: 0n, y: 1n };
+    const iz = invert(Z3, P);
+    if (modP(Z3 * iz) !== 1n)
+      err("invalid inverse");
+    const x5 = modP(X2 * iz);
+    const y7 = modP(Y2 * iz);
+    return { x: x5, y: y7 };
+  }
+  toBytes() {
+    const { x: x5, y: y7 } = this.toAffine();
+    const b5 = numTo32bLE(y7);
+    b5[31] |= x5 & 1n ? 128 : 0;
+    return b5;
+  }
+  toHex() {
+    return bytesToHex(this.toBytes());
+  }
+  clearCofactor() {
+    return this.multiply(big(h4), false);
+  }
+  isSmallOrder() {
+    return this.clearCofactor().is0();
+  }
+  isTorsionFree() {
+    let p5 = this.multiply(N4 / 2n, false).double();
+    if (N4 % 2n)
+      p5 = p5.add(this);
+    return p5.is0();
+  }
+};
+var G = new Point(Gx, Gy, 1n, M2(Gx * Gy));
+var I4 = new Point(0n, 1n, 1n, 0n);
+Point.BASE = G;
+Point.ZERO = I4;
+var numTo32bLE = (num) => hexToBytes(padh(assertRange(num, 0n, B256), 64)).reverse();
+var bytesToNumberLE = (b5) => big("0x" + bytesToHex(u8fr(abytes2(b5)).reverse()));
+var pow2 = (x5, power) => {
+  let r2 = x5;
+  while (power-- > 0n) {
+    r2 = modP(r2 * r2);
+  }
+  return r2;
+};
+var pow_2_252_3 = (x5) => {
+  const x22 = modP(x5 * x5);
+  const b22 = modP(x22 * x5);
+  const b42 = modP(pow2(b22, 2n) * b22);
+  const b5 = modP(pow2(b42, 1n) * x5);
+  const b10 = modP(pow2(b5, 5n) * b5);
+  const b20 = modP(pow2(b10, 10n) * b10);
+  const b40 = modP(pow2(b20, 20n) * b20);
+  const b80 = modP(pow2(b40, 40n) * b40);
+  const b160 = modP(pow2(b80, 80n) * b80);
+  const b240 = modP(pow2(b160, 80n) * b80);
+  const b250 = modP(pow2(b240, 10n) * b10);
+  const pow_p_5_8 = modP(pow2(b250, 2n) * x5);
+  return { pow_p_5_8, b2: b22 };
+};
+var RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
+var uvRatio = (u3, v3) => {
+  const v32 = modP(v3 * modP(v3 * v3));
+  const v7 = modP(modP(v32 * v32) * v3);
+  const pow = pow_2_252_3(modP(u3 * v7)).pow_p_5_8;
+  let x5 = modP(u3 * modP(v32 * pow));
+  const vx2 = modP(v3 * modP(x5 * x5));
+  const root1 = x5;
+  const root2 = modP(x5 * RM1);
+  const useRoot1 = vx2 === u3;
+  const useRoot2 = vx2 === M2(-u3);
+  const noRoot = vx2 === M2(-u3 * RM1);
+  if (useRoot1)
+    x5 = root1;
+  if (useRoot2 || noRoot)
+    x5 = root2;
+  if ((M2(x5) & 1n) === 1n)
+    x5 = M2(-x5);
+  return { isValid: useRoot1 || useRoot2, value: x5 };
+};
+var W = 8;
+var scalarBits = 256;
+var pwindows = Math.ceil(scalarBits / W) + 1;
+var pwindowSize = 2 ** (W - 1);
+var precompute = () => {
+  const points = [];
+  let p5 = G;
+  let b5 = p5;
+  for (let w3 = 0; w3 < pwindows; w3++) {
+    b5 = p5;
+    points.push(b5);
+    for (let i = 1; i < pwindowSize; i++) {
+      b5 = b5.add(p5);
+      points.push(b5);
+    }
+    p5 = b5.double();
+  }
+  return points;
+};
+var Gpows = void 0;
+var ctneg = (cnd, p5) => {
+  const n2 = p5.negate();
+  return cnd ? n2 : p5;
+};
+var wNAF = (n2) => {
+  const comp = Gpows || (Gpows = precompute());
+  let p5 = I4;
+  let f7 = G;
+  const pow_2_w = 2 ** W;
+  const maxNum = pow_2_w;
+  const mask = big(pow_2_w - 1);
+  const shiftBy = big(W);
+  for (let w3 = 0; w3 < pwindows; w3++) {
+    let wbits = Number(n2 & mask);
+    n2 >>= shiftBy;
+    if (wbits > pwindowSize) {
+      wbits -= maxNum;
+      n2 += 1n;
+    }
+    const off = w3 * pwindowSize;
+    const offF = off;
+    const offP = off + Math.abs(wbits) - 1;
+    const isEven = w3 % 2 !== 0;
+    const isNeg = wbits < 0;
+    if (wbits === 0) {
+      f7 = f7.add(ctneg(isEven, comp[offF]));
+    } else {
+      p5 = p5.add(ctneg(isNeg, comp[offP]));
+    }
+  }
+  if (n2 !== 0n)
+    err("invalid wnaf");
+  return { p: p5, f: f7 };
+};
+
+// ../crypto-core/dist/cose.js
+var CanonicalCborError2 = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "CanonicalCborError";
+    this.code = code;
+  }
+};
+function decodeCanonicalCbor2(bytes) {
+  try {
+    return l4(bytes, {
+      ...r,
+      rejectStreaming: true,
+      rejectDuplicateKeys: true,
+      // A CIP-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 mapDecodeError2(cause);
+  }
+}
+function mapDecodeError2(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 CanonicalCborError2("MALFORMED_CBOR", `cbor decode failed: ${detail}`, { cause });
+}
+Point.CURVE().n;
+var CoseVerifyError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "CoseVerifyError";
+    this.code = code;
+  }
+};
+var CARDANO_POE_SIG_DOMAIN_PREFIX = "cardano-poe-record-sig-v1";
+var CARDANO_POE_SIG_DOMAIN_PREFIX_BYTES = new TextEncoder().encode(
+  CARDANO_POE_SIG_DOMAIN_PREFIX
+);
+if (CARDANO_POE_SIG_DOMAIN_PREFIX_BYTES.length !== 25) {
+  throw new Error(
+    `cardano-poe-record-sig-v1 prefix must encode to exactly 25 UTF-8 bytes, got ${CARDANO_POE_SIG_DOMAIN_PREFIX_BYTES.length}`
+  );
+}
+function asCoseHeader(value) {
+  if (value instanceof Map) return value;
+  if (value !== null && typeof value === "object" && value.constructor === Object) {
+    return new Map(Object.entries(value));
+  }
+  return null;
+}
+function decodeCoseSign1(bytes) {
+  let arr;
+  try {
+    arr = decodeCanonicalCbor2(bytes);
+  } catch (cause) {
+    throw new CoseVerifyError("MALFORMED_SIG_COSE", "cose decode failed", { cause });
+  }
+  if (!Array.isArray(arr) || arr.length !== 4) {
+    throw new CoseVerifyError("MALFORMED_SIG_COSE", "expected 4-element array");
+  }
+  const [protectedBytesRaw, unprotectedRaw, payloadRaw, signatureRaw] = arr;
+  if (!(protectedBytesRaw instanceof Uint8Array)) {
+    throw new CoseVerifyError("MALFORMED_SIG_COSE", "protected_bytes must be bytes");
+  }
+  const unprotectedHeader = asCoseHeader(unprotectedRaw);
+  if (unprotectedHeader === null) {
+    throw new CoseVerifyError("MALFORMED_SIG_COSE", "unprotected header must be map");
+  }
+  if (payloadRaw !== null && !(payloadRaw instanceof Uint8Array)) {
+    throw new CoseVerifyError("MALFORMED_SIG_COSE", "payload must be bytes or null");
+  }
+  if (!(signatureRaw instanceof Uint8Array) || signatureRaw.length !== 64) {
+    throw new CoseVerifyError("MALFORMED_SIG_COSE", "signature must be 64 bytes");
+  }
+  let protectedHeader;
+  if (protectedBytesRaw.length === 0) {
+    protectedHeader = /* @__PURE__ */ new Map();
+  } else {
+    let decodedProtected;
+    try {
+      decodedProtected = decodeCanonicalCbor2(protectedBytesRaw);
+    } catch (cause) {
+      throw new CoseVerifyError("MALFORMED_SIG_COSE", "protected header decode failed", { cause });
+    }
+    const ph = asCoseHeader(decodedProtected);
+    if (ph === null) {
+      throw new CoseVerifyError("MALFORMED_SIG_COSE", "protected header must decode to map");
+    }
+    if (ph.size === 0) {
+      throw new CoseVerifyError(
+        "MALFORMED_SIG_COSE",
+        "empty protected header must encode as 0x40 (zero-length bstr), not as an empty map"
+      );
+    }
+    protectedHeader = ph;
+  }
+  return {
+    protectedHeader,
+    protectedBytes: protectedBytesRaw,
+    unprotectedHeader,
+    payload: payloadRaw,
+    signature: signatureRaw
+  };
+}
+
+// src/chunked.ts
+var UTF8_ENCODER = new TextEncoder();
+function bytesChunkArrayConcat(chunks) {
+  let total = 0;
+  for (const c5 of chunks) total += c5.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c5 of chunks) {
+    out.set(c5, offset);
+    offset += c5.length;
+  }
+  return out;
+}
+function reconstructChunkedUri(chunks) {
+  const merged = bytesChunkArrayConcat(chunks.map((c5) => UTF8_ENCODER.encode(c5)));
+  try {
+    const uri = new TextDecoder("utf-8", { fatal: true }).decode(merged);
+    return { ok: true, uri };
+  } catch (cause) {
+    return {
+      ok: false,
+      code: "INVALID_URI",
+      reason: cause instanceof Error ? cause.message : String(cause)
+    };
+  }
+}
+var SEVERITY = Object.freeze({
+  // --- Part A ---
+  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",
+  INVALID_URI: "error",
+  CHUNK_TOO_LARGE: "error",
+  UNAUTHENTICATED_CIPHER_FORBIDDEN: "error",
+  UNSUPPORTED_AEAD_ALG: "error",
+  NONCE_LENGTH_MISMATCH: "error",
+  UNSUPPORTED_ENVELOPE_SCHEME: "error",
+  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_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",
+  // --- Part B ---
+  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_FETCH_FAILED: "warning",
+  CONTENT_UNAVAILABLE: "error",
+  CIPHERTEXT_UNAVAILABLE: "error",
+  PROVIDER_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",
+  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_LEAVES_INFORMATIVE_FORM: "info",
+  // Dual-severity — default reading is `info`; the verifier promotes to
+  // `error` for merkle-only records (no `items[]` content claim was
+  // validated in the same record).
+  MERKLE_UNSUPPORTED: "info",
+  // Dual-severity — default reading is `info` (render mode); strict
+  // end-to-end verifiers promote to `error`.
+  OUT_OF_PROFILE_SKIPPED: "info"
+});
+var ChunkedBytesArraySchema = zod.z.array(
+  zod.z.instanceof(Uint8Array).refine((b5) => b5.length >= 1 && b5.length <= 64, {
+    params: { code: "CHUNK_TOO_LARGE" }
+  })
+).min(1);
+var UTF8_ENCODER2 = new TextEncoder();
+var UriChunkArraySchema = zod.z.array(
+  zod.z.string().refine(
+    (s3) => {
+      const n2 = UTF8_ENCODER2.encode(s3).length;
+      return n2 >= 1 && n2 <= 64;
+    },
+    { params: { code: "CHUNK_TOO_LARGE" } }
+  )
+).min(1);
+var HashDigestSchema = zod.z.instanceof(Uint8Array);
+var HashesMapSchema = zod.z.record(zod.z.string(), HashDigestSchema);
+var MerkleCommitSchema = zod.z.object({
+  alg: zod.z.string(),
+  root: zod.z.instanceof(Uint8Array),
+  leaf_count: zod.z.number().int().min(1),
+  uris: zod.z.array(UriChunkArraySchema).min(1).optional()
+}).strict();
+var SlotSchema = zod.z.object({
+  epk: zod.z.instanceof(Uint8Array).optional(),
+  kem_ct: ChunkedBytesArraySchema.optional(),
+  wrap: zod.z.instanceof(Uint8Array).optional()
+});
+zod.z.object({
+  m: zod.z.number().int(),
+  t: zod.z.number().int(),
+  p: zod.z.number().int()
+}).strict();
+var PassphraseBlockSchema = zod.z.object({
+  alg: zod.z.string(),
+  salt: zod.z.instanceof(Uint8Array).superRefine((bytes, ctx) => {
+    if (bytes.length < 16) {
+      ctx.addIssue({
+        code: "custom",
+        path: [],
+        message: `passphrase.salt length ${bytes.length} < 16`,
+        params: { code: "ENC_PASSPHRASE_SALT_TOO_SHORT" }
+      });
+    } else if (bytes.length > 64) {
+      ctx.addIssue({
+        code: "custom",
+        path: [],
+        message: `passphrase.salt length ${bytes.length} > 64`,
+        params: { code: "ENC_PASSPHRASE_SALT_TOO_LONG" }
+      });
+    }
+  }),
+  params: zod.z.record(zod.z.string(), zod.z.unknown())
+}).strict();
+var EncryptionEnvelopeSchema = zod.z.object({
+  scheme: zod.z.unknown(),
+  aead: zod.z.string(),
+  kem: zod.z.string().optional(),
+  nonce: zod.z.instanceof(Uint8Array),
+  slots: zod.z.array(SlotSchema).optional(),
+  slots_mac: zod.z.instanceof(Uint8Array).refine((b5) => b5.length === 32, {
+    params: { code: "ENC_SLOTS_MAC_INVALID_LENGTH" }
+  }).optional(),
+  passphrase: PassphraseBlockSchema.optional()
+}).strict();
+var ItemEntrySchema = zod.z.object({
+  hashes: HashesMapSchema,
+  uris: zod.z.array(UriChunkArraySchema).min(1).optional(),
+  // Captured as `unknown` so the validator can run the
+  // `ENC_REQUIRES_CONTENT_HASH` pre-check ahead of any inner-shape errors
+  // and surface the most informative code first.
+  enc: zod.z.unknown().optional()
+}).strict();
+var SigEntrySchema = zod.z.object({
+  cose_key: ChunkedBytesArraySchema.optional(),
+  cose_sign1: ChunkedBytesArraySchema
+}).strict();
+var SupersedesSchema = zod.z.instanceof(Uint8Array).refine((b5) => b5.length === 32, {
+  params: { code: "SUPERSEDES_TX_INVALID_LENGTH" }
+});
+var VersionLiteralSchema = zod.z.literal(1);
+var PoeRecordSchema = zod.z.looseObject({
+  v: VersionLiteralSchema,
+  items: zod.z.array(ItemEntrySchema).optional(),
+  merkle: zod.z.array(MerkleCommitSchema).optional(),
+  supersedes: SupersedesSchema.optional(),
+  sigs: zod.z.array(SigEntrySchema).optional(),
+  crit: zod.z.array(zod.z.string()).optional()
+});
+var TOP_LEVEL_BASE_KEYS = /* @__PURE__ */ new Set([
+  "v",
+  "items",
+  "merkle",
+  "supersedes",
+  "sigs",
+  "crit"
+]);
+var EXTENSION_KEY_VENDOR_RE = /^x-.+\n?$/;
+var EXTENSION_KEY_COMPANION_RE = /^[a-z]+-.+\n?$/;
+function isExtensionKey(k4) {
+  return EXTENSION_KEY_VENDOR_RE.test(k4) || EXTENSION_KEY_COMPANION_RE.test(k4);
+}
+
+// src/validator.ts
+var HASH_ALG_LENGTHS = {
+  "sha2-256": 32,
+  "blake2b-256": 32
+};
+var MERKLE_COMMIT_ALG_LENGTHS = {
+  "rfc9162-sha256": 32
+};
+var AEAD_NONCE_LENGTHS = {
+  "xchacha20-poly1305": 24
+};
+var UNAUTHENTICATED_CIPHER_RE = /(?:^|[-_])(?:cbc|ctr|ecb|cfb|ofb)(?:[-_]|\n?$)|^(?:rc4|des|3des)(?:[-_]|\n?$)/i;
+var KEM_SLOT_DESCRIPTORS = {
+  x25519: { field: "epk", fieldLength: 32, wrapLength: 48 },
+  mlkem768x25519: { field: "kem_ct", fieldLength: 1120, wrapLength: 48 }
+};
+var KEM_FIELD_LENGTH_CODE = {
+  epk: "KEM_EPK_LENGTH_MISMATCH",
+  kem_ct: "KEM_CT_LENGTH_MISMATCH"
+};
+var PASSPHRASE_KDF_ALGS = /* @__PURE__ */ new Set(["argon2id"]);
+var KNOWN_SIG_ALG_IDS = /* @__PURE__ */ new Set([-8, -19]);
+function validatePoeRecord(bytes) {
+  let decoded;
+  try {
+    decoded = decodeCanonicalCbor(bytes);
+  } catch (cause) {
+    return {
+      ok: false,
+      issues: [
+        {
+          code: "MALFORMED_CBOR",
+          path: [],
+          message: cause instanceof Error ? cause.message : String(cause),
+          severity: "error"
+        }
+      ]
+    };
+  }
+  const parse = PoeRecordSchema.safeParse(decoded);
+  if (!parse.success) {
+    const issues = parse.error.issues.map((issue2) => mapZodIssue(issue2, decoded)).sort(compareIssuePath);
+    return { ok: false, issues };
+  }
+  const record = parse.data;
+  const errors = [];
+  const warnings = [];
+  const info = [];
+  const itemsLen = Array.isArray(record.items) ? record.items.length : 0;
+  const merkleLen = Array.isArray(record.merkle) ? record.merkle.length : 0;
+  if (itemsLen === 0 && merkleLen === 0) {
+    errors.push(
+      issue(
+        "SCHEMA_EMPTY_RECORD",
+        [],
+        "record must carry at least one of items[] or merkle[] non-empty"
+      )
+    );
+  }
+  const decodedTopKeys = topLevelKeysOf(decoded);
+  const critShapeInvalidIndices = checkCritShape(record, decodedTopKeys, errors);
+  for (const k4 of decodedTopKeys) {
+    if (TOP_LEVEL_BASE_KEYS.has(k4)) continue;
+    if (isExtensionKey(k4)) continue;
+    errors.push(issue("SCHEMA_UNKNOWN_FIELD", [k4], `unknown top-level field: ${k4}`));
+  }
+  if (Array.isArray(record.crit)) {
+    for (let i = 0; i < record.crit.length; i++) {
+      if (critShapeInvalidIndices.has(i)) continue;
+      const critName = record.crit[i];
+      errors.push(
+        issue(
+          "EXTENSION_UNSUPPORTED_CRITICAL",
+          ["crit", i],
+          `crit lists extension '${critName}' that this validator does not implement`
+        )
+      );
+    }
+  }
+  for (let i = 0; i < (record.items ?? []).length; i++) {
+    const item = record.items[i];
+    checkItemHashes(item, i, errors);
+    if (item.uris) checkItemUris(item.uris, ["items", i, "uris"], errors);
+    if (item.enc !== void 0) checkItemEnc(item, i, errors);
+  }
+  for (let i = 0; i < (record.merkle ?? []).length; i++) {
+    const commit = record.merkle[i];
+    checkMerkleCommit(commit, i, errors);
+  }
+  if (record.sigs) {
+    for (let i = 0; i < record.sigs.length; i++) {
+      checkSigEntry(record.sigs[i], i, errors, info);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, issues: errors.sort(compareIssuePath) };
+  }
+  const result = {
+    ok: true,
+    record
+  };
+  if (warnings.length > 0) result.warnings = warnings.sort(compareIssuePath);
+  if (info.length > 0) result.info = info.sort(compareIssuePath);
+  return result;
+}
+function mapZodIssue(zissue, decoded) {
+  const path = zissue.path;
+  const explicit = zissue.params?.code;
+  if (explicit !== void 0) {
+    return issue(explicit, path, zissue.message);
+  }
+  const inSigsEntry = path.length >= 2 && path[0] === "sigs" && typeof path[1] === "number";
+  const isInSlotEntry = (() => {
+    if (path.length >= 5 && path[0] === "items" && typeof path[1] === "number" && path[2] === "enc" && path[3] === "slots" && typeof path[4] === "number") {
+      return true;
+    }
+    if (path.length >= 2 && path[0] === "slots" && typeof path[1] === "number") {
+      return true;
+    }
+    return false;
+  })();
+  const valueAtIssue = valueAtPath(decoded, path);
+  const isMissing = valueAtIssue === void 0;
+  switch (zissue.code) {
+    case "invalid_type":
+      if (isInSlotEntry) return issue("ENC_SLOT_INVALID_SHAPE", path, zissue.message);
+      if (isMissing) {
+        if (inSigsEntry) return issue("SIG_ENTRY_INVALID_SHAPE", path, zissue.message);
+        return issue("SCHEMA_MISSING_REQUIRED", path, zissue.message);
+      }
+      if (inSigsEntry) return issue("SIG_ENTRY_INVALID_SHAPE", path, zissue.message);
+      return issue("SCHEMA_TYPE_MISMATCH", path, zissue.message);
+    case "invalid_value":
+      if (path.length === 1 && path[0] === "v") {
+        return issue(
+          isMissing ? "SCHEMA_MISSING_REQUIRED" : "SCHEMA_INVALID_LITERAL",
+          path,
+          zissue.message
+        );
+      }
+      return issue("SCHEMA_INVALID_LITERAL", path, zissue.message);
+    case "unrecognized_keys":
+      if (isInSlotEntry) return issue("ENC_SLOT_INVALID_SHAPE", path, zissue.message);
+      if (inSigsEntry) return issue("SIG_ENTRY_INVALID_SHAPE", path, zissue.message);
+      return issue("SCHEMA_UNKNOWN_FIELD", path, zissue.message);
+    case "invalid_format":
+    case "too_big":
+    case "too_small":
+      if (inSigsEntry) return issue("SIG_ENTRY_INVALID_SHAPE", path, zissue.message);
+      return issue("SCHEMA_TYPE_MISMATCH", path, zissue.message);
+    case "invalid_union":
+    case "invalid_key":
+    case "invalid_element":
+    case "custom":
+    default:
+      if (isInSlotEntry) return issue("ENC_SLOT_INVALID_SHAPE", path, zissue.message);
+      if (inSigsEntry) return issue("SIG_ENTRY_INVALID_SHAPE", path, zissue.message);
+      return issue("SCHEMA_TYPE_MISMATCH", path, zissue.message);
+  }
+}
+function checkItemHashes(item, idx, errors) {
+  const entries = Object.entries(item.hashes);
+  if (entries.length === 0) {
+    errors.push(
+      issue(
+        "SCHEMA_TYPE_MISMATCH",
+        ["items", idx, "hashes"],
+        "hashes must be a non-empty CBOR map of <alg-id> -> <digest>"
+      )
+    );
+    return;
+  }
+  for (const [alg, digest] of entries) {
+    if (!(alg in HASH_ALG_LENGTHS)) {
+      errors.push(
+        issue("UNSUPPORTED_HASH_ALG", ["items", idx, "hashes", alg], `unknown hash alg: ${alg}`)
+      );
+      continue;
+    }
+    const expected = HASH_ALG_LENGTHS[alg];
+    if (digest.length !== expected) {
+      errors.push(
+        issue(
+          "HASH_DIGEST_LENGTH_MISMATCH",
+          ["items", idx, "hashes", alg],
+          `hashes['${alg}'] digest length ${digest.length} != ${expected}`
+        )
+      );
+    }
+  }
+}
+function checkItemUris(uris, basePath, errors) {
+  uris.forEach((chunks, ui) => validateOneUri(chunks, [...basePath, ui], errors));
+}
+function validateOneUri(chunks, path, errors) {
+  const reconstructed = reconstructChunkedUri(chunks);
+  if (!reconstructed.ok) {
+    errors.push(issue(reconstructed.code, path, reconstructed.reason));
+    return;
+  }
+  const uri = reconstructed.uri;
+  if (uri.includes("#")) {
+    errors.push(
+      issue(
+        "INVALID_URI",
+        path,
+        "URI contains a fragment identifier ('#'), which is forbidden"
+      )
+    );
+    return;
+  }
+  const sepIdx = uri.indexOf("://");
+  if (sepIdx <= 0 || !/^[a-z][a-z0-9+.-]*$/i.test(uri.slice(0, sepIdx))) {
+    errors.push(
+      issue("INVALID_URI", path, "URI is not absolute (missing scheme://hierarchical-part)")
+    );
+    return;
+  }
+  const scheme = uri.slice(0, sepIdx).toLowerCase();
+  const rest = uri.slice(sepIdx + "://".length);
+  if (scheme === "ar") {
+    if (!/^ar:\/\/[A-Za-z0-9_-]{43}$/.test("ar://" + rest)) {
+      errors.push(
+        issue(
+          "INVALID_URI",
+          path,
+          "ar:// URI does not match `^ar://[A-Za-z0-9_-]{43}$` (43-char base64url txid, no path/query/fragment)"
+        )
+      );
+    }
+    return;
+  }
+  if (scheme === "ipfs") {
+    const slashIdx = rest.indexOf("/");
+    const cid = slashIdx === -1 ? rest : rest.slice(0, slashIdx);
+    if (!validateCidProfile(cid)) {
+      errors.push(
+        issue(
+          "INVALID_URI",
+          path,
+          "ipfs:// URI is not a valid CID under the CIP-309 profile"
+        )
+      );
+    }
+    return;
+  }
+  errors.push(
+    issue(
+      "INVALID_URI",
+      path,
+      "unsupported URI scheme; v1 PoE URI set is {ar://, ipfs://}"
+    )
+  );
+}
+function checkItemEnc(item, idx, errors) {
+  const hasContentHash = Object.keys(item.hashes).some((alg) => alg in HASH_ALG_LENGTHS);
+  if (!hasContentHash) {
+    errors.push(
+      issue(
+        "ENC_REQUIRES_CONTENT_HASH",
+        ["items", idx, "enc"],
+        "item carries `enc` but `hashes` has no content-hash entry (sha2-256 or blake2b-256)"
+      )
+    );
+    return;
+  }
+  const encParse = EncryptionEnvelopeSchema.safeParse(item.enc);
+  if (!encParse.success) {
+    for (const zissue of encParse.error.issues) {
+      const mapped = mapZodIssue(zissue, item.enc);
+      errors.push({
+        ...mapped,
+        path: ["items", idx, "enc", ...mapped.path]
+      });
+    }
+    return;
+  }
+  const enc = encParse.data;
+  const basePath = ["items", idx, "enc"];
+  if (typeof enc.scheme !== "number" || !Number.isInteger(enc.scheme) || enc.scheme !== 1) {
+    errors.push(
+      issue(
+        "UNSUPPORTED_ENVELOPE_SCHEME",
+        [...basePath, "scheme"],
+        `enc.scheme must be the unsigned integer 1; got ${String(enc.scheme)}`
+      )
+    );
+  }
+  if (UNAUTHENTICATED_CIPHER_RE.test(enc.aead)) {
+    errors.push(
+      issue(
+        "UNAUTHENTICATED_CIPHER_FORBIDDEN",
+        [...basePath, "aead"],
+        `'${enc.aead}' is an unauthenticated cipher; CIP-309 mandates an authenticated (AEAD) cipher`
+      )
+    );
+    return;
+  }
+  if (!(enc.aead in AEAD_NONCE_LENGTHS)) {
+    errors.push(
+      issue("UNSUPPORTED_AEAD_ALG", [...basePath, "aead"], `unknown aead alg: ${enc.aead}`)
+    );
+    return;
+  }
+  const expectedNonceLen = AEAD_NONCE_LENGTHS[enc.aead];
+  if (enc.nonce.length !== expectedNonceLen) {
+    errors.push(
+      issue(
+        "NONCE_LENGTH_MISMATCH",
+        [...basePath, "nonce"],
+        `nonce length ${enc.nonce.length} != ${expectedNonceLen} for ${enc.aead}`
+      )
+    );
+  }
+  if (enc.kem !== void 0 && !(enc.kem in KEM_SLOT_DESCRIPTORS)) {
+    errors.push(issue("UNSUPPORTED_KEM_ALG", [...basePath, "kem"], `unknown kem alg: ${enc.kem}`));
+  }
+  const hasSlots = enc.slots !== void 0;
+  const hasSlotsMac = enc.slots_mac !== void 0;
+  const hasPassphrase = enc.passphrase !== void 0;
+  if (hasSlots && hasPassphrase) {
+    errors.push(
+      issue("ENC_EXCLUSIVITY_VIOLATION", basePath, "enc combines slots with passphrase; pick one")
+    );
+  }
+  if (hasSlots && !hasSlotsMac) {
+    errors.push(
+      issue("ENC_SLOTS_MAC_REQUIRED", basePath, "enc.slots present but enc.slots_mac absent")
+    );
+  }
+  if (hasSlotsMac && !hasSlots) {
+    errors.push(
+      issue("ENC_SLOTS_REQUIRED", basePath, "enc.slots_mac present but enc.slots absent")
+    );
+  }
+  if (hasSlots && enc.kem === void 0) {
+    errors.push(issue("ENC_KEM_REQUIRED", basePath, "enc.slots present but enc.kem absent"));
+  }
+  if (!hasSlots && !hasPassphrase) {
+    errors.push(
+      issue(
+        "ENC_NO_KEY_PATH",
+        basePath,
+        "enc requires either slots or passphrase \u2014 no on-chain key path otherwise"
+      )
+    );
+  }
+  if (hasSlots) {
+    if (enc.slots.length < 1) {
+      errors.push(
+        issue("ENC_SLOTS_EMPTY", [...basePath, "slots"], `slots length ${enc.slots.length} < 1`)
+      );
+    }
+    const descriptor = enc.kem !== void 0 ? KEM_SLOT_DESCRIPTORS[enc.kem] : void 0;
+    if (descriptor !== void 0) {
+      const rawSlotKeys = rawSlotKeySets(item.enc);
+      enc.slots.forEach((slot, si) => {
+        checkSlotShape(
+          slot,
+          rawSlotKeys[si] ?? /* @__PURE__ */ new Set(),
+          descriptor,
+          enc.kem,
+          [...basePath, "slots", si],
+          errors
+        );
+      });
+    }
+  }
+  if (hasPassphrase) {
+    const pp = enc.passphrase;
+    const ppPath = [...basePath, "passphrase"];
+    if (!PASSPHRASE_KDF_ALGS.has(pp.alg)) {
+      errors.push(
+        issue(
+          "ENC_PASSPHRASE_ALG_UNSUPPORTED",
+          [...ppPath, "alg"],
+          `unknown passphrase kdf alg: ${pp.alg}`
+        )
+      );
+      return;
+    }
+    if (pp.alg === "argon2id") {
+      const allowed = /* @__PURE__ */ new Set(["m", "t", "p"]);
+      for (const k4 of Object.keys(pp.params)) {
+        if (!allowed.has(k4)) {
+          errors.push(
+            issue(
+              "SCHEMA_UNKNOWN_FIELD",
+              [...ppPath, "params", k4],
+              `unknown argon2id params field: ${k4}`
+            )
+          );
+        }
+      }
+      const p5 = pp.params;
+      const argonInt = (val, name) => {
+        if (typeof val !== "number" || !Number.isInteger(val)) {
+          errors.push(
+            issue(
+              "SCHEMA_TYPE_MISMATCH",
+              [...ppPath, "params", name],
+              `argon2id params.${name} must be a CBOR unsigned integer`
+            )
+          );
+          return null;
+        }
+        return val;
+      };
+      const mVal = argonInt(p5.m, "m");
+      const tVal = argonInt(p5.t, "t");
+      const pVal = argonInt(p5.p, "p");
+      if (mVal !== null && mVal < 65536) {
+        errors.push(
+          issue(
+            "ENC_PASSPHRASE_ARGON2_PARAMS_TOO_LOW",
+            [...ppPath, "params", "m"],
+            "argon2id requires m >= 65536 KiB"
+          )
+        );
+      }
+      if (tVal !== null && tVal < 3) {
+        errors.push(
+          issue(
+            "ENC_PASSPHRASE_ARGON2_PARAMS_TOO_LOW",
+            [...ppPath, "params", "t"],
+            "argon2id requires t >= 3"
+          )
+        );
+      }
+      if (pVal !== null && pVal < 1) {
+        errors.push(
+          issue(
+            "ENC_PASSPHRASE_ARGON2_PARAMS_TOO_LOW",
+            [...ppPath, "params", "p"],
+            "argon2id requires p >= 1"
+          )
+        );
+      }
+    }
+  }
+}
+var SLOT_KEY_UNIVERSE = /* @__PURE__ */ new Set(["epk", "kem_ct", "wrap"]);
+function checkSlotShape(slot, rawKeys, descriptor, kem, slotPath, errors) {
+  const foreignField = descriptor.field === "epk" ? "kem_ct" : "epk";
+  if (rawKeys.has(foreignField)) {
+    errors.push(
+      issue(
+        "ENC_SLOT_INVALID_SHAPE",
+        [...slotPath, foreignField],
+        `slot carries '${foreignField}' but kem='${kem}' expects '${descriptor.field}'`
+      )
+    );
+  }
+  for (const k4 of rawKeys) {
+    if (!SLOT_KEY_UNIVERSE.has(k4)) {
+      errors.push(
+        issue(
+          "ENC_SLOT_INVALID_SHAPE",
+          [...slotPath, k4],
+          `slot carries unexpected key '${k4}'; a slot is a 2-key map {${descriptor.field}, wrap}`
+        )
+      );
+    }
+  }
+  if (descriptor.field === "epk") {
+    if (slot.epk === void 0) {
+      errors.push(
+        issue(
+          "ENC_SLOT_INVALID_SHAPE",
+          [...slotPath, "epk"],
+          `slot for kem='${kem}' is missing required 'epk'`
+        )
+      );
+    } else if (slot.epk.length !== descriptor.fieldLength) {
+      errors.push(
+        issue(
+          KEM_FIELD_LENGTH_CODE.epk,
+          [...slotPath, "epk"],
+          `slot.epk length ${slot.epk.length} != ${descriptor.fieldLength} for ${kem}`
+        )
+      );
+    }
+  } else {
+    if (slot.kem_ct === void 0) {
+      errors.push(
+        issue(
+          "ENC_SLOT_INVALID_SHAPE",
+          [...slotPath, "kem_ct"],
+          `slot for kem='${kem}' is missing required 'kem_ct'`
+        )
+      );
+    } else {
+      const reassembled = bytesChunkArrayConcat(slot.kem_ct).length;
+      if (reassembled !== descriptor.fieldLength) {
+        errors.push(
+          issue(
+            KEM_FIELD_LENGTH_CODE.kem_ct,
+            [...slotPath, "kem_ct"],
+            `slot.kem_ct reassembles to ${reassembled} bytes != ${descriptor.fieldLength} for ${kem}`
+          )
+        );
+      }
+    }
+  }
+  if (slot.wrap === void 0) {
+    errors.push(
+      issue(
+        "ENC_SLOT_INVALID_SHAPE",
+        [...slotPath, "wrap"],
+        `slot for kem='${kem}' is missing required 'wrap'`
+      )
+    );
+  } else if (slot.wrap.length !== descriptor.wrapLength) {
+    errors.push(
+      issue(
+        "WRAP_LENGTH_MISMATCH",
+        [...slotPath, "wrap"],
+        `slot.wrap length ${slot.wrap.length} != ${descriptor.wrapLength}`
+      )
+    );
+  }
+}
+function rawSlotKeySets(rawEnc) {
+  const slots = mapLikeGet(rawEnc, "slots");
+  if (!Array.isArray(slots)) return [];
+  return slots.map((slot) => {
+    const keys = /* @__PURE__ */ new Set();
+    if (slot instanceof Map) {
+      for (const k4 of slot.keys()) if (typeof k4 === "string") keys.add(k4);
+    } else if (typeof slot === "object" && slot !== null) {
+      for (const k4 of Object.keys(slot)) keys.add(k4);
+    }
+    return keys;
+  });
+}
+function mapLikeGet(value, key) {
+  if (value instanceof Map) return value.get(key);
+  if (typeof value === "object" && value !== null) {
+    return value[key];
+  }
+  return void 0;
+}
+function checkMerkleCommit(commit, idx, errors) {
+  const basePath = ["merkle", idx];
+  if (!(commit.alg in MERKLE_COMMIT_ALG_LENGTHS)) {
+    errors.push(
+      issue(
+        "UNSUPPORTED_MERKLE_COMMIT_ALG",
+        [...basePath, "alg"],
+        `unknown merkle commitment alg: ${commit.alg}`
+      )
+    );
+    return;
+  }
+  const expected = MERKLE_COMMIT_ALG_LENGTHS[commit.alg];
+  if (commit.root.length !== expected) {
+    errors.push(
+      issue(
+        "HASH_DIGEST_LENGTH_MISMATCH",
+        [...basePath, "root"],
+        `merkle entry root length ${commit.root.length} != ${expected} for ${commit.alg}`
+      )
+    );
+  }
+  if (commit.uris) {
+    checkItemUris(commit.uris, [...basePath, "uris"], errors);
+  }
+}
+function checkSigEntry(entry, idx, errors, info) {
+  if (entry.cose_key !== void 0) {
+    const keyIssue = inspectCoseKey(entry.cose_key, idx);
+    if (keyIssue !== null) {
+      errors.push(keyIssue);
+      return;
+    }
+  }
+  const merged = bytesChunkArrayConcat(entry.cose_sign1);
+  let cose;
+  try {
+    cose = decodeCoseSign1(merged);
+  } catch (cause) {
+    errors.push(
+      issue(
+        "MALFORMED_SIG_COSE_SIGN1",
+        ["sigs", idx],
+        cause instanceof CoseVerifyError || cause instanceof Error ? cause.message : String(cause)
+      )
+    );
+    return;
+  }
+  if (cose.payload !== null) {
+    errors.push(
+      issue(
+        "MALFORMED_SIG_COSE_SIGN1",
+        ["sigs", idx],
+        "COSE_Sign1 payload must be null (detached); attached form forbidden"
+      )
+    );
+    return;
+  }
+  const alg = cose.protectedHeader.get(1);
+  if (typeof alg !== "number" || !KNOWN_SIG_ALG_IDS.has(alg)) {
+    info.push(
+      issue(
+        "SIGNATURE_UNSUPPORTED",
+        ["sigs", idx],
+        `COSE_Sign1 protected alg ${String(alg)} not in {-8, -19}`
+      )
+    );
+  }
+  const protectedKid = cose.protectedHeader.get(4);
+  if (protectedKid instanceof Uint8Array && protectedKid.length === 32 && entry.cose_key !== void 0) {
+    errors.push(
+      issue(
+        "SIG_ENTRY_KID_COSE_KEY_CONFLICT",
+        ["sigs", idx],
+        "sigs[i] carries both a 32-byte protected `kid` (path 1) and an inline `cose_key` (path 2); paths are mutually exclusive"
+      )
+    );
+  }
+}
+function inspectCoseKey(keyChunks, i) {
+  let decoded;
+  try {
+    decoded = decodeCanonicalCbor(bytesChunkArrayConcat(keyChunks));
+  } catch (cause) {
+    return issue(
+      "MALFORMED_SIG_COSE_SIGN1",
+      ["sigs", i, "cose_key"],
+      `sigs[${i}].cose_key failed to decode as cbor<COSE_Key>: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+  }
+  const getLabel = (label) => {
+    if (decoded instanceof Map) return decoded.get(label);
+    if (typeof decoded === "object" && decoded !== null) {
+      return decoded[String(label)];
+    }
+    return void 0;
+  };
+  const hasLabel = (label) => {
+    if (decoded instanceof Map) return decoded.has(label);
+    if (typeof decoded === "object" && decoded !== null) {
+      return Object.prototype.hasOwnProperty.call(decoded, String(label));
+    }
+    return false;
+  };
+  if (hasLabel(-4)) {
+    return issue(
+      "SIG_PRIVATE_KEY_LEAKED",
+      ["sigs", i, "cose_key"],
+      "cose_key carries COSE_Key private-key material (label -4, the OKP/EC2 private scalar d); publishing a private key on the permanent ledger is forbidden"
+    );
+  }
+  const kty = getLabel(1);
+  if (kty !== 1) {
+    return issue(
+      "MALFORMED_SIG_COSE_SIGN1",
+      ["sigs", i, "cose_key"],
+      `sigs[${i}].cose_key COSE_Key kty (label 1) must be 1 (OKP); got ${String(kty)}`
+    );
+  }
+  const crv = getLabel(-1);
+  if (crv !== 6) {
+    return issue(
+      "MALFORMED_SIG_COSE_SIGN1",
+      ["sigs", i, "cose_key"],
+      `sigs[${i}].cose_key COSE_Key crv (label -1) must be 6 (Ed25519); got ${String(crv)}`
+    );
+  }
+  if (!hasLabel(-2)) {
+    return issue(
+      "MALFORMED_SIG_COSE_SIGN1",
+      ["sigs", i, "cose_key"],
+      `sigs[${i}].cose_key COSE_Key missing label -2 (Ed25519 public-key bytes)`
+    );
+  }
+  const x5 = getLabel(-2);
+  if (!(x5 instanceof Uint8Array) || x5.length !== 32) {
+    const got = x5 instanceof Uint8Array ? `${x5.length}-byte bstr` : typeof x5;
+    return issue(
+      "MALFORMED_SIG_COSE_SIGN1",
+      ["sigs", i, "cose_key"],
+      `sigs[${i}].cose_key COSE_Key label -2 must be a 32-byte byte string (Ed25519 public key); got ${got}`
+    );
+  }
+  return null;
+}
+var ACCEPTED_CIDV1_MULTIBASE = /* @__PURE__ */ new Set(["b", "B", "f", "F", "z"]);
+var ACCEPTED_MULTICODECS = /* @__PURE__ */ new Set([85, 112, 113]);
+var ACCEPTED_MULTIHASHES = /* @__PURE__ */ new Map([
+  [18, 32],
+  [45600, 32]
+]);
+function validateCidProfile(cid) {
+  if (cid.length === 0) return false;
+  if (cid.startsWith("Qm")) {
+    let decoded;
+    try {
+      decoded = decodeBase58btc(cid);
+    } catch {
+      return false;
+    }
+    return decoded.length === 34 && decoded[0] === 18 && decoded[1] === 32;
+  }
+  const mbPrefix = cid[0];
+  if (!ACCEPTED_CIDV1_MULTIBASE.has(mbPrefix)) return false;
+  let bytes;
+  try {
+    bytes = decodeMultibase(mbPrefix, cid.slice(1));
+  } catch {
+    return false;
+  }
+  if (bytes.length < 4) return false;
+  const versionParse = readVarint(bytes, 0);
+  if (versionParse === null || versionParse.value !== 1) return false;
+  const codecParse = readVarint(bytes, versionParse.next);
+  if (codecParse === null) return false;
+  if (!ACCEPTED_MULTICODECS.has(codecParse.value)) return false;
+  const mhParse = readVarint(bytes, codecParse.next);
+  if (mhParse === null) return false;
+  const lenParse = readVarint(bytes, mhParse.next);
+  if (lenParse === null) return false;
+  const digestLen = lenParse.value;
+  const expectedLen = ACCEPTED_MULTIHASHES.get(mhParse.value);
+  if (expectedLen === void 0 || digestLen !== expectedLen) return false;
+  if (lenParse.next + digestLen !== bytes.length) return false;
+  return true;
+}
+function readVarint(bytes, start) {
+  let value = 0;
+  let shift = 0;
+  let i = start;
+  while (i < bytes.length) {
+    const b5 = bytes[i];
+    value |= (b5 & 127) << shift;
+    i++;
+    if ((b5 & 128) === 0) return { value, next: i };
+    shift += 7;
+    if (shift > 28) return null;
+  }
+  return null;
+}
+function decodeMultibase(prefix, body) {
+  switch (prefix) {
+    case "b":
+      return decodeBase32(body.toLowerCase(), "rfc4648-lower");
+    case "B":
+      return decodeBase32(body.toUpperCase(), "rfc4648-upper");
+    case "f":
+      return decodeBase16(body.toLowerCase());
+    case "F":
+      return decodeBase16(body.toUpperCase());
+    case "z":
+      return decodeBase58btc(body);
+    default:
+      throw new Error(`unsupported multibase prefix ${prefix}`);
+  }
+}
+var BASE16_LOWER = "0123456789abcdef";
+var BASE16_UPPER = "0123456789ABCDEF";
+function decodeBase16(s3) {
+  if (s3.length % 2 !== 0) throw new Error("base16: odd-length");
+  const out = new Uint8Array(s3.length / 2);
+  const alphabet = s3 === s3.toLowerCase() ? BASE16_LOWER : BASE16_UPPER;
+  for (let i = 0; i < out.length; i++) {
+    const hi = alphabet.indexOf(s3[i * 2]);
+    const lo = alphabet.indexOf(s3[i * 2 + 1]);
+    if (hi < 0 || lo < 0) throw new Error(`base16: non-hex char at ${i * 2}`);
+    out[i] = hi << 4 | lo;
+  }
+  return out;
+}
+var BASE32_RFC4648_LOWER = "abcdefghijklmnopqrstuvwxyz234567";
+var BASE32_RFC4648_UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+function decodeBase32(s3, variant) {
+  const alphabet = variant === "rfc4648-lower" ? BASE32_RFC4648_LOWER : BASE32_RFC4648_UPPER;
+  const trimmed = s3.replace(/=+$/, "");
+  const out = [];
+  let buf = 0;
+  let bits = 0;
+  for (const ch of trimmed) {
+    const idx = alphabet.indexOf(ch);
+    if (idx < 0) throw new Error(`base32: invalid char '${ch}'`);
+    buf = buf << 5 | idx;
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      out.push(buf >> bits & 255);
+    }
+  }
+  return Uint8Array.from(out);
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function decodeBase58btc(s3) {
+  if (s3.length === 0) return new Uint8Array(0);
+  let zeros = 0;
+  while (zeros < s3.length && s3[zeros] === "1") zeros++;
+  const size = Math.floor((s3.length - zeros) * 733 / 1e3) + 1;
+  const b256 = new Uint8Array(size);
+  let length = 0;
+  for (let i = zeros; i < s3.length; i++) {
+    const ch = s3[i];
+    const carryIdx = BASE58_ALPHABET.indexOf(ch);
+    if (carryIdx < 0) throw new Error(`base58: invalid char '${ch}'`);
+    let carry = carryIdx;
+    let k4 = 0;
+    for (let j3 = size - 1; (carry !== 0 || k4 < length) && j3 >= 0; j3--, k4++) {
+      carry += 58 * b256[j3];
+      b256[j3] = carry % 256;
+      carry = Math.floor(carry / 256);
+    }
+    length = k4;
+  }
+  let it = size - length;
+  while (it < size && b256[it] === 0) it++;
+  const out = new Uint8Array(zeros + (size - it));
+  let j2 = zeros;
+  while (it < size) {
+    out[j2++] = b256[it++];
+  }
+  return out;
+}
+function checkCritShape(record, decodedTopKeys, errors) {
+  const invalid = /* @__PURE__ */ new Set();
+  if (!Array.isArray(record.crit)) return invalid;
+  if (record.crit.length === 0) {
+    errors.push(
+      issue("SCHEMA_TYPE_MISMATCH", ["crit"], "crit[] must carry at least one entry when present")
+    );
+    return invalid;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < record.crit.length; i++) {
+    const critName = record.crit[i];
+    let reason = null;
+    if (TOP_LEVEL_BASE_KEYS.has(critName)) {
+      reason = `'${critName}' is a base key and MUST NOT appear in crit[]`;
+    } else if (!isExtensionKey(critName)) {
+      reason = `'${critName}' does not match the extension-key regex (^x-.+ or ^[a-z]+-.+)`;
+    } else if (!decodedTopKeys.has(critName)) {
+      reason = `'${critName}' is named in crit but absent from the record map`;
+    } else if (seen.has(critName)) {
+      reason = `'${critName}' appears more than once in crit[]`;
+    }
+    seen.add(critName);
+    if (reason !== null) {
+      invalid.add(i);
+      errors.push(issue("CRIT_SHAPE_INVALID", ["crit", i], reason));
+    }
+  }
+  return invalid;
+}
+function topLevelKeysOf(decoded) {
+  if (decoded === null || typeof decoded !== "object") return /* @__PURE__ */ new Set();
+  if (decoded instanceof Map) {
+    const out = /* @__PURE__ */ new Set();
+    for (const k4 of decoded.keys()) {
+      if (typeof k4 === "string") out.add(k4);
+    }
+    return out;
+  }
+  return new Set(Object.keys(decoded));
+}
+function issue(code, path, message) {
+  return { code, path, message, severity: SEVERITY[code] };
+}
+function compareIssuePath(a4, b5) {
+  return a4.path.join(".").localeCompare(b5.path.join("."));
+}
+function valueAtPath(root, path) {
+  let cur = root;
+  for (const seg of path) {
+    if (cur === null || cur === void 0) return void 0;
+    if (cur instanceof Map) {
+      cur = cur.get(seg);
+      continue;
+    }
+    if (typeof cur !== "object") return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+/*! Bundled license information:
+
+@noble/ed25519/index.js:
+  (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
+*/
+
+exports.validateCidProfile = validateCidProfile;
+exports.validatePoeRecord = validatePoeRecord;
+//# sourceMappingURL=validator.cjs.map
+//# sourceMappingURL=validator.cjs.map