@forestrie/forestrie-cli 0.9.0 → 0.10.0

package/dist/cli.js

@@ -1841,6 +1841,38 @@ function extractAlgFromProtected(protectedBstr) {
   } catch {}
   return null;
 }
+function readProtectedAlg(protectedBstr) {
+  if (protectedBstr.length === 0) {
+    throw new ProtectedHeaderAlgError("protected header is empty, so it carries no alg (label 1)");
+  }
+  let decoded;
+  try {
+    decoded = decodeCborDeterministic(protectedBstr);
+  } catch (err) {
+    throw new ProtectedHeaderAlgError(`protected header is not decodable CBOR: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let alg;
+  if (decoded instanceof Map) {
+    alg = decoded.get(1);
+  } else if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded) && !ArrayBuffer.isView(decoded)) {
+    const obj = decoded;
+    alg = obj[1] ?? obj["1"];
+  } else {
+    throw new ProtectedHeaderAlgError("protected header is not a CBOR map, so it carries no alg (label 1)");
+  }
+  if (typeof alg === "number") {
+    if (!Number.isInteger(alg)) {
+      throw new ProtectedHeaderAlgError(`protected header alg (label 1) is not an integer (got ${alg})`);
+    }
+    return alg;
+  }
+  if (typeof alg === "bigint")
+    return Number(alg);
+  if (alg === undefined) {
+    throw new ProtectedHeaderAlgError("protected header carries no alg (label 1)");
+  }
+  throw new ProtectedHeaderAlgError("protected header alg (label 1) is not an integer");
+}
 async function webauthnEnvelopeSignedBytes(envelope, sigStructure, signature, opts) {
   if (!Array.isArray(envelope) || envelope.length !== 2) {
     logVerifyFailure(opts, "webauthn_envelope_malformed", {
@@ -2005,7 +2037,7 @@ function decodeCoseSign1(coseSign1Bytes) {
     signature: sig
   };
 }
-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 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, ProtectedHeaderAlgError;
 var init_verify_cose_sign1 = __esm(() => {
   init_base64url();
   init_decode_cbor_deterministic();
@@ -2013,6 +2045,12 @@ var init_verify_cose_sign1 = __esm(() => {
   WEBAUTHN_ENVELOPE_LABEL = COSE_ALG_ES256_WEBAUTHN;
   P256_N = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
   P256_HALF_N = P256_N >> 1n;
+  ProtectedHeaderAlgError = class ProtectedHeaderAlgError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "ProtectedHeaderAlgError";
+    }
+  };
 });
 
 // node_modules/@forestrie/encoding/dist/verify-delegate-key-voucher.js
@@ -25591,6 +25629,146 @@ var init_register4 = __esm(() => {
     run: defineCommandRunner(parseRegisterOptions, runRegister)
   });
 });
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/encode-cbor-deterministic.js
+var init_encode_cbor_deterministic2 = () => {};
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/decode-cbor-deterministic.js
+var INT64_MIN2;
+var init_decode_cbor_deterministic2 = __esm(() => {
+  INT64_MIN2 = -9223372036854775808n;
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/encode-sig-structure.js
+var init_encode_sig_structure3 = () => {};
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/encode-grant-request.js
+var init_encode_grant_request3 = () => {};
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/problem-details.js
+var init_problem_details4 = __esm(() => {
+  init_encode_cbor_deterministic2();
+});
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/grant-payload-canonical.js
+function appendCborBstr3(out, bytes) {
+  const n = bytes.length;
+  if (n < 24)
+    out.push(64 | n);
+  else if (n <= 255)
+    out.push(88, n);
+  else if (n <= 65535)
+    out.push(89, n >> 8 & 255, n & 255);
+  else
+    out.push(90, n >>> 24 & 255, n >> 16 & 255, n >> 8 & 255, n & 255);
+  for (let i = 0;i < n; i++)
+    out.push(bytes[i]);
+}
+function appendCborText3(out, s) {
+  const bytes = new TextEncoder().encode(s);
+  const n = bytes.length;
+  if (n < 24)
+    out.push(96 | n);
+  else if (n <= 255)
+    out.push(120, n);
+  else
+    out.push(121, n >> 8 & 255, n & 255);
+  for (let i = 0;i < n; i++)
+    out.push(bytes[i]);
+}
+var init_grant_payload_canonical3 = () => {};
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/encode-cose-protected.js
+var MAX_UINT642;
+var init_encode_cose_protected3 = __esm(() => {
+  init_grant_payload_canonical3();
+  MAX_UINT642 = (1n << 64n) - 1n;
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/cose-protected-tree-size.js
+var init_cose_protected_tree_size2 = __esm(() => {
+  init_decode_cbor_deterministic2();
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/encode-cose-sign1-statement.js
+var init_encode_cose_sign1_statement3 = __esm(() => {
+  init_encode_cose_protected3();
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/sign-cose-sign1-statement.js
+var init_sign_cose_sign1_statement3 = __esm(() => {
+  init_encode_cose_protected3();
+  init_encode_cose_sign1_statement3();
+  init_encode_sig_structure3();
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/base64url.js
+var ALPHABET3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", REVERSE3;
+var init_base64url3 = __esm(() => {
+  REVERSE3 = (() => {
+    const out = new Int8Array(128).fill(-1);
+    for (let i = 0;i < ALPHABET3.length; i++) {
+      out[ALPHABET3.charCodeAt(i)] = i;
+    }
+    return out;
+  })();
+});
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/verify-cose-sign1.js
+var P256_N3, P256_HALF_N3;
+var init_verify_cose_sign13 = __esm(() => {
+  init_base64url3();
+  init_decode_cbor_deterministic2();
+  init_encode_sig_structure3();
+  P256_N3 = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
+  P256_HALF_N3 = P256_N3 >> 1n;
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/verify-delegate-key-voucher.js
+var init_verify_delegate_key_voucher3 = __esm(() => {
+  init_decode_cbor_deterministic2();
+  init_verify_cose_sign13();
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/cose-key-thumbprint.js
+var init_cose_key_thumbprint3 = __esm(() => {
+  init_base64url3();
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/encode-cose-sign1-raw.js
+var init_encode_cose_sign1_raw3 = __esm(() => {
+  init_encode_cbor_deterministic2();
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/merge-cose-sign1-unprotected.js
+var init_merge_cose_sign1_unprotected3 = __esm(() => {
+  init_verify_cose_sign13();
+  init_encode_cose_sign1_raw3();
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/grant-codec.js
+var init_grant_codec3 = __esm(() => {
+  init_encode_cbor_deterministic2();
+  init_decode_cbor_deterministic2();
+});
+
+// node_modules/@forestrie/grant-builder/node_modules/@forestrie/encoding/dist/index.js
+var init_dist7 = __esm(() => {
+  init_encode_cbor_deterministic2();
+  init_decode_cbor_deterministic2();
+  init_encode_sig_structure3();
+  init_encode_grant_request3();
+  init_problem_details4();
+  init_encode_cose_protected3();
+  init_cose_protected_tree_size2();
+  init_encode_cose_sign1_statement3();
+  init_sign_cose_sign1_statement3();
+  init_base64url3();
+  init_verify_cose_sign13();
+  init_verify_delegate_key_voucher3();
+  init_cose_key_thumbprint3();
+  init_encode_cose_sign1_raw3();
+  init_merge_cose_sign1_unprotected3();
+  init_grant_codec3();
+  init_grant_payload_canonical3();
+});
 
 // node_modules/@forestrie/grant-builder/dist/grant-flags.js
 function authLogBootstrapShapedFlags() {
@@ -25633,7 +25811,7 @@ function bytesToForestrieGrantBase64(bytes) {
 
 // node_modules/@forestrie/grant-builder/dist/transparent-statement-assert.js
 var init_transparent_statement_assert = __esm(() => {
-  init_dist3();
+  init_dist7();
 });
 
 // node_modules/@forestrie/grant-builder/dist/es256-pem-grant.js
@@ -25644,10 +25822,10 @@ function sha2564(bytes) {
 function signGrantPayloadWithEs256Pem(grantPayloadBytes, es256PrivateKeyPem) {
   const payload = sha2564(grantPayloadBytes);
   const sig = [132];
-  appendCborText(sig, "Signature1");
-  appendCborBstr(sig, ES256_PROTECTED_HEADER);
-  appendCborBstr(sig, new Uint8Array(0));
-  appendCborBstr(sig, payload);
+  appendCborText3(sig, "Signature1");
+  appendCborBstr3(sig, ES256_PROTECTED_HEADER);
+  appendCborBstr3(sig, new Uint8Array(0));
+  appendCborBstr3(sig, payload);
   const sigStructure = new Uint8Array(sig);
   const key = createPrivateKey2({ key: es256PrivateKeyPem, format: "pem" });
   const signature = new Uint8Array(nodeSign("sha256", Buffer.from(sigStructure), {
@@ -25658,19 +25836,19 @@ function signGrantPayloadWithEs256Pem(grantPayloadBytes, es256PrivateKeyPem) {
     throw new Error(`ES256 signature must be ${ES256_RAW_SIG_BYTES}-byte raw r‖s; got ${signature.length}`);
   }
   const out = [132];
-  appendCborBstr(out, ES256_PROTECTED_HEADER);
+  appendCborBstr3(out, ES256_PROTECTED_HEADER);
   out.push(162);
   out.push(...CBOR_KEY_IDTIMESTAMP);
-  appendCborBstr(out, new Uint8Array(IDTIMESTAMP_BYTES));
+  appendCborBstr3(out, new Uint8Array(IDTIMESTAMP_BYTES));
   out.push(...CBOR_KEY_FORESTRIE_GRANT_V0);
-  appendCborBstr(out, grantPayloadBytes);
-  appendCborBstr(out, payload);
-  appendCborBstr(out, signature);
+  appendCborBstr3(out, grantPayloadBytes);
+  appendCborBstr3(out, payload);
+  appendCborBstr3(out, signature);
   return new Uint8Array(out);
 }
 var ES256_PROTECTED_HEADER, IDTIMESTAMP_BYTES = 8, ES256_RAW_SIG_BYTES = 64, CBOR_KEY_FORESTRIE_GRANT_V0, CBOR_KEY_IDTIMESTAMP;
 var init_es256_pem_grant = __esm(() => {
-  init_dist3();
+  init_dist7();
   ES256_PROTECTED_HEADER = new Uint8Array([161, 1, 38]);
   CBOR_KEY_FORESTRIE_GRANT_V0 = [58, 0, 1, 0, 1];
   CBOR_KEY_IDTIMESTAMP = [58, 0, 1, 0, 0];
@@ -25678,16 +25856,16 @@ var init_es256_pem_grant = __esm(() => {
 
 // node_modules/@forestrie/grant-builder/dist/mint-es256-root-grant.js
 var init_mint_es256_root_grant = __esm(() => {
-  init_dist3();
-  init_dist3();
+  init_dist7();
+  init_dist7();
   init_es256_pem_grant();
 });
 
 // node_modules/@forestrie/grant-builder/dist/ks256-wallet-grant.js
 var KS256_PROTECTED_HEADER;
 var init_ks256_wallet_grant = __esm(() => {
-  init_dist3();
-  init_dist3();
+  init_dist7();
+  init_dist7();
   KS256_PROTECTED_HEADER = new Uint8Array([
     161,
     1,
@@ -25700,11 +25878,11 @@ var init_ks256_wallet_grant = __esm(() => {
 });
 
 // node_modules/@forestrie/grant-builder/dist/index.js
-var init_dist7 = __esm(() => {
-  init_dist3();
-  init_dist3();
-  init_dist3();
-  init_dist3();
+var init_dist8 = __esm(() => {
+  init_dist7();
+  init_dist7();
+  init_dist7();
+  init_dist7();
   init_transparent_statement_assert();
   init_es256_pem_grant();
   init_mint_es256_root_grant();
@@ -25783,7 +25961,7 @@ function buildGrantStatement(params) {
 var RegisterGrantBuildError, ES256_XY_BYTES = 64;
 var init_register_grant_build = __esm(() => {
   init_openssl_error_queue();
-  init_dist7();
+  init_dist8();
   init_dist3();
   RegisterGrantBuildError = class RegisterGrantBuildError extends Error {
     constructor(message) {
@@ -25848,7 +26026,7 @@ function buildCreateLogGrant(params) {
   };
 }
 var init_create_log_build = __esm(() => {
-  init_dist7();
+  init_dist8();
   init_dist3();
   init_register_grant_build();
 });
@@ -25869,11 +26047,45 @@ function completeGrantBase64(grantBase64, receiptBytes, entryIdHex) {
 }
 var ENTRY_ID_HEX_RE;
 var init_register_grant_complete = __esm(() => {
-  init_dist7();
+  init_dist8();
   init_dist3();
   ENTRY_ID_HEX_RE = /^[0-9a-f]{32}$/i;
 });
 
+// src/lib/http-problem.ts
+function describe(problem) {
+  const { title, detail } = problem;
+  if (detail && title)
+    return `${title}: ${detail}`;
+  return detail ?? title;
+}
+async function responseProblemDetail(response, max = MAX_PROBLEM_DETAIL) {
+  const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
+  let text = "";
+  try {
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (bytes.length === 0)
+      return "";
+    if (contentType.includes("cbor")) {
+      const problem = decodeProblemDetailsBytes(bytes);
+      const described = problem && describe(problem);
+      if (described)
+        return described.slice(0, max);
+    }
+    text = new TextDecoder().decode(bytes);
+    if (contentType.includes("json")) {
+      const described = describe(JSON.parse(text));
+      if (described)
+        return described.slice(0, max);
+    }
+  } catch {}
+  return text.slice(0, max);
+}
+var MAX_PROBLEM_DETAIL = 512;
+var init_http_problem = __esm(() => {
+  init_dist6();
+});
+
 // src/lib/create-log-prepare.ts
 async function prepareChildLog(params, deps = {}) {
   const fetchImpl = deps.fetchImpl ?? fetch;
@@ -25883,7 +26095,7 @@ async function prepareChildLog(params, deps = {}) {
     headers: { Authorization: `Forestrie-Grant ${params.grantBase64}` }
   });
   if (!res.ok) {
-    const preview = (await res.text().catch(() => "")).slice(0, 300);
+    const preview = await responseProblemDetail(res, 300);
     throw new PrepareLogError(`prepare failed: HTTP ${res.status} ${preview}`, res.status);
   }
   let publicRoot = "ok";
@@ -25903,6 +26115,7 @@ async function prepareChildLog(params, deps = {}) {
 }
 var PrepareLogError;
 var init_create_log_prepare = __esm(() => {
+  init_http_problem();
   PrepareLogError = class PrepareLogError extends Error {
     httpStatus;
     constructor(message, httpStatus) {
@@ -26658,7 +26871,513 @@ 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_ES2563 = -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_ES2564 = -7, KS256_EOA_SIG_BYTES = 65, ES256_SIG_BYTES = 64;
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/canonical-key-order.js
+function compareCanonicalKeys3(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/delegation-cose/node_modules/@forestrie/encoding/dist/encode-cbor-deterministic.js
+function concat6(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 encodeHead3(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 encodeInteger3(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 encodeHead3(MAJOR_UINT3, n);
+  return encodeHead3(MAJOR_NINT3, -1n - n);
+}
+function encodeCborDeterministic4(value) {
+  return encodeValue3(value, 0);
+}
+function encodeValue3(value, depth) {
+  if (depth > MAX_DEPTH3) {
+    throw new Error(`encodeCborDeterministic: nesting exceeds ${MAX_DEPTH3}`);
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return encodeInteger3(value);
+  }
+  if (typeof value === "boolean") {
+    return new Uint8Array([value ? 245 : 244]);
+  }
+  if (value === null) {
+    return new Uint8Array([246]);
+  }
+  if (value instanceof Uint8Array) {
+    return concat6([encodeHead3(MAJOR_BSTR3, value.length), value]);
+  }
+  if (value instanceof ArrayBuffer) {
+    const bytes = new Uint8Array(value);
+    return concat6([encodeHead3(MAJOR_BSTR3, bytes.length), bytes]);
+  }
+  if (typeof value === "string") {
+    const bytes = new TextEncoder().encode(value);
+    return concat6([encodeHead3(MAJOR_TSTR3, bytes.length), bytes]);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((v) => encodeValue3(v, depth + 1));
+    return concat6([encodeHead3(MAJOR_ARRAY3, value.length), ...items]);
+  }
+  if (value instanceof Map) {
+    return encodeMap3(value.entries(), depth);
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+    return encodeMap3(entries[Symbol.iterator](), depth);
+  }
+  throw new Error(`encodeCborDeterministic: unsupported value type ${typeof value}`);
+}
+function encodeMap3(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: encodeValue3(k, depth + 1),
+      valueBytes: encodeValue3(v, depth + 1)
+    };
+  });
+  encoded.sort((a, b) => compareCanonicalKeys3(a.keyBytes, b.keyBytes));
+  for (let i = 1;i < encoded.length; i++) {
+    if (compareCanonicalKeys3(encoded[i - 1].keyBytes, encoded[i].keyBytes) === 0) {
+      throw new Error("encodeCborDeterministic: duplicate map key");
+    }
+  }
+  const chunks = [encodeHead3(MAJOR_MAP3, encoded.length)];
+  for (const e of encoded)
+    chunks.push(e.keyBytes, e.valueBytes);
+  return concat6(chunks);
+}
+var MAJOR_UINT3 = 0, MAJOR_NINT3 = 1, MAJOR_BSTR3 = 2, MAJOR_TSTR3 = 3, MAJOR_ARRAY3 = 4, MAJOR_MAP3 = 5, MAX_DEPTH3 = 64;
+var init_encode_cbor_deterministic3 = () => {};
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/decode-cbor-deterministic.js
+class CborTag4 {
+  tag;
+  value;
+  constructor(tag, value) {
+    this.tag = tag;
+    this.value = value;
+  }
+}
+
+class CborSimple3 {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class CborFloat3 {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Reader3 {
+  buf;
+  rejectTags;
+  pos = 0;
+  constructor(buf, rejectTags) {
+    this.buf = buf;
+    this.rejectTags = rejectTags;
+  }
+  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) {
+      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) {
+      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;
+      if (v < 0x100000000n)
+        throw this.notShortest(v);
+      return v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : v;
+    }
+    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 notPreferredFloat2(`NaN payload f9${half.toString(16).padStart(4, "0")}`, "f97e00");
+    }
+    const sign2 = half & 32768 ? -1 : 1;
+    if (exponent === 0)
+      return sign2 * fraction * 2 ** -24;
+    if (exponent === 31)
+      return fraction ? NaN : sign2 * Infinity;
+    return sign2 * (fraction + 1024) * 2 ** (exponent - 25);
+  }
+  float32() {
+    const v = new DataView(this.bytes(4).buffer).getFloat32(0);
+    if (Number.isNaN(v))
+      throw notPreferredFloat2("NaN as fa", "f97e00");
+    if (isFloat16Exact2(v))
+      throw notPreferredFloat2(`single ${v}`, "half (f9)");
+    return v;
+  }
+  float64() {
+    const v = new DataView(this.bytes(8).buffer).getFloat64(0);
+    if (Number.isNaN(v))
+      throw notPreferredFloat2("NaN as fb", "f97e00");
+    if (isFloat16Exact2(v))
+      throw notPreferredFloat2(`double ${v}`, "half (f9)");
+    if (Math.fround(v) === v) {
+      throw notPreferredFloat2(`double ${v}`, "single (fa)");
+    }
+    return v;
+  }
+  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(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);
+      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 = 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:
+        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 CborTag4(tag, this.value(depth + 1));
+      }
+      case 7: {
+        if (ai < 20)
+          return new CborSimple3(ai);
+        switch (ai) {
+          case 20:
+            return false;
+          case 21:
+            return true;
+          case 22:
+            return null;
+          case 23:
+            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 CborSimple3(v);
+          }
+          case 25:
+            return new CborFloat3(this.float16());
+          case 26:
+            return new CborFloat3(this.float32());
+          case 27:
+            return new CborFloat3(this.float64());
+          default:
+            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);
+      checkKeyMagnitude2(key);
+      if (previousKey !== null) {
+        const order = compareCanonicalKeys3(previousKey, keyBytes);
+        if (order === 0) {
+          throw new Error(`decodeCbor: duplicate map key ${describeKey2(key)}`);
+        }
+        if (order > 0) {
+          throw new Error(`decodeCbor: map key ${describeKey2(key)} is out of canonical order`);
+        }
+      }
+      previousKey = keyBytes;
+      m.set(key, this.value(depth + 1));
+    }
+    return m;
+  }
+}
+function checkKeyMagnitude2(key) {
+  if (typeof key !== "bigint")
+    return;
+  if (key > INT64_MAX2 || key < INT64_MIN3) {
+    throw new Error(`decodeCbor: integer map key ${key} exceeds int64 magnitude`);
+  }
+}
+function notPreferredFloat2(got, want) {
+  return new Error(`decodeCbor: float ${got} is not in shortest form; it re-encodes as ${want} (RFC 8949 4.2.2)`);
+}
+function isFloat16Exact2(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 describeKey2(key) {
+  return typeof key === "string" ? JSON.stringify(key) : String(key);
+}
+function decodeCborDeterministic4(bytes, options) {
+  const r = new Reader3(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;
+}
+var INT64_MAX2 = 9223372036854775807n, INT64_MIN3;
+var init_decode_cbor_deterministic3 = __esm(() => {
+  INT64_MIN3 = -9223372036854775808n;
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/encode-sig-structure.js
+var init_encode_sig_structure4 = () => {};
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/encode-grant-request.js
+var init_encode_grant_request4 = () => {};
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/problem-details.js
+var init_problem_details5 = __esm(() => {
+  init_encode_cbor_deterministic3();
+});
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/grant-payload-canonical.js
+var init_grant_payload_canonical4 = () => {};
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/encode-cose-protected.js
+var MAX_UINT643;
+var init_encode_cose_protected4 = __esm(() => {
+  init_grant_payload_canonical4();
+  MAX_UINT643 = (1n << 64n) - 1n;
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/cose-protected-tree-size.js
+var init_cose_protected_tree_size3 = __esm(() => {
+  init_decode_cbor_deterministic3();
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/encode-cose-sign1-statement.js
+var init_encode_cose_sign1_statement4 = __esm(() => {
+  init_encode_cose_protected4();
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/sign-cose-sign1-statement.js
+var init_sign_cose_sign1_statement4 = __esm(() => {
+  init_encode_cose_protected4();
+  init_encode_cose_sign1_statement4();
+  init_encode_sig_structure4();
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/base64url.js
+var ALPHABET4 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", REVERSE4;
+var init_base64url4 = __esm(() => {
+  REVERSE4 = (() => {
+    const out = new Int8Array(128).fill(-1);
+    for (let i = 0;i < ALPHABET4.length; i++) {
+      out[ALPHABET4.charCodeAt(i)] = i;
+    }
+    return out;
+  })();
+});
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/verify-cose-sign1.js
+var P256_N4, P256_HALF_N4;
+var init_verify_cose_sign14 = __esm(() => {
+  init_base64url4();
+  init_decode_cbor_deterministic3();
+  init_encode_sig_structure4();
+  P256_N4 = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
+  P256_HALF_N4 = P256_N4 >> 1n;
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/verify-delegate-key-voucher.js
+var init_verify_delegate_key_voucher4 = __esm(() => {
+  init_decode_cbor_deterministic3();
+  init_verify_cose_sign14();
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/cose-key-thumbprint.js
+var init_cose_key_thumbprint4 = __esm(() => {
+  init_base64url4();
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/encode-cose-sign1-raw.js
+var init_encode_cose_sign1_raw4 = __esm(() => {
+  init_encode_cbor_deterministic3();
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/merge-cose-sign1-unprotected.js
+var init_merge_cose_sign1_unprotected4 = __esm(() => {
+  init_verify_cose_sign14();
+  init_encode_cose_sign1_raw4();
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/grant-codec.js
+var init_grant_codec4 = __esm(() => {
+  init_encode_cbor_deterministic3();
+  init_decode_cbor_deterministic3();
+});
+
+// node_modules/@forestrie/delegation-cose/node_modules/@forestrie/encoding/dist/index.js
+var init_dist9 = __esm(() => {
+  init_encode_cbor_deterministic3();
+  init_decode_cbor_deterministic3();
+  init_encode_sig_structure4();
+  init_encode_grant_request4();
+  init_problem_details5();
+  init_encode_cose_protected4();
+  init_cose_protected_tree_size3();
+  init_encode_cose_sign1_statement4();
+  init_sign_cose_sign1_statement4();
+  init_base64url4();
+  init_verify_cose_sign14();
+  init_verify_delegate_key_voucher4();
+  init_cose_key_thumbprint4();
+  init_encode_cose_sign1_raw4();
+  init_merge_cose_sign1_unprotected4();
+  init_grant_codec4();
+  init_grant_payload_canonical4();
+});
 
 // node_modules/@forestrie/delegation-cose/dist/bytes-utils.js
 function bytesFromUnknown(value, label) {
@@ -26675,14 +27394,14 @@ function toArrayBuffer(bytes) {
 
 // node_modules/@forestrie/delegation-cose/dist/encode-int-map.js
 function encodeIntKeyCbor(value) {
-  return encodeCborDeterministic(value);
+  return encodeCborDeterministic4(value);
 }
 var init_encode_int_map = __esm(() => {
-  init_dist3();
+  init_dist9();
 });
 
 // node_modules/@forestrie/delegation-cose/dist/encode-cbor-bstr.js
-function encodeCborBstr3(bytes) {
+function encodeCborBstr5(bytes) {
   const len = bytes.length;
   let header;
   if (len < 24) {
@@ -26723,7 +27442,7 @@ function encodeCborTstr2(s) {
   out.set(bytes, header.length);
   return out;
 }
-function concat6(...arrays) {
+function concat7(...arrays) {
   const total = arrays.reduce((sum, a) => sum + a.length, 0);
   const out = new Uint8Array(total);
   let off = 0;
@@ -26733,12 +27452,12 @@ function concat6(...arrays) {
   }
   return out;
 }
-function encodeSigStructure3(protectedHeaderMapBytes, externalAad, payloadBstr) {
+function encodeSigStructure5(protectedHeaderMapBytes, externalAad, payloadBstr) {
   const arrayHeader = new Uint8Array([132]);
   const label = encodeCborTstr2("Signature1");
-  return concat6(arrayHeader, label, encodeCborBstr3(protectedHeaderMapBytes), encodeCborBstr3(externalAad), encodeCborBstr3(payloadBstr));
+  return concat7(arrayHeader, label, encodeCborBstr5(protectedHeaderMapBytes), encodeCborBstr5(externalAad), encodeCborBstr5(payloadBstr));
 }
-var init_encode_sig_structure3 = () => {};
+var init_encode_sig_structure5 = () => {};
 
 // node_modules/@forestrie/delegation-cose/dist/webauthn-assertion.js
 var TYPE_MARKER, CHALLENGE_MARKER;
@@ -26796,11 +27515,11 @@ function buildOnchainDelegationToBeSignedWithAlg(input, alg) {
   return {
     protectedHeader,
     delegationKey,
-    sigStructureBytes: encodeSigStructure3(protectedHeader, new Uint8Array, payload)
+    sigStructureBytes: encodeSigStructure5(protectedHeader, new Uint8Array, payload)
   };
 }
 function buildOnchainDelegationToBeSignedEs256(input) {
-  return buildOnchainDelegationToBeSignedWithAlg(input, COSE_ALG_ES2563);
+  return buildOnchainDelegationToBeSignedWithAlg(input, COSE_ALG_ES2564);
 }
 function normalizeEs256SignatureLowS(signature) {
   if (signature.length !== ES256_SIG_BYTES) {
@@ -26810,10 +27529,10 @@ function normalizeEs256SignatureLowS(signature) {
   for (let i = 32;i < 64; i++) {
     s = s << 8n | BigInt(signature[i]);
   }
-  if (s <= P256_HALF_N3) {
+  if (s <= P256_HALF_N5) {
     return signature;
   }
-  s = P256_N3 - s;
+  s = P256_N5 - s;
   const out = new Uint8Array(64);
   out.set(signature.slice(0, 32), 0);
   for (let i = 0;i < 32; i++) {
@@ -26836,14 +27555,14 @@ async function signOnchainDelegationEs256(input, rootKeyPair) {
     algData: []
   };
 }
-var ONCHAIN_DELEGATION_DOMAIN = "forestrie.univocity.delegation.v1", P256_N3, P256_HALF_N3;
+var ONCHAIN_DELEGATION_DOMAIN = "forestrie.univocity.delegation.v1", P256_N5, P256_HALF_N5;
 var init_build_onchain_delegation = __esm(() => {
-  init_dist3();
+  init_dist9();
   init_encode_int_map();
-  init_encode_sig_structure3();
+  init_encode_sig_structure5();
   init_webauthn_assertion();
-  P256_N3 = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
-  P256_HALF_N3 = P256_N3 >> 1n;
+  P256_N5 = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
+  P256_HALF_N5 = P256_N5 >> 1n;
 });
 
 // node_modules/@forestrie/delegation-cose/dist/assemble-certificate.js
@@ -26908,11 +27627,11 @@ function parseDelegatedCoseKeyFromPayload(raw) {
   return { x, y };
 }
 function decodeDelegatedCoseKeyFromBytes(bytes) {
-  const raw = decodeCborDeterministic(bytes);
+  const raw = decodeCborDeterministic4(bytes);
   return normalizeIntKeyedMap(raw);
 }
 function decodeCoseSign1Parts(certificate) {
-  const cert = decodeCborDeterministic(certificate);
+  const cert = decodeCborDeterministic4(certificate);
   if (!Array.isArray(cert) || cert.length !== 4) {
     throw new Error("delegation certificate must be COSE_Sign1 array");
   }
@@ -26923,7 +27642,7 @@ function decodeCoseSign1Parts(certificate) {
   };
 }
 var init_parse_delegated_cose_key = __esm(() => {
-  init_dist3();
+  init_dist9();
 });
 
 // node_modules/@forestrie/delegation-cose/dist/build-delegation-payload.js
@@ -26958,11 +27677,11 @@ function buildDelegationPayloadBytes(input) {
   ]));
 }
 function buildDelegationToBeSigned(protectedBytes, payloadBytes) {
-  const sigStructureBytes = encodeSigStructure3(protectedBytes, new Uint8Array, payloadBytes);
+  const sigStructureBytes = encodeSigStructure5(protectedBytes, new Uint8Array, payloadBytes);
   return { protectedBytes, payloadBytes, sigStructureBytes };
 }
 var init_build_delegation_payload = __esm(() => {
-  init_encode_sig_structure3();
+  init_encode_sig_structure5();
   init_parse_delegated_cose_key();
   init_encode_int_map();
 });
@@ -26990,7 +27709,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_ES2563],
+    [COSE_HEADER_ALG, COSE_ALG_ES2564],
     [COSE_HEADER_CTY, DELEGATION_CONTENT_TYPE],
     [COSE_HEADER_KID, rootKid]
   ]));
@@ -27032,7 +27751,7 @@ var init_build_delegation_certificate_ks256 = __esm(() => {
 // node_modules/@forestrie/delegation-cose/dist/parse-certificate.js
 function parseDelegationCertificate(certificate) {
   const { payloadBytes } = decodeCoseSign1Parts(certificate);
-  const payloadMap = normalizeIntKeyedMap(decodeCborDeterministic(payloadBytes));
+  const payloadMap = normalizeIntKeyedMap(decodeCborDeterministic4(payloadBytes));
   const logIdHex32 = payloadMap.get(PAYLOAD_LOG_ID);
   if (typeof logIdHex32 !== "string") {
     throw new Error("payload missing log id");
@@ -27048,24 +27767,24 @@ function parseDelegationCertificate(certificate) {
   };
 }
 var init_parse_certificate = __esm(() => {
-  init_dist3();
+  init_dist9();
   init_parse_delegated_cose_key();
 });
 
 // node_modules/@forestrie/delegation-cose/dist/verify-es256.js
 var init_verify_es256 = __esm(() => {
-  init_encode_sig_structure3();
+  init_encode_sig_structure5();
   init_parse_delegated_cose_key();
 });
 
 // node_modules/@forestrie/delegation-cose/dist/verify-ks256.js
 var init_verify_ks256 = __esm(() => {
-  init_encode_sig_structure3();
+  init_encode_sig_structure5();
   init_parse_delegated_cose_key();
 });
 
 // node_modules/@forestrie/delegation-cose/dist/index.js
-var init_dist8 = __esm(() => {
+var init_dist10 = __esm(() => {
   init_build_onchain_delegation();
   init_webauthn_assertion();
   init_assemble_certificate();
@@ -27083,7 +27802,7 @@ var init_dist8 = __esm(() => {
 });
 
 // src/lib/delegate-voucher.ts
-function parseRegistrarKeyXY3(raw) {
+function parseRegistrarKeyXY5(raw) {
   if (raw.length !== REGISTRAR_KEY_XY_BYTES)
     return null;
   return {
@@ -27110,7 +27829,7 @@ function toBigIntOrNull(value) {
     return BigInt(value);
   return null;
 }
-async function verifyDelegateKeyVoucher3(voucherBytes, pinnedKey, expect) {
+async function verifyDelegateKeyVoucher5(voucherBytes, pinnedKey, expect) {
   const sigOk = await verifyCoseSign1WithParsedKey(voucherBytes, pinnedKey);
   if (!sigOk)
     return { ok: false, reason: "signature" };
@@ -27176,7 +27895,7 @@ async function runDelegateFlow(params, deps = {}) {
   const pendingUrl = `${params.coordinatorUrl}/api/logs/${params.logId}/pending-delegation`;
   const pendingRes = await fetchImpl(pendingUrl);
   if (!pendingRes.ok) {
-    const preview = (await pendingRes.text()).slice(0, 200);
+    const preview = await responseProblemDetail(pendingRes, 200);
     throw new DelegateFlowError(`pending-delegation fetch failed: HTTP ${pendingRes.status} ${preview}`, pendingRes.status);
   }
   const pending = await pendingRes.json();
@@ -27188,11 +27907,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 = parseRegistrarKeyXY3(b64ToBytes(params.knownSealerKey));
+  const pinned = parseRegistrarKeyXY5(b64ToBytes(params.knownSealerKey));
   if (pinned === null) {
     throw new DelegateFlowError("known-sealer-key must be base64 x||y (64 bytes)");
   }
-  const voucherResult = await verifyDelegateKeyVoucher3(b64ToBytes(standing.voucher), pinned, {
+  const voucherResult = await verifyDelegateKeyVoucher5(b64ToBytes(standing.voucher), pinned, {
     sealerId: standing.sealerId,
     epoch: standing.epoch,
     publicKey: b64ToBytes(standing.delegatedPublicKey)
@@ -27239,7 +27958,7 @@ async function runDelegateFlow(params, deps = {}) {
     })
   });
   if (!submitRes.ok) {
-    const preview = (await submitRes.text()).slice(0, 200);
+    const preview = await responseProblemDetail(submitRes, 200);
     throw new DelegateFlowError(`certificate submit failed: HTTP ${submitRes.status} ${preview}`, submitRes.status);
   }
   return {
@@ -27254,9 +27973,10 @@ async function runDelegateFlow(params, deps = {}) {
 }
 var MMR_START = 0, DelegateFlowError;
 var init_delegate_flow = __esm(() => {
-  init_dist8();
+  init_dist10();
   init_dist3();
   init_delegate_voucher();
+  init_http_problem();
   DelegateFlowError = class DelegateFlowError extends Error {
     httpStatus;
     code;
@@ -27488,7 +28208,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_ES2564],
+    [LABEL_GENESIS_ALG, COSE_ALG_ES2566],
     [LABEL_BOOTSTRAP_KEY, opts.bootstrapKeyXy]
   ]));
 }
@@ -27499,7 +28219,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_ES2564 = -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_ES2566 = -7;
 var init_onboard_genesis_body = __esm(() => {
   init_dist3();
 });
@@ -27569,7 +28289,7 @@ async function runOnboardGenesis(out, options, deps = {}) {
       command: "onboard-genesis",
       message: `genesis POST rejected: HTTP ${res.status}`,
       httpStatus: res.status,
-      detail: (await res.text()).slice(0, 512)
+      detail: await responseProblemDetail(res)
     });
     return;
   }
@@ -27617,6 +28337,7 @@ var init_onboard_genesis = __esm(() => {
   init_fsio();
   init_deployment_record();
   init_onboard_genesis_body();
+  init_http_problem();
 });
 
 // src/options/onboard-genesis.ts
@@ -27751,14 +28472,14 @@ function assemble(prot, payload, signature) {
   return encodeCborDeterministic([prot, new Map, payload, signature]);
 }
 async function buildOnboardAttestationEs256(key, input) {
-  const prot = protectedBytes(COSE_ALG_ES2565);
+  const prot = protectedBytes(COSE_ALG_ES2567);
   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_KS2564);
+  const prot = protectedBytes(COSE_ALG_KS2566);
   const payload = claimsBytes(input);
   const sigStructure = encodeSigStructure(prot, new Uint8Array(0), payload);
   const hash3 = keccak256(sigStructure);
@@ -27769,7 +28490,7 @@ async function buildOnboardAttestationKs256(privateKeyHex, input) {
   }
   return assemble(prot, payload, sig);
 }
-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 ONBOARD_ATTESTATION_CONTENT_TYPE = "application/forestrie-onboard-attestation+cwt", COSE_ALG_ES2567 = -7, COSE_ALG_KS2566 = -65799, CLAIM_CHAIN_BINDING = -70000, DEFAULT_ATTESTATION_WINDOW_SEC = 3600;
 var init_onboard_attestation = __esm(() => {
   init_accounts();
   init__esm();
@@ -27942,7 +28663,7 @@ async function runOnboardRequest(out, options, deps = {}) {
       reportError8(out, options, {
         error: "create_failed",
         command: "onboard-request",
-        message: `request rejected: HTTP ${res2.status}: ${(await res2.text()).slice(0, 300)}`,
+        message: `request rejected: HTTP ${res2.status}: ${await responseProblemDetail(res2, 300)}`,
         httpStatus: res2.status
       });
       return;
@@ -28018,7 +28739,7 @@ async function runOnboardRequest(out, options, deps = {}) {
     reportError8(out, options, {
       error: "redeem_failed",
       command: "onboard-request",
-      message: `redeem rejected: HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`,
+      message: `redeem rejected: HTTP ${res.status}: ${await responseProblemDetail(res, 300)}`,
       httpStatus: res.status
     });
     return;
@@ -28078,6 +28799,7 @@ var init_onboard_request = __esm(() => {
   init_onboard_attestation();
   init_sign_statement_key();
   init_x402_payment();
+  init_http_problem();
 });
 
 // src/options/onboard-request.ts
@@ -28949,7 +29671,7 @@ function bitLength2(value) {
 var init_math = () => {};
 
 // node_modules/@forestrie/merklelog/dist/mmr/errors.js
-var ConsistencyShapeError, IncompleteTreeSize, ConsistencyPeakCountMismatch, ConsistencyPathLengthMismatch, ConsistencyRootMismatch, SizeMustIncrease;
+var ConsistencyShapeError, IncompleteTreeSize, ConsistencyPeakCountMismatch, ConsistencyPathLengthMismatch, ConsistencyRootMismatch, SizeMustIncrease, SizeNotUint64, ConsistencyPathMalformed;
 var init_errors4 = __esm(() => {
   ConsistencyShapeError = class ConsistencyShapeError extends Error {
     constructor(message) {
@@ -29005,6 +29727,26 @@ var init_errors4 = __esm(() => {
       this.name = "SizeMustIncrease";
     }
   };
+  SizeNotUint64 = class SizeNotUint64 extends ConsistencyShapeError {
+    which;
+    size;
+    constructor(which, size5) {
+      super(`${which} (${size5}) is outside the uint64 range [0, 2^64 - 1]`);
+      this.which = which;
+      this.size = size5;
+      this.name = "SizeNotUint64";
+    }
+  };
+  ConsistencyPathMalformed = class ConsistencyPathMalformed extends ConsistencyShapeError {
+    detail;
+    index;
+    constructor(detail, index2) {
+      super(index2 === undefined ? `paths: ${detail}` : `path ${index2}: ${detail}`);
+      this.detail = detail;
+      this.index = index2;
+      this.name = "ConsistencyPathMalformed";
+    }
+  };
 });
 
 // node_modules/@forestrie/merklelog/dist/utils/arrays.js
@@ -29064,6 +29806,12 @@ async function verifyInclusion(hasher, leafHash, proof, root) {
   return arraysEqual(calculatedRoot, root);
 }
 async function consistentRootsForSizes(hasher, sizeFrom, sizeTo, accumulatorFrom, paths) {
+  if (sizeFrom < 0n || sizeFrom > MAX_UINT644) {
+    throw new SizeNotUint64("sizeFrom", sizeFrom);
+  }
+  if (sizeTo < 0n || sizeTo > MAX_UINT644) {
+    throw new SizeNotUint64("sizeTo", sizeTo);
+  }
   if (sizeTo <= sizeFrom) {
     throw new SizeMustIncrease(sizeFrom, sizeTo);
   }
@@ -29076,9 +29824,13 @@ async function consistentRootsForSizes(hasher, sizeFrom, sizeTo, accumulatorFrom
   if (accumulatorFrom.length !== n) {
     throw new ConsistencyPeakCountMismatch(n, accumulatorFrom.length);
   }
+  if (!Array.isArray(paths)) {
+    throw new ConsistencyPathMalformed(`not an array (got ${typeName(paths)})`);
+  }
   if (paths.length !== n) {
     throw new ConsistencyPeakCountMismatch(n, paths.length);
   }
+  assertDensePaths(paths);
   const nto = popcount(to);
   if (n === 0) {
     return { roots: [], expectedRight: nto };
@@ -29141,9 +29893,34 @@ function indexConsistencyProof(get, mmrIndexA, mmrIndexB) {
   }
   return { mmrSizeA: mmrIndexA + 1n, mmrSizeB: mmrIndexB + 1n, paths };
 }
+function typeName(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "an array";
+  return typeof value;
+}
+function assertDensePaths(paths) {
+  for (let i = 0;i < paths.length; i++) {
+    if (!(i in paths)) {
+      throw new ConsistencyPathMalformed("missing (the array is sparse)", i);
+    }
+    const path2 = paths[i];
+    if (!Array.isArray(path2)) {
+      throw new ConsistencyPathMalformed(`not an array (got ${typeName(path2)})`, i);
+    }
+    for (let j = 0;j < path2.length; j++) {
+      if (!(j in path2) || !(path2[j] instanceof Uint8Array)) {
+        throw new ConsistencyPathMalformed(`element ${j} is not a Uint8Array (got ${typeName(path2[j])})`, i);
+      }
+    }
+  }
+}
+var MAX_UINT644;
 var init_algorithms = __esm(() => {
   init_errors4();
   init_math();
+  MAX_UINT644 = (1n << 64n) - 1n;
 });
 
 // node_modules/@forestrie/merklelog/dist/mmr/algorithms-sync.js
@@ -29178,7 +29955,7 @@ async function createSyncHasher() {
 }
 
 // node_modules/@forestrie/merklelog/dist/index.js
-var init_dist9 = __esm(() => {
+var init_dist11 = __esm(() => {
   init_massif();
   init_types();
   init_types();
@@ -29208,22 +29985,10 @@ function asBytesArray(v, what) {
   }
   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)");
-  }
+function decodeOneProof(proofBstr) {
   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]");
+  if (!Array.isArray(proof) || proof.length !== 4) {
+    throw new Error(`consistency proof must be [tree-size-1, tree-size-2, paths, right-peaks] (4 elements), got ${Array.isArray(proof) ? proof.length : typeof proof}`);
   }
   const pathsRaw = proof[2];
   if (!Array.isArray(pathsRaw)) {
@@ -29253,8 +30018,50 @@ function decodeConsistencyProofFromUnprotected(unprotected) {
     rightPeaks: asBytesArray(proof[3], "right-peaks")
   };
 }
+function decodeProofAt(proofBstr, at) {
+  if (at === null)
+    return decodeOneProof(proofBstr);
+  try {
+    return decodeOneProof(proofBstr);
+  } catch (err) {
+    throw new Error(`consistency-proofs entry ${at}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function decodeConsistencyProofsFromUnprotected(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 entry = vdpRaw.get(VDP_CONSISTENCY_PROOF_KEY);
+  if (entry === undefined || entry === null)
+    return null;
+  if (entry instanceof Uint8Array) {
+    return [decodeOneProof(entry)];
+  }
+  if (!Array.isArray(entry)) {
+    throw new Error("checkpoint carries no consistency proof (vdp key -2)");
+  }
+  if (entry.length === 0) {
+    throw new EmptyConsistencyProofsError("consistency-proofs (vdp key -2) is empty; at least one proof is required");
+  }
+  return entry.map((proofBstr, i) => {
+    if (!(proofBstr instanceof Uint8Array)) {
+      throw new Error(`consistency-proofs entry ${i} is not a byte string (vdp key -2)`);
+    }
+    return decodeProofAt(proofBstr, entry.length === 1 ? null : i);
+  });
+}
+var EmptyConsistencyProofsError;
 var init_decode_checkpoint_consistency_proof = __esm(() => {
   init_dist3();
+  EmptyConsistencyProofsError = class EmptyConsistencyProofsError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "EmptyConsistencyProofsError";
+    }
+  };
 });
 
 // node_modules/@forestrie/receipt-verify/dist/subtle-hasher.js
@@ -29375,24 +30182,15 @@ function cborBytes(value) {
   return encodeCborDeterministic(value);
 }
 function sealedSizeFromCheckpoint(coseSign1, unprotected) {
-  let declared;
-  try {
-    declared = decodeConsistencyProofFromUnprotected(unprotected);
-  } catch {
-    return null;
-  }
+  const declared = decodeConsistencyProofsFromUnprotected(unprotected);
   if (declared === null)
     return null;
-  try {
-    return readProtectedTreeSize2(coseSign1[0]);
-  } catch {
-    return null;
-  }
+  return readProtectedTreeSize2(coseSign1[0]);
 }
 var DELEGATION_CERT_LABEL = 1000;
 var init_build_receipt_offline = __esm(() => {
   init_dist3();
-  init_dist9();
+  init_dist11();
   init_parse_receipt();
   init_decode_checkpoint_consistency_proof();
 });
@@ -29400,40 +30198,61 @@ var init_build_receipt_offline = __esm(() => {
 // node_modules/@forestrie/receipt-verify/dist/checkpoint-chain.js
 function checkpointConsistencyProof(checkpointBytes) {
   const { coseSign1, unprotected } = parseCheckpoint(checkpointBytes);
-  const alg = extractAlgFromProtected(coseSign1[0]);
+  let alg;
+  try {
+    alg = readProtectedAlg(coseSign1[0]);
+  } catch (err) {
+    if (err instanceof ProtectedHeaderAlgError) {
+      throw new CheckpointProtectedHeaderAlgError(`checkpoint protected header carries no integer alg (label 1): ${err.message}`);
+    }
+    throw err;
+  }
   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) {
+  const proofs = decodeConsistencyProofsFromUnprotected(unprotected);
+  if (proofs === null) {
     throw new Error("checkpoint carries no consistency proof (vdp key -2)");
   }
+  const last = proofs[proofs.length - 1];
   const signedTreeSize2 = readProtectedTreeSize2(coseSign1[0]);
   if (signedTreeSize2 === null) {
     throw new Error("checkpoint protected header carries no signed tree-size-2 (-65933)");
   }
-  if (signedTreeSize2 !== declared.treeSize2) {
-    throw new CheckpointSignedSizeMismatchError(`signed tree-size-2 (-65933) ${signedTreeSize2} != declared consistency-proof tree-size-2 ${declared.treeSize2}`);
+  if (signedTreeSize2 !== last.treeSize2) {
+    throw new CheckpointSignedSizeMismatchError(`signed tree-size-2 (-65933) ${signedTreeSize2} != declared consistency-proof tree-size-2 ${last.treeSize2}`);
   }
   return {
-    treeSize1: declared.treeSize1,
-    treeSize2: declared.treeSize2,
-    signedTreeSize2,
-    paths: declared.paths,
-    rightPeaks: declared.rightPeaks
+    proofs,
+    treeSize1: proofs[0].treeSize1,
+    treeSize2: last.treeSize2,
+    signedTreeSize2
   };
 }
 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}`);
+  if (proof.proofs.length === 0) {
+    throw new EmptyConsistencyProofsError("consistency proof relays no proofs (empty proofs array); at least " + "one is required to fold");
   }
   const hasher = new SubtleHasher;
-  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}`);
+  let accumulator = accumulatorFrom;
+  let size5 = sizeFrom;
+  for (let i = 0;i < proof.proofs.length; i++) {
+    const step = proof.proofs[i];
+    if (step.treeSize1 !== size5) {
+      throw new ConsistencyChainNotContiguousError(i === 0 ? `consistency proof base tree-size-1 ${step.treeSize1} does not match the trusted size ${size5}` : `consistency-proofs entry ${i} declares tree-size-1 ${step.treeSize1}; the previous proof reached ${size5}`);
+    }
+    const { roots, expectedRight } = await consistentRootsForSizes(hasher, size5, step.treeSize2, accumulator, step.paths);
+    if (step.rightPeaks.length !== expectedRight) {
+      throw new Error(`checkpoint supplies ${step.rightPeaks.length} right-peaks; size ${step.treeSize2} requires ${expectedRight}`);
+    }
+    accumulator = [...roots, ...step.rightPeaks];
+    size5 = step.treeSize2;
+  }
+  if (size5 !== proof.treeSize2) {
+    throw new ConsistencyChainNotContiguousError(`consistency proof folds to tree-size-2 ${size5}; the chain's declared tree-size-2 is ${proof.treeSize2}`);
   }
-  return [...roots, ...proof.rightPeaks];
+  return accumulator;
 }
 function accumulatorPayload(accumulator) {
   const out = new Uint8Array(accumulator.reduce((s, p) => s + p.length, 0));
@@ -29476,6 +30295,18 @@ async function verifyCheckpointChain(opts) {
         links
       };
     }
+    for (let i = 0;i < trustedBase.accumulator.length; i++) {
+      const peak = trustedBase.accumulator[i];
+      if (!(peak instanceof Uint8Array) || peak.length !== 32) {
+        return {
+          ok: false,
+          reason: "proof_malformed",
+          at: 0,
+          detail: `trusted base accumulator peak ${i} is not a 32-byte node value (${describePeak(peak)})`,
+          links
+        };
+      }
+    }
   }
   let accumulator = trustedBase?.accumulator ?? [];
   let expectedBase = trustedBase?.size ?? 0n;
