@funnelsgrove/payments 0.1.56 → 0.1.57

package/README.md

@@ -13,13 +13,17 @@ Read this file before editing checkout code. Deeper implementation docs:
 
 ## Current Checkout Path
 
+Render every visible wallet placement with `StripeSubscriptionWalletSurface`. It is the normal current path for Apple Pay and Google Pay:
+
+- Each surface owns one private Checkout Session per simultaneously visible wallet placement, isolated by its own `surfaceId`.
+- Simultaneously visible placements may use the same plan and coupon; nothing is shared because each surface keeps its own session.
+- When the selected plan changes, the surface updates the existing Checkout Session in place without changing `surfaceId`, React `key`, `clientSecret`, `CheckoutProvider`, or the Express Checkout iframe.
+
 Use these for new subscription paywalls:
 
+- `StripeSubscriptionWalletSurface`
 - `useStripeSubscriptionCheckoutSession`
 - `SharedStripeCheckoutV2Dialog`
-- `ApplePaySubscriptionCheckoutSlot`
-- `GooglePaySubscriptionCheckoutSlot`
-- `WalletSubscriptionCheckoutSlot`
 - `trackPaidStripeSubscriptionCheckoutCompleted`
 
 Use these for new one-time paywall plans:
@@ -29,6 +33,10 @@ Use these for new one-time paywall plans:
 
 Use `chargeStripeOneClickPayment` for post-checkout one-click upsells when the shared client helper fits the funnel. It delegates to `funnelSdkService.chargeOneClickPayment`.
 
+## Advanced Wallet Primitives
+
+`ApplePaySubscriptionCheckoutSlot`, `GooglePaySubscriptionCheckoutSlot`, and `WalletSubscriptionCheckoutSlot` stay exported and runtime-compatible. They are backward-compatible advanced low-level primitives: reach for them only when a placement needs wiring `StripeSubscriptionWalletSurface` does not cover. Never share one `useStripeSubscriptionCheckoutSession` result across placements; give each visible placement its own session.
+
 ## Compatibility-Only Surfaces
 
 Keep these exports available for saved drafts, old published artifacts, and controlled migrations. Do not use them for new subscription checkout work:
@@ -70,7 +78,7 @@ When a live funnel still uses one of these, migrate the funnel deliberately with
 - `services/runtimeBillingPlanCatalog.service`: test/live runtime catalog selection.
 - `services/paywallOffer.service`: timed discount and display-plan helpers.
 - `services/stripe.service`: Stripe loader, Checkout Session, hosted checkout, one-click, one-time Checkout Session clients, and deprecated PaymentIntent compatibility clients.
-- `providers/*`: provider-neutral checkout state and Stripe subscription checkout slots.
+- `providers/*`: provider-neutral checkout state, the Stripe subscription wallet surface, and Stripe subscription checkout slots.
 - `components/shared/*`: plan selector, checkout dialogs, Express Checkout wrappers, wallet placeholders, and trust assets.
 - `testing/walletCheckoutSmoke`: wallet checkout smoke assertions.
 

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from './providers/stripe/useStripeOneTimeCheckoutSession.js';
 export * from './providers/stripe/WalletSubscriptionCheckoutSlot.js';
 export * from './providers/stripe/ApplePaySubscriptionCheckoutSlot.js';
 export * from './providers/stripe/GooglePaySubscriptionCheckoutSlot.js';
+export * from './providers/stripe/StripeSubscriptionWalletSurface.js';
 export { ManageSubscriptionScreen, type ManageSubscriptionContent, type ManageSubscriptionScreenProps, } from './components/ManageSubscriptionScreen.js';
 export * from './components/shared/SharedStripeCheckoutV2Dialog.js';
 export * from './components/shared/StripeExpressCheckoutElement.js';

package/dist/index.js

@@ -17,6 +17,7 @@ export * from './providers/stripe/useStripeOneTimeCheckoutSession.js';
 export * from './providers/stripe/WalletSubscriptionCheckoutSlot.js';
 export * from './providers/stripe/ApplePaySubscriptionCheckoutSlot.js';
 export * from './providers/stripe/GooglePaySubscriptionCheckoutSlot.js';
+export * from './providers/stripe/StripeSubscriptionWalletSurface.js';
 // Shared checkout and subscription-management UI.
 export { ManageSubscriptionScreen, } from './components/ManageSubscriptionScreen.js';
 export * from './components/shared/SharedStripeCheckoutV2Dialog.js';

