@humanagencyp/hap-core 0.11.2 → 0.12.1

package/dist/index.js

@@ -32,65 +32,72 @@ var index_exports = {};
 __export(index_exports, {
   CanonicalValueError: () => CanonicalValueError,
   ContentBindingError: () => ContentBindingError,
-  MandateError: () => MandateError,
+  HapError: () => HapError,
+  MANDATE_ERROR_CODES: () => MANDATE_ERROR_CODES,
+  OwnerSignatureError: () => OwnerSignatureError,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
   SIGNABLE_COMMITMENT_MODES: () => SIGNABLE_COMMITMENT_MODES,
+  SUPPORTED_VERSIONS: () => SUPPORTED_VERSIONS,
+  TICKET_ERROR_CODES: () => TICKET_ERROR_CODES,
   allowedCommitmentModes: () => allowedCommitmentModes,
   approvalSigningBytes: () => approvalSigningBytes,
-  attestationId: () => attestationId,
   bindingAppliesTo: () => bindingAppliesTo,
   boundActionTypes: () => boundActionTypes,
   buildMandateProjection: () => buildMandateProjection,
   canonicalBounds: () => canonicalBounds,
-  canonicalContext: () => canonicalContext,
-  canonicalFrame: () => canonicalFrame,
+  canonicalScope: () => canonicalScope,
   canonicalize: () => canonicalize,
   canonicalizeText: () => canonicalizeText,
-  checkAttestationExpiry: () => checkAttestationExpiry,
+  checkDiscloseSubset: () => checkDiscloseSubset,
+  checkMandateExpiry: () => checkMandateExpiry,
+  checkOwnerSignatureRequirement: () => checkOwnerSignatureRequirement,
   clearProfiles: () => clearProfiles,
   computeBoundsHash: () => computeBoundsHash,
   computeContentHash: () => computeContentHash,
-  computeContextHash: () => computeContextHash,
   computeFieldsContentHash: () => computeFieldsContentHash,
-  computeFrameHash: () => computeFrameHash,
   computeIntentDisclosureHash: () => computeIntentDisclosureHash,
   computeIntentHash: () => computeIntentHash,
+  computeProfileHash: () => computeProfileHash,
+  computeScopeHash: () => computeScopeHash,
   contentCanonicalBytes: () => contentCanonicalBytes,
-  decodeAttestationBlob: () => decodeAttestationBlob,
   decodeDidKey: () => decodeDidKey,
+  decodeMandateBlob: () => decodeMandateBlob,
   deriveIdentityLine: () => deriveIdentityLine,
-  encodeAttestationBlob: () => encodeAttestationBlob,
   encodeDidKey: () => encodeDidKey,
-  frameHash: () => frameHash,
+  encodeMandateBlob: () => encodeMandateBlob,
+  filesFields: () => filesFields,
+  fromBase64Url: () => fromBase64Url,
   getAllProfiles: () => getAllProfiles,
   getProfile: () => getProfile,
   intentDisclosureCanonicalBytes: () => intentDisclosureCanonicalBytes,
+  invalidFieldKindsReason: () => invalidFieldKindsReason,
   isCommitmentModeAllowed: () => isCommitmentModeAllowed,
   isFieldBinding: () => isFieldBinding,
   isKeyBearingDid: () => isKeyBearingDid,
-  isV4Attestation: () => isV4Attestation,
   listProfiles: () => listProfiles,
-  mandateSigningBytes: () => mandateSigningBytes,
+  mandateBlobId: () => mandateBlobId,
+  negotiateVersion: () => negotiateVersion,
+  projectionSigningBytes: () => projectionSigningBytes,
+  publicTicketView: () => publicTicketView,
   registerProfile: () => registerProfile,
   selectBoundFields: () => selectBoundFields,
   signApproval: () => signApproval,
+  signMandate: () => signMandate,
   signMandateProjection: () => signMandateProjection,
+  signTicket: () => signTicket,
+  toBase64Url: () => toBase64Url,
   validateBoundsParams: () => validateBoundsParams,
-  validateBoundsRequiredFor: () => validateBoundsRequiredFor,
-  validateCommitmentModes: () => validateCommitmentModes,
-  validateContextParams: () => validateContextParams,
-  validateFrameParams: () => validateFrameParams,
+  validateMandateOwners: () => validateMandateOwners,
+  validateProfile: () => validateProfile,
+  validateScopeParams: () => validateScopeParams,
   validateSubject: () => validateSubject,
   verify: () => verify,
   verifyApproval: () => verifyApproval,
-  verifyAttestation: () => verifyAttestation,
-  verifyAttestationSignature: () => verifyAttestationSignature,
-  verifyAttestationV4: () => verifyAttestationV4,
-  verifyBoundsHash: () => verifyBoundsHash,
-  verifyContextHash: () => verifyContextHash,
-  verifyFrameHash: () => verifyFrameHash,
-  verifyOwnerMandate: () => verifyOwnerMandate,
-  verifyOwnerMandates: () => verifyOwnerMandates,
-  verifyReceiptSignature: () => verifyReceiptSignature
+  verifyMandate: () => verifyMandate,
+  verifyMandateSignature: () => verifyMandateSignature,
+  verifyOwnerSignature: () => verifyOwnerSignature,
+  verifyOwnerSignatures: () => verifyOwnerSignatures,
+  verifyTicketSignature: () => verifyTicketSignature
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -119,6 +126,88 @@ function canonicalize(value) {
   return "{" + parts.join(",") + "}";
 }
 
+// src/base64url.ts
+var STRICT_B64URL = /^[A-Za-z0-9_-]*$/;
+function toBase64Url(bytes) {
+  return Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(s) {
+  if (!STRICT_B64URL.test(s)) {
+    throw new Error(
+      `${JSON.stringify(s)} is not strict base64url \u2014 standard base64 ("+"/"/"/padding) is retired (protocol.md \u2192 Mandate Payload, rule 3).`
+    );
+  }
+  const padding = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
+  return new Uint8Array(Buffer.from(s + padding, "base64"));
+}
+
+// src/errors.ts
+var MANDATE_ERROR_CODES = [
+  "BOUNDS_HASH_MISMATCH",
+  "SCOPE_HASH_MISMATCH",
+  "INVALID_SIGNATURE",
+  "OWNER_NOT_COVERED",
+  "TTL_EXPIRED",
+  "PROFILE_NOT_FOUND",
+  "PROFILE_INVALID",
+  "PROFILE_HASH_MISMATCH",
+  "COVERAGE_INSUFFICIENT",
+  "MALFORMED_MANDATE",
+  "VERSION_UNSUPPORTED",
+  "OWNER_NOT_APPROVER",
+  "BOUNDS_INVALID_VALUE",
+  "SCOPE_INVALID_VALUE",
+  "ABOVE_CAP_CONFIG_INVALID",
+  "OWNER_SIGNATURE_REQUIRED",
+  "OWNER_SIGNATURE_INVALID"
+];
+var TICKET_ERROR_CODES = [
+  "MANDATE_NOT_FOUND",
+  "MANDATE_EXPIRED",
+  "MANDATE_REVOKED",
+  "BOUND_EXCEEDED",
+  "CUMULATIVE_LIMIT_EXCEEDED",
+  "COVERAGE_INSUFFICIENT",
+  "PROFILE_NOT_FOUND",
+  "INVALID_ACTION_TYPE",
+  "APPROVAL_REQUIRED",
+  "PROPOSAL_REQUIRED",
+  "PROPOSAL_NOT_FOUND",
+  "PROPOSAL_NOT_APPROVED",
+  "PROPOSAL_EXPIRED",
+  "PROPOSAL_REJECTED",
+  "PROPOSAL_MISMATCH",
+  "PROPOSAL_MANDATE_MISMATCH",
+  "PROPOSAL_ALREADY_EXECUTED",
+  "MALFORMED_TICKET_REQUEST",
+  "IDEMPOTENCY_KEY_REQUIRED",
+  "IDEMPOTENCY_MISMATCH",
+  "APPROVAL_SIGNATURE_REQUIRED",
+  "APPROVAL_SIGNATURE_INVALID"
+];
+var HapError = class extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "HapError";
+  }
+};
+
+// src/versions.ts
+var PROTOCOL_VERSION = "0.7";
+var SUPPORTED_VERSIONS = ["0.7"];
+function negotiateVersion(requested, supported = SUPPORTED_VERSIONS) {
+  const requestedVersions = requested ?? ["0.6"];
+  const common = supported.filter((v) => requestedVersions.includes(v)).sort().reverse();
+  if (common.length === 0) {
+    throw new HapError(
+      "VERSION_UNSUPPORTED",
+      `no protocol version in [${requestedVersions.join(", ")}] is supported by this implementation (supports [${supported.join(", ")}])`
+    );
+  }
+  return common[0];
+}
+
 // src/content-binding.ts
 var import_crypto = require("crypto");
 function canonicalizeText(input) {
@@ -228,6 +317,20 @@ function selectBoundFields(binding, args) {
 function computeFieldsContentHash(binding, args) {
   return computeContentHash(binding, selectBoundFields(binding, args));
 }
+var FIELD_KINDS = /* @__PURE__ */ new Set(["text", "list", "files"]);
+function invalidFieldKindsReason(binding) {
+  const kinds = binding.field_kinds;
+  if (kinds === void 0) return null;
+  if (!kinds || typeof kinds !== "object" || Array.isArray(kinds)) return "field_kinds must be an object";
+  for (const [field, kind] of Object.entries(kinds)) {
+    if (!(binding.fields ?? []).includes(field)) return `field_kinds names "${field}", which is not in fields`;
+    if (!FIELD_KINDS.has(kind)) return `field_kinds.${field} must be one of text, list, files`;
+  }
+  return null;
+}
+function filesFields(binding) {
+  return Object.entries(binding.field_kinds ?? {}).filter(([, k]) => k === "files").map(([f]) => f);
+}
 
 // src/intent-disclosure.ts
 var import_crypto2 = require("crypto");
@@ -262,9 +365,9 @@ function validateSubject(subject, opts) {
     } else if (method === "eudi") {
       if (trust_root !== "external") errors.push('eudi requires trust_root "external"');
       if (!verifier) errors.push("eudi requires a verifier");
-      if (opts?.ownerMandates !== void 0) {
-        const entry = opts.ownerMandates.find((m) => m.did === did && m.binding === "eudi");
-        if (!entry) errors.push('eudi requires an owner_mandates entry with binding "eudi" for this DID');
+      if (opts?.mandateOwners !== void 0) {
+        const entry = opts.mandateOwners.find((m) => m.did === did && m.binding === "eudi");
+        if (!entry) errors.push('eudi requires a mandate_owners entry with binding "eudi" for this DID');
       }
     } else {
       errors.push(`high assurance requires method "as_vouched" or "eudi", got "${method}"`);
@@ -288,48 +391,6 @@ function deriveIdentityLine(subject, { operatorName }) {
 
 // src/frame.ts
 var import_crypto3 = require("crypto");
-function validateFrameParams(params, profile) {
-  const errors = [];
-  if (!profile.frameSchema) {
-    return { valid: false, errors: ["Profile does not have a frameSchema"] };
-  }
-  for (const [fieldName, fieldDef] of Object.entries(profile.frameSchema.fields)) {
-    if (fieldDef.required && !(fieldName in params)) {
-      errors.push(`Missing required field: ${fieldName}`);
-    }
-  }
-  for (const [field, value] of Object.entries(params)) {
-    const fieldDef = profile.frameSchema.fields[field];
-    if (!fieldDef) {
-      errors.push(`Unknown field "${field}" not defined in profile ${profile.id}`);
-      continue;
-    }
-    if (fieldDef.type === "number" && typeof value !== "number") {
-      errors.push(`Field "${field}" must be a number, got ${typeof value}`);
-    }
-    if (fieldDef.type === "string" && typeof value !== "string") {
-      errors.push(`Field "${field}" must be a string, got ${typeof value}`);
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function canonicalFrame(params, profile) {
-  const validation = validateFrameParams(params, profile);
-  if (!validation.valid) {
-    throw new Error(`Invalid frame parameters: ${validation.errors.join("; ")}`);
-  }
-  const lines = profile.frameSchema.keyOrder.map(
-    (key) => `${key}=${String(params[key])}`
-  );
-  return lines.join("\n");
-}
-function frameHash(canonicalFrameString) {
-  const hash = (0, import_crypto3.createHash)("sha256").update(canonicalFrameString, "utf8").digest("hex");
-  return `sha256:${hash}`;
-}
-function computeFrameHash(params, profile) {
-  return frameHash(canonicalFrame(params, profile));
-}
 function validateBoundsParams(params, profile) {
   const errors = [];
   if (!profile.boundsSchema) {
@@ -355,23 +416,23 @@ function validateBoundsParams(params, profile) {
   }
   return { valid: errors.length === 0, errors };
 }
-function validateContextParams(params, profile) {
+function validateScopeParams(params, profile) {
   const errors = [];
-  if (!profile.contextSchema) {
+  if (!profile.scopeSchema) {
     if (Object.keys(params).length > 0) {
-      errors.push("Profile does not have a contextSchema but context params were provided");
+      errors.push("Profile does not have a scopeSchema but scope params were provided");
     }
     return { valid: errors.length === 0, errors };
   }
-  for (const [fieldName, fieldDef] of Object.entries(profile.contextSchema.fields)) {
+  for (const [fieldName, fieldDef] of Object.entries(profile.scopeSchema.fields)) {
     if (fieldDef.required && !(fieldName in params)) {
       errors.push(`Missing required field: ${fieldName}`);
     }
   }
   for (const [field, value] of Object.entries(params)) {
-    const fieldDef = profile.contextSchema.fields[field];
+    const fieldDef = profile.scopeSchema.fields[field];
     if (!fieldDef) {
-      errors.push(`Unknown field "${field}" not defined in contextSchema of profile ${profile.id}`);
+      errors.push(`Unknown field "${field}" not defined in scopeSchema of profile ${profile.id}`);
       continue;
     }
     if (fieldDef.type === "number" && typeof value !== "number") {
@@ -383,38 +444,6 @@ function validateContextParams(params, profile) {
   }
   return { valid: errors.length === 0, errors };
 }
-function validateBoundsRequiredFor(profile) {
-  const errors = [];
-  const boundsSchema = profile.boundsSchema;
-  if (!boundsSchema) return errors;
-  const actionTypes = boundsSchema.actionTypes ? [...boundsSchema.actionTypes] : void 0;
-  for (const [fieldName, fieldDef] of Object.entries(boundsSchema.fields)) {
-    const bt = fieldDef.boundType;
-    if (!bt) continue;
-    const requiredFor = bt.requiredFor;
-    if (requiredFor === void 0) continue;
-    if (!Array.isArray(requiredFor) || !requiredFor.every((v) => typeof v === "string")) {
-      errors.push(`Bound "${fieldName}": requiredFor must be a string array.`);
-      continue;
-    }
-    if (bt.kind !== "per_transaction") {
-      errors.push(
-        `Bound "${fieldName}": requiredFor is only meaningful on a per_transaction bound (found on kind "${bt.kind}") \u2014 every enforcement point ignores it there. Remove it.`
-      );
-      continue;
-    }
-    if (actionTypes) {
-      for (const actionType of requiredFor) {
-        if (!actionTypes.includes(actionType)) {
-          errors.push(
-            `Bound "${fieldName}": requiredFor names action type "${actionType}", which is not in this profile's boundsSchema.actionTypes registry [${actionTypes.join(", ")}]. It can never match a real execution and the requirement is dead.`
-          );
-        }
-      }
-    }
-  }
-  return errors;
-}
 var CanonicalValueError = class extends Error {
   code;
   field;
@@ -461,23 +490,23 @@ function canonicalBounds(params, profile) {
   }
   return canonicalRecords(params, profile.boundsSchema.keyOrder, "BOUNDS_INVALID_VALUE");
 }
-function canonicalContext(params, profile) {
-  if (!profile.contextSchema || Object.keys(profile.contextSchema.fields).length === 0) {
+function canonicalScope(params, profile) {
+  if (!profile.scopeSchema || Object.keys(profile.scopeSchema.fields).length === 0) {
     return "";
   }
-  const validation = validateContextParams(params, profile);
+  const validation = validateScopeParams(params, profile);
   if (!validation.valid) {
-    throw new Error(`Invalid context parameters: ${validation.errors.join("; ")}`);
+    throw new Error(`Invalid scope parameters: ${validation.errors.join("; ")}`);
   }
-  return canonicalRecords(params, profile.contextSchema.keyOrder, "CONTEXT_INVALID_VALUE");
+  return canonicalRecords(params, profile.scopeSchema.keyOrder, "SCOPE_INVALID_VALUE");
 }
 function computeBoundsHash(params, profile) {
   const canonical = canonicalBounds(params, profile);
   const hash = (0, import_crypto3.createHash)("sha256").update(canonical, "utf8").digest("hex");
   return `sha256:${hash}`;
 }
-function computeContextHash(params, profile) {
-  const canonical = canonicalContext(params, profile);
+function computeScopeHash(params, profile) {
+  const canonical = canonicalScope(params, profile);
   const hash = (0, import_crypto3.createHash)("sha256").update(canonical, "utf8").digest("hex");
   return `sha256:${hash}`;
 }
@@ -494,361 +523,672 @@ function allowedCommitmentModes(profile) {
 function isCommitmentModeAllowed(profile, mode) {
   return isSignable(mode) && allowedCommitmentModes(profile).includes(mode);
 }
-function validateCommitmentModes(profile) {
-  const declared = profile.commitment_modes;
-  if (declared === void 0) return [];
-  if (!Array.isArray(declared)) return ["commitment_modes must be a list of modes."];
-  const errors = [];
-  if (declared.length === 0) errors.push("commitment_modes is empty \u2014 no mandate could ever be signed under this profile.");
-  const seen = /* @__PURE__ */ new Set();
-  for (const m of declared) {
-    if (!isSignable(m)) errors.push(`commitment_modes: "${String(m)}" is not a mode a signer can choose (${SIGNABLE_COMMITMENT_MODES.join(", ")}).`);
-    if (seen.has(m)) errors.push(`commitment_modes: "${String(m)}" appears twice.`);
-    seen.add(m);
-  }
-  return errors;
-}
 
-// src/attestation.ts
+// src/profile.ts
 var import_crypto4 = require("crypto");
-var ed = __toESM(require("@noble/ed25519"));
-function decodeAttestationBlob(blob) {
-  try {
-    const base64 = blob.replace(/-/g, "+").replace(/_/g, "/");
-    const padding = base64.length % 4 === 0 ? "" : "=".repeat(4 - base64.length % 4);
-    const json = Buffer.from(base64 + padding, "base64").toString("utf8");
-    return JSON.parse(json);
-  } catch {
-    throw new Error("MALFORMED_ATTESTATION: Failed to decode attestation blob");
-  }
-}
-function encodeAttestationBlob(attestation) {
-  const json = JSON.stringify(attestation);
-  const base64 = Buffer.from(json, "utf8").toString("base64");
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function attestationId(blob) {
-  const hash = (0, import_crypto4.createHash)("sha256").update(blob, "utf8").digest("hex");
+function computeProfileHash(parsed) {
+  const hash = (0, import_crypto4.createHash)("sha256").update(canonicalize(parsed), "utf8").digest("hex");
   return `sha256:${hash}`;
 }
-async function verifyAttestationSignature(attestation, publicKeyHex) {
-  try {
-    const payloadJson = canonicalize(attestation.payload);
-    const payloadBytes = new TextEncoder().encode(payloadJson);
-    const signatureBytes = Buffer.from(attestation.signature, "base64");
-    const publicKeyBytes = Buffer.from(publicKeyHex, "hex");
-    const isValid = await ed.verifyAsync(signatureBytes, payloadBytes, publicKeyBytes);
-    if (!isValid) {
-      throw new Error("INVALID_SIGNATURE: Attestation signature verification failed");
+var RETIRED_PROFILE_KEYS = {
+  contextSchema: "scopeSchema",
+  ownerMandate: "ownerSignature",
+  receipt_lookup: "ticket_lookup",
+  frameSchema: "(removed \u2014 v0.3 execution frames are retired)"
+};
+function validateProfile(profile) {
+  const errors = [];
+  const p = profile;
+  for (const [retired, current] of Object.entries(RETIRED_PROFILE_KEYS)) {
+    if (retired in p) {
+      errors.push({
+        code: "PROFILE_INVALID",
+        field: retired,
+        message: `"${retired}" is retired in v0.7 \u2014 use "${current}" instead.`
+      });
     }
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("INVALID_SIGNATURE")) throw error;
-    throw new Error(`INVALID_SIGNATURE: Signature verification error: ${error}`);
   }
-}
-function checkAttestationExpiry(payload, now = Math.floor(Date.now() / 1e3)) {
-  if (payload.expires_at <= now) {
-    throw new Error(
-      `TTL_EXPIRED: Attestation expired at ${payload.expires_at}, current time is ${now}`
-    );
+  if (Array.isArray(p.requiredGates) && p.requiredGates.includes("decision_owner")) {
+    errors.push({
+      code: "PROFILE_INVALID",
+      field: "requiredGates",
+      message: '"decision_owner" is retired in v0.7 \u2014 the required gate is "mandate_owner".'
+    });
   }
-}
-function verifyFrameHash(attestation, expectedFrameHash) {
-  if (attestation.payload.frame_hash !== expectedFrameHash) {
-    throw new Error("FRAME_MISMATCH: Frame hash mismatch");
+  const boundsSchema = profile.boundsSchema;
+  if (boundsSchema) {
+    const actionTypes = boundsSchema.actionTypes ? [...boundsSchema.actionTypes] : void 0;
+    for (const [fieldName, fieldDef] of Object.entries(boundsSchema.fields)) {
+      if (fieldName === "profile") continue;
+      const routing = ["path", "paths"].filter((k) => k in fieldDef);
+      if (routing.length > 0) {
+        errors.push({
+          code: "PROFILE_INVALID",
+          field: fieldName,
+          message: `Bounds field "${fieldName}" declares ${routing.map((k) => `"${k}"`).join(" and ")} \u2014 action-routing arrays are forbidden (Bounds Schema rule 6); use actionType and appliesTo.`
+        });
+      }
+      if (!fieldDef.boundType) {
+        errors.push({
+          code: "PROFILE_INVALID",
+          field: fieldName,
+          message: `Bounds field "${fieldName}" has no boundType \u2014 enforcement semantics undefined (Bounds Schema rule 2).`
+        });
+        continue;
+      }
+      const bt = fieldDef.boundType;
+      if (fieldDef.appliesTo && (bt.kind === "per_transaction" || bt.kind === "enum")) {
+        errors.push({
+          code: "PROFILE_INVALID",
+          field: fieldName,
+          message: `Bounds field "${fieldName}": appliesTo MUST NOT be declared on a ${bt.kind} bound (Bounds Schema rule 7).`
+        });
+      }
+      if (bt.kind === "cumulative_count" && !fieldDef.appliesTo?.length) {
+        errors.push({
+          code: "PROFILE_INVALID",
+          field: fieldName,
+          message: `Bounds field "${fieldName}": a cumulative_count bound on a v0.7+ profile MUST declare appliesTo (Bounds Schema rule 7) \u2014 absence would silently throttle every action type.`
+        });
+      }
+      if (fieldDef.appliesTo && actionTypes) {
+        for (const at of fieldDef.appliesTo) {
+          if (!actionTypes.includes(at)) {
+            errors.push({
+              code: "PROFILE_INVALID",
+              field: fieldName,
+              message: `Bounds field "${fieldName}": appliesTo names "${at}", which is not in boundsSchema.actionTypes [${actionTypes.join(", ")}].`
+            });
+          }
+        }
+      }
+      if (bt.kind !== "per_transaction" && bt.requiredFor !== void 0) {
+        errors.push({
+          code: "PROFILE_INVALID",
+          field: fieldName,
+          message: `Bounds field "${fieldName}": requiredFor is only meaningful on a per_transaction bound (found on kind "${bt.kind}") \u2014 every enforcement point ignores it there. Remove it.`
+        });
+      }
+      if (bt.kind === "per_transaction" && Array.isArray(bt.requiredFor) && actionTypes) {
+        for (const at of bt.requiredFor) {
+          if (!actionTypes.includes(at)) {
+            errors.push({
+              code: "PROFILE_INVALID",
+              field: fieldName,
+              message: `Bounds field "${fieldName}": requiredFor names "${at}", which is not in boundsSchema.actionTypes [${actionTypes.join(", ")}].`
+            });
+          }
+        }
+      }
+    }
   }
-}
-function isV4Attestation(attestation) {
-  return attestation.payload.bounds_hash !== void 0;
-}
-function verifyBoundsHash(attestation, expectedBoundsHash) {
-  const attestedHash = attestation.payload.bounds_hash ?? attestation.payload.frame_hash;
-  if (attestedHash !== expectedBoundsHash) {
-    throw new Error("BOUNDS_MISMATCH: Bounds hash mismatch");
+  const declaredModes = p.commitment_modes;
+  if (declaredModes !== void 0) {
+    if (!Array.isArray(declaredModes)) {
+      errors.push({ code: "PROFILE_INVALID", field: "commitment_modes", message: "commitment_modes must be a list of modes." });
+    } else {
+      if (declaredModes.length === 0) {
+        errors.push({
+          code: "PROFILE_INVALID",
+          field: "commitment_modes",
+          message: "commitment_modes is empty \u2014 no mandate could ever be signed under this profile."
+        });
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const m of declaredModes) {
+        if (!SIGNABLE_COMMITMENT_MODES.includes(m)) {
+          errors.push({
+            code: "PROFILE_INVALID",
+            field: "commitment_modes",
+            message: `commitment_modes: "${String(m)}" is not a mode a signer can choose (${SIGNABLE_COMMITMENT_MODES.join(", ")}).`
+          });
+        }
+        if (seen.has(m)) {
+          errors.push({ code: "PROFILE_INVALID", field: "commitment_modes", message: `commitment_modes: "${String(m)}" appears twice.` });
+        }
+        seen.add(m);
+      }
+    }
   }
-}
-function verifyContextHash(attestation, expectedContextHash) {
-  if (attestation.payload.context_hash !== expectedContextHash) {
-    throw new Error("CONTEXT_MISMATCH: Context hash mismatch");
+  if (Array.isArray(declaredModes) && declaredModes.length > 0 && allowedCommitmentModes(profile).length === 0) {
+    errors.push({
+      code: "PROFILE_INVALID",
+      field: "commitment_modes",
+      message: "commitment_modes declares no mode this profile can actually use."
+    });
   }
+  return errors;
 }
-async function verifyAttestation(blob, publicKeyHex, expectedFrameHash) {
-  const attestation = decodeAttestationBlob(blob);
-  await verifyAttestationSignature(attestation, publicKeyHex);
-  checkAttestationExpiry(attestation.payload);
-  verifyFrameHash(attestation, expectedFrameHash);
-  return attestation.payload;
-}
-async function verifyAttestationV4(blob, publicKeyHex, expectedBoundsHash, expectedContextHash) {
-  const attestation = decodeAttestationBlob(blob);
-  await verifyAttestationSignature(attestation, publicKeyHex);
-  checkAttestationExpiry(attestation.payload);
-  verifyBoundsHash(attestation, expectedBoundsHash);
-  verifyContextHash(attestation, expectedContextHash);
-  return attestation.payload;
+function checkDiscloseSubset(mandateDiscloseFields, profileDiscloseFields) {
+  if (!mandateDiscloseFields || mandateDiscloseFields.length === 0) return;
+  const allowed = new Set(profileDiscloseFields ?? []);
+  const widened = mandateDiscloseFields.filter((f) => !allowed.has(f));
+  if (widened.length > 0) {
+    throw new HapError(
+      "MALFORMED_MANDATE",
+      `disclose_fields [${widened.join(", ")}] is not a subset of the profile's disclose_fields [${[...allowed].join(", ")}] \u2014 a mandate may narrow disclosure, never widen it.`
+    );
+  }
 }
 
-// src/profiles/index.ts
-var PROFILES = {};
-function registerProfile(profileId, profile) {
-  PROFILES[profileId] = profile;
+// src/mandate.ts
+var import_crypto5 = require("crypto");
+var ed = __toESM(require("@noble/ed25519"));
+
+// src/did-key.ts
+var B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var B58_MAP = {};
+for (let i = 0; i < B58_ALPHABET.length; i++) B58_MAP[B58_ALPHABET[i]] = i;
+var ED25519_MULTICODEC = Uint8Array.from([237, 1]);
+var ED25519_KEY_BYTES = 32;
+function base58btcEncode(bytes) {
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  const digits = [];
+  for (let i = zeros; i < bytes.length; i++) {
+    let carry = bytes[i];
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] * 256;
+      digits[j] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  let out = "1".repeat(zeros);
+  for (let i = digits.length - 1; i >= 0; i--) out += B58_ALPHABET[digits[i]];
+  return out;
 }
-function getProfile(profileId) {
-  return PROFILES[profileId];
+function base58btcDecode(s) {
+  let zeros = 0;
+  while (zeros < s.length && s[zeros] === "1") zeros++;
+  const bytes = [];
+  for (let i = zeros; i < s.length; i++) {
+    const val = B58_MAP[s[i]];
+    if (val === void 0) throw new Error(`invalid base58 character "${s[i]}"`);
+    let carry = val;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  const out = new Uint8Array(zeros + bytes.length);
+  for (let i = 0; i < bytes.length; i++) out[zeros + i] = bytes[bytes.length - 1 - i];
+  return out;
 }
-function listProfiles() {
-  return Object.keys(PROFILES);
+function encodeDidKey(publicKey) {
+  if (publicKey.length !== ED25519_KEY_BYTES) {
+    throw new Error(`INVALID_KEY: expected ${ED25519_KEY_BYTES} bytes, got ${publicKey.length}`);
+  }
+  const prefixed = new Uint8Array(ED25519_MULTICODEC.length + publicKey.length);
+  prefixed.set(ED25519_MULTICODEC, 0);
+  prefixed.set(publicKey, ED25519_MULTICODEC.length);
+  return `did:key:z${base58btcEncode(prefixed)}`;
 }
-function getAllProfiles() {
-  return Object.values(PROFILES);
+function decodeDidKey(did) {
+  if (!did.startsWith("did:key:z")) {
+    throw new Error(`NOT_KEY_BEARING: ${JSON.stringify(did)} is not a base58btc did:key`);
+  }
+  let decoded;
+  try {
+    decoded = base58btcDecode(did.slice("did:key:z".length));
+  } catch (err) {
+    throw new Error(`NOT_KEY_BEARING: ${err.message}`);
+  }
+  if (decoded.length !== ED25519_MULTICODEC.length + ED25519_KEY_BYTES || decoded[0] !== ED25519_MULTICODEC[0] || decoded[1] !== ED25519_MULTICODEC[1]) {
+    throw new Error("NOT_KEY_BEARING: not an ed25519-pub multicodec payload");
+  }
+  return decoded.slice(ED25519_MULTICODEC.length);
 }
-function clearProfiles() {
-  for (const key of Object.keys(PROFILES)) {
-    delete PROFILES[key];
+function isKeyBearingDid(did) {
+  try {
+    decodeDidKey(did);
+    return true;
+  } catch {
+    return false;
   }
 }
 
-// src/gatekeeper.ts
-async function verify(request, publicKeyHex, now = Math.floor(Date.now() / 1e3), executionLog) {
-  const errors = [];
-  const profileId = request.frame.profile;
-  if (typeof profileId !== "string") {
-    return { approved: false, errors: [{ code: "INVALID_PROFILE", message: "Missing profile in frame" }] };
-  }
-  const profile = getProfile(profileId);
-  if (!profile) {
-    return { approved: false, errors: [{ code: "INVALID_PROFILE", message: `Unknown profile: ${profileId}` }] };
+// src/mandate.ts
+var CLOCK_SKEW_SECONDS = 300;
+function decodeMandateBlob(blob) {
+  let json;
+  try {
+    json = new TextDecoder().decode(fromBase64Url(blob));
+  } catch (err) {
+    throw new HapError("MALFORMED_MANDATE", `failed to decode mandate blob: ${err.message}`);
   }
-  const isV4Profile = !!profile.boundsSchema;
-  if (isV4Profile) {
-    return verifyV4(request, profile, publicKeyHex, now, executionLog);
-  } else {
-    return verifyV3(request, profile, publicKeyHex, now, executionLog, errors);
+  try {
+    return JSON.parse(json);
+  } catch (err) {
+    throw new HapError("MALFORMED_MANDATE", `mandate blob did not decode to JSON: ${err}`);
   }
 }
-function noAttestationSupplied(request) {
-  return !Array.isArray(request.attestations) || request.attestations.length === 0;
+function encodeMandateBlob(mandate) {
+  return toBase64Url(new TextEncoder().encode(JSON.stringify(mandate)));
 }
-function noAttestationResult() {
-  return {
-    approved: false,
-    errors: [{ code: "MALFORMED_ATTESTATION", message: "No attestation supplied \u2014 nothing to verify" }]
-  };
+function mandateBlobId(blob) {
+  const hash = (0, import_crypto5.createHash)("sha256").update(blob, "utf8").digest("hex");
+  return `sha256:${hash}`;
 }
-async function verifyV3(request, profile, publicKeyHex, now, executionLog, errors) {
-  if (noAttestationSupplied(request)) return noAttestationResult();
-  let expectedFrameHash;
+async function signMandate(payload, privateKey, opts) {
+  const header = { typ: "HAP-mandate", alg: "EdDSA", ...opts?.kid ? { kid: opts.kid } : {} };
+  const signature = toBase64Url(await ed.signAsync(new TextEncoder().encode(canonicalize(payload)), privateKey));
+  return { header, payload, signature };
+}
+async function verifyMandateSignature(mandate, opts) {
+  const { issuer } = mandate.payload;
+  if (opts?.trustedIssuers && !opts.trustedIssuers.includes(issuer)) {
+    throw new HapError("INVALID_SIGNATURE", `issuer ${JSON.stringify(issuer)} is not a trusted Authority Server`);
+  }
+  let publicKey;
   try {
-    expectedFrameHash = computeFrameHash(request.frame, profile);
+    publicKey = decodeDidKey(issuer);
   } catch (err) {
-    return { approved: false, errors: [{ code: "FRAME_MISMATCH", message: `Frame hash computation failed: ${err}` }] };
+    throw new HapError("INVALID_SIGNATURE", `cannot resolve a key from issuer ${JSON.stringify(issuer)}: ${err.message}`);
   }
-  const requiredDomains = [];
-  const coveredDomains = /* @__PURE__ */ new Set();
-  for (const blob of request.attestations) {
-    let attestation;
-    try {
-      attestation = decodeAttestationBlob(blob);
-    } catch {
-      errors.push({ code: "MALFORMED_ATTESTATION", message: "Failed to decode attestation blob" });
-      continue;
-    }
-    try {
-      await verifyAttestationSignature(attestation, publicKeyHex);
-    } catch {
-      errors.push({ code: "INVALID_SIGNATURE", message: "Attestation signature verification failed" });
-      continue;
-    }
-    try {
-      verifyFrameHash(attestation, expectedFrameHash);
-    } catch {
-      errors.push({ code: "FRAME_MISMATCH", message: "Attestation frame_hash does not match computed frame_hash" });
-      continue;
-    }
-    try {
-      checkAttestationExpiry(attestation.payload, now);
-    } catch {
-      const domainNames = (attestation.payload.resolved_domains ?? []).map((d) => d.domain).join(", ");
-      errors.push({ code: "TTL_EXPIRED", message: `Attestation for domain "${domainNames}" has expired` });
-      continue;
-    }
-    for (const rd of attestation.payload.resolved_domains ?? []) {
-      coveredDomains.add(rd.domain);
+  if (mandate.header.kid !== void 0) {
+    const fingerprint = issuer.startsWith("did:key:") ? issuer.slice("did:key:".length) : void 0;
+    if (mandate.header.kid !== fingerprint) {
+      throw new HapError("INVALID_SIGNATURE", "header.kid disagrees with issuer's key (Mandate rule 8) \u2014 the field a verifier cannot forge wins");
     }
   }
-  for (const domain of requiredDomains) {
-    if (!coveredDomains.has(domain)) {
-      errors.push({ code: "DOMAIN_NOT_COVERED", message: `Required domain "${domain}" not covered by any valid attestation` });
-    }
+  const payloadBytes = new TextEncoder().encode(canonicalize(mandate.payload));
+  let sigBytes;
+  try {
+    sigBytes = fromBase64Url(mandate.signature);
+  } catch (err) {
+    throw new HapError("INVALID_SIGNATURE", `${err.message}`);
   }
-  if (errors.length > 0) {
-    return { approved: false, errors };
+  const isValid = await ed.verifyAsync(sigBytes, payloadBytes, publicKey).catch(() => false);
+  if (!isValid) {
+    throw new HapError("INVALID_SIGNATURE", "mandate signature verification failed");
   }
-  if (executionLog && profile.executionContextSchema?.fields) {
-    const cumulativeErrors = resolveCumulativeFields(request, profile, executionLog, now);
-    if (cumulativeErrors.length > 0) {
-      return { approved: false, errors: cumulativeErrors };
-    }
+}
+function checkMandateExpiry(payload, now = Math.floor(Date.now() / 1e3)) {
+  if (now > payload.expires_at + CLOCK_SKEW_SECONDS) {
+    throw new HapError("TTL_EXPIRED", `mandate expired at ${payload.expires_at}, current time is ${now}`);
   }
-  const boundsErrors = checkBoundsFromFrameSchema(request, profile);
-  if (boundsErrors.length > 0) {
-    return { approved: false, errors: boundsErrors };
+}
+var OWNER_SIGNATURE_FIELDS = ["alg", "signature", "signed_at", "nonce", "binding", "signing_surface"];
+function validateMandateOwners(payload) {
+  const owners = payload.mandate_owners;
+  if (!Array.isArray(owners) || owners.length !== 1) {
+    throw new HapError(
+      "MALFORMED_MANDATE",
+      `mandate_owners MUST contain exactly one entry in v0.7, got ${Array.isArray(owners) ? owners.length : typeof owners}`
+    );
+  }
+  const entry = owners[0];
+  if (!entry.did) {
+    throw new HapError("MALFORMED_MANDATE", "mandate_owners[0].did is required");
+  }
+  const present = OWNER_SIGNATURE_FIELDS.filter((f) => entry[f] !== void 0);
+  if (present.length > 0 && present.length < OWNER_SIGNATURE_FIELDS.length) {
+    const missing = OWNER_SIGNATURE_FIELDS.filter((f) => entry[f] === void 0);
+    throw new HapError(
+      "MALFORMED_MANDATE",
+      `mandate_owners[0] carries [${present.join(", ")}] but not [${missing.join(", ")}] \u2014 signature fields are present together or absent together (Mandate rule 7)`
+    );
+  }
+  if (present.length === OWNER_SIGNATURE_FIELDS.length && !isKeyBearingDid(entry.did)) {
+    throw new HapError("OWNER_SIGNATURE_INVALID", `co-signing DID ${entry.did} is not key-bearing`);
   }
-  return { approved: true };
 }
-async function verifyV4(request, profile, publicKeyHex, now, executionLog) {
-  if (noAttestationSupplied(request)) return noAttestationResult();
-  const errors = [];
-  const bounds = request.frame;
-  const context = request.context;
+async function verifyMandate(blob, opts) {
+  const mandate = decodeMandateBlob(blob);
+  if (mandate.payload.version !== PROTOCOL_VERSION) {
+    throw new HapError(
+      "VERSION_UNSUPPORTED",
+      `mandate version ${JSON.stringify(mandate.payload.version)} is not verifiable by this implementation (verifies ${PROTOCOL_VERSION} only \u2014 re-issue the mandate)`
+    );
+  }
+  await verifyMandateSignature(mandate, opts);
+  checkMandateExpiry(mandate.payload, opts?.now);
+  validateMandateOwners(mandate.payload);
+  return mandate.payload;
+}
+
+// src/owner-signature.ts
+var ed2 = __toESM(require("@noble/ed25519"));
+var OwnerSignatureError = class extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "OwnerSignatureError";
+  }
+};
+function decodeOrThrow(signature, code) {
+  try {
+    return fromBase64Url(signature);
+  } catch (err) {
+    throw new OwnerSignatureError(code, err.message);
+  }
+}
+function buildMandateProjection(payload, entry) {
+  const {
+    profile_id,
+    profile_hash,
+    bounds_hash,
+    scope_hash,
+    execution_context_hash,
+    gate_content_hashes,
+    commitment_mode,
+    expires_at
+  } = payload;
+  if (!profile_hash || !bounds_hash || !scope_hash || !commitment_mode) {
+    throw new OwnerSignatureError(
+      "MALFORMED_MANDATE",
+      "mandate projection requires profile_hash, bounds_hash, scope_hash and commitment_mode"
+    );
+  }
+  const projection = {
+    typ: "HAP-mandate-projection",
+    version: "0.7",
+    profile_id,
+    profile_hash,
+    owner_did: entry.did,
+    bounds_hash,
+    scope_hash,
+    execution_context_hash,
+    gate_content_hashes,
+    commitment_mode,
+    expires_at,
+    nonce: entry.nonce
+  };
+  if (payload.intent_disclosure_hash !== void 0) {
+    projection.intent_disclosure_hash = payload.intent_disclosure_hash;
+  }
+  if (payload.commitment_mode === "review_above_cap") {
+    projection.above_cap_caps = payload.above_cap_caps;
+    projection.above_cap_approvers = payload.above_cap_approvers;
+  }
+  if (payload.disclose_fields !== void 0) {
+    projection.disclose_fields = payload.disclose_fields;
+  }
+  return projection;
+}
+function projectionSigningBytes(projection) {
+  return new TextEncoder().encode(canonicalize(projection));
+}
+function approvalSigningBytes(approval) {
+  return new TextEncoder().encode(canonicalize(approval));
+}
+async function signMandateProjection(projection, privateKey) {
+  return toBase64Url(await ed2.signAsync(projectionSigningBytes(projection), privateKey));
+}
+async function signApproval(approval, privateKey) {
+  return toBase64Url(await ed2.signAsync(approvalSigningBytes(approval), privateKey));
+}
+async function verifyOwnerSignature(mandate, entry) {
+  const owners = mandate.payload.mandate_owners ?? [];
+  if (!owners.some((o) => o.did === entry.did)) {
+    throw new OwnerSignatureError("OWNER_SIGNATURE_INVALID", `signing DID ${entry.did} is not this mandate's mandate_owners`);
+  }
+  if (entry.alg !== void 0 && entry.alg !== "EdDSA") {
+    throw new OwnerSignatureError("OWNER_SIGNATURE_INVALID", `alg ${entry.alg} disagrees with the DID's key type (DID is authoritative)`);
+  }
+  if (!entry.signature || !entry.nonce) {
+    throw new OwnerSignatureError("OWNER_SIGNATURE_INVALID", `mandate_owners entry for ${entry.did} carries no signature to verify`);
+  }
+  let publicKey;
+  try {
+    publicKey = decodeDidKey(entry.did);
+  } catch (err) {
+    throw new OwnerSignatureError("OWNER_SIGNATURE_INVALID", err.message);
+  }
+  const projection = buildMandateProjection(mandate.payload, entry);
+  const ok = await ed2.verifyAsync(decodeOrThrow(entry.signature, "OWNER_SIGNATURE_INVALID"), projectionSigningBytes(projection), publicKey).catch(() => false);
+  if (!ok) {
+    throw new OwnerSignatureError("OWNER_SIGNATURE_INVALID", `owner signature by ${entry.did} does not verify`);
+  }
+}
+async function verifyOwnerSignatures(mandate) {
+  const entries = (mandate.payload.mandate_owners ?? []).filter((e) => e.signature !== void 0);
+  for (const entry of entries) {
+    await verifyOwnerSignature(mandate, entry);
+  }
+  return entries;
+}
+async function verifyApproval(approval, signature, signerDid) {
+  let publicKey;
+  try {
+    publicKey = decodeDidKey(signerDid);
+  } catch (err) {
+    throw new OwnerSignatureError("OWNER_SIGNATURE_INVALID", err.message);
+  }
+  const ok = await ed2.verifyAsync(decodeOrThrow(signature, "APPROVAL_SIGNATURE_INVALID"), approvalSigningBytes(approval), publicKey).catch(() => false);
+  if (!ok) {
+    throw new OwnerSignatureError("APPROVAL_SIGNATURE_INVALID", `approval signature by ${signerDid} does not verify`);
+  }
+}
+var BINDING_RANK = { raw: 0, webauthn: 1, eudi: 2 };
+function checkOwnerSignatureRequirement(payload, floor) {
+  if (!floor?.required) return;
+  const entry = payload.mandate_owners[0];
+  const signed = entry?.signature !== void 0 && entry?.binding !== void 0;
+  if (!signed) {
+    throw new OwnerSignatureError(
+      "OWNER_SIGNATURE_REQUIRED",
+      "this profile requires an owner signature and mandate_owners[0] carries none"
+    );
+  }
+  const minRank = floor.minBinding ? BINDING_RANK[floor.minBinding] : 0;
+  const haveRank = BINDING_RANK[entry.binding] ?? 0;
+  if (haveRank < minRank) {
+    throw new OwnerSignatureError(
+      "OWNER_SIGNATURE_REQUIRED",
+      `this profile requires binding >= "${floor.minBinding}", mandate_owners[0] carries "${entry.binding}"`
+    );
+  }
+}
+
+// src/ticket.ts
+var ed3 = __toESM(require("@noble/ed25519"));
+async function signTicket(payload, privateKey) {
+  const signature = toBase64Url(await ed3.signAsync(new TextEncoder().encode(canonicalize(payload)), privateKey));
+  return { ...payload, signature };
+}
+async function verifyTicketSignature(ticket, opts) {
+  const { signature, ...unsigned } = ticket;
+  if (!signature) {
+    throw new HapError("INVALID_SIGNATURE", "ticket carries no signature");
+  }
+  if (opts?.trustedIssuers && !opts.trustedIssuers.includes(ticket.issuer)) {
+    throw new HapError("INVALID_SIGNATURE", `issuer ${JSON.stringify(ticket.issuer)} is not a trusted Authority Server`);
+  }
+  let publicKey;
+  try {
+    publicKey = decodeDidKey(ticket.issuer);
+  } catch (err) {
+    throw new HapError("INVALID_SIGNATURE", `cannot resolve a key from issuer ${JSON.stringify(ticket.issuer)}: ${err.message}`);
+  }
+  const bytes = new TextEncoder().encode(canonicalize(unsigned));
+  let sigBytes;
+  try {
+    sigBytes = fromBase64Url(signature);
+  } catch (err) {
+    throw new HapError("INVALID_SIGNATURE", `${err.message}`);
+  }
+  const ok = await ed3.verifyAsync(sigBytes, bytes, publicKey).catch(() => false);
+  if (!ok) {
+    throw new HapError("INVALID_SIGNATURE", "ticket signature verification failed");
+  }
+}
+function publicTicketView(ticket, governingDiscloseFields = []) {
+  const { userId: _userId, cumulativeState: _cumulativeState, limits: _limits, executionContext, ...rest } = ticket;
+  const allowed = new Set(governingDiscloseFields);
+  const disclosedExecutionContext = {};
+  for (const [key, value] of Object.entries(executionContext)) {
+    if (allowed.has(key)) disclosedExecutionContext[key] = value;
+  }
+  return { ...rest, executionContext: disclosedExecutionContext };
+}
+
+// src/profiles/index.ts
+var PROFILES = {};
+function registerProfile(profileId, profile) {
+  PROFILES[profileId] = profile;
+}
+function getProfile(profileId) {
+  return PROFILES[profileId];
+}
+function listProfiles() {
+  return Object.keys(PROFILES);
+}
+function getAllProfiles() {
+  return Object.values(PROFILES);
+}
+function clearProfiles() {
+  for (const key of Object.keys(PROFILES)) {
+    delete PROFILES[key];
+  }
+}
+
+// src/gatekeeper.ts
+async function verify(request, opts = {}) {
+  const now = opts.now ?? Math.floor(Date.now() / 1e3);
+  const profileId = request.bounds.profile;
+  if (typeof profileId !== "string") {
+    return { approved: false, errors: [{ code: "PROFILE_NOT_FOUND", message: "Missing profile in bounds" }] };
+  }
+  const profile = getProfile(profileId);
+  if (!profile) {
+    return { approved: false, errors: [{ code: "PROFILE_NOT_FOUND", message: `Unknown profile: ${profileId}` }] };
+  }
+  if (!Array.isArray(request.mandates) || request.mandates.length === 0) {
+    return { approved: false, errors: [{ code: "MALFORMED_MANDATE", message: "No mandate supplied \u2014 nothing to verify" }] };
+  }
+  const bounds = request.bounds;
+  const scope = request.scope;
   let expectedBoundsHash;
-  let expectedContextHash;
   try {
     expectedBoundsHash = computeBoundsHash(bounds, profile);
   } catch (err) {
-    return { approved: false, errors: [{ code: "BOUNDS_MISMATCH", message: `Bounds hash computation failed: ${err}` }] };
-  }
-  if (context && Object.keys(context).length > 0) {
-    try {
-      expectedContextHash = computeContextHash(context, profile);
-    } catch (err) {
-      return { approved: false, errors: [{ code: "CONTEXT_MISMATCH", message: `Context hash computation failed: ${err}` }] };
+    if (err instanceof CanonicalValueError) {
+      return { approved: false, errors: [{ code: err.code, field: err.field, message: err.message }] };
     }
+    return { approved: false, errors: [{ code: "BOUNDS_HASH_MISMATCH", message: `Bounds hash computation failed: ${err}` }] };
   }
-  const requiredDomains = [];
-  const coveredDomains = /* @__PURE__ */ new Set();
-  for (const blob of request.attestations) {
-    let attestation;
-    try {
-      attestation = decodeAttestationBlob(blob);
-    } catch {
-      errors.push({ code: "MALFORMED_ATTESTATION", message: "Failed to decode attestation blob" });
-      continue;
-    }
+  let expectedScopeHash;
+  if (scope && Object.keys(scope).length > 0) {
     try {
-      await verifyAttestationSignature(attestation, publicKeyHex);
-    } catch {
-      errors.push({ code: "INVALID_SIGNATURE", message: "Attestation signature verification failed" });
-      continue;
-    }
-    try {
-      verifyBoundsHash(attestation, expectedBoundsHash);
-    } catch {
-      errors.push({ code: "BOUNDS_MISMATCH", message: "Attestation bounds_hash does not match computed bounds_hash" });
-      continue;
-    }
-    if (isV4Attestation(attestation) && expectedContextHash) {
-      try {
-        verifyContextHash(attestation, expectedContextHash);
-      } catch {
-        errors.push({ code: "CONTEXT_MISMATCH", message: "Attestation context_hash does not match computed context_hash" });
-        continue;
+      expectedScopeHash = computeScopeHash(scope, profile);
+    } catch (err) {
+      if (err instanceof CanonicalValueError) {
+        return { approved: false, errors: [{ code: err.code, field: err.field, message: err.message }] };
       }
-    }
-    try {
-      checkAttestationExpiry(attestation.payload, now);
-    } catch {
-      const domainNames = (attestation.payload.resolved_domains ?? []).map((d) => d.domain).join(", ");
-      errors.push({ code: "TTL_EXPIRED", message: `Attestation for domain "${domainNames}" has expired` });
-      continue;
-    }
-    for (const rd of attestation.payload.resolved_domains ?? []) {
-      coveredDomains.add(rd.domain);
+      return { approved: false, errors: [{ code: "SCOPE_HASH_MISMATCH", message: `Scope hash computation failed: ${err}` }] };
     }
   }
-  for (const domain of requiredDomains) {
-    if (!coveredDomains.has(domain)) {
-      errors.push({ code: "DOMAIN_NOT_COVERED", message: `Required domain "${domain}" not covered by any valid attestation` });
-    }
+  const expectedProfileHash = computeProfileHash(profile);
+  const errors = [];
+  for (const blob of request.mandates) {
+    const mandateErrors = await verifyOneMandate(blob, {
+      expectedBoundsHash,
+      expectedScopeHash,
+      expectedProfileHash,
+      trustedIssuers: opts.trustedIssuers,
+      now
+    });
+    errors.push(...mandateErrors);
   }
   if (errors.length > 0) {
     return { approved: false, errors };
   }
-  const v4BoundsErrors = checkBoundsV4(request, profile, executionLog, now);
-  if (v4BoundsErrors.length > 0) {
-    return { approved: false, errors: v4BoundsErrors };
+  const actionType = typeof request.execution.action_type === "string" ? request.execution.action_type : void 0;
+  const registry = profile.boundsSchema?.actionTypes;
+  if (registry && registry.length > 0) {
+    if (actionType === void 0 || !registry.includes(actionType)) {
+      return {
+        approved: false,
+        errors: [{
+          code: "INVALID_ACTION_TYPE",
+          field: "action_type",
+          message: `action_type ${JSON.stringify(actionType)} is not in profile ${profile.id}'s actionTypes registry [${registry.join(", ")}]`
+        }]
+      };
+    }
+  }
+  const boundsErrors = checkBounds(request, profile, actionType);
+  if (boundsErrors.length > 0) {
+    return { approved: false, errors: boundsErrors };
   }
-  if (profile.contextSchema && Object.keys(profile.contextSchema.fields).length > 0) {
-    const enforceableFields = Object.entries(profile.contextSchema.fields).filter(([, def]) => def.constraint?.enforceable?.length);
-    if (enforceableFields.length > 0 && !context) {
+  if (profile.scopeSchema && Object.keys(profile.scopeSchema.fields).length > 0) {
+    const enforceableFields = Object.entries(profile.scopeSchema.fields).filter(([, def]) => def.constraint?.enforceable?.length);
+    if (enforceableFields.length > 0 && !scope) {
       return {
         approved: false,
         errors: [{
           code: "BOUND_EXCEEDED",
-          message: `Declared context required for constraint enforcement but not provided. Fields: ${enforceableFields.map(([n]) => n).join(", ")}`
+          message: `Declared scope required for constraint enforcement but not provided. Fields: ${enforceableFields.map(([n]) => n).join(", ")}`
         }]
       };
     }
-    if (context) {
-      const contextErrors = checkContextConstraints(context, request.execution, profile);
-      if (contextErrors.length > 0) {
-        return { approved: false, errors: contextErrors };
+    if (scope) {
+      const scopeErrors = checkScopeConstraints(scope, request.execution, profile);
+      if (scopeErrors.length > 0) {
+        return { approved: false, errors: scopeErrors };
       }
     }
   }
   return { approved: true };
 }
-function checkBoundsFromFrameSchema(request, profile) {
-  const errors = [];
-  if (!profile.frameSchema) return errors;
-  for (const [fieldName, fieldDef] of Object.entries(profile.frameSchema.fields)) {
-    if (!fieldDef.constraint) continue;
-    const constraint = fieldDef.constraint;
-    for (const enforceType of constraint.enforceable) {
-      if (enforceType === "max") {
-        const execField = fieldName.replace(/_max$/, "");
-        const boundValue = request.frame[fieldName];
-        const actualValue = request.execution[execField];
-        if (actualValue === void 0) continue;
-        if (typeof boundValue !== "number" || typeof actualValue !== "number") {
-          errors.push({
-            code: "BOUND_EXCEEDED",
-            field: execField,
-            message: `Bound check requires numeric values for "${execField}"`,
-            bound: boundValue,
-            actual: actualValue
-          });
-          continue;
-        }
-        if (actualValue > boundValue) {
-          errors.push({
-            code: "BOUND_EXCEEDED",
-            field: execField,
-            message: `Value ${actualValue} exceeds authorized maximum of ${boundValue}`,
-            bound: boundValue,
-            actual: actualValue
-          });
-        }
-      }
-      if (enforceType === "enum") {
-        const boundValue = request.frame[fieldName];
-        const actualValue = request.execution[fieldName];
-        if (actualValue === void 0) continue;
-        const allowed = typeof boundValue === "string" ? boundValue.split(",").map((s) => s.trim()) : [String(boundValue)];
-        const actualStr = String(actualValue);
-        if (!allowed.includes(actualStr)) {
-          errors.push({
-            code: "BOUND_EXCEEDED",
-            field: fieldName,
-            message: `Value "${actualStr}" not in authorized values [${allowed.join(", ")}]`,
-            bound: boundValue,
-            actual: actualValue
-          });
-        }
-      }
-    }
+function codeFromThrown(err) {
+  if (err instanceof HapError) return err.code;
+  if (err instanceof Error) {
+    const [prefix] = err.message.split(":");
+    return prefix;
   }
-  return errors;
+  return "MALFORMED_MANDATE";
 }
-function boundGovernsAction(fieldName, fieldDef, bt, actionType) {
-  if (fieldDef.appliesTo) {
-    return actionType ? fieldDef.appliesTo.includes(actionType) : true;
+async function verifyOneMandate(blob, opts) {
+  let mandate;
+  try {
+    mandate = decodeMandateBlob(blob);
+  } catch (err) {
+    return [{ code: "MALFORMED_MANDATE", message: err.message }];
   }
-  if (bt.kind !== "cumulative_count" || !actionType) return true;
-  const prefix = fieldName.replace(/_(?:daily|monthly|weekly)_max$/, "");
-  const namedForAnAction = prefix !== fieldName;
-  const matches = prefix === actionType || prefix.startsWith("transaction");
-  return !namedForAnAction || matches;
+  if (mandate.payload.version !== PROTOCOL_VERSION) {
+    return [{
+      code: "VERSION_UNSUPPORTED",
+      message: `mandate version ${JSON.stringify(mandate.payload.version)} is not verifiable by this Gatekeeper (verifies ${PROTOCOL_VERSION} only)`
+    }];
+  }
+  try {
+    await verifyMandateSignature(mandate, { trustedIssuers: opts.trustedIssuers });
+  } catch (err) {
+    return [{ code: codeFromThrown(err), message: err.message }];
+  }
+  try {
+    checkMandateExpiry(mandate.payload, opts.now);
+  } catch (err) {
+    return [{ code: codeFromThrown(err), message: err.message }];
+  }
+  try {
+    validateMandateOwners(mandate.payload);
+  } catch (err) {
+    return [{ code: codeFromThrown(err), message: err.message }];
+  }
+  const errors = [];
+  const payload = mandate.payload;
+  if (payload.bounds_hash !== opts.expectedBoundsHash) {
+    errors.push({ code: "BOUNDS_HASH_MISMATCH", message: "Mandate bounds_hash does not match the recomputed bounds_hash" });
+  }
+  if (opts.expectedScopeHash !== void 0 && payload.scope_hash !== opts.expectedScopeHash) {
+    errors.push({ code: "SCOPE_HASH_MISMATCH", message: "Mandate scope_hash does not match the recomputed scope_hash" });
+  }
+  if (payload.profile_hash !== opts.expectedProfileHash) {
+    errors.push({ code: "PROFILE_HASH_MISMATCH", message: "Mandate profile_hash does not match the Gatekeeper's provisioned profile bytes" });
+  }
+  return errors;
 }
 function boundActionTypes(fieldName, fieldDef) {
   if (fieldDef.appliesTo) return fieldDef.appliesTo;
@@ -858,29 +1198,25 @@ function boundActionTypes(fieldName, fieldDef) {
   if (prefix === fieldName || prefix.startsWith("transaction")) return void 0;
   return [prefix];
 }
-function checkBoundsV4(request, profile, executionLog, now) {
+function checkBounds(request, profile, actionType) {
   const errors = [];
   if (!profile.boundsSchema) return errors;
-  const bounds = request.frame;
-  const profileId = String(bounds.profile ?? profile.id);
-  const actionType = typeof request.execution.action_type === "string" ? request.execution.action_type : void 0;
-  const path = request.path ?? (bounds.path ? String(bounds.path) : "");
+  const bounds = request.bounds;
   for (const [fieldName, fieldDef] of Object.entries(profile.boundsSchema.fields)) {
-    if (fieldName === "profile" || fieldName === "path") continue;
+    if (fieldName === "profile") continue;
     const boundValue = bounds[fieldName];
     if (boundValue === void 0) continue;
     const bt = fieldDef.boundType;
     if (!bt) {
       errors.push({
-        code: "BOUND_EXCEEDED",
+        code: "PROFILE_INVALID",
         field: fieldName,
-        message: `Profile ${profile.id} bound "${fieldName}" has no boundType \u2014 enforcement semantics undefined. Add boundType to the profile's boundsSchema.`,
+        message: `Profile ${profile.id} bound "${fieldName}" has no boundType \u2014 enforcement semantics undefined.`,
         bound: boundValue,
         actual: boundValue
       });
       continue;
     }
-    if (!boundGovernsAction(fieldName, fieldDef, bt, actionType)) continue;
     switch (bt.kind) {
       case "per_transaction": {
         const actual = request.execution[bt.of];
@@ -922,72 +1258,6 @@ function checkBoundsV4(request, profile, executionLog, now) {
         }
         break;
       }
-      case "cumulative_sum": {
-        if (typeof boundValue !== "number") {
-          errors.push({
-            code: "CUMULATIVE_LIMIT_EXCEEDED",
-            field: bt.of,
-            message: `Cumulative bound "${fieldName}" must be numeric`,
-            bound: boundValue,
-            actual: 0
-          });
-          break;
-        }
-        if (!executionLog) break;
-        const runningTotal = executionLog.sumByWindow(
-          profileId,
-          path,
-          bt.of,
-          bt.window,
-          now,
-          boundActionTypes(fieldName, fieldDef)
-        );
-        const currentRaw = request.execution[bt.of];
-        const current = typeof currentRaw === "number" ? currentRaw : currentRaw !== void 0 ? Number(currentRaw) : 0;
-        const total = runningTotal + current;
-        if (total > boundValue) {
-          errors.push({
-            code: "CUMULATIVE_LIMIT_EXCEEDED",
-            field: bt.of,
-            message: `Cumulative ${bt.window} sum of ${bt.of} (${total}) exceeds limit of ${boundValue} for ${fieldName}`,
-            bound: boundValue,
-            actual: total
-          });
-        }
-        break;
-      }
-      case "cumulative_count": {
-        if (typeof boundValue !== "number") {
-          errors.push({
-            code: "CUMULATIVE_LIMIT_EXCEEDED",
-            field: fieldName,
-            message: `Cumulative count bound "${fieldName}" must be numeric`,
-            bound: boundValue,
-            actual: 0
-          });
-          break;
-        }
-        if (!executionLog) break;
-        const runningCount = executionLog.sumByWindow(
-          profileId,
-          path,
-          "_count",
-          bt.window,
-          now,
-          boundActionTypes(fieldName, fieldDef)
-        );
-        const total = runningCount + 1;
-        if (total > boundValue) {
-          errors.push({
-            code: "CUMULATIVE_LIMIT_EXCEEDED",
-            field: fieldName,
-            message: `Cumulative ${bt.window} count (${total}) exceeds limit of ${boundValue} for ${fieldName}`,
-            bound: boundValue,
-            actual: total
-          });
-        }
-        break;
-      }
       case "enum": {
         if (typeof boundValue === "string" && !bt.values.includes(boundValue)) {
           errors.push({
@@ -1000,18 +1270,21 @@ function checkBoundsV4(request, profile, executionLog, now) {
         }
         break;
       }
+      case "cumulative_sum":
+      case "cumulative_count":
+        break;
     }
   }
   return errors;
 }
-function checkContextConstraints(context, execution, profile) {
+function checkScopeConstraints(scope, execution, profile) {
   const errors = [];
-  if (!profile.contextSchema) return errors;
-  for (const [fieldName, fieldDef] of Object.entries(profile.contextSchema.fields)) {
+  if (!profile.scopeSchema) return errors;
+  for (const [fieldName, fieldDef] of Object.entries(profile.scopeSchema.fields)) {
     if (!fieldDef.constraint) continue;
     const requiredFor = fieldDef.constraint.requiredFor;
     if (requiredFor?.length) {
-      const boundValue = context[fieldName];
+      const boundValue = scope[fieldName];
       const actualValue = execution[fieldName];
       const actionType = execution["action_type"];
       const constrained = boundValue !== void 0 && boundValue !== "";
@@ -1028,7 +1301,7 @@ function checkContextConstraints(context, execution, profile) {
     }
     for (const enforceType of fieldDef.constraint.enforceable) {
       if (enforceType === "enum") {
-        const boundValue = context[fieldName];
+        const boundValue = scope[fieldName];
         const actualValue = execution[fieldName];
         if (actualValue === void 0) continue;
         const allowed = typeof boundValue === "string" ? boundValue.split(",").map((s) => s.trim()) : [String(boundValue)];
@@ -1037,14 +1310,14 @@ function checkContextConstraints(context, execution, profile) {
           errors.push({
             code: "BOUND_EXCEEDED",
             field: fieldName,
-            message: `Value "${actualStr}" not in authorized context values [${allowed.join(", ")}]`,
+            message: `Value "${actualStr}" not in authorized scope values [${allowed.join(", ")}]`,
             bound: boundValue,
             actual: actualValue
           });
         }
       }
       if (enforceType === "subset") {
-        const boundValue = context[fieldName];
+        const boundValue = scope[fieldName];
         const actualValue = execution[fieldName];
         if (boundValue === void 0 || boundValue === "") continue;
         if (actualValue === void 0 || actualValue === "") continue;
@@ -1065,304 +1338,74 @@ function checkContextConstraints(context, execution, profile) {
   }
   return errors;
 }
-function resolveCumulativeFields(request, profile, executionLog, now) {
-  const errors = [];
-  const profileId = String(request.frame.profile);
-  const boundsOrFrame = request.frame;
-  for (const [fieldName, fieldDef] of Object.entries(profile.executionContextSchema.fields)) {
-    if (fieldDef.source !== "cumulative") continue;
-    const cumDef = fieldDef;
-    const { cumulativeField, window: windowType } = cumDef;
-    const path = request.frame.path ? String(request.frame.path) : "";
-    const runningTotal = executionLog.sumByWindow(profileId, path, cumulativeField, windowType, now);
-    let currentContribution;
-    if (cumulativeField === "_count") {
-      currentContribution = 1;
-    } else {
-      const val = request.execution[cumulativeField];
-      currentContribution = typeof val === "number" ? val : val !== void 0 ? Number(val) : 0;
-    }
-    const cumulativeValue = runningTotal + currentContribution;
-    request.execution[fieldName] = cumulativeValue;
-    const boundFieldName = fieldName + "_max";
-    const boundValue = boundsOrFrame[boundFieldName];
-    if (boundValue === void 0) continue;
-    if (typeof boundValue !== "number") {
-      errors.push({
-        code: "CUMULATIVE_LIMIT_EXCEEDED",
-        field: fieldName,
-        message: `Cumulative bound requires numeric value for "${boundFieldName}"`,
-        bound: boundValue,
-        actual: cumulativeValue
-      });
-      continue;
-    }
-    if (cumulativeValue > boundValue) {
-      errors.push({
-        code: "CUMULATIVE_LIMIT_EXCEEDED",
-        field: fieldName,
-        message: `Cumulative ${windowType} value ${cumulativeValue} exceeds limit of ${boundValue}`,
-        bound: boundValue,
-        actual: cumulativeValue
-      });
-    }
-  }
-  return errors;
-}
-
-// src/did-key.ts
-var B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-var B58_MAP = {};
-for (let i = 0; i < B58_ALPHABET.length; i++) B58_MAP[B58_ALPHABET[i]] = i;
-var ED25519_MULTICODEC = Uint8Array.from([237, 1]);
-var ED25519_KEY_BYTES = 32;
-function base58btcEncode(bytes) {
-  let zeros = 0;
-  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
-  const digits = [];
-  for (let i = zeros; i < bytes.length; i++) {
-    let carry = bytes[i];
-    for (let j = 0; j < digits.length; j++) {
-      carry += digits[j] * 256;
-      digits[j] = carry % 58;
-      carry = carry / 58 | 0;
-    }
-    while (carry > 0) {
-      digits.push(carry % 58);
-      carry = carry / 58 | 0;
-    }
-  }
-  let out = "1".repeat(zeros);
-  for (let i = digits.length - 1; i >= 0; i--) out += B58_ALPHABET[digits[i]];
-  return out;
-}
-function base58btcDecode(s) {
-  let zeros = 0;
-  while (zeros < s.length && s[zeros] === "1") zeros++;
-  const bytes = [];
-  for (let i = zeros; i < s.length; i++) {
-    const val = B58_MAP[s[i]];
-    if (val === void 0) throw new Error(`invalid base58 character "${s[i]}"`);
-    let carry = val;
-    for (let j = 0; j < bytes.length; j++) {
-      carry += bytes[j] * 58;
-      bytes[j] = carry & 255;
-      carry >>= 8;
-    }
-    while (carry > 0) {
-      bytes.push(carry & 255);
-      carry >>= 8;
-    }
-  }
-  const out = new Uint8Array(zeros + bytes.length);
-  for (let i = 0; i < bytes.length; i++) out[zeros + i] = bytes[bytes.length - 1 - i];
-  return out;
-}
-function encodeDidKey(publicKey) {
-  if (publicKey.length !== ED25519_KEY_BYTES) {
-    throw new Error(`INVALID_KEY: expected ${ED25519_KEY_BYTES} bytes, got ${publicKey.length}`);
-  }
-  const prefixed = new Uint8Array(ED25519_MULTICODEC.length + publicKey.length);
-  prefixed.set(ED25519_MULTICODEC, 0);
-  prefixed.set(publicKey, ED25519_MULTICODEC.length);
-  return `did:key:z${base58btcEncode(prefixed)}`;
-}
-function decodeDidKey(did) {
-  if (!did.startsWith("did:key:z")) {
-    throw new Error(`NOT_KEY_BEARING: ${JSON.stringify(did)} is not a base58btc did:key`);
-  }
-  let decoded;
-  try {
-    decoded = base58btcDecode(did.slice("did:key:z".length));
-  } catch (err) {
-    throw new Error(`NOT_KEY_BEARING: ${err.message}`);
-  }
-  if (decoded.length !== ED25519_MULTICODEC.length + ED25519_KEY_BYTES || decoded[0] !== ED25519_MULTICODEC[0] || decoded[1] !== ED25519_MULTICODEC[1]) {
-    throw new Error("NOT_KEY_BEARING: not an ed25519-pub multicodec payload");
-  }
-  return decoded.slice(ED25519_MULTICODEC.length);
-}
-function isKeyBearingDid(did) {
-  try {
-    decodeDidKey(did);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/mandate.ts
-var ed2 = __toESM(require("@noble/ed25519"));
-var MandateError = class extends Error {
-  constructor(code, message) {
-    super(`${code}: ${message}`);
-    this.code = code;
-    this.name = "MandateError";
-  }
-};
-function buildMandateProjection(payload, entry) {
-  const { profile_id, bounds_hash, context_hash, execution_context_hash, gate_content_hashes, commitment_mode, expires_at } = payload;
-  if (!bounds_hash || !context_hash || !commitment_mode) {
-    throw new MandateError("MALFORMED_ATTESTATION", "mandate projection requires bounds_hash, context_hash and commitment_mode");
-  }
-  const projection = {
-    typ: "HAP-mandate",
-    version: "0.6",
-    profile_id,
-    owner_did: entry.did,
-    bounds_hash,
-    context_hash,
-    execution_context_hash,
-    gate_content_hashes,
-    commitment_mode,
-    expires_at,
-    nonce: entry.nonce
-  };
-  if (payload.intent_disclosure_hash !== void 0) {
-    projection.intent_disclosure_hash = payload.intent_disclosure_hash;
-  }
-  return projection;
-}
-function mandateSigningBytes(projection) {
-  return new TextEncoder().encode(canonicalize(projection));
-}
-function approvalSigningBytes(approval) {
-  return new TextEncoder().encode(canonicalize(approval));
-}
-function base64urlToBytes(s) {
-  const base64 = s.replace(/-/g, "+").replace(/_/g, "/");
-  const padding = base64.length % 4 === 0 ? "" : "=".repeat(4 - base64.length % 4);
-  return new Uint8Array(Buffer.from(base64 + padding, "base64"));
-}
-function bytesToBase64url(bytes) {
-  return Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-async function signMandateProjection(projection, privateKey) {
-  const sig = await ed2.signAsync(mandateSigningBytes(projection), privateKey);
-  return bytesToBase64url(sig);
-}
-async function signApproval(approval, privateKey) {
-  const sig = await ed2.signAsync(approvalSigningBytes(approval), privateKey);
-  return bytesToBase64url(sig);
-}
-async function verifyOwnerMandate(attestation, entry) {
-  const owners = attestation.payload.resolved_owners ?? [];
-  if (!owners.includes(entry.did)) {
-    throw new MandateError("OWNER_NOT_RESOLVED", `signing DID ${entry.did} is not in resolved_owners`);
-  }
-  if (entry.alg !== "EdDSA") {
-    throw new MandateError("MANDATE_SIGNATURE_INVALID", `alg ${entry.alg} disagrees with the DID's key type (DID is authoritative)`);
-  }
-  let publicKey;
-  try {
-    publicKey = decodeDidKey(entry.did);
-  } catch (err) {
-    throw new MandateError("NOT_KEY_BEARING", err.message);
-  }
-  const projection = buildMandateProjection(attestation.payload, entry);
-  const ok = await ed2.verifyAsync(base64urlToBytes(entry.signature), mandateSigningBytes(projection), publicKey);
-  if (!ok) {
-    throw new MandateError("MANDATE_SIGNATURE_INVALID", `owner mandate signature by ${entry.did} does not verify`);
-  }
-}
-async function verifyOwnerMandates(attestation) {
-  const entries = attestation.payload.owner_mandates ?? [];
-  for (const entry of entries) {
-    await verifyOwnerMandate(attestation, entry);
-  }
-  return entries;
-}
-async function verifyApproval(approval, signature, signerDid) {
-  let publicKey;
-  try {
-    publicKey = decodeDidKey(signerDid);
-  } catch (err) {
-    throw new MandateError("NOT_KEY_BEARING", err.message);
-  }
-  const ok = await ed2.verifyAsync(base64urlToBytes(signature), approvalSigningBytes(approval), publicKey);
-  if (!ok) {
-    throw new MandateError("APPROVAL_SIGNATURE_INVALID", `approval signature by ${signerDid} does not verify`);
-  }
-}
-
-// src/receipt.ts
-var ed3 = __toESM(require("@noble/ed25519"));
-async function verifyReceiptSignature(receipt, publicKeyHex) {
-  const { signature, ...unsigned } = receipt;
-  if (!signature) {
-    throw new Error("INVALID_SIGNATURE: receipt carries no signature");
-  }
-  const bytes = new TextEncoder().encode(canonicalize(unsigned));
-  const base64 = signature.replace(/-/g, "+").replace(/_/g, "/");
-  const padding = base64.length % 4 === 0 ? "" : "=".repeat(4 - base64.length % 4);
-  const sigBytes = new Uint8Array(Buffer.from(base64 + padding, "base64"));
-  const publicKeyBytes = new Uint8Array(Buffer.from(publicKeyHex, "hex"));
-  const ok = await ed3.verifyAsync(sigBytes, bytes, publicKeyBytes).catch(() => false);
-  if (!ok) {
-    throw new Error("INVALID_SIGNATURE: receipt signature verification failed");
-  }
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CanonicalValueError,
   ContentBindingError,
-  MandateError,
+  HapError,
+  MANDATE_ERROR_CODES,
+  OwnerSignatureError,
+  PROTOCOL_VERSION,
   SIGNABLE_COMMITMENT_MODES,
+  SUPPORTED_VERSIONS,
+  TICKET_ERROR_CODES,
   allowedCommitmentModes,
   approvalSigningBytes,
-  attestationId,
   bindingAppliesTo,
   boundActionTypes,
   buildMandateProjection,
   canonicalBounds,
-  canonicalContext,
-  canonicalFrame,
+  canonicalScope,
   canonicalize,
   canonicalizeText,
-  checkAttestationExpiry,
+  checkDiscloseSubset,
+  checkMandateExpiry,
+  checkOwnerSignatureRequirement,
   clearProfiles,
   computeBoundsHash,
   computeContentHash,
-  computeContextHash,
   computeFieldsContentHash,
-  computeFrameHash,
   computeIntentDisclosureHash,
   computeIntentHash,
+  computeProfileHash,
+  computeScopeHash,
   contentCanonicalBytes,
-  decodeAttestationBlob,
   decodeDidKey,
+  decodeMandateBlob,
   deriveIdentityLine,
-  encodeAttestationBlob,
   encodeDidKey,
-  frameHash,
+  encodeMandateBlob,
+  filesFields,
+  fromBase64Url,
   getAllProfiles,
   getProfile,
   intentDisclosureCanonicalBytes,
+  invalidFieldKindsReason,
   isCommitmentModeAllowed,
   isFieldBinding,
   isKeyBearingDid,
-  isV4Attestation,
   listProfiles,
-  mandateSigningBytes,
+  mandateBlobId,
+  negotiateVersion,
+  projectionSigningBytes,
+  publicTicketView,
   registerProfile,
   selectBoundFields,
   signApproval,
+  signMandate,
   signMandateProjection,
+  signTicket,
+  toBase64Url,
   validateBoundsParams,
-  validateBoundsRequiredFor,
-  validateCommitmentModes,
-  validateContextParams,
-  validateFrameParams,
+  validateMandateOwners,
+  validateProfile,
+  validateScopeParams,
   validateSubject,
   verify,
   verifyApproval,
-  verifyAttestation,
-  verifyAttestationSignature,
-  verifyAttestationV4,
-  verifyBoundsHash,
-  verifyContextHash,
-  verifyFrameHash,
-  verifyOwnerMandate,
-  verifyOwnerMandates,
-  verifyReceiptSignature
+  verifyMandate,
+  verifyMandateSignature,
+  verifyOwnerSignature,
+  verifyOwnerSignatures,
+  verifyTicketSignature
 });