@@ -29518,7 +30349,7 @@ async function verifyCheckpointChain(opts) {
     } catch (err) {
       return {
         ok: false,
-        reason: "proof_malformed",
+        reason: err instanceof ConsistencyChainNotContiguousError ? "size_mismatch" : "proof_malformed",
         at: i,
         detail: err instanceof Error ? err.message : String(err),
         links
@@ -29546,12 +30377,27 @@ async function verifyCheckpointChain(opts) {
   }
   return { ok: true, links, accumulator };
 }
-var CheckpointSignedSizeMismatchError, CheckpointHighSSignatureError;
+function describePeak(peak) {
+  if (peak instanceof Uint8Array)
+    return `${peak.length} bytes`;
+  if (peak === null)
+    return "null";
+  if (Array.isArray(peak))
+    return "an array";
+  return typeof peak;
+}
+var ConsistencyChainNotContiguousError, CheckpointSignedSizeMismatchError, CheckpointHighSSignatureError, CheckpointProtectedHeaderAlgError;
 var init_checkpoint_chain = __esm(() => {
   init_dist3();
-  init_dist9();
+  init_dist11();
   init_build_receipt_offline();
   init_decode_checkpoint_consistency_proof();
+  ConsistencyChainNotContiguousError = class ConsistencyChainNotContiguousError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "ConsistencyChainNotContiguousError";
+    }
+  };
   CheckpointSignedSizeMismatchError = class CheckpointSignedSizeMismatchError extends Error {
     constructor(message) {
       super(message);
@@ -29564,6 +30410,12 @@ var init_checkpoint_chain = __esm(() => {
       this.name = "CheckpointHighSSignatureError";
     }
   };
+  CheckpointProtectedHeaderAlgError = class CheckpointProtectedHeaderAlgError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "CheckpointProtectedHeaderAlgError";
+    }
+  };
 });
 
 // node_modules/@forestrie/receipt-verify/dist/freshen-receipt.js
