@devlab.group/agent-commerce 1.2.0 → 1.4.0

package/dist/ap2.js

@@ -0,0 +1,669 @@
+import { AP2_CHECKOUT_MANDATE_VCT, AP2_SIGNING_ALGORITHM, AP2_DIGEST_ALGORITHM, AP2_CHECKOUT_PROFILE, AP2_SPEC_VERSION, AP2_KEY_TYPE, AP2_JWK_CURVE, openSqliteDatabase } from './chunk-7NKWFGBY.js';
+export { AP2_CHECKOUT_MANDATE_VCT, AP2_CHECKOUT_PROFILE, AP2_DEFAULT_CLOCK_SKEW_SECONDS, AP2_MAX_CLOCK_SKEW_SECONDS, AP2_SIGNING_ALGORITHM, AP2_SPEC_VERSION } from './chunk-7NKWFGBY.js';
+import { systemClock, NOOP_LOGGER, CommerceError, PACKAGE_VERSION } from './chunk-ZDVJ7EVL.js';
+import { SignJWT, importPKCS8, importJWK, jwtVerify } from 'jose';
+import canonicalize from 'canonicalize';
+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",
+  "unsupported_algorithm",
+  "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.",
+  unsupported_algorithm: "The mandate uses a signature or digest algorithm that is not accepted.",
+  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 } : {}
+    }
+  );
+}
+
+// src/authorization/ap2/profile.ts
+var REQUIRED_PROFILE_CLAIMS = [
+  "profile",
+  "resource_id",
+  "input_hash",
+  "amount",
+  "currency",
+  "payment_method"
+];
+async function computeInputHash(input) {
+  const canonical = canonicalize(input ?? {});
+  if (canonical === void 0) {
+    throw new TypeError("resource input is not canonicalizable JSON");
+  }
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonical));
+  return Buffer.from(digest).toString("base64url");
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+async function bindMandateToPurchase(mandate, context, errorContext) {
+  const profile = asRecord(mandate.checkoutClaims["agent_commerce"]);
+  if (profile === void 0) 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 = await 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 (declared !== expected) throw ap2Rejected("purchase_mismatch", errorContext);
+  }
+  return {
+    resourceId: profile["resource_id"],
+    amount: profile["amount"],
+    currency: profile["currency"],
+    paymentMethod: profile["payment_method"]
+  };
+}
+
+// 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: await 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/descriptor.ts
+var AP2_CAPABILITIES = [
+  "direct-mode",
+  AP2_CHECKOUT_MANDATE_VCT,
+  "sd-jwt-presentation",
+  AP2_SIGNING_ALGORITHM,
+  AP2_DIGEST_ALGORITHM,
+  "static-inline-trust",
+  "merchant-checkout-jwt-binding",
+  AP2_CHECKOUT_PROFILE,
+  "purchase-binding",
+  "replay-defence"
+];
+var AP2_UNSUPPORTED = [
+  // Mandate kinds. Open mandates carry spending constraints nothing here
+  // evaluates, so accepting one would tell a buyer their limits were checked.
+  "autonomous mode",
+  "open checkout mandates (mandate.checkout.open.1)",
+  "intent mandates",
+  "cart mandates",
+  "spending constraint evaluation",
+  "cnf-bound agent keys",
+  // Key handling. Every key is written into config by an operator
+  "JWKS and any key discovery by URL (jku, x5u)",
+  "issuer metadata fetching",
+  "key rotation without a config change",
+  // Algorithms
+  "signature algorithms other than ES256",
+  "digest algorithms other than sha-256",
+  // Roles this gateway does not play
+  "mandate issuance",
+  "merchant checkout JWT issuance",
+  "AP2 over the ACP checkout adapter"
+];
+function buildAp2Descriptor(implementationVersion) {
+  return {
+    name: "ap2",
+    kind: "authorization",
+    implementationVersion,
+    supportedSpec: `ap2/v${AP2_SPEC_VERSION} mode=direct`,
+    capabilities: AP2_CAPABILITIES,
+    status: "experimental",
+    unsupported: AP2_UNSUPPORTED
+  };
+}
+
+// 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) {
+      if (existing.state !== "released") {
+        return { kind: "replayed", state: existing.state };
+      }
+      reReserve.run({ reference: request.reference, request_id: request.requestId, at });
+      return { kind: "reserved" };
+    }
+    const sameCheckout = selectLiveByJti.get(request.checkoutJti, request.reference);
+    if (sameCheckout !== void 0) {
+      return { kind: "replayed", state: sameCheckout.state };
+    }
+    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();
+}
+function decodeSegment(jwt, index) {
+  const segment = jwt.split(".")[index];
+  if (segment === void 0) return void 0;
+  try {
+    const parsed = JSON.parse(Buffer.from(segment, "base64url").toString("utf8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+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);
+  }
+  await requireMatchingHash(compact, expectedHash, context);
+  const header = decodeSegment(compact, 0);
+  const unverifiedPayload = decodeSegment(compact, 1);
+  if (header === void 0 || unverifiedPayload === void 0) {
+    throw ap2Rejected("checkout_binding_failed", context);
+  }
+  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 };
+}
+async function requireMatchingHash(compact, expected, context) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(compact));
+  const actual = Buffer.from(digest).toString("base64url");
+  if (actual !== expected) throw ap2Rejected("checkout_binding_failed", context);
+}
+async function hasher(data, algorithm) {
+  if (algorithm.toLowerCase() !== AP2_DIGEST_ALGORITHM) {
+    throw new Error(`unsupported digest algorithm ${algorithm}`);
+  }
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+}
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+async function verifyMandate(presentation, deps, 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 = asRecord2(decoded.jwt.payload);
+  const header = asRecord2(decoded.jwt.header);
+  if (rawPayload === void 0 || header === void 0) {
+    throw ap2Rejected("malformed_presentation", context);
+  }
+  const { issuer, key } = await deps.trust.resolve(rawPayload["iss"], header["kid"], context);
+  const options = {
+    // Redundant today (the key is EC, so jose already refuses `alg: none` and
+    // a forged HMAC) and kept for the day this resolves a key set instead of
+    // one key, where the header would get to pick
+    algorithms: [AP2_SIGNING_ALGORITHM],
+    // Also redundant, and for the same reason: the key was resolved *from*
+    // `iss` against the configured allowlist, so nothing reaching here can
+    // carry a different one. It backstops a future resolver that matches on
+    // something else. `audience` below is not redundant - `aud` is the
+    // presenter's claim, checked against what the operator configured.
+    issuer: issuer.issuer,
+    audience: issuer.audience,
+    clockTolerance: deps.clockSkewSeconds,
+    // Injected clock, not jose's `Date.now()`, so expiry tests are tests
+    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 });
+  }
+  requireFreshness(verifiedPayload, deps, context);
+  let claims;
+  try {
+    claims = await getClaims(verifiedPayload, decoded.disclosures, hasher);
+  } catch (cause) {
+    throw ap2Rejected("malformed_presentation", { ...context, cause });
+  }
+  requireClosedCheckoutMandate(claims, context);
+  return { issuer: issuer.issuer, claims, signedToken: encodedJws };
+}
+function classifyJoseFailure(cause) {
+  const code = cause?.code;
+  if (code === "ERR_JWT_EXPIRED") return "expired";
+  if (code === "ERR_JWT_CLAIM_VALIDATION_FAILED") {
+    const claim = cause.claim;
+    if (claim === "aud") return "wrong_audience";
+    if (claim === "nbf" || claim === "exp") return "expired";
+  }
+  return "invalid_signature";
+}
+function requireFreshness(payload, deps, context) {
+  const exp = payload["exp"];
+  const iat = payload["iat"];
+  if (typeof exp !== "number" || typeof iat !== "number") {
+    throw ap2Rejected("invalid_claims", context);
+  }
+  const nowSeconds = Math.floor(deps.clock.now().getTime() / 1e3);
+  if (iat > nowSeconds + deps.clockSkewSeconds) throw ap2Rejected("expired", 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();
+  return {
+    /** Every trusted issuer id, for diagnostics. Never the keys themselves */
+    issuerIds() {
+      return [...byIssuer.keys()];
+    },
+    async resolve(iss, kid, 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);
+      if (typeof kid !== "string" || kid.length === 0) {
+        throw ap2Rejected("unknown_key", 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
+async function mandateReference(signedToken) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(signedToken));
+  return `sha256:${Buffer.from(digest).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 };
+  return {
+    async verify(presentation, context = {}) {
+      if (typeof presentation !== "string" || presentation.length === 0) {
+        throw ap2Rejected("malformed_presentation", context);
+      }
+      const mandate = await verifyMandate(presentation, { ...deps, trust: mandateTrust }, context);
+      const checkout = await verifyCheckoutJwt(
+        mandate.claims,
+        { ...deps, trust: checkoutTrust },
+        context
+      );
+      return {
+        reference: await mandateReference(mandate.signedToken),
+        mandateIssuer: mandate.issuer,
+        checkoutIssuer: checkout.issuer,
+        checkoutJwtId: checkout.jwtId,
+        checkoutClaims: checkout.claims,
+        mandateClaims: mandate.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,
+      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 trusted = verifier.trustedIssuers();
+      const checkedAt = clock.nowIso();
+      const durationMs = Math.round(clock.monotonicMs() - startedAt);
+      try {
+        replay.stateOf("health-probe");
+      } catch {
+        return { status: "fail", checkedAt, durationMs, detail: "replay-store-unavailable" };
+      }
+      return {
+        status: "pass",
+        checkedAt,
+        durationMs,
+        detail: `mandate-issuers=${trusted.mandate.length} checkout-issuers=${trusted.checkout.length}`
+      };
+    },
+    close() {
+      replay.close();
+    }
+  };
+}
+
+export { AP2_CAPABILITIES, AP2_REJECTION_REASONS, AP2_UNSUPPORTED, createAp2AuthorizationProvider as ap2, createAp2AuthorizationProvider, createCheckoutJwt };
+//# sourceMappingURL=ap2.js.map
+//# sourceMappingURL=ap2.js.map