mppx 0.9.1 → 0.9.3

package/dist/stripe/client/Charge.d.ts

@@ -55,9 +55,18 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
             externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
             metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
             networkId: z.ZodMiniString<string>;
-            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniObject<{
-                metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
-            }, z.core.$strip>>;
+            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+                customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                hooks: z.ZodMiniOptional<z.ZodMiniObject<{
+                    inputs: z.ZodMiniObject<{
+                        tax: z.ZodMiniObject<{
+                            calculation: z.ZodMiniString<string>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+                metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+                receipt_email: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>, z.ZodMiniCustom<import("../internal/payment-intent.js").ResolveOptions, import("../internal/payment-intent.js").ResolveOptions>]>>;
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
@@ -79,8 +88,17 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
-            paymentIntentOptions?: {
-                metadata: Record<string, string>;
+            paymentIntentOptions?: import("../internal/payment-intent.js").ResolveOptions | {
+                customer?: string | undefined;
+                hooks?: {
+                    inputs: {
+                        tax: {
+                            calculation: string;
+                        };
+                    };
+                } | undefined;
+                metadata?: Record<string, string> | undefined;
+                receipt_email?: string | undefined;
             } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;

package/dist/stripe/client/Methods.d.ts

@@ -42,9 +42,18 @@ export declare function stripe(parameters: stripe.Parameters): readonly [import(
             externalId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             metadata: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniRecord<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniString<string>>>;
             networkId: import("zod/mini").ZodMiniString<string>;
-            paymentIntentOptions: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniObject<{
-                metadata: import("zod/mini").ZodMiniRecord<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniString<string>>;
-            }, import("zod/v4/core").$strip>>;
+            paymentIntentOptions: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniObject<{
+                customer: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+                hooks: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniObject<{
+                    inputs: import("zod/mini").ZodMiniObject<{
+                        tax: import("zod/mini").ZodMiniObject<{
+                            calculation: import("zod/mini").ZodMiniString<string>;
+                        }, import("zod/v4/core").$strip>;
+                    }, import("zod/v4/core").$strip>;
+                }, import("zod/v4/core").$strip>>;
+                metadata: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniRecord<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniString<string>>>;
+                receipt_email: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniCustom<import("../internal/payment-intent.js").ResolveOptions, import("../internal/payment-intent.js").ResolveOptions>]>>;
             paymentMethodTypes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>;
             recipient: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
@@ -66,8 +75,17 @@ export declare function stripe(parameters: stripe.Parameters): readonly [import(
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
-            paymentIntentOptions?: {
-                metadata: Record<string, string>;
+            paymentIntentOptions?: import("../internal/payment-intent.js").ResolveOptions | {
+                customer?: string | undefined;
+                hooks?: {
+                    inputs: {
+                        tax: {
+                            calculation: string;
+                        };
+                    };
+                } | undefined;
+                metadata?: Record<string, string> | undefined;
+                receipt_email?: string | undefined;
             } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;

package/dist/stripe/internal/constants.d.ts

@@ -5,4 +5,8 @@
  * Bump this when upgrading to a newer Stripe API version.
  */
 export declare const stripePreviewVersion = "2026-07-29.preview";
+/** Metadata identifying a Stripe PaymentIntent as a machine payment. */
+export declare const machinePaymentMetadata: {
+    readonly machine_payment: 'true';
+};
 //# sourceMappingURL=constants.d.ts.map

package/dist/stripe/internal/constants.js

@@ -5,4 +5,6 @@
  * Bump this when upgrading to a newer Stripe API version.
  */
 export const stripePreviewVersion = '2026-07-29.preview';
+/** Metadata identifying a Stripe PaymentIntent as a machine payment. */
+export const machinePaymentMetadata = { machine_payment: 'true' };
 //# sourceMappingURL=constants.js.map

package/dist/stripe/internal/parse-units.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a decimal string to its integer representation at the given precision.
+ * Fractional digits beyond the precision are rounded half away from zero.
+ *
+ * @see https://github.com/wevm/viem/pull/4859
+ */
+export declare function parseUnits(value: string, decimals: number): bigint;
+//# sourceMappingURL=parse-units.d.ts.map

package/dist/stripe/internal/parse-units.js

@@ -0,0 +1,20 @@
+/**
+ * Converts a decimal string to its integer representation at the given precision.
+ * Fractional digits beyond the precision are rounded half away from zero.
+ *
+ * @see https://github.com/wevm/viem/pull/4859
+ */
+export function parseUnits(value, decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0)
+        throw new RangeError('Decimals must be a non-negative integer.');
+    if (!/^-?(?:\d+(?:\.\d*)?|\.\d+)$/.test(value))
+        throw new TypeError(`Value \`${value}\` is not a valid decimal number.`);
+    const negative = value.startsWith('-');
+    const [integer = '0', fraction = ''] = (negative ? value.slice(1) : value).split('.');
+    const keptFraction = fraction.slice(0, decimals).padEnd(decimals, '0');
+    let result = BigInt(`${integer || '0'}${keptFraction}`);
+    if (fraction.length > decimals && fraction[decimals] >= '5')
+        result += 1n;
+    return negative ? -result : result;
+}
+//# sourceMappingURL=parse-units.js.map

package/dist/stripe/internal/payment-intent.d.ts

@@ -1,7 +1,45 @@
+import type * as Challenge from '../../Challenge.js';
+import type * as Credential from '../../Credential.js';
+import type { MaybePromise } from '../../internal/types.js';
+import type * as Method from '../../Method.js';
 import * as z from '../../zod.js';
 /** Stripe PaymentIntent options accepted only by server-side method input. */
 export declare const Schema: z.ZodMiniObject<{
-    metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+    customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    hooks: z.ZodMiniOptional<z.ZodMiniObject<{
+        inputs: z.ZodMiniObject<{
+            tax: z.ZodMiniObject<{
+                calculation: z.ZodMiniString<string>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    receipt_email: z.ZodMiniOptional<z.ZodMiniString<string>>;
 }, z.core.$strip>;
 export type Options = z.infer<typeof Schema>;
+/** Context provided when resolving request-scoped PaymentIntent options. */
+export type ResolveOptionsContext = {
+    challenge: Challenge.Challenge;
+    credential: Credential.Credential;
+    envelope?: Method.VerifiedChallengeEnvelope | undefined;
+    request: Record<string, unknown>;
+};
+/** Lazily resolves request-scoped PaymentIntent options before the terminal payment operation. */
+export type ResolveOptions = (context: ResolveOptionsContext) => MaybePromise<Options | undefined>;
+export type OptionsInput = Options | ResolveOptions;
+/** PaymentIntent options accepted only by server-side method input. */
+export declare const InputSchema: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    hooks: z.ZodMiniOptional<z.ZodMiniObject<{
+        inputs: z.ZodMiniObject<{
+            tax: z.ZodMiniObject<{
+                calculation: z.ZodMiniString<string>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    receipt_email: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>, z.ZodMiniCustom<ResolveOptions, ResolveOptions>]>;
+/** Resolves and validates request-scoped PaymentIntent options. */
+export declare function resolve(input: OptionsInput | undefined, context: ResolveOptionsContext): Promise<Options | undefined>;
 //# sourceMappingURL=payment-intent.d.ts.map

package/dist/stripe/internal/payment-intent.js

@@ -1,6 +1,21 @@
 import * as z from '../../zod.js';
 /** Stripe PaymentIntent options accepted only by server-side method input. */
 export const Schema = z.object({
-    metadata: z.record(z.string(), z.string()),
+    customer: z.optional(z.string().check(z.minLength(1))),
+    hooks: z.optional(z.object({
+        inputs: z.object({
+            tax: z.object({ calculation: z.string().check(z.minLength(1)) }),
+        }),
+    })),
+    metadata: z.optional(z.record(z.string(), z.string())),
+    receipt_email: z.optional(z.string().check(z.minLength(1))),
 });
+const ResolveOptionsSchema = z.custom((value) => typeof value === 'function');
+/** PaymentIntent options accepted only by server-side method input. */
+export const InputSchema = z.union([Schema, ResolveOptionsSchema]);
+/** Resolves and validates request-scoped PaymentIntent options. */
+export async function resolve(input, context) {
+    const options = typeof input === 'function' ? await input(context) : input;
+    return z.optional(Schema).parse(options);
+}
 //# sourceMappingURL=payment-intent.js.map

package/dist/stripe/internal/types.d.ts

@@ -6,6 +6,10 @@ import * as StripeJsTypes from '../../stripe/server/internal/html/types.js';
  * Uses loose signatures so any Stripe SDK version is assignable.
  */
 export type StripeClient = {
+    /** Stripe-node request transport used for hosted fee-payer requests. */
+    _requestSender?: {
+        _request(...args: any[]): void;
+    } | undefined;
     paymentIntents: {
         create(...args: any[]): Promise<{
             id: string;

package/dist/stripe/server/Charge.d.ts

@@ -4,6 +4,7 @@ import type { ConfiguredDefaults, LooseOmit, MaybePromise, OneOf } from '../../i
 import * as Method from '../../Method.js';
 import type * as Html from '../../server/internal/html/config.ts';
 import type * as z from '../../zod.js';
+import * as PaymentIntent from '../internal/payment-intent.js';
 import type { StripeClient, CreatePaymentMethodFromElements, StripeElementsOptionsMode, StripePaymentElementOptions } from '../internal/types.js';
 import * as Methods from '../Methods.js';
 /**
@@ -49,9 +50,18 @@ export declare function charge<const parameters extends charge.Parameters>(param
             externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
             metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
             networkId: z.ZodMiniString<string>;
-            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniObject<{
-                metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
-            }, z.core.$strip>>;
+            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+                customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                hooks: z.ZodMiniOptional<z.ZodMiniObject<{
+                    inputs: z.ZodMiniObject<{
+                        tax: z.ZodMiniObject<{
+                            calculation: z.ZodMiniString<string>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+                metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+                receipt_email: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>, z.ZodMiniCustom<PaymentIntent.ResolveOptions, PaymentIntent.ResolveOptions>]>>;
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
@@ -73,8 +83,17 @@ export declare function charge<const parameters extends charge.Parameters>(param
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
-            paymentIntentOptions?: {
-                metadata: Record<string, string>;
+            paymentIntentOptions?: PaymentIntent.ResolveOptions | {
+                customer?: string | undefined;
+                hooks?: {
+                    inputs: {
+                        tax: {
+                            calculation: string;
+                        };
+                    };
+                } | undefined;
+                metadata?: Record<string, string> | undefined;
+                receipt_email?: string | undefined;
             } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;
@@ -112,6 +131,7 @@ export declare namespace charge {
      * `decimals` remains required when it was not configured on `stripe.charge()`.
      */
     type DeriveDefaults<parameters extends Parameters> = ConfiguredDefaults<parameters, Defaults>;
+    type ResolvePaymentIntentOptionsContext = PaymentIntent.ResolveOptionsContext;
     /**
      * Server-side Stripe Connect settlement parameters.
      *

package/dist/stripe/server/Charge.js

@@ -2,7 +2,9 @@ import { InvalidChallengeError, PaymentActionRequiredError, VerificationFailedEr
 import * as Expires from '../../Expires.js';
 import * as Method from '../../Method.js';
 import { stripePreviewVersion } from '../internal/constants.js';
+import * as PaymentIntent from '../internal/payment-intent.js';
 import * as Methods from '../Methods.js';
+import { buildAnalytics } from './internal/analytics.js';
 import { html as htmlContent } from './internal/html.gen.js';
 /**
  * Stripe's general minimum charge amounts in each currency's smallest unit.
@@ -117,7 +119,7 @@ export function charge(parameters) {
         onPaymentSuccess,
         async verify({ credential, envelope, request }) {
             const { challenge } = credential;
-            const { paymentIntentOptions, ...methodRequest } = request;
+            const { paymentIntentOptions: paymentIntentOptionsInput, ...methodRequest } = request;
             const resolvedRequest = (() => {
                 const parsed = Methods.charge.schema.request.safeParse(methodRequest);
                 if (parsed.success)
@@ -139,32 +141,44 @@ export function charge(parameters) {
                 });
             }
             const userMetadata = resolvedRequest.methodDetails?.metadata;
-            const resolvedMetadata = {
-                ...buildAnalytics({ credential }),
-                ...userMetadata,
-                ...paymentIntentOptions?.metadata,
-            };
             const settlement = validateConnectSettlement({
                 amount: resolvedRequest.amount,
                 settlement: typeof connect === 'function'
                     ? await connect({ challenge, credential, envelope, request: resolvedRequest })
                     : connect,
             });
+            const paymentIntentOptions = await PaymentIntent.resolve(paymentIntentOptionsInput, {
+                challenge,
+                credential,
+                envelope,
+                request: resolvedRequest,
+            });
+            const { customer, hooks, metadata: optionMetadata, receipt_email, } = paymentIntentOptions ?? {};
+            const resolvedPaymentIntentOptions = {
+                ...(customer !== undefined && { customer }),
+                ...(hooks !== undefined && { hooks }),
+                metadata: {
+                    ...buildAnalytics({ challenge }),
+                    ...userMetadata,
+                    ...optionMetadata,
+                },
+                ...(receipt_email !== undefined && { receipt_email }),
+            };
             const pi = client
                 ? await createWithClient({
                     client,
                     challenge,
+                    paymentIntentOptions: resolvedPaymentIntentOptions,
                     request: resolvedRequest,
                     spt,
-                    metadata: resolvedMetadata,
                     settlement,
                 })
                 : await createWithSecretKey({
                     secretKey: secretKey,
                     challenge,
+                    paymentIntentOptions: resolvedPaymentIntentOptions,
                     request: resolvedRequest,
                     spt,
-                    metadata: resolvedMetadata,
                     settlement,
                 });
             if (pi.replayed)
@@ -186,14 +200,18 @@ export function charge(parameters) {
 }
 /** Creates a PaymentIntent using the Stripe SDK client. */
 async function createWithClient(parameters) {
-    const { client, challenge, metadata, request, settlement, spt } = parameters;
+    const { client, challenge, paymentIntentOptions, request, settlement, spt } = parameters;
+    const { customer, hooks, metadata, receipt_email } = paymentIntentOptions;
     try {
         const paymentIntentParams = {
             amount: Number(request.amount),
             automatic_payment_methods: { allow_redirects: 'never', enabled: true },
             confirm: true,
             currency: request.currency,
+            ...(customer !== undefined && { customer }),
+            ...(hooks !== undefined && { hooks }),
             metadata,
+            ...(receipt_email !== undefined && { receipt_email }),
             ...(settlement?.applicationFeeAmount !== undefined && {
                 application_fee_amount: settlement.applicationFeeAmount,
             }),
@@ -210,12 +228,12 @@ async function createWithClient(parameters) {
             // `shared_payment_granted_token` is not yet in the Stripe SDK types (SPTs are in private preview).
             shared_payment_granted_token: spt,
         };
-        const paymentIntentOptions = {
+        const requestOptions = {
             apiVersion: stripePreviewVersion,
             idempotencyKey: `mpp_${challenge.id}_${spt}`,
             ...(settlement?.stripeAccount !== undefined && { stripeAccount: settlement.stripeAccount }),
         };
-        const result = await client.paymentIntents.create(paymentIntentParams, paymentIntentOptions);
+        const result = await client.paymentIntents.create(paymentIntentParams, requestOptions);
         // https://docs.stripe.com/error-low-level#idempotency
         const replayed = result.lastResponse?.headers?.['idempotent-replayed'] === 'true';
         return { id: result.id, status: result.status, replayed };
@@ -229,18 +247,23 @@ async function createWithClient(parameters) {
 }
 /** Creates a PaymentIntent using a raw secret key and fetch. */
 async function createWithSecretKey(parameters) {
-    const { secretKey, challenge, metadata, request, settlement, spt } = parameters;
+    const { secretKey, challenge, paymentIntentOptions, request, settlement, spt } = parameters;
+    const { customer, hooks, metadata, receipt_email } = paymentIntentOptions;
     const body = new URLSearchParams({
         amount: request.amount,
         'automatic_payment_methods[allow_redirects]': 'never',
         'automatic_payment_methods[enabled]': 'true',
         confirm: 'true',
         currency: request.currency,
+        ...(customer !== undefined && { customer }),
+        ...(receipt_email !== undefined && { receipt_email }),
         shared_payment_granted_token: spt,
     });
     for (const [key, value] of Object.entries(metadata)) {
         body.set(`metadata[${key}]`, value);
     }
+    if (hooks !== undefined)
+        body.set('hooks[inputs][tax][calculation]', hooks.inputs.tax.calculation);
     if (settlement?.applicationFeeAmount !== undefined)
         body.set('application_fee_amount', String(settlement.applicationFeeAmount));
     if (settlement?.onBehalfOf !== undefined)
@@ -284,17 +307,6 @@ async function createWithSecretKey(parameters) {
     const result = (await response.json());
     return { ...result, replayed };
 }
-/** @internal */
-function buildAnalytics(parameters) {
-    const { credential } = parameters;
-    const { challenge } = credential;
-    return {
-        mpp_intent: challenge.intent,
-        mpp_challenge_id: challenge.id,
-        mpp_server_id: challenge.realm,
-        ...(credential.source ? { mpp_client_id: credential.source } : {}),
-    };
-}
 function validateConnectSettlement(parameters) {
     const { amount, settlement } = parameters;
     if (settlement === undefined)

package/dist/stripe/server/Methods.d.ts

@@ -2,12 +2,14 @@ import { charge as evmCharge } from '../../evm/server/Charge.js';
 import type * as Method from '../../Method.js';
 import { charge as tempoCharge } from '../../tempo/server/Charge.js';
 import { session as tempoSession } from '../../tempo/session/server/Session.js';
+import * as PaymentIntent from '../internal/payment-intent.js';
 import type { StripeClient } from '../internal/types.js';
 import { charge as charge_ } from './Charge.js';
 import { findOrCreateDepositAddress as _findOrCreateDepositAddress } from './internal/deposit-address.js';
 import { type ConnectConfig } from './internal/request.js';
 export declare namespace stripe {
     type Network = 'tempo' | 'base' | 'solana';
+    type ResolvePaymentIntentOptionsContext = PaymentIntent.ResolveOptionsContext;
     type DepositAddress<N extends Network = Network> = string & {
         readonly __brand: 'StripeDepositAddress';
         readonly __network: N;
@@ -16,6 +18,7 @@ export declare namespace stripe {
         client: StripeClient;
         networkId: string;
         livemode: boolean;
+        hostedFeePayer?: boolean | undefined;
         connect?: ConnectConfig;
         depositAddresses?: Partial<Record<Network, string>> | ((network: Network) => Promise<string>);
         metadata?: Record<string, string> | undefined;
@@ -139,6 +142,11 @@ declare class DefaultMethodsBuilder implements PromiseLike<DefaultMethods> {
  *   secretKey: mppSecretKey,
  * })
  * ```
+ *
+ * PaymentIntent option resolvers run after non-mutating method validation, when
+ * available, and before the terminal payment operation. If Stripe later rejects
+ * resolved optional fields while recording a completed crypto payment, mppx
+ * retries the recording once without them. SPT payments do not use this fallback.
  */
 export declare function stripe<const P extends stripe.Parameters>(parameters: P): StripeMachinePayments<P>;
 export declare namespace stripe {

package/dist/stripe/server/Methods.js

@@ -6,7 +6,9 @@ import { session as tempoSession } from '../../tempo/session/server/Session.js';
 import * as z from '../../zod.js';
 import * as PaymentIntent from '../internal/payment-intent.js';
 import { charge as charge_ } from './Charge.js';
+import { buildAnalytics } from './internal/analytics.js';
 import { findOrCreateDepositAddress as _findOrCreateDepositAddress } from './internal/deposit-address.js';
+import * as HostedFeePayer from './internal/hosted-fee-payer.js';
 import { recordCryptoPayment } from './internal/record-payment.js';
 const defaultMethodNames = ['tempo', 'spt'];
 const additionalBuiltinKeys = ['base', 'tempo'];
@@ -71,12 +73,22 @@ class DefaultMethodsBuilder {
  *   secretKey: mppSecretKey,
  * })
  * ```
+ *
+ * PaymentIntent option resolvers run after non-mutating method validation, when
+ * available, and before the terminal payment operation. If Stripe later rejects
+ * resolved optional fields while recording a completed crypto payment, mppx
+ * retries the recording once without them. SPT payments do not use this fallback.
  */
 export function stripe(parameters) {
-    const { client, networkId, livemode, connect, depositAddresses, metadata } = parameters;
+    const { client, networkId, livemode, hostedFeePayer, connect, depositAddresses, metadata } = parameters;
     if (!client.rawRequest)
         throw new Error('stripe.create() requires a Stripe SDK client with rawRequest() (v15+)');
+    if (hostedFeePayer && !livemode)
+        throw new Error('Stripe hosted fee payer requires a live-mode integration.');
+    if (hostedFeePayer && connect)
+        throw new Error('Stripe hosted fee payer does not support Connect account routing.');
     const tempoCurrency = (livemode ? tempoDefaults.tokens.usdc : tempoDefaults.tokens.pathUsd);
+    const hostedTempoFeePayer = hostedFeePayer ? HostedFeePayer.create(client) : undefined;
     const tempoPaymentHandler = createPaymentSuccessHandler(client, 'tempo', connect, metadata);
     const basePaymentHandler = createPaymentSuccessHandler(client, 'base', connect, metadata);
     // All stripe-managed crypto rails use 6-decimal stablecoins. Reject amounts
@@ -102,6 +114,7 @@ export function stripe(parameters) {
             currency: tempoCurrency,
             recipient,
             ...(!livemode && { testnet: true }),
+            ...(hostedTempoFeePayer && { feePayer: hostedTempoFeePayer }),
             canOffer: cryptoCanOffer,
             onPaymentSuccess: handler,
             ...rest,
@@ -113,6 +126,7 @@ export function stripe(parameters) {
             currency: tempoCurrency,
             recipient,
             ...(!livemode && { testnet: true }),
+            ...(hostedTempoFeePayer && { feePayer: hostedTempoFeePayer }),
             ...rest,
         });
     }
@@ -269,18 +283,27 @@ function customRails(additional) {
 }
 function createPaymentSuccessHandler(client, network, connect, metadata) {
     return (params) => {
-        const { receipt, request, requestInput } = params;
+        const { challenge, receipt, request, requestInput } = params;
         if (receipt?.reference && request?.amount) {
+            const paymentIntentOptionsInput = requestInput?.paymentIntentOptions;
+            const paymentIntentOptions = typeof paymentIntentOptionsInput === 'function' ? undefined : paymentIntentOptionsInput;
             const resolvedMetadata = {
                 ...metadata,
-                ...requestInput?.paymentIntentOptions?.metadata,
+                ...paymentIntentOptions?.metadata,
+            };
+            const resolvedPaymentIntentOptions = {
+                ...paymentIntentOptions,
+                ...(Object.keys(resolvedMetadata).length > 0 && { metadata: resolvedMetadata }),
             };
             return recordCryptoPayment(client, {
                 network,
                 reference: receipt.reference,
                 amount: String(request.amount),
                 ...(connect && { connect }),
-                ...(Object.keys(resolvedMetadata).length > 0 && { metadata: resolvedMetadata }),
+                analyticsMetadata: buildAnalytics({ challenge }),
+                ...(Object.keys(resolvedPaymentIntentOptions).length > 0 && {
+                    paymentIntentOptions: resolvedPaymentIntentOptions,
+                }),
             });
         }
     };
@@ -289,8 +312,9 @@ function createPaymentSuccessHandler(client, network, connect, metadata) {
  * Extends a rail's server-only input with Stripe PaymentIntent options while
  * keeping its canonical request unchanged. The schema strips the options
  * before challenge serialization, and delegated lifecycle hooks receive the
- * underlying rail request without Stripe-only fields. The wrapper retains the
- * options only in `requestInput` for payment-success recording.
+ * underlying rail request without Stripe-only fields. After method validation,
+ * the wrapper resolves the options immediately before the terminal operation
+ * and retains the result in `requestInput` for payment-success recording.
  */
 function withPaymentIntentInput(method) {
     const baseSchema = method.schema.request;
@@ -306,7 +330,7 @@ function withPaymentIntentInput(method) {
             ...method.schema,
             request: z.pipe(z.custom(), z.transform((input) => {
                 const { paymentIntentOptions, ...request } = input;
-                z.optional(PaymentIntent.Schema).parse(paymentIntentOptions);
+                z.optional(PaymentIntent.InputSchema).parse(paymentIntentOptions);
                 // Only the base schema's output is included in the challenge.
                 return baseSchema.parse(request);
             })),
@@ -314,22 +338,43 @@ function withPaymentIntentInput(method) {
         async request(context) {
             const { paymentIntentOptions, ...request } = context.request;
             const resolved = baseRequest ? await baseRequest({ ...context, request }) : request;
+            // Keep the server-only value in requestInput for the success hook. The
+            // schema transform above still excludes it from the signed challenge.
             return { ...resolved, paymentIntentOptions };
         },
         ...(baseRespond && {
             respond: (context) => baseRespond(withoutPaymentIntentOptions(context)),
         }),
         ...(baseBroadcast && {
-            broadcast: (context) => baseBroadcast(withoutPaymentIntentOptions(context)),
+            async broadcast(context) {
+                await resolvePaymentIntentOptions(context);
+                return baseBroadcast(withoutPaymentIntentOptions(context));
+            },
         }),
         ...(baseValidate && {
             validate: (context) => baseValidate(withoutPaymentIntentOptions(context)),
         }),
         ...(baseVerify && {
-            verify: (context) => baseVerify(withoutPaymentIntentOptions(context)),
+            async verify(context) {
+                await resolvePaymentIntentOptions(context);
+                return baseVerify(withoutPaymentIntentOptions(context));
+            },
         }),
     };
 }
+/** Resolves Stripe-only options immediately before the terminal payment operation. */
+async function resolvePaymentIntentOptions(context) {
+    const { paymentIntentOptions } = context.request;
+    const resolved = await PaymentIntent.resolve(paymentIntentOptions, {
+        challenge: context.credential.challenge,
+        credential: context.credential,
+        envelope: context.envelope,
+        request: context.envelope?.request ?? context.credential.challenge.request,
+    });
+    // MPPX later snapshots this request-local input for onPaymentSuccess. Replacing
+    // only the schema-stripped field keeps the canonical challenge unchanged.
+    context.request.paymentIntentOptions = resolved;
+}
 function withoutPaymentIntentOptions(context) {
     const { paymentIntentOptions: _, ...request } = context.request;
     return { ...context, request };

package/dist/stripe/server/internal/analytics.d.ts

@@ -0,0 +1,6 @@
+import type * as Challenge from '../../../Challenge.js';
+/** Builds Stripe metadata used to identify and analyze MPP payments. */
+export declare function buildAnalytics(parameters: {
+    challenge?: Pick<Challenge.Challenge, 'id' | 'intent'> | undefined;
+}): Record<string, string>;
+//# sourceMappingURL=analytics.d.ts.map

package/dist/stripe/server/internal/analytics.js

@@ -0,0 +1,16 @@
+import { sdkIdentifier } from '../../../internal/version.js';
+import { machinePaymentMetadata } from '../../internal/constants.js';
+/** Builds Stripe metadata used to identify and analyze MPP payments. */
+export function buildAnalytics(parameters) {
+    const { challenge } = parameters;
+    const metadata = {
+        ...machinePaymentMetadata,
+        mpp_sdk: sdkIdentifier,
+        ...(challenge && {
+            mpp_challenge_id: challenge.id,
+            mpp_intent: challenge.intent,
+        }),
+    };
+    return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, [...value].slice(0, 500).join('')]));
+}
+//# sourceMappingURL=analytics.js.map

package/dist/stripe/server/internal/hosted-fee-payer.d.ts

@@ -0,0 +1,10 @@
+import type * as RemoteFeePayer from '../../../tempo/internal/remote-fee-payer.js';
+import type { StripeClient } from '../../internal/types.js';
+/**
+ * Creates an instance of a Stripe feepayer using an authenticated Stripe client.
+ *
+ * This compatibility path uses the Stripe client so that requests to the feepayer
+ * retain their authentication, timeouts, telemetry, and request events.
+ */
+export declare function create(client: StripeClient): RemoteFeePayer.Config;
+//# sourceMappingURL=hosted-fee-payer.d.ts.map