@devlab.group/agent-commerce 2.4.0 → 2.5.0

package/dist/cli/{chunk-PIMFPCNZ.js → chunk-Z34UMZBB.js}

@@ -1,6 +1,8 @@
-import { SETTLE_AFTER_BACKEND_METADATA_KEY, REUSE_REJECTED_AUTHORIZATION_METADATA_KEY } from './chunk-OZ4LAWBK.js';
-import { RESERVED_INPUT_FIELDS, NOOP_LOGGER, DEFAULT_BACKEND_TIMEOUT_MS, CommerceError, isCommerceError, describeError, toCommerceError } from './chunk-QQ3WY5L3.js';
+import { SETTLE_AFTER_BACKEND_METADATA_KEY, REUSE_REJECTED_AUTHORIZATION_METADATA_KEY, canonicalJson } from './chunk-5R7DM5LM.js';
+import { RESERVED_INPUT_FIELDS, NOOP_LOGGER, DEFAULT_BACKEND_TIMEOUT_MS, RECONCILIATION_METADATA_KEY } from './chunk-IDY2735M.js';
+import { CommerceError, isCommerceError, describeError, toCommerceError } from './chunk-SYQLJXIU.js';
 import { isRecord } from './chunk-3M6U7ILB.js';
+import { createHash } from 'crypto';
 import { isDeepStrictEqual } from 'util';
 
 // src/config/filename.ts
@@ -352,6 +354,56 @@ function safeStringify(value) {
 function isAbortError(error) {
   return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
 }
+function createFlow(request, transactionId) {
+  return { request, transactionId, persistenceFailures: [], journaled: false };
+}
+function failuresOf(flow) {
+  return flow.persistenceFailures.length > 0 ? { persistenceFailures: [...flow.persistenceFailures] } : {};
+}
+function sha256(text) {
+  return `sha256:${createHash("sha256").update(text, "utf8").digest("hex")}`;
+}
+function inputDigest(input) {
+  const json = canonicalJson(input);
+  return json !== void 0 ? sha256(json) : void 0;
+}
+function configDigest(resource, requirement) {
+  const terms = {
+    resourceId: resource.id,
+    pricing: resource.pricing,
+    paymentMethods: resource.paymentMethods,
+    authorization: resource.authorization?.required ?? [],
+    requirement: {
+      provider: requirement.provider,
+      amount: requirement.amount,
+      currency: requirement.currency,
+      destination: requirement.destination ?? null,
+      network: requirement.network ?? null,
+      asset: requirement.asset ?? null,
+      settleAfterBackend: requirement.metadata?.[SETTLE_AFTER_BACKEND_METADATA_KEY] === true
+    }
+  };
+  return sha256(canonicalJson(terms) ?? JSON.stringify(terms));
+}
+function newTransaction(flow, resource, requirement, verification, validInput, authorization) {
+  const raw = verification.metadata?.[RECONCILIATION_METADATA_KEY];
+  const locator = isRecord(raw) ? raw : void 0;
+  const expiresAt = typeof locator?.["expiresAt"] === "string" ? locator["expiresAt"] : void 0;
+  const network = verification.network ?? requirement.network;
+  const asset = verification.asset ?? requirement.asset;
+  const digest = inputDigest(validInput);
+  return {
+    id: flow.transactionId,
+    protocol: flow.request.protocol,
+    ...network !== void 0 ? { network } : {},
+    ...asset !== void 0 ? { asset } : {},
+    ...locator !== void 0 ? { locator } : {},
+    ...expiresAt !== void 0 ? { expiresAt } : {},
+    ...authorization !== void 0 ? { authorization } : {},
+    ...digest !== void 0 ? { inputDigest: digest } : {},
+    configDigest: configDigest(resource, requirement)
+  };
+}
 var SUPPORTED_TYPES = /* @__PURE__ */ new Set([
   "object",
   "string",
@@ -494,16 +546,15 @@ function resolveAuthorizationProviders(providers, resource, requestId) {
 }
 function createAuthorizeAndReserve(ctx) {
   const { options, safeEmit, buildEvent } = ctx;
-  async function authorizeAndReserve(request, resource, providers, requirement, input) {
+  async function authorizeAndReserve(flow, request, resource, providers, requirement, input) {
     if (providers.length === 0) return void 0;
     const submission = request.authorization;
     const provider = providers.find((candidate) => candidate.name === submission?.method);
     const unmet = providers.filter((candidate) => candidate !== provider).map((c) => c.name);
     if (submission === void 0 || provider === void 0 || unmet.length > 0) {
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "authorization.rejected",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           status: "error",
@@ -540,9 +591,8 @@ function createAuthorizeAndReserve(ctx) {
         }
       );
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "authorization.rejected",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           status: "error",
@@ -552,9 +602,8 @@ function createAuthorizeAndReserve(ctx) {
       throw mapped;
     }
     await safeEmit(
-      buildEvent({
+      buildEvent(flow, {
         type: "authorization.verified",
-        requestId: request.requestId,
         resourceId: resource.id,
         adapter: request.protocol,
         status: "ok",
@@ -568,14 +617,17 @@ function createAuthorizeAndReserve(ctx) {
         reference: verification.reference,
         ...verification.metadata !== void 0 ? { metadata: verification.metadata } : {}
       },
+      reservationId: verification.reservationId,
       async finalize(action) {
         try {
           await provider[action](verification.reservationId, context);
+          return true;
         } catch (error) {
           options.logger.error(
             { err: describeError(error), requestId: request.requestId, action },
             "Authorization finalization failed; the reservation stays reserved"
           );
+          return false;
         }
       }
     };
@@ -616,7 +668,7 @@ function replayError(error, requirement) {
 // src/core/execution/pipeline/admission.ts
 function createPaymentAdmission(ctx, authorizeAndReserve) {
   const { options, safeEmit, buildEvent } = ctx;
-  return async function admitPayment(request, resource, pricing, validInput) {
+  return async function admitPayment(flow, request, resource, pricing, validInput) {
     const provider = pickProvider(options.paymentProviders, resource.paymentMethods);
     if (!provider) {
       throw new CommerceError(
@@ -655,9 +707,8 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
     }
     if (!request.payment) {
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "payment.required",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           paymentProvider: provider.name
@@ -666,6 +717,7 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
       return {
         kind: "payment-required",
         requestId: request.requestId,
+        transactionId: flow.transactionId,
         resourceId: resource.id,
         requirement,
         ...authProviders.length > 0 ? { authorization: authProviders.map((p) => p.requirement) } : {}
@@ -696,9 +748,8 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
         ...retryChallenge(requirement)
       });
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "payment.rejected",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           paymentProvider: provider.name,
@@ -710,9 +761,8 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
     }
     if (verification.status !== "verified") {
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "payment.rejected",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           paymentProvider: provider.name,
@@ -732,9 +782,8 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
     }
     if (!verification.replayKey) {
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "payment.rejected",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           paymentProvider: provider.name,
@@ -749,6 +798,7 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
     }
     const replayKey = verification.replayKey;
     const hold = await authorizeAndReserve(
+      flow,
       request,
       resource,
       authProviders,
@@ -756,7 +806,7 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
       validInput
     );
     try {
-      await options.store.reservePaymentAttempt({
+      const attempt = await options.store.reservePaymentAttempt({
         requestId: request.requestId,
         resourceId: resource.id,
         provider: provider.name,
@@ -765,8 +815,17 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
         currency: verification.currency,
         ...verification.payer !== void 0 ? { payer: verification.payer } : {},
         ...verification.payee !== void 0 ? { payee: verification.payee } : {},
-        ...requirement.metadata?.[REUSE_REJECTED_AUTHORIZATION_METADATA_KEY] === true ? { reclaimRejected: true } : {}
+        ...requirement.metadata?.[REUSE_REJECTED_AUTHORIZATION_METADATA_KEY] === true ? { reclaimRejected: true } : {},
+        transaction: newTransaction(
+          flow,
+          resource,
+          requirement,
+          verification,
+          validInput,
+          hold !== void 0 ? { ...hold.record, reservationId: hold.reservationId } : void 0
+        )
       });
+      flow.journaled = attempt.transactionId === flow.transactionId && options.store.recordTransactionStep !== void 0;
     } catch (error) {
       const mapped = toCommerceError(
         error,
@@ -775,9 +834,8 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
       );
       await hold?.finalize("release");
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "payment.rejected",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           paymentProvider: provider.name,
@@ -788,9 +846,8 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
       throw replayError(mapped, requirement);
     }
     await safeEmit(
-      buildEvent({
+      buildEvent(flow, {
         type: "payment.verified",
-        requestId: request.requestId,
         resourceId: resource.id,
         adapter: request.protocol,
         paymentProvider: provider.name,
@@ -800,6 +857,7 @@ function createPaymentAdmission(ctx, authorizeAndReserve) {
     return {
       kind: "admitted",
       settleArgs: {
+        flow,
         request,
         resource,
         provider,
@@ -821,6 +879,11 @@ function pickProvider(providers, methods) {
 }
 
 // src/core/execution/pipeline/context.ts
+var HOLD_STATES = {
+  consume: "consumed",
+  release: "released",
+  markUncertain: "uncertain"
+};
 function createPipelineContext(options) {
   async function safeEmit(event) {
     try {
@@ -832,27 +895,73 @@ function createPipelineContext(options) {
       );
     }
   }
-  async function safePersist(op, label, requestId) {
+  async function safePersist(flow, op, label, failure) {
     try {
       await op();
+      return true;
     } catch (error) {
       options.logger.error(
-        { err: describeError(error), requestId },
+        {
+          err: describeError(error),
+          requestId: flow.request.requestId,
+          transactionId: flow.transactionId
+        },
         `Persistence failed: ${label}`
       );
+      if (failure !== void 0 && !flow.persistenceFailures.includes(failure)) {
+        flow.persistenceFailures.push(failure);
+      }
+      return false;
     }
   }
-  function buildEvent(partial) {
-    return { id: options.ids.next("evt"), at: options.clock.nowIso(), ...partial };
+  async function recordStep(flow, step) {
+    const record = options.store.recordTransactionStep;
+    if (!flow.journaled || record === void 0) return;
+    const full = {
+      ...step,
+      transactionId: flow.transactionId,
+      at: options.clock.nowIso()
+    };
+    await safePersist(
+      flow,
+      () => record.call(options.store, full),
+      `recordTransactionStep(${step.kind})`,
+      "journal"
+    );
+  }
+  async function finalizeHold(flow, hold, action) {
+    if (hold !== void 0 && await hold.finalize(action)) {
+      await recordStep(flow, { kind: "hold", hold: HOLD_STATES[action] });
+    }
+  }
+  function buildEvent(flow, partial) {
+    return {
+      id: options.ids.next("evt"),
+      at: options.clock.nowIso(),
+      requestId: flow.request.requestId,
+      transactionId: flow.transactionId,
+      ...partial
+    };
   }
-  return { options, safeEmit, safePersist, buildEvent };
+  return { options, safeEmit, safePersist, recordStep, finalizeHold, buildEvent };
 }
 
 // src/core/execution/pipeline/settlement.ts
 function createSettlement(ctx) {
-  const { options, safeEmit, safePersist, buildEvent } = ctx;
+  const { options, safeEmit, safePersist, recordStep, finalizeHold, buildEvent } = ctx;
   async function settle(args) {
-    const { request, resource, provider, requirement, payment, verification, replayKey, hold } = args;
+    const {
+      flow,
+      request,
+      resource,
+      provider,
+      requirement,
+      payment,
+      verification,
+      replayKey,
+      hold
+    } = args;
+    await recordStep(flow, { kind: "settling" });
     let settlement;
     try {
       settlement = await provider.settle({
@@ -865,25 +974,29 @@ function createSettlement(ctx) {
     } catch (error) {
       const notSubmitted = notSubmittedReason(error);
       if (notSubmitted !== void 0) {
-        await hold?.finalize("release");
+        await finalizeHold(flow, hold, "release");
         await safePersist(
+          flow,
           () => options.store.updatePaymentAttempt({
             replayKey,
             status: "rejected",
             rejectionReason: notSubmitted
           }),
           "updatePaymentAttempt(not-submitted)",
-          request.requestId
+          "payment-attempt"
         );
         await safeEmit(
-          buildEvent({
+          buildEvent(flow, {
             type: "payment.rejected",
-            requestId: request.requestId,
             resourceId: resource.id,
             adapter: request.protocol,
             paymentProvider: provider.name,
             status: "error",
-            data: { reason: "settlement-not-submitted", providerReason: notSubmitted }
+            data: {
+              reason: "settlement-not-submitted",
+              providerReason: notSubmitted,
+              ...failuresOf(flow)
+            }
           })
         );
         throw new CommerceError(
@@ -893,8 +1006,9 @@ function createSettlement(ctx) {
         );
       }
       const txHash = settlementTxHash(error);
-      await hold?.finalize("markUncertain");
+      await finalizeHold(flow, hold, "markUncertain");
       await safePersist(
+        flow,
         () => options.store.updatePaymentAttempt({
           replayKey,
           status: "settlement-uncertain",
@@ -902,19 +1016,19 @@ function createSettlement(ctx) {
           ...error instanceof Error ? { rejectionReason: error.message } : {}
         }),
         "updatePaymentAttempt(settlement-uncertain)",
-        request.requestId
+        "payment-attempt"
       );
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "payment.rejected",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           paymentProvider: provider.name,
           status: "error",
           data: {
             reason: "settlement-uncertain",
-            ...txHash !== void 0 ? { transactionHash: txHash } : {}
+            ...txHash !== void 0 ? { transactionHash: txHash } : {},
+            ...failuresOf(flow)
           }
         })
       );
@@ -930,8 +1044,9 @@ function createSettlement(ctx) {
       });
     }
     if (settlement.status !== "settled") {
-      await hold?.finalize("release");
+      await finalizeHold(flow, hold, "release");
       await safePersist(
+        flow,
         () => options.store.updatePaymentAttempt({
           replayKey,
           status: "rejected",
@@ -939,17 +1054,19 @@ function createSettlement(ctx) {
           ...settlement.externalReference !== void 0 ? { externalReference: settlement.externalReference } : {}
         }),
         "updatePaymentAttempt(rejected)",
-        request.requestId
+        "payment-attempt"
       );
       await safeEmit(
-        buildEvent({
+        buildEvent(flow, {
           type: "payment.rejected",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           paymentProvider: provider.name,
           status: "error",
-          data: settlement.rejectionReason ? { reason: settlement.rejectionReason } : {}
+          data: {
+            ...settlement.rejectionReason ? { reason: settlement.rejectionReason } : {},
+            ...failuresOf(flow)
+          }
         })
       );
       const rejectionDetails = retryChallenge(requirement, settlement.rejectionReason).details;
@@ -967,20 +1084,20 @@ function createSettlement(ctx) {
         }
       );
     }
-    await hold?.finalize("consume");
+    await finalizeHold(flow, hold, "consume");
     await safePersist(
+      flow,
       () => options.store.updatePaymentAttempt({
         replayKey,
         status: "settled",
         ...settlement.externalReference !== void 0 ? { externalReference: settlement.externalReference } : {}
       }),
       "updatePaymentAttempt(settled)",
-      request.requestId
+      "payment-attempt"
     );
     await safeEmit(
-      buildEvent({
+      buildEvent(flow, {
         type: "payment.settled",
-        requestId: request.requestId,
         resourceId: resource.id,
         adapter: request.protocol,
         paymentProvider: provider.name,
@@ -990,26 +1107,26 @@ function createSettlement(ctx) {
     return settlement;
   }
   async function abandonSettlement(args, backendErrorCode) {
-    const { request, resource, provider, replayKey, hold } = args;
-    await hold?.finalize("release");
+    const { flow, request, resource, provider, replayKey, hold } = args;
+    await finalizeHold(flow, hold, "release");
     await safePersist(
+      flow,
       () => options.store.updatePaymentAttempt({
         replayKey,
         status: "rejected",
         rejectionReason: "backend_failed"
       }),
       "updatePaymentAttempt(backend-failed)",
-      request.requestId
+      "payment-attempt"
     );
     await safeEmit(
-      buildEvent({
+      buildEvent(flow, {
         type: "payment.rejected",
-        requestId: request.requestId,
         resourceId: resource.id,
         adapter: request.protocol,
         paymentProvider: provider.name,
         status: "error",
-        data: { reason: "backend-failed", backendErrorCode }
+        data: { reason: "backend-failed", backendErrorCode, ...failuresOf(flow) }
       })
     );
   }
@@ -1046,7 +1163,7 @@ function createExecutionPipeline(options) {
     return compiled;
   }
   const ctx = createPipelineContext(options);
-  const { safeEmit, safePersist, buildEvent } = ctx;
+  const { safeEmit, safePersist, recordStep, buildEvent } = ctx;
   const { settle, abandonSettlement } = createSettlement(ctx);
   const admitPayment = createPaymentAdmission(ctx, createAuthorizeAndReserve(ctx));
   async function execute(request) {
@@ -1062,10 +1179,10 @@ function createExecutionPipeline(options) {
         }
       );
     }
+    const flow = createFlow(request, options.ids.next("txn"));
     await safeEmit(
-      buildEvent({
+      buildEvent(flow, {
         type: "resource.requested",
-        requestId: request.requestId,
         resourceId: resource.id,
         adapter: request.protocol
       })
@@ -1110,20 +1227,34 @@ function createExecutionPipeline(options) {
         }
       );
     }
-    let paymentResult;
-    let authorization;
-    let deferredSettlement;
+    let settleArgs;
     if (resource.pricing.type === "fixed") {
-      const admission = await admitPayment(request, resource, resource.pricing, validInput);
+      const admission = await admitPayment(flow, request, resource, resource.pricing, validInput);
       if (admission.kind === "payment-required") return admission;
-      const { settleArgs } = admission;
-      authorization = settleArgs.hold?.record;
+      settleArgs = admission.settleArgs;
+    }
+    try {
+      return await settleAndDeliver(flow, resource, validInput, settleArgs, pipelineStart);
+    } finally {
+      await recordStep(flow, { kind: "completed", ...failuresOf(flow) });
+    }
+  }
+  async function settleAndDeliver(flow, resource, validInput, settleArgs, pipelineStart) {
+    const { request } = flow;
+    const authorization = settleArgs?.hold?.record;
+    let paymentResult;
+    let deferredSettlement;
+    if (settleArgs !== void 0) {
       if (settleArgs.requirement.metadata?.[SETTLE_AFTER_BACKEND_METADATA_KEY] === true) {
         deferredSettlement = settleArgs;
       } else {
         paymentResult = await settle(settleArgs);
       }
     }
+    await recordStep(flow, {
+      kind: "backend-dispatched",
+      deadlineAt: backendDeadline(options.clock.now(), resource)
+    });
     const backendStart = options.clock.monotonicMs();
     let backendResponse;
     try {
@@ -1136,18 +1267,23 @@ function createExecutionPipeline(options) {
       });
     } catch (error) {
       const commerceError = toCommerceError(error, "BACKEND_ERROR", "Backend call failed");
-      await safeEmit(
-        buildEvent({
+      await recordStep(flow, {
+        kind: "backend-result",
+        status: backendErrorStatus(commerceError),
+        errorCode: commerceError.code
+      });
+      const backendFailed = (data = {}) => safeEmit(
+        buildEvent(flow, {
           type: "backend.failed",
-          requestId: request.requestId,
           resourceId: resource.id,
           adapter: request.protocol,
           status: "error",
           durationMs: Math.round(options.clock.monotonicMs() - backendStart),
-          data: { code: commerceError.code }
+          data: { code: commerceError.code, ...data }
         })
       );
       if (deferredSettlement !== void 0) {
+        await backendFailed();
         await abandonSettlement(deferredSettlement, commerceError.code);
         throw commerceError;
       }
@@ -1161,13 +1297,11 @@ function createExecutionPipeline(options) {
           protocol: request.protocol,
           payment: paymentResult,
           ...authorization !== void 0 ? { authorization } : {},
-          metadata: { delivered: false, backendErrorCode: commerceError.code }
+          metadata: { delivered: false, backendErrorCode: commerceError.code },
+          transactionId: flow.transactionId
         };
-        await safePersist(
-          () => options.store.saveReceipt(failedReceipt),
-          "saveReceipt(backend-failed-after-settlement)",
-          request.requestId
-        );
+        await saveReceipt(flow, failedReceipt, "saveReceipt(backend-failed-after-settlement)");
+        await backendFailed(failuresOf(flow));
         throw new CommerceError(
           "BACKEND_ERROR",
           "Payment settled but the backend call failed; the payment was not refunded automatically",
@@ -1191,12 +1325,13 @@ function createExecutionPipeline(options) {
           }
         );
       }
+      await backendFailed();
       throw commerceError;
     }
+    await recordStep(flow, { kind: "backend-result", status: backendResponse.status });
     await safeEmit(
-      buildEvent({
+      buildEvent(flow, {
         type: "backend.called",
-        requestId: request.requestId,
         resourceId: resource.id,
         adapter: request.protocol,
         status: "ok",
@@ -1216,34 +1351,48 @@ function createExecutionPipeline(options) {
       durationMs: backendResponse.durationMs,
       protocol: request.protocol,
       ...paymentResult !== void 0 ? { payment: paymentResult } : {},
-      ...authorization !== void 0 ? { authorization } : {}
+      ...authorization !== void 0 ? { authorization } : {},
+      transactionId: flow.transactionId
     };
-    await safePersist(() => options.store.saveReceipt(receipt), "saveReceipt", request.requestId);
+    await saveReceipt(flow, receipt, "saveReceipt");
     const totalDurationMs = Math.round(options.clock.monotonicMs() - pipelineStart);
+    const failures = failuresOf(flow);
     await safeEmit(
-      buildEvent({
+      buildEvent(flow, {
         type: "resource.delivered",
-        requestId: request.requestId,
         resourceId: resource.id,
         adapter: request.protocol,
         status: "ok",
-        durationMs: totalDurationMs
+        durationMs: totalDurationMs,
+        ...failures.persistenceFailures !== void 0 ? { data: failures } : {}
       })
     );
     return {
       kind: "delivered",
       requestId: request.requestId,
+      transactionId: flow.transactionId,
       resourceId: resource.id,
       backendStatus: backendResponse.status,
       body: backendResponse.body,
       headers: backendResponse.headers,
       ...paymentResult !== void 0 ? { payment: paymentResult } : {},
       receipt,
-      durationMs: totalDurationMs
+      durationMs: totalDurationMs,
+      ...failures
     };
   }
+  async function saveReceipt(flow, receipt, label) {
+    if (await safePersist(flow, () => options.store.saveReceipt(receipt), label, "receipt")) {
+      await recordStep(flow, { kind: "receipt", receiptId: receipt.id });
+    }
+  }
   return { execute };
 }
+var BACKEND_DEADLINE_MARGIN_MS = 5e3;
+function backendDeadline(dispatchedAt, resource) {
+  const timeoutMs = resource.handler.timeoutMs ?? DEFAULT_BACKEND_TIMEOUT_MS;
+  return new Date(dispatchedAt.getTime() + timeoutMs + BACKEND_DEADLINE_MARGIN_MS).toISOString();
+}
 function backendErrorStatus(error) {
   const status = error.details?.["status"];
   return typeof status === "number" ? status : 0;
@@ -1349,5 +1498,5 @@ var ACP_MERCHANT_RETRY_AFTER_DEFAULT_SECONDS = 5;
 var ACP_MERCHANT_RETRY_AFTER_MAX_SECONDS = 300;
 
 export { ACP_API_VERSION, ACP_API_VERSION_HEADER, ACP_CHECKOUT_OPERATIONS, ACP_FORWARDED_HEADERS, ACP_IDEMPOTENCY_KEY_HEADER, ACP_IDEMPOTENT_REPLAYED_HEADER, ACP_IN_FLIGHT_RETRY_AFTER_SECONDS, ACP_JSON_MEDIA_TYPE, ACP_MAX_FORWARDED_HEADER_LENGTH, ACP_MAX_REQUEST_ID_LENGTH, ACP_MERCHANT_RETRY_AFTER_DEFAULT_SECONDS, ACP_MERCHANT_RETRY_AFTER_MAX_SECONDS, ACP_OPERATION_INPUT_KEYS, ACP_OPERATION_OPTIONAL_INPUT_KEYS, ACP_REQUEST_ID_HEADER, ACP_SESSION_ID_INPUT_KEY, ACP_SPEC_VERSION, ACP_WELL_KNOWN_PATH, BackendErrorResponse, DEFAULT_CONFIG_FILENAME, HttpBackendExecutor, createExecutionPipeline, createResourceRegistry, createStoreEventSink, extractPathParameterNames, findUnparsedBraceToken, isObjectSchemaNode };
-//# sourceMappingURL=chunk-PIMFPCNZ.js.map
-//# sourceMappingURL=chunk-PIMFPCNZ.js.map
+//# sourceMappingURL=chunk-Z34UMZBB.js.map
+//# sourceMappingURL=chunk-Z34UMZBB.js.map