@orangecheck/agent-core 0.1.0

package/dist/index.js

@@ -0,0 +1,671 @@
+'use strict';
+
+var sha256 = require('@noble/hashes/sha256');
+var canonical = require('@orangecheck/stamp-core/canonical');
+
+// src/types.ts
+var ENVELOPE_VERSION = 1;
+
+// src/scope.ts
+var REGISTERED_SCOPES = {
+  "lock:seal": { keys: ["recipient", "mime", "max_bytes"] },
+  "lock:chat": { keys: ["recipient", "max_bytes_per_msg", "max_msgs"] },
+  "stamp:sign": { keys: ["mime", "max_bytes", "content_hash_prefix"] },
+  "vote:cast": { keys: ["poll_id", "choice"] },
+  "nostr:publish": { keys: ["kind", "relay", "max_bytes"] },
+  "http:request": { keys: ["origin", "method", "max_rps", "max_bytes_out"] },
+  "ln:send": { keys: ["max_sats", "node", "max_fee_sats"] },
+  "mcp:invoke": { keys: ["server", "tool", "max_invocations"] }
+};
+var NUMERIC_KEYS = /* @__PURE__ */ new Set([
+  "max_bytes",
+  "max_bytes_per_msg",
+  "max_msgs",
+  "max_bytes_out",
+  "max_rps",
+  "max_sats",
+  "max_fee_sats",
+  "max_invocations",
+  "kind"
+]);
+var IDENT_RE = /^[a-z][a-z0-9_]*$/;
+var BARE_TOKEN_RE = /^[A-Za-z0-9_.:/@+\-]+$/;
+var ScopeParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ScopeParseError";
+  }
+};
+function parseScope(input) {
+  if (typeof input !== "string" || input.length === 0) {
+    throw new ScopeParseError("scope must be a non-empty string");
+  }
+  if (/\s/.test(input)) {
+    throw new ScopeParseError(`scope may not contain whitespace: ${JSON.stringify(input)}`);
+  }
+  const colonIdx = input.indexOf(":");
+  if (colonIdx < 0) throw new ScopeParseError('scope missing "product:verb" separator');
+  const product = input.slice(0, colonIdx);
+  if (!IDENT_RE.test(product)) throw new ScopeParseError(`invalid product: ${product}`);
+  const rest = input.slice(colonIdx + 1);
+  const parenIdx = rest.indexOf("(");
+  let verb;
+  let constraintText = "";
+  if (parenIdx < 0) {
+    verb = rest;
+  } else {
+    verb = rest.slice(0, parenIdx);
+    if (!rest.endsWith(")")) throw new ScopeParseError('scope constraint list must end with ")"');
+    constraintText = rest.slice(parenIdx + 1, -1);
+  }
+  if (!IDENT_RE.test(verb)) throw new ScopeParseError(`invalid verb: ${verb}`);
+  const constraints = [];
+  if (constraintText.length > 0) {
+    for (const piece of splitTopLevelCommas(constraintText)) {
+      constraints.push(parseConstraint(piece));
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const c of constraints) {
+    if (seen.has(c.key)) throw new ScopeParseError(`duplicate constraint key: ${c.key}`);
+    seen.add(c.key);
+  }
+  return { product, verb, constraints };
+}
+function splitTopLevelCommas(text) {
+  const out = [];
+  let depth = 0;
+  let inQuotes = false;
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inQuotes) {
+      if (ch === "\\" && i + 1 < text.length) {
+        i++;
+        continue;
+      }
+      if (ch === '"') inQuotes = false;
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = true;
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) {
+      out.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(text.slice(start));
+  return out;
+}
+function parseConstraint(piece) {
+  if (piece.length === 0) throw new ScopeParseError("empty constraint");
+  const OPS = [">=", "<=", "!=", "=", ">", "<"];
+  const wildcardMatch = /^([a-z][a-z0-9_]*)(?:=\*|\*)$/.exec(piece);
+  if (wildcardMatch) {
+    return { key: wildcardMatch[1], op: "*", value: void 0, quoted: false };
+  }
+  for (const op of OPS) {
+    const idx = piece.indexOf(op);
+    if (idx <= 0) continue;
+    const key = piece.slice(0, idx);
+    if (!IDENT_RE.test(key)) continue;
+    const raw = piece.slice(idx + op.length);
+    const { value, quoted } = parseValue(raw);
+    return { key, op, value, quoted };
+  }
+  throw new ScopeParseError(`constraint missing operator: ${piece}`);
+}
+function parseValue(raw) {
+  if (raw.length === 0) throw new ScopeParseError("constraint value is empty");
+  if (raw.startsWith('"')) {
+    if (!raw.endsWith('"') || raw.length < 2) {
+      throw new ScopeParseError(`unterminated quoted value: ${raw}`);
+    }
+    let v = "";
+    for (let i = 1; i < raw.length - 1; i++) {
+      const ch = raw[i];
+      if (ch === "\\" && i + 1 < raw.length - 1) {
+        const next = raw[++i];
+        v += next;
+      } else if (ch === '"') {
+        throw new ScopeParseError(`unescaped quote in value: ${raw}`);
+      } else {
+        v += ch;
+      }
+    }
+    return { value: v, quoted: true };
+  }
+  if (!BARE_TOKEN_RE.test(raw)) {
+    throw new ScopeParseError(`invalid bare-token value: ${JSON.stringify(raw)}`);
+  }
+  return { value: raw, quoted: false };
+}
+function canonicalizeScope(scope) {
+  const sorted = [...scope.constraints].sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+  const parts = sorted.map(serializeConstraint);
+  const inner = parts.join(",");
+  return `${scope.product}:${scope.verb}${parts.length === 0 ? "" : `(${inner})`}`;
+}
+function canonicalizeScopeString(input) {
+  return canonicalizeScope(parseScope(input));
+}
+function serializeConstraint(c) {
+  if (c.op === "*") return `${c.key}=*`;
+  const v = c.quoted ? quoteValue(c.value ?? "") : c.value ?? "";
+  return `${c.key}${c.op}${v}`;
+}
+function quoteValue(v) {
+  let out = '"';
+  for (const ch of v) {
+    if (ch === '"' || ch === "\\") out += "\\" + ch;
+    else out += ch;
+  }
+  out += '"';
+  return out;
+}
+function validateScope(scope, options = {}) {
+  const mode = options.mode ?? "strict";
+  const reg = REGISTERED_SCOPES[`${scope.product}:${scope.verb}`];
+  if (!reg) {
+    if (mode === "strict") {
+      throw new ScopeParseError(`unregistered scope: ${scope.product}:${scope.verb}`);
+    }
+    return;
+  }
+  const registered = new Set(reg.keys);
+  for (const c of scope.constraints) {
+    if (!registered.has(c.key)) {
+      if (mode === "strict") {
+        throw new ScopeParseError(
+          `unregistered constraint key for ${scope.product}:${scope.verb}: ${c.key}`
+        );
+      }
+    }
+  }
+}
+function isSubScope(exercised, granted) {
+  if (exercised.product !== granted.product) return false;
+  if (exercised.verb !== granted.verb) return false;
+  const exIndex = /* @__PURE__ */ new Map();
+  for (const c of exercised.constraints) exIndex.set(c.key, c);
+  for (const g of granted.constraints) {
+    const ex = exIndex.get(g.key);
+    if (g.op === "*") continue;
+    if (g.op === "=") {
+      if (!ex) return false;
+      if (ex.op !== "=" || ex.value !== g.value) return false;
+      continue;
+    }
+    if (g.op === "!=") {
+      if (!ex) return false;
+      if (ex.op === "=" && ex.value !== g.value) continue;
+      if (ex.op === "!=" && ex.value === g.value) continue;
+      return false;
+    }
+    if (g.op === "<" || g.op === "<=" || g.op === ">" || g.op === ">=") {
+      if (!ex) return false;
+      if (!NUMERIC_KEYS.has(g.key)) return false;
+      if (ex.op === "*") return false;
+      if (ex.value === void 0 || g.value === void 0) return false;
+      if (!rangeSubset(ex, g)) return false;
+      continue;
+    }
+  }
+  return true;
+}
+function rangeSubset(ex, g) {
+  const exRange = opToRange(ex);
+  const gRange = opToRange(g);
+  if (!exRange || !gRange) return false;
+  return gRange.lo <= exRange.lo && exRange.hi <= gRange.hi;
+}
+function opToRange(c) {
+  if (c.value === void 0) return null;
+  const n = Number(c.value);
+  if (!Number.isFinite(n)) return null;
+  switch (c.op) {
+    case "=":
+      return { lo: n, hi: n };
+    case "<":
+      return { lo: -Infinity, hi: n - 1 };
+    // integers only
+    case "<=":
+      return { lo: -Infinity, hi: n };
+    case ">":
+      return { lo: n + 1, hi: Infinity };
+    case ">=":
+      return { lo: n, hi: Infinity };
+    default:
+      return null;
+  }
+}
+
+// src/canonical.ts
+function canonicalizeScopes(scopes) {
+  const canonical = scopes.map((s) => canonicalizeScope(parseScope(s)));
+  return [...canonical].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function parseAndCanonicalizeScopes(scopes) {
+  const parsed = scopes.map(parseScope);
+  const canonicalStrings = parsed.map(canonicalizeScope);
+  const indexed = canonicalStrings.map((s, i) => ({ s, p: parsed[i] }));
+  indexed.sort((a, b) => a.s < b.s ? -1 : a.s > b.s ? 1 : 0);
+  return {
+    canonical: indexed.map((x) => x.s),
+    parsed: indexed.map((x) => x.p)
+  };
+}
+function delegationCanonicalMessage(input) {
+  const scopeField = input.scopes.join(",");
+  return [
+    "oc-agent:delegation:v1",
+    `principal: ${input.principal}`,
+    `agent: ${input.agent}`,
+    `scopes: ${scopeField}`,
+    `bond_sats: ${input.bond_sats}`,
+    `bond_attestation: ${input.bond_attestation}`,
+    `issued_at: ${input.issued_at}`,
+    `expires_at: ${input.expires_at}`,
+    `nonce: ${input.nonce}`
+  ].join("\n");
+}
+function actionCanonicalMessage(input) {
+  return [
+    "oc-agent:action:v1",
+    `address: ${input.address}`,
+    `content_hash: ${input.content_hash}`,
+    `content_length: ${input.content_length}`,
+    `content_mime: ${input.content_mime}`,
+    `signed_at: ${input.signed_at}`,
+    `delegation_id: ${input.delegation_id}`,
+    `scope_exercised: ${input.scope_exercised}`
+  ].join("\n");
+}
+function revocationCanonicalMessage(input) {
+  return [
+    "oc-agent:revocation:v1",
+    `address: ${input.address}`,
+    `delegation_id: ${input.delegation_id}`,
+    `reason: ${input.reason}`,
+    `signed_at: ${input.signed_at}`
+  ].join("\n");
+}
+function delegationCanonicalBytes(input) {
+  return new TextEncoder().encode(delegationCanonicalMessage(input));
+}
+function actionCanonicalBytes(input) {
+  return new TextEncoder().encode(actionCanonicalMessage(input));
+}
+function revocationCanonicalBytes(input) {
+  return new TextEncoder().encode(revocationCanonicalMessage(input));
+}
+function computeDelegationId(input) {
+  return canonical.hexEncode(sha256.sha256(delegationCanonicalBytes(input)));
+}
+function computeActionId(input) {
+  return canonical.hexEncode(sha256.sha256(actionCanonicalBytes(input)));
+}
+function computeRevocationId(input) {
+  return canonical.hexEncode(sha256.sha256(revocationCanonicalBytes(input)));
+}
+function canonicalizeDelegation(env) {
+  return canonical.canonicalize(env);
+}
+function canonicalizeAction(env) {
+  return canonical.canonicalize(env);
+}
+function canonicalizeRevocation(env) {
+  return canonical.canonicalize(env);
+}
+function canonicalDelegationBytes(env) {
+  return new TextEncoder().encode(canonicalizeDelegation(env) + "\n");
+}
+function canonicalActionBytes(env) {
+  return new TextEncoder().encode(canonicalizeAction(env) + "\n");
+}
+function canonicalRevocationBytes(env) {
+  return new TextEncoder().encode(canonicalizeRevocation(env) + "\n");
+}
+function sha256Hex(bytes) {
+  return canonical.hexEncode(sha256.sha256(bytes));
+}
+var AgentError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AgentError";
+  }
+};
+async function verifyDelegation(input) {
+  const env = input.envelope;
+  if (env.v !== ENVELOPE_VERSION) {
+    return err("E_UNSUPPORTED_VERSION", `delegation version ${env.v} not supported`);
+  }
+  const shape = checkDelegationShape(env);
+  if (shape) return shape;
+  let canonicalScopes;
+  try {
+    for (const s of env.scopes) validateScope(parseScope(s), { mode: input.scopeMode ?? "strict" });
+    canonicalScopes = canonicalizeScopes(env.scopes);
+  } catch (e) {
+    const msg = e instanceof ScopeParseError ? e.message : e.message;
+    return err("E_BAD_SCOPE_GRAMMAR", msg);
+  }
+  for (let i = 0; i < canonicalScopes.length; i++) {
+    if (env.scopes[i] !== canonicalScopes[i]) {
+      return err(
+        "E_BAD_SCOPE_GRAMMAR",
+        `scope at index ${i} not in canonical form; expected ${canonicalScopes[i]} got ${env.scopes[i]}`
+      );
+    }
+  }
+  const bondSats = env.bond?.sats ?? 0;
+  const bondAttestation = env.bond?.attestation_id ?? "none";
+  const canonInput = {
+    principal: env.principal.address,
+    agent: env.agent.address,
+    scopes: canonicalScopes,
+    bond_sats: bondSats,
+    bond_attestation: bondAttestation,
+    issued_at: env.issued_at,
+    expires_at: env.expires_at,
+    nonce: env.nonce
+  };
+  const reconstructedMessage = delegationCanonicalMessage(canonInput);
+  const reconstructedId = canonical.hexEncode(sha256.sha256(delegationCanonicalBytes(canonInput)));
+  if (reconstructedId !== env.id) {
+    return err(
+      "E_BAD_ID",
+      `reconstructed id (${reconstructedId}) does not match envelope.id (${env.id})`
+    );
+  }
+  if (!input.skipSignatureVerification) {
+    if (!input.verifyBip322) return err("E_BAD_SIG", "no BIP-322 verifier supplied");
+    const ok = await input.verifyBip322(env.id, env.sig.value, env.principal.address);
+    if (!ok) return err("E_BAD_SIG", "BIP-322 signature did not verify");
+  }
+  if (!input.skipTemporalCheck) {
+    const now = input.now ?? /* @__PURE__ */ new Date();
+    const issued = new Date(env.issued_at);
+    const expires = new Date(env.expires_at);
+    if (expires <= issued) return err("E_MALFORMED", "expires_at <= issued_at");
+    if (now < issued) return err("E_NOT_YET_VALID", `delegation not valid until ${env.issued_at}`);
+    if (now >= expires) return err("E_EXPIRED", `delegation expired at ${env.expires_at}`);
+  }
+  return {
+    ok: true,
+    envelope: env,
+    canonicalMessage: reconstructedMessage,
+    id: env.id
+  };
+}
+async function verifyAction(input) {
+  const a = input.action;
+  const d = input.delegation;
+  const dr = await verifyDelegation({
+    envelope: d,
+    verifyBip322: input.verifyBip322,
+    skipSignatureVerification: input.skipSignatureVerification,
+    scopeMode: input.scopeMode,
+    skipTemporalCheck: true
+    // action window check dominates
+  });
+  if (!dr.ok) return dr;
+  if (a.v !== ENVELOPE_VERSION) {
+    return err("E_UNSUPPORTED_VERSION", `action version ${a.v} not supported`);
+  }
+  const shape = checkActionShape(a);
+  if (shape) return shape;
+  const canonInput = {
+    address: a.signer.address,
+    content_hash: a.content.hash,
+    content_length: a.content.length,
+    content_mime: a.content.mime,
+    signed_at: a.signed_at,
+    delegation_id: a.delegation_id,
+    scope_exercised: a.scope_exercised
+  };
+  const reconstructedMessage = actionCanonicalMessage(canonInput);
+  const reconstructedId = canonical.hexEncode(sha256.sha256(actionCanonicalBytes(canonInput)));
+  if (reconstructedId !== a.id) {
+    return err("E_BAD_ID", `reconstructed id (${reconstructedId}) does not match action.id (${a.id})`);
+  }
+  if (!input.skipSignatureVerification) {
+    if (!input.verifyBip322) return err("E_BAD_SIG", "no BIP-322 verifier supplied");
+    const ok = await input.verifyBip322(a.id, a.sig.value, a.signer.address);
+    if (!ok) return err("E_BAD_ACTION_STAMP", "action BIP-322 signature did not verify");
+  }
+  if (a.delegation_id !== d.id) {
+    return err("E_DELEGATION_MISMATCH", `action.delegation_id (${a.delegation_id}) != delegation.id (${d.id})`);
+  }
+  if (a.signer.address !== d.agent.address) {
+    return err("E_AGENT_MISMATCH", `action signer (${a.signer.address}) != delegation.agent (${d.agent.address})`);
+  }
+  const issued = new Date(d.issued_at).getTime();
+  const expires = new Date(d.expires_at).getTime();
+  const signed = new Date(a.signed_at).getTime();
+  if (Number.isNaN(issued) || Number.isNaN(expires) || Number.isNaN(signed)) {
+    return err("E_MALFORMED", "unparseable ISO 8601 timestamp");
+  }
+  if (signed < issued || signed >= expires) {
+    return err("E_OUT_OF_WINDOW", `action.signed_at ${a.signed_at} is outside delegation window [${d.issued_at}, ${d.expires_at})`);
+  }
+  let exercised, accepted;
+  try {
+    exercised = canonicalizeScope(parseScope(a.scope_exercised));
+    const granted = d.scopes.map((s) => parseScope(s));
+    const exercisedParsed = parseScope(a.scope_exercised);
+    validateScope(exercisedParsed, { mode: input.scopeMode ?? "strict" });
+    accepted = granted.some((g) => isSubScope(exercisedParsed, g));
+  } catch (e) {
+    const msg = e instanceof ScopeParseError ? e.message : e.message;
+    return err("E_BAD_SCOPE_GRAMMAR", msg);
+  }
+  if (!accepted) return err("E_SCOPE_DENIED", `scope_exercised (${exercised}) not a sub-scope of any granted scope`);
+  if (input.revocations && input.revocations.length > 0) {
+    for (const rev of input.revocations) {
+      if (rev.delegation_id !== d.id) continue;
+      const rr = await verifyRevocation({
+        envelope: rev,
+        delegation: d,
+        verifyBip322: input.verifyBip322,
+        skipSignatureVerification: input.skipSignatureVerification
+      });
+      if (!rr.ok) continue;
+      const effective = effectiveRevocationTime(rev, input.resolveAnchorBlockHeight);
+      const actionTime = actionEffectiveTime(a, input.resolveAnchorBlockHeight);
+      if (compareTimes(effective, actionTime) <= 0) {
+        return err("E_REVOKED", `delegation was revoked by ${rev.id} before action was signed`);
+      }
+    }
+  }
+  if (input.content) {
+    const actualHash = "sha256:" + canonical.hexEncode(sha256.sha256(input.content));
+    if (actualHash !== a.content.hash) {
+      return err("E_BAD_ACTION_STAMP", `content hash (${actualHash}) != action.content.hash (${a.content.hash})`);
+    }
+  }
+  let anchor;
+  if (a.ots === null) {
+    anchor = { status: "none" };
+  } else if (a.ots.status === "pending") {
+    anchor = { status: "pending" };
+  } else {
+    const h = a.ots.block_height;
+    const hash = a.ots.block_hash;
+    if (h === null || hash === null) {
+      return err("E_MALFORMED", "confirmed OTS proof missing block_height or block_hash");
+    }
+    let verified = false;
+    if (input.verifyOtsAnchor) {
+      try {
+        verified = await input.verifyOtsAnchor(a.ots.proof, h, hash);
+      } catch (e) {
+        return err("E_MALFORMED", `anchor verifier threw: ${e.message}`);
+      }
+    }
+    anchor = { status: "confirmed", blockHeight: h, blockHash: hash, verified };
+  }
+  return {
+    ok: true,
+    envelope: a,
+    canonicalMessage: reconstructedMessage,
+    id: a.id,
+    delegation: d,
+    scopeExercised: exercised,
+    anchor
+  };
+}
+async function verifyRevocation(input) {
+  const env = input.envelope;
+  const d = input.delegation;
+  if (env.v !== ENVELOPE_VERSION) {
+    return err("E_UNSUPPORTED_VERSION", `revocation version ${env.v} not supported`);
+  }
+  const shape = checkRevocationShape(env);
+  if (shape) return shape;
+  if (env.delegation_id !== d.id) {
+    return err("E_DELEGATION_MISMATCH", `revocation.delegation_id (${env.delegation_id}) != delegation.id (${d.id})`);
+  }
+  const holders = d.revocation?.holders ?? ["principal"];
+  const holderAddrs = /* @__PURE__ */ new Set();
+  if (holders.includes("principal")) holderAddrs.add(d.principal.address);
+  if (holders.includes("agent")) holderAddrs.add(d.agent.address);
+  if (!holderAddrs.has(env.signer.address)) {
+    return err("E_REVOKER_UNAUTHORIZED", `revocation signer ${env.signer.address} not in delegation holders`);
+  }
+  const canonInput = {
+    address: env.signer.address,
+    delegation_id: env.delegation_id,
+    reason: env.reason,
+    signed_at: env.signed_at
+  };
+  const reconstructedMessage = revocationCanonicalMessage(canonInput);
+  const reconstructedId = canonical.hexEncode(sha256.sha256(revocationCanonicalBytes(canonInput)));
+  if (reconstructedId !== env.id) {
+    return err("E_BAD_ID", `reconstructed id (${reconstructedId}) does not match revocation.id (${env.id})`);
+  }
+  if (!input.skipSignatureVerification) {
+    if (!input.verifyBip322) return err("E_BAD_SIG", "no BIP-322 verifier supplied");
+    const ok = await input.verifyBip322(env.id, env.sig.value, env.signer.address);
+    if (!ok) return err("E_BAD_SIG", "revocation BIP-322 signature did not verify");
+  }
+  return { ok: true, envelope: env, canonicalMessage: reconstructedMessage, id: env.id };
+}
+function checkDelegationShape(env) {
+  if (env.kind !== "agent-delegation") return err("E_MALFORMED", 'kind must be "agent-delegation"');
+  if (!isHex64(env.id)) return err("E_MALFORMED", "id must be 64 lowercase hex chars");
+  if (!env.principal?.address || env.principal.alg !== "bip322") return err("E_MALFORMED", "principal invalid");
+  if (!env.agent?.address || env.agent.alg !== "bip322") return err("E_MALFORMED", "agent invalid");
+  if (!Array.isArray(env.scopes) || env.scopes.length === 0) return err("E_MALFORMED", "scopes must be non-empty array");
+  if (env.bond !== null) {
+    if (!Number.isInteger(env.bond.sats) || env.bond.sats < 0) return err("E_MALFORMED", "bond.sats must be non-negative integer");
+    if (!isHex64(env.bond.attestation_id)) return err("E_MALFORMED", "bond.attestation_id must be 64-hex");
+  }
+  if (!isIsoUtc(env.issued_at)) return err("E_MALFORMED", "issued_at must be ISO 8601 UTC");
+  if (!isIsoUtc(env.expires_at)) return err("E_MALFORMED", "expires_at must be ISO 8601 UTC");
+  if (!/^[0-9a-f]{32}$/.test(env.nonce)) return err("E_MALFORMED", "nonce must be 32 lowercase hex chars");
+  if (env.sig?.alg !== "bip322" || typeof env.sig.value !== "string") return err("E_MALFORMED", "sig invalid");
+  if (env.sig.pubkey !== env.principal.address) return err("E_MALFORMED", "sig.pubkey must equal principal.address");
+  return null;
+}
+function checkActionShape(a) {
+  if (a.kind !== "agent-action") return err("E_MALFORMED", 'kind must be "agent-action"');
+  if (!isHex64(a.id)) return err("E_MALFORMED", "id must be 64 lowercase hex chars");
+  if (!a.content || typeof a.content.hash !== "string" || !a.content.hash.startsWith("sha256:")) {
+    return err("E_MALFORMED", 'content.hash must start with "sha256:"');
+  }
+  if (!Number.isInteger(a.content.length) || a.content.length < 0) return err("E_MALFORMED", "content.length invalid");
+  if (!a.signer?.address || a.signer.alg !== "bip322") return err("E_MALFORMED", "signer invalid");
+  if (!isIsoUtc(a.signed_at)) return err("E_MALFORMED", "signed_at must be ISO 8601 UTC");
+  if (!isHex64(a.delegation_id)) return err("E_MALFORMED", "delegation_id must be 64-hex");
+  if (typeof a.scope_exercised !== "string" || a.scope_exercised.length === 0) return err("E_MALFORMED", "scope_exercised required");
+  if (a.sig?.alg !== "bip322" || typeof a.sig.value !== "string") return err("E_MALFORMED", "sig invalid");
+  if (a.sig.pubkey !== a.signer.address) return err("E_MALFORMED", "sig.pubkey must equal signer.address");
+  return null;
+}
+function checkRevocationShape(env) {
+  if (env.kind !== "agent-revocation") return err("E_MALFORMED", 'kind must be "agent-revocation"');
+  if (!isHex64(env.id)) return err("E_MALFORMED", "id must be 64 lowercase hex chars");
+  if (!isHex64(env.delegation_id)) return err("E_MALFORMED", "delegation_id must be 64-hex");
+  if (!env.signer?.address || env.signer.alg !== "bip322") return err("E_MALFORMED", "signer invalid");
+  if (typeof env.reason !== "string" || env.reason.length > 128) return err("E_MALFORMED", "reason must be a string <=128 bytes");
+  if (!isIsoUtc(env.signed_at)) return err("E_MALFORMED", "signed_at must be ISO 8601 UTC");
+  if (env.sig?.alg !== "bip322" || typeof env.sig.value !== "string") return err("E_MALFORMED", "sig invalid");
+  if (env.sig.pubkey !== env.signer.address) return err("E_MALFORMED", "sig.pubkey must equal signer.address");
+  return null;
+}
+function actionEffectiveTime(a, resolve) {
+  if (a.ots?.status === "confirmed") {
+    const h = resolve ? resolve(a) : a.ots.block_height;
+    if (h !== null && h !== void 0) return { kind: "anchor", blockHeight: h };
+  }
+  return { kind: "signed", ms: new Date(a.signed_at).getTime() };
+}
+function effectiveRevocationTime(r, resolve) {
+  if (r.ots?.status === "confirmed") {
+    const h = resolve ? resolve(r) : r.ots.block_height;
+    if (h !== null && h !== void 0) return { kind: "anchor", blockHeight: h };
+  }
+  return { kind: "signed", ms: new Date(r.signed_at).getTime() };
+}
+function compareTimes(a, b) {
+  if (a.kind === "anchor" && b.kind === "anchor") return a.blockHeight - b.blockHeight;
+  if (a.kind === "anchor") return -1;
+  if (b.kind === "anchor") return 1;
+  return a.ms - b.ms;
+}
+function err(code, message) {
+  return { ok: false, code, message };
+}
+function isHex64(s) {
+  return typeof s === "string" && /^[0-9a-f]{64}$/.test(s);
+}
+function isIsoUtc(s) {
+  return typeof s === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/.test(s);
+}
+
+Object.defineProperty(exports, "canonicalize", {
+  enumerable: true,
+  get: function () { return canonical.canonicalize; }
+});
+Object.defineProperty(exports, "hexEncode", {
+  enumerable: true,
+  get: function () { return canonical.hexEncode; }
+});
+exports.AgentError = AgentError;
+exports.ENVELOPE_VERSION = ENVELOPE_VERSION;
+exports.REGISTERED_SCOPES = REGISTERED_SCOPES;
+exports.ScopeParseError = ScopeParseError;
+exports.actionCanonicalBytes = actionCanonicalBytes;
+exports.actionCanonicalMessage = actionCanonicalMessage;
+exports.canonicalActionBytes = canonicalActionBytes;
+exports.canonicalDelegationBytes = canonicalDelegationBytes;
+exports.canonicalRevocationBytes = canonicalRevocationBytes;
+exports.canonicalizeAction = canonicalizeAction;
+exports.canonicalizeDelegation = canonicalizeDelegation;
+exports.canonicalizeRevocation = canonicalizeRevocation;
+exports.canonicalizeScope = canonicalizeScope;
+exports.canonicalizeScopeString = canonicalizeScopeString;
+exports.canonicalizeScopes = canonicalizeScopes;
+exports.computeActionId = computeActionId;
+exports.computeDelegationId = computeDelegationId;
+exports.computeRevocationId = computeRevocationId;
+exports.delegationCanonicalBytes = delegationCanonicalBytes;
+exports.delegationCanonicalMessage = delegationCanonicalMessage;
+exports.isSubScope = isSubScope;
+exports.parseAndCanonicalizeScopes = parseAndCanonicalizeScopes;
+exports.parseScope = parseScope;
+exports.revocationCanonicalBytes = revocationCanonicalBytes;
+exports.revocationCanonicalMessage = revocationCanonicalMessage;
+exports.sha256Hex = sha256Hex;
+exports.validateScope = validateScope;
+exports.verifyAction = verifyAction;
+exports.verifyDelegation = verifyDelegation;
+exports.verifyRevocation = verifyRevocation;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map