package/dist/providers/stripe/ApplePaySubscriptionCheckoutSlot.d.ts

@@ -4,4 +4,9 @@ export type ApplePaySubscriptionCheckoutSlotProps = Omit<WalletSubscriptionCheck
     options?: Partial<StripeCheckoutExpressCheckoutElementOptions>;
     placeholderLabel?: string;
 };
+/**
+ * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
+ * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
+ * never be shared across placements.
+ */
 export declare function ApplePaySubscriptionCheckoutSlot({ options, placeholderLabel, ...slotProps }: ApplePaySubscriptionCheckoutSlotProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/stripe/ApplePaySubscriptionCheckoutSlot.js

@@ -36,6 +36,11 @@ const applePayExpressCheckoutOptions = {
         paypal: 'never',
     },
 };
+/**
+ * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
+ * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
+ * never be shared across placements.
+ */
 export function ApplePaySubscriptionCheckoutSlot(_a) {
     var _b, _c, _d, _e, _f, _g, _h, _j, _k;
     var { options, placeholderLabel = 'Subscribe with Apple Pay' } = _a, slotProps = __rest(_a, ["options", "placeholderLabel"]);

package/dist/providers/stripe/GooglePaySubscriptionCheckoutSlot.d.ts

@@ -4,4 +4,9 @@ export type GooglePaySubscriptionCheckoutSlotProps = Omit<WalletSubscriptionChec
     options?: Partial<StripeCheckoutExpressCheckoutElementOptions>;
     placeholderLabel?: string;
 };
+/**
+ * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
+ * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
+ * never be shared across placements.
+ */
 export declare function GooglePaySubscriptionCheckoutSlot({ options, placeholderLabel, ...slotProps }: GooglePaySubscriptionCheckoutSlotProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/stripe/GooglePaySubscriptionCheckoutSlot.js

@@ -36,6 +36,11 @@ const googlePayExpressCheckoutOptions = {
         paypal: 'never',
     },
 };