@@ -29604,6 +30456,12 @@ async function freshenReceipt(input) {
   if (baseAccumulator.length !== basePeaks) {
     throw new Error(`base accumulator has ${baseAccumulator.length} peaks; trusted base size ${baseSize} has ${basePeaks}`);
   }
+  for (let i = 0;i < links.length; i++) {
+    const link = links[i];
+    if (link.signedTreeSize2 !== link.treeSize2) {
+      throw new CheckpointSignedSizeMismatchError(`consistency proof ${i}: signed tree-size-2 (-65933) ${link.signedTreeSize2} != declared consistency-proof tree-size-2 ${link.treeSize2}`);
+    }
+  }
   if (firstLink.treeSize1 !== baseSize) {
     throw new Error(`first consistency proof declares tree-size-1 ${firstLink.treeSize1}; the trusted base size is ${baseSize}`);
   }
@@ -29641,15 +30499,15 @@ async function freshenReceipt(input) {
   for (let k = 0;k < oldPath.length; k++) {
     store.set(fullIndices[k], oldPath[k]);
   }
-  for (const link of links) {
-    if (link.treeSize1 === 0n)
+  for (const step of links.flatMap((link) => link.proofs)) {
+    if (step.treeSize1 === 0n)
       continue;
-    const fromPeaks = peakMMRIndexes(link.treeSize1 - 1n);
+    const fromPeaks = peakMMRIndexes(step.treeSize1 - 1n);
     fromPeaks.forEach((peakIndex, j) => {
-      const climb = link.paths[j];
+      const climb = step.paths[j];
       if (climb === undefined)
         return;
-      const climbIndices = inclusionProofPath(link.treeSize2 - 1n, peakIndex);
+      const climbIndices = inclusionProofPath(step.treeSize2 - 1n, peakIndex);
       climbIndices.forEach((ix, e) => {
         const v = climb[e];
         if (v !== undefined)
@@ -29674,14 +30532,14 @@ async function freshenReceipt(input) {
   return { receipt, sealedSize };
 }
 var init_freshen_receipt = __esm(() => {
-  init_dist9();
+  init_dist11();
   init_build_receipt_offline();
   init_checkpoint_chain();
   init_parse_receipt();
 });
 
 // node_modules/@forestrie/receipt-verify/dist/cose-key.js
-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;
+var COSE_ALG_ES2568 = -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;
@@ -29828,13 +30686,13 @@ async function decodeTrustRootDetailsFromGenesis(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_ES2566) {
+    if (alg !== undefined && alg !== COSE_ALG_ES2568) {
       throw new Error("genesis EC2 key must be ES256");
     }
     const xy = new Uint8Array(64);
     xy.set(x, 0);
     xy.set(y, 32);
-    const key = await decodeTrustRootCbor({ alg: COSE_ALG_ES2566, key: xy });
+    const key = await decodeTrustRootCbor({ alg: COSE_ALG_ES2568, key: xy });
     return { key, bootstrapKeyXy: xy };
   }
   if (versionRaw === FOREST_GENESIS_SCHEMA_V1 || versionRaw === undefined) {
@@ -29856,26 +30714,26 @@ var init_decode_chain_binding_from_genesis = __esm(() => {
 });
 
 // node_modules/@forestrie/receipt-verify/dist/uuid-bytes.js
-function toPaddedWire323(bytes) {
-  if (bytes.length === WIRE_LOG_ID_BYTES3)
+function toPaddedWire325(bytes) {
+  if (bytes.length === WIRE_LOG_ID_BYTES5)
     return bytes;
-  const out = new Uint8Array(WIRE_LOG_ID_BYTES3);
-  if (bytes.length >= WIRE_LOG_ID_BYTES3) {
-    out.set(bytes.slice(-WIRE_LOG_ID_BYTES3));
+  const out = new Uint8Array(WIRE_LOG_ID_BYTES5);
+  if (bytes.length >= WIRE_LOG_ID_BYTES5) {
+    out.set(bytes.slice(-WIRE_LOG_ID_BYTES5));
   } else {
-    out.set(bytes, WIRE_LOG_ID_BYTES3 - bytes.length);
+    out.set(bytes, WIRE_LOG_ID_BYTES5 - bytes.length);
   }
   return out;
 }
-function fromPaddedWire323(wire) {
+function fromPaddedWire325(wire) {
   if (wire.length === 16)
     return wire;
-  if (wire.length !== WIRE_LOG_ID_BYTES3) {
-    throw new Error(`Expected ${WIRE_LOG_ID_BYTES3}-byte wire log id`);
+  if (wire.length !== WIRE_LOG_ID_BYTES5) {
+    throw new Error(`Expected ${WIRE_LOG_ID_BYTES5}-byte wire log id`);
   }
   return wire.slice(-16);
 }
-var WIRE_LOG_ID_BYTES3 = 32;
+var WIRE_LOG_ID_BYTES5 = 32;
 
 // node_modules/@forestrie/receipt-verify/dist/grant-commitment.js
 function u64Be(n) {
@@ -29897,11 +30755,11 @@ function grantFlags32(flags) {
   return out;
 }
 function grantCommitmentPreimage(grant) {
-  const logId = toPaddedWire323(grant.logId);
+  const logId = toPaddedWire325(grant.logId);
   const flags32 = grantFlags32(grant.grant);
   const maxHeight = grant.maxHeight ?? 0;
   const minGrowth = grant.minGrowth ?? 0;
-  const ownerLogId = toPaddedWire323(grant.ownerLogId);
+  const ownerLogId = toPaddedWire325(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);
@@ -30240,7 +31098,7 @@ async function verifyReceiptOfflineWithLeafInnerKeys(input) {
 }
 var init_verify_grant_receipt_offline = __esm(() => {
   init_dist3();
-  init_dist9();
+  init_dist11();
   init_grant_commitment();
   init_decode_trust_root_from_genesis();
   init_decode_trust_root_cbor();
@@ -30274,6 +31132,14 @@ function leftPad(b, length) {
   out.set(b, length - b.length);
   return out;
 }
+function assertNoObsoleteWireKeys(m) {
+  const keys = m instanceof Map ? [...m.keys()] : Object.keys(m).map(Number).filter((n) => Number.isFinite(n));
+  for (const k of keys) {
+    if (k === 7 || k === 8) {
+      throw new Error("Grant wire v0: obsolete CBOR keys 7 (signer) and 8 (kind) must not be present; use grantData in the commitment only.");
+    }
+  }
+}
 function mapToGrant(m) {
   const get = (k) => m instanceof Map ? m.get(k) : m[k];
   const requireBstr = (v, minLen = 0) => {
@@ -30291,25 +31157,27 @@ function mapToGrant(m) {
     throw new Error("Grant payload: expected uint");
   };
   return {
-    logId: fromPaddedWire323(requireBstr(get(CBOR_KEY_LOG_ID))),
-    ownerLogId: fromPaddedWire323(requireBstr(get(CBOR_KEY_OWNER_LOG_ID))),
+    logId: fromPaddedWire325(requireBstr(get(CBOR_KEY_LOG_ID))),
+    ownerLogId: fromPaddedWire325(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 decodeGrantPayload3(bytes) {
+function decodeGrantPayload5(bytes) {
   if (!bytes?.length)
     throw new Error("Grant payload is empty");
   const raw = decodeCborDeterministic(bytes);
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     throw new Error("Grant payload must be a CBOR map");
   }
-  return mapToGrant(raw);
+  const m = raw;
+  assertNoObsoleteWireKeys(m);
+  return mapToGrant(m);
 }
 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_codec3 = __esm(() => {
+var init_grant_codec5 = __esm(() => {
   init_dist3();
   init_dist3();
 });
@@ -30358,7 +31226,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: decodeGrantPayload3(embedded),
+    grant: decodeGrantPayload5(embedded),
     idtimestampBe8: new Uint8Array(idtimestampBe8)
   };
 }
@@ -30366,7 +31234,7 @@ var IDTIMESTAMP_BYTES3 = 8;
 var init_decode_forestrie_grant_cose = __esm(() => {
   init_sha256();
   init_dist3();
-  init_grant_codec3();
+  init_grant_codec5();
 });
 
 // node_modules/@forestrie/receipt-verify/dist/attach-transparent-statement-receipt.js
@@ -30414,7 +31282,7 @@ async function findGrantLeafInMassif(massifBytes, grant) {
   return index2.findLeafByContentHash(inner);
 }
 var init_find_grant_leaf = __esm(() => {
-  init_dist9();
+  init_dist11();
   init_grant_commitment();
 });
 
@@ -30489,7 +31357,7 @@ var init_erc1271_verify_hooks = __esm(() => {
 });
 
 // node_modules/@forestrie/chain-rpc/dist/index.js
-var init_dist10 = __esm(() => {
+var init_dist12 = __esm(() => {
   init_substitute_env_templates();
   init_supported_chains_config();
   init_erc1271_verify_hooks();
@@ -30580,17 +31448,17 @@ 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_dist9();
-  init_dist10();
+  init_dist11();
+  init_dist12();
   init_parse_receipt();
 });
 
 // node_modules/@forestrie/receipt-verify/dist/index.js
-var init_dist11 = __esm(() => {
+var init_dist13 = __esm(() => {
   init_parse_receipt();
   init_build_receipt_offline();
   init_freshen_receipt();
-  init_dist9();
+  init_dist11();
   init_decode_trust_root_from_genesis();
   init_decode_chain_binding_from_genesis();
   init_verify_grant_receipt_offline();
@@ -30601,11 +31469,11 @@ var init_dist11 = __esm(() => {
   init_session_key_endorsement();
   init_verify_endorsed_leaf();
   init_decode_forestrie_grant_cose();
-  init_grant_codec3();
+  init_grant_codec5();
   init_attach_transparent_statement_receipt();
   init_grant_commitment();
   init_find_grant_leaf();
-  init_dist9();
+  init_dist11();
   init_checkpoint_chain();
   init_known_accumulator();
 });
@@ -30632,6 +31500,11 @@ async function deriveCheckpointReceipt(input) {
   if (sealedSize === null || sealedSize <= 0n) {
     fail3("parse", "checkpoint_missing_sealed_size", "checkpoint carries no consistency proof (cannot determine sealed size)");
   }
+  try {
+    checkpointConsistencyProof(checkpointBytes);
+  } catch (err) {
+    fail3("parse", "checkpoint_consistency_invalid", `checkpoint consistency proofs do not agree with its signed size: ${errorMessage2(err)}`);
+  }
   let store;
   try {
     store = openMassifNodeStore(massifBytes);
@@ -30684,7 +31557,7 @@ async function deriveCheckpointReceipt(input) {
 }
 var CreateReceiptFailure;
 var init_create_receipt_derive = __esm(() => {
-  init_dist11();
+  init_dist13();
   CreateReceiptFailure = class CreateReceiptFailure extends Error {
     stage;
     reason;
@@ -30782,8 +31655,8 @@ function errorMessage3(err) {
 }
 var CompleteGrantFailure;
 var init_complete_grant_derive = __esm(() => {
-  init_dist11();
-  init_dist7();
+  init_dist13();
+  init_dist8();
   init_register_grant_complete();
   init_create_receipt_derive();
   CompleteGrantFailure = class CompleteGrantFailure extends Error {
@@ -31041,7 +31914,7 @@ function loadCreateReceiptArtifacts(options) {
   return { massifBytes, checkpointBytes, leaf };
 }
 var init_create_receipt_inputs = __esm(() => {
-  init_dist11();
+  init_dist13();
 });
 
 // src/lib/verify-inputs.ts
@@ -31077,7 +31950,7 @@ function decodeGrantBytes(bytes, entryId, source) {
       idtimestampBe8: entryId !== undefined ? entryIdHexToIdtimestampBe82(entryId) : decoded.idtimestampBe8
     };
   } catch {}
-  const grant = decodeGrantPayload3(bytes);
+  const grant = decodeGrantPayload5(bytes);
   if (entryId === undefined) {
     throw new Error(`${source} is a raw grant payload (no embedded idtimestamp) — pass --entry-id`);
   }
@@ -31101,7 +31974,7 @@ function loadVerifyArtifacts(options) {
   return { genesisCbor, receiptCbor, grant, idtimestampBe8 };
 }
 var init_verify_inputs = __esm(() => {
-  init_dist11();
+  init_dist13();
 });
 
 // src/lib/bytes.ts
@@ -31194,7 +32067,7 @@ function checkReceiptAnchoredToCheckpointChain(opts) {
 }
 var init_verify_checkpoint_chain = __esm(() => {
   init_dist3();
-  init_dist11();
+  init_dist13();
 });
 
 // src/lib/verify-known-accumulator.ts
@@ -31273,7 +32146,7 @@ async function checkReceiptAnchoredToSnapshot(opts) {
   };
 }
 var init_verify_known_accumulator = __esm(() => {
-  init_dist11();
+  init_dist13();
 });
 
 // src/lib/verify-anchored.ts
@@ -31435,10 +32308,10 @@ async function checkReceiptAnchored(opts) {
 }
 var LOG_STATE_SELECTOR = "0xeecac1b7";
 var init_verify_anchored = __esm(() => {
-  init_dist10();
+  init_dist12();
   init_dist3();
-  init_dist9();
   init_dist11();
+  init_dist13();
 });
 
 // src/lib/verify-eventscan.ts
@@ -31539,7 +32412,7 @@ function selectPublishedAtBlock(published, atBlock) {
 }
 var CHECKPOINT_PUBLISHED_TOPIC0 = "0x156942b408823cb05a16027962ea485fa7171d99779ee04094280b2569482426";
 var init_verify_eventscan = __esm(() => {
-  init_dist10();
+  init_dist12();
   init_verify_anchored();
 });
 
@@ -31582,7 +32455,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)
     }
   };
 }
@@ -31622,7 +32496,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; }",
@@ -31631,6 +32505,14 @@ var init_decode_checkpoint_calldata = __esm(() => {
 });
 
 // src/lib/checkpoint-provider.ts
+function singleProofChain(p, signedTreeSize2 = p.treeSize2) {
+  return {
+    proofs: [p],
+    treeSize1: p.treeSize1,
+    treeSize2: p.treeSize2,
+    signedTreeSize2
+  };
+}
 async function foldProofChain(proofs, opts = {}) {
   let accumulator = opts.accumulatorFrom ?? [];
   let expectedBase;
@@ -31648,13 +32530,16 @@ 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, signedTreeSize2: p.treeSize2 }, accumulator, expectedBase);
+    const signed = opts.signedSizes?.[i];
+    accumulator = await computeCheckpointAccumulator(singleProofChain(p, signed), accumulator, expectedBase);
     const link = {
       treeSize1: p.treeSize1,
       treeSize2: p.treeSize2,
       accumulator,
       proof: p
     };
+    if (signed !== undefined)
+      link.signedTreeSize2 = signed;
     const seal = opts.seals?.[i];
     if (seal !== undefined)
       link.seal = seal;
@@ -31667,16 +32552,26 @@ async function foldProofChain(proofs, opts = {}) {
   return links;
 }
 async function sthCheckpointChain(checkpoints, opts = {}) {
-  const proofs = checkpoints.map((bytes) => checkpointConsistencyProof(bytes));
-  const seals = checkpoints.map((bytes) => ({
-    kind: "sth",
-    checkpointBytes: bytes
-  }));
+  const proofs = [];
+  const seals = [];
+  const sourceRefs = [];
+  const signedSizes = [];
+  checkpoints.forEach((bytes, i) => {
+    const chain = checkpointConsistencyProof(bytes);
+    chain.proofs.forEach((step, j) => {
+      const last = j === chain.proofs.length - 1;
+      proofs.push(step);
+      seals.push(last ? { kind: "sth", checkpointBytes: bytes } : undefined);
+      signedSizes.push(last ? chain.signedTreeSize2 : undefined);
+      sourceRefs.push(opts.sourceRefs?.[i]);
+    });
+  });
   return foldProofChain(proofs, {
     seals,
+    signedSizes,
     ...opts.accumulatorFrom !== undefined ? { accumulatorFrom: opts.accumulatorFrom } : {},
     ...opts.accumulatorFromSize !== undefined ? { accumulatorFromSize: opts.accumulatorFromSize } : {},
-    ...opts.sourceRefs !== undefined ? { sourceRefs: opts.sourceRefs } : {}
+    ...opts.sourceRefs !== undefined ? { sourceRefs } : {}
   });
 }
 async function mapBounded(items, limit, fn) {
@@ -31756,7 +32651,7 @@ async function calldataCheckpointChain(opts) {
   return links;
 }
 var init_checkpoint_provider = __esm(() => {
-  init_dist11();
+  init_dist13();
   init_verify_eventscan();
   init_decode_checkpoint_calldata();
 });
@@ -31774,10 +32669,7 @@ async function emitFreshened(opts) {
   const result = await freshenReceipt({
     oldReceiptBytes: opts.oldReceiptBytes,
     leafValue: opts.leafValue,
-    consistencyProofs: opts.links.map((l) => ({
-      ...l.proof,
-      signedTreeSize2: l.proof.treeSize2
-    })),
+    consistencyProofs: opts.links.map((l) => singleProofChain(l.proof, l.signedTreeSize2)),
     latestCheckpointBytes: opts.latestCheckpointBytes
   });
   let knownAccumulatorMatched;
@@ -31816,7 +32708,7 @@ async function freshenFromSthChain(opts) {
     leafValue,
     links,
     latestCheckpointBytes: opts.checkpoints[opts.checkpoints.length - 1],
-    sourceRefs: [...opts.sourceRefs ?? []],
+    sourceRefs: links.map((l) => l.sourceRef ?? ""),
     knownAccumulator: opts.knownAccumulator
   });
 }
@@ -31841,7 +32733,7 @@ async function freshenFromCalldataChain(opts) {
   });
 }
 var init_resolve_receipt_freshen = __esm(() => {
-  init_dist11();
+  init_dist13();
   init_checkpoint_provider();
   init_verify_anchored();
 });
@@ -31929,7 +32821,7 @@ async function verifyChainAnchored(input, deps = defaultDeps) {
 }
 var ChainVerifyFailure, defaultDeps;
 var init_create_receipt_chain_verify = __esm(() => {
-  init_dist11();
+  init_dist13();
   init_verify_anchored();
   ChainVerifyFailure = class ChainVerifyFailure extends Error {
     stage;
@@ -32275,7 +33167,7 @@ var CHAIN_EXIT_CODE, ERROR_CODES2, CHAIN_OUTCOME_NARRATION;
 var init_create_receipt = __esm(() => {
   init_create_receipt_derive();
   init_create_receipt_inputs();
-  init_dist11();
+  init_dist13();
   init_verify_inputs();
   init_verify_checkpoint_chain();
   init_verify_known_accumulator();
@@ -32700,11 +33592,11 @@ var init_decode_receipt_labels = __esm(() => {
     [CWT_CLAIMS_LABEL, { name: "CWT claims", note: "RFC 9597" }],
     [
       VDS_LABEL,
-      { name: "verifiable data structure", note: "COSE receipts (draft)" }
+      { name: "verifiable data structure", note: "COSE receipts (RFC 9942)" }
     ],
     [
       VERIFIABLE_PROOFS_LABEL,
-      { name: "verifiable proofs", note: "COSE receipts (draft)" }
+      { name: "verifiable proofs", note: "COSE receipts (RFC 9942)" }
     ],
     [
       DELEGATION_CERT_LABEL3,
@@ -32764,7 +33656,7 @@ var init_decode_receipt_labels = __esm(() => {
     [-65799, "KS256 (secp256k1 + Keccak-256, forestrie private-use)"],
     [
       -65800,
-      "ES256-WebAuthn (forestrie private-use; delegation proofs and " + "certificates only, never checkpoint-signing)"
+      "ES256-WebAuthn (forestrie private-use; delegation proofs, certificates " + "and session-key endorsements, never checkpoint-signing)"
     ]
   ]);
   VDS_NAMES = new Map([
@@ -32977,7 +33869,7 @@ function decodeReceipt(receiptBytes) {
 }
 var DecodeReceiptError, HEX;
 var init_decode_receipt_decode = __esm(() => {
-  init_dist11();
+  init_dist13();
   init_dist3();
   init_decode_receipt_cbor();
   init_decode_receipt_labels();
@@ -33427,7 +34319,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_dist9();
+  init_dist11();
 });
 
 // src/lib/verify-report.ts
@@ -33929,7 +34821,7 @@ async function runVerifyGrant(out, options) {
 }
 var VERIFY_ERROR_CODES;
 var init_verify = __esm(() => {
-  init_dist11();
+  init_dist13();
   init_verify_eventscan();
   init_verify_anchored();
   init_verify_checkpoint_chain();
@@ -34074,7 +34966,7 @@ var init_verify3 = __esm(() => {
       },
       "known-log-key": {
         type: "string",
-        description: "Caller-known log OWNER key (the delegation issuer), base64 x||y (64 bytes) (env KNOWN_LOG_KEY). Offline signer-provenance anchor that replaces --genesis; asserts (does not prove) the key-to-log binding — --genesis derives it from the grant chain, while the accumulator anchors (--known-accumulator / --rpc-url) supply split-view (freshness is a weaker, separate axis bearing only on coverage). See https://github.com/forestrie/protocol/blob/main/spec/receipt-trust-model.md",
+        description: "Caller-known log OWNER key (the delegation issuer), base64 x||y (64 bytes) (env KNOWN_LOG_KEY). Offline signer-provenance anchor that replaces --genesis; asserts (does not prove) the key-to-log binding — --genesis roots it in the forest genesis document's bootstrap key (the root log, or a delegation directly under it), while the accumulator roots (--known-accumulator / --rpc-url) supply split-view (freshness is a weaker, separate axis bearing only on coverage). See https://github.com/forestrie/protocol/blob/main/spec/receipt-trust-model.md",
         valueHint: "base64"
       },
       receipt: {
@@ -34163,7 +35055,7 @@ var init_verify_grant = __esm(() => {
       },
       "known-log-key": {
         type: "string",
-        description: "Caller-known log OWNER key (the delegation issuer), base64 x||y (64 bytes) (env KNOWN_LOG_KEY). Offline signer-provenance anchor that replaces --genesis; asserts (does not prove) the key-to-log binding — --genesis derives it from the grant chain, while the accumulator anchors (--known-accumulator / --rpc-url) supply split-view (freshness is a weaker, separate axis bearing only on coverage). See https://github.com/forestrie/protocol/blob/main/spec/receipt-trust-model.md",
+        description: "Caller-known log OWNER key (the delegation issuer), base64 x||y (64 bytes) (env KNOWN_LOG_KEY). Offline signer-provenance anchor that replaces --genesis; asserts (does not prove) the key-to-log binding — --genesis roots it in the forest genesis document's bootstrap key (the root log, or a delegation directly under it), while the accumulator roots (--known-accumulator / --rpc-url) supply split-view (freshness is a weaker, separate axis bearing only on coverage). See https://github.com/forestrie/protocol/blob/main/spec/receipt-trust-model.md",
         valueHint: "base64"
       },
       receipt: {
@@ -34337,7 +35229,7 @@ async function runFetchAccumulator(out, options) {
 }
 var LOG_STATE_SELECTOR2 = "0xeecac1b7";
 var init_fetch_accumulator = __esm(() => {
-  init_dist10();
+  init_dist12();
   init_verify_anchored();
   init_verify_known_accumulator();
   init_verify_eventscan();
@@ -34558,7 +35450,7 @@ init_dist();
 // package.json
 var package_default = {
   name: "@forestrie/forestrie-cli",
-  version: "0.9.0",
+  version: "0.10.0",
   description: "forestrie — participant CLI for forestrie transparency logs (SCITT / COSE receipts)",
   keywords: [
     "forestrie",
@@ -34626,10 +35518,10 @@ var package_default = {
     "@forestrie/cli-kit": "^0.1.1",
     "@forestrie/delegation-cose": "^0.3.2",
     "@forestrie/deploy-core": "^0.7.1",
-    "@forestrie/encoding": "^0.8.0",
+    "@forestrie/encoding": "^0.9.1",
     "@forestrie/grant-builder": "^0.5.0",
-    "@forestrie/merklelog": "^0.4.0",
-    "@forestrie/receipt-verify": "^2.0.0",
+    "@forestrie/merklelog": "^0.5.0",
+    "@forestrie/receipt-verify": "^3.0.1",
     "@forestrie/scrapi-client": "^0.2.2",
     citty: "^0.2.2",
     viem: "^2.31.0"