@forestrie/forestrie-cli 0.8.1 → 0.9.1

package/dist/cli.js

@@ -913,6 +913,17 @@ async function readStdinBytes() {
 }
 var init_fsio = () => {};
 
+// node_modules/@forestrie/encoding/dist/canonical-key-order.js
+function compareCanonicalKeys(a, b) {
+  if (a.length !== b.length)
+    return a.length - b.length;
+  for (let i = 0;i < a.length; i++) {
+    if (a[i] !== b[i])
+      return a[i] - b[i];
+  }
+  return 0;
+}
+
 // node_modules/@forestrie/encoding/dist/encode-cbor-bstr.js
 function encodeCborBstr(bytes) {
   const len = bytes.length;
@@ -1043,9 +1054,9 @@ function encodeMap(entries, depth) {
       valueBytes: encodeValue(v, depth + 1)
     };
   });
-  encoded.sort((a, b) => compareBytes(a.keyBytes, b.keyBytes));
+  encoded.sort((a, b) => compareCanonicalKeys(a.keyBytes, b.keyBytes));
   for (let i = 1;i < encoded.length; i++) {
-    if (compareBytes(encoded[i - 1].keyBytes, encoded[i].keyBytes) === 0) {
+    if (compareCanonicalKeys(encoded[i - 1].keyBytes, encoded[i].keyBytes) === 0) {
       throw new Error("encodeCborDeterministic: duplicate map key");
     }
   }
@@ -1054,15 +1065,8 @@ function encodeMap(entries, depth) {
     chunks.push(e.keyBytes, e.valueBytes);
   return concat(chunks);
 }
-function compareBytes(a, b) {
-  const n = Math.min(a.length, b.length);
-  for (let i = 0;i < n; i++) {
-    if (a[i] !== b[i])
-      return a[i] - b[i];
-  }
-  return a.length - b.length;
-}
 var MAJOR_UINT = 0, MAJOR_NINT = 1, MAJOR_BSTR = 2, MAJOR_TSTR = 3, MAJOR_ARRAY = 4, MAJOR_MAP = 5, MAX_DEPTH = 64;
+var init_encode_cbor_deterministic = () => {};
 
 // node_modules/@forestrie/encoding/dist/decode-cbor-deterministic.js
 class CborTag {
@@ -1074,11 +1078,27 @@ class CborTag {
   }
 }
 
+class CborSimple {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class CborFloat {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
 class Reader {
   buf;
+  rejectTags;
   pos = 0;
-  constructor(buf) {
+  constructor(buf, rejectTags) {
     this.buf = buf;
+    this.rejectTags = rejectTags;
   }
   need(n) {
     if (this.pos + n > this.buf.length) {
@@ -1098,18 +1118,26 @@ class Reader {
   argument(ai) {
     if (ai < 24)
       return ai;
-    if (ai === 24)
-      return this.u8();
+    if (ai === 24) {
+      const v = this.u8();
+      if (v < 24)
+        throw this.notShortest(v);
+      return v;
+    }
     if (ai === 25) {
       this.need(2);
       const v = this.buf[this.pos] << 8 | this.buf[this.pos + 1];
       this.pos += 2;
+      if (v < 256)
+        throw this.notShortest(v);
       return v;
     }
     if (ai === 26) {
       this.need(4);
       const v = this.buf[this.pos] * 16777216 + (this.buf[this.pos + 1] << 16) + (this.buf[this.pos + 2] << 8) + this.buf[this.pos + 3];
       this.pos += 4;
+      if (v < 65536)
+        throw this.notShortest(v);
       return v;
     }
     if (ai === 27) {
@@ -1118,9 +1146,55 @@ class Reader {
       for (let i = 0;i < 8; i++)
         v = v << 8n | BigInt(this.buf[this.pos + i]);
       this.pos += 8;
+      if (v < 0x100000000n)
+        throw this.notShortest(v);
       return v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : v;
     }
-    throw new Error(`decodeCbor: unsupported additional info ${ai}`);
+    throw new Error(`decodeCbor: malformed additional info ${ai}`);
+  }
+  notShortest(v) {
+    return new Error(`decodeCbor: argument ${v} is not in shortest form (RFC 8949 4.2.1)`);
+  }
+  checkDeclaredLength(declared, itemsEach, what) {
+    const remaining = BigInt(this.buf.length - this.pos);
+    if (BigInt(declared) * BigInt(itemsEach) > remaining) {
+      throw new Error(`decodeCbor: ${what} declares ${declared} but only ${remaining} byte(s) remain`);
+    }
+    return Number(declared);
+  }
+  float16() {
+    const b = this.bytes(2);
+    const half = b[0] << 8 | b[1];
+    const exponent = half >> 10 & 31;
+    const fraction = half & 1023;
+    if (exponent === 31 && fraction !== 0 && half !== 32256) {
+      throw notPreferredFloat(`NaN payload f9${half.toString(16).padStart(4, "0")}`, "f97e00");
+    }
+    const sign = half & 32768 ? -1 : 1;
+    if (exponent === 0)
+      return sign * fraction * 2 ** -24;
+    if (exponent === 31)
+      return fraction ? NaN : sign * Infinity;
+    return sign * (fraction + 1024) * 2 ** (exponent - 25);
+  }
+  float32() {
+    const v = new DataView(this.bytes(4).buffer).getFloat32(0);
+    if (Number.isNaN(v))
+      throw notPreferredFloat("NaN as fa", "f97e00");
+    if (isFloat16Exact(v))
+      throw notPreferredFloat(`single ${v}`, "half (f9)");
+    return v;
+  }
+  float64() {
+    const v = new DataView(this.bytes(8).buffer).getFloat64(0);
+    if (Number.isNaN(v))
+      throw notPreferredFloat("NaN as fb", "f97e00");
+    if (isFloat16Exact(v))
+      throw notPreferredFloat(`double ${v}`, "half (f9)");
+    if (Math.fround(v) === v) {
+      throw notPreferredFloat(`double ${v}`, "single (fa)");
+    }
+    return v;
   }
   value(depth) {
     if (depth > 64)
@@ -1128,8 +1202,9 @@ class Reader {
     const ib = this.u8();
     const major = ib >> 5;
     const ai = ib & 31;
-    if (ai === 31)
-      throw new Error("decodeCbor: indefinite lengths not allowed");
+    if (ai === 31) {
+      throw new Error(major === 7 ? "decodeCbor: break code (0xff) is not a well-formed item" : "decodeCbor: indefinite lengths not allowed");
+    }
     switch (major) {
       case 0:
         return this.argument(ai);
@@ -1149,27 +1224,24 @@ class Reader {
         }).decode(this.bytes(len));
       }
       case 4: {
-        const len = Number(this.argument(ai));
+        const len = this.checkDeclaredLength(this.argument(ai), 1, "array");
         const out = new Array(len);
         for (let i = 0;i < len; i++)
           out[i] = this.value(depth + 1);
         return out;
       }
-      case 5: {
-        const len = Number(this.argument(ai));
-        const m = new Map;
-        for (let i = 0;i < len; i++) {
-          const k = this.value(depth + 1);
-          const v = this.value(depth + 1);
-          m.set(k, v);
-        }
-        return m;
-      }
+      case 5:
+        return this.map(ai, depth);
       case 6: {
         const tag = Number(this.argument(ai));
+        if (this.rejectTags) {
+          throw new Error(`decodeCbor: tag ${tag} is not allowed here`);
+        }
         return new CborTag(tag, this.value(depth + 1));
       }
       case 7: {
+        if (ai < 20)
+          return new CborSimple(ai);
         switch (ai) {
           case 20:
             return false;
@@ -1178,30 +1250,102 @@ class Reader {
           case 22:
             return null;
           case 23:
-            return;
+            throw new Error("decodeCbor: undefined (0xf7) is not allowed; it re-encodes as null");
+          case 24: {
+            const v = this.u8();
+            if (v < 32) {
+              throw new Error(`decodeCbor: two-byte simple value ${v} below 32 is malformed`);
+            }
+            return new CborSimple(v);
+          }
+          case 25:
+            return new CborFloat(this.float16());
+          case 26:
+            return new CborFloat(this.float32());
+          case 27:
+            return new CborFloat(this.float64());
           default:
-            throw new Error(`decodeCbor: unsupported simple/float value (ai=${ai})`);
+            throw new Error(`decodeCbor: malformed additional info ${ai} (major type 7)`);
         }
       }
       default:
         throw new Error(`decodeCbor: unsupported major type ${major}`);
     }
   }
+  map(ai, depth) {
+    const pairs = this.checkDeclaredLength(this.argument(ai), 2, "map");
+    const m = new Map;
+    let previousKey = null;
+    for (let i = 0;i < pairs; i++) {
+      const keyStart = this.pos;
+      const key = this.value(depth + 1);
+      const keyBytes = this.buf.subarray(keyStart, this.pos);
+      checkKeyMagnitude(key);
+      if (previousKey !== null) {
+        const order = compareCanonicalKeys(previousKey, keyBytes);
+        if (order === 0) {
+          throw new Error(`decodeCbor: duplicate map key ${describeKey(key)}`);
+        }
+        if (order > 0) {
+          throw new Error(`decodeCbor: map key ${describeKey(key)} is out of canonical order`);
+        }
+      }
+      previousKey = keyBytes;
+      m.set(key, this.value(depth + 1));
+    }
+    return m;
+  }
+}
+function checkKeyMagnitude(key) {
+  if (typeof key !== "bigint")
+    return;
+  if (key > INT64_MAX || key < INT64_MIN) {
+    throw new Error(`decodeCbor: integer map key ${key} exceeds int64 magnitude`);
+  }
+}
+function notPreferredFloat(got, want) {
+  return new Error(`decodeCbor: float ${got} is not in shortest form; it re-encodes as ${want} (RFC 8949 4.2.2)`);
+}
+function isFloat16Exact(v) {
+  if (v === 0)
+    return true;
+  if (!Number.isFinite(v))
+    return true;
+  const a = Math.abs(v);
+  if (a > 65504)
+    return false;
+  if (a < 2 ** -24)
+    return false;
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, a);
+  const exponent = (view.getUint32(0) >>> 20 & 2047) - 1023;
+  const step = exponent >= -14 ? 2 ** (exponent - 10) : 2 ** -24;
+  return a % step === 0;
 }
-function decodeCborDeterministic(bytes) {
-  const r = new Reader(bytes);
+function describeKey(key) {
+  return typeof key === "string" ? JSON.stringify(key) : String(key);
+}
+function decodeCborDeterministic(bytes, options) {
+  const r = new Reader(bytes, options?.tags === "reject");
   const v = r.value(0);
   if (r.pos !== bytes.length) {
     throw new Error(`decodeCbor: ${bytes.length - r.pos} trailing byte(s) after item`);
   }
   return v;
 }
+function decodeCborDeterministicStrict(bytes) {
+  return decodeCborDeterministic(bytes, { tags: "reject" });
+}
 function decodeCborUnwrapCose(bytes) {
   const v = decodeCborDeterministic(bytes);
   if (v instanceof CborTag && (v.tag === 18 || v.tag === 98))
     return v.value;
   return v;
 }
+var INT64_MAX = 9223372036854775807n, INT64_MIN;
+var init_decode_cbor_deterministic = __esm(() => {
+  INT64_MIN = -9223372036854775808n;
+});
 
 // node_modules/@forestrie/encoding/dist/encode-sig-structure.js
 function encodeCborTstr(s) {
@@ -1241,7 +1385,12 @@ var init_encode_sig_structure = () => {};
 var init_encode_grant_request = () => {};
 
 // node_modules/@forestrie/encoding/dist/problem-details.js
-var init_problem_details = () => {};
+var init_problem_details = __esm(() => {
+  init_encode_cbor_deterministic();
+});
+
+// node_modules/@forestrie/encoding/dist/cose-labels.js
+var COSE_LABEL_ALG = 1, COSE_LABEL_VDP = 396, VDP_CONSISTENCY_PROOF_KEY = -2, COSE_LABEL_PEAK_RECEIPTS = -65931, COSE_LABEL_TREE_SIZE_2 = -65933;
 
 // node_modules/@forestrie/encoding/dist/uuid-bytes.js
 function uuidToBytes(uuid) {
@@ -1365,6 +1514,37 @@ function appendCborInt(out, v) {
   else
     out.push(58, n >>> 24 & 255, n >> 16 & 255, n >> 8 & 255, n & 255);
 }
+function appendCborUint64(out, v) {
+  let n;
+  if (typeof v === "bigint") {
+    n = v;
+  } else {
+    if (!Number.isInteger(v)) {
+      throw new Error(`COSE header uint value must be an integer, got ${v}`);
+    }
+    n = BigInt(v);
+  }
+  if (n < 0n) {
+    throw new Error(`COSE header uint value must not be negative: ${n}`);
+  }
+  if (n > MAX_UINT64) {
+    throw new Error(`COSE header uint value exceeds uint64 range: ${n}`);
+  }
+  if (n < 24n) {
+    out.push(Number(n));
+  } else if (n <= 0xffn) {
+    out.push(24, Number(n));
+  } else if (n <= 0xffffn) {
+    out.push(25, Number(n >> 8n & 0xffn), Number(n & 0xffn));
+  } else if (n <= 0xffffffffn) {
+    out.push(26, Number(n >> 24n & 0xffn), Number(n >> 16n & 0xffn), Number(n >> 8n & 0xffn), Number(n & 0xffn));
+  } else {
+    out.push(27);
+    for (let shift = 56n;shift >= 0n; shift -= 8n) {
+      out.push(Number(n >> shift & 0xffn));
+    }
+  }
+}
 function appendBoundedCborText(out, s) {
   const byteLength = new TextEncoder().encode(s).length;
   if (byteLength > 65535) {
@@ -1405,15 +1585,7 @@ function appendCwtClaimsMap(out, claims) {
     appendCborInt(bytes, k);
     return { k, bytes };
   });
-  encodedKeys.sort((a, b) => {
-    const n = Math.min(a.bytes.length, b.bytes.length);
-    for (let i = 0;i < n; i++) {
-      const d = a.bytes[i] - b.bytes[i];
-      if (d !== 0)
-        return d;
-    }
-    return a.bytes.length - b.bytes.length;
-  });
+  encodedKeys.sort((a, b) => compareCanonicalKeys(new Uint8Array(a.bytes), new Uint8Array(b.bytes)));
   out.push(160 | entries.size);
   for (const { k, bytes } of encodedKeys) {
     out.push(...bytes);
@@ -1424,7 +1596,8 @@ function encodeCoseProtectedMapBytes(kid, options) {
   const hasAlg = options?.alg !== undefined;
   const hasCty = options?.cty !== undefined;
   const hasClaims = options?.cwtClaims !== undefined;
-  const size = 1 + (hasAlg ? 1 : 0) + (hasCty ? 1 : 0) + (hasClaims ? 1 : 0);
+  const hasTreeSize2 = options?.treeSize2 !== undefined;
+  const size = 1 + (hasAlg ? 1 : 0) + (hasCty ? 1 : 0) + (hasClaims ? 1 : 0) + (hasTreeSize2 ? 1 : 0);
   const out = [160 | size];
   if (hasAlg) {
     appendCborUint(out, COSE_ALG);
@@ -1444,14 +1617,84 @@ function encodeCoseProtectedMapBytes(kid, options) {
     appendCborUint(out, COSE_CWT_CLAIMS);
     appendCwtClaimsMap(out, options.cwtClaims);
   }
+  if (hasTreeSize2) {
+    appendCborInt(out, COSE_LABEL_TREE_SIZE_2);
+    appendCborUint64(out, options.treeSize2);
+  }
   return new Uint8Array(out);
 }
 function encodeCoseProtectedWithKid(kid, options) {
   return encodeCborBstr(encodeCoseProtectedMapBytes(kid, options));
 }
-var COSE_ALG = 1, COSE_CTY = 3, COSE_KID = 4, COSE_CWT_CLAIMS = 15, CWT_ISS = 1, CWT_SUB = 2, CWT_IAT = 6;
+var COSE_ALG, COSE_CTY = 3, COSE_KID = 4, COSE_CWT_CLAIMS = 15, CWT_ISS = 1, CWT_SUB = 2, CWT_IAT = 6, MAX_UINT64;
 var init_encode_cose_protected = __esm(() => {
   init_grant_payload_canonical();
+  COSE_ALG = COSE_LABEL_ALG;
+  MAX_UINT64 = (1n << 64n) - 1n;
+});
+
+// node_modules/@forestrie/encoding/dist/cose-protected-tree-size.js
+function isAllowedHeaderValue(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return true;
+  if (typeof value === "string")
+    return true;
+  if (typeof value === "boolean" || value === null)
+    return true;
+  if (value instanceof Uint8Array)
+    return true;
+  if (value instanceof CborFloat)
+    return true;
+  return false;
+}
+function readProtectedTreeSize2(protectedMapBytes) {
+  const decoded = decodeCborDeterministicStrict(protectedMapBytes);
+  if (!(decoded instanceof Map)) {
+    throw new Error("readProtectedTreeSize2: protected header is not a CBOR map");
+  }
+  for (const [label, value] of decoded) {
+    if (typeof label !== "number" && typeof label !== "bigint") {
+      throw new Error(`readProtectedTreeSize2: protected header label is not an integer (got ${describeValue(label)})`);
+    }
+    if (!isAllowedHeaderValue(value)) {
+      throw new Error(`readProtectedTreeSize2: protected header label ${label} carries an excluded value type (got ${describeValue(value)})`);
+    }
+  }
+  if (!decoded.has(COSE_LABEL_TREE_SIZE_2))
+    return null;
+  const raw = decoded.get(COSE_LABEL_TREE_SIZE_2);
+  if (typeof raw === "bigint") {
+    if (raw < 0n) {
+      throw new Error(`readProtectedTreeSize2: tree-size-2 is not an unsigned integer (bigint ${raw})`);
+    }
+    return raw;
+  }
+  if (typeof raw === "number" && Number.isInteger(raw) && raw >= 0) {
+    return BigInt(raw);
+  }
+  throw new Error(`readProtectedTreeSize2: tree-size-2 is not an unsigned integer (got ${describeValue(raw)})`);
+}
+function describeValue(raw) {
+  if (raw === null)
+    return "null";
+  if (raw instanceof CborFloat)
+    return `float ${raw.value}`;
+  if (raw instanceof CborSimple)
+    return `simple value ${raw.value}`;
+  if (raw instanceof CborTag)
+    return `tag ${raw.tag}`;
+  if (typeof raw === "string")
+    return `text string ${JSON.stringify(raw)}`;
+  if (raw instanceof Uint8Array)
+    return "byte string";
+  if (raw instanceof Map)
+    return "map";
+  if (Array.isArray(raw))
+    return "array";
+  return typeof raw;
+}
+var init_cose_protected_tree_size = __esm(() => {
+  init_decode_cbor_deterministic();
 });
 
 // node_modules/@forestrie/encoding/dist/encode-cose-sign1-statement.js
@@ -1765,6 +2008,7 @@ function decodeCoseSign1(coseSign1Bytes) {
 var COSE_ALG_ES256 = -7, COSE_ALG_KS256 = -65799, COSE_ALG_ES256_WEBAUTHN = -65800, WEBAUTHN_ENVELOPE_LABEL, AUTH_FLAG_UP = 1, AUTH_FLAG_UV = 4, AUTH_FLAG_BE = 8, AUTH_FLAG_BS = 16, AUTH_DATA_MIN_BYTES = 37, P256_N, P256_HALF_N;
 var init_verify_cose_sign1 = __esm(() => {
   init_base64url();
+  init_decode_cbor_deterministic();
   init_encode_sig_structure();
   WEBAUTHN_ENVELOPE_LABEL = COSE_ALG_ES256_WEBAUTHN;
   P256_N = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
@@ -1773,6 +2017,7 @@ var init_verify_cose_sign1 = __esm(() => {
 
 // node_modules/@forestrie/encoding/dist/verify-delegate-key-voucher.js
 var init_verify_delegate_key_voucher = __esm(() => {
+  init_decode_cbor_deterministic();
   init_verify_cose_sign1();
 });
 
@@ -1812,7 +2057,9 @@ function encodeCoseSign1Raw(protectedBstr, unprotected, payloadBstr, signature)
   const tuple = [protectedBstr, unprotected, payloadBstr, signature];
   return encodeCborDeterministic(tuple);
 }
-var init_encode_cose_sign1_raw = () => {};
+var init_encode_cose_sign1_raw = __esm(() => {
+  init_encode_cbor_deterministic();
+});
 
 // node_modules/@forestrie/encoding/dist/merge-cose-sign1-unprotected.js
 function mergeUnprotectedIntoCoseSign1(coseSign1Bytes, additions) {
@@ -1832,14 +2079,20 @@ var init_merge_cose_sign1_unprotected = __esm(() => {
 });
 
 // node_modules/@forestrie/encoding/dist/grant-codec.js
-var init_grant_codec = () => {};
+var init_grant_codec = __esm(() => {
+  init_encode_cbor_deterministic();
+  init_decode_cbor_deterministic();
+});
 
 // node_modules/@forestrie/encoding/dist/index.js
 var init_dist3 = __esm(() => {
+  init_encode_cbor_deterministic();
+  init_decode_cbor_deterministic();
   init_encode_sig_structure();
   init_encode_grant_request();
   init_problem_details();
   init_encode_cose_protected();
+  init_cose_protected_tree_size();
   init_encode_cose_sign1_statement();
   init_sign_cose_sign1_statement();
   init_base64url();
@@ -24383,14 +24636,363 @@ var init_sign_statement3 = __esm(() => {
     run: defineCommandRunner(parseSignStatementOptions, runSignStatement)
   });
 });
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/encode-cbor-deterministic.js
+function concat5(chunks) {
+  let total = 0;
+  for (const c of chunks)
+    total += c.length;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+function encodeHead2(major, argument) {
+  const mt = major << 5;
+  const n = typeof argument === "bigint" ? argument : BigInt(argument);
+  if (n < 0n)
+    throw new Error("encodeHead: argument must be non-negative");
+  if (n < 24n)
+    return new Uint8Array([mt | Number(n)]);
+  if (n < 0x100n)
+    return new Uint8Array([mt | 24, Number(n)]);
+  if (n < 0x10000n) {
+    return new Uint8Array([mt | 25, Number(n >> 8n) & 255, Number(n) & 255]);
+  }
+  if (n < 0x100000000n) {
+    return new Uint8Array([
+      mt | 26,
+      Number(n >> 24n & 0xffn),
+      Number(n >> 16n & 0xffn),
+      Number(n >> 8n & 0xffn),
+      Number(n & 0xffn)
+    ]);
+  }
+  if (n < 0x10000000000000000n) {
+    const out = new Uint8Array(9);
+    out[0] = mt | 27;
+    let v = n;
+    for (let i = 8;i >= 1; i--) {
+      out[i] = Number(v & 0xffn);
+      v >>= 8n;
+    }
+    return out;
+  }
+  throw new Error("encodeHead: argument exceeds 64-bit range");
+}
+function encodeInteger2(v) {
+  if (typeof v === "number" && !Number.isInteger(v)) {
+    throw new Error(`encodeCborDeterministic: non-integer number ${v}`);
+  }
+  const n = typeof v === "bigint" ? v : BigInt(v);
+  if (n >= 0n)
+    return encodeHead2(MAJOR_UINT2, n);
+  return encodeHead2(MAJOR_NINT2, -1n - n);
+}
+function encodeCborDeterministic2(value) {
+  return encodeValue2(value, 0);
+}
+function encodeValue2(value, depth) {
+  if (depth > MAX_DEPTH2) {
+    throw new Error(`encodeCborDeterministic: nesting exceeds ${MAX_DEPTH2}`);
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return encodeInteger2(value);
+  }
+  if (typeof value === "boolean") {
+    return new Uint8Array([value ? 245 : 244]);
+  }
+  if (value === null) {
+    return new Uint8Array([246]);
+  }
+  if (value instanceof Uint8Array) {
+    return concat5([encodeHead2(MAJOR_BSTR2, value.length), value]);
+  }
+  if (value instanceof ArrayBuffer) {
+    const bytes = new Uint8Array(value);
+    return concat5([encodeHead2(MAJOR_BSTR2, bytes.length), bytes]);
+  }
+  if (typeof value === "string") {
+    const bytes = new TextEncoder().encode(value);
+    return concat5([encodeHead2(MAJOR_TSTR2, bytes.length), bytes]);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((v) => encodeValue2(v, depth + 1));
+    return concat5([encodeHead2(MAJOR_ARRAY2, value.length), ...items]);
+  }
+  if (value instanceof Map) {
+    return encodeMap2(value.entries(), depth);
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+    return encodeMap2(entries[Symbol.iterator](), depth);
+  }
+  throw new Error(`encodeCborDeterministic: unsupported value type ${typeof value}`);
+}
+function encodeMap2(entries, depth) {
+  const encoded = Array.from(entries).map(([k, v]) => {
+    if (typeof k !== "number" && typeof k !== "bigint" && typeof k !== "string") {
+      throw new Error(`encodeCborDeterministic: unsupported map key type ${typeof k}`);
+    }
+    return {
+      keyBytes: encodeValue2(k, depth + 1),
+      valueBytes: encodeValue2(v, depth + 1)
+    };
+  });
+  encoded.sort((a, b) => compareBytes(a.keyBytes, b.keyBytes));
+  for (let i = 1;i < encoded.length; i++) {
+    if (compareBytes(encoded[i - 1].keyBytes, encoded[i].keyBytes) === 0) {
+      throw new Error("encodeCborDeterministic: duplicate map key");
+    }
+  }
+  const chunks = [encodeHead2(MAJOR_MAP2, encoded.length)];
+  for (const e of encoded)
+    chunks.push(e.keyBytes, e.valueBytes);
+  return concat5(chunks);
+}
+function compareBytes(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0;i < n; i++) {
+    if (a[i] !== b[i])
+      return a[i] - b[i];
+  }
+  return a.length - b.length;
+}
+var MAJOR_UINT2 = 0, MAJOR_NINT2 = 1, MAJOR_BSTR2 = 2, MAJOR_TSTR2 = 3, MAJOR_ARRAY2 = 4, MAJOR_MAP2 = 5, MAX_DEPTH2 = 64;
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/decode-cbor-deterministic.js
+class CborTag2 {
+  tag;
+  value;
+  constructor(tag, value) {
+    this.tag = tag;
+    this.value = value;
+  }
+}
+
+class Reader2 {
+  buf;
+  pos = 0;
+  constructor(buf) {
+    this.buf = buf;
+  }
+  need(n) {
+    if (this.pos + n > this.buf.length) {
+      throw new Error("decodeCbor: unexpected end of input");
+    }
+  }
+  u8() {
+    this.need(1);
+    return this.buf[this.pos++];
+  }
+  bytes(n) {
+    this.need(n);
+    const out = this.buf.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return out.slice();
+  }
+  argument(ai) {
+    if (ai < 24)
+      return ai;
+    if (ai === 24)
+      return this.u8();
+    if (ai === 25) {
+      this.need(2);
+      const v = this.buf[this.pos] << 8 | this.buf[this.pos + 1];
+      this.pos += 2;
+      return v;
+    }
+    if (ai === 26) {
+      this.need(4);
+      const v = this.buf[this.pos] * 16777216 + (this.buf[this.pos + 1] << 16) + (this.buf[this.pos + 2] << 8) + this.buf[this.pos + 3];
+      this.pos += 4;
+      return v;
+    }
+    if (ai === 27) {
+      this.need(8);
+      let v = 0n;
+      for (let i = 0;i < 8; i++)
+        v = v << 8n | BigInt(this.buf[this.pos + i]);
+      this.pos += 8;
+      return v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : v;
+    }
+    throw new Error(`decodeCbor: unsupported additional info ${ai}`);
+  }
+  value(depth) {
+    if (depth > 64)
+      throw new Error("decodeCbor: nesting too deep");
+    const ib = this.u8();
+    const major = ib >> 5;
+    const ai = ib & 31;
+    if (ai === 31)
+      throw new Error("decodeCbor: indefinite lengths not allowed");
+    switch (major) {
+      case 0:
+        return this.argument(ai);
+      case 1: {
+        const n = this.argument(ai);
+        return typeof n === "bigint" ? -1n - n : -1 - n;
+      }
+      case 2: {
+        const len = Number(this.argument(ai));
+        return this.bytes(len);
+      }
+      case 3: {
+        const len = Number(this.argument(ai));
+        return new TextDecoder("utf-8", {
+          fatal: true,
+          ignoreBOM: false
+        }).decode(this.bytes(len));
+      }
+      case 4: {
+        const len = Number(this.argument(ai));
+        const out = new Array(len);
+        for (let i = 0;i < len; i++)
+          out[i] = this.value(depth + 1);
+        return out;
+      }
+      case 5: {
+        const len = Number(this.argument(ai));
+        const m = new Map;
+        for (let i = 0;i < len; i++) {
+          const k = this.value(depth + 1);
+          const v = this.value(depth + 1);
+          m.set(k, v);
+        }
+        return m;
+      }
+      case 6: {
+        const tag = Number(this.argument(ai));
+        return new CborTag2(tag, this.value(depth + 1));
+      }
+      case 7: {
+        switch (ai) {
+          case 20:
+            return false;
+          case 21:
+            return true;
+          case 22:
+            return null;
+          case 23:
+            return;
+          default:
+            throw new Error(`decodeCbor: unsupported simple/float value (ai=${ai})`);
+        }
+      }
+      default:
+        throw new Error(`decodeCbor: unsupported major type ${major}`);
+    }
+  }
+}
+function decodeCborDeterministic2(bytes) {
+  const r = new Reader2(bytes);
+  const v = r.value(0);
+  if (r.pos !== bytes.length) {
+    throw new Error(`decodeCbor: ${bytes.length - r.pos} trailing byte(s) after item`);
+  }
+  return v;
+}
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/encode-sig-structure.js
+var init_encode_sig_structure2 = () => {};
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/encode-grant-request.js
+var init_encode_grant_request2 = () => {};
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/problem-details.js
+var init_problem_details2 = () => {};
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/grant-payload-canonical.js
+var init_grant_payload_canonical2 = () => {};
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/encode-cose-protected.js
+var init_encode_cose_protected2 = __esm(() => {
+  init_grant_payload_canonical2();
+});
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/encode-cose-sign1-statement.js
+var init_encode_cose_sign1_statement2 = __esm(() => {
+  init_encode_cose_protected2();
+});
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/sign-cose-sign1-statement.js
+var init_sign_cose_sign1_statement2 = __esm(() => {
+  init_encode_cose_protected2();
+  init_encode_cose_sign1_statement2();
+  init_encode_sig_structure2();
+});
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/base64url.js
+var ALPHABET2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", REVERSE2;
+var init_base64url2 = __esm(() => {
+  REVERSE2 = (() => {
+    const out = new Int8Array(128).fill(-1);
+    for (let i = 0;i < ALPHABET2.length; i++) {
+      out[ALPHABET2.charCodeAt(i)] = i;
+    }
+    return out;
+  })();
+});
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/verify-cose-sign1.js
+var P256_N2, P256_HALF_N2;
+var init_verify_cose_sign12 = __esm(() => {
+  init_base64url2();
+  init_encode_sig_structure2();
+  P256_N2 = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
+  P256_HALF_N2 = P256_N2 >> 1n;
+});
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/verify-delegate-key-voucher.js
+var init_verify_delegate_key_voucher2 = __esm(() => {
+  init_verify_cose_sign12();
+});
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/cose-key-thumbprint.js
+var init_cose_key_thumbprint2 = __esm(() => {
+  init_base64url2();
+});
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/encode-cose-sign1-raw.js
+var init_encode_cose_sign1_raw2 = () => {};
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/merge-cose-sign1-unprotected.js
+var init_merge_cose_sign1_unprotected2 = __esm(() => {
+  init_verify_cose_sign12();
+  init_encode_cose_sign1_raw2();
+});
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/grant-codec.js
+var init_grant_codec2 = () => {};
+
+// node_modules/@forestrie/scrapi-client/node_modules/@forestrie/encoding/dist/index.js
+var init_dist5 = __esm(() => {
+  init_encode_sig_structure2();
+  init_encode_grant_request2();
+  init_problem_details2();
+  init_encode_cose_protected2();
+  init_encode_cose_sign1_statement2();
+  init_sign_cose_sign1_statement2();
+  init_base64url2();
+  init_verify_cose_sign12();
+  init_verify_delegate_key_voucher2();
+  init_cose_key_thumbprint2();
+  init_encode_cose_sign1_raw2();
+  init_merge_cose_sign1_unprotected2();
+  init_grant_codec2();
+  init_grant_payload_canonical2();
+});
 
 // node_modules/@forestrie/scrapi-client/dist/problem-details.js
-function decodeProblemDetailsBytes(body) {
+function decodeProblemDetailsBytes(body, contentType) {
   if (!body || body.length === 0) {
     return;
   }
+  if (contentType !== undefined && !contentType.toLowerCase().includes(PROBLEM_DETAILS_CONTENT_TYPE)) {
+    return;
+  }
   try {
-    const decoded = decodeCborDeterministic(body);
+    const decoded = decodeCborDeterministic2(body);
     if (!(decoded instanceof Map)) {
       return;
     }
@@ -24399,10 +25001,27 @@ function decodeProblemDetailsBytes(body) {
     return;
   }
 }
-var init_problem_details2 = __esm(() => {
-  init_dist3();
+var PROBLEM_DETAILS_CONTENT_TYPE = "application/problem+cbor";
+var init_problem_details3 = __esm(() => {
+  init_dist5();
 });
 
+// node_modules/@forestrie/scrapi-client/dist/raw-response.js
+async function toRawResponse(url, res) {
+  const headers = {};
+  res.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value;
+  });
+  const body = new Uint8Array(await res.arrayBuffer());
+  return {
+    url,
+    status: res.status,
+    headers,
+    body,
+    at: new Date().toISOString()
+  };
+}
+
 // node_modules/@forestrie/scrapi-client/dist/scrapi-url.js
 function toAbsoluteScrapiUrl(baseUrl, location) {
   if (location.startsWith("http"))
@@ -24417,7 +25036,7 @@ function forestrieGrantAuthorization(grantBase64) {
 }
 function interpretRegisterRedirect(view, baseUrl) {
   if (view.status !== 303) {
-    const problem = decodeProblemDetailsBytes(view.body);
+    const problem = decodeProblemDetailsBytes(view.body, view.contentType);
     const bodyText = view.body?.length ? new TextDecoder().decode(view.body) : "";
     const detail = problem?.detail ?? (bodyText.slice(0, 200) || "(empty body)");
     throw new ScrapiRegistrationError(`register: expected 303, got ${view.status} (${detail})`, view.status, detail, problem);
@@ -24427,7 +25046,7 @@ function interpretRegisterRedirect(view, baseUrl) {
   }
   return { statusUrl: toAbsoluteScrapiUrl(baseUrl, view.location) };
 }
-async function registerGrant(opts) {
+async function registerGrantRaw(opts) {
   const doFetch = opts.fetchImpl ?? fetch;
   const headers = {
     Authorization: forestrieGrantAuthorization(opts.grantBase64)
@@ -24435,21 +25054,27 @@ async function registerGrant(opts) {
   let body;
   if (opts.parentGrantBase64) {
     headers["Content-Type"] = "application/cbor";
-    body = encodeCborDeterministic({
+    body = encodeCborDeterministic2({
       parentGrant: base64ToBytes2(opts.parentGrantBase64)
     });
   }
-  const res = await doFetch(`${opts.baseUrl.replace(/\/$/, "")}/register/${opts.bootstrapLogId}/grants`, {
+  const url = `${opts.baseUrl.replace(/\/$/, "")}/register/${opts.bootstrapLogId}/grants`;
+  const res = await doFetch(url, {
     method: "POST",
     headers,
     body,
     redirect: "manual"
   });
-  return interpretRegisterRedirect(await toResponseView(res), opts.baseUrl);
+  return toRawResponse(url, res);
 }
-async function registerSignedStatement(opts) {
+async function registerGrant(opts) {
+  const raw = await registerGrantRaw(opts);
+  return interpretRegisterRedirect(rawToView(raw), opts.baseUrl);
+}
+async function registerSignedStatementRaw(opts) {
   const doFetch = opts.fetchImpl ?? fetch;
-  const res = await doFetch(`${opts.baseUrl.replace(/\/$/, "")}/register/${opts.bootstrapLogId}/entries`, {
+  const url = `${opts.baseUrl.replace(/\/$/, "")}/register/${opts.bootstrapLogId}/entries`;
+  const res = await doFetch(url, {
     method: "POST",
     headers: {
       Authorization: forestrieGrantAuthorization(opts.grantBase64),
@@ -24458,13 +25083,18 @@ async function registerSignedStatement(opts) {
     body: opts.statement,
     redirect: "manual"
   });
-  return interpretRegisterRedirect(await toResponseView(res), opts.baseUrl);
+  return toRawResponse(url, res);
 }
-async function toResponseView(res) {
+async function registerSignedStatement(opts) {
+  const raw = await registerSignedStatementRaw(opts);
+  return interpretRegisterRedirect(rawToView(raw), opts.baseUrl);
+}
+function rawToView(raw) {
   return {
-    status: res.status,
-    location: res.headers.get("location") ?? undefined,
-    body: new Uint8Array(await res.arrayBuffer())
+    status: raw.status,
+    location: raw.headers["location"],
+    body: raw.body,
+    contentType: raw.headers["content-type"]
   };
 }
 function base64ToBytes2(b64) {
@@ -24477,8 +25107,8 @@ function base64ToBytes2(b64) {
 }
 var COSE_SIGN1_CONTENT_TYPE = 'application/cose; cose-type="cose-sign1"', ScrapiRegistrationError;
 var init_register = __esm(() => {
-  init_dist3();
-  init_problem_details2();
+  init_dist5();
+  init_problem_details3();
   ScrapiRegistrationError = class ScrapiRegistrationError extends Error {
     httpStatus;
     problem;
@@ -24501,23 +25131,26 @@ function parseEntryIdFromReceiptLocation(location) {
   }
   return m[1].toLowerCase();
 }
-async function queryRegistrationOnce(opts) {
+async function queryRegistrationRaw(opts) {
   const doFetch = opts.fetchImpl ?? fetch;
   const res = await doFetch(opts.statusUrl, {
     headers: { Accept: opts.accept ?? "application/cbor" },
     redirect: "manual"
   });
-  if (res.status !== 303) {
-    const body = new Uint8Array(await res.arrayBuffer());
-    const problem = decodeProblemDetailsBytes(body);
+  return toRawResponse(opts.statusUrl, res);
+}
+async function queryRegistrationOnce(opts) {
+  const raw = await queryRegistrationRaw(opts);
+  if (raw.status !== 303) {
+    const problem = decodeProblemDetailsBytes(raw.body, raw.headers["content-type"]);
     return {
       status: "error",
-      httpStatus: res.status,
+      httpStatus: raw.status,
       problem,
-      detail: problem?.detail ?? `expected 303, got ${res.status}`
+      detail: problem?.detail ?? `expected 303, got ${raw.status}`
     };
   }
-  const location = res.headers.get("location");
+  const location = raw.headers["location"];
   if (!location) {
     return {
       status: "error",
@@ -24532,7 +25165,7 @@ async function queryRegistrationOnce(opts) {
       entryIdHex: parseEntryIdFromReceiptLocation(location)
     };
   }
-  const retryAfterSec = Number.parseInt(res.headers.get("retry-after") ?? "0", 10);
+  const retryAfterSec = Number.parseInt(raw.headers["retry-after"] ?? "0", 10);
   return {
     status: "pending",
     location,
@@ -24541,39 +25174,46 @@ async function queryRegistrationOnce(opts) {
 }
 var RECEIPT_LOCATION_RE;
 var init_query_registration = __esm(() => {
-  init_problem_details2();
+  init_problem_details3();
   RECEIPT_LOCATION_RE = /\/logs\/[^/]+\/[^/]+\/\d+\/entries\/[0-9a-f]{32}\/receipt(?:\?|$)/i;
 });
 
 // node_modules/@forestrie/scrapi-client/dist/resolve-receipt.js
-async function resolveReceiptOnce(opts) {
+async function resolveReceiptRaw(opts) {
   const doFetch = opts.fetchImpl ?? fetch;
   const res = await doFetch(opts.receiptUrl, {
-    headers: { Accept: opts.accept ?? "application/cbor" }
+    headers: { Accept: opts.accept ?? SCITT_RECEIPT_COSE_CONTENT_TYPE },
+    redirect: "manual"
   });
-  if (res.status === 200) {
-    const headers = {};
-    res.headers.forEach((v, k) => {
-      headers[k] = v;
-    });
+  return toRawResponse(opts.receiptUrl, res);
+}
+async function resolveReceiptOnce(opts) {
+  const raw = await resolveReceiptRaw(opts);
+  if (raw.status === 200) {
     return {
       status: "receipt",
-      httpStatus: res.status,
-      headers,
-      body: new Uint8Array(await res.arrayBuffer())
+      httpStatus: raw.status,
+      headers: raw.headers,
+      body: raw.body
     };
   }
-  if (res.status === 404) {
-    return { status: "pending" };
+  const problem = decodeProblemDetailsBytes(raw.body, raw.headers["content-type"]);
+  if (raw.status === 404) {
+    return { status: "not_found", problem };
   }
-  return { status: "error", httpStatus: res.status };
+  return { status: "error", httpStatus: raw.status, problem };
 }
+var SCITT_RECEIPT_COSE_CONTENT_TYPE = "application/scitt.receipt+cose";
+var init_resolve_receipt = __esm(() => {
+  init_problem_details3();
+});
 
 // node_modules/@forestrie/scrapi-client/dist/index.js
-var init_dist5 = __esm(() => {
+var init_dist6 = __esm(() => {
   init_register();
   init_query_registration();
-  init_problem_details2();
+  init_resolve_receipt();
+  init_problem_details3();
 });
 
 // src/lib/register-flow.ts
@@ -24698,7 +25338,7 @@ async function runRegisterFlow(params, deps = {}) {
 }
 var RegisterFlowError, defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var init_register_flow = __esm(() => {
-  init_dist5();
+  init_dist6();
   RegisterFlowError = class RegisterFlowError extends Error {
     stage;
     httpStatus;
@@ -25020,10 +25660,10 @@ function signGrantPayloadWithEs256Pem(grantPayloadBytes, es256PrivateKeyPem) {
   const out = [132];
   appendCborBstr(out, ES256_PROTECTED_HEADER);
   out.push(162);
-  out.push(...CBOR_KEY_FORESTRIE_GRANT_V0);
-  appendCborBstr(out, grantPayloadBytes);
   out.push(...CBOR_KEY_IDTIMESTAMP);
   appendCborBstr(out, new Uint8Array(IDTIMESTAMP_BYTES));
+  out.push(...CBOR_KEY_FORESTRIE_GRANT_V0);
+  appendCborBstr(out, grantPayloadBytes);
   appendCborBstr(out, payload);
   appendCborBstr(out, signature);
   return new Uint8Array(out);
@@ -25060,7 +25700,7 @@ var init_ks256_wallet_grant = __esm(() => {
 });
 
 // node_modules/@forestrie/grant-builder/dist/index.js
-var init_dist6 = __esm(() => {
+var init_dist7 = __esm(() => {
   init_dist3();
   init_dist3();
   init_dist3();
@@ -25143,7 +25783,7 @@ function buildGrantStatement(params) {
 var RegisterGrantBuildError, ES256_XY_BYTES = 64;
 var init_register_grant_build = __esm(() => {
   init_openssl_error_queue();
-  init_dist6();
+  init_dist7();
   init_dist3();
   RegisterGrantBuildError = class RegisterGrantBuildError extends Error {
     constructor(message) {
@@ -25208,7 +25848,7 @@ function buildCreateLogGrant(params) {
   };
 }
 var init_create_log_build = __esm(() => {
-  init_dist6();
+  init_dist7();
   init_dist3();
   init_register_grant_build();
 });
@@ -25229,7 +25869,7 @@ function completeGrantBase64(grantBase64, receiptBytes, entryIdHex) {
 }
 var ENTRY_ID_HEX_RE;
 var init_register_grant_complete = __esm(() => {
-  init_dist6();
+  init_dist7();
   init_dist3();
   ENTRY_ID_HEX_RE = /^[0-9a-f]{32}$/i;
 });
@@ -25396,7 +26036,7 @@ async function runRegisterGrantFlow(params, deps = {}) {
 }
 var defaultSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var init_register_grant_flow = __esm(() => {
-  init_dist5();
+  init_dist6();
   init_register_flow();
 });
 
@@ -26018,7 +26658,7 @@ var init_register_grant3 = __esm(() => {
 var DELEGATION_CONTENT_TYPE = "application/forestrie.delegation+cbor";
 
 // node_modules/@forestrie/delegation-cose/dist/payload-labels.js
-var COSE_HEADER_ALG = 1, COSE_HEADER_CTY = 3, COSE_HEADER_KID = 4, PAYLOAD_LOG_ID = 1, PAYLOAD_MMR_START = 3, PAYLOAD_MMR_END = 4, PAYLOAD_DELEGATED_KEY = 5, PAYLOAD_CONSTRAINTS = 6, PAYLOAD_SCHEMA_VER = 7, PAYLOAD_ISSUED_AT = 8, PAYLOAD_EXPIRES_AT = 9, PAYLOAD_DELEGATION_ID = 10, COSE_KTY = 1, COSE_CRV = -1, COSE_X = -2, COSE_Y = -3, COSE_KTY_EC2 = 2, COSE_CRV_P256 = 1, COSE_ALG_ES2562 = -7, KS256_EOA_SIG_BYTES = 65, ES256_SIG_BYTES = 64;
+var COSE_HEADER_ALG = 1, COSE_HEADER_CTY = 3, COSE_HEADER_KID = 4, PAYLOAD_LOG_ID = 1, PAYLOAD_MMR_START = 3, PAYLOAD_MMR_END = 4, PAYLOAD_DELEGATED_KEY = 5, PAYLOAD_CONSTRAINTS = 6, PAYLOAD_SCHEMA_VER = 7, PAYLOAD_ISSUED_AT = 8, PAYLOAD_EXPIRES_AT = 9, PAYLOAD_DELEGATION_ID = 10, COSE_KTY = 1, COSE_CRV = -1, COSE_X = -2, COSE_Y = -3, COSE_KTY_EC2 = 2, COSE_CRV_P256 = 1, COSE_ALG_ES2563 = -7, KS256_EOA_SIG_BYTES = 65, ES256_SIG_BYTES = 64;
 
 // node_modules/@forestrie/delegation-cose/dist/bytes-utils.js
 function bytesFromUnknown(value, label) {
@@ -26042,7 +26682,7 @@ var init_encode_int_map = __esm(() => {
 });
 
 // node_modules/@forestrie/delegation-cose/dist/encode-cbor-bstr.js
-function encodeCborBstr2(bytes) {
+function encodeCborBstr3(bytes) {
   const len = bytes.length;
   let header;
   if (len < 24) {
@@ -26083,7 +26723,7 @@ function encodeCborTstr2(s) {
   out.set(bytes, header.length);
   return out;
 }
-function concat5(...arrays) {
+function concat6(...arrays) {
   const total = arrays.reduce((sum, a) => sum + a.length, 0);
   const out = new Uint8Array(total);
   let off = 0;
@@ -26093,12 +26733,12 @@ function concat5(...arrays) {
   }
   return out;
 }
-function encodeSigStructure2(protectedHeaderMapBytes, externalAad, payloadBstr) {
+function encodeSigStructure3(protectedHeaderMapBytes, externalAad, payloadBstr) {
   const arrayHeader = new Uint8Array([132]);
   const label = encodeCborTstr2("Signature1");
-  return concat5(arrayHeader, label, encodeCborBstr2(protectedHeaderMapBytes), encodeCborBstr2(externalAad), encodeCborBstr2(payloadBstr));
+  return concat6(arrayHeader, label, encodeCborBstr3(protectedHeaderMapBytes), encodeCborBstr3(externalAad), encodeCborBstr3(payloadBstr));
 }
-var init_encode_sig_structure2 = () => {};
+var init_encode_sig_structure3 = () => {};
 
 // node_modules/@forestrie/delegation-cose/dist/webauthn-assertion.js
 var TYPE_MARKER, CHALLENGE_MARKER;
@@ -26156,11 +26796,11 @@ function buildOnchainDelegationToBeSignedWithAlg(input, alg) {
   return {
     protectedHeader,
     delegationKey,
-    sigStructureBytes: encodeSigStructure2(protectedHeader, new Uint8Array, payload)
+    sigStructureBytes: encodeSigStructure3(protectedHeader, new Uint8Array, payload)
   };
 }
 function buildOnchainDelegationToBeSignedEs256(input) {
-  return buildOnchainDelegationToBeSignedWithAlg(input, COSE_ALG_ES2562);
+  return buildOnchainDelegationToBeSignedWithAlg(input, COSE_ALG_ES2563);
 }
 function normalizeEs256SignatureLowS(signature) {
   if (signature.length !== ES256_SIG_BYTES) {
@@ -26170,10 +26810,10 @@ function normalizeEs256SignatureLowS(signature) {
   for (let i = 32;i < 64; i++) {
     s = s << 8n | BigInt(signature[i]);
   }
-  if (s <= P256_HALF_N2) {
+  if (s <= P256_HALF_N3) {
     return signature;
   }
-  s = P256_N2 - s;
+  s = P256_N3 - s;
   const out = new Uint8Array(64);
   out.set(signature.slice(0, 32), 0);
   for (let i = 0;i < 32; i++) {
@@ -26196,14 +26836,14 @@ async function signOnchainDelegationEs256(input, rootKeyPair) {
     algData: []
   };
 }
-var ONCHAIN_DELEGATION_DOMAIN = "forestrie.univocity.delegation.v1", P256_N2, P256_HALF_N2;
+var ONCHAIN_DELEGATION_DOMAIN = "forestrie.univocity.delegation.v1", P256_N3, P256_HALF_N3;
 var init_build_onchain_delegation = __esm(() => {
   init_dist3();
   init_encode_int_map();
-  init_encode_sig_structure2();
+  init_encode_sig_structure3();
   init_webauthn_assertion();
-  P256_N2 = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
-  P256_HALF_N2 = P256_N2 >> 1n;
+  P256_N3 = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
+  P256_HALF_N3 = P256_N3 >> 1n;
 });
 
 // node_modules/@forestrie/delegation-cose/dist/assemble-certificate.js
@@ -26318,11 +26958,11 @@ function buildDelegationPayloadBytes(input) {
   ]));
 }
 function buildDelegationToBeSigned(protectedBytes, payloadBytes) {
-  const sigStructureBytes = encodeSigStructure2(protectedBytes, new Uint8Array, payloadBytes);
+  const sigStructureBytes = encodeSigStructure3(protectedBytes, new Uint8Array, payloadBytes);
   return { protectedBytes, payloadBytes, sigStructureBytes };
 }
 var init_build_delegation_payload = __esm(() => {
-  init_encode_sig_structure2();
+  init_encode_sig_structure3();
   init_parse_delegated_cose_key();
   init_encode_int_map();
 });
@@ -26350,7 +26990,7 @@ function buildDelegationToBeSignedEs256(input, rootKid) {
     throw new Error("ES256 root kid must be 16 bytes");
   }
   const protectedBytes = encodeIntKeyCbor(new Map([
-    [COSE_HEADER_ALG, COSE_ALG_ES2562],
+    [COSE_HEADER_ALG, COSE_ALG_ES2563],
     [COSE_HEADER_CTY, DELEGATION_CONTENT_TYPE],
     [COSE_HEADER_KID, rootKid]
   ]));
@@ -26414,18 +27054,18 @@ var init_parse_certificate = __esm(() => {
 
 // node_modules/@forestrie/delegation-cose/dist/verify-es256.js
 var init_verify_es256 = __esm(() => {
-  init_encode_sig_structure2();
+  init_encode_sig_structure3();
   init_parse_delegated_cose_key();
 });
 
 // node_modules/@forestrie/delegation-cose/dist/verify-ks256.js
 var init_verify_ks256 = __esm(() => {
-  init_encode_sig_structure2();
+  init_encode_sig_structure3();
   init_parse_delegated_cose_key();
 });
 
 // node_modules/@forestrie/delegation-cose/dist/index.js
-var init_dist7 = __esm(() => {
+var init_dist8 = __esm(() => {
   init_build_onchain_delegation();
   init_webauthn_assertion();
   init_assemble_certificate();
@@ -26443,7 +27083,7 @@ var init_dist7 = __esm(() => {
 });
 
 // src/lib/delegate-voucher.ts
-function parseRegistrarKeyXY2(raw) {
+function parseRegistrarKeyXY3(raw) {
   if (raw.length !== REGISTRAR_KEY_XY_BYTES)
     return null;
   return {
@@ -26470,7 +27110,7 @@ function toBigIntOrNull(value) {
     return BigInt(value);
   return null;
 }
-async function verifyDelegateKeyVoucher2(voucherBytes, pinnedKey, expect) {
+async function verifyDelegateKeyVoucher3(voucherBytes, pinnedKey, expect) {
   const sigOk = await verifyCoseSign1WithParsedKey(voucherBytes, pinnedKey);
   if (!sigOk)
     return { ok: false, reason: "signature" };
@@ -26548,11 +27188,11 @@ async function runDelegateFlow(params, deps = {}) {
   if (standing.voucher === undefined || standing.sealerId === undefined || standing.epoch === undefined) {
     throw new DelegateFlowError("standing entry is missing its registrar voucher — refusing to bind");
   }
-  const pinned = parseRegistrarKeyXY2(b64ToBytes(params.knownSealerKey));
+  const pinned = parseRegistrarKeyXY3(b64ToBytes(params.knownSealerKey));
   if (pinned === null) {
     throw new DelegateFlowError("known-sealer-key must be base64 x||y (64 bytes)");
   }
-  const voucherResult = await verifyDelegateKeyVoucher2(b64ToBytes(standing.voucher), pinned, {
+  const voucherResult = await verifyDelegateKeyVoucher3(b64ToBytes(standing.voucher), pinned, {
     sealerId: standing.sealerId,
     epoch: standing.epoch,
     publicKey: b64ToBytes(standing.delegatedPublicKey)
@@ -26614,7 +27254,7 @@ async function runDelegateFlow(params, deps = {}) {
 }
 var MMR_START = 0, DelegateFlowError;
 var init_delegate_flow = __esm(() => {
-  init_dist7();
+  init_dist8();
   init_dist3();
   init_delegate_voucher();
   DelegateFlowError = class DelegateFlowError extends Error {
@@ -26848,7 +27488,7 @@ function buildEs256GenesisBody(opts) {
     [LABEL_GENESIS_VERSION, SCHEMA_V2],
     [LABEL_UNIVOCITY_ADDR, hexToBytes20(opts.univocityAddress)],
     [LABEL_CHAIN_ID, opts.chainId],
-    [LABEL_GENESIS_ALG, COSE_ALG_ES2563],
+    [LABEL_GENESIS_ALG, COSE_ALG_ES2564],
     [LABEL_BOOTSTRAP_KEY, opts.bootstrapKeyXy]
   ]));
 }
@@ -26859,7 +27499,7 @@ function genesisPostUrl(baseUrl, logId, webhookUrl) {
 function coordinatorSigningRouteUrl(coordinatorUrl, logId) {
   return `${coordinatorUrl.replace(/\/$/, "")}/api/logs/${logId}/signing-route`;
 }
-var LABEL_GENESIS_VERSION = -68009, LABEL_UNIVOCITY_ADDR = -68011, LABEL_CHAIN_ID = -68013, LABEL_GENESIS_ALG = -68014, LABEL_BOOTSTRAP_KEY = -68015, SCHEMA_V2 = 2, COSE_ALG_ES2563 = -7;
+var LABEL_GENESIS_VERSION = -68009, LABEL_UNIVOCITY_ADDR = -68011, LABEL_CHAIN_ID = -68013, LABEL_GENESIS_ALG = -68014, LABEL_BOOTSTRAP_KEY = -68015, SCHEMA_V2 = 2, COSE_ALG_ES2564 = -7;
 var init_onboard_genesis_body = __esm(() => {
   init_dist3();
 });
@@ -27111,14 +27751,14 @@ function assemble(prot, payload, signature) {
   return encodeCborDeterministic([prot, new Map, payload, signature]);
 }
 async function buildOnboardAttestationEs256(key, input) {
-  const prot = protectedBytes(COSE_ALG_ES2564);
+  const prot = protectedBytes(COSE_ALG_ES2565);
   const payload = claimsBytes(input);
   const sigStructure = encodeSigStructure(prot, new Uint8Array(0), payload);
   const signature = new Uint8Array(await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, key.privateKey, sigStructure));
   return assemble(prot, payload, signature);
 }
 async function buildOnboardAttestationKs256(privateKeyHex, input) {
-  const prot = protectedBytes(COSE_ALG_KS2563);
+  const prot = protectedBytes(COSE_ALG_KS2564);
   const payload = claimsBytes(input);
   const sigStructure = encodeSigStructure(prot, new Uint8Array(0), payload);
   const hash3 = keccak256(sigStructure);
@@ -27129,7 +27769,7 @@ async function buildOnboardAttestationKs256(privateKeyHex, input) {
   }
   return assemble(prot, payload, sig);
 }
-var ONBOARD_ATTESTATION_CONTENT_TYPE = "application/forestrie-onboard-attestation+cwt", COSE_ALG_ES2564 = -7, COSE_ALG_KS2563 = -65799, CLAIM_CHAIN_BINDING = -70000, DEFAULT_ATTESTATION_WINDOW_SEC = 3600;
+var ONBOARD_ATTESTATION_CONTENT_TYPE = "application/forestrie-onboard-attestation+cwt", COSE_ALG_ES2565 = -7, COSE_ALG_KS2564 = -65799, CLAIM_CHAIN_BINDING = -70000, DEFAULT_ATTESTATION_WINDOW_SEC = 3600;
 var init_onboard_attestation = __esm(() => {
   init_accounts();
   init__esm();
@@ -27578,7 +28218,7 @@ function parseReceipt(receiptBytes) {
     throw new Error("Receipt payload must be nil (detached) or 32-byte peak hash");
   }
   const unprotected = toHeaderMap(coseSign1[1]);
-  const proofsRaw = unprotected.get(VDS_COSE_RECEIPT_PROOFS_TAG);
+  const proofsRaw = unprotected.get(COSE_LABEL_VDP);
   if (!proofsRaw || typeof proofsRaw !== "object") {
     throw new Error("Receipt missing header 396 (inclusion proof)");
   }
@@ -27607,7 +28247,6 @@ function parseReceipt(receiptBytes) {
     coseSign1
   };
 }
-var VDS_COSE_RECEIPT_PROOFS_TAG = 396;
 var init_parse_receipt = __esm(() => {
   init_dist3();
 });
@@ -28066,6 +28705,9 @@ function peaksBitmap(mmrSize) {
   }
   return peakMap;
 }
+function mmrSizeForLeafCount(leaves) {
+  return 2n * leaves - BigInt(popcount(leaves));
+}
 function popcount(x) {
   let count = 0;
   let v = x;
@@ -28306,6 +28948,65 @@ function bitLength2(value) {
 }
 var init_math = () => {};
 
+// node_modules/@forestrie/merklelog/dist/mmr/errors.js
+var ConsistencyShapeError, IncompleteTreeSize, ConsistencyPeakCountMismatch, ConsistencyPathLengthMismatch, ConsistencyRootMismatch, SizeMustIncrease;
+var init_errors4 = __esm(() => {
+  ConsistencyShapeError = class ConsistencyShapeError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "ConsistencyShapeError";
+    }
+  };
+  IncompleteTreeSize = class IncompleteTreeSize extends ConsistencyShapeError {
+    size;
+    constructor(size5) {
+      super(`size ${size5} is not a complete MMR size`);
+      this.size = size5;
+      this.name = "IncompleteTreeSize";
+    }
+  };
+  ConsistencyPeakCountMismatch = class ConsistencyPeakCountMismatch extends ConsistencyShapeError {
+    expected;
+    actual;
+    constructor(expected, actual) {
+      super(`expected ${expected} entries for the origin peaks, got ${actual}`);
+      this.expected = expected;
+      this.actual = actual;
+      this.name = "ConsistencyPeakCountMismatch";
+    }
+  };
+  ConsistencyPathLengthMismatch = class ConsistencyPathLengthMismatch extends ConsistencyShapeError {
+    index;
+    expected;
+    actual;
+    constructor(index2, expected, actual) {
+      super(`path ${index2}: expected length ${expected}, got ${actual}`);
+      this.index = index2;
+      this.expected = expected;
+      this.actual = actual;
+      this.name = "ConsistencyPathLengthMismatch";
+    }
+  };
+  ConsistencyRootMismatch = class ConsistencyRootMismatch extends ConsistencyShapeError {
+    index;
+    constructor(index2) {
+      super(`path ${index2} proves a different root from the paths before it`);
+      this.index = index2;
+      this.name = "ConsistencyRootMismatch";
+    }
+  };
+  SizeMustIncrease = class SizeMustIncrease extends ConsistencyShapeError {
+    sizeFrom;
+    sizeTo;
+    constructor(sizeFrom, sizeTo) {
+      super(`sizeTo (${sizeTo}) must exceed sizeFrom (${sizeFrom})`);
+      this.sizeFrom = sizeFrom;
+      this.sizeTo = sizeTo;
+      this.name = "SizeMustIncrease";
+    }
+  };
+});
+
 // node_modules/@forestrie/merklelog/dist/utils/arrays.js
 function arraysEqual(a, b) {
   if (a.length !== b.length) {
@@ -28362,33 +29063,72 @@ async function verifyInclusion(hasher, leafHash, proof, root) {
   const calculatedRoot = await calculateRoot(hasher, leafHash, proof, leafIdx);
   return arraysEqual(calculatedRoot, root);
 }
-async function consistentRoots(hasher, ifrom, accumulatorFrom, paths) {
-  const fromPeaks = peakMMRIndexes(ifrom);
-  if (fromPeaks.length !== paths.length) {
-    throw new Error(`a proof for each accumulator peak is required: ${fromPeaks.length} peaks, ${paths.length} paths`);
+async function consistentRootsForSizes(hasher, sizeFrom, sizeTo, accumulatorFrom, paths) {
+  if (sizeTo <= sizeFrom) {
+    throw new SizeMustIncrease(sizeFrom, sizeTo);
   }
-  if (accumulatorFrom.length !== fromPeaks.length) {
-    throw new Error(`accumulator length mismatch: ${accumulatorFrom.length} values for ${fromPeaks.length} peaks`);
+  const to = peaksBitmap(sizeTo);
+  if (mmrSizeForLeafCount(to) !== sizeTo) {
+    throw new IncompleteTreeSize(sizeTo);
   }
+  const from15 = peaksBitmap(sizeFrom);
+  const n = popcount(from15);
+  if (accumulatorFrom.length !== n) {
+    throw new ConsistencyPeakCountMismatch(n, accumulatorFrom.length);
+  }
+  if (paths.length !== n) {
+    throw new ConsistencyPeakCountMismatch(n, paths.length);
+  }
+  const nto = popcount(to);
+  if (n === 0) {
+    return { roots: [], expectedRight: nto };
+  }
+  const split2 = bitLength(from15 ^ to) - 1;
   const roots = [];
-  for (let i = 0;i < accumulatorFrom.length; i++) {
-    const root = await calculateRoot(hasher, accumulatorFrom[i], { path: paths[i], mmrIndex: fromPeaks[i] }, fromPeaks[i]);
-    if (roots.length > 0 && arraysEqual(roots[roots.length - 1], root)) {
+  let offset = 0n;
+  let i = 0;
+  for (let h = bitLength(from15) - 1;h > split2; h--) {
+    if ((from15 >> BigInt(h) & 1n) === 0n)
       continue;
+    if (paths[i].length !== 0) {
+      throw new ConsistencyPathLengthMismatch(i, 0, paths[i].length);
     }
+    roots.push(accumulatorFrom[i]);
+    offset += (1n << BigInt(h + 1)) - 1n;
+    i += 1;
+  }
+  const above = roots.length;
+  let root;
+  for (let h = split2 - 1;h >= 0; h--) {
+    if ((from15 >> BigInt(h) & 1n) === 0n)
+      continue;
+    const expected = split2 - h;
+    if (paths[i].length !== expected) {
+      throw new ConsistencyPathLengthMismatch(i, expected, paths[i].length);
+    }
+    const subtree = (1n << BigInt(h + 1)) - 1n;
+    const peakMMRIndex = offset + subtree - 1n;
+    const proven = await calculateRoot(hasher, accumulatorFrom[i], { path: paths[i], mmrIndex: peakMMRIndex }, peakMMRIndex);
+    if (i === above) {
+      root = proven;
+    } else if (!arraysEqual(proven, root)) {
+      throw new ConsistencyRootMismatch(i);
+    }
+    offset += subtree;
+    i += 1;
+  }
+  if (n > above) {
     roots.push(root);
   }
-  return roots;
+  return { roots, expectedRight: nto - roots.length };
 }
-async function verifyConsistency(hasher, proof, peaksFrom, peaksTo) {
-  const proven = await consistentRoots(hasher, proof.mmrSizeA - 1n, peaksFrom, proof.paths);
-  let ito = 0;
-  for (const root of proven) {
-    if (ito < peaksTo.length && arraysEqual(peaksTo[ito], root)) {
-      continue;
-    }
-    ito += 1;
-    if (ito >= peaksTo.length || !arraysEqual(peaksTo[ito], root)) {
+async function verifyConsistency(hasher, sizeFrom, sizeTo, peaksFrom, paths, peaksTo) {
+  const { roots, expectedRight } = await consistentRootsForSizes(hasher, sizeFrom, sizeTo, peaksFrom, paths);
+  if (peaksTo.length !== roots.length + expectedRight) {
+    return { ok: false, accumulator: [] };
+  }
+  for (let i = 0;i < roots.length; i++) {
+    if (!arraysEqual(peaksTo[i], roots[i])) {
       return { ok: false, accumulator: [] };
     }
   }
@@ -28402,6 +29142,7 @@ function indexConsistencyProof(get, mmrIndexA, mmrIndexB) {
   return { mmrSizeA: mmrIndexA + 1n, mmrSizeB: mmrIndexB + 1n, paths };
 }
 var init_algorithms = __esm(() => {
+  init_errors4();
   init_math();
 });
 
@@ -28437,7 +29178,7 @@ async function createSyncHasher() {
 }
 
 // node_modules/@forestrie/merklelog/dist/index.js
-var init_dist8 = __esm(() => {
+var init_dist9 = __esm(() => {
   init_massif();
   init_types();
   init_types();
@@ -28445,6 +29186,75 @@ var init_dist8 = __esm(() => {
   init_leafindex();
   init_math();
   init_algorithms();
+  init_errors4();
+});
+
+// node_modules/@forestrie/receipt-verify/dist/decode-checkpoint-consistency-proof.js
+function asBigint(v, what) {
+  if (typeof v === "bigint") {
+    if (v < 0n) {
+      throw new Error(`${what}: must be an unsigned integer, got ${v}`);
+    }
+    return v;
+  }
+  if (typeof v === "number" && Number.isSafeInteger(v) && v >= 0) {
+    return BigInt(v);
+  }
+  throw new Error(`${what}: expected an unsigned integer`);
+}
+function asBytesArray(v, what) {
+  if (!Array.isArray(v) || v.some((e) => !(e instanceof Uint8Array) || e.length !== 32)) {
+    throw new Error(`${what}: expected an array of 32-byte strings`);
+  }
+  return v;
+}
+function decodeConsistencyProofFromUnprotected(unprotected) {
+  const vdpRaw = unprotected.get(COSE_LABEL_VDP);
+  if (vdpRaw === undefined || vdpRaw === null)
+    return null;
+  if (!(vdpRaw instanceof Map)) {
+    throw new Error("checkpoint carries no verifiable-proofs header (396)");
+  }
+  const proofBstr = vdpRaw.get(VDP_CONSISTENCY_PROOF_KEY);
+  if (proofBstr === undefined || proofBstr === null)
+    return null;
+  if (!(proofBstr instanceof Uint8Array)) {
+    throw new Error("checkpoint carries no consistency proof (vdp key -2)");
+  }
+  const proof = decodeCborDeterministic(proofBstr);
+  if (!Array.isArray(proof) || proof.length < 4) {
+    throw new Error("consistency proof must be [tree-size-1, tree-size-2, paths, right-peaks]");
+  }
+  const pathsRaw = proof[2];
+  if (!Array.isArray(pathsRaw)) {
+    throw new Error("consistency paths must be arrays of 32-byte strings");
+  }
+  for (let i = 0;i < pathsRaw.length; i++) {
+    const path2 = pathsRaw[i];
+    if (!Array.isArray(path2)) {
+      throw new Error(`consistency path ${i}: expected an array of 32-byte strings`);
+    }
+    for (let j = 0;j < path2.length; j++) {
+      const node = path2[j];
+      if (!(node instanceof Uint8Array) || node.length !== 32) {
+        throw new Error(`consistency path ${i} element ${j}: expected a 32-byte string`);
+      }
+    }
+  }
+  const treeSize1 = asBigint(proof[0], "tree-size-1");
+  const treeSize2 = asBigint(proof[1], "tree-size-2");
+  if (treeSize2 <= treeSize1) {
+    throw new Error(`consistency proof must grow the tree: tree-size-1 ${treeSize1} < tree-size-2 ${treeSize2}`);
+  }
+  return {
+    treeSize1,
+    treeSize2,
+    paths: pathsRaw,
+    rightPeaks: asBytesArray(proof[3], "right-peaks")
+  };
+}
+var init_decode_checkpoint_consistency_proof = __esm(() => {
+  init_dist3();
 });
 
 // node_modules/@forestrie/receipt-verify/dist/subtle-hasher.js
@@ -28474,7 +29284,7 @@ function parseCheckpoint(checkpointBytes) {
   const decoded = decodeCborDeterministic(checkpointBytes);
   const coseSign1 = requireCoseSign1(unwrapCoseSign1Tag(decoded));
   const unprotected = toHeaderMap(coseSign1[1]);
-  const peakReceiptsRaw = unprotected.get(SEAL_PEAK_RECEIPTS_LABEL);
+  const peakReceiptsRaw = unprotected.get(COSE_LABEL_PEAK_RECEIPTS);
   const peakReceipts = Array.isArray(peakReceiptsRaw) ? peakReceiptsRaw : null;
   const delegationCertRaw = unprotected.get(DELEGATION_CERT_LABEL);
   const delegationCert = delegationCertRaw instanceof Uint8Array && delegationCertRaw.length > 0 ? delegationCertRaw : null;
@@ -28482,7 +29292,7 @@ function parseCheckpoint(checkpointBytes) {
     coseSign1,
     unprotected,
     peakReceipts,
-    mmrSize: sealedSizeFromCheckpoint(unprotected),
+    mmrSize: sealedSizeFromCheckpoint(coseSign1, unprotected),
     delegationCert
   };
 }
@@ -28535,7 +29345,7 @@ function assembleReceiptFromProof(checkpoint, mmrIndex2, proof) {
   const verifiableProofs = new Map([
     [-1, [inclusionProofEntry]]
   ]);
-  receiptUnprotected.set(VDS_COSE_RECEIPT_PROOFS_TAG2, verifiableProofs);
+  receiptUnprotected.set(COSE_LABEL_VDP, verifiableProofs);
   const assembled = [
     receiptSign1[0],
     receiptUnprotected,
@@ -28564,89 +29374,66 @@ async function computeAccumulatorPeak(opts) {
 function cborBytes(value) {
   return encodeCborDeterministic(value);
 }
-function sealedSizeFromCheckpoint(unprotected) {
-  const vdpRaw = unprotected.get(VDS_COSE_RECEIPT_PROOFS_TAG2);
-  if (vdpRaw === undefined || vdpRaw === null)
+function sealedSizeFromCheckpoint(coseSign1, unprotected) {
+  let declared;
+  try {
+    declared = decodeConsistencyProofFromUnprotected(unprotected);
+  } catch {
     return null;
-  const vdp = toHeaderMap(vdpRaw);
-  const proofBstr = vdp.get(VDP_CONSISTENCY_PROOF_KEY);
-  if (!(proofBstr instanceof Uint8Array))
+  }
+  if (declared === null)
     return null;
-  const proof = decodeCborDeterministic(proofBstr);
-  if (!Array.isArray(proof) || proof.length < 2)
+  try {
+    return readProtectedTreeSize2(coseSign1[0]);
+  } catch {
     return null;
-  const treeSize2 = proof[1];
-  if (typeof treeSize2 === "bigint")
-    return treeSize2;
-  if (typeof treeSize2 === "number" && Number.isSafeInteger(treeSize2)) {
-    return BigInt(treeSize2);
   }
-  return null;
 }
-var VDS_COSE_RECEIPT_PROOFS_TAG2 = 396, SEAL_PEAK_RECEIPTS_LABEL = -65931, DELEGATION_CERT_LABEL = 1000, VDP_CONSISTENCY_PROOF_KEY = -2;
+var DELEGATION_CERT_LABEL = 1000;
 var init_build_receipt_offline = __esm(() => {
   init_dist3();
-  init_dist8();
+  init_dist9();
   init_parse_receipt();
+  init_decode_checkpoint_consistency_proof();
 });
 
 // node_modules/@forestrie/receipt-verify/dist/checkpoint-chain.js
-function asBigint(v, what) {
-  if (typeof v === "bigint") {
-    if (v < 0n)
-      throw new Error(`${what}: must be an unsigned integer, got ${v}`);
-    return v;
-  }
-  if (typeof v === "number" && Number.isSafeInteger(v) && v >= 0) {
-    return BigInt(v);
-  }
-  throw new Error(`${what}: expected an unsigned integer`);
-}
-function asBytesArray(v, what) {
-  if (!Array.isArray(v) || v.some((e) => !(e instanceof Uint8Array) || e.length !== 32)) {
-    throw new Error(`${what}: expected an array of 32-byte strings`);
-  }
-  return v;
-}
 function checkpointConsistencyProof(checkpointBytes) {
-  const { unprotected } = parseCheckpoint(checkpointBytes);
-  const vdpRaw = unprotected.get(VDS_COSE_RECEIPT_PROOFS_TAG3);
-  if (!(vdpRaw instanceof Map)) {
-    throw new Error("checkpoint carries no verifiable-proofs header (396)");
-  }
-  const proofBstr = vdpRaw.get(VDP_CONSISTENCY_PROOF_KEY2);
-  if (!(proofBstr instanceof Uint8Array)) {
+  const { coseSign1, unprotected } = parseCheckpoint(checkpointBytes);
+  const alg = extractAlgFromProtected(coseSign1[0]);
+  const signature = coseSign1[3];
+  if (alg === COSE_ALG_ES256 && signature.length === 64 && !isLowS(signature)) {
+    throw new CheckpointHighSSignatureError("checkpoint ES256 signature is not low-s canonical (s > n/2); rejected " + "to match the univocity contract's P-256 verifier and go-merklelog");
+  }
+  const declared = decodeConsistencyProofFromUnprotected(unprotected);
+  if (declared === null) {
     throw new Error("checkpoint carries no consistency proof (vdp key -2)");
   }
-  const proof = decodeCborDeterministic(proofBstr);
-  if (!Array.isArray(proof) || proof.length < 4) {
-    throw new Error("consistency proof must be [tree-size-1, tree-size-2, paths, right-peaks]");
-  }
-  const pathsRaw = proof[2];
-  if (!Array.isArray(pathsRaw) || pathsRaw.some((p) => !Array.isArray(p) || p.some((n) => !(n instanceof Uint8Array)))) {
-    throw new Error("consistency paths must be arrays of byte strings");
+  const signedTreeSize2 = readProtectedTreeSize2(coseSign1[0]);
+  if (signedTreeSize2 === null) {
+    throw new Error("checkpoint protected header carries no signed tree-size-2 (-65933)");
   }
-  const treeSize1 = asBigint(proof[0], "tree-size-1");
-  const treeSize2 = asBigint(proof[1], "tree-size-2");
-  if (treeSize2 <= treeSize1) {
-    throw new Error(`consistency proof must grow the tree: tree-size-1 ${treeSize1} < tree-size-2 ${treeSize2}`);
+  if (signedTreeSize2 !== declared.treeSize2) {
+    throw new CheckpointSignedSizeMismatchError(`signed tree-size-2 (-65933) ${signedTreeSize2} != declared consistency-proof tree-size-2 ${declared.treeSize2}`);
   }
   return {
-    treeSize1,
-    treeSize2,
-    paths: pathsRaw,
-    rightPeaks: asBytesArray(proof[3], "right-peaks")
+    treeSize1: declared.treeSize1,
+    treeSize2: declared.treeSize2,
+    signedTreeSize2,
+    paths: declared.paths,
+    rightPeaks: declared.rightPeaks
   };
 }
-async function computeCheckpointAccumulator(proof, accumulatorFrom) {
+async function computeCheckpointAccumulator(proof, accumulatorFrom, sizeFrom) {
+  if (proof.treeSize1 !== sizeFrom) {
+    throw new Error(`consistency proof base tree-size-1 ${proof.treeSize1} does not match the trusted size ${sizeFrom}`);
+  }
   const hasher = new SubtleHasher;
-  const proven = proof.treeSize1 === 0n ? [] : await consistentRoots(hasher, proof.treeSize1 - 1n, accumulatorFrom, proof.paths);
-  const accumulator = [...proven, ...proof.rightPeaks];
-  const expected = peakMMRIndexes(proof.treeSize2 - 1n).length;
-  if (accumulator.length !== expected) {
-    throw new Error(`computed accumulator has ${accumulator.length} peaks; size ${proof.treeSize2} requires ${expected}`);
+  const { roots, expectedRight } = await consistentRootsForSizes(hasher, sizeFrom, proof.treeSize2, accumulatorFrom, proof.paths);
+  if (proof.rightPeaks.length !== expectedRight) {
+    throw new Error(`checkpoint supplies ${proof.rightPeaks.length} right-peaks; size ${proof.treeSize2} requires ${expectedRight}`);
   }
-  return accumulator;
+  return [...roots, ...proof.rightPeaks];
 }
 function accumulatorPayload(accumulator) {
   const out = new Uint8Array(accumulator.reduce((s, p) => s + p.length, 0));
@@ -28668,56 +29455,66 @@ async function verifyCheckpointChain(opts) {
       links
     };
   }
-  let accumulator = opts.accumulatorFrom ?? [];
-  let expectedBase = null;
+  const trustedBase = opts.trustedBase;
+  if (trustedBase !== undefined) {
+    if (trustedBase.size < 0n || mmrSizeForLeafCount(peaksBitmap(trustedBase.size)) !== trustedBase.size) {
+      return {
+        ok: false,
+        reason: "proof_malformed",
+        at: 0,
+        detail: `trusted base size ${trustedBase.size} is not a complete MMR size`,
+        links
+      };
+    }
+    const basePeaks = trustedBase.size === 0n ? 0 : peakMMRIndexes(trustedBase.size - 1n).length;
+    if (trustedBase.accumulator.length !== basePeaks) {
+      return {
+        ok: false,
+        reason: "proof_malformed",
+        at: 0,
+        detail: `trusted base accumulator has ${trustedBase.accumulator.length} peaks; size ${trustedBase.size} has ${basePeaks}`,
+        links
+      };
+    }
+  }
+  let accumulator = trustedBase?.accumulator ?? [];
+  let expectedBase = trustedBase?.size ?? 0n;
   for (let i = 0;i < opts.checkpoints.length; i++) {
     const bytes = opts.checkpoints[i];
     let proof;
     try {
       proof = checkpointConsistencyProof(bytes);
     } catch (err) {
+      const reason = err instanceof CheckpointSignedSizeMismatchError ? "size_mismatch" : err instanceof CheckpointHighSSignatureError ? "signature_malleable" : "proof_malformed";
       return {
         ok: false,
-        reason: "proof_malformed",
+        reason,
         at: i,
         detail: err instanceof Error ? err.message : String(err),
         links
       };
     }
-    if (expectedBase === null) {
-      if (proof.treeSize1 !== 0n) {
-        const wanted = peakMMRIndexes(proof.treeSize1 - 1n).length;
-        if (opts.accumulatorFrom === undefined) {
-          return {
-            ok: false,
-            reason: "legacy_chain_break",
-            at: i,
-            detail: `first checkpoint base ${proof.treeSize1} != 0 and no trusted base accumulator was supplied`,
-            links
-          };
-        }
-        if (accumulator.length !== wanted) {
-          return {
-            ok: false,
-            reason: "proof_malformed",
-            at: i,
-            detail: `trusted base accumulator has ${accumulator.length} peaks; base size ${proof.treeSize1} requires ${wanted}`,
-            links
-          };
-        }
+    if (proof.treeSize1 !== expectedBase) {
+      if (i === 0) {
+        return {
+          ok: false,
+          reason: "size_mismatch",
+          at: i,
+          detail: trustedBase === undefined ? `first checkpoint declared tree-size-1 ${proof.treeSize1} != whole-log base size ${expectedBase} and no trusted base was supplied` : `first checkpoint declared tree-size-1 ${proof.treeSize1} != trusted base size ${expectedBase}`,
+          links
+        };
       }
-    } else if (proof.treeSize1 !== expectedBase) {
       return {
         ok: false,
-        reason: "legacy_chain_break",
+        reason: "size_mismatch",
         at: i,
-        detail: `checkpoint ${i} base ${proof.treeSize1} != previous sealed size ${expectedBase} — ` + "pre-FOR-410 drifted chain (permanent for this log); fall back to the event scan, tile extension, or a holder cache",
+        detail: `checkpoint ${i} declared tree-size-1 ${proof.treeSize1} != the previous link's tree-size-2 ${expectedBase} — ` + "the declared origin is unsigned, so the chain is treated as not continuous",
         links
       };
     }
     let computed;
     try {
-      computed = await computeCheckpointAccumulator(proof, accumulator);
+      computed = await computeCheckpointAccumulator(proof, accumulator, expectedBase);
     } catch (err) {
       return {
         ok: false,
@@ -28728,12 +29525,6 @@ async function verifyCheckpointChain(opts) {
       };
     }
     const signatureOk = await opts.verifySignature(bytes, accumulatorPayload(computed));
-    links.push({
-      treeSize1: proof.treeSize1,
-      treeSize2: proof.treeSize2,
-      accumulator: computed,
-      signatureOk
-    });
     if (!signatureOk) {
       return {
         ok: false,
@@ -28743,16 +29534,36 @@ async function verifyCheckpointChain(opts) {
         links
       };
     }
+    links.push({
+      treeSize1: proof.treeSize1,
+      treeSize2: proof.treeSize2,
+      signedTreeSize2: proof.signedTreeSize2,
+      accumulator: computed,
+      signatureOk
+    });
     accumulator = computed;
     expectedBase = proof.treeSize2;
   }
   return { ok: true, links, accumulator };
 }
-var VDS_COSE_RECEIPT_PROOFS_TAG3 = 396, VDP_CONSISTENCY_PROOF_KEY2 = -2;
+var CheckpointSignedSizeMismatchError, CheckpointHighSSignatureError;
 var init_checkpoint_chain = __esm(() => {
   init_dist3();
-  init_dist8();
+  init_dist9();
   init_build_receipt_offline();
+  init_decode_checkpoint_consistency_proof();
+  CheckpointSignedSizeMismatchError = class CheckpointSignedSizeMismatchError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "CheckpointSignedSizeMismatchError";
+    }
+  };
+  CheckpointHighSSignatureError = class CheckpointHighSSignatureError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "CheckpointHighSSignatureError";
+    }
+  };
 });
 
 // node_modules/@forestrie/receipt-verify/dist/freshen-receipt.js
@@ -28784,16 +29595,17 @@ async function freshenReceipt(input) {
     throw new Error("freshen requires at least one consistency proof linking the receipt's era to the checkpoint");
   }
   const firstLink = links[0];
-  const baseCount = input.accumulatorFrom?.length ?? 0;
-  if (firstLink.treeSize1 === 0n) {
-    if (baseCount !== 0) {
-      throw new Error("base-0 consistency chain must start from an empty accumulator seed");
-    }
-  } else {
-    const wanted = peakMMRIndexes(firstLink.treeSize1 - 1n).length;
-    if (baseCount !== wanted) {
-      throw new Error(`base accumulator has ${baseCount} peaks; first link size ${firstLink.treeSize1} requires ${wanted}`);
-    }
+  const baseSize = input.trustedBase?.size ?? 0n;
+  const baseAccumulator = input.trustedBase?.accumulator ?? [];
+  if (baseSize < 0n || mmrSizeForLeafCount(peaksBitmap(baseSize)) !== baseSize) {
+    throw new Error(`trusted base size ${baseSize} is not a complete MMR size`);
+  }
+  const basePeaks = baseSize === 0n ? 0 : peakMMRIndexes(baseSize - 1n).length;
+  if (baseAccumulator.length !== basePeaks) {
+    throw new Error(`base accumulator has ${baseAccumulator.length} peaks; trusted base size ${baseSize} has ${basePeaks}`);
+  }
+  if (firstLink.treeSize1 !== baseSize) {
+    throw new Error(`first consistency proof declares tree-size-1 ${firstLink.treeSize1}; the trusted base size is ${baseSize}`);
   }
   for (let i = 1;i < links.length; i++) {
     if (links[i].treeSize1 !== links[i - 1].treeSize2) {
@@ -28804,9 +29616,11 @@ async function freshenReceipt(input) {
   if (lastLink.treeSize2 !== sealedSize) {
     throw new Error(`consistency chain ends at size ${lastLink.treeSize2} but the checkpoint sealed size ${sealedSize}`);
   }
-  let accumulator = input.accumulatorFrom ?? [];
+  let accumulator = baseAccumulator;
+  let sizeFrom = baseSize;
   for (const p of links) {
-    accumulator = await computeCheckpointAccumulator(p, accumulator);
+    accumulator = await computeCheckpointAccumulator(p, accumulator, sizeFrom);
+    sizeFrom = p.treeSize2;
   }
   const aLatest = accumulator;
   const structuralPeaks = peakMMRIndexes(sealedSize - 1n).length;
@@ -28860,14 +29674,14 @@ async function freshenReceipt(input) {
   return { receipt, sealedSize };
 }
 var init_freshen_receipt = __esm(() => {
-  init_dist8();
+  init_dist9();
   init_build_receipt_offline();
   init_checkpoint_chain();
   init_parse_receipt();
 });
 
 // node_modules/@forestrie/receipt-verify/dist/cose-key.js
-var COSE_ALG_ES2565 = -7, COSE_KEY_KTY = 1, COSE_KEY_ALG = 3, COSE_EC2_CRV = -1, COSE_EC2_X = -2, COSE_EC2_Y = -3, COSE_KTY_EC22 = 2, COSE_CRV_P2562 = 1;
+var COSE_ALG_ES2566 = -7, COSE_KEY_KTY = 1, COSE_KEY_ALG = 3, COSE_EC2_CRV = -1, COSE_EC2_X = -2, COSE_EC2_Y = -3, COSE_KTY_EC22 = 2, COSE_CRV_P2562 = 1;
 
 // node_modules/@forestrie/receipt-verify/dist/forest-genesis-labels.js
 var FOREST_GENESIS_LABEL_GENESIS_VERSION = -68009, FOREST_GENESIS_LABEL_GENESIS_ALG = -68014, FOREST_GENESIS_LABEL_BOOTSTRAP_KEY = -68015, FOREST_GENESIS_SCHEMA_V2 = 2, FOREST_GENESIS_SCHEMA_V1 = 1, HEADER_IDTIMESTAMP2 = -65537, HEADER_FORESTRIE_GRANT_V02 = -65538;
@@ -28965,8 +29779,8 @@ var init_decode_trust_root_cbor = __esm(() => {
   init_dist3();
 });
 
-// node_modules/@forestrie/receipt-verify/dist/decode-trust-root-from-genesis.js
-function decodeBodyAsIntKeyMap(raw) {
+// node_modules/@forestrie/receipt-verify/dist/decode-genesis-cbor-map.js
+function decodeGenesisBodyAsIntKeyMap(raw) {
   if (raw instanceof Map)
     return raw;
   if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
@@ -28983,14 +29797,16 @@ function decodeBodyAsIntKeyMap(raw) {
 function asGenesisUint8Array(v) {
   return v instanceof Uint8Array ? v : null;
 }
-async function decodeTrustRootFromGenesis(genesisCbor) {
+
+// node_modules/@forestrie/receipt-verify/dist/decode-trust-root-from-genesis.js
+async function decodeTrustRootDetailsFromGenesis(genesisCbor) {
   let raw;
   try {
     raw = decodeCborDeterministic(genesisCbor);
   } catch {
     throw new Error("genesis CBOR decode failed");
   }
-  const m = decodeBodyAsIntKeyMap(raw);
+  const m = decodeGenesisBodyAsIntKeyMap(raw);
   if (!m)
     throw new Error("genesis document must be a CBOR map");
   const versionRaw = m.get(FOREST_GENESIS_LABEL_GENESIS_VERSION);
@@ -29000,7 +29816,11 @@ async function decodeTrustRootFromGenesis(genesisCbor) {
     if (bootstrapKey === null) {
       throw new Error("v2 genesis missing bootstrapKey");
     }
-    return decodeTrustRootCbor({ alg, key: bootstrapKey });
+    const key = await decodeTrustRootCbor({ alg, key: bootstrapKey });
+    return {
+      key,
+      bootstrapKeyXy: isParsedKs256RootKey(key) ? undefined : bootstrapKey
+    };
   }
   const kty = m.get(COSE_KEY_KTY);
   const crv = m.get(COSE_EC2_CRV);
@@ -29008,45 +29828,54 @@ async function decodeTrustRootFromGenesis(genesisCbor) {
   const y = asGenesisUint8Array(m.get(COSE_EC2_Y));
   if (kty === COSE_KTY_EC22 && crv === COSE_CRV_P2562 && x && y) {
     const alg = m.get(COSE_KEY_ALG);
-    if (alg !== undefined && alg !== COSE_ALG_ES2565) {
+    if (alg !== undefined && alg !== COSE_ALG_ES2566) {
       throw new Error("genesis EC2 key must be ES256");
     }
     const xy = new Uint8Array(64);
     xy.set(x, 0);
     xy.set(y, 32);
-    return decodeTrustRootCbor({ alg: COSE_ALG_ES2565, key: xy });
+    const key = await decodeTrustRootCbor({ alg: COSE_ALG_ES2566, key: xy });
+    return { key, bootstrapKeyXy: xy };
   }
   if (versionRaw === FOREST_GENESIS_SCHEMA_V1 || versionRaw === undefined) {
     throw new Error("unsupported or invalid genesis schema for trust root");
   }
   throw new Error("unsupported genesis document");
 }
+async function decodeTrustRootFromGenesis(genesisCbor) {
+  return (await decodeTrustRootDetailsFromGenesis(genesisCbor)).key;
+}
 var init_decode_trust_root_from_genesis = __esm(() => {
   init_dist3();
   init_decode_trust_root_cbor();
 });
 
+// node_modules/@forestrie/receipt-verify/dist/decode-chain-binding-from-genesis.js
+var init_decode_chain_binding_from_genesis = __esm(() => {
+  init_dist3();
+});
+
 // node_modules/@forestrie/receipt-verify/dist/uuid-bytes.js
-function toPaddedWire322(bytes) {
-  if (bytes.length === WIRE_LOG_ID_BYTES2)
+function toPaddedWire323(bytes) {
+  if (bytes.length === WIRE_LOG_ID_BYTES3)
     return bytes;
-  const out = new Uint8Array(WIRE_LOG_ID_BYTES2);
-  if (bytes.length >= WIRE_LOG_ID_BYTES2) {
-    out.set(bytes.slice(-WIRE_LOG_ID_BYTES2));
+  const out = new Uint8Array(WIRE_LOG_ID_BYTES3);
+  if (bytes.length >= WIRE_LOG_ID_BYTES3) {
+    out.set(bytes.slice(-WIRE_LOG_ID_BYTES3));
   } else {
-    out.set(bytes, WIRE_LOG_ID_BYTES2 - bytes.length);
+    out.set(bytes, WIRE_LOG_ID_BYTES3 - bytes.length);
   }
   return out;
 }
-function fromPaddedWire322(wire) {
+function fromPaddedWire323(wire) {
   if (wire.length === 16)
     return wire;
-  if (wire.length !== WIRE_LOG_ID_BYTES2) {
-    throw new Error(`Expected ${WIRE_LOG_ID_BYTES2}-byte wire log id`);
+  if (wire.length !== WIRE_LOG_ID_BYTES3) {
+    throw new Error(`Expected ${WIRE_LOG_ID_BYTES3}-byte wire log id`);
   }
   return wire.slice(-16);
 }
-var WIRE_LOG_ID_BYTES2 = 32;
+var WIRE_LOG_ID_BYTES3 = 32;
 
 // node_modules/@forestrie/receipt-verify/dist/grant-commitment.js
 function u64Be(n) {
@@ -29068,11 +29897,11 @@ function grantFlags32(flags) {
   return out;
 }
 function grantCommitmentPreimage(grant) {
-  const logId = toPaddedWire322(grant.logId);
+  const logId = toPaddedWire323(grant.logId);
   const flags32 = grantFlags32(grant.grant);
   const maxHeight = grant.maxHeight ?? 0;
   const minGrowth = grant.minGrowth ?? 0;
-  const ownerLogId = toPaddedWire322(grant.ownerLogId);
+  const ownerLogId = toPaddedWire323(grant.ownerLogId);
   const grantData = grantDataToBytes(grant.grantData ?? new Uint8Array(0));
   const total = logId.length + flags32.length + U64_BYTES * 2 + ownerLogId.length + grantData.length;
   const out = new Uint8Array(total);
@@ -29411,7 +30240,7 @@ async function verifyReceiptOfflineWithLeafInnerKeys(input) {
 }
 var init_verify_grant_receipt_offline = __esm(() => {
   init_dist3();
-  init_dist8();
+  init_dist9();
   init_grant_commitment();
   init_decode_trust_root_from_genesis();
   init_decode_trust_root_cbor();
@@ -29462,15 +30291,15 @@ function mapToGrant(m) {
     throw new Error("Grant payload: expected uint");
   };
   return {
-    logId: fromPaddedWire322(requireBstr(get(CBOR_KEY_LOG_ID))),
-    ownerLogId: fromPaddedWire322(requireBstr(get(CBOR_KEY_OWNER_LOG_ID))),
+    logId: fromPaddedWire323(requireBstr(get(CBOR_KEY_LOG_ID))),
+    ownerLogId: fromPaddedWire323(requireBstr(get(CBOR_KEY_OWNER_LOG_ID))),
     grant: leftPad(requireBstr(get(CBOR_KEY_GRANT_FLAGS)), WIRE_GRANT_FLAGS_BYTES2),
     maxHeight: requireUint(get(CBOR_KEY_MAX_HEIGHT)),
     minGrowth: requireUint(get(CBOR_KEY_MIN_GROWTH)),
     grantData: get(CBOR_KEY_GRANT_DATA) instanceof Uint8Array ? get(CBOR_KEY_GRANT_DATA) : new Uint8Array(0)
   };
 }
-function decodeGrantPayload2(bytes) {
+function decodeGrantPayload3(bytes) {
   if (!bytes?.length)
     throw new Error("Grant payload is empty");
   const raw = decodeCborDeterministic(bytes);
@@ -29480,7 +30309,7 @@ function decodeGrantPayload2(bytes) {
   return mapToGrant(raw);
 }
 var CBOR_KEY_LOG_ID = 1, CBOR_KEY_OWNER_LOG_ID = 2, CBOR_KEY_GRANT_FLAGS = 3, CBOR_KEY_MAX_HEIGHT = 4, CBOR_KEY_MIN_GROWTH = 5, CBOR_KEY_GRANT_DATA = 6, WIRE_GRANT_FLAGS_BYTES2 = 8;
-var init_grant_codec2 = __esm(() => {
+var init_grant_codec3 = __esm(() => {
   init_dist3();
   init_dist3();
 });
@@ -29529,7 +30358,7 @@ function decodeForestrieGrantCose(bytes) {
   const idtimestampVal = unprotected.get(HEADER_IDTIMESTAMP2);
   const idtimestampBe8 = idtimestampVal instanceof Uint8Array && idtimestampVal.length >= IDTIMESTAMP_BYTES3 ? idtimestampVal.length === IDTIMESTAMP_BYTES3 ? idtimestampVal : idtimestampVal.slice(-IDTIMESTAMP_BYTES3) : new Uint8Array(IDTIMESTAMP_BYTES3);
   return {
-    grant: decodeGrantPayload2(embedded),
+    grant: decodeGrantPayload3(embedded),
     idtimestampBe8: new Uint8Array(idtimestampBe8)
   };
 }
@@ -29537,7 +30366,7 @@ var IDTIMESTAMP_BYTES3 = 8;
 var init_decode_forestrie_grant_cose = __esm(() => {
   init_sha256();
   init_dist3();
-  init_grant_codec2();
+  init_grant_codec3();
 });
 
 // node_modules/@forestrie/receipt-verify/dist/attach-transparent-statement-receipt.js
@@ -29585,7 +30414,7 @@ async function findGrantLeafInMassif(massifBytes, grant) {
   return index2.findLeafByContentHash(inner);
 }
 var init_find_grant_leaf = __esm(() => {
-  init_dist8();
+  init_dist9();
   init_grant_commitment();
 });
 
@@ -29606,10 +30435,11 @@ function defaultTimeoutMs(options) {
 }
 async function ethRpc(rpcUrl, method, params, options = {}) {
   const timeoutMs = defaultTimeoutMs(options);
+  const fetch2 = options.fetchImpl ?? globalThis.fetch;
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const res = await fetch(rpcUrl, {
+    const res = await fetch2(rpcUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
@@ -29659,7 +30489,7 @@ var init_erc1271_verify_hooks = __esm(() => {
 });
 
 // node_modules/@forestrie/chain-rpc/dist/index.js
-var init_dist9 = __esm(() => {
+var init_dist10 = __esm(() => {
   init_substitute_env_templates();
   init_supported_chains_config();
   init_erc1271_verify_hooks();
@@ -29750,18 +30580,19 @@ function assertSnapshotBinding(snapshot, opts) {
 var LABEL_VERSION = 1, LABEL_CHAIN_ID2 = 2, LABEL_UNIVOCITY = 3, LABEL_LOG_ID = 4, LABEL_SIZE = 5, LABEL_ACCUMULATOR = 6, LABEL_BLOCK_NUMBER = 7, LABEL_BLOCK_HASH = 8, SNAPSHOT_VERSION = 1;
 var init_known_accumulator = __esm(() => {
   init_dist3();
-  init_dist8();
   init_dist9();
+  init_dist10();
   init_parse_receipt();
 });
 
 // node_modules/@forestrie/receipt-verify/dist/index.js
-var init_dist10 = __esm(() => {
+var init_dist11 = __esm(() => {
   init_parse_receipt();
   init_build_receipt_offline();
   init_freshen_receipt();
-  init_dist8();
+  init_dist9();
   init_decode_trust_root_from_genesis();
+  init_decode_chain_binding_from_genesis();
   init_verify_grant_receipt_offline();
   init_verify_grant_receipt_offline();
   init_verify_grant_receipt_offline();
@@ -29770,11 +30601,11 @@ var init_dist10 = __esm(() => {
   init_session_key_endorsement();
   init_verify_endorsed_leaf();
   init_decode_forestrie_grant_cose();
-  init_grant_codec2();
+  init_grant_codec3();
   init_attach_transparent_statement_receipt();
   init_grant_commitment();
   init_find_grant_leaf();
-  init_dist8();
+  init_dist9();
   init_checkpoint_chain();
   init_known_accumulator();
 });
@@ -29853,7 +30684,7 @@ async function deriveCheckpointReceipt(input) {
 }
 var CreateReceiptFailure;
 var init_create_receipt_derive = __esm(() => {
-  init_dist10();
+  init_dist11();
   CreateReceiptFailure = class CreateReceiptFailure extends Error {
     stage;
     reason;
@@ -29951,8 +30782,8 @@ function errorMessage3(err) {
 }
 var CompleteGrantFailure;
 var init_complete_grant_derive = __esm(() => {
-  init_dist10();
-  init_dist6();
+  init_dist11();
+  init_dist7();
   init_register_grant_complete();
   init_create_receipt_derive();
   CompleteGrantFailure = class CompleteGrantFailure extends Error {
@@ -30210,7 +31041,7 @@ function loadCreateReceiptArtifacts(options) {
   return { massifBytes, checkpointBytes, leaf };
 }
 var init_create_receipt_inputs = __esm(() => {
-  init_dist10();
+  init_dist11();
 });
 
 // src/lib/verify-inputs.ts
@@ -30246,7 +31077,7 @@ function decodeGrantBytes(bytes, entryId, source) {
       idtimestampBe8: entryId !== undefined ? entryIdHexToIdtimestampBe82(entryId) : decoded.idtimestampBe8
     };
   } catch {}
-  const grant = decodeGrantPayload2(bytes);
+  const grant = decodeGrantPayload3(bytes);
   if (entryId === undefined) {
     throw new Error(`${source} is a raw grant payload (no embedded idtimestamp) — pass --entry-id`);
   }
@@ -30270,7 +31101,7 @@ function loadVerifyArtifacts(options) {
   return { genesisCbor, receiptCbor, grant, idtimestampBe8 };
 }
 var init_verify_inputs = __esm(() => {
-  init_dist10();
+  init_dist11();
 });
 
 // src/lib/bytes.ts
@@ -30363,7 +31194,7 @@ function checkReceiptAnchoredToCheckpointChain(opts) {
 }
 var init_verify_checkpoint_chain = __esm(() => {
   init_dist3();
-  init_dist10();
+  init_dist11();
 });
 
 // src/lib/verify-known-accumulator.ts
@@ -30442,7 +31273,7 @@ async function checkReceiptAnchoredToSnapshot(opts) {
   };
 }
 var init_verify_known_accumulator = __esm(() => {
-  init_dist10();
+  init_dist11();
 });
 
 // src/lib/verify-anchored.ts
@@ -30604,10 +31435,10 @@ async function checkReceiptAnchored(opts) {
 }
 var LOG_STATE_SELECTOR = "0xeecac1b7";
 var init_verify_anchored = __esm(() => {
-  init_dist9();
-  init_dist3();
-  init_dist8();
   init_dist10();
+  init_dist3();
+  init_dist9();
+  init_dist11();
 });
 
 // src/lib/verify-eventscan.ts
@@ -30708,7 +31539,7 @@ function selectPublishedAtBlock(published, atBlock) {
 }
 var CHECKPOINT_PUBLISHED_TOPIC0 = "0x156942b408823cb05a16027962ea485fa7171d99779ee04094280b2569482426";
 var init_verify_eventscan = __esm(() => {
-  init_dist9();
+  init_dist10();
   init_verify_anchored();
 });
 
@@ -30751,7 +31582,8 @@ function decodePublishCheckpointCalldata(inputHex) {
       delegationKey: hexToBytes7(receipt.delegationProof.delegationKey),
       mmrStart: receipt.delegationProof.mmrStart,
       mmrEnd: receipt.delegationProof.mmrEnd,
-      signature: hexToBytes7(receipt.delegationProof.signature)
+      signature: hexToBytes7(receipt.delegationProof.signature),
+      algData: receipt.delegationProof.algData.map(hexToBytes7)
     }
   };
 }
@@ -30791,7 +31623,7 @@ var init_decode_checkpoint_calldata = __esm(() => {
   init__esm();
   PUBLISH_CHECKPOINT_ABI = parseAbi([
     "struct ConsistencyProof { uint64 treeSize1; uint64 treeSize2; bytes32[][] paths; bytes32[] rightPeaks; }",
-    "struct DelegationProof { bytes protectedHeader; bytes delegationKey; uint64 mmrStart; uint64 mmrEnd; bytes signature; }",
+    "struct DelegationProof { bytes protectedHeader; bytes delegationKey; uint64 mmrStart; uint64 mmrEnd; bytes signature; bytes[] algData; }",
     "struct ConsistencyReceipt { bytes protectedHeader; bytes signature; ConsistencyProof[] consistencyProofs; DelegationProof delegationProof; }",
     "struct InclusionProof { uint64 index; bytes32[] path; }",
     "struct PublishGrant { bytes32 logId; uint256 grant; uint256 request; uint64 maxHeight; uint64 minGrowth; bytes32 ownerLogId; bytes grantData; }",
@@ -30817,7 +31649,7 @@ async function foldProofChain(proofs, opts = {}) {
     if (p.treeSize1 !== expectedBase) {
       throw new Error(`checkpoint chain is not contiguous at link ${i}: base ${p.treeSize1} != expected ${expectedBase}`);
     }
-    accumulator = await computeCheckpointAccumulator(p, accumulator);
+    accumulator = await computeCheckpointAccumulator({ ...p, signedTreeSize2: p.treeSize2 }, accumulator, expectedBase);
     const link = {
       treeSize1: p.treeSize1,
       treeSize2: p.treeSize2,
@@ -30925,7 +31757,7 @@ async function calldataCheckpointChain(opts) {
   return links;
 }
 var init_checkpoint_provider = __esm(() => {
-  init_dist10();
+  init_dist11();
   init_verify_eventscan();
   init_decode_checkpoint_calldata();
 });
@@ -30943,7 +31775,10 @@ async function emitFreshened(opts) {
   const result = await freshenReceipt({
     oldReceiptBytes: opts.oldReceiptBytes,
     leafValue: opts.leafValue,
-    consistencyProofs: opts.links.map((l) => l.proof),
+    consistencyProofs: opts.links.map((l) => ({
+      ...l.proof,
+      signedTreeSize2: l.proof.treeSize2
+    })),
     latestCheckpointBytes: opts.latestCheckpointBytes
   });
   let knownAccumulatorMatched;
@@ -31007,7 +31842,7 @@ async function freshenFromCalldataChain(opts) {
   });
 }
 var init_resolve_receipt_freshen = __esm(() => {
-  init_dist10();
+  init_dist11();
   init_checkpoint_provider();
   init_verify_anchored();
 });
@@ -31095,7 +31930,7 @@ async function verifyChainAnchored(input, deps = defaultDeps) {
 }
 var ChainVerifyFailure, defaultDeps;
 var init_create_receipt_chain_verify = __esm(() => {
-  init_dist10();
+  init_dist11();
   init_verify_anchored();
   ChainVerifyFailure = class ChainVerifyFailure extends Error {
     stage;
@@ -31441,7 +32276,7 @@ var CHAIN_EXIT_CODE, ERROR_CODES2, CHAIN_OUTCOME_NARRATION;
 var init_create_receipt = __esm(() => {
   init_create_receipt_derive();
   init_create_receipt_inputs();
-  init_dist10();
+  init_dist11();
   init_verify_inputs();
   init_verify_checkpoint_chain();
   init_verify_known_accumulator();
@@ -31597,7 +32432,7 @@ __export(exports_resolve_receipt, {
   default: () => resolve_receipt_default
 });
 var resolve_receipt_default;
-var init_resolve_receipt = __esm(() => {
+var init_resolve_receipt2 = __esm(() => {
   init_commoncli2();
   init_create_receipt();
   init_create_receipt2();
@@ -31854,7 +32689,7 @@ var init_decode_receipt_cbor = __esm(() => {
 function headerLabelInfo(label) {
   return HEADER_LABELS.get(label) ?? null;
 }
-var COSE_SIGN1_TAG = 18, VERIFIABLE_PROOFS_LABEL = 396, VDS_LABEL = 395, CWT_CLAIMS_LABEL = 15, DELEGATION_CERT_LABEL3 = 1000, SEAL_PEAK_RECEIPTS_LABEL2 = -65931, PROOFS_INCLUSION_KEY = -1, PROOFS_CONSISTENCY_KEY = -2, HEADER_LABELS, ALG_NAMES, VDS_NAMES, CWT_CLAIM_NAMES, COSE_KEY_PARAM_NAMES, PROOF_KIND_NAMES;
+var COSE_SIGN1_TAG = 18, VERIFIABLE_PROOFS_LABEL = 396, VDS_LABEL = 395, CWT_CLAIMS_LABEL = 15, DELEGATION_CERT_LABEL3 = 1000, SEAL_PEAK_RECEIPTS_LABEL = -65931, TREE_SIZE_2_LABEL = -65933, PROOFS_INCLUSION_KEY = -1, PROOFS_CONSISTENCY_KEY = -2, HEADER_LABELS, ALG_NAMES, VDS_NAMES, CWT_CLAIM_NAMES, COSE_KEY_PARAM_NAMES, PROOF_KIND_NAMES;
 var init_decode_receipt_labels = __esm(() => {
   HEADER_LABELS = new Map([
     [1, { name: "alg" }],
@@ -31896,12 +32731,19 @@ var init_decode_receipt_labels = __esm(() => {
       }
     ],
     [
-      SEAL_PEAK_RECEIPTS_LABEL2,
+      SEAL_PEAK_RECEIPTS_LABEL,
       {
         name: "pre-signed peak receipts",
         note: "forestrie SealPeakReceiptsLabel (checkpoint header)"
       }
     ],
+    [
+      TREE_SIZE_2_LABEL,
+      {
+        name: "tree-size-2",
+        note: "forestrie: signed sealed size (ADR-0066 D1 as amended, checkpoint " + "protected header)"
+      }
+    ],
     [
       -66535,
       {
@@ -32101,7 +32943,7 @@ function decodeReceipt(receiptBytes) {
         byteLength: value.length,
         nestedCoseSign1: decodeCoseSign1(value) !== null
       };
-    } else if (label === SEAL_PEAK_RECEIPTS_LABEL2 && Array.isArray(value)) {
+    } else if (label === SEAL_PEAK_RECEIPTS_LABEL && Array.isArray(value)) {
       peakReceipts = { count: value.length };
     }
   }
@@ -32136,7 +32978,7 @@ function decodeReceipt(receiptBytes) {
 }
 var DecodeReceiptError, HEX;
 var init_decode_receipt_decode = __esm(() => {
-  init_dist10();
+  init_dist11();
   init_dist3();
   init_decode_receipt_cbor();
   init_decode_receipt_labels();
@@ -32227,7 +33069,7 @@ function unprotectedLines(entry, receipt, depth) {
       }
     ];
   }
-  if (entry.label === SEAL_PEAK_RECEIPTS_LABEL2 && receipt.unprotected.peakReceipts) {
+  if (entry.label === SEAL_PEAK_RECEIPTS_LABEL && receipt.unprotected.peakReceipts) {
     return [
       {
         depth,
@@ -32530,7 +33372,7 @@ async function buildConsistencyProofArtifact(opts) {
   const proof = indexConsistencyProof(opts.get, opts.fromSize - 1n, opts.toSize - 1n);
   const accumulatorTo = peakMMRIndexes(opts.toSize - 1n).map(opts.get);
   const hasher = await createSyncHasher();
-  const check = await verifyConsistency(hasher, proof, accumulatorFrom, accumulatorTo);
+  const check = await verifyConsistency(hasher, opts.fromSize, opts.toSize, accumulatorFrom, proof.paths, accumulatorTo);
   if (!check.ok) {
     throw new Error("self-verification failed: supplied massifs do not consistently cover the requested range");
   }
@@ -32573,11 +33415,7 @@ async function checkReceiptAnchoredViaConsistencyProof(opts) {
     };
   }
   const hasher = await createSyncHasher();
-  const check = await verifyConsistency(hasher, {
-    mmrSizeA: artifact.fromSize,
-    mmrSizeB: artifact.toSize,
-    paths: artifact.paths
-  }, artifact.accumulatorFrom, opts.trustedAccumulator);
+  const check = await verifyConsistency(hasher, artifact.fromSize, artifact.toSize, artifact.accumulatorFrom, artifact.paths, opts.trustedAccumulator);
   if (!check.ok) {
     return {
       anchored: false,
@@ -32590,7 +33428,7 @@ async function checkReceiptAnchoredViaConsistencyProof(opts) {
 var LABEL_VERSION2 = 1, LABEL_FROM_SIZE = 2, LABEL_TO_SIZE = 3, LABEL_ACCUMULATOR_FROM = 4, LABEL_PATHS = 5, ARTIFACT_VERSION = 1;
 var init_consistency_proof = __esm(() => {
   init_dist3();
-  init_dist8();
+  init_dist9();
 });
 
 // src/lib/verify-report.ts
@@ -33092,7 +33930,7 @@ async function runVerifyGrant(out, options) {
 }
 var VERIFY_ERROR_CODES;
 var init_verify = __esm(() => {
-  init_dist10();
+  init_dist11();
   init_verify_eventscan();
   init_verify_anchored();
   init_verify_checkpoint_chain();
@@ -33500,7 +34338,7 @@ async function runFetchAccumulator(out, options) {
 }
 var LOG_STATE_SELECTOR2 = "0xeecac1b7";
 var init_fetch_accumulator = __esm(() => {
-  init_dist9();
+  init_dist10();
   init_verify_anchored();
   init_verify_known_accumulator();
   init_verify_eventscan();
@@ -33721,7 +34559,7 @@ init_dist();
 // package.json
 var package_default = {
   name: "@forestrie/forestrie-cli",
-  version: "0.8.1",
+  version: "0.9.1",
   description: "forestrie — participant CLI for forestrie transparency logs (SCITT / COSE receipts)",
   keywords: [
     "forestrie",
@@ -33785,15 +34623,15 @@ var package_default = {
     prepack: "bun run build"
   },
   dependencies: {
-    "@forestrie/chain-rpc": "^0.2.0",
+    "@forestrie/chain-rpc": "^0.3.0",
     "@forestrie/cli-kit": "^0.1.1",
-    "@forestrie/delegation-cose": "^0.3.1",
+    "@forestrie/delegation-cose": "^0.3.2",
     "@forestrie/deploy-core": "^0.7.1",
-    "@forestrie/encoding": "^0.7.0",
-    "@forestrie/grant-builder": "^0.4.1",
-    "@forestrie/merklelog": "^0.3.0",
-    "@forestrie/receipt-verify": "^1.0.0",
-    "@forestrie/scrapi-client": "^0.1.4",
+    "@forestrie/encoding": "^0.8.0",
+    "@forestrie/grant-builder": "^0.5.0",
+    "@forestrie/merklelog": "^0.4.0",
+    "@forestrie/receipt-verify": "^2.0.0",
+    "@forestrie/scrapi-client": "^0.2.2",
     citty: "^0.2.2",
     viem: "^2.31.0"
   },
@@ -33822,8 +34660,8 @@ var command_default = defineForestrieCommand({
     "onboard-genesis": () => Promise.resolve().then(() => (init_onboard_genesis3(), exports_onboard_genesis)).then((m) => m.default),
     "onboard-request": () => Promise.resolve().then(() => (init_onboard_request3(), exports_onboard_request)).then((m) => m.default),
     "complete-grant": () => Promise.resolve().then(() => (init_complete_grant3(), exports_complete_grant)).then((m) => m.default),
-    "resolve-receipt": () => Promise.resolve().then(() => (init_resolve_receipt(), exports_resolve_receipt)).then((m) => m.default),
-    "create-receipt": () => Promise.resolve().then(() => (init_resolve_receipt(), exports_resolve_receipt)).then((m) => m.default),
+    "resolve-receipt": () => Promise.resolve().then(() => (init_resolve_receipt2(), exports_resolve_receipt)).then((m) => m.default),
+    "create-receipt": () => Promise.resolve().then(() => (init_resolve_receipt2(), exports_resolve_receipt)).then((m) => m.default),
     "decode-receipt": () => Promise.resolve().then(() => (init_decode_receipt3(), exports_decode_receipt)).then((m) => m.default),
     verify: () => Promise.resolve().then(() => (init_verify3(), exports_verify)).then((m) => m.default),
     "verify-grant": () => Promise.resolve().then(() => (init_verify_grant(), exports_verify_grant)).then((m) => m.default),