+/**
+ * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
+ * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
+ * never be shared across placements.
+ */
 export function GooglePaySubscriptionCheckoutSlot(_a) {
     var _b, _c, _d, _e, _f, _g, _h, _j, _k;
     var { options, placeholderLabel = 'Subscribe with Google Pay' } = _a, slotProps = __rest(_a, ["options", "placeholderLabel"]);

package/dist/providers/stripe/StripeSubscriptionWalletSurface.d.ts

@@ -0,0 +1,82 @@
+import { type ReactNode } from 'react';
+import type { Appearance, StripeCheckoutExpressCheckoutElementOptions } from '@stripe/stripe-js';
+import { type PlatformWalletPaymentMethod } from '../../components/shared/walletPlatform.js';
+import type { StripeSubscriptionCheckoutAnalyticsContext } from '../../services/checkoutCompletionAnalytics.service.js';
+import { type StripeSubscriptionCheckoutSessionInput } from './useStripeSubscriptionCheckoutSession.js';
+export type StripeSubscriptionWalletSurfaceCheckoutInput = Omit<StripeSubscriptionCheckoutSessionInput, 'onError'> & {
+    customerName?: string | null;
+};
+export type StripeSubscriptionWalletSurfaceAvailability = {
+    anyAvailable: boolean;
+    methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>;
+    resolved: boolean;
+};
+export type StripeSubscriptionWalletSurfaceAvailabilityState = {
+    intentKey: string;
+    methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>;
+};
+export type StripeSubscriptionWalletSurfaceErrorContext = {
+    paymentMethod?: PlatformWalletPaymentMethod;
+    surfaceId: string;
+};
+export type StripeSubscriptionWalletSurfaceErrorEmission = {
+    context: StripeSubscriptionWalletSurfaceErrorContext;
+    errorState: StripeSubscriptionWalletSurfaceErrorState;
+    message: string | null;
+};
+export type StripeSubscriptionWalletSurfaceErrorState = {
+    methodMessages: Partial<Record<PlatformWalletPaymentMethod, string>>;
+    surfaceMessage: string | null;
+};
+export type StripeSubscriptionWalletSurfaceRenderStateInput = {
+    anyAvailable: boolean;
+    configured: boolean;
+    paymentMethodCount: number;
+    resolved: boolean;
+    suspended: boolean;
+};
+export declare function buildStripeSubscriptionWalletSurfaceAnalyticsMetadata(analyticsMetadata: Record<string, unknown> | null | undefined, surfaceId: string): Record<string, unknown>;
+export declare function buildStripeSubscriptionWalletSurfaceCheckoutAnalytics(checkoutAnalytics: StripeSubscriptionCheckoutAnalyticsContext | null | undefined, surfaceId: string): StripeSubscriptionCheckoutAnalyticsContext | null;
+export declare function normalizeStripeSubscriptionWalletSurfaceMethods(paymentMethods: readonly PlatformWalletPaymentMethod[]): PlatformWalletPaymentMethod[];
+export declare function getStripeSubscriptionWalletSurfaceVisibleMethods(paymentMethods: readonly PlatformWalletPaymentMethod[], methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>): PlatformWalletPaymentMethod[];
+export declare function getStripeSubscriptionWalletSurfaceMethodAvailability(state: StripeSubscriptionWalletSurfaceAvailabilityState, intentKey: string): Partial<Record<PlatformWalletPaymentMethod, boolean>>;
+export declare function applyStripeSubscriptionWalletSurfaceMethodAvailability(state: StripeSubscriptionWalletSurfaceAvailabilityState, intentKey: string, method: PlatformWalletPaymentMethod, available: boolean): StripeSubscriptionWalletSurfaceAvailabilityState;
+export declare function buildStripeSubscriptionWalletSurfaceAvailability(paymentMethods: readonly PlatformWalletPaymentMethod[], methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>): StripeSubscriptionWalletSurfaceAvailability;
+export declare function shouldRenderStripeSubscriptionWalletSurface({ anyAvailable, configured, paymentMethodCount, resolved, suspended, }: StripeSubscriptionWalletSurfaceRenderStateInput): boolean;
+export declare function resolveStripeSubscriptionWalletSurfaceError({ errorState, message, paymentMethod, surfaceId, }: {
+    errorState: StripeSubscriptionWalletSurfaceErrorState;
+    message: string | null;
+    paymentMethod?: PlatformWalletPaymentMethod;
+    surfaceId: string;
+}): StripeSubscriptionWalletSurfaceErrorEmission | null;
+export type StripeSubscriptionWalletSurfaceProps = {
+    amountCents: number;
+    appearance?: Appearance;
+    applePayOptions?: Partial<StripeCheckoutExpressCheckoutElementOptions>;
+    applePayPlaceholderLabel?: string;
+    beforeConfirm?: () => Promise<string | null>;
+    checkout: StripeSubscriptionWalletSurfaceCheckoutInput;
+    checkoutAnalytics?: StripeSubscriptionCheckoutAnalyticsContext | null;
+    className?: string;
+    containerClassName?: string;
+    disabled?: boolean;
+    googlePayOptions?: Partial<StripeCheckoutExpressCheckoutElementOptions>;
+    googlePayPlaceholderLabel?: string;
+    onAvailabilityChange?: (availability: StripeSubscriptionWalletSurfaceAvailability) => void;
+    onCancel?: () => void;
+    onError?: (message: string | null, context: StripeSubscriptionWalletSurfaceErrorContext) => void;
+    onPaymentInfoSubmitted?: () => void | Promise<void>;
+    onSuccess?: () => void | Promise<void>;
+    onUnavailableClick?: () => Promise<void> | void;
+    paymentMethods?: readonly PlatformWalletPaymentMethod[];
+    renderHeader?: (props: {
+        availability: StripeSubscriptionWalletSurfaceAvailability;
+    }) => ReactNode;
+    resolveMethodClassName?: (method: PlatformWalletPaymentMethod) => string | undefined;
+    resolveMethodWrapperClassName?: (method: PlatformWalletPaymentMethod) => string | undefined;
+    slotClassName?: string;
+    summaryLabel: string;
+    surfaceId: string;
+    suspended?: boolean;
+};
+export declare function StripeSubscriptionWalletSurface({ amountCents, appearance, applePayOptions, applePayPlaceholderLabel, beforeConfirm, checkout, checkoutAnalytics, className, containerClassName, disabled, googlePayOptions, googlePayPlaceholderLabel, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, paymentMethods, renderHeader, resolveMethodClassName, resolveMethodWrapperClassName, slotClassName, summaryLabel, surfaceId, suspended, }: StripeSubscriptionWalletSurfaceProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/providers/stripe/StripeSubscriptionWalletSurface.js

@@ -0,0 +1,188 @@
+'use client';
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { usePlatformWalletPaymentMethods, } from '../../components/shared/walletPlatform.js';
+import { ApplePaySubscriptionCheckoutSlot } from './ApplePaySubscriptionCheckoutSlot.js';
+import { GooglePaySubscriptionCheckoutSlot } from './GooglePaySubscriptionCheckoutSlot.js';
+import { useStripeSubscriptionCheckoutSession, } from './useStripeSubscriptionCheckoutSession.js';
+export function buildStripeSubscriptionWalletSurfaceAnalyticsMetadata(analyticsMetadata, surfaceId) {
+    return Object.assign(Object.assign({}, (analyticsMetadata !== null && analyticsMetadata !== void 0 ? analyticsMetadata : {})), { checkoutSurfaceId: surfaceId });
+}
+export function buildStripeSubscriptionWalletSurfaceCheckoutAnalytics(checkoutAnalytics, surfaceId) {
+    if (!checkoutAnalytics) {
+        return null;
+    }
+    return Object.assign(Object.assign({}, checkoutAnalytics), { metadata: buildStripeSubscriptionWalletSurfaceAnalyticsMetadata(checkoutAnalytics.metadata, surfaceId) });
+}
+export function normalizeStripeSubscriptionWalletSurfaceMethods(paymentMethods) {
+    return paymentMethods.filter((method, index) => paymentMethods.indexOf(method) === index);
+}
+export function getStripeSubscriptionWalletSurfaceVisibleMethods(paymentMethods, methods) {
+    return paymentMethods.filter((method) => methods[method] !== false);
+}
+export function getStripeSubscriptionWalletSurfaceMethodAvailability(state, intentKey) {
+    return state.intentKey === intentKey ? state.methods : {};
+}
+export function applyStripeSubscriptionWalletSurfaceMethodAvailability(state, intentKey, method, available) {
+    return {
+        intentKey,
+        methods: Object.assign(Object.assign({}, getStripeSubscriptionWalletSurfaceMethodAvailability(state, intentKey)), { [method]: available }),
+    };
+}
+export function buildStripeSubscriptionWalletSurfaceAvailability(paymentMethods, methods) {
+    const reportedMethods = paymentMethods.filter((method) => typeof methods[method] === 'boolean');
+    return {
+        anyAvailable: reportedMethods.some((method) => methods[method] === true),
+        methods: reportedMethods.reduce((current, method) => (Object.assign(Object.assign({}, current), { [method]: methods[method] === true })), {}),
+        resolved: reportedMethods.length === paymentMethods.length,
+    };
+}
+export function shouldRenderStripeSubscriptionWalletSurface({ anyAvailable, configured, paymentMethodCount, resolved, suspended, }) {
+    return configured && !suspended && paymentMethodCount > 0 && (!resolved || anyAvailable);
+}
+export function resolveStripeSubscriptionWalletSurfaceError({ errorState, message, paymentMethod, surfaceId, }) {
+    if (paymentMethod && errorState.methodMessages[paymentMethod] === message) {
+        return null;
+    }
+    if (!paymentMethod) {
+        const methodMessages = Object.values(errorState.methodMessages);
+        if (message === null) {
+            if (errorState.surfaceMessage === null && methodMessages.length === 0) {
+                return null;
+            }
+        }
+        else if (errorState.surfaceMessage === message || methodMessages.includes(message)) {
+            return null;
+        }
+    }
+    const nextErrorState = message === null
+        ? { methodMessages: {}, surfaceMessage: null }
+        : paymentMethod
+            ? Object.assign(Object.assign({}, errorState), { methodMessages: Object.assign(Object.assign({}, errorState.methodMessages), { [paymentMethod]: message }) }) : Object.assign(Object.assign({}, errorState), { surfaceMessage: message });
+    return {
+        context: Object.assign(Object.assign({}, (paymentMethod ? { paymentMethod } : {})), { surfaceId }),
+        errorState: nextErrorState,
+        message,
+    };
+}
+// Availability identity used to notify consumers only when the aggregate actually changed.
+function buildAvailabilitySignature(availability) {
+    return [
+        availability.resolved ? 'resolved' : 'unresolved',
+        availability.anyAvailable ? 'available' : 'unavailable',
+        Object.entries(availability.methods)
+            .map(([method, available]) => `${method}:${available ? '1' : '0'}`)
+            .sort()
+            .join(','),
+    ].join('|');
+}
+export function StripeSubscriptionWalletSurface({ amountCents, appearance, applePayOptions, applePayPlaceholderLabel, beforeConfirm, checkout, checkoutAnalytics, className, containerClassName, disabled, googlePayOptions, googlePayPlaceholderLabel, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, paymentMethods, renderHeader, resolveMethodClassName, resolveMethodWrapperClassName, slotClassName, summaryLabel, surfaceId, suspended = false, }) {
+    var _a;
+    const platformWalletPaymentMethods = usePlatformWalletPaymentMethods();
+    const walletPaymentMethods = normalizeStripeSubscriptionWalletSurfaceMethods(paymentMethods !== null && paymentMethods !== void 0 ? paymentMethods : platformWalletPaymentMethods);
+    const normalizedSurfaceId = surfaceId.trim();
+    const { customerName } = checkout, checkoutSessionInput = __rest(checkout, ["customerName"]);
+    const surfaceAnalyticsMetadata = useMemo(() => buildStripeSubscriptionWalletSurfaceAnalyticsMetadata(checkout.analyticsMetadata, normalizedSurfaceId), [checkout.analyticsMetadata, normalizedSurfaceId]);
+    const session = useStripeSubscriptionCheckoutSession(Object.assign(Object.assign({}, checkoutSessionInput), { analyticsMetadata: surfaceAnalyticsMetadata }));
+    const surfaceCheckoutAnalytics = useMemo(() => buildStripeSubscriptionWalletSurfaceCheckoutAnalytics(checkoutAnalytics, normalizedSurfaceId), [checkoutAnalytics, normalizedSurfaceId]);
+    const [availabilityState, setAvailabilityState] = useState({
+        intentKey: session.intentKey,
+        methods: {},
+    });
+    const availability = buildStripeSubscriptionWalletSurfaceAvailability(walletPaymentMethods, getStripeSubscriptionWalletSurfaceMethodAvailability(availabilityState, session.intentKey));
+    const availabilitySignature = buildAvailabilitySignature(availability);
+    const reportedAvailabilitySignatureRef = useRef(null);
+    const errorStateRef = useRef({
+        methodMessages: {},
+        surfaceMessage: null,
+    });
+    const emitError = useCallback((message, paymentMethod) => {
+        const emission = resolveStripeSubscriptionWalletSurfaceError({
+            errorState: errorStateRef.current,
+            message,
+            paymentMethod,
+            surfaceId: normalizedSurfaceId,
+        });
+        if (!emission) {
+            return;
+        }
+        errorStateRef.current = emission.errorState;
+        onError === null || onError === void 0 ? void 0 : onError(emission.message, emission.context);
+    }, [normalizedSurfaceId, onError]);
+    useEffect(() => {
+        if (reportedAvailabilitySignatureRef.current === availabilitySignature) {
+            return;
+        }
+        reportedAvailabilitySignatureRef.current = availabilitySignature;
+        onAvailabilityChange === null || onAvailabilityChange === void 0 ? void 0 : onAvailabilityChange(availability);
+    }, [availability, availabilitySignature, onAvailabilityChange]);
+    useEffect(() => {
+        emitError(session.error);
+    }, [emitError, session.error]);
+    const renderWalletMethod = (method) => {
+        var _a;
+        const slotProps = {
+            amountCents,
+            appearance,
+            beforeConfirm,
+            checkoutAnalytics: surfaceCheckoutAnalytics,
+            className: (_a = resolveMethodClassName === null || resolveMethodClassName === void 0 ? void 0 : resolveMethodClassName(method)) !== null && _a !== void 0 ? _a : className,
+            customerEmail: checkout.customerEmail,
+            customerName,
+            disabled,
+            onAvailabilityChange: (available) => setAvailabilityState((current) => applyStripeSubscriptionWalletSurfaceMethodAvailability(current, session.intentKey, method, available)),
+            onCancel,
+            onError: (message) => emitError(message, method),
+            onPaymentInfoSubmitted,
+            onSuccess,
+            onUnavailableClick,
+            returnUrl: checkout.returnUrl,
+            session,
+            slotClassName,
+            summaryLabel,
+        };
+        if (method === 'applePay') {
+            return (_jsx(ApplePaySubscriptionCheckoutSlot, Object.assign({}, slotProps, { options: applePayOptions, placeholderLabel: applePayPlaceholderLabel })));
+        }
+        if (method === 'googlePay') {
+            return (_jsx(GooglePaySubscriptionCheckoutSlot, Object.assign({}, slotProps, { options: googlePayOptions, placeholderLabel: googlePayPlaceholderLabel })));
+        }
+        return null;
+    };
+    const visibleWalletPaymentMethods = getStripeSubscriptionWalletSurfaceVisibleMethods(walletPaymentMethods, availability.methods);
+    const shouldRenderSurface = shouldRenderStripeSubscriptionWalletSurface({
+        anyAvailable: availability.anyAvailable,
+        configured: session.configured,
+        paymentMethodCount: walletPaymentMethods.length,
+        resolved: availability.resolved,
+        suspended,
+    });
+    if (!shouldRenderSurface) {
+        return null;
+    }
+    return (_jsxs("div", { className: [
+            'stripe-subscription-wallet-surface',
+            containerClassName !== null && containerClassName !== void 0 ? containerClassName : '',
+        ]
+            .filter(Boolean)
+            .join(' '), "data-wallet-surface-id": normalizedSurfaceId, children: [(_a = renderHeader === null || renderHeader === void 0 ? void 0 : renderHeader({ availability })) !== null && _a !== void 0 ? _a : null, visibleWalletPaymentMethods.map((method) => {
+                var _a;
+                return (_jsx("div", { className: [
+                        'stripe-subscription-wallet-surface__method',
+                        (_a = resolveMethodWrapperClassName === null || resolveMethodWrapperClassName === void 0 ? void 0 : resolveMethodWrapperClassName(method)) !== null && _a !== void 0 ? _a : '',
+                    ]
+                        .filter(Boolean)
+                        .join(' '), "data-wallet-payment-method": method, children: renderWalletMethod(method) }, method));
+            })] }));
+}

package/dist/providers/stripe/WalletSubscriptionCheckoutSlot.d.ts

@@ -50,5 +50,10 @@ export type WalletSubscriptionCheckoutSlotProps = {
     suspended?: boolean;
 };
 export declare function WalletSubscriptionCheckoutLoadingPlaceholder({ className, label, }: Pick<WalletPlaceholderButtonProps, 'className' | 'label'>): import("react/jsx-runtime").JSX.Element;
+/**
+ * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
+ * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
+ * never be shared across placements.
+ */
 export declare function WalletSubscriptionCheckoutSlot({ amountCents, appearance, availabilityPaymentMethod, beforeConfirm, checkoutAnalytics, className, customerEmail, customerName, disabled, expressCheckoutAllowed, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, options, placeholderLabel, renderPreparingPlaceholder, renderPlaceholder, returnUrl, session, slotClassName, summaryLabel, suspended, }: WalletSubscriptionCheckoutSlotProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/providers/stripe/WalletSubscriptionCheckoutSlot.js

@@ -29,6 +29,11 @@ export function WalletSubscriptionCheckoutLoadingPlaceholder({ className, label,
             .filter(Boolean)
             .join(' '), "aria-label": label, role: 'status', children: [_jsx("span", { className: 'wallet-subscription-checkout-slot__loading-bar' }), _jsx("style", { children: walletSubscriptionCheckoutLoadingPlaceholderStyles })] }));
 }
+/**
+ * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
+ * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
+ * never be shared across placements.
+ */
 export function WalletSubscriptionCheckoutSlot({ amountCents, appearance, availabilityPaymentMethod, beforeConfirm, checkoutAnalytics, className, customerEmail, customerName, disabled = false, expressCheckoutAllowed = true, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, options, placeholderLabel, renderPreparingPlaceholder, renderPlaceholder, returnUrl, session, slotClassName, summaryLabel, suspended = false, }) {
     const [walletAvailability, setWalletAvailability] = useState({
         available: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funnelsgrove/payments",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/The-Solid-Grove/funnelsgrove.git",