mppx 0.8.15 → 0.8.18

package/dist/server/Mppx.js

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from 'node:util';
+import * as AttestationServer from '../attestation/Server.js';
 import * as Challenge from '../Challenge.js';
 import * as Constants from '../Constants.js';
 import * as Credential from '../Credential.js';
@@ -6,7 +7,6 @@ import * as Errors from '../Errors.js';
 import * as Expires from '../Expires.js';
 import * as AcceptPayment from '../internal/AcceptPayment.js';
 import * as Env from '../internal/env.js';
-import * as Method from '../Method.js';
 import * as PaymentRequest from '../PaymentRequest.js';
 import * as x402_Header from '../x402/Header.js';
 import * as x402_Types from '../x402/Types.js';
@@ -52,21 +52,36 @@ export const reservedMppxKeys = new Set(reservedMppxKeyValues);
  * ```
  */
 export function create(config) {
-    const { realm = Env.get('realm'), secretKey = Env.get('secretKey'), transport = Transport.http(), } = config;
+    const { attestation, realm = Env.get('realm'), selectOffers, secretKey = Env.get('secretKey'), transport = Transport.http(), } = config;
     if (!secretKey) {
         throw new Error('Missing secret key. Set the MPP_SECRET_KEY environment variable or pass `secretKey` to Mppx.create().');
     }
     assertSecretKey(secretKey);
     const methods = config.methods.flat();
     const serverEvents = createServerEventDispatcher();
+    const verifyAttestation = attestation
+        ? createAttestationGuard(attestation)
+        : undefined;
     const handlers = {};
     const intentCount = {};
     for (const mi of methods) {
         intentCount[mi.intent] = (intentCount[mi.intent] ?? 0) + 1;
+        if (mi.onPaymentSuccess) {
+            serverEvents.on('payment.success', (async (ctx) => {
+                if (ctx.method.name === mi.name && ctx.method.intent === mi.intent) {
+                    await mi.onPaymentSuccess({
+                        input: ctx.input,
+                        receipt: ctx.receipt,
+                        request: ctx.request,
+                    });
+                }
+            }));
+        }
     }
     assertNoReservedMppxKeys(methods);
     for (const mi of methods) {
         const fn = createMethodFn({
+            ...(verifyAttestation && { attest: verifyAttestation }),
             authorize: mi.authorize,
             defaults: mi.defaults,
             method: mi,
@@ -91,10 +106,27 @@ export function create(config) {
         if (aliasKey)
             handlers[aliasKey] = fn;
     }
-    // Also set shorthand intent key when there's no collision
+    // Set shorthand intent key: single method gets direct handler,
+    // multiple methods get an implicit compose wrapper.
+    const processedIntents = new Set();
     for (const mi of methods) {
-        if (intentCount[mi.intent] === 1)
+        if (processedIntents.has(mi.intent))
+            continue;
+        processedIntents.add(mi.intent);
+        if (intentCount[mi.intent] === 1) {
             handlers[mi.intent] = handlers[`${mi.name}/${mi.intent}`];
+        }
+        else {
+            const intentMethods = methods.filter((m) => m.intent === mi.intent);
+            handlers[mi.intent] = (options) => {
+                const configured = intentMethods.map((m) => {
+                    const key = `${m.name}/${m.intent}`;
+                    const handlerFn = handlers[key];
+                    return handlerFn(options);
+                });
+                return composeHandlers(configured, undefined, selectOffers);
+            };
+        }
     }
     // Build nested handlers: mppx.tempo.charge(...)
     for (const mi of methods) {
@@ -123,7 +155,7 @@ export function create(config) {
         const emitFailures = parameters.emitFailures === true;
         const { method: credMethod, intent: credIntent } = credential.challenge;
         const methodCandidates = methods.filter((m) => m.name === credMethod && m.intent === credIntent);
-        const mi = Method.selectServerMethod(methodCandidates, credential.challenge);
+        const mi = methodCandidates[0];
         const eventMethod = mi ?? { intent: credIntent, name: credMethod };
         const emitStandalonePaymentFailed = async (failure) => {
             if (!emitFailures)
@@ -316,7 +348,7 @@ export function create(config) {
                 throw new Error(`No handler for "${key}". Is this method in your methods array?`);
             return handlerFn(options);
         });
-        return compose(...configured);
+        return composeHandlers(configured, undefined, selectOffers);
     }
     function onChallengeCreated(handler) {
         return serverEvents.on('challenge.created', handler);
@@ -351,7 +383,7 @@ function assertSecretKey(secretKey) {
 }
 // biome-ignore lint/correctness/noUnusedVariables: _
 function createMethodFn(parameters) {
-    const { authorize, defaults, events, method, preflight, realm, respond, secretKey, broadcast, stableBinding, transport, validate, verify, } = parameters;
+    const { attest, authorize, defaults, events, method, preflight, realm, respond, secretKey, broadcast, stableBinding, transport, validate, verify, } = parameters;
     return (options) => {
         const { description, meta, scope, ...rest } = options;
         const staticMeta = Scope.merge({ meta, scope });
@@ -366,7 +398,18 @@ function createMethodFn(parameters) {
             _canonicalRequest: PaymentRequest.fromMethod(method, { ...defaults, ...rest }),
             _stableBinding: stableBinding,
         };
+        Object.defineProperty(internal, '_method', { value: method });
         const handler = async (input) => {
+            if (attest && input instanceof globalThis.Request) {
+                const response = await attest(input);
+                if (response)
+                    return {
+                        status: 200,
+                        withReceipt() {
+                            return response;
+                        },
+                    };
+            }
             if (method.html && isServiceWorkerRequest(input))
                 return {
                     status: 402,
@@ -827,6 +870,33 @@ function createChallengeFn(parameters) {
         }).then((resolved) => resolved.challenge);
     };
 }
+function createAttestationGuard(verifiers) {
+    const entries = Object.entries(verifiers);
+    if (entries.length === 0)
+        throw new TypeError('Mppx server attestation must configure at least one verifier.');
+    const cache = new WeakMap();
+    return (request) => {
+        const cached = cache.get(request);
+        if (cached)
+            return cached;
+        const verification = AttestationServer.verify(request, verifiers).then((outcomes) => {
+            for (const [name, outcome] of Object.entries(outcomes))
+                if (outcome.status === 'invalid')
+                    return new globalThis.Response(`Request attestation "${name}" is invalid: ${outcome.reason}`, { status: 401 });
+            for (const [name, outcome] of Object.entries(outcomes)) {
+                if (outcome.status === 'verified')
+                    continue;
+                const reason = outcome.status === 'unverified'
+                    ? `Request attestation "${name}" could not be verified: ${outcome.reason}`
+                    : `Request attestation "${name}" is required.`;
+                return new globalThis.Response(reason, { status: 403 });
+            }
+            return undefined;
+        });
+        cache.set(request, verification);
+        return verification;
+    };
+}
 function createServerEventDispatcher() {
     const handlers = {
         '*': new Set(),
@@ -1303,9 +1373,20 @@ export function compose(...args) {
         })()
         : undefined;
     const handlers = (composeOptions ? args.slice(0, -1) : args);
+    return composeHandlers(handlers, composeOptions);
+}
+function composeHandlers(handlers, composeOptions, selectOffers) {
     if (handlers.length === 0)
         throw new Error('compose() requires at least one handler');
-    return async (input) => {
+    const offerSelector = selectOffers;
+    const offerEntries = handlers.map((handler) => {
+        const internal = handler._internal;
+        const offer = internal && !isComposedHandlerMetadata(internal) ? createServerOffer(internal) : undefined;
+        const method = internal && !isComposedHandlerMetadata(internal) ? internal._method : undefined;
+        return { handler, method, offer };
+    });
+    const hasOfferPolicy = offerSelector !== undefined || offerEntries.some(({ method }) => method?.canOffer !== undefined);
+    const composed = async (input) => {
         // Serve service worker for html-enabled compose
         if (new URL(input.url).searchParams.has(Html.params.serviceWorker)) {
             const hasHtml = handlers.some((h) => h._internal?.html);
@@ -1337,14 +1418,13 @@ export function compose(...args) {
                 const { method: credMethod, intent: credIntent } = credential.challenge;
                 const credReq = credential.challenge.request;
                 // Filter by name+intent, then narrow by comparing stable request fields
-                // from the echoed challenge against each handler's canonical request.
+                // from the echoed challenge against each handler's configured offers.
                 // Uses the schema-parsed canonical form (not raw options) so that
                 // transformed fields (e.g. amount with decimals) match correctly.
                 // Also checks inside methodDetails for fields moved there by transforms.
-                const candidates = handlers.filter((h) => {
+                const candidates = handlers.filter((handler) => getConfiguredOffers(handler).some((internal) => {
                     try {
-                        const internal = h._internal;
-                        if (!internal || internal.name !== credMethod || internal.intent !== credIntent)
+                        if (internal.name !== credMethod || internal.intent !== credIntent)
                             return false;
                         const mismatch = internal._stableBinding
                             ? getRequestBindingMismatch(getStableBinding(internal._canonicalRequest, internal._stableBinding), getStableBinding(credReq, internal._stableBinding))
@@ -1354,23 +1434,26 @@ export function compose(...args) {
                     catch {
                         return false;
                     }
-                });
+                }));
                 const match = candidates[0] ??
-                    handlers.find((h) => {
-                        const meta = h._internal;
-                        return meta?.name === credMethod && meta?.intent === credIntent;
-                    });
+                    handlers.find((handler) => getConfiguredOffers(handler).some((internal) => internal.name === credMethod && internal.intent === credIntent));
                 if (match)
                     return match(input);
             }
-            // Payment credential present but no matching handler — dispatch to first
-            // handler which will reject with an appropriate error (invalid challenge, etc.).
-            return handlers[0](input);
+            // Unrecognized or malformed credentials still use the currently eligible
+            // offer set before the first handler issues its rejection challenge.
         }
+        const selectedHandlers = hasOfferPolicy
+            ? await selectOfferHandlers({
+                entries: offerEntries,
+                input,
+                selectOffers: offerSelector,
+            })
+            : handlers;
         // No credential — evaluate handlers sequentially so authorize()/renewal hooks
         // can safely claim the request without racing each other.
         const results = [];
-        for (const handler of handlers) {
+        for (const handler of selectedHandlers) {
             const result = await handler(input);
             if (result.status === 200)
                 return result;
@@ -1378,7 +1461,7 @@ export function compose(...args) {
         }
         const challengeEntries = (() => {
             const entries = [];
-            for (let i = 0; i < handlers.length; i++) {
+            for (let i = 0; i < selectedHandlers.length; i++) {
                 const result = results[i];
                 if (result?.status !== 402)
                     continue;
@@ -1387,7 +1470,7 @@ export function compose(...args) {
                 if (!wwwAuth)
                     continue;
                 entries.push({
-                    handler: handlers[i],
+                    handler: selectedHandlers[i],
                     challenge: Challenge.deserialize(wwwAuth),
                     result,
                 });
@@ -1488,6 +1571,101 @@ export function compose(...args) {
             challenge: new Response(body, { status: 402, headers: mergedHeaders }),
         };
     };
+    const offers = handlers.flatMap(getConfiguredOffers);
+    if (offers.length > 0)
+        composed._internal = { offers };
+    return composed;
+}
+/** Returns the flattened configured offers accepted by a handler. */
+function getConfiguredOffers(handler) {
+    const internal = handler._internal;
+    if (!internal)
+        return [];
+    if (isComposedHandlerMetadata(internal))
+        return internal.offers;
+    return [internal];
+}
+function isComposedHandlerMetadata(internal) {
+    return 'offers' in internal && !('_canonicalRequest' in internal);
+}
+function createServerOffer(internal) {
+    return Object.freeze({
+        key: `${internal.name}/${internal.intent}`,
+        method: Object.freeze({
+            ...(internal._method.alias ? { alias: internal._method.alias } : {}),
+            intent: internal.intent,
+            name: internal.name,
+        }),
+        request: immutableSnapshot(internal._canonicalRequest),
+    });
+}
+/** Applies and validates the server-level offer selection policy. */
+async function selectOfferHandlers(parameters) {
+    const { entries, input, selectOffers } = parameters;
+    const eligibleEntries = [];
+    for (const entry of entries) {
+        const canOffer = entry.method?.canOffer;
+        if (canOffer) {
+            const approved = await canOffer({
+                input: cloneOfferInput(input),
+                request: entry.offer.request,
+            });
+            if (typeof approved !== 'boolean')
+                throw new Error('canOffer() must return a boolean');
+            if (!approved)
+                continue;
+        }
+        eligibleEntries.push(entry);
+    }
+    if (eligibleEntries.length === 0)
+        throw new Error('No payment offers are available for this request');
+    if (!selectOffers)
+        return eligibleEntries.map(({ handler }) => handler);
+    const offers = eligibleEntries.map(({ offer }) => {
+        if (!offer)
+            throw new Error('selectOffers() can only select configured payment offers');
+        return offer;
+    });
+    const selected = await selectOffers(Object.freeze(offers), Object.freeze({ request: cloneOfferInput(input) }));
+    if (!Array.isArray(selected))
+        throw new Error('selectOffers() must return an array of offers');
+    if (selected.length === 0)
+        throw new Error('selectOffers() must select at least one offer');
+    let previousIndex = -1;
+    const selectedHandlers = selected.map((offer) => {
+        const index = offers.indexOf(offer);
+        if (index === -1)
+            throw new Error('selectOffers() must return only offers from its input array');
+        if (index <= previousIndex)
+            throw new Error('selectOffers() must preserve offer order and must not return duplicates');
+        previousIndex = index;
+        return eligibleEntries[index].handler;
+    });
+    return selectedHandlers;
+}
+/** Clones a request for offer hooks, falling back to a bodyless metadata copy. */
+function cloneOfferInput(input) {
+    try {
+        return input.clone();
+    }
+    catch {
+        return new globalThis.Request(input.url, {
+            headers: new Headers(input.headers),
+            method: input.method,
+            signal: input.signal,
+        });
+    }
+}
+/** Clones and recursively freezes protocol data exposed to offer hooks. */
+function immutableSnapshot(value) {
+    return deepFreeze(structuredClone(value));
+}
+function deepFreeze(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    for (const nested of Object.values(value))
+        deepFreeze(nested);
+    return Object.freeze(value);
 }
 function mergeX402PaymentRequiredHeaders(values) {
     if (values.length === 0)

package/dist/server/core.d.ts

@@ -0,0 +1,9 @@
+export * as Constants from '../Constants.js';
+export * as Expires from '../Expires.js';
+export * as Store from '../Store.js';
+export * as Mppx from './Mppx.js';
+export * as NodeListener from './NodeListener.js';
+export * as Request from './Request.js';
+export * as Response from './Response.js';
+export * as Transport from './Transport.js';
+//# sourceMappingURL=core.d.ts.map

package/dist/server/core.js

@@ -0,0 +1,9 @@
+export * as Constants from '../Constants.js';
+export * as Expires from '../Expires.js';
+export * as Store from '../Store.js';
+export * as Mppx from './Mppx.js';
+export * as NodeListener from './NodeListener.js';
+export * as Request from './Request.js';
+export * as Response from './Response.js';
+export * as Transport from './Transport.js';
+//# sourceMappingURL=core.js.map

package/dist/server/internal/html/config.d.ts

@@ -41,10 +41,10 @@ export declare const vars: {
     readonly spacingUnit: CssVar;
 };
 export declare const defaultText: {
-    readonly expires: "Expires at";
-    readonly pay: "Pay";
-    readonly paymentRequired: "Payment Required";
-    readonly title: "Payment Required";
+    readonly expires: 'Expires at';
+    readonly pay: 'Pay';
+    readonly paymentRequired: 'Payment Required';
+    readonly title: 'Payment Required';
 };
 export type Text = {
     /** Prefix for the expiry line. @default 'Expires at' */
@@ -57,11 +57,11 @@ export type Text = {
     title?: string | undefined;
 };
 export declare const defaultTheme: {
-    readonly colorScheme: "light dark";
-    readonly fontFamily: "system-ui, -apple-system, sans-serif";
-    readonly fontSizeBase: "16px";
-    readonly radius: "6px";
-    readonly spacingUnit: "2px";
+    readonly colorScheme: 'light dark';
+    readonly fontFamily: 'system-ui, -apple-system, sans-serif';
+    readonly fontSizeBase: '16px';
+    readonly radius: '6px';
+    readonly spacingUnit: '2px';
     readonly accent: readonly ["#171717", "#ededed"];
     readonly background: readonly ["#ffffff", "#0a0a0a"];
     readonly border: readonly ["#e5e5e5", "#2e2e2e"];

package/dist/server/internal/html/constants.d.ts

@@ -1,26 +1,26 @@
 export declare const ids: {
-    readonly data: "__MPPX_DATA__";
-    readonly error: "root_error";
-    readonly root: "root";
+    readonly data: '__MPPX_DATA__';
+    readonly error: 'root_error';
+    readonly root: 'root';
 };
 export declare const params: {
-    readonly serviceWorker: "__mppx_worker";
-    readonly tab: "__mppx_tab";
+    readonly serviceWorker: '__mppx_worker';
+    readonly tab: '__mppx_tab';
 };
 export declare const attrs: {
-    readonly challengeId: "data-mppx-challenge-id";
-    readonly remaining: "data-remaining";
+    readonly challengeId: 'data-mppx-challenge-id';
+    readonly remaining: 'data-remaining';
 };
 export declare const classNames: {
-    readonly error: "mppx-error";
-    readonly header: "mppx-header";
-    readonly logo: "mppx-logo";
-    readonly summary: "mppx-summary";
-    readonly summaryAmount: "mppx-summary-amount";
-    readonly summaryDescription: "mppx-summary-description";
-    readonly summaryExpires: "mppx-summary-expires";
-    readonly tab: "mppx-tab";
-    readonly tabList: "mppx-tablist";
-    readonly tabPanel: "mppx-tabpanel";
+    readonly error: 'mppx-error';
+    readonly header: 'mppx-header';
+    readonly logo: 'mppx-logo';
+    readonly summary: 'mppx-summary';
+    readonly summaryAmount: 'mppx-summary-amount';
+    readonly summaryDescription: 'mppx-summary-description';
+    readonly summaryExpires: 'mppx-summary-expires';
+    readonly tab: 'mppx-tab';
+    readonly tabList: 'mppx-tablist';
+    readonly tabPanel: 'mppx-tabpanel';
 };
 //# sourceMappingURL=constants.d.ts.map

package/dist/stripe/Methods.d.ts

@@ -8,13 +8,13 @@ export declare const charge: {
     readonly name: "stripe";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniObject<{
+        credential: {
+            payload: z.ZodMiniObject<{
                 externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 spt: z.ZodMiniString<string>;
             }, z.core.$strip>;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        request: z.ZodMiniPipe<z.ZodMiniObject<{
             amount: z.ZodMiniString<string>;
             currency: z.ZodMiniString<string>;
             decimals: z.ZodMiniNumber<number>;
@@ -25,25 +25,25 @@ export declare const charge: {
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
+            currency: string;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            recipient?: string | undefined;
             amount: string;
             methodDetails: {
-                metadata?: Record<string, string> | undefined;
                 networkId: string;
                 paymentMethodTypes: string[];
+                metadata?: Record<string, string> | undefined;
             };
-            currency: string;
-            description?: string | undefined;
-            externalId?: string | undefined;
-            recipient?: string | undefined;
         }, {
             amount: string;
             currency: string;
             decimals: number;
-            networkId: string;
-            paymentMethodTypes: string[];
             description?: string | undefined;
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
+            networkId: string;
+            paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;
     };

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

@@ -41,13 +41,13 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
     readonly name: "stripe";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniObject<{
+        credential: {
+            payload: z.ZodMiniObject<{
                 externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 spt: z.ZodMiniString<string>;
             }, z.core.$strip>;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        request: z.ZodMiniPipe<z.ZodMiniObject<{
             amount: z.ZodMiniString<string>;
             currency: z.ZodMiniString<string>;
             decimals: z.ZodMiniNumber<number>;
@@ -58,25 +58,25 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
+            currency: string;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            recipient?: string | undefined;
             amount: string;
             methodDetails: {
-                metadata?: Record<string, string> | undefined;
                 networkId: string;
                 paymentMethodTypes: string[];
+                metadata?: Record<string, string> | undefined;
             };
-            currency: string;
-            description?: string | undefined;
-            externalId?: string | undefined;
-            recipient?: string | undefined;
         }, {
             amount: string;
             currency: string;
             decimals: number;
-            networkId: string;
-            paymentMethodTypes: string[];
             description?: string | undefined;
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
+            networkId: string;
+            paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;
     };

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

@@ -28,13 +28,13 @@ export declare function stripe(parameters: stripe.Parameters): readonly [import(
     readonly name: "stripe";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: import("zod/mini").ZodMiniObject<{
+        credential: {
+            payload: import("zod/mini").ZodMiniObject<{
                 externalId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 spt: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>;
         };
-        readonly request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+        request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
             amount: import("zod/mini").ZodMiniString<string>;
             currency: import("zod/mini").ZodMiniString<string>;
             decimals: import("zod/mini").ZodMiniNumber<number>;
@@ -45,25 +45,25 @@ export declare function stripe(parameters: stripe.Parameters): readonly [import(
             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<{
+            currency: string;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            recipient?: string | undefined;
             amount: string;
             methodDetails: {
-                metadata?: Record<string, string> | undefined;
                 networkId: string;
                 paymentMethodTypes: string[];
+                metadata?: Record<string, string> | undefined;
             };
-            currency: string;
-            description?: string | undefined;
-            externalId?: string | undefined;
-            recipient?: string | undefined;
         }, {
             amount: string;
             currency: string;
             decimals: number;
-            networkId: string;
-            paymentMethodTypes: string[];
             description?: string | undefined;
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
+            networkId: string;
+            paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;
     };

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

@@ -4,5 +4,5 @@
  * Required for `shared_payment_granted_token` (SPTs are in private preview).
  * Bump this when upgrading to a newer Stripe API version.
  */
-export declare const stripePreviewVersion = "2026-02-25.preview";
+export declare const stripePreviewVersion = "2026-07-29.preview";
 //# sourceMappingURL=constants.d.ts.map

package/dist/stripe/internal/constants.js

@@ -4,5 +4,5 @@
  * Required for `shared_payment_granted_token` (SPTs are in private preview).
  * Bump this when upgrading to a newer Stripe API version.
  */
-export const stripePreviewVersion = '2026-02-25.preview';
+export const stripePreviewVersion = '2026-07-29.preview';
 //# sourceMappingURL=constants.js.map

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

@@ -15,6 +15,7 @@ export type StripeClient = {
             };
         }>;
     };
+    rawRequest?(method: string, path: string, params?: any, options?: any): Promise<any>;
 };
 /**
  * Duck-typed interface for Stripe.js (`@stripe/stripe-js`).