@mnemom/mnemom 0.17.35 → 0.17.36

package/node_modules/@mnemom/aip-verifier/dist/index.cjs

@@ -0,0 +1,971 @@
+'use strict';
+
+var ed25519 = require('@noble/ed25519');
+var sha2_js = require('@noble/hashes/sha2.js');
+var utils_js = require('@noble/hashes/utils.js');
+
+// src/crypto.ts
+function base64ToUint8(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function hexToUint8(hex) {
+  return utils_js.hexToBytes(hex);
+}
+function sha256Hex(input) {
+  return utils_js.bytesToHex(sha2_js.sha256(utils_js.utf8ToBytes(input)));
+}
+async function verifySignature(signature, payload, publicKey) {
+  try {
+    const sigBytes = base64ToUint8(signature);
+    const msgBytes = utils_js.utf8ToBytes(payload);
+    return await ed25519.verifyAsync(sigBytes, msgBytes, publicKey);
+  } catch {
+    return false;
+  }
+}
+function verifyMerkleProof(leafHash, siblings, expectedRoot) {
+  let current = leafHash;
+  for (const sibling of siblings) {
+    const pair = sibling.position === "left" ? sibling.hash + current : current + sibling.hash;
+    current = sha256Hex(pair);
+  }
+  return current === expectedRoot;
+}
+function computeChainHash(prevChainHash, checkpointId, verdict, thinkingBlockHash, inputCommitment, timestamp) {
+  const prev = prevChainHash ?? "genesis";
+  const preimage = [
+    prev,
+    checkpointId,
+    verdict,
+    thinkingBlockHash,
+    inputCommitment,
+    timestamp
+  ].join("|");
+  return sha256Hex(preimage);
+}
+
+// src/verify.ts
+async function verifyCertificate(certificate, options) {
+  const publicKey = resolvePublicKey(options.publicKey);
+  const signature = await checkSignature(certificate, publicKey);
+  const chain = checkChain(certificate);
+  const merkle = checkMerkle(certificate, options.merkleRoot);
+  const verdictDerivation = checkVerdictDerivation(
+    certificate,
+    options.verdictDerivationImageId
+  );
+  const allValid = signature.valid && chain.valid && (merkle === null || merkle.valid) && (verdictDerivation === null || verdictDerivation.valid);
+  return {
+    valid: allValid,
+    checks: { signature, chain, merkle, verdict_derivation: verdictDerivation },
+    certificate_id: certificate.certificate_id,
+    verified_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function resolvePublicKey(key) {
+  if (typeof key === "string") {
+    return hexToUint8(key);
+  }
+  return key;
+}
+async function checkSignature(cert, publicKey) {
+  const { value, signed_payload } = cert.proofs.signature;
+  const valid = await verifySignature(value, signed_payload, publicKey);
+  return {
+    valid,
+    details: valid ? "Ed25519 signature is valid" : "Ed25519 signature verification failed"
+  };
+}
+function checkChain(cert) {
+  const expected = computeChainHash(
+    cert.proofs.chain.prev_chain_hash,
+    cert.subject.checkpoint_id,
+    cert.claims.verdict,
+    cert.input_commitments.thinking_block_hash,
+    cert.input_commitments.combined_commitment,
+    cert.issued_at
+  );
+  const valid = expected === cert.proofs.chain.chain_hash;
+  return {
+    valid,
+    details: valid ? "Chain hash matches recomputed value" : `Chain hash mismatch: expected ${expected}, got ${cert.proofs.chain.chain_hash}`
+  };
+}
+function checkMerkle(cert, merkleRoot) {
+  if (cert.proofs.merkle === null) {
+    return null;
+  }
+  if (merkleRoot === void 0) {
+    return null;
+  }
+  const { leaf_hash, inclusion_proof, root } = cert.proofs.merkle;
+  if (root !== merkleRoot) {
+    return {
+      valid: false,
+      details: `Merkle root mismatch: certificate claims ${root}, expected ${merkleRoot}`
+    };
+  }
+  const valid = verifyMerkleProof(leaf_hash, inclusion_proof, merkleRoot);
+  return {
+    valid,
+    details: valid ? "Merkle inclusion proof is valid" : "Merkle inclusion proof verification failed"
+  };
+}
+function checkVerdictDerivation(cert, expectedImageId) {
+  const proof = cert.proofs.verdict_derivation;
+  if (proof === null || proof === void 0) {
+    return null;
+  }
+  if (!["SP1-STARK", "RISC-Zero-STARK"].includes(proof.method)) {
+    return {
+      valid: false,
+      details: `Unknown verdict derivation method: ${proof.method}`
+    };
+  }
+  if (!proof.journal || !proof.image_id || !proof.receipt) {
+    return {
+      valid: false,
+      details: "Verdict derivation proof is missing required fields (journal, image_id, or receipt)"
+    };
+  }
+  if (expectedImageId !== void 0 && proof.image_id !== expectedImageId) {
+    return {
+      valid: false,
+      details: `Image ID mismatch: proof has ${proof.image_id}, expected ${expectedImageId}`
+    };
+  }
+  let journal;
+  try {
+    journal = JSON.parse(proof.journal);
+  } catch {
+    return {
+      valid: false,
+      details: "Failed to parse verdict derivation journal as JSON"
+    };
+  }
+  if (journal.verdict !== void 0) {
+    const certVerdict = cert.claims.verdict;
+    if (journal.verdict !== certVerdict) {
+      return {
+        valid: false,
+        details: `Journal verdict "${journal.verdict}" does not match certificate verdict "${certVerdict}"`
+      };
+    }
+  }
+  if (journal.thinking_hash !== void 0) {
+    const certThinkingHash = cert.input_commitments.thinking_block_hash;
+    if (journal.thinking_hash !== certThinkingHash) {
+      return {
+        valid: false,
+        details: `Journal thinking_hash does not match certificate input_commitments.thinking_block_hash`
+      };
+    }
+  }
+  if (journal.card_hash !== void 0) {
+    const certCardHash = cert.input_commitments.card_hash;
+    if (journal.card_hash !== certCardHash) {
+      return {
+        valid: false,
+        details: `Journal card_hash does not match certificate input_commitments.card_hash`
+      };
+    }
+  }
+  if (journal.values_hash !== void 0) {
+    const certValuesHash = cert.input_commitments.values_hash;
+    if (journal.values_hash !== certValuesHash) {
+      return {
+        valid: false,
+        details: `Journal values_hash does not match certificate input_commitments.values_hash`
+      };
+    }
+  }
+  return {
+    valid: true,
+    details: "Verdict derivation proof is structurally valid (STARK receipt verification deferred to server)"
+  };
+}
+
+// src/canonical.ts
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  const record = value;
+  const entries = Object.keys(record).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(record[k])}`);
+  return `{${entries.join(",")}}`;
+}
+function base64urlToUint8(input) {
+  if (typeof input !== "string" || !/^[A-Za-z0-9_-]*={0,2}$/.test(input)) {
+    throw new Error("not base64url");
+  }
+  const b64 = input.replace(/-/g, "+").replace(/_/g, "/").replace(/=+$/, "");
+  const padded = b64 + "===".slice(0, (4 - b64.length % 4) % 4);
+  const binary = atob(padded);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+
+// src/statements.ts
+var STATEMENT_TYPES = [
+  "AAP-ConductRecord/v1",
+  "AAP-PRRecord/v1",
+  "AAP-Outcome/v1",
+  "AAP-ShareCard/v1"
+];
+var BUNDLE_TYP = "AAP-RecordBundle/v1";
+var CARD_LINE_CLASSES = ["measured", "verdict", "outcome"];
+var REASONS = {
+  not_an_object: "not_an_object",
+  unknown_typ: "unknown_typ",
+  unsupported_alg: "unsupported_alg",
+  signing_key_id_missing: "signing_key_id_missing",
+  signature_missing: "signature_missing",
+  signature_malformed: "signature_malformed",
+  key_not_found: "key_not_found",
+  key_not_ed25519: "key_not_ed25519",
+  signature_invalid: "signature_invalid",
+  bundle_not_an_object: "bundle_not_an_object",
+  bundle_unknown_typ: "bundle_unknown_typ",
+  bundle_statements_missing: "bundle_statements_missing",
+  digest_malformed: "digest_malformed",
+  linked_statement_wrong_typ: "linked_statement_wrong_typ",
+  card_line_class_not_allowed: "card_line_class_not_allowed",
+  card_verdict_without_coverage: "card_verdict_without_coverage"
+};
+var FLAGS = {
+  card_hash_not_recorded: "card hash not recorded",
+  card_not_bound: "card not bound",
+  linked_statement_not_in_bundle: "linked statement not in bundle"
+};
+
+// src/verify-record.ts
+var DIGEST_RE = /^[0-9a-f]{64}$/;
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function statementCommitment(statement) {
+  const { signature: _signature, ...rest } = statement;
+  return canonicalJson(rest);
+}
+function statementDigest(statement) {
+  return utils_js.bytesToHex(sha2_js.sha256(utils_js.utf8ToBytes(statementCommitment(statement))));
+}
+function selectKey(jwks, kid) {
+  const keys = isObject(jwks) && Array.isArray(jwks.keys) ? jwks.keys : [];
+  const jwk = keys.find((k) => isObject(k) && k.kid === kid);
+  if (!jwk) return { reason: REASONS.key_not_found };
+  if (jwk.alg !== "EdDSA" || jwk.kty !== "OKP" || jwk.crv !== "Ed25519" || typeof jwk.x !== "string") {
+    return { reason: REASONS.key_not_ed25519 };
+  }
+  let key;
+  try {
+    key = base64urlToUint8(jwk.x);
+  } catch {
+    return { reason: REASONS.key_not_ed25519 };
+  }
+  if (key.length !== 32) return { reason: REASONS.key_not_ed25519 };
+  return { key };
+}
+function checkpointFlags(checkpoints) {
+  if (!Array.isArray(checkpoints)) return [];
+  const flags = [];
+  for (const c of checkpoints) {
+    if (!isObject(c)) continue;
+    const subject = typeof c.checkpoint_id === "string" ? c.checkpoint_id : "<no checkpoint_id>";
+    if (typeof c.card_hash !== "string" || c.card_hash.length === 0) {
+      flags.push({ flag: FLAGS.card_hash_not_recorded, subject });
+    }
+    const bound = typeof c.combined_commitment === "string" && c.combined_commitment.length > 0 && typeof c.commitment_signature === "string" && c.commitment_signature.length > 0;
+    if (!bound) flags.push({ flag: FLAGS.card_not_bound, subject });
+  }
+  return flags;
+}
+function shareCardReasons(lines) {
+  if (!Array.isArray(lines)) return [];
+  const reasons = [];
+  for (const line of lines) {
+    if (!isObject(line) || !CARD_LINE_CLASSES.includes(line.class)) {
+      reasons.push(REASONS.card_line_class_not_allowed);
+      continue;
+    }
+    if (line.class === "verdict") {
+      const cov = line.coverage;
+      const ok = isObject(cov) && Number.isInteger(cov.judged) && Number.isInteger(cov.total) && cov.judged >= 0 && cov.total >= cov.judged;
+      if (!ok) reasons.push(REASONS.card_verdict_without_coverage);
+    }
+  }
+  return [...new Set(reasons)];
+}
+function digestFieldsOf(statement) {
+  const out = [];
+  if (statement.previous_digest !== void 0 && statement.previous_digest !== null) {
+    out.push(statement.previous_digest);
+  }
+  if (statement.pr_record_digest !== void 0) out.push(statement.pr_record_digest);
+  if (statement.source_digest !== void 0) out.push(statement.source_digest);
+  if (statement.conduct_digests !== void 0) {
+    if (Array.isArray(statement.conduct_digests)) out.push(...statement.conduct_digests);
+    else out.push(null);
+  }
+  return out;
+}
+async function verifyStatement(statement, jwks) {
+  const fail = (reasons2, partial = {}) => ({
+    valid: false,
+    typ: null,
+    digest: null,
+    signing_key_id: null,
+    flags: [],
+    ...partial,
+    reasons: reasons2
+  });
+  if (!isObject(statement)) return fail([REASONS.not_an_object]);
+  const typ = typeof statement.typ === "string" ? statement.typ : null;
+  const digest = statementDigest(statement);
+  const kid = typeof statement.signing_key_id === "string" ? statement.signing_key_id : null;
+  const base = { typ, digest, signing_key_id: kid };
+  if (!typ || !STATEMENT_TYPES.includes(typ)) {
+    return fail([REASONS.unknown_typ], base);
+  }
+  if (statement.alg !== void 0 && statement.alg !== "EdDSA") {
+    return fail([REASONS.unsupported_alg], base);
+  }
+  if (!kid) return fail([REASONS.signing_key_id_missing], base);
+  if (typeof statement.signature !== "string" || statement.signature.length === 0) {
+    return fail([REASONS.signature_missing], base);
+  }
+  let sig;
+  try {
+    sig = base64urlToUint8(statement.signature);
+  } catch {
+    return fail([REASONS.signature_malformed], base);
+  }
+  if (sig.length !== 64) return fail([REASONS.signature_malformed], base);
+  const selected = selectKey(jwks, kid);
+  if (!selected.key) return fail([selected.reason], base);
+  let sigOk = false;
+  try {
+    sigOk = await ed25519.verifyAsync(sig, utils_js.utf8ToBytes(statementCommitment(statement)), selected.key);
+  } catch {
+    sigOk = false;
+  }
+  if (!sigOk) return fail([REASONS.signature_invalid], base);
+  const reasons = [];
+  for (const d of digestFieldsOf(statement)) {
+    if (typeof d !== "string" || !DIGEST_RE.test(d)) {
+      reasons.push(REASONS.digest_malformed);
+      break;
+    }
+  }
+  if (typ === "AAP-ShareCard/v1") reasons.push(...shareCardReasons(statement.lines));
+  const flags = typ === "AAP-ConductRecord/v1" ? checkpointFlags(statement.checkpoints) : [];
+  return {
+    valid: reasons.length === 0,
+    typ,
+    digest,
+    signing_key_id: kid,
+    reasons,
+    flags
+  };
+}
+var LINK_TARGETS = {
+  previous_digest: "same",
+  conduct_digests: ["AAP-ConductRecord/v1"],
+  pr_record_digest: ["AAP-PRRecord/v1"],
+  source_digest: ["AAP-ConductRecord/v1", "AAP-PRRecord/v1", "AAP-Outcome/v1"]
+};
+async function verify(input, jwks) {
+  const verified_at = (/* @__PURE__ */ new Date()).toISOString();
+  const result = (valid, reasons2, flags2, statements2) => ({ valid, reasons: reasons2, flags: flags2, statements: statements2, verified_at });
+  if (!isObject(input)) return result(false, [REASONS.bundle_not_an_object], [], []);
+  if (input.typ !== BUNDLE_TYP && Array.isArray(input.statements) && !STATEMENT_TYPES.includes(input.typ)) {
+    return result(false, [REASONS.bundle_unknown_typ], [], []);
+  }
+  if (input.typ !== BUNDLE_TYP) {
+    const one = await verifyStatement(input, jwks);
+    return result(one.valid, one.reasons.map((r) => `0:${r}`), one.flags, [one]);
+  }
+  const rawStatements = Array.isArray(input.statements) ? input.statements : null;
+  if (!rawStatements) {
+    return result(false, [REASONS.bundle_statements_missing], [], []);
+  }
+  const statements = [];
+  for (const s of rawStatements) statements.push(await verifyStatement(s, jwks));
+  const byDigest = /* @__PURE__ */ new Map();
+  statements.forEach((s) => {
+    if (s.digest) byDigest.set(s.digest, s);
+  });
+  const reasons = [];
+  const flags = [];
+  statements.forEach((s, i) => {
+    s.reasons.forEach((r) => reasons.push(`${i}:${r}`));
+    flags.push(...s.flags);
+    const raw = rawStatements[i];
+    if (!s.valid || !isObject(raw)) return;
+    for (const [field, targets] of Object.entries(LINK_TARGETS)) {
+      const value = raw[field];
+      const digests = Array.isArray(value) ? value : [value];
+      for (const d of digests) {
+        if (typeof d !== "string") continue;
+        const linked = byDigest.get(d);
+        if (!linked) {
+          flags.push({ flag: FLAGS.linked_statement_not_in_bundle, subject: d });
+          continue;
+        }
+        const allowed = targets === "same" ? [s.typ] : targets;
+        if (!linked.typ || !allowed.includes(linked.typ)) {
+          reasons.push(`${i}:${REASONS.linked_statement_wrong_typ}`);
+        }
+      }
+    }
+  });
+  return result(reasons.length === 0, reasons, flags, statements);
+}
+
+// src/claim-table.ts
+var CLAIM_CLASSES = ["measured", "verdict", "estimate", "benchmark", "outcome"];
+var SURFACES = ["record_page", "check_summary", "pr_comment", "share_card", "period_card"];
+var CARD_SURFACES = ["share_card", "period_card"];
+var ESTIMATE_FORBIDDEN_SURFACES = ["pr_comment", "share_card", "period_card"];
+var MODES = ["off", "observe", "nudge", "enforce"];
+var MODE_VERBS = {
+  off: "not checked",
+  observe: "flagged",
+  nudge: "flagged, agent nudged",
+  enforce: "stopped"
+};
+var PROTECTION_VERDICTS = ["pass", "warn", "nudge", "quarantine", "block"];
+function protectionVerb(mode, verdict) {
+  if (mode === "off" || verdict === "pass") return null;
+  if (mode === "observe") return MODE_VERBS.observe;
+  if (mode === "nudge") return verdict === "nudge" ? MODE_VERBS.nudge : MODE_VERBS.observe;
+  return verdict === "block" || verdict === "quarantine" ? MODE_VERBS.enforce : MODE_VERBS.observe;
+}
+var GOAL_MODES = ["sealed", "implicit", "off"];
+var CLAIM_TABLE = {
+  commits_recorded: { class: "measured", verb_by_mode: false, money_allowed: false },
+  messages_from_person: { class: "measured", verb_by_mode: false, money_allowed: false },
+  compactions: { class: "measured", verb_by_mode: false, money_allowed: false },
+  tokens_sent_vs_reaching: { class: "measured", verb_by_mode: false, money_allowed: false },
+  peak_context: { class: "measured", verb_by_mode: false, money_allowed: false },
+  model_cost: { class: "measured", verb_by_mode: false, money_allowed: true },
+  mu_cost: { class: "measured", verb_by_mode: false, money_allowed: true },
+  approval: { class: "measured", verb_by_mode: false, money_allowed: false },
+  /** How the goal was set: "sealed contract", "implicit goal" or "not checked" (M7: its own measured line). */
+  goal_mode: { class: "measured", verb_by_mode: false, money_allowed: false },
+  goal: { class: "verdict", verb_by_mode: true, money_allowed: false },
+  /** The protection area's mode when no act is shown: "not checked" under off. */
+  protection_mode: { class: "measured", verb_by_mode: false, money_allowed: false },
+  protection: { class: "verdict", verb_by_mode: true, money_allowed: false },
+  autonomy: { class: "measured", verb_by_mode: false, money_allowed: false },
+  savings_estimate: {
+    class: "estimate",
+    verb_by_mode: false,
+    money_allowed: true,
+    surfaces: ["record_page", "check_summary"]
+  },
+  benchmark: { class: "benchmark", verb_by_mode: false, money_allowed: false },
+  outcome: { class: "outcome", verb_by_mode: false, money_allowed: false }
+};
+function isClaimField(field) {
+  return typeof field === "string" && Object.prototype.hasOwnProperty.call(CLAIM_TABLE, field);
+}
+var LINE_KEY_FIELDS = {
+  "cost.model": "model_cost",
+  "cost.mu": "mu_cost",
+  "goal.mode": "goal_mode",
+  "goal.verdict": "goal",
+  "protection.mode": "protection_mode",
+  "people.messages": "messages_from_person",
+  "context.compactions": "compactions"
+};
+var PROTECTION_ACT_KEY = /^protection\.act\.\d+$/;
+function fieldForLineKey(key) {
+  if (typeof key !== "string") return void 0;
+  if (PROTECTION_ACT_KEY.test(key)) return "protection";
+  return Object.prototype.hasOwnProperty.call(LINE_KEY_FIELDS, key) ? LINE_KEY_FIELDS[key] : void 0;
+}
+
+// src/claim-lint.ts
+var LINT_RULES = {
+  one_class_per_line: "one_class_per_line",
+  forbidden_word: "forbidden_word",
+  money_on_goal_or_protection: "money_on_goal_or_protection",
+  implicit_goal_sealed: "implicit_goal_sealed",
+  goal_off_not_checked: "goal_off_not_checked",
+  estimate_on_forbidden_surface: "estimate_on_forbidden_surface",
+  verb_mismatch: "verb_mismatch",
+  enforce_without_tool_name: "enforce_without_tool_name",
+  tool_name_on_card: "tool_name_on_card",
+  tool_arguments_shown: "tool_arguments_shown",
+  trust_claim: "trust_claim",
+  savings_percentage: "savings_percentage",
+  benchmark_not_published: "benchmark_not_published",
+  verdict_without_coverage: "verdict_without_coverage",
+  card_class_not_allowed: "card_class_not_allowed",
+  period_card_without_revert: "period_card_without_revert",
+  field_not_on_surface: "field_not_on_surface",
+  provisional_mu_on_card: "provisional_mu_on_card",
+  provisional_mu_off_cost_line: "provisional_mu_off_cost_line",
+  unknown_surface: "unknown_surface"
+};
+function clauseHas(text, rule) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(rule.tokens)) {
+    const kind = Object.entries(m.groups ?? {}).find(([, v]) => v !== void 0)?.[0];
+    if (kind === void 0) continue;
+    if (kind === "brk") {
+      seen.clear();
+      continue;
+    }
+    if (rule.alone?.includes(kind)) return true;
+    if (rule.pairs.some(([first, then]) => then === kind && seen.has(first))) return true;
+    seen.add(kind);
+  }
+  return false;
+}
+var FORBIDDEN_WORD = /\b(safe|safely|unsafe|correct|correctly|incorrect|prevent|prevents|prevented|preventing|prevention)\b/i;
+var MONEY = /(?:\$|€|£|¥)\s?\d|\b(?<!\d,+)\d[\d,]*(?:\.\d+)?\s?(?:USD|EUR|GBP|dollars?|cents?)\b/i;
+var SEALED = /\bsealed\b/i;
+var ESTIMATE_WORDS = /\b(estimate[ds]?|estimation|saving|savings|saved|would have cost|counterfactual)\b/i;
+var TRUST_CLAIM = /\b(minutes?|seconds?|hours?)\s+to\s+trust\b|\btrust(ed)?\s+in\s+(under\s+|about\s+)?\d+\s*(minutes?|seconds?|hours?|min|s|h)\b|\breview[- ]time\b|\btime\s+to\s+review\b|\bwithout\s+re-?check(ing)?\b|\bno\s+need\s+to\s+(re-?check|review)\b|\btrust(ed)?\s+without\b/i;
+var SAVINGS_PERCENTAGE = {
+  tokens: /\d+(?<percent>(?:\.\d+)?\s?%)?|\b(?<less>less)\b|\b(?<saving>sav(?:e[sd]?|ings?)|cheaper|reduction|reduced)\b|(?<brk>[.\n])/gi,
+  pairs: [
+    ["percent", "saving"],
+    ["percent", "less"],
+    ["saving", "percent"]
+  ]
+};
+var REVERT = /\brevert(s|ed)?\b/i;
+var PROVISIONAL_MU = {
+  tokens: /(?<approx>(?:≈|~|\bapprox(?:\.|imately)?\b|\babout\b)\s*\d[\d,]*(?:\.\d+)?\s*(?:mmu\b|mu\b|μ|µ))|\d[\d,]*(?<amount>(?:\.\d+)?\s*(?:mmu\b|mu\b|μ|µ))?|\b(?<pending>pending)\b|(?<brk>[.\n])/gi,
+  alone: ["approx"],
+  pairs: [
+    ["amount", "pending"],
+    ["pending", "amount"]
+  ]
+};
+var NOT_CHECKED = /^not checked$/i;
+var COVERAGE_IN_TEXT = /\b(\d+)\s+of\s+(\d+)\s+turns\s+judged\b/i;
+var MODE_VERB_REGEX = {
+  off: NOT_CHECKED,
+  observe: /\bflagged\b/i,
+  nudge: /\bflagged, agent nudged\b/i,
+  enforce: /\bstopped\b/i
+};
+var OTHER_MODE_VERBS = {
+  off: [/\bflagged\b/i, /\bnudged\b/i, /\bstopped\b/i],
+  observe: [/\bnudged\b/i, /\bstopped\b/i],
+  nudge: [/\bstopped\b/i],
+  enforce: [/\bflagged\b/i, /\bnudged\b/i]
+};
+function isObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function coverageObjectValid(cov) {
+  return isObject2(cov) && Number.isInteger(cov.judged) && Number.isInteger(cov.total) && cov.judged >= 0 && cov.total >= cov.judged;
+}
+function coverageShown(line) {
+  const cov = line.coverage;
+  if (cov !== void 0) return coverageObjectValid(cov);
+  const m = COVERAGE_IN_TEXT.exec(line.text);
+  return m !== null && Number(m[2]) >= Number(m[1]);
+}
+function expectedVerb(mode, verdict) {
+  if (mode === "off") return "off";
+  if (verdict === void 0) return mode === "observe" ? "observe" : void 0;
+  if (!PROTECTION_VERDICTS.includes(verdict)) return void 0;
+  const verb = protectionVerb(mode, verdict);
+  return MODES.find((m) => MODE_VERBS[m] === verb);
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function argumentsAppear(text, args) {
+  if (args === void 0 || args === null) return false;
+  const needles = [];
+  const walk = (v) => {
+    if (typeof v === "string") {
+      if (v.length >= 3) needles.push(v);
+    } else if (typeof v === "number" || typeof v === "boolean") {
+      needles.push(String(v));
+    } else if (Array.isArray(v)) {
+      v.forEach(walk);
+    } else if (isObject2(v)) {
+      Object.values(v).forEach(walk);
+    }
+  };
+  walk(args);
+  if (needles.length === 0) return false;
+  try {
+    needles.push(JSON.stringify(args));
+  } catch {
+  }
+  return needles.some((n) => n.length > 0 && text.includes(n));
+}
+function lintLine(surface, line, index, out) {
+  const push = (rule) => {
+    out.push({ rule, line: index, text: isObject2(line) && typeof line.text === "string" ? line.text : "" });
+  };
+  if (!isObject2(line) || typeof line.text !== "string" || typeof line.class !== "string") {
+    push(LINT_RULES.one_class_per_line);
+    return;
+  }
+  const text = line.text;
+  const onCard = CARD_SURFACES.includes(surface);
+  const field = line.field !== void 0 ? line.field : fieldForLineKey(line.key);
+  const cls = line.class;
+  if (!CLAIM_CLASSES.includes(cls)) {
+    push(LINT_RULES.one_class_per_line);
+  } else if (field !== void 0) {
+    if (!isClaimField(field)) {
+      push(LINT_RULES.one_class_per_line);
+    } else {
+      const entry = CLAIM_TABLE[field];
+      if (entry.class !== cls) push(LINT_RULES.one_class_per_line);
+      if (entry.surfaces && !entry.surfaces.includes(surface)) {
+        push(LINT_RULES.field_not_on_surface);
+      }
+    }
+  }
+  if (cls !== "estimate" && ESTIMATE_WORDS.test(text)) push(LINT_RULES.one_class_per_line);
+  if (FORBIDDEN_WORD.test(text)) push(LINT_RULES.forbidden_word);
+  const isGoal = field === "goal" || field === "goal_mode";
+  const isProtection = field === "protection" || field === "protection_mode";
+  if ((isGoal || isProtection) && MONEY.test(text)) push(LINT_RULES.money_on_goal_or_protection);
+  if (field !== void 0 && isClaimField(field) && !CLAIM_TABLE[field].money_allowed) {
+    if (!isGoal && !isProtection && MONEY.test(text)) push(LINT_RULES.one_class_per_line);
+  }
+  if (isGoal) {
+    if (line.goal_mode === "implicit" && SEALED.test(text)) push(LINT_RULES.implicit_goal_sealed);
+    if (line.goal_mode === "off" && !NOT_CHECKED.test(text.trim())) push(LINT_RULES.goal_off_not_checked);
+  }
+  if (cls === "estimate" || ESTIMATE_WORDS.test(text)) {
+    if (ESTIMATE_FORBIDDEN_SURFACES.includes(surface)) push(LINT_RULES.estimate_on_forbidden_surface);
+  }
+  if (line.mode !== void 0) {
+    const verb = MODES.includes(line.mode) ? expectedVerb(line.mode, line.verdict) : void 0;
+    const name = typeof line.tool_name === "string" ? line.tool_name.trim() : "";
+    const nameShown = name.length > 0 && new RegExp(`(^|[^A-Za-z0-9_])${escapeRegExp(name)}([^A-Za-z0-9_]|$)`).test(text);
+    if (verb === void 0) {
+      push(LINT_RULES.verb_mismatch);
+    } else if (!MODE_VERB_REGEX[verb].test(verb === "off" ? text.trim() : text)) {
+      push(LINT_RULES.verb_mismatch);
+    } else if (OTHER_MODE_VERBS[verb].some((re) => re.test(text))) {
+      push(LINT_RULES.verb_mismatch);
+    } else if (verb !== "enforce" && nameShown && !onCard) {
+      push(LINT_RULES.verb_mismatch);
+    }
+    if (onCard) {
+      if (nameShown) push(LINT_RULES.tool_name_on_card);
+    } else if (verb === "enforce" && !nameShown) {
+      push(LINT_RULES.enforce_without_tool_name);
+    }
+  }
+  if (argumentsAppear(text, line.tool_arguments)) push(LINT_RULES.tool_arguments_shown);
+  if (clauseHas(text, PROVISIONAL_MU)) {
+    if (onCard) push(LINT_RULES.provisional_mu_on_card);
+    if (field !== "mu_cost") push(LINT_RULES.provisional_mu_off_cost_line);
+  }
+  if (TRUST_CLAIM.test(text)) push(LINT_RULES.trust_claim);
+  if (clauseHas(text, SAVINGS_PERCENTAGE)) push(LINT_RULES.savings_percentage);
+  if (cls === "benchmark") push(LINT_RULES.benchmark_not_published);
+  if (cls === "verdict") {
+    const covered = onCard ? coverageObjectValid(line.coverage) : field === "protection" || coverageShown(line);
+    if (!covered) push(LINT_RULES.verdict_without_coverage);
+  }
+  if (onCard && cls !== "measured" && cls !== "verdict" && cls !== "outcome") push(LINT_RULES.card_class_not_allowed);
+}
+function lintRendering(rendering) {
+  const violations = [];
+  if (!isObject2(rendering) || !Array.isArray(rendering.lines)) {
+    return { ok: false, violations: [{ rule: LINT_RULES.unknown_surface, line: -1, text: "" }] };
+  }
+  const surface = rendering.surface;
+  if (!SURFACES.includes(surface)) {
+    return { ok: false, violations: [{ rule: LINT_RULES.unknown_surface, line: -1, text: String(surface) }] };
+  }
+  const lines = rendering.lines;
+  lines.forEach((line, i) => lintLine(surface, line, i, violations));
+  if (surface === "period_card") {
+    const hasRevert = lines.some(
+      (l) => isObject2(l) && l.class === "outcome" && typeof l.text === "string" && REVERT.test(l.text)
+    );
+    if (!hasRevert) violations.push({ rule: LINT_RULES.period_card_without_revert, line: -1, text: "" });
+  }
+  return { ok: violations.length === 0, violations };
+}
+function lintRenderings(renderings) {
+  return renderings.map(lintRendering);
+}
+function attachLineContext(lines, goal, protection) {
+  return lines.map((line) => {
+    const out = { class: line.class, key: line.key, text: line.text };
+    if (line.key.startsWith("goal.") && goal) out.goal_mode = goal.mode;
+    if (line.key === "protection.mode") out.mode = "off";
+    const act = /^protection\.act\.(\d+)$/.exec(line.key);
+    if (act && protection) {
+      const entry = protection.acts[Number(act[1])];
+      if (entry) {
+        out.mode = entry.mode;
+        out.verdict = entry.verdict;
+        if (entry.tool_name) out.tool_name = entry.tool_name;
+      }
+    }
+    return out;
+  });
+}
+
+// src/render-estimate.ts
+var ESTIMATE_COUNTING_FLOOR_TOKENS = 2e5;
+var ESTIMATE_DISQUALIFIERS = {
+  not_an_object: "not_an_object",
+  method_not_lower_bound: "method_not_lower_bound",
+  counting_floor_below_200k: "counting_floor_below_200k",
+  not_net_of_mu: "not_net_of_mu",
+  never_shows_loss: "never_shows_loss",
+  value_not_finite: "value_not_finite"
+};
+function isObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function estimateQualifies(estimate) {
+  if (!isObject3(estimate)) return { qualifies: false, reasons: [ESTIMATE_DISQUALIFIERS.not_an_object] };
+  const reasons = [];
+  if (estimate.method !== "lower_bound") reasons.push(ESTIMATE_DISQUALIFIERS.method_not_lower_bound);
+  const floor = estimate.counting_floor_tokens;
+  if (typeof floor !== "number" || !Number.isFinite(floor) || floor < ESTIMATE_COUNTING_FLOOR_TOKENS) {
+    reasons.push(ESTIMATE_DISQUALIFIERS.counting_floor_below_200k);
+  }
+  if (estimate.net_of_mu !== true) reasons.push(ESTIMATE_DISQUALIFIERS.not_net_of_mu);
+  if (estimate.reports_loss !== true) reasons.push(ESTIMATE_DISQUALIFIERS.never_shows_loss);
+  if (typeof estimate.net_lower_bound !== "number" || !Number.isFinite(estimate.net_lower_bound)) {
+    reasons.push(ESTIMATE_DISQUALIFIERS.value_not_finite);
+  }
+  return { qualifies: reasons.length === 0, reasons };
+}
+var RENDER_ESTIMATE_REASONS = {
+  unknown_surface: "unknown_surface",
+  surface_never_shows_estimate: "surface_never_shows_estimate",
+  estimate_does_not_qualify: "estimate_does_not_qualify"
+};
+function shouldRenderEstimate(estimate, surface) {
+  if (!SURFACES.includes(surface)) {
+    return { render: false, reasons: [RENDER_ESTIMATE_REASONS.unknown_surface] };
+  }
+  if (ESTIMATE_FORBIDDEN_SURFACES.includes(surface)) {
+    return { render: false, reasons: [RENDER_ESTIMATE_REASONS.surface_never_shows_estimate] };
+  }
+  const q = estimateQualifies(estimate);
+  if (!q.qualifies) {
+    return { render: false, reasons: [RENDER_ESTIMATE_REASONS.estimate_does_not_qualify, ...q.reasons] };
+  }
+  return { render: true, reasons: [] };
+}
+var SHARE_CARD_TYP = "AAP-ShareCard/v1";
+var IDENTIFYING_KEYS = /* @__PURE__ */ new Set([
+  "repo",
+  "repository",
+  "repo_name",
+  "branch",
+  "branch_name",
+  "ref",
+  "pr",
+  "pr_title",
+  "pull_request",
+  "title",
+  "commit",
+  "commit_message",
+  "commit_sha",
+  "message",
+  "author",
+  "email",
+  "url",
+  "path"
+]);
+var CARD_KEYS = ["typ", "card_id", "period", "issued_at", "signing_key_id", "statements", "lines", "signature"];
+var PERIOD_KEYS = ["start", "end"];
+var STATEMENT_KEYS = ["typ", "hash"];
+var LINE_KEYS = ["id", "kind", "label", "value", "statement_hash"];
+var HEX64 = /^[0-9a-f]{64}$/;
+var DATE = /^\d{4}-\d{2}-\d{2}$/;
+var OPAQUE_ID = /^[a-z0-9_-]{1,64}$/;
+var LABEL = /^[A-Za-z0-9 .,()+-]{1,40}$/;
+var LABEL_MAX = 40;
+var SHARE_CARD_STATEMENT_TYPES = [
+  "AAP-ConductRecord/v1",
+  "AAP-PRRecord/v1",
+  "AAP-Outcome/v1"
+];
+var SIGNATURE_LEN = 86;
+var RFC3339 = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|([+-])(\d{2}):(\d{2}))$/;
+function isCalendarDate(y, m, d) {
+  if (m < 1 || m > 12 || d < 1) return false;
+  const dim = [31, y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][m - 1];
+  return d <= dim;
+}
+function isRfc3339(v) {
+  const m = RFC3339.exec(v);
+  if (!m) return false;
+  const [y, mo, d, h, mi, se] = m.slice(1, 7).map(Number);
+  if (!isCalendarDate(y, mo, d) || h > 23 || mi > 59 || se > 59) return false;
+  if (m[7] !== void 0 && (Number(m[8]) > 23 || Number(m[9]) > 59)) return false;
+  return true;
+}
+function shareCardSigningInput(card) {
+  const { signature: _signature, ...rest } = card;
+  return canonicalJson(rest);
+}
+function bytesToBase64url(b) {
+  let bin = "";
+  for (const x of b) bin += String.fromCharCode(x);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64urlToBytes(s) {
+  if (s.length !== SIGNATURE_LEN || !/^[A-Za-z0-9_-]+$/.test(s)) throw new Error("bad base64url");
+  const padded = s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice(0, (4 - s.length % 4) % 4);
+  const bin = atob(padded);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  if (out.length !== 64 || bytesToBase64url(out) !== s) throw new Error("non-canonical base64url");
+  return out;
+}
+function isObj(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function exactKeys(obj, allowed, where, errors) {
+  for (const k of Object.keys(obj)) {
+    if (IDENTIFYING_KEYS.has(k.toLowerCase())) errors.push(`${where}: identifying field "${k}" is not allowed`);
+    else if (!allowed.includes(k)) errors.push(`${where}: unknown field "${k}"`);
+  }
+  for (const k of allowed) if (!(k in obj)) errors.push(`${where}: missing field "${k}"`);
+}
+function validateShareCardShape(card) {
+  const errors = [];
+  if (!isObj(card)) return ["card: not an object"];
+  exactKeys(card, CARD_KEYS, "card", errors);
+  if (card.typ !== SHARE_CARD_TYP) errors.push(`card: typ must be ${SHARE_CARD_TYP}`);
+  if (typeof card.card_id !== "string" || !OPAQUE_ID.test(card.card_id)) errors.push("card: card_id must be an opaque id matching ^[a-z0-9_-]{1,64}$");
+  if (typeof card.issued_at !== "string" || !isRfc3339(card.issued_at)) errors.push("card: issued_at must be an RFC 3339 date-time");
+  if (typeof card.signing_key_id !== "string" || !card.signing_key_id) errors.push("card: signing_key_id must be a non-empty string");
+  if (typeof card.signature !== "string") errors.push("card: signature must be a string");
+  else {
+    try {
+      base64urlToBytes(card.signature);
+    } catch {
+      errors.push("card: signature must be a canonical 86-char unpadded base64url Ed25519 signature");
+    }
+  }
+  if (!isObj(card.period)) errors.push("period: not an object");
+  else {
+    exactKeys(card.period, PERIOD_KEYS, "period", errors);
+    for (const k of PERIOD_KEYS) {
+      const v = card.period[k];
+      if (typeof v !== "string" || !DATE.test(v) || !isCalendarDate(Number(v.slice(0, 4)), Number(v.slice(5, 7)), Number(v.slice(8, 10)))) {
+        errors.push(`period.${k}: must be a real calendar date YYYY-MM-DD`);
+      }
+    }
+    const { start, end } = card.period;
+    if (typeof start === "string" && typeof end === "string" && DATE.test(start) && DATE.test(end) && start > end) {
+      errors.push("period: start must be <= end");
+    }
+  }
+  const hashes = /* @__PURE__ */ new Set();
+  const referenced = /* @__PURE__ */ new Set();
+  const lineIds = /* @__PURE__ */ new Set();
+  if (!Array.isArray(card.statements) || card.statements.length === 0) errors.push("statements: must be a non-empty array");
+  else
+    card.statements.forEach((s, i) => {
+      if (!isObj(s)) return void errors.push(`statements[${i}]: not an object`);
+      exactKeys(s, STATEMENT_KEYS, `statements[${i}]`, errors);
+      if (typeof s.typ !== "string" || !SHARE_CARD_STATEMENT_TYPES.includes(s.typ)) {
+        errors.push(`statements[${i}].typ: must be one of ${SHARE_CARD_STATEMENT_TYPES.join(", ")}`);
+      }
+      if (typeof s.hash !== "string" || !HEX64.test(s.hash)) errors.push(`statements[${i}].hash: must be 64 lowercase hex`);
+      else hashes.add(s.hash);
+    });
+  if (!Array.isArray(card.lines) || card.lines.length === 0) errors.push("lines: must be a non-empty array");
+  else
+    card.lines.forEach((l, i) => {
+      if (!isObj(l)) return void errors.push(`lines[${i}]: not an object`);
+      exactKeys(l, LINE_KEYS, `lines[${i}]`, errors);
+      if (typeof l.id !== "string" || !OPAQUE_ID.test(l.id)) errors.push(`lines[${i}].id: must be an opaque id matching ^[a-z0-9_-]{1,64}$`);
+      else if (lineIds.has(l.id)) errors.push(`lines[${i}].id: duplicate line id "${l.id}"`);
+      else lineIds.add(l.id);
+      if (l.kind !== "count" && l.kind !== "revert") errors.push(`lines[${i}].kind: must be "count" or "revert"`);
+      if (typeof l.label !== "string" || !l.label || l.label.length > LABEL_MAX || /[/#]|:\/\/|www\./i.test(l.label) || !LABEL.test(l.label)) {
+        errors.push(`lines[${i}].label: must be short plain text (max ${LABEL_MAX}), no "/", "#" or URLs`);
+      }
+      if (typeof l.value !== "number" || !Number.isSafeInteger(l.value) || l.value < 0) errors.push(`lines[${i}].value: must be a non-negative integer`);
+      if (typeof l.statement_hash !== "string" || !HEX64.test(l.statement_hash)) errors.push(`lines[${i}].statement_hash: must be 64 lowercase hex`);
+      else if (!hashes.has(l.statement_hash)) errors.push(`lines[${i}].statement_hash: not committed in statements`);
+      else referenced.add(l.statement_hash);
+    });
+  for (const h of hashes) if (!referenced.has(h)) errors.push(`statements: ${h} is not referenced by any line`);
+  return errors;
+}
+async function verifyShareCard(card, options) {
+  const fail = (errors) => ({ valid: false, lines: [], errors });
+  const shapeErrors = validateShareCardShape(card);
+  if (shapeErrors.length > 0) return fail(shapeErrors);
+  const c = card;
+  let ok = false;
+  try {
+    const pk = typeof options.publicKey === "string" ? hexToUint8(options.publicKey) : options.publicKey;
+    ok = await ed25519.verifyAsync(base64urlToBytes(c.signature), utils_js.utf8ToBytes(shareCardSigningInput(c)), pk, { zip215: false });
+  } catch {
+    ok = false;
+  }
+  if (!ok) return fail(["signature: verification failed"]);
+  return { valid: true, lines: c.lines.map((l) => ({ ...l })), errors: [] };
+}
+
+exports.BUNDLE_TYP = BUNDLE_TYP;
+exports.CARD_LINE_CLASSES = CARD_LINE_CLASSES;
+exports.CARD_SURFACES = CARD_SURFACES;
+exports.CLAIM_CLASSES = CLAIM_CLASSES;
+exports.CLAIM_TABLE = CLAIM_TABLE;
+exports.ESTIMATE_COUNTING_FLOOR_TOKENS = ESTIMATE_COUNTING_FLOOR_TOKENS;
+exports.ESTIMATE_DISQUALIFIERS = ESTIMATE_DISQUALIFIERS;
+exports.ESTIMATE_FORBIDDEN_SURFACES = ESTIMATE_FORBIDDEN_SURFACES;
+exports.FLAGS = FLAGS;
+exports.GOAL_MODES = GOAL_MODES;
+exports.LINE_KEY_FIELDS = LINE_KEY_FIELDS;
+exports.LINT_RULES = LINT_RULES;
+exports.MODES = MODES;
+exports.MODE_VERBS = MODE_VERBS;
+exports.PROTECTION_VERDICTS = PROTECTION_VERDICTS;
+exports.REASONS = REASONS;
+exports.RENDER_ESTIMATE_REASONS = RENDER_ESTIMATE_REASONS;
+exports.SHARE_CARD_TYP = SHARE_CARD_TYP;
+exports.STATEMENT_TYPES = STATEMENT_TYPES;
+exports.SURFACES = SURFACES;
+exports.attachLineContext = attachLineContext;
+exports.canonicalJson = canonicalJson;
+exports.estimateQualifies = estimateQualifies;
+exports.fieldForLineKey = fieldForLineKey;
+exports.isClaimField = isClaimField;
+exports.lintRendering = lintRendering;
+exports.lintRenderings = lintRenderings;
+exports.protectionVerb = protectionVerb;
+exports.shareCardSigningInput = shareCardSigningInput;
+exports.shouldRenderEstimate = shouldRenderEstimate;
+exports.statementCommitment = statementCommitment;
+exports.statementDigest = statementDigest;
+exports.validateShareCardShape = validateShareCardShape;
+exports.verify = verify;
+exports.verifyCertificate = verifyCertificate;
+exports.verifyShareCard = verifyShareCard;
+exports.verifyStatement = verifyStatement;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map