@devlab.group/agent-commerce 2.1.0 → 2.2.0

package/dist/cli/ap2-MBMQHFX4.js

@@ -0,0 +1,678 @@
+import { buildAp2Descriptor } from './chunk-3EQBCFZY.js';
+export { AP2_CAPABILITIES, AP2_UNSUPPORTED, buildAp2Descriptor } from './chunk-3EQBCFZY.js';
+import { openSqliteDatabase } from './chunk-3MGAJ5FX.js';
+import { AP2_CHECKOUT_PROFILE, AP2_SIGNING_ALGORITHM, AP2_SPEC_VERSION, AP2_KEY_TYPE, AP2_JWK_CURVE, AP2_DIGEST_ALGORITHM, AP2_CHECKOUT_MANDATE_VCT } from './chunk-FHCFR2GS.js';
+export { AP2_CHECKOUT_MANDATE_VCT, AP2_CHECKOUT_PROFILE, AP2_DEFAULT_CLOCK_SKEW_SECONDS, AP2_DIGEST_ALGORITHM, AP2_MAX_CLOCK_SKEW_SECONDS, AP2_MODES, AP2_SIGNING_ALGORITHM, AP2_SPEC_VERSION } from './chunk-FHCFR2GS.js';
+import { PACKAGE_VERSION } from './chunk-FRMLWGSS.js';
+import { NOOP_LOGGER, systemClock, CommerceError } from './chunk-QQ3WY5L3.js';
+import { isRecord } from './chunk-3M6U7ILB.js';
+import { SignJWT, importPKCS8, importJWK, jwtVerify, decodeProtectedHeader, decodeJwt } from 'jose';
+import canonicalize from 'canonicalize';
+import { createHash } from 'crypto';
+import { decodeSdJwt, splitSdJwt, getClaims } from '@sd-jwt/core';
+
+// src/authorization/ap2/errors.ts
+var AP2_REJECTION_REASONS = [
+  "malformed_presentation",
+  "untrusted_issuer",
+  "unknown_key",
+  "invalid_signature",
+  "invalid_claims",
+  "expired",
+  "wrong_audience",
+  "unsupported_mandate_type",
+  "checkout_binding_failed",
+  "purchase_mismatch"
+];
+var MESSAGES = {
+  malformed_presentation: "The authorization is not a well-formed SD-JWT presentation.",
+  untrusted_issuer: "The mandate was issued by a party this merchant does not trust.",
+  unknown_key: "The mandate names a signing key this merchant does not trust.",
+  invalid_signature: "The mandate signature did not verify.",
+  invalid_claims: "The mandate is missing required claims or they are malformed.",
+  expired: "The mandate is expired or not yet valid.",
+  wrong_audience: "The mandate is addressed to a different audience.",
+  unsupported_mandate_type: "The mandate is not a closed Direct Checkout Mandate.",
+  checkout_binding_failed: "The merchant checkout document bound to the mandate did not verify.",
+  purchase_mismatch: "The mandate does not authorize this purchase."
+};
+function ap2Rejected(reason, context = {}) {
+  return new CommerceError("AUTHORIZATION_INVALID", MESSAGES[reason], {
+    details: { method: "ap2", reason },
+    ...context.requestId !== void 0 ? { requestId: context.requestId } : {},
+    ...context.resourceId !== void 0 ? { resourceId: context.resourceId } : {},
+    ...context.cause !== void 0 ? { cause: context.cause } : {}
+  });
+}
+function ap2Replayed(state, context = {}) {
+  return new CommerceError(
+    "AUTHORIZATION_REPLAYED",
+    "This mandate has already been presented and cannot authorize another purchase.",
+    {
+      details: { method: "ap2", reason: "replayed", state },
+      ...context.requestId !== void 0 ? { requestId: context.requestId } : {},
+      ...context.resourceId !== void 0 ? { resourceId: context.resourceId } : {}
+    }
+  );
+}
+function ap2Unavailable(detail, context = {}) {
+  return new CommerceError(
+    "AUTHORIZATION_PROVIDER_UNAVAILABLE",
+    "Authorization could not be verified right now. This is a merchant-side fault, not a problem with the presented mandate.",
+    {
+      details: { method: "ap2", reason: "verifier_unavailable", detail },
+      ...context.requestId !== void 0 ? { requestId: context.requestId } : {},
+      ...context.resourceId !== void 0 ? { resourceId: context.resourceId } : {},
+      ...context.cause !== void 0 ? { cause: context.cause } : {}
+    }
+  );
+}
+function sha256(data) {
+  return createHash("sha256").update(data).digest();
+}
+
+// src/authorization/ap2/profile.ts
+var REQUIRED_PROFILE_CLAIMS = [
+  "profile",
+  "resource_id",
+  "input_hash",
+  "amount",
+  "currency",
+  "payment_method"
+];
+function computeInputHash(input) {
+  const canonical = canonicalize(input ?? {});
+  if (canonical === void 0) {
+    throw new CommerceError("INTERNAL_ERROR", "resource input is not canonicalizable JSON");
+  }
+  return sha256(canonical).toString("base64url");
+}
+var EVM_ADDRESS = /^0x[0-9a-f]{40}$/i;
+function sameCoordinate(declared, expected) {
+  if (typeof declared === "string" && expected !== void 0) {
+    if (EVM_ADDRESS.test(declared) && EVM_ADDRESS.test(expected)) {
+      return declared.toLowerCase() === expected.toLowerCase();
+    }
+  }
+  return declared === expected;
+}
+async function bindMandateToPurchase(mandate, context, errorContext) {
+  const profile = mandate.checkoutClaims["agent_commerce"];
+  if (!isRecord(profile)) throw ap2Rejected("purchase_mismatch", errorContext);
+  for (const claim of REQUIRED_PROFILE_CLAIMS) {
+    const value = profile[claim];
+    if (typeof value !== "string" || value.length === 0) {
+      throw ap2Rejected("purchase_mismatch", errorContext);
+    }
+  }
+  const requirement = context.requirement;
+  const expectedInputHash = computeInputHash(context.input);
+  const mustMatch = [
+    ["profile", AP2_CHECKOUT_PROFILE],
+    ["resource_id", context.resourceId],
+    ["input_hash", expectedInputHash],
+    // Decimal strings on both sides. Comparing numerically would make "0.10"
+    // and "0.1" equal, and a mandate says what it says.
+    ["amount", requirement.amount],
+    ["currency", requirement.currency],
+    ["payment_method", requirement.provider]
+  ];
+  for (const [claim, expected] of mustMatch) {
+    if (profile[claim] !== expected) throw ap2Rejected("purchase_mismatch", errorContext);
+  }
+  for (const [claim, expected] of [
+    ["destination", requirement.destination],
+    ["network", requirement.network],
+    ["asset", requirement.asset]
+  ]) {
+    const declared = profile[claim];
+    if (declared === void 0 && expected === void 0) continue;
+    if (!sameCoordinate(declared, expected)) throw ap2Rejected("purchase_mismatch", errorContext);
+  }
+}
+
+// src/authorization/ap2/checkout-signer.ts
+var DEFAULT_EXPIRES_IN_SECONDS = 900;
+function requireText(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(
+      `createCheckoutJwt: ${field} must be a non-empty string, received ${describe(value)}`
+    );
+  }
+  return value;
+}
+function describe(value) {
+  return value === null ? "null" : typeof value;
+}
+async function resolveKey(key) {
+  if (typeof key === "string") {
+    if (!key.includes("BEGIN PRIVATE KEY")) {
+      throw new TypeError(
+        'createCheckoutJwt: a string privateKey must be a PKCS#8 PEM beginning "-----BEGIN PRIVATE KEY-----"'
+      );
+    }
+    return importPKCS8(key, AP2_SIGNING_ALGORITHM);
+  }
+  if (typeof key !== "object" || key === null) {
+    throw new TypeError("createCheckoutJwt: privateKey must be a private JWK or a PKCS#8 PEM");
+  }
+  if (key["d"] === void 0) {
+    throw new TypeError(
+      'createCheckoutJwt: privateKey is a public JWK (no "d"). Use the private half of the pair whose public key is configured under checkoutIssuers'
+    );
+  }
+  if (key["kty"] !== AP2_KEY_TYPE || key["crv"] !== AP2_JWK_CURVE) {
+    throw new TypeError(
+      `createCheckoutJwt: privateKey must be ${AP2_KEY_TYPE}/${AP2_JWK_CURVE}, the pair ${AP2_SIGNING_ALGORITHM} implies`
+    );
+  }
+  return key;
+}
+async function createCheckoutJwt(options) {
+  const kid = requireText(options.kid, "kid");
+  const issuer = requireText(options.issuer, "issuer");
+  const audience = requireText(options.audience, "audience");
+  const resourceId = requireText(options.resourceId, "resourceId");
+  const currency = requireText(options.currency, "currency");
+  const paymentMethod = requireText(options.paymentMethod, "paymentMethod");
+  if (typeof options.amount === "number") {
+    throw new TypeError(
+      'createCheckoutJwt: amount must be a decimal string, not a number. It is compared as a string, so 0.1 and "0.10" are different mandates'
+    );
+  }
+  const amount = requireText(options.amount, "amount");
+  const key = await resolveKey(options.privateKey);
+  const issuedAt = Math.floor((options.now ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+  const expiresIn = options.expiresInSeconds ?? DEFAULT_EXPIRES_IN_SECONDS;
+  if (!Number.isInteger(expiresIn) || expiresIn <= 0) {
+    throw new TypeError("createCheckoutJwt: expiresInSeconds must be a positive whole number");
+  }
+  const agentCommerce = {
+    profile: AP2_CHECKOUT_PROFILE,
+    resource_id: resourceId,
+    input_hash: computeInputHash(options.input),
+    amount,
+    currency,
+    payment_method: paymentMethod,
+    ...options.destination !== void 0 ? { destination: options.destination } : {},
+    ...options.network !== void 0 ? { network: options.network } : {},
+    ...options.asset !== void 0 ? { asset: options.asset } : {}
+  };
+  return new SignJWT({ agent_commerce: agentCommerce }).setProtectedHeader({ alg: AP2_SIGNING_ALGORITHM, kid, typ: "JWT" }).setIssuer(issuer).setAudience(audience).setIssuedAt(issuedAt).setExpirationTime(issuedAt + expiresIn).setJti(options.jwtId ?? crypto.randomUUID()).sign(key);
+}
+
+// src/authorization/ap2/replay-store.ts
+function createAp2ReplayStore(options) {
+  const logger = options.logger ?? NOOP_LOGGER;
+  const now = options.now ?? (() => Date.now());
+  const db = openSqliteDatabase({
+    path: options.path,
+    label: "AP2 authorization database",
+    logger
+  });
+  migrate(db);
+  const selectByReference = db.prepare(
+    "SELECT state FROM ap2_authorizations WHERE reference = ?"
+  );
+  const selectLiveByJti = db.prepare(
+    `SELECT state FROM ap2_authorizations
+      WHERE checkout_jti = ? AND reference != ? AND state != 'released'`
+  );
+  const insert = db.prepare(
+    `INSERT INTO ap2_authorizations
+       (reference, checkout_jti, mandate_issuer, checkout_issuer, resource_id, request_id,
+        state, created_at, updated_at)
+     VALUES (@reference, @checkout_jti, @mandate_issuer, @checkout_issuer, @resource_id,
+             @request_id, 'reserved', @at, @at)`
+  );
+  const reReserve = db.prepare(
+    `UPDATE ap2_authorizations
+        SET state = 'reserved', request_id = @request_id, updated_at = @at
+      WHERE reference = @reference AND state = 'released'`
+  );
+  const transition = db.prepare(
+    `UPDATE ap2_authorizations SET state = @state, updated_at = @at
+      WHERE reference = @reference AND state = 'reserved'`
+  );
+  const reserveTx = db.transaction((request) => {
+    const at = new Date(now()).toISOString();
+    const existing = selectByReference.get(request.reference);
+    if (existing !== void 0 && existing.state !== "released") {
+      return { kind: "replayed", state: existing.state };
+    }
+    const sameCheckout = selectLiveByJti.get(request.checkoutJti, request.reference);
+    if (sameCheckout !== void 0) {
+      return { kind: "replayed", state: sameCheckout.state };
+    }
+    if (existing !== void 0) {
+      reReserve.run({ reference: request.reference, request_id: request.requestId, at });
+      return { kind: "reserved" };
+    }
+    insert.run({
+      reference: request.reference,
+      checkout_jti: request.checkoutJti,
+      mandate_issuer: request.mandateIssuer,
+      checkout_issuer: request.checkoutIssuer,
+      resource_id: request.resourceId,
+      request_id: request.requestId,
+      at
+    });
+    return { kind: "reserved" };
+  });
+  const move = (reference, state) => {
+    transition.run({ reference, state, at: new Date(now()).toISOString() });
+  };
+  let closed = false;
+  return {
+    reserve(request) {
+      return reserveTx(request);
+    },
+    consume(reference) {
+      move(reference, "consumed");
+    },
+    release(reference) {
+      move(reference, "released");
+    },
+    markUncertain(reference) {
+      move(reference, "uncertain");
+    },
+    stateOf(reference) {
+      return selectByReference.get(reference)?.state;
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      db.close();
+    }
+  };
+}
+function migrate(db) {
+  const current = db.pragma("user_version", { simple: true });
+  if (current >= 1) return;
+  const apply = db.transaction(() => {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS ap2_authorizations (
+        reference        TEXT PRIMARY KEY,
+        checkout_jti     TEXT NOT NULL,
+        mandate_issuer   TEXT NOT NULL,
+        checkout_issuer  TEXT NOT NULL,
+        resource_id      TEXT NOT NULL,
+        request_id       TEXT NOT NULL,
+        state            TEXT NOT NULL
+                         CHECK (state IN ('reserved', 'consumed', 'released', 'uncertain')),
+        created_at       TEXT NOT NULL,
+        updated_at       TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_ap2_authorizations_checkout_jti
+        ON ap2_authorizations(checkout_jti);
+    `);
+    db.pragma("user_version = 1");
+  });
+  apply();
+}
+async function verifyCheckoutJwt(mandateClaims, deps, context) {
+  const compact = mandateClaims["checkout_jwt"];
+  const expectedHash = mandateClaims["checkout_hash"];
+  if (typeof compact !== "string" || compact.length === 0) {
+    throw ap2Rejected("invalid_claims", context);
+  }
+  if (typeof expectedHash !== "string" || expectedHash.length === 0) {
+    throw ap2Rejected("invalid_claims", context);
+  }
+  requireMatchingHash(compact, expectedHash, context);
+  let header;
+  let unverifiedPayload;
+  try {
+    header = decodeProtectedHeader(compact);
+    unverifiedPayload = decodeJwt(compact);
+  } catch (cause) {
+    throw ap2Rejected("checkout_binding_failed", { ...context, cause });
+  }
+  const { issuer, key } = await deps.trust.resolve(unverifiedPayload.iss, header.kid, context);
+  const options = {
+    algorithms: [AP2_SIGNING_ALGORITHM],
+    issuer: issuer.issuer,
+    audience: issuer.audience,
+    clockTolerance: deps.clockSkewSeconds,
+    currentDate: deps.clock.now()
+  };
+  let claims;
+  try {
+    const result = await jwtVerify(compact, key, options);
+    claims = result.payload;
+  } catch (cause) {
+    throw ap2Rejected("checkout_binding_failed", { ...context, cause });
+  }
+  const exp = claims["exp"];
+  const iat = claims["iat"];
+  const jti = claims["jti"];
+  if (typeof exp !== "number" || typeof iat !== "number") {
+    throw ap2Rejected("invalid_claims", context);
+  }
+  if (typeof jti !== "string" || jti.length === 0) {
+    throw ap2Rejected("invalid_claims", context);
+  }
+  const nowSeconds = Math.floor(deps.clock.now().getTime() / 1e3);
+  if (iat > nowSeconds + deps.clockSkewSeconds) throw ap2Rejected("expired", context);
+  return { issuer: issuer.issuer, jwtId: jti, claims };
+}
+function requireMatchingHash(compact, expected, context) {
+  const actual = sha256(compact).toString("base64url");
+  if (actual !== expected) throw ap2Rejected("checkout_binding_failed", context);
+}
+function hasher(data, algorithm) {
+  if (algorithm.toLowerCase() !== AP2_DIGEST_ALGORITHM) {
+    throw ap2Rejected("malformed_presentation");
+  }
+  return sha256(typeof data === "string" ? data : new Uint8Array(data));
+}
+var KEY_BOUND_TYPES = /* @__PURE__ */ new Set([
+  "kb+sd-jwt",
+  "kb-sd-jwt",
+  "kb+sd-jwt+kb",
+  "kb-sd-jwt+kb"
+]);
+async function verifyMandate(presentation, deps, context) {
+  if (presentation.includes("~~")) {
+    throw ap2Rejected("unsupported_mandate_type", context);
+  }
+  let decoded;
+  let encodedJws;
+  try {
+    decoded = await decodeSdJwt(presentation, hasher);
+    encodedJws = splitSdJwt(presentation).jwt;
+  } catch (cause) {
+    throw ap2Rejected("malformed_presentation", { ...context, cause });
+  }
+  if (decoded.kbJwt !== void 0) {
+    throw ap2Rejected("unsupported_mandate_type", context);
+  }
+  const rawPayload = decoded.jwt.payload;
+  const header = decoded.jwt.header;
+  if (!isRecord(rawPayload) || !isRecord(header)) {
+    throw ap2Rejected("malformed_presentation", context);
+  }
+  if (KEY_BOUND_TYPES.has(String(header["typ"])) || rawPayload["sd_hash"] !== void 0 || rawPayload["issuer_jwt_hash"] !== void 0) {
+    throw ap2Rejected("unsupported_mandate_type", context);
+  }
+  const { issuer, key } = await deps.trust.resolve(rawPayload["iss"], header["kid"], context);
+  const hasAudience = rawPayload["aud"] !== void 0;
+  if (!hasAudience && deps.requireAudience === true) {
+    throw ap2Rejected("invalid_claims", context);
+  }
+  const options = {
+    // Redundant with one resolved EC key, which already refuses `alg: none` and
+    // a forged HMAC. It stops the header picking the algorithm if a key set is
+    // ever resolved instead.
+    algorithms: [AP2_SIGNING_ALGORITHM],
+    // Also redundant, since the key was resolved *from* `iss`, and kept as a
+    // backstop for a resolver that matches on something else
+    ...rawPayload["iss"] !== void 0 ? { issuer: issuer.issuer } : {},
+    // Not redundant: `aud` is the presenter's claim, checked against the
+    // configured value
+    ...hasAudience ? { audience: issuer.audience } : {},
+    clockTolerance: deps.clockSkewSeconds,
+    // Injected clock, not jose's `Date.now()`, so expiry is testable
+    currentDate: deps.clock.now()
+  };
+  let verifiedPayload;
+  try {
+    const result = await jwtVerify(encodedJws, key, options);
+    verifiedPayload = result.payload;
+  } catch (cause) {
+    throw ap2Rejected(classifyJoseFailure(cause), { ...context, cause });
+  }
+  let claims;
+  try {
+    claims = await getClaims(verifiedPayload, decoded.disclosures, hasher);
+  } catch (cause) {
+    throw ap2Rejected("malformed_presentation", { ...context, cause });
+  }
+  const mandate = delegatedMandate(claims, context);
+  if (claims["cnf"] !== void 0 || mandate["cnf"] !== void 0) {
+    throw ap2Rejected("unsupported_mandate_type", context);
+  }
+  requireClosedCheckoutMandate(mandate, context);
+  if (mandate["constraints"] !== void 0) {
+    throw ap2Rejected("unsupported_mandate_type", context);
+  }
+  requireFreshness([verifiedPayload, mandate], deps, context);
+  return { issuer: issuer.issuer, claims: mandate, signedToken: encodedJws };
+}
+function delegatedMandate(claims, context) {
+  const delegated = claims["delegate_payload"];
+  if (!Array.isArray(delegated)) throw ap2Rejected("unsupported_mandate_type", context);
+  const disclosed = delegated.filter(isRecord);
+  const [only] = disclosed;
+  if (disclosed.length !== 1 || only === void 0) throw ap2Rejected("invalid_claims", context);
+  return only;
+}
+function classifyJoseFailure(cause) {
+  const code = cause?.code;
+  if (code === "ERR_JWT_EXPIRED") return "expired";
+  if (code === "ERR_JWT_CLAIM_VALIDATION_FAILED") {
+    const { claim, reason } = cause;
+    if (claim === "aud") return "wrong_audience";
+    if (claim === "nbf" || claim === "exp")
+      return reason === "invalid" ? "invalid_claims" : "expired";
+  }
+  return "invalid_signature";
+}
+function requireFreshness(sources, deps, context) {
+  const nowSeconds = Math.floor(deps.clock.now().getTime() / 1e3);
+  let expires = false;
+  for (const claims of sources) {
+    const exp = claims["exp"];
+    const iat = claims["iat"];
+    if (exp !== void 0) {
+      if (typeof exp !== "number") throw ap2Rejected("invalid_claims", context);
+      if (exp <= nowSeconds - deps.clockSkewSeconds) throw ap2Rejected("expired", context);
+      expires = true;
+    }
+    const nbf = claims["nbf"];
+    if (nbf !== void 0) {
+      if (typeof nbf !== "number") throw ap2Rejected("invalid_claims", context);
+      if (nbf > nowSeconds + deps.clockSkewSeconds) throw ap2Rejected("expired", context);
+    }
+    if (iat !== void 0) {
+      if (typeof iat !== "number") throw ap2Rejected("invalid_claims", context);
+      if (iat > nowSeconds + deps.clockSkewSeconds) throw ap2Rejected("expired", context);
+    }
+  }
+  if (!expires && deps.requireExpiry === true) throw ap2Rejected("invalid_claims", context);
+}
+function requireClosedCheckoutMandate(claims, context) {
+  if (claims["vct"] !== AP2_CHECKOUT_MANDATE_VCT) {
+    throw ap2Rejected("unsupported_mandate_type", context);
+  }
+}
+function createTrustStore(issuers) {
+  const byIssuer = new Map(issuers.map((entry) => [entry.issuer, entry]));
+  const imported = /* @__PURE__ */ new Map();
+  function issuerByName(iss, context) {
+    if (typeof iss !== "string" || iss.length === 0) {
+      throw ap2Rejected("invalid_claims", context);
+    }
+    const issuer = byIssuer.get(iss);
+    if (issuer === void 0) throw ap2Rejected("untrusted_issuer", context);
+    return issuer;
+  }
+  function issuerByKid(kid, context) {
+    const matches = issuers.filter((entry) => entry.keys.some((key) => key.kid === kid));
+    const [only] = matches;
+    if (matches.length !== 1 || only === void 0) throw ap2Rejected("unknown_key", context);
+    return only;
+  }
+  return {
+    /** Every trusted issuer id, for diagnostics. Never the keys themselves */
+    issuerIds() {
+      return [...byIssuer.keys()];
+    },
+    async resolve(iss, kid, context) {
+      if (typeof kid !== "string" || kid.length === 0) {
+        throw ap2Rejected("unknown_key", context);
+      }
+      const issuer = iss === void 0 ? issuerByKid(kid, context) : issuerByName(iss, context);
+      const trusted = issuer.keys.find((candidate) => candidate.kid === kid);
+      if (trusted === void 0) throw ap2Rejected("unknown_key", context);
+      const cacheKey = JSON.stringify([iss, kid]);
+      let pending = imported.get(cacheKey);
+      if (pending === void 0) {
+        pending = importJWK(trusted.jwk, AP2_SIGNING_ALGORITHM);
+        imported.set(cacheKey, pending);
+      }
+      try {
+        return { issuer, key: await pending };
+      } catch (cause) {
+        imported.delete(cacheKey);
+        throw ap2Unavailable("configured verification key could not be imported", {
+          ...context,
+          cause
+        });
+      }
+    }
+  };
+}
+
+// src/authorization/ap2/verifier.ts
+function mandateReference(signedToken) {
+  return `sha256:${sha256(signedToken).toString("base64url")}`;
+}
+function createAp2MandateVerifier(options) {
+  const mandateTrust = createTrustStore(options.config.trust.mandateIssuers);
+  const checkoutTrust = createTrustStore(options.config.trust.checkoutIssuers);
+  const deps = { clock: options.clock, clockSkewSeconds: options.config.clockSkewSeconds };
+  const mandatePolicy = {
+    ...deps,
+    trust: mandateTrust,
+    requireAudience: options.config.requireMandateAudience === true,
+    requireExpiry: options.config.requireMandateExpiry === true
+  };
+  return {
+    async verify(presentation, context = {}) {
+      if (typeof presentation !== "string" || presentation.length === 0) {
+        throw ap2Rejected("malformed_presentation", context);
+      }
+      const mandate = await verifyMandate(presentation, mandatePolicy, context);
+      const checkout = await verifyCheckoutJwt(
+        mandate.claims,
+        { ...deps, trust: checkoutTrust },
+        context
+      );
+      return {
+        reference: mandateReference(mandate.signedToken),
+        mandateIssuer: mandate.issuer,
+        checkoutIssuer: checkout.issuer,
+        checkoutJwtId: checkout.jwtId,
+        checkoutClaims: checkout.claims
+      };
+    },
+    trustedIssuers() {
+      return { mandate: mandateTrust.issuerIds(), checkout: checkoutTrust.issuerIds() };
+    }
+  };
+}
+
+// src/authorization/ap2/provider.ts
+function createAp2AuthorizationProvider(options) {
+  const clock = options.clock ?? systemClock;
+  const logger = options.logger ?? NOOP_LOGGER;
+  const verifier = createAp2MandateVerifier({ config: options.config, clock });
+  const replay = options.replayStore ?? createAp2ReplayStore({ path: options.config.replay.path, logger });
+  const requirement = {
+    method: "ap2",
+    version: AP2_SPEC_VERSION,
+    profile: AP2_CHECKOUT_PROFILE
+  };
+  async function verifyAndReserve(context) {
+    const errorContext = {
+      requestId: context.requestId,
+      resourceId: context.resourceId
+    };
+    const mandate = await verifier.verify(context.submission.payload, errorContext);
+    await bindMandateToPurchase(mandate, context, errorContext);
+    let reservation;
+    try {
+      reservation = replay.reserve({
+        reference: mandate.reference,
+        checkoutJti: mandate.checkoutJwtId,
+        mandateIssuer: mandate.mandateIssuer,
+        checkoutIssuer: mandate.checkoutIssuer,
+        resourceId: context.resourceId,
+        requestId: context.requestId
+      });
+    } catch (cause) {
+      throw ap2Unavailable("replay store could not be written", { ...errorContext, cause });
+    }
+    if (reservation.kind === "replayed") {
+      throw ap2Replayed(reservation.state, errorContext);
+    }
+    return {
+      status: "verified",
+      method: "ap2",
+      reference: mandate.reference,
+      // The reservation handle is the reference itself, so the two can never
+      // name different mandates
+      reservationId: mandate.reference,
+      // Opaque identifiers an operator can reconcile with. Never a claim from
+      // the mandate: those carry the buyer's purchase and their personal data.
+      // `checkoutId`, not `checkoutJwtId` - the receipt store redacts any key
+      // that reads as secret-shaped, and "jwt" is on that list.
+      metadata: {
+        mandateIssuer: mandate.mandateIssuer,
+        checkoutIssuer: mandate.checkoutIssuer,
+        checkoutId: mandate.checkoutJwtId
+      }
+    };
+  }
+  const finalize = (action, reservationId, context) => {
+    try {
+      replay[action](reservationId);
+    } catch (cause) {
+      throw ap2Unavailable(`replay store could not record ${action}`, { ...context, cause });
+    }
+  };
+  return {
+    name: "ap2",
+    descriptor: buildAp2Descriptor(PACKAGE_VERSION),
+    requirement,
+    verifyAndReserve,
+    async consume(reservationId, context) {
+      finalize("consume", reservationId, context);
+    },
+    async release(reservationId, context) {
+      finalize("release", reservationId, context);
+    },
+    async markUncertain(reservationId, context) {
+      finalize("markUncertain", reservationId, context);
+    },
+    async health() {
+      const startedAt = clock.monotonicMs();
+      const checkedAt = clock.nowIso();
+      let available = true;
+      try {
+        replay.stateOf("health-probe");
+      } catch {
+        available = false;
+      }
+      const durationMs = Math.round(clock.monotonicMs() - startedAt);
+      if (!available) {
+        return { status: "fail", checkedAt, durationMs, detail: "replay-store-unavailable" };
+      }
+      const trusted = verifier.trustedIssuers();
+      return {
+        status: "pass",
+        checkedAt,
+        durationMs,
+        detail: `mandate-issuers=${trusted.mandate.length} checkout-issuers=${trusted.checkout.length}`
+      };
+    },
+    close() {
+      replay.close();
+    }
+  };
+}
+
+export { AP2_REJECTION_REASONS, createAp2AuthorizationProvider, createAp2ReplayStore, createCheckoutJwt };
+//# sourceMappingURL=ap2-MBMQHFX4.js.map
+//# sourceMappingURL=ap2-MBMQHFX4.js.map