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

package/dist/cjs/acquisition.js

@@ -1,789 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNoConnectRequestOptions = assertNoConnectRequestOptions;
-exports.terminalAcquisitionResult = terminalAcquisitionResult;
-exports.openSharedAcquisitionSession = openSharedAcquisitionSession;
-exports.acquireStripeRoot = acquireStripeRoot;
-exports.terminalAfterAcquisitionFailure = terminalAfterAcquisitionFailure;
-exports.recordOrReconcileLegacyCheckoutBinding = recordOrReconcileLegacyCheckoutBinding;
-exports.fingerprintStripeProviderOptions = fingerprintStripeProviderOptions;
-exports.hashProviderCartEvidence = hashProviderCartEvidence;
-exports.checkoutOptionsForFingerprint = checkoutOptionsForFingerprint;
-exports.fingerprintHostedCheckoutProviderOptions = fingerprintHostedCheckoutProviderOptions;
-exports.retrieveCheckoutSessionWithLineEvidence = retrieveCheckoutSessionWithLineEvidence;
-exports.checkoutCartConfirmation = checkoutCartConfirmation;
-exports.paymentIntentOptionsForFingerprint = paymentIntentOptionsForFingerprint;
-exports.acquisitionMetadata = acquisitionMetadata;
-exports.mergeAcquisitionMetadata = mergeAcquisitionMetadata;
-exports.assertMerchantDoesNotSetAcquisitionMetadata = assertMerchantDoesNotSetAcquisitionMetadata;
-exports.assertAcquisitionMetadata = assertAcquisitionMetadata;
-exports.reserveDirectSubscriptionAcquisition = reserveDirectSubscriptionAcquisition;
-exports.recoverSetupIntentReservation = recoverSetupIntentReservation;
-exports.attachAcquisitionObject = attachAcquisitionObject;
-exports.createOrRecoverStripeAcquisitionObject = createOrRecoverStripeAcquisitionObject;
-exports.stripeRequestOptions = stripeRequestOptions;
-exports.requireStripeObjectId = requireStripeObjectId;
-exports.assertDirectSubscriptionReservation = assertDirectSubscriptionReservation;
-const node_crypto_1 = require("node:crypto");
-const server_js_1 = require("@proxy-checkout/server-js");
-const errors_js_1 = require("./errors.js");
-const metadata_js_1 = require("./metadata.js");
-const MAX_STRIPE_METADATA_KEYS = 50;
-const MAX_STRIPE_METADATA_KEY_LENGTH = 40;
-const MAX_STRIPE_METADATA_VALUE_LENGTH = 500;
-/** Connect routing is outside every first-class Proxy acquisition path. */
-function assertNoConnectRequestOptions(options) {
-    if (options && (options.stripeAccount !== undefined || options.stripe_account !== undefined)) {
-        throw new errors_js_1.UnsupportedStripeOptionError("Stripe Connect account routing is outside this acquisition capability.", "stripeRequestOptions.stripeAccount");
-    }
-}
-function terminalAcquisitionResult(proxySession, cart) {
-    const common = { cart, proxySession, proxySessionId: proxySession.id };
-    if (proxySession.presentationState === "already_paid" &&
-        (proxySession.status === "paid" ||
-            proxySession.status === "provisionable" ||
-            proxySession.status === "provisioned" ||
-            proxySession.status === "provisioning_failed")) {
-        return { ...common, outcome: "already_paid", sessionStatus: proxySession.status };
-    }
-    if (proxySession.presentationState === "action_required" &&
-        proxySession.status === "merchant_action_required") {
-        return { ...common, outcome: "action_required", sessionStatus: proxySession.status };
-    }
-    if (proxySession.presentationState === "unavailable" &&
-        (proxySession.status === "cancelled" ||
-            proxySession.status === "created" ||
-            proxySession.status === "expired" ||
-            proxySession.status === "failed")) {
-        return { ...common, outcome: "unavailable", sessionStatus: proxySession.status };
-    }
-    throw new server_js_1.ProxyCheckoutValidationError(`Proxy session ${proxySession.id} returned an inconsistent presentation and lifecycle status.`, { code: "invalid_session_presentation", field: "presentation_state" });
-}
-async function openSharedAcquisitionSession(options) {
-    const proxySession = await options.proxy.sessions.payerOpened(options.proxySessionId, {
-        requestId: options.requestId,
-    });
-    const cart = options.cartSchema || options.getCartBuyerReference
-        ? options.proxy.sessions.parseCart(proxySession, options.cartSchema ?? ((value) => value), { getBuyerReference: options.getCartBuyerReference })
-        : proxySession.cartSnapshot;
-    if (proxySession.presentationState === "checkout_available") {
-        return { cart, outcome: "active", proxySession, proxySessionId: proxySession.id };
-    }
-    return terminalAcquisitionResult(proxySession, cart);
-}
-/**
- * One order-scoped owner for reserve/join, deterministic provider creation,
- * null-or-same attachment, and exact provider/cart confirmation. There is no
- * payer lease: every identical caller can execute this function concurrently.
- */
-async function acquireStripeRoot(options) {
-    const existing = await currentAcquisition(options);
-    if (existing?.providerRootObjectId) {
-        assertAcquisitionConfiguration(existing, options);
-        const object = await retrieveKnownRoot(options, existing, existing.providerRootObjectId);
-        options.validateObject(object, existing);
-        assertProviderCustomer(existing, object);
-        const acquisition = await confirmProviderCart(options, existing, options.toConfirmation(object));
-        return { acquisition, object, outcome: "acquired", reservation: null };
-    }
-    let reservation;
-    try {
-        reservation = await options.proxy.providerAcquisitions.reserveProviderAcquisition(options.proxySession.id, {
-            ...(options.checkoutUiMode === undefined ? {} : { checkoutUiMode: options.checkoutUiMode }),
-            commercialMode: options.commercialMode,
-            integrationPath: options.integrationPath,
-            ...(options.directMerchandiseSubtotalMinor === undefined
-                ? {}
-                : { merchandiseSubtotalMinor: options.directMerchandiseSubtotalMinor }),
-            pricingMode: options.pricingMode,
-            providerOptionsFingerprint: options.providerOptionsFingerprint,
-            requestId: options.requestId,
-        });
-    }
-    catch (cause) {
-        const proxySession = await terminalAfterAcquisitionFailure({
-            cause,
-            proxy: options.proxy,
-            proxySessionId: options.proxySession.id,
-            requestId: options.requestId,
-        });
-        return { outcome: "terminal", proxySession };
-    }
-    let acquisition = reservation.acquisitionAttempt;
-    if (acquisition.providerRootObjectId) {
-        const object = await retrieveKnownRoot(options, acquisition, acquisition.providerRootObjectId);
-        options.validateObject(object, acquisition);
-        assertProviderCustomer(acquisition, object);
-        acquisition = await confirmProviderCart(options, acquisition, options.toConfirmation(object));
-        return { acquisition, object, outcome: "acquired", reservation };
-    }
-    const replayed = await createOrRecoverStripeAcquisitionObject({
-        acquisition,
-        objectType: options.objectType,
-        proxy: options.proxy,
-        proxySessionId: options.proxySession.id,
-        requestId: options.requestId,
-        retrieve: options.retrieve,
-        role: "root",
-        create: () => options.create(reservation),
-    });
-    const { object } = replayed;
-    acquisition = replayed.acquisition;
-    options.validateObject(object, acquisition);
-    assertProviderCustomer(acquisition, object);
-    const confirmation = options.toConfirmation(object);
-    if (!replayed.alreadyAttached) {
-        acquisition = await attachAcquisitionObject({
-            acquisitionAttempt: acquisition,
-            objectId: object.id,
-            objectType: options.objectType,
-            providerConfirmation: confirmation,
-            proxy: options.proxy,
-            proxySessionId: options.proxySession.id,
-            requestId: options.requestId,
-            role: "root",
-        });
-    }
-    acquisition = await confirmProviderCart(options, acquisition, confirmation);
-    return { acquisition, object, outcome: "acquired", reservation };
-}
-/**
- * Re-read only a terminal reserve conflict. Failures after reserve are never
- * converted because a Stripe root may already exist and must remain visible.
- */
-async function terminalAfterAcquisitionFailure(input) {
-    if (!isTerminalReserveConflict(input.cause))
-        throw input.cause;
-    const proxySession = await input.proxy.sessions.payerOpened(input.proxySessionId, {
-        requestId: input.requestId,
-    });
-    if (proxySession.presentationState === "checkout_available")
-        throw input.cause;
-    return proxySession;
-}
-function isTerminalReserveConflict(cause) {
-    if (!cause || typeof cause !== "object")
-        return false;
-    const error = cause;
-    return (error.statusCode === 409 &&
-        (error.code === "session_already_completed" || error.code === "session_not_actionable"));
-}
-/** Compatibility bridge for 0.0.x Checkout callers while the public helper
- * moves all provider-binding ownership out of open-checkout.ts. */
-async function recordOrReconcileLegacyCheckoutBinding(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 readLegacyCheckoutBinding(input).catch(() => undefined);
-        if (reconciled)
-            return reconciled;
-        if (isProxyConflict(cause))
-            throw cause;
-        throw new errors_js_1.ProxyStripeOpenCheckoutError("Stripe Checkout Session was created but Proxy provider binding could not be recorded.", {
-            cause,
-            code: "provider_binding_failed",
-            providerCheckoutSessionId: input.checkoutSessionId,
-        });
-    }
-}
-function fingerprintStripeProviderOptions(path, params) {
-    return hashEvidence(`proxy.stripe.provider_options.${path}.v1`, params);
-}
-function hashProviderCartEvidence(path, value) {
-    return hashEvidence(`proxy.stripe.provider_cart.${path}.v1`, value);
-}
-function checkoutOptionsForFingerprint(params) {
-    const { line_items: _lineItems, ...configuration } = params;
-    return configuration;
-}
-/** Canonical provider-options identity used when replacing a hosted Checkout acquisition. */
-function fingerprintHostedCheckoutProviderOptions(params) {
-    return fingerprintStripeProviderOptions("checkout_session", checkoutOptionsForFingerprint(params));
-}
-async function retrieveCheckoutSessionWithLineEvidence(input) {
-    let session = input.initial;
-    if (!hasCompleteCheckoutLineItems(session)) {
-        session = await input.stripe.checkout.sessions.retrieve(input.id, { expand: ["line_items.data.price"] }, input.requestOptions);
-    }
-    if (hasCompleteCheckoutLineItems(session))
-        return session;
-    const listLineItems = input.stripe.checkout.sessions.listLineItems;
-    if (!listLineItems) {
-        throw new errors_js_1.StripeResponseShapeError("Stripe Checkout line-item evidence is incomplete; enable expanded line_items or provide checkout.sessions.listLineItems.", "line_items");
-    }
-    const data = [];
-    let startingAfter;
-    for (let pageNumber = 0; pageNumber < 100; pageNumber += 1) {
-        const page = await listLineItems.call(input.stripe.checkout.sessions, input.id, {
-            expand: ["data.price"],
-            limit: 100,
-            ...(startingAfter ? { starting_after: startingAfter } : {}),
-        }, input.requestOptions);
-        if (!Array.isArray(page.data)) {
-            throw new errors_js_1.StripeResponseShapeError("Stripe Checkout line-item list response is missing data.", "line_items.data");
-        }
-        data.push(...page.data);
-        if (page.has_more !== true) {
-            return { ...session, line_items: { data, has_more: false } };
-        }
-        const cursor = page.data.at(-1)?.id;
-        if (!cursor) {
-            throw new errors_js_1.StripeResponseShapeError("Stripe Checkout line-item pagination is missing its cursor.", "line_items.data.id");
-        }
-        startingAfter = cursor;
-    }
-    throw new errors_js_1.StripeResponseShapeError("Stripe Checkout line-item evidence exceeded the bounded 10,000-line read.", "line_items");
-}
-function checkoutCartConfirmation(input) {
-    const { checkoutSession } = input;
-    if (!Number.isSafeInteger(checkoutSession.amount_total) ||
-        (checkoutSession.amount_total ?? -1) < 0 ||
-        !Number.isSafeInteger(checkoutSession.amount_subtotal) ||
-        (checkoutSession.amount_subtotal ?? -1) < 0 ||
-        typeof checkoutSession.currency !== "string") {
-        throw new errors_js_1.StripeResponseShapeError("Stripe Checkout response is missing amount_total, amount_subtotal, or currency.", "amount_total");
-    }
-    const providerLines = normalizeProviderCheckoutLines(checkoutSession);
-    const expectedLines = normalizeExpectedCheckoutLines(input.expectedLineItems);
-    if (!checkoutLinesMatch(expectedLines, providerLines)) {
-        throw new server_js_1.ProxyCheckoutValidationError(`Stripe Checkout Session ${checkoutSession.id} line identity, quantity, or recurring semantics do not match the requested cart revision.`, { code: "cart_version_conflict", field: "provider_line_items" });
-    }
-    const amountMinor = checkoutSession.amount_total;
-    const merchandiseSubtotalMinor = checkoutSession.amount_subtotal;
-    return {
-        amountMinor,
-        cartVersion: input.cartVersion,
-        currency: checkoutSession.currency,
-        evidenceSha256: hashProviderCartEvidence("checkout_session", {
-            amount_subtotal: merchandiseSubtotalMinor,
-            amount_total: amountMinor,
-            cart_version: input.cartVersion,
-            currency: checkoutSession.currency,
-            id: checkoutSession.id,
-            lines: providerLines,
-        }),
-        merchandiseSubtotalMinor,
-    };
-}
-function paymentIntentOptionsForFingerprint(params) {
-    const { amount: _amount, currency: _currency, ...configuration } = params;
-    return configuration;
-}
-function acquisitionMetadata(reservation) {
-    return {
-        proxy_acquisition_attempt_id: reservation.stripe.metadata.proxyAcquisitionAttemptId,
-        proxy_contract_version: reservation.stripe.metadata.proxyContractVersion,
-        proxy_integration_path: reservation.acquisitionAttempt.integrationPath,
-        proxy_session_id: reservation.stripe.metadata.proxySessionId,
-    };
-}
-function mergeAcquisitionMetadata(existing, required, field = "metadata") {
-    for (const [key, requiredValue] of Object.entries(required)) {
-        const existingValue = existing?.[key];
-        if (existingValue !== undefined && existingValue !== requiredValue) {
-            throw new errors_js_1.ProxyMetadataConflictError(`${field}.${key}`);
-        }
-    }
-    const merged = { ...existing, ...required };
-    const entries = Object.entries(merged);
-    if (entries.length > MAX_STRIPE_METADATA_KEYS) {
-        throw new errors_js_1.ProxyStripeAcquisitionError(`Stripe ${field} has ${entries.length} keys after adding Proxy acquisition metadata; the supported maximum is ${MAX_STRIPE_METADATA_KEYS}.`, { code: "unsupported_provider_option", field });
-    }
-    for (const [key, value] of entries) {
-        if (key.length === 0 || key.length > MAX_STRIPE_METADATA_KEY_LENGTH) {
-            throw new errors_js_1.ProxyStripeAcquisitionError(`Stripe ${field} contains a metadata key outside the supported length.`, { code: "unsupported_provider_option", field: `${field}.${key}` });
-        }
-        if (value !== null && String(value).length > MAX_STRIPE_METADATA_VALUE_LENGTH) {
-            throw new errors_js_1.ProxyStripeAcquisitionError(`Stripe ${field}.${key} exceeds the supported metadata value length.`, { code: "unsupported_provider_option", field: `${field}.${key}` });
-        }
-    }
-    return merged;
-}
-function assertMerchantDoesNotSetAcquisitionMetadata(metadata, field = "metadata") {
-    for (const key of [
-        "proxy_acquisition_attempt_id",
-        "proxy_contract_version",
-        "proxy_integration_path",
-        "proxy_session_id",
-    ]) {
-        if (metadata?.[key] !== undefined) {
-            throw new errors_js_1.ProxyMetadataConflictError(`${field}.${key}`);
-        }
-    }
-}
-function assertAcquisitionMetadata(metadata, expected, objectLabel) {
-    for (const [key, expectedValue] of Object.entries(expected)) {
-        if (metadata?.[key] !== expectedValue) {
-            throw new errors_js_1.ProxyStripeAcquisitionError(`${objectLabel} metadata.${key} does not match the Proxy acquisition.`, { code: "acquisition_mismatch", field: `metadata.${key}` });
-        }
-    }
-}
-async function reserveDirectSubscriptionAcquisition(input) {
-    return input.proxy.providerAcquisitions.reserveProviderAcquisition(input.proxySessionId, {
-        commercialMode: "subscription",
-        directSubscriptionSource: input.directSubscriptionSource,
-        integrationPath: "direct_subscription",
-        pricingMode: "fixed",
-        providerOptionsFingerprint: input.providerOptionsFingerprint,
-        requestId: input.requestId,
-    });
-}
-async function recoverSetupIntentReservation(input) {
-    const reservation = await reserveDirectSubscriptionAcquisition({
-        directSubscriptionSource: "setup_intent",
-        providerOptionsFingerprint: input.providerOptionsFingerprint,
-        proxy: input.proxy,
-        proxySessionId: input.proxySessionId,
-        requestId: input.requestId,
-    });
-    assertDirectSubscriptionReservation(reservation, "setup_intent", input.proxySessionId, input.providerOptionsFingerprint);
-    if (reservation.acquisitionAttempt.id !== input.acquisitionAttemptId) {
-        throw new errors_js_1.ProxyStripeAcquisitionError(`Proxy acquisition ${reservation.acquisitionAttempt.id} does not match requested acquisition ${input.acquisitionAttemptId}.`, { code: "acquisition_mismatch", field: "acquisitionAttemptId" });
-    }
-    if (reservation.acquisitionAttempt.providerSetupIntentId !== input.setupIntentId) {
-        throw new errors_js_1.ProxyStripeAcquisitionError(`Stripe SetupIntent ${input.setupIntentId} is not attached to Proxy acquisition ${input.acquisitionAttemptId}.`, { code: "acquisition_mismatch", field: "setupIntentId" });
-    }
-    return reservation;
-}
-async function attachAcquisitionObject(input) {
-    try {
-        return await input.proxy.providerAcquisitions.attachProviderAcquisitionObject(input.proxySessionId, input.acquisitionAttempt.id, {
-            expectedVersion: input.acquisitionAttempt.version,
-            objectId: input.objectId,
-            objectType: input.objectType,
-            ...(input.providerConfirmation ? { providerConfirmation: input.providerConfirmation } : {}),
-            ...(input.providerCustomerId ? { providerCustomerId: input.providerCustomerId } : {}),
-            requestId: input.requestId,
-            role: input.role,
-        });
-    }
-    catch (cause) {
-        const acquisitions = await input.proxy.providerAcquisitions
-            .listProviderAcquisitions(input.proxySessionId, { requestId: input.requestId })
-            .catch(() => []);
-        const current = acquisitions.find((candidate) => candidate.id === input.acquisitionAttempt.id);
-        const same = input.role === "setup_intent"
-            ? current?.providerSetupIntentId === input.objectId
-            : current?.providerRootObjectId === input.objectId &&
-                current.providerRootObjectType === input.objectType;
-        if (current && same)
-            return current;
-        throw new errors_js_1.ProxyStripeAcquisitionError("Stripe provider object exists but Proxy could not record or reconcile its attachment.", {
-            acquisitionAttemptId: input.acquisitionAttempt.id,
-            cause,
-            code: "provider_attachment_failed",
-            providerObjectId: input.objectId,
-        });
-    }
-}
-/**
- * Canonical deterministic-create replay used by every Stripe acquisition role.
- * A second create uses the same caller-owned idempotency key and therefore
- * recovers the first result; it never authorizes another physical object.
- */
-async function createOrRecoverStripeAcquisitionObject(input) {
-    let acquisition = input.acquisition;
-    const attachedObjectId = acquisitionObjectId(acquisition, input.role, input.objectType);
-    if (attachedObjectId) {
-        return {
-            acquisition,
-            alreadyAttached: true,
-            object: await retrieveAcquisitionObject(input, acquisition, attachedObjectId),
-        };
-    }
-    assertProviderCreateReplayWindowOpen(acquisition);
-    try {
-        return { acquisition, alreadyAttached: false, object: await input.create() };
-    }
-    catch (firstCause) {
-        const current = await findAcquisitionById(input, acquisition.id);
-        const recoveredObjectId = current
-            ? acquisitionObjectId(current, input.role, input.objectType)
-            : null;
-        if (current && recoveredObjectId) {
-            acquisition = current;
-            return {
-                acquisition,
-                alreadyAttached: true,
-                object: await retrieveAcquisitionObject(input, acquisition, recoveredObjectId),
-            };
-        }
-        assertProviderCreateReplayWindowOpen(acquisition);
-        try {
-            return { acquisition, alreadyAttached: false, object: await input.create() };
-        }
-        catch (cause) {
-            throw new errors_js_1.ProxyStripeAcquisitionError("Stripe provider creation remained ambiguous after the deterministic idempotent retry.", {
-                acquisitionAttemptId: acquisition.id,
-                cause: aggregateCauses(firstCause, cause),
-                code: "provider_create_ambiguous",
-            });
-        }
-    }
-}
-function assertProviderCreateReplayWindowOpen(acquisition) {
-    const retryNotAfter = Date.parse(acquisition.providerRetryNotAfter);
-    if (!Number.isFinite(retryNotAfter)) {
-        throw new errors_js_1.StripeResponseShapeError(`Proxy acquisition ${acquisition.id} returned an invalid provider replay deadline.`, "acquisition.providerRetryNotAfter");
-    }
-    if (Date.now() >= retryNotAfter) {
-        throw new errors_js_1.ProxyStripeAcquisitionError("Stripe provider creation remains ambiguous after the safe idempotency replay window.", {
-            acquisitionAttemptId: acquisition.id,
-            code: "provider_create_ambiguous",
-        });
-    }
-}
-function acquisitionObjectId(acquisition, role, objectType) {
-    if (role === "setup_intent") {
-        if (objectType !== "setup_intent") {
-            throw new errors_js_1.ProxyStripeAcquisitionError(`Proxy acquisition ${acquisition.id} received an invalid SetupIntent role type.`, { code: "acquisition_mismatch", field: "objectType" });
-        }
-        return acquisition.providerSetupIntentId;
-    }
-    if (acquisition.providerRootObjectId !== null &&
-        acquisition.providerRootObjectType !== objectType) {
-        throw new errors_js_1.ProxyStripeAcquisitionError(`Proxy acquisition ${acquisition.id} is attached to a different provider root type.`, { code: "acquisition_mismatch", field: "providerRootObjectType" });
-    }
-    return acquisition.providerRootObjectId;
-}
-async function findAcquisitionById(input, acquisitionAttemptId) {
-    const acquisitions = await input.proxy.providerAcquisitions.listProviderAcquisitions(input.proxySessionId, { requestId: input.requestId });
-    return acquisitions.find((candidate) => candidate.id === acquisitionAttemptId) ?? null;
-}
-async function retrieveAcquisitionObject(input, acquisition, providerObjectId) {
-    try {
-        return await input.retrieve(providerObjectId);
-    }
-    catch (cause) {
-        throw new errors_js_1.ProxyStripeAcquisitionError("Proxy knows the Stripe object but retrieval failed.", {
-            acquisitionAttemptId: acquisition.id,
-            cause,
-            code: "provider_retrieve_failed",
-            providerObjectId,
-        });
-    }
-}
-function stripeRequestOptions(merchantOptions, idempotencyKey) {
-    return { ...merchantOptions, idempotencyKey };
-}
-function requireStripeObjectId(value, prefix, field) {
-    const id = typeof value === "string"
-        ? value
-        : typeof value === "object" && value !== null && "id" in value
-            ? value.id
-            : undefined;
-    if (typeof id !== "string" || !id.startsWith(prefix) || id.length <= prefix.length) {
-        throw new errors_js_1.StripeResponseShapeError(`Stripe response field ${field} is missing or invalid.`, field);
-    }
-    return id;
-}
-function assertDirectSubscriptionReservation(reservation, source, proxySessionId, providerOptionsFingerprint) {
-    const attempt = reservation.acquisitionAttempt;
-    if (attempt.proxySessionId !== proxySessionId ||
-        attempt.commercialMode !== "subscription" ||
-        attempt.integrationPath !== "direct_subscription" ||
-        attempt.pricingMode !== "fixed" ||
-        attempt.directSubscriptionSource !== source ||
-        (providerOptionsFingerprint !== undefined &&
-            attempt.providerOptionsFingerprint !== providerOptionsFingerprint) ||
-        reservation.stripe.metadata.proxyAcquisitionAttemptId !== attempt.id ||
-        reservation.stripe.metadata.proxyContractVersion !== "2" ||
-        reservation.stripe.metadata.proxySessionId !== proxySessionId) {
-        throw new errors_js_1.ProxyStripeAcquisitionError(`Proxy acquisition ${attempt.id} does not match the requested direct Subscription contract.`, { code: "acquisition_mismatch", field: "acquisition" });
-    }
-}
-async function currentAcquisition(options, expectedId) {
-    const summary = options.proxySession.currentAcquisitionAttempt;
-    const acquisitionId = expectedId ?? summary?.id;
-    if (!acquisitionId)
-        return null;
-    const acquisitions = await options.proxy.providerAcquisitions.listProviderAcquisitions(options.proxySession.id, { requestId: options.requestId });
-    return acquisitions.find((candidate) => candidate.id === acquisitionId) ?? null;
-}
-function assertAcquisitionConfiguration(acquisition, options) {
-    const expectedSubtotal = options.directMerchandiseSubtotalMinor ?? null;
-    if (acquisition.integrationPath !== options.integrationPath ||
-        acquisition.commercialMode !== options.commercialMode ||
-        acquisition.pricingMode !== options.pricingMode ||
-        acquisition.checkoutUiMode !== (options.checkoutUiMode ?? null) ||
-        acquisition.directMerchandiseSubtotalMinor !== expectedSubtotal ||
-        acquisition.providerOptionsFingerprint !== options.providerOptionsFingerprint) {
-        throw new server_js_1.ProxyCheckoutValidationError(`Proxy session ${options.proxySession.id} already has an acquisition with different immutable Stripe options.`, { code: "acquisition_provider_options_conflict", field: "provider_options_fingerprint" });
-    }
-}
-async function retrieveKnownRoot(options, acquisition, providerObjectId) {
-    try {
-        return await options.retrieve(providerObjectId);
-    }
-    catch (cause) {
-        throw new errors_js_1.ProxyStripeAcquisitionError("Proxy knows the Stripe root but retrieval failed.", {
-            acquisitionAttemptId: acquisition.id,
-            cause,
-            code: "provider_retrieve_failed",
-            providerObjectId,
-        });
-    }
-}
-async function confirmProviderCart(options, acquisition, confirmation) {
-    if (sameConfirmation(acquisition, confirmation))
-        return acquisition;
-    try {
-        return await options.proxy.providerAcquisitions.confirmProviderAcquisitionCart(options.proxySession.id, acquisition.id, {
-            ...confirmation,
-            expectedVersion: acquisition.version,
-            requestId: options.requestId,
-        });
-    }
-    catch (cause) {
-        const refreshed = await currentAcquisition(options, acquisition.id).catch(() => null);
-        if (refreshed?.id === acquisition.id && sameConfirmation(refreshed, confirmation)) {
-            return refreshed;
-        }
-        throw new errors_js_1.ProxyStripeAcquisitionError("Stripe root exists but its exact cart revision could not be confirmed with Proxy.", {
-            acquisitionAttemptId: acquisition.id,
-            cause,
-            code: "provider_cart_confirmation_failed",
-            providerObjectId: acquisition.providerRootObjectId,
-        });
-    }
-}
-function sameConfirmation(acquisition, confirmation) {
-    return (acquisition.providerConfirmedAmountMinor === confirmation.amountMinor &&
-        acquisition.providerConfirmedCartVersion === confirmation.cartVersion &&
-        acquisition.providerConfirmedCurrency === confirmation.currency &&
-        acquisition.providerConfirmedEvidenceSha256 === confirmation.evidenceSha256 &&
-        acquisition.providerConfirmedMerchandiseSubtotalMinor ===
-            (confirmation.merchandiseSubtotalMinor ?? null));
-}
-function assertProviderCustomer(acquisition, object) {
-    const providerCustomerId = stripeCustomerId(object);
-    if (providerCustomerId &&
-        acquisition.providerCustomerId &&
-        acquisition.providerCustomerId !== providerCustomerId) {
-        throw new errors_js_1.ProxyStripeAcquisitionError("Stripe root Customer disagrees with the immutable Proxy acquisition diagnostic.", {
-            acquisitionAttemptId: acquisition.id,
-            cause: undefined,
-            code: "provider_attachment_failed",
-            providerObjectId: object.id,
-        });
-    }
-}
-function stripeCustomerId(object) {
-    const customer = object.customer;
-    const id = typeof customer === "string" ? customer : customer?.id;
-    return typeof id === "string" && /^cus_[A-Za-z0-9._:-]+$/.test(id) ? id : null;
-}
-async function readLegacyCheckoutBinding(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);
-    (0, metadata_js_1.assertCheckoutSessionBelongsToProxy)(checkoutSession, input.proxySessionId);
-    return {
-        providerCheckoutSessionId: input.checkoutSessionId,
-        proxySessionId: current.id,
-        psp: input.psp,
-        updatedAt: current.updatedAt,
-    };
-}
-function isProxyConflict(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "statusCode" in error &&
-        error.statusCode === 409);
-}
-function hasCompleteCheckoutLineItems(session) {
-    return Array.isArray(session?.line_items?.data) && session.line_items?.has_more === false;
-}
-function normalizeProviderCheckoutLines(session) {
-    if (!hasCompleteCheckoutLineItems(session)) {
-        throw new errors_js_1.StripeResponseShapeError("Stripe Checkout response is missing complete provider-authored line-item evidence.", "line_items");
-    }
-    const lines = session.line_items.data.map((line) => {
-        const price = objectRecord(line.price);
-        const priceId = readNonemptyString(price.id);
-        const quantity = readPositiveInteger(line.quantity);
-        if (!priceId || !quantity) {
-            throw new errors_js_1.StripeResponseShapeError("Stripe Checkout line-item evidence is missing Price identity or quantity.", "line_items.data.price");
-        }
-        const recurring = normalizeRecurringEvidence(price.recurring);
-        const priceType = recurring ? "recurring" : "one_time";
-        if ((price.type === "recurring" && !recurring) || (price.type === "one_time" && recurring)) {
-            throw new errors_js_1.StripeResponseShapeError("Stripe Checkout Price type disagrees with recurring evidence.", "line_items.data.price.recurring");
-        }
-        const unitAmountMinor = readNonnegativeInteger(price.unit_amount);
-        return {
-            currency: readNonemptyString(price.currency)?.toLowerCase() ?? null,
-            description: readNonemptyString(line.description),
-            priceId,
-            priceType,
-            productId: readStripeObjectId(price.product),
-            quantity,
-            recurring,
-            unitAmountDecimal: readStripeDecimal(price.unit_amount_decimal) ??
-                (unitAmountMinor === null ? null : String(unitAmountMinor)),
-            unitAmountMinor,
-        };
-    });
-    return sortEvidence(lines);
-}
-function normalizeExpectedCheckoutLines(value) {
-    if (!Array.isArray(value) || value.length === 0) {
-        throw new server_js_1.ProxyCheckoutValidationError("Stripe Checkout requires line_items for exact cart-revision evidence.", { code: "cart_version_conflict", field: "line_items" });
-    }
-    const lines = value.map((rawLine) => {
-        const line = objectRecord(rawLine);
-        const quantity = readPositiveInteger(line.quantity) ?? 1;
-        const priceId = readStripeObjectId(line.price);
-        if (priceId) {
-            return { kind: "price", priceId, quantity };
-        }
-        const priceData = objectRecord(line.price_data);
-        const productData = objectRecord(priceData.product_data);
-        const currency = readNonemptyString(priceData.currency)?.toLowerCase();
-        const unitAmountMinor = readNonnegativeInteger(priceData.unit_amount);
-        const unitAmountDecimal = readNonemptyString(priceData.unit_amount_decimal);
-        const productId = readStripeObjectId(priceData.product);
-        const productName = readNonemptyString(productData.name);
-        if (!currency ||
-            (!productId && !productName) ||
-            (unitAmountMinor === null && unitAmountDecimal === null)) {
-            throw new server_js_1.ProxyCheckoutValidationError("Stripe Checkout line_items must identify a Price or complete price_data.", { code: "cart_version_conflict", field: "line_items.price" });
-        }
-        return {
-            currency,
-            kind: "price_data",
-            productId,
-            productName,
-            quantity,
-            recurring: normalizeRecurringEvidence(priceData.recurring),
-            unitAmountDecimal: unitAmountDecimal ?? String(unitAmountMinor),
-            unitAmountMinor,
-        };
-    });
-    return sortEvidence(lines);
-}
-function checkoutLinesMatch(expected, provider) {
-    if (expected.length !== provider.length)
-        return false;
-    const remaining = [...provider];
-    for (const expectedLine of expected) {
-        const index = remaining.findIndex((providerLine) => expectedLine.kind === "price"
-            ? expectedLine.priceId === providerLine.priceId &&
-                expectedLine.quantity === providerLine.quantity
-            : expectedLine.currency === providerLine.currency &&
-                (expectedLine.productId
-                    ? expectedLine.productId === providerLine.productId
-                    : expectedLine.productName === providerLine.description) &&
-                expectedLine.quantity === providerLine.quantity &&
-                stableStringify(expectedLine.recurring) === stableStringify(providerLine.recurring) &&
-                expectedLine.unitAmountDecimal === providerLine.unitAmountDecimal &&
-                expectedLine.unitAmountMinor === providerLine.unitAmountMinor);
-        if (index < 0)
-            return false;
-        remaining.splice(index, 1);
-    }
-    return remaining.length === 0;
-}
-function normalizeRecurringEvidence(value) {
-    if (value === null || value === undefined)
-        return null;
-    const recurring = objectRecord(value);
-    const interval = readNonemptyString(recurring.interval);
-    const intervalCount = readPositiveInteger(recurring.interval_count) ?? 1;
-    const usageType = readNonemptyString(recurring.usage_type) ?? "licensed";
-    if (!interval) {
-        throw new errors_js_1.StripeResponseShapeError("Stripe Checkout recurring Price evidence is missing its interval.", "line_items.data.price.recurring.interval");
-    }
-    return { interval, intervalCount, usageType };
-}
-function readNonemptyString(value) {
-    return typeof value === "string" && value.length > 0 ? value : null;
-}
-function readStripeDecimal(value) {
-    const rendered = typeof value === "string"
-        ? value
-        : typeof value === "number" && Number.isFinite(value)
-            ? String(value)
-            : typeof value === "object" &&
-                value !== null &&
-                "toString" in value &&
-                typeof value.toString === "function"
-                ? value.toString()
-                : null;
-    return rendered && /^\d+(?:\.\d+)?$/.test(rendered) ? rendered : null;
-}
-function readPositiveInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
-}
-function readNonnegativeInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
-}
-function readStripeObjectId(value) {
-    if (typeof value === "string" && value.length > 0)
-        return value;
-    return readNonemptyString(objectRecord(value).id);
-}
-function objectRecord(value) {
-    return typeof value === "object" && value !== null ? value : {};
-}
-function sortEvidence(values) {
-    return [...values].sort((left, right) => stableStringify(left).localeCompare(stableStringify(right)));
-}
-function hashEvidence(domain, value) {
-    return (0, node_crypto_1.createHash)("sha256")
-        .update(domain, "utf8")
-        .update("\0", "utf8")
-        .update(stableStringify(value), "utf8")
-        .digest("hex");
-}
-function stableStringify(value) {
-    const normalized = normalizeJson(value, new Set());
-    return JSON.stringify(normalized);
-}
-function normalizeJson(value, ancestors) {
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return value;
-    if (typeof value === "number") {
-        if (!Number.isFinite(value))
-            throw new TypeError("Stripe options must contain finite numbers.");
-        return value;
-    }
-    if (Array.isArray(value)) {
-        if (ancestors.has(value))
-            throw new TypeError("Stripe options must not contain cycles.");
-        ancestors.add(value);
-        const result = value.map((item) => item === undefined ? null : normalizeJson(item, ancestors));
-        ancestors.delete(value);
-        return result;
-    }
-    if (typeof value === "object") {
-        if (ancestors.has(value))
-            throw new TypeError("Stripe options must not contain cycles.");
-        ancestors.add(value);
-        const result = {};
-        for (const [key, item] of Object.entries(value).sort(([left], [right]) => left.localeCompare(right))) {
-            if (item !== undefined)
-                result[key] = normalizeJson(item, ancestors);
-        }
-        ancestors.delete(value);
-        return result;
-    }
-    throw new TypeError("Stripe options must be JSON-compatible.");
-}
-function aggregateCauses(first, second) {
-    return new Error("Both deterministic Stripe create attempts failed.", {
-        cause: { first, second },
-    });
-}