@proxy-checkout/stripe-server-js 0.1.0-prx-146.161.1 → 0.1.0

package/dist/esm/open-checkout.js

@@ -7,15 +7,10 @@
  * metadata placement, idempotency, and binding reconciliation.
  */
 import { assertCartBuyerReference, ProxyCheckoutValidationError } from "@proxy-checkout/server-js";
-import { acquireStripeRoot, assertNoConnectRequestOptions, checkoutCartConfirmation, fingerprintHostedCheckoutProviderOptions, recordOrReconcileLegacyCheckoutBinding, retrieveCheckoutSessionWithLineEvidence, } from "./acquisition.js";
-import { assertHostedNoCostCompatibility, assertStripePathCompatibility, } from "./compatibility.js";
-import { StripeResponseShapeError, UnsupportedStripeOptionError } from "./errors.js";
-import { assertCheckoutSessionBelongsToProxy, assertCheckoutSessionMetadataPreflight, assertProviderObjectBelongsToAcquisition, injectRequiredCheckoutSessionMetadata, } from "./metadata.js";
+import { ProxyStripeOpenCheckoutError } from "./errors.js";
+import { assertCheckoutSessionBelongsToProxy, injectRequiredCheckoutSessionMetadata, } from "./metadata.js";
 import { normalizePsp } from "./psp.js";
 export async function openCheckout(options) {
-    if (usesAcquisitionContract(options)) {
-        return openAcquisitionCheckout(options);
-    }
     // Normalize the same way the API does on store, so the binding is recorded
     // under the normalized psp and later syncCheckoutCart validations compare
     // normalized-to-normalized.
@@ -135,7 +130,7 @@ export async function openCheckout(options) {
     const checkoutSession = (await options.stripe.checkout.sessions.create(injectRequiredCheckoutSessionMetadata(params, proxySession.id), buildStripeRequestOptions(options, proxySession.id, psp)));
     // Fail closed if the merchant forgot to place proxy_session_id metadata.
     assertCheckoutSessionBelongsToProxy(checkoutSession, proxySession.id);
-    const binding = await recordOrReconcileLegacyCheckoutBinding({
+    const binding = await recordOrReconcileProviderBinding({
         checkoutSessionId: checkoutSession.id,
         expectedCartVersion: proxySession.cartVersion,
         commercialMode,
@@ -157,310 +152,6 @@ export async function openCheckout(options) {
         proxySessionId: proxySession.id,
     };
 }
-async function openAcquisitionCheckout(options) {
-    if (options.commercialMode !== "one_time" ||
-        (options.uiMode !== "hosted" && options.uiMode !== "embedded" && options.uiMode !== "custom") ||
-        options.pricingMode === undefined) {
-        throw new UnsupportedStripeOptionError("The explicit Checkout acquisition contract supports one_time hosted, embedded, and custom presentations only.", "uiMode");
-    }
-    if (normalizePsp(options.psp ?? "stripe") !== "stripe") {
-        throw new UnsupportedStripeOptionError("The Stripe acquisition helper cannot route provider creation through another PSP.", "psp");
-    }
-    assertNoConnectRequestOptions(options.stripeRequestOptions);
-    const compatibility = compatibilityDescriptor(options);
-    assertStripePathCompatibility(checkoutCompatibilityPath(options.uiMode), compatibility);
-    let proxySession = await options.proxy.sessions.payerOpened(options.proxySessionId, {
-        requestId: options.requestId,
-    });
-    let cart = parseCheckoutCart(options, proxySession);
-    if (proxySession.presentationState !== "checkout_available") {
-        return terminalResultFromSession(proxySession, cart);
-    }
-    let offer = options.validateCart
-        ? await options.validateCart({ cart, session: proxySession })
-        : undefined;
-    const reconciledCart = await options.reconcileCart?.({ cart, offer, session: proxySession });
-    if (reconciledCart) {
-        if (options.getCartBuyerReference) {
-            assertCartBuyerReference(options.getCartBuyerReference(reconciledCart.cart), proxySession);
-        }
-        try {
-            const updated = await options.proxy.sessions.cart.set(proxySession.id, {
-                amountMinor: reconciledCart.amountMinor,
-                cartSnapshot: reconciledCart.cartSnapshot,
-                currency: reconciledCart.currency,
-                expectedCartVersion: proxySession.cartVersion,
-                requestId: options.requestId,
-            });
-            proxySession = {
-                ...proxySession,
-                amountMinor: updated.amountMinor,
-                cartSnapshot: updated.cartSnapshot,
-                cartVersion: updated.cartVersion,
-                currency: updated.currency,
-            };
-        }
-        catch (cause) {
-            if (!isProxyConflict(cause))
-                throw cause;
-            const joined = await options.proxy.sessions.payerOpened(proxySession.id, {
-                requestId: options.requestId,
-            });
-            if (!sameCheckoutCart(joined, reconciledCart))
-                throw cause;
-            proxySession = joined;
-        }
-        cart = reconciledCart.cart;
-        if (options.validateCart)
-            offer = await options.validateCart({ cart, session: proxySession });
-    }
-    const current = await options.proxy.sessions.payerOpened(proxySession.id, {
-        requestId: options.requestId,
-    });
-    if (current.presentationState !== "checkout_available") {
-        return terminalResultFromSession(current, cart);
-    }
-    if (!sameCheckoutCart(current, proxySession)) {
-        throw new ProxyCheckoutValidationError(`Proxy session ${proxySession.id} cart changed while Checkout was being prepared.`, { code: "cart_version_conflict", field: "cart_version" });
-    }
-    proxySession = current;
-    const builtParams = await options.buildCheckoutSessionParams({
-        cart,
-        offer,
-        proxySession,
-        stripe: options.stripe,
-    });
-    validateAcquisitionCheckoutParams(builtParams, options, proxySession);
-    assertCheckoutSessionMetadataPreflight(builtParams, proxySession.id);
-    // Stripe 12 has no hosted ui_mode create field, while newer Stripe responses
-    // name the same provider value hosted_page. Omit only the hosted provider
-    // alias; client-secret paths must send their exact generation-specific mode.
-    const params = options.uiMode === "hosted" ? withoutHostedProviderUiMode(builtParams) : builtParams;
-    if (options.pricingMode === "fixed" && proxySession.amountMinor === 0) {
-        assertHostedNoCostCompatibility(compatibility);
-    }
-    const providerOptionsFingerprint = fingerprintHostedCheckoutProviderOptions(params);
-    const acquisitionResult = await acquireStripeRoot({
-        checkoutUiMode: options.uiMode,
-        commercialMode: "one_time",
-        integrationPath: "checkout_session",
-        objectType: "checkout_session",
-        pricingMode: options.pricingMode,
-        create: async (reservation) => {
-            const created = (await options.stripe.checkout.sessions.create(injectRequiredCheckoutSessionMetadata(params, proxySession.id, {
-                contractVersion: "2",
-                id: reservation.acquisitionAttempt.id,
-            }), {
-                ...options.stripeRequestOptions,
-                idempotencyKey: reservation.stripe.idempotencyKeys.root,
-            }));
-            return (await retrieveCheckoutSessionWithLineEvidence({
-                id: created.id,
-                initial: created,
-                requestOptions: options.stripeRequestOptions,
-                stripe: options.stripe,
-            }));
-        },
-        providerOptionsFingerprint,
-        proxy: options.proxy,
-        proxySession,
-        requestId: options.requestId,
-        retrieve: async (id) => (await retrieveCheckoutSessionWithLineEvidence({
-            id,
-            requestOptions: options.stripeRequestOptions,
-            stripe: options.stripe,
-        })),
-        toConfirmation: (session) => checkoutCartConfirmation({
-            cartVersion: proxySession.cartVersion,
-            checkoutSession: session,
-            expectedLineItems: params.line_items,
-        }),
-        validateObject: (session, acquisition) => {
-            assertProviderObjectBelongsToAcquisition(session, {
-                acquisitionAttemptId: acquisition.id,
-                integrationPath: "checkout_session",
-                proxySessionId: proxySession.id,
-            });
-            assertCheckoutProviderCart(session, proxySession, options.pricingMode ?? "fixed", params.line_items, options.uiMode ?? "hosted");
-        },
-    });
-    if (acquisitionResult.outcome === "terminal") {
-        return terminalResultFromSession(acquisitionResult.proxySession, cart);
-    }
-    const acquired = acquisitionResult;
-    const presentation = checkoutPresentation(acquired.object, options.uiMode);
-    return {
-        acquisitionAttemptId: acquired.acquisition.id,
-        binding: {
-            providerCheckoutSessionId: acquired.object.id,
-            proxySessionId: proxySession.id,
-            psp: "stripe",
-            updatedAt: acquired.acquisition.updatedAt,
-        },
-        cart,
-        checkoutSession: acquired.object,
-        checkoutSessionId: acquired.object.id,
-        clientSecret: presentation.kind === "client_secret" ? presentation.clientSecret : null,
-        offer,
-        outcome: "ready",
-        presentation,
-        proxySession,
-        proxySessionId: proxySession.id,
-    };
-}
-function usesAcquisitionContract(options) {
-    const values = [options.commercialMode, options.pricingMode, options.uiMode];
-    const count = values.filter((value) => value !== undefined).length;
-    if (count !== 0 && count !== values.length) {
-        throw new ProxyCheckoutValidationError("commercialMode, pricingMode, and uiMode must be supplied together for the acquisition contract.", { code: "unsupported_provider_option", field: "commercialMode" });
-    }
-    return count === values.length;
-}
-function parseCheckoutCart(options, proxySession) {
-    return options.cartSchema || options.getCartBuyerReference
-        ? options.proxy.sessions.parseCart(proxySession, options.cartSchema ?? ((value) => value), { getBuyerReference: options.getCartBuyerReference })
-        : proxySession.cartSnapshot;
-}
-function compatibilityDescriptor(options) {
-    if (!options.compatibility && !options.stripeApiVersion)
-        return undefined;
-    return {
-        ...options.compatibility,
-        ...(options.stripeApiVersion ? { apiVersion: options.stripeApiVersion } : {}),
-    };
-}
-function validateAcquisitionCheckoutParams(params, options, proxySession) {
-    assertCheckoutAutomaticRecoveryDisabled(params, proxySession.id);
-    if (checkoutCommercialMode(params, proxySession.id) !== options.commercialMode) {
-        throw new UnsupportedStripeOptionError("Stripe Checkout mode does not match commercialMode.", "mode");
-    }
-    const uiMode = normalizeProviderUiMode(params.ui_mode);
-    if (uiMode !== options.uiMode) {
-        throw new UnsupportedStripeOptionError(`Stripe Checkout ui_mode ${uiMode} does not match requested ${options.uiMode}.`, "ui_mode");
-    }
-    if (uiMode === "hosted" && !params.success_url) {
-        throw new UnsupportedStripeOptionError("Hosted Stripe Checkout requires success_url.", "success_url");
-    }
-    if (uiMode === "hosted" && params.return_url !== undefined) {
-        throw new UnsupportedStripeOptionError("Hosted Stripe Checkout uses success_url and must not set return_url.", "return_url");
-    }
-    if (uiMode !== "hosted" && !params.return_url) {
-        throw new UnsupportedStripeOptionError(`${uiMode} Stripe Checkout requires return_url.`, "return_url");
-    }
-    if (uiMode !== "hosted" && params.success_url !== undefined) {
-        throw new UnsupportedStripeOptionError(`${uiMode} Stripe Checkout uses return_url and must not set success_url.`, "success_url");
-    }
-    const paymentIntentData = objectRecord(params.payment_intent_data);
-    for (const field of [
-        "application_fee_amount",
-        "application_fee_percent",
-        "capture_method",
-        "on_behalf_of",
-        "transfer_data",
-        "transfer_group",
-    ]) {
-        if (paymentIntentData[field] !== undefined) {
-            throw new UnsupportedStripeOptionError(`One-time Checkout does not support payment_intent_data.${field}.`, `payment_intent_data.${field}`);
-        }
-    }
-    if (options.pricingMode === "fixed") {
-        for (const field of [
-            "allow_promotion_codes",
-            "shipping_address_collection",
-            "shipping_options",
-        ]) {
-            const value = params[field];
-            if (value !== undefined && value !== false) {
-                throw new UnsupportedStripeOptionError(`Fixed-price Checkout cannot use provider-finalized option ${field}.`, field);
-            }
-        }
-        for (const field of ["adaptive_pricing", "automatic_tax"]) {
-            const value = objectRecord(params[field]);
-            if (value.enabled === true) {
-                throw new UnsupportedStripeOptionError(`Fixed-price Checkout cannot enable provider-finalized option ${field}.`, `${field}.enabled`);
-            }
-        }
-        const lineItems = Array.isArray(params.line_items) ? params.line_items : [];
-        if (lineItems.some((line) => objectRecord(objectRecord(line).adjustable_quantity).enabled === true)) {
-            throw new UnsupportedStripeOptionError("Fixed-price Checkout cannot enable adjustable line-item quantities.", "line_items.adjustable_quantity.enabled");
-        }
-    }
-}
-function assertCheckoutProviderCart(checkoutSession, proxySession, pricingMode, expectedLineItems, requestedUiMode) {
-    const confirmation = checkoutCartConfirmation({
-        cartVersion: 0,
-        checkoutSession,
-        expectedLineItems,
-    });
-    if (checkoutSession.mode !== undefined &&
-        checkoutSession.mode !== null &&
-        checkoutSession.mode !== "payment") {
-        throw new StripeResponseShapeError("Stripe Checkout response is not payment mode.", "mode");
-    }
-    if (normalizeProviderUiMode(checkoutSession.ui_mode) !== requestedUiMode) {
-        throw new StripeResponseShapeError(`Stripe Checkout response is not ${requestedUiMode} UI mode.`, "ui_mode");
-    }
-    if (confirmation.currency !== proxySession.currency ||
-        (pricingMode === "fixed" && confirmation.amountMinor !== proxySession.amountMinor)) {
-        throw new ProxyCheckoutValidationError(`Stripe Checkout Session ${checkoutSession.id} does not represent the current Proxy cart amount and currency.`, { code: "cart_version_conflict", field: "provider_amount" });
-    }
-}
-function normalizeProviderUiMode(value) {
-    if (value === undefined || value === null || value === "hosted" || value === "hosted_page") {
-        return "hosted";
-    }
-    if (value === "embedded" || value === "embedded_page")
-        return "embedded";
-    if (value === "custom" || value === "elements")
-        return "custom";
-    return value;
-}
-function checkoutCompatibilityPath(uiMode) {
-    return `one_time.checkout.${uiMode}`;
-}
-function checkoutPresentation(checkoutSession, uiMode) {
-    const clientSecret = checkoutSession.client_secret;
-    const url = checkoutSession.url;
-    if (uiMode === "hosted") {
-        if (!isSafeHostedCheckoutUrl(url)) {
-            throw new StripeResponseShapeError("Hosted Stripe Checkout response did not contain a safe HTTPS redirect URL.", "url");
-        }
-        if (clientSecret !== undefined && clientSecret !== null) {
-            throw new StripeResponseShapeError("Hosted Stripe Checkout response unexpectedly contained a client secret.", "client_secret");
-        }
-        return { kind: "redirect", url };
-    }
-    if (!isCheckoutSessionClientSecret(clientSecret)) {
-        throw new StripeResponseShapeError(`${uiMode} Stripe Checkout response did not contain a valid Checkout Session client secret.`, "client_secret");
-    }
-    if (url !== undefined && url !== null) {
-        throw new StripeResponseShapeError(`${uiMode} Stripe Checkout response unexpectedly contained a hosted redirect URL.`, "url");
-    }
-    return { clientSecret, kind: "client_secret", uiMode };
-}
-function isCheckoutSessionClientSecret(value) {
-    return typeof value === "string" && /^cs_(?:test|live)_[A-Za-z0-9_]+$/.test(value);
-}
-function isSafeHostedCheckoutUrl(value) {
-    if (typeof value !== "string" || value !== value.trim())
-        return false;
-    try {
-        const parsed = new URL(value);
-        return parsed.protocol === "https:" && parsed.username === "" && parsed.password === "";
-    }
-    catch {
-        return false;
-    }
-}
-function withoutHostedProviderUiMode(params) {
-    if (params.ui_mode === undefined)
-        return params;
-    const { ui_mode: _providerUiMode, ...providerParams } = params;
-    return providerParams;
-}
-function objectRecord(value) {
-    return typeof value === "object" && value !== null ? value : {};
-}
 function terminalResultFromSession(proxySession, cart) {
     const common = {
         cart,
@@ -520,6 +211,31 @@ function bindingFromSession(proxySession) {
         updatedAt: proxySession.updatedAt,
     };
 }
+async function recordOrReconcileProviderBinding(input) {
+    try {
+        return await input.proxy.sessions.recordProviderBinding(input.proxySessionId, {
+            commercialMode: input.commercialMode,
+            expectedCartVersion: input.expectedCartVersion,
+            providerCheckoutSessionId: input.checkoutSessionId,
+            psp: input.psp,
+            requestId: input.requestId,
+        });
+    }
+    catch (cause) {
+        const reconciled = await readReconciledBinding(input).catch(() => undefined);
+        if (reconciled) {
+            return reconciled;
+        }
+        if (isProxyConflict(cause)) {
+            throw cause;
+        }
+        throw new ProxyStripeOpenCheckoutError("Stripe Checkout Session was created but Proxy provider binding could not be recorded.", {
+            cause,
+            code: "provider_binding_failed",
+            providerCheckoutSessionId: input.checkoutSessionId,
+        });
+    }
+}
 function sameCheckoutCart(actual, expected) {
     return (actual.amountMinor === expected.amountMinor &&
         actual.currency === expected.currency &&
@@ -551,6 +267,18 @@ function assertCheckoutAutomaticRecoveryDisabled(params, proxySessionId) {
         throw new ProxyCheckoutValidationError(`Proxy session ${proxySessionId} does not allow Stripe Checkout automatic recovery because replacement roots require explicit Proxy supersession.`, { code: "unsupported_provider_option", field: "after_expiration.recovery.enabled" });
     }
 }
+async function readReconciledBinding(input) {
+    const current = await input.proxy.sessions.retrieve(input.proxySessionId, {
+        requestId: input.requestId,
+    });
+    if (current.providerCheckoutSessionId !== input.checkoutSessionId ||
+        current.providerCheckoutSessionPsp !== input.psp) {
+        return undefined;
+    }
+    const checkoutSession = await input.stripe.checkout.sessions.retrieve(input.checkoutSessionId, undefined, input.stripeRequestOptions);
+    assertCheckoutSessionBelongsToProxy(checkoutSession, input.proxySessionId);
+    return bindingFromSession(current);
+}
 function isProxyConflict(error) {
     return (typeof error === "object" &&
         error !== null &&

package/dist/esm/sync-checkout-cart.d.ts

@@ -6,7 +6,7 @@
  * safest order with deterministic rollback/reconciliation on failure.
  */
 import { type JsonObject, type MerchantProxySession, type ProxyCartValidator, type ProxyCheckoutServerClient } from "@proxy-checkout/server-js";
-import type { StripeCheckoutSessionLike, StripeMutableCheckoutClientLike, StripeRequestOptionsWithoutIdempotencyLike } from "./types.js";
+import type { StripeCheckoutSessionLike, StripeClientLike, StripeRequestOptionsWithoutIdempotencyLike } from "./types.js";
 /** The next cart, expressed both as Proxy state and the typed merchant cart. */
 export interface SyncedCart<TCart> {
     readonly amountMinor: number;
@@ -14,7 +14,7 @@ export interface SyncedCart<TCart> {
     readonly cartSnapshot: JsonObject;
     readonly currency: string;
 }
-export interface SyncCheckoutCartOptions<TStripe extends StripeMutableCheckoutClientLike, TCart, TInput> {
+export interface SyncCheckoutCartOptions<TStripe extends StripeClientLike, TCart, TInput> {
     /** Compute the next cart from current state and the merchant input. */
     readonly buildNextCart: (input: {
         currentCart: TCart;
@@ -44,4 +44,4 @@ export interface SyncCheckoutCartResult<TCart> {
     readonly checkoutSession: StripeCheckoutSessionLike;
     readonly currency: string;
 }
-export declare function syncCheckoutCart<TStripe extends StripeMutableCheckoutClientLike, TCart, TInput>(options: SyncCheckoutCartOptions<TStripe, TCart, TInput>): Promise<SyncCheckoutCartResult<TCart>>;
+export declare function syncCheckoutCart<TStripe extends StripeClientLike, TCart, TInput>(options: SyncCheckoutCartOptions<TStripe, TCart, TInput>): Promise<SyncCheckoutCartResult<TCart>>;

package/dist/esm/sync-checkout-cart.js

@@ -6,9 +6,8 @@
  * safest order with deterministic rollback/reconciliation on failure.
  */
 import { ProxyCheckoutValidationError, } from "@proxy-checkout/server-js";
-import { assertNoConnectRequestOptions, checkoutCartConfirmation, retrieveCheckoutSessionWithLineEvidence, } from "./acquisition.js";
 import { ProxyStripeCartSyncError } from "./errors.js";
-import { assertCheckoutSessionBelongsToProxy, assertProviderObjectBelongsToAcquisition, } from "./metadata.js";
+import { assertCheckoutSessionBelongsToProxy } from "./metadata.js";
 import { normalizePsp } from "./psp.js";
 export async function syncCheckoutCart(options) {
     // Normalize the same way the API does on store, so the binding comparison is
@@ -18,32 +17,11 @@ export async function syncCheckoutCart(options) {
     const session = await options.proxy.sessions.retrieve(options.proxySessionId, {
         requestId: options.requestId,
     });
-    // Ownership: validate the stored binding and, for contract-v2 objects, the
-    // exact acquisition before any Stripe read or mutation.
+    // Ownership: validate against the stored binding first, then defensively
+    // against the Stripe object's own metadata.
     assertSessionBoundTo(session, options.checkoutSessionId, psp);
-    const acquisition = session.currentAcquisitionAttempt === null
-        ? null
-        : await resolveExplicitCheckoutAcquisition(options, session);
-    if (acquisition)
-        assertNoConnectRequestOptions(options.stripeRequestOptions);
-    if (acquisition?.checkoutUiMode === "hosted") {
-        throw new ProxyStripeCartSyncError("Hosted Stripe Checkout Sessions do not support line-item mutation. Expire the bound Session, wait for Proxy to observe provider-confirmed expiry, update the versioned Proxy cart, supersede the terminal acquisition, and call openCheckout again.", {
-            cause: new Error("Stripe hosted Checkout requires provider-confirmed replacement"),
-            code: "hosted_replacement_required",
-            reconciled: true,
-        });
-    }
     const stripeSession = await options.stripe.checkout.sessions.retrieve(options.checkoutSessionId, undefined, options.stripeRequestOptions);
-    if (acquisition) {
-        assertProviderObjectBelongsToAcquisition(stripeSession, {
-            acquisitionAttemptId: acquisition.id,
-            integrationPath: "checkout_session",
-            proxySessionId: options.proxySessionId,
-        });
-    }
-    else {
-        assertCheckoutSessionBelongsToProxy(stripeSession, options.proxySessionId);
-    }
+    assertCheckoutSessionBelongsToProxy(stripeSession, options.proxySessionId);
     const currentCart = options.cartSchema
         ? options.proxy.sessions.parseCart(session, options.cartSchema)
         : session.cartSnapshot;
@@ -52,6 +30,12 @@ export async function syncCheckoutCart(options) {
         currentSession: session,
         input: options.input,
     });
+    const prior = {
+        amountMinor: session.amountMinor,
+        cartSnapshot: session.cartSnapshot,
+        cartVersion: session.cartVersion,
+        currency: session.currency,
+    };
     const stripeUpdateParams = {
         line_items: options.buildStripeLineItems(next.cart),
     };
@@ -73,22 +57,19 @@ export async function syncCheckoutCart(options) {
             updatedCheckout = await options.stripe.checkout.sessions.update(options.checkoutSessionId, stripeUpdateParams, stripeUpdateOptions);
         }
         catch (retryCause) {
-            throw new ProxyStripeCartSyncError("Stripe checkout update failed after an idempotent retry. The versioned Proxy cart remains committed so another concurrent viewer cannot be orphaned; provider success is gated until that revision is confirmed.", { cause: retryCause, code: "stripe_update_failed", reconciled: false });
-        }
-    }
-    if (acquisition) {
-        try {
-            await confirmCheckoutCartRevision(options, {
-                acquisition,
-                cartVersion: proxyCartUpdate.cartVersion,
-                checkoutSession: updatedCheckout,
-                currency: proxyCartUpdate.currency,
-                expectedAmountMinor: proxyCartUpdate.amountMinor,
-                expectedLineItems: stripeUpdateParams.line_items,
-            });
-        }
-        catch (cause) {
-            throw new ProxyStripeCartSyncError("Stripe checkout was updated, but Proxy could not confirm the provider-authored cart revision; payment remains non-provisionable until reconciliation succeeds.", { cause, code: "reconciliation_failed", reconciled: false });
+            try {
+                await options.proxy.sessions.cart.set(options.proxySessionId, {
+                    amountMinor: prior.amountMinor,
+                    cartSnapshot: prior.cartSnapshot,
+                    currency: prior.currency,
+                    expectedCartVersion: proxyCartUpdate.cartVersion,
+                    requestId: options.requestId,
+                });
+            }
+            catch (rollbackCause) {
+                throw new ProxyStripeCartSyncError("Stripe checkout update failed after an idempotent retry and the Proxy cart rollback failed; carts may be out of sync.", { cause: retryCause, code: "reconciliation_failed", reconciled: false, rollbackCause });
+            }
+            throw new ProxyStripeCartSyncError("Stripe checkout update failed after an idempotent retry; the Proxy cart rollback was attempted, but Stripe state may still be ambiguous.", { cause: retryCause, code: "stripe_update_failed", reconciled: false });
         }
     }
     return {
@@ -99,57 +80,6 @@ export async function syncCheckoutCart(options) {
         currency: proxyCartUpdate.currency,
     };
 }
-async function confirmCheckoutCartRevision(options, input) {
-    const checkoutSession = await retrieveCheckoutSessionWithLineEvidence({
-        id: options.checkoutSessionId,
-        initial: input.checkoutSession,
-        requestOptions: options.stripeRequestOptions,
-        stripe: options.stripe,
-    });
-    const confirmation = checkoutCartConfirmation({
-        cartVersion: input.cartVersion,
-        checkoutSession,
-        expectedLineItems: input.expectedLineItems,
-    });
-    const acquisition = input.acquisition;
-    if (acquisition.commercialMode !== "one_time" ||
-        acquisition.integrationPath !== "checkout_session") {
-        return;
-    }
-    if (acquisition.pricingMode === "fixed" &&
-        confirmation.amountMinor !== input.expectedAmountMinor) {
-        throw new Error("Stripe Checkout total does not match the fixed Proxy cart amount.");
-    }
-    if (confirmation.currency !== input.currency) {
-        throw new Error("Stripe Checkout currency does not match the Proxy cart currency.");
-    }
-    await options.proxy.providerAcquisitions.confirmProviderAcquisitionCart(options.proxySessionId, acquisition.id, {
-        ...confirmation,
-        expectedVersion: acquisition.version,
-        requestId: options.requestId,
-    });
-}
-async function resolveExplicitCheckoutAcquisition(options, session) {
-    const summary = session.currentAcquisitionAttempt;
-    if (summary === null || summary.integrationPath !== "checkout_session") {
-        throw acquisitionBindingMismatch(session.id, "current_acquisition_attempt.integration_path", "The current Proxy acquisition is not a Checkout Session acquisition.");
-    }
-    const acquisitions = await options.proxy.providerAcquisitions.listProviderAcquisitions(session.id, { requestId: options.requestId });
-    const acquisition = acquisitions.find((candidate) => candidate.id === summary.id);
-    if (acquisition?.psp !== "stripe" ||
-        acquisition.integrationPath !== "checkout_session" ||
-        acquisition.providerRootObjectType !== "checkout_session" ||
-        acquisition.providerRootObjectId !== options.checkoutSessionId) {
-        throw acquisitionBindingMismatch(session.id, "current_acquisition_attempt", "The current Proxy acquisition is not bound to the requested Stripe Checkout Session.");
-    }
-    return acquisition;
-}
-function acquisitionBindingMismatch(proxySessionId, field, message) {
-    return new ProxyCheckoutValidationError(`${message} Proxy session: ${proxySessionId}.`, {
-        code: "provider_binding_mismatch",
-        field,
-    });
-}
 function buildStripeUpdateRequestOptions(options, cartVersion) {
     return {
         ...options.stripeRequestOptions,