@proxy-checkout/stripe-server-js 0.0.0 → 0.0.1-prx-103.66.1

package/dist/cjs/open-checkout.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * `openCheckout` — the payer-opened + provider-object creation workflow.
+ *
+ * It performs the Proxy protocol steps (record payer-opened, validate the cart,
+ * inject required metadata, create the Stripe Checkout Session, record the
+ * provider binding). Merchants provide only Stripe params, so the adapter owns
+ * metadata placement, idempotency, and binding reconciliation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openCheckout = openCheckout;
+const server_js_1 = require("@proxy-checkout/server-js");
+const errors_js_1 = require("./errors.js");
+const metadata_js_1 = require("./metadata.js");
+const psp_js_1 = require("./psp.js");
+async function openCheckout(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.
+    const psp = (0, psp_js_1.normalizePsp)(options.psp ?? "stripe");
+    let proxySession = await options.proxy.sessions.payerOpened(options.proxySessionId, {
+        requestId: options.requestId,
+    });
+    // Parse the cart (and run the buyer-reference check) whenever a schema OR a
+    // buyer-reference extractor is provided, so the consistency check is never
+    // silently skipped just because no custom schema was passed.
+    let cart = options.cartSchema || options.getCartBuyerReference
+        ? options.proxy.sessions.parseCart(proxySession, options.cartSchema ?? ((value) => value), { getBuyerReference: options.getCartBuyerReference })
+        : proxySession.cartSnapshot;
+    let offer = options.validateCart
+        ? await options.validateCart({ cart, session: proxySession })
+        : undefined;
+    if (proxySession.providerCheckoutSessionId !== null) {
+        assertExistingBindingMatches(proxySession, psp);
+        const checkoutSession = (await options.stripe.checkout.sessions.retrieve(proxySession.providerCheckoutSessionId, undefined, options.stripeRequestOptions));
+        (0, metadata_js_1.assertCheckoutSessionBelongsToProxy)(checkoutSession, proxySession.id);
+        return {
+            binding: bindingFromSession(proxySession),
+            cart,
+            checkoutSession,
+            clientSecret: checkoutSession.client_secret ?? null,
+            offer,
+            proxySession,
+            proxySessionId: proxySession.id,
+        };
+    }
+    let rollbackCart;
+    const reconciledCart = await options.reconcileCart?.({ cart, offer, session: proxySession });
+    if (reconciledCart) {
+        if (options.getCartBuyerReference !== undefined) {
+            (0, server_js_1.assertCartBuyerReference)(options.getCartBuyerReference(reconciledCart.cart), proxySession);
+        }
+        const priorCart = {
+            amountMinor: proxySession.amountMinor,
+            cartSnapshot: proxySession.cartSnapshot,
+            cartVersion: proxySession.cartVersion,
+            currency: proxySession.currency,
+        };
+        const updatedCart = await options.proxy.sessions.cart.set(proxySession.id, {
+            amountMinor: reconciledCart.amountMinor,
+            cartSnapshot: reconciledCart.cartSnapshot,
+            currency: reconciledCart.currency,
+            expectedCartVersion: proxySession.cartVersion,
+            requestId: options.requestId,
+        });
+        rollbackCart = {
+            ...priorCart,
+            expectedCartVersion: updatedCart.cartVersion,
+        };
+        proxySession = {
+            ...proxySession,
+            amountMinor: updatedCart.amountMinor,
+            cartSnapshot: updatedCart.cartSnapshot,
+            cartVersion: updatedCart.cartVersion,
+            currency: updatedCart.currency,
+            updatedAt: proxySession.updatedAt,
+        };
+        cart = reconciledCart.cart;
+    }
+    try {
+        if (reconciledCart && options.validateCart) {
+            offer = await options.validateCart({ cart, session: proxySession });
+        }
+        const params = await options.buildCheckoutSessionParams({
+            cart,
+            offer,
+            proxySession,
+            stripe: options.stripe,
+        });
+        const checkoutSession = (await options.stripe.checkout.sessions.create((0, metadata_js_1.injectRequiredCheckoutSessionMetadata)(params, proxySession.id), buildStripeRequestOptions(options, proxySession.id, psp)));
+        // Fail closed if the merchant forgot to place proxy_session_id metadata.
+        (0, metadata_js_1.assertCheckoutSessionBelongsToProxy)(checkoutSession, proxySession.id);
+        const binding = await recordOrReconcileProviderBinding({
+            checkoutSessionId: checkoutSession.id,
+            proxy: options.proxy,
+            proxySessionId: proxySession.id,
+            psp,
+            requestId: options.requestId,
+            stripe: options.stripe,
+            stripeRequestOptions: options.stripeRequestOptions,
+        });
+        return {
+            binding,
+            cart,
+            checkoutSession,
+            clientSecret: checkoutSession.client_secret ?? null,
+            offer,
+            proxySession,
+            proxySessionId: proxySession.id,
+        };
+    }
+    catch (cause) {
+        if (rollbackCart) {
+            await rollbackReconciledCart({
+                cause,
+                proxy: options.proxy,
+                proxySessionId: proxySession.id,
+                requestId: options.requestId,
+                rollbackCart,
+            });
+        }
+        throw cause;
+    }
+}
+function buildStripeRequestOptions(options, proxySessionId, psp) {
+    return {
+        ...options.stripeRequestOptions,
+        idempotencyKey: `proxy-open-checkout:${proxySessionId}:${psp}`,
+    };
+}
+function assertExistingBindingMatches(proxySession, psp) {
+    if (proxySession.providerCheckoutSessionId === null) {
+        return;
+    }
+    if (proxySession.providerCheckoutSessionPsp !== psp) {
+        throw new server_js_1.ProxyCheckoutValidationError(`Proxy session ${proxySession.id} is already bound under psp ${proxySession.providerCheckoutSessionPsp}.`, { code: "provider_binding_mismatch", field: "provider_checkout_session_psp" });
+    }
+}
+function bindingFromSession(proxySession) {
+    if (proxySession.providerCheckoutSessionId === null ||
+        proxySession.providerCheckoutSessionPsp === null) {
+        throw new Error("Proxy session is not bound to a provider checkout session.");
+    }
+    return {
+        providerCheckoutSessionId: proxySession.providerCheckoutSessionId,
+        proxySessionId: proxySession.id,
+        psp: proxySession.providerCheckoutSessionPsp,
+        updatedAt: proxySession.updatedAt,
+    };
+}
+async function rollbackReconciledCart(input) {
+    try {
+        await input.proxy.sessions.cart.set(input.proxySessionId, {
+            amountMinor: input.rollbackCart.amountMinor,
+            cartSnapshot: input.rollbackCart.cartSnapshot,
+            currency: input.rollbackCart.currency,
+            expectedCartVersion: input.rollbackCart.expectedCartVersion,
+            requestId: input.requestId,
+        });
+    }
+    catch (rollbackCause) {
+        throw new errors_js_1.ProxyStripeCartSyncError("openCheckout failed after reconciling the Proxy cart, and the rollback failed; carts may be out of sync.", {
+            cause: input.cause,
+            code: "reconciliation_failed",
+            reconciled: false,
+            rollbackCause,
+        });
+    }
+}
+async function recordOrReconcileProviderBinding(input) {
+    try {
+        return await input.proxy.sessions.recordProviderBinding(input.proxySessionId, {
+            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 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,
+        });
+    }
+}
+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);
+    (0, metadata_js_1.assertCheckoutSessionBelongsToProxy)(checkoutSession, input.proxySessionId);
+    return bindingFromSession(current);
+}
+function isProxyConflict(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "statusCode" in error &&
+        error.statusCode === 409);
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/psp.d.cts

@@ -0,0 +1,12 @@
+/**
+ * Provider (psp) identifier normalization, kept in lockstep with the Proxy API.
+ *
+ * The API normalizes the psp before persisting a provider binding
+ * (`psp.trim().toLowerCase()`), then compares stored bindings against that
+ * normalized value. The SDK must normalize identically before recording or
+ * validating a binding so a caller passing the same psp with different
+ * casing/whitespace for `openCheckout` vs `syncCheckoutCart` does not get a
+ * false `provider_binding_mismatch`.
+ */
+/** Normalize and validate a psp identifier exactly as the Proxy API does before storing/comparing a binding. */
+export declare function normalizePsp(psp: string): string;

package/dist/cjs/psp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Provider (psp) identifier normalization, kept in lockstep with the Proxy API.
+ *
+ * The API normalizes the psp before persisting a provider binding
+ * (`psp.trim().toLowerCase()`), then compares stored bindings against that
+ * normalized value. The SDK must normalize identically before recording or
+ * validating a binding so a caller passing the same psp with different
+ * casing/whitespace for `openCheckout` vs `syncCheckoutCart` does not get a
+ * false `provider_binding_mismatch`.
+ */
+/** Normalize and validate a psp identifier exactly as the Proxy API does before storing/comparing a binding. */
+export declare function normalizePsp(psp: string): string;

package/dist/cjs/psp.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePsp = normalizePsp;
+const server_js_1 = require("@proxy-checkout/server-js");
+/**
+ * Provider (psp) identifier normalization, kept in lockstep with the Proxy API.
+ *
+ * The API normalizes the psp before persisting a provider binding
+ * (`psp.trim().toLowerCase()`), then compares stored bindings against that
+ * normalized value. The SDK must normalize identically before recording or
+ * validating a binding so a caller passing the same psp with different
+ * casing/whitespace for `openCheckout` vs `syncCheckoutCart` does not get a
+ * false `provider_binding_mismatch`.
+ */
+/** Normalize and validate a psp identifier exactly as the Proxy API does before storing/comparing a binding. */
+function normalizePsp(psp) {
+    const normalized = psp.trim().toLowerCase();
+    if (!/^[a-z0-9_]{1,32}$/.test(normalized)) {
+        throw new server_js_1.ProxyCheckoutValidationError("psp must be a short lowercase identifier", {
+            code: "provider_binding_mismatch",
+            field: "psp",
+        });
+    }
+    return normalized;
+}

package/dist/cjs/sync-checkout-cart.d.cts

@@ -0,0 +1,47 @@
+/**
+ * `syncCheckoutCart` — coordinated Proxy + Stripe cart update.
+ *
+ * Validates ownership against the first-class Proxy provider binding (not just
+ * Stripe metadata), then updates the Proxy cart and the Stripe checkout in the
+ * 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, 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;
+    readonly cart: TCart;
+    readonly cartSnapshot: JsonObject;
+    readonly currency: string;
+}
+export interface SyncCheckoutCartOptions<TStripe extends StripeClientLike, TCart, TInput> {
+    /** Compute the next cart from current state and the merchant input. */
+    readonly buildNextCart: (input: {
+        currentCart: TCart;
+        currentSession: MerchantProxySession;
+        input: TInput;
+    }) => Promise<SyncedCart<TCart>> | SyncedCart<TCart>;
+    /** Derive the Stripe `line_items` update from the next typed cart. */
+    readonly buildStripeLineItems: (cart: TCart) => unknown;
+    /** Optional schema validating the current cart snapshot into a typed cart. */
+    readonly cartSchema?: ProxyCartValidator<TCart>;
+    readonly checkoutSessionId: string;
+    /** Merchant-supplied change request (e.g. new interval/quantity). */
+    readonly input: TInput;
+    readonly proxy: ProxyCheckoutServerClient;
+    readonly proxySessionId: string;
+    /** Provider identifier the session must be bound under. Defaults to "stripe". */
+    readonly psp?: string;
+    readonly requestId?: string;
+    readonly stripe: TStripe;
+    /** Optional Stripe request options, e.g. Stripe Connect account scoping. */
+    readonly stripeRequestOptions?: StripeRequestOptionsWithoutIdempotencyLike;
+}
+export interface SyncCheckoutCartResult<TCart> {
+    readonly amountMinor: number;
+    readonly cart: TCart;
+    readonly cartSnapshot: JsonObject;
+    readonly checkoutSession: StripeCheckoutSessionLike;
+    readonly currency: string;
+}
+export declare function syncCheckoutCart<TStripe extends StripeClientLike, TCart, TInput>(options: SyncCheckoutCartOptions<TStripe, TCart, TInput>): Promise<SyncCheckoutCartResult<TCart>>;

package/dist/{sync-checkout-cart.d.ts → cjs/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, StripeClientLike } 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;
@@ -34,6 +34,8 @@ export interface SyncCheckoutCartOptions<TStripe extends StripeClientLike, TCart
     readonly psp?: string;
     readonly requestId?: string;
     readonly stripe: TStripe;
+    /** Optional Stripe request options, e.g. Stripe Connect account scoping. */
+    readonly stripeRequestOptions?: StripeRequestOptionsWithoutIdempotencyLike;
 }
 export interface SyncCheckoutCartResult<TCart> {
     readonly amountMinor: number;

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

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * `syncCheckoutCart` — coordinated Proxy + Stripe cart update.
+ *
+ * Validates ownership against the first-class Proxy provider binding (not just
+ * Stripe metadata), then updates the Proxy cart and the Stripe checkout in the
+ * safest order with deterministic rollback/reconciliation on failure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncCheckoutCart = syncCheckoutCart;
+const server_js_1 = require("@proxy-checkout/server-js");
+const errors_js_1 = require("./errors.js");
+const metadata_js_1 = require("./metadata.js");
+const psp_js_1 = require("./psp.js");
+async function syncCheckoutCart(options) {
+    // Normalize the same way the API does on store, so the binding comparison is
+    // normalized-to-normalized and a custom psp with differing casing/whitespace
+    // does not produce a false provider_binding_mismatch.
+    const psp = (0, psp_js_1.normalizePsp)(options.psp ?? "stripe");
+    const session = await options.proxy.sessions.retrieve(options.proxySessionId, {
+        requestId: options.requestId,
+    });
+    // Ownership: validate against the stored binding first, then defensively
+    // against the Stripe object's own metadata.
+    assertSessionBoundTo(session, options.checkoutSessionId, psp);
+    const stripeSession = await options.stripe.checkout.sessions.retrieve(options.checkoutSessionId, undefined, options.stripeRequestOptions);
+    (0, metadata_js_1.assertCheckoutSessionBelongsToProxy)(stripeSession, options.proxySessionId);
+    const currentCart = options.cartSchema
+        ? options.proxy.sessions.parseCart(session, options.cartSchema)
+        : session.cartSnapshot;
+    const next = await options.buildNextCart({
+        currentCart,
+        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),
+    };
+    // Update Proxy first; the API rejects a non-editable session before Stripe is touched.
+    const proxyCartUpdate = await options.proxy.sessions.cart.set(options.proxySessionId, {
+        amountMinor: next.amountMinor,
+        cartSnapshot: next.cartSnapshot,
+        currency: next.currency,
+        expectedCartVersion: session.cartVersion,
+        requestId: options.requestId,
+    });
+    const stripeUpdateOptions = buildStripeUpdateRequestOptions(options, proxyCartUpdate.cartVersion);
+    let updatedCheckout;
+    try {
+        updatedCheckout = await options.stripe.checkout.sessions.update(options.checkoutSessionId, stripeUpdateParams, stripeUpdateOptions);
+    }
+    catch {
+        try {
+            updatedCheckout = await options.stripe.checkout.sessions.update(options.checkoutSessionId, stripeUpdateParams, stripeUpdateOptions);
+        }
+        catch (retryCause) {
+            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 errors_js_1.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 errors_js_1.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 {
+        amountMinor: next.amountMinor,
+        cart: next.cart,
+        cartSnapshot: next.cartSnapshot,
+        checkoutSession: updatedCheckout,
+        currency: proxyCartUpdate.currency,
+    };
+}
+function buildStripeUpdateRequestOptions(options, cartVersion) {
+    return {
+        ...options.stripeRequestOptions,
+        idempotencyKey: `proxy-sync-checkout-cart:${options.proxySessionId}:${options.checkoutSessionId}:${cartVersion}`,
+    };
+}
+function assertSessionBoundTo(session, checkoutSessionId, psp) {
+    if (session.providerCheckoutSessionId !== checkoutSessionId ||
+        session.providerCheckoutSessionPsp !== psp) {
+        throw new server_js_1.ProxyCheckoutValidationError(`Proxy session ${session.id} is not bound to provider checkout session ${checkoutSessionId}.`, { code: "provider_binding_mismatch", field: "provider_checkout_session_id" });
+    }
+}

package/dist/cjs/types.d.cts

@@ -0,0 +1,52 @@
+/**
+ * Minimal structural Stripe types.
+ *
+ * The adapter is dependency-free: merchants inject their own `Stripe` instance
+ * and objects, which are structurally compatible with these narrow interfaces.
+ * This avoids a runtime/build dependency on the `stripe` package while keeping
+ * the bits the adapter actually touches type-safe.
+ */
+export type StripeMetadataValue = string | number | null;
+export type StripeMetadata = Record<string, StripeMetadataValue> | null | undefined;
+export type StripeMetadataParam = Record<string, StripeMetadataValue> | undefined;
+export interface StripeCheckoutSessionLike {
+    readonly client_secret?: string | null;
+    readonly id: string;
+    readonly metadata?: StripeMetadata;
+}
+export interface StripeSubscriptionLike {
+    readonly id: string;
+    readonly metadata?: StripeMetadata;
+}
+export interface StripePaymentIntentLike {
+    readonly id: string;
+    readonly metadata?: StripeMetadata;
+}
+export interface StripeCheckoutSessionUpdateParams {
+    readonly line_items?: unknown;
+    readonly metadata?: StripeMetadataParam;
+}
+export type StripeCheckoutSessionCreateParams = object & {
+    readonly metadata?: StripeMetadataParam;
+    readonly mode?: "payment" | "setup" | "subscription";
+    readonly payment_intent_data?: unknown;
+    readonly subscription_data?: unknown;
+};
+export interface StripeRequestOptionsLike {
+    readonly idempotencyKey?: string;
+    readonly [key: string]: unknown;
+}
+export interface StripeRequestOptionsWithoutIdempotencyLike {
+    readonly idempotencyKey?: never;
+    readonly [key: string]: unknown;
+}
+export interface StripeCheckoutSessionsApiLike {
+    create(params: unknown, options?: unknown): Promise<StripeCheckoutSessionLike>;
+    retrieve(id: string, params?: unknown, options?: unknown): Promise<StripeCheckoutSessionLike>;
+    update(id: string, params: unknown, options?: unknown): Promise<StripeCheckoutSessionLike>;
+}
+export interface StripeClientLike {
+    readonly checkout: {
+        readonly sessions: StripeCheckoutSessionsApiLike;
+    };
+}

package/dist/{types.d.ts → cjs/types.d.ts}

@@ -6,7 +6,9 @@
  * This avoids a runtime/build dependency on the `stripe` package while keeping
  * the bits the adapter actually touches type-safe.
  */
-export type StripeMetadata = Record<string, string | null> | null | undefined;
+export type StripeMetadataValue = string | number | null;
+export type StripeMetadata = Record<string, StripeMetadataValue> | null | undefined;
+export type StripeMetadataParam = Record<string, StripeMetadataValue> | undefined;
 export interface StripeCheckoutSessionLike {
     readonly client_secret?: string | null;
     readonly id: string;
@@ -22,11 +24,26 @@ export interface StripePaymentIntentLike {
 }
 export interface StripeCheckoutSessionUpdateParams {
     readonly line_items?: unknown;
-    readonly metadata?: Record<string, string>;
+    readonly metadata?: StripeMetadataParam;
+}
+export type StripeCheckoutSessionCreateParams = object & {
+    readonly metadata?: StripeMetadataParam;
+    readonly mode?: "payment" | "setup" | "subscription";
+    readonly payment_intent_data?: unknown;
+    readonly subscription_data?: unknown;
+};
+export interface StripeRequestOptionsLike {
+    readonly idempotencyKey?: string;
+    readonly [key: string]: unknown;
+}
+export interface StripeRequestOptionsWithoutIdempotencyLike {
+    readonly idempotencyKey?: never;
+    readonly [key: string]: unknown;
 }
 export interface StripeCheckoutSessionsApiLike {
+    create(params: unknown, options?: unknown): Promise<StripeCheckoutSessionLike>;
     retrieve(id: string, params?: unknown, options?: unknown): Promise<StripeCheckoutSessionLike>;
-    update(id: string, params: StripeCheckoutSessionUpdateParams, options?: unknown): Promise<StripeCheckoutSessionLike>;
+    update(id: string, params: unknown, options?: unknown): Promise<StripeCheckoutSessionLike>;
 }
 export interface StripeClientLike {
     readonly checkout: {

package/dist/cjs/types.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Minimal structural Stripe types.
+ *
+ * The adapter is dependency-free: merchants inject their own `Stripe` instance
+ * and objects, which are structurally compatible with these narrow interfaces.
+ * This avoids a runtime/build dependency on the `stripe` package while keeping
+ * the bits the adapter actually touches type-safe.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/version.d.cts

@@ -0,0 +1,2 @@
+export declare const proxyCheckoutStripeServerSdkName = "@proxy-checkout/stripe-server-js";
+export declare const proxyCheckoutStripeServerSdkVersion = "0.0.1-prx-103.66.1";

package/dist/{version.d.ts → cjs/version.d.ts}

@@ -1,2 +1,2 @@
 export declare const proxyCheckoutStripeServerSdkName = "@proxy-checkout/stripe-server-js";
-export declare const proxyCheckoutStripeServerSdkVersion = "0.0.0";
+export declare const proxyCheckoutStripeServerSdkVersion = "0.0.1-prx-103.66.1";

package/dist/cjs/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyCheckoutStripeServerSdkVersion = exports.proxyCheckoutStripeServerSdkName = void 0;
+exports.proxyCheckoutStripeServerSdkName = "@proxy-checkout/stripe-server-js";
+exports.proxyCheckoutStripeServerSdkVersion = "0.0.1-prx-103.66.1";

package/dist/esm/errors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Adapter-specific error raised when a Stripe/Proxy cart synchronization cannot
+ * complete cleanly. The `reconciled` flag is true only when the SDK verified the
+ * Proxy and Stripe carts are back in a consistent state.
+ */
+export type ProxyStripeCartSyncCode = "reconciliation_failed" | "stripe_update_failed";
+export type ProxyStripeOpenCheckoutCode = "provider_binding_failed";
+/**
+ * Raised after Stripe Checkout creation succeeds but the Proxy binding cannot
+ * be recorded or reconciled. The provider id is exposed so operators can find
+ * and expire/refund the orphaned provider object deterministically.
+ */
+export declare class ProxyStripeOpenCheckoutError extends Error {
+    readonly name = "ProxyStripeOpenCheckoutError";
+    readonly code: ProxyStripeOpenCheckoutCode;
+    readonly cause: unknown;
+    readonly providerCheckoutSessionId: string;
+    readonly reconciled = false;
+    constructor(message: string, details: {
+        cause: unknown;
+        code: ProxyStripeOpenCheckoutCode;
+        providerCheckoutSessionId: string;
+    });
+}
+export declare class ProxyStripeCartSyncError extends Error {
+    readonly name = "ProxyStripeCartSyncError";
+    readonly code: ProxyStripeCartSyncCode;
+    /** True only when the SDK verified Proxy and Stripe are in a consistent state. */
+    readonly reconciled: boolean;
+    readonly cause: unknown;
+    readonly rollbackCause: unknown;
+    constructor(message: string, details: {
+        code: ProxyStripeCartSyncCode;
+        reconciled: boolean;
+        cause: unknown;
+        rollbackCause?: unknown;
+    });
+}

package/dist/esm/errors.js

@@ -0,0 +1,33 @@
+/**
+ * Raised after Stripe Checkout creation succeeds but the Proxy binding cannot
+ * be recorded or reconciled. The provider id is exposed so operators can find
+ * and expire/refund the orphaned provider object deterministically.
+ */
+export class ProxyStripeOpenCheckoutError extends Error {
+    name = "ProxyStripeOpenCheckoutError";
+    code;
+    cause;
+    providerCheckoutSessionId;
+    reconciled = false;
+    constructor(message, details) {
+        super(message);
+        this.cause = details.cause;
+        this.code = details.code;
+        this.providerCheckoutSessionId = details.providerCheckoutSessionId;
+    }
+}
+export class ProxyStripeCartSyncError extends Error {
+    name = "ProxyStripeCartSyncError";
+    code;
+    /** True only when the SDK verified Proxy and Stripe are in a consistent state. */
+    reconciled;
+    cause;
+    rollbackCause;
+    constructor(message, details) {
+        super(message);
+        this.code = details.code;
+        this.reconciled = details.reconciled;
+        this.cause = details.cause;
+        this.rollbackCause = details.rollbackCause;
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export { type ProxyStripeCartSyncCode, ProxyStripeCartSyncError, type ProxyStripeOpenCheckoutCode, ProxyStripeOpenCheckoutError, } from "./errors.js";
+export { assertCheckoutSessionBelongsToProxy, assertPaymentIntentBelongsToProxy, assertSubscriptionBelongsToProxy, injectRequiredCheckoutSessionMetadata, PROXY_SESSION_METADATA_KEY, type ProxySessionMetadata, type ProxyStripeRequiredMetadata, requiredMetadata, } from "./metadata.js";
+export { type OpenCheckoutOptions, type OpenCheckoutReconciledCart, type OpenCheckoutResult, openCheckout, } from "./open-checkout.js";
+export { normalizePsp } from "./psp.js";
+export { type SyncCheckoutCartOptions, type SyncCheckoutCartResult, type SyncedCart, syncCheckoutCart, } from "./sync-checkout-cart.js";
+export type { StripeCheckoutSessionCreateParams, StripeCheckoutSessionLike, StripeCheckoutSessionsApiLike, StripeCheckoutSessionUpdateParams, StripeClientLike, StripeMetadata, StripePaymentIntentLike, StripeRequestOptionsLike, StripeSubscriptionLike, } from "./types.js";
+export { proxyCheckoutStripeServerSdkName, proxyCheckoutStripeServerSdkVersion, } from "./version.js";

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+export { ProxyStripeCartSyncError, ProxyStripeOpenCheckoutError, } from "./errors.js";
+export { assertCheckoutSessionBelongsToProxy, assertPaymentIntentBelongsToProxy, assertSubscriptionBelongsToProxy, injectRequiredCheckoutSessionMetadata, PROXY_SESSION_METADATA_KEY, requiredMetadata, } from "./metadata.js";
+export { openCheckout, } from "./open-checkout.js";
+export { normalizePsp } from "./psp.js";
+export { syncCheckoutCart, } from "./sync-checkout-cart.js";
+export { proxyCheckoutStripeServerSdkName, proxyCheckoutStripeServerSdkVersion, } from "./version.js";