@dodopayments/nextjs 0.3.0 → 0.3.2

package/dist/index.js

@@ -24,10 +24,9 @@ var detectDomainLocale = {};
 	        detectedLocale = detectedLocale.toLowerCase();
 	    }
 	    for (const item of domainItems){
-	        var _item_domain, _item_locales;
 	        // remove port if present
-	        const domainHostname = (_item_domain = item.domain) == null ? void 0 : _item_domain.split(':', 1)[0].toLowerCase();
-	        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || ((_item_locales = item.locales) == null ? void 0 : _item_locales.some((locale)=>locale.toLowerCase() === detectedLocale))) {
+	        const domainHostname = item.domain?.split(':', 1)[0].toLowerCase();
+	        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || item.locales?.some((locale)=>locale.toLowerCase() === detectedLocale)) {
 	            return item;
 	        }
 	    }
@@ -122,7 +121,7 @@ var parsePath = {};
 	        return path;
 	    }
 	    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
-	    return "" + prefix + pathname + query + hash;
+	    return `${prefix}${pathname}${query}${hash}`;
 	}
 
 	
@@ -146,7 +145,7 @@ var addPathSuffix = {};
 	        return path;
 	    }
 	    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
-	    return "" + pathname + suffix + query + hash;
+	    return `${pathname}${suffix}${query}${hash}`;
 	}
 
 	
@@ -199,10 +198,10 @@ var pathHasPrefix = {};
 	    // don't need to prefix the path.
 	    if (!ignorePrefix) {
 	        if ((0, _pathhasprefix.pathHasPrefix)(lower, '/api')) return path;
-	        if ((0, _pathhasprefix.pathHasPrefix)(lower, "/" + locale.toLowerCase())) return path;
+	        if ((0, _pathhasprefix.pathHasPrefix)(lower, `/${locale.toLowerCase()}`)) return path;
 	    }
 	    // Add the locale prefix to the path.
-	    return (0, _addpathprefix.addPathPrefix)(path, "/" + locale);
+	    return (0, _addpathprefix.addPathPrefix)(path, `/${locale}`);
 	}
 
 	
@@ -228,7 +227,7 @@ var pathHasPrefix = {};
 	        pathname = (0, _removetrailingslash.removeTrailingSlash)(pathname);
 	    }
 	    if (info.buildId) {
-	        pathname = (0, _addpathsuffix.addPathSuffix)((0, _addpathprefix.addPathPrefix)(pathname, "/_next/data/" + info.buildId), info.pathname === '/' ? 'index.json' : '.json');
+	        pathname = (0, _addpathsuffix.addPathSuffix)((0, _addpathprefix.addPathPrefix)(pathname, `/_next/data/${info.buildId}`), info.pathname === '/' ? 'index.json' : '.json');
 	    }
 	    pathname = (0, _addpathprefix.addPathPrefix)(pathname, info.basePath);
 	    return !info.buildId && info.trailingSlash ? !pathname.endsWith('/') ? (0, _addpathsuffix.addPathSuffix)(pathname, '/') : pathname : (0, _removetrailingslash.removeTrailingSlash)(pathname);
@@ -253,7 +252,7 @@ var getHostname = {};
 	    // Get the hostname from the headers if it exists, otherwise use the parsed
 	    // hostname.
 	    let hostname;
-	    if ((headers == null ? void 0 : headers.host) && !Array.isArray(headers.host)) {
+	    if (headers?.host && !Array.isArray(headers.host)) {
 	        hostname = headers.host.toString().split(':', 1)[0];
 	    } else if (parsed.hostname) {
 	        hostname = parsed.hostname;
@@ -361,7 +360,7 @@ var removePathPrefix = {};
 	    }
 	    // If the path without the prefix doesn't start with a `/` we need to add it
 	    // back to the path to make sure it's a valid path.
-	    return "/" + withoutPrefix;
+	    return `/${withoutPrefix}`;
 	}
 
 	
@@ -381,8 +380,7 @@ var removePathPrefix = {};
 	const _removepathprefix = removePathPrefix;
 	const _pathhasprefix = pathHasPrefix;
 	function getNextPathnameInfo(pathname, options) {
-	    var _options_nextConfig;
-	    const { basePath, i18n, trailingSlash } = (_options_nextConfig = options.nextConfig) != null ? _options_nextConfig : {};
+	    const { basePath, i18n, trailingSlash } = options.nextConfig ?? {};
 	    const info = {
 	        pathname,
 	        trailingSlash: pathname !== '/' ? pathname.endsWith('/') : trailingSlash
@@ -396,7 +394,7 @@ var removePathPrefix = {};
 	        const paths = info.pathname.replace(/^\/_next\/data\//, '').replace(/\.json$/, '').split('/');
 	        const buildId = paths[0];
 	        info.buildId = buildId;
-	        pathnameNoDataPrefix = paths[1] !== 'index' ? "/" + paths.slice(1).join('/') : '/';
+	        pathnameNoDataPrefix = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/';
 	        // update pathname with normalized if enabled although
 	        // we use normalized to populate locale info still
 	        if (options.parseData === true) {
@@ -408,8 +406,7 @@ var removePathPrefix = {};
 	    if (i18n) {
 	        let result = options.i18nProvider ? options.i18nProvider.analyze(info.pathname) : (0, _normalizelocalepath.normalizeLocalePath)(info.pathname, i18n.locales);
 	        info.locale = result.detectedLocale;
-	        var _result_pathname;
-	        info.pathname = (_result_pathname = result.pathname) != null ? _result_pathname : info.pathname;
+	        info.pathname = result.pathname ?? info.pathname;
 	        if (!result.detectedLocale && info.buildId) {
 	            result = options.i18nProvider ? options.i18nProvider.analyze(pathnameNoDataPrefix) : (0, _normalizelocalepath.normalizeLocalePath)(pathnameNoDataPrefix, i18n.locales);
 	            if (result.detectedLocale) {
@@ -659,12 +656,18 @@ var constants = {};
 	    GSSP_NO_RETURNED_VALUE: function() {
 	        return GSSP_NO_RETURNED_VALUE;
 	    },
+	    HTML_CONTENT_TYPE_HEADER: function() {
+	        return HTML_CONTENT_TYPE_HEADER;
+	    },
 	    INFINITE_CACHE: function() {
 	        return INFINITE_CACHE;
 	    },
 	    INSTRUMENTATION_HOOK_FILENAME: function() {
 	        return INSTRUMENTATION_HOOK_FILENAME;
 	    },
+	    JSON_CONTENT_TYPE_HEADER: function() {
+	        return JSON_CONTENT_TYPE_HEADER;
+	    },
 	    MATCHED_PATH_HEADER: function() {
 	        return MATCHED_PATH_HEADER;
 	    },
@@ -725,6 +728,12 @@ var constants = {};
 	    PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER: function() {
 	        return PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER;
 	    },
+	    PROXY_FILENAME: function() {
+	        return PROXY_FILENAME;
+	    },
+	    PROXY_LOCATION_REGEXP: function() {
+	        return PROXY_LOCATION_REGEXP;
+	    },
 	    PUBLIC_DIR_MIDDLEWARE_CONFLICT: function() {
 	        return PUBLIC_DIR_MIDDLEWARE_CONFLICT;
 	    },
@@ -785,6 +794,9 @@ var constants = {};
 	    STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR: function() {
 	        return STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR;
 	    },
+	    TEXT_PLAIN_CONTENT_TYPE_HEADER: function() {
+	        return TEXT_PLAIN_CONTENT_TYPE_HEADER;
+	    },
 	    UNSTABLE_REVALIDATE_RENAME_ERROR: function() {
 	        return UNSTABLE_REVALIDATE_RENAME_ERROR;
 	    },
@@ -793,8 +805,14 @@ var constants = {};
 	    },
 	    WEBPACK_RESOURCE_QUERIES: function() {
 	        return WEBPACK_RESOURCE_QUERIES;
+	    },
+	    WEB_SOCKET_MAX_RECONNECTIONS: function() {
+	        return WEB_SOCKET_MAX_RECONNECTIONS;
 	    }
 	});
+	const TEXT_PLAIN_CONTENT_TYPE_HEADER = 'text/plain';
+	const HTML_CONTENT_TYPE_HEADER = 'text/html; charset=utf-8';
+	const JSON_CONTENT_TYPE_HEADER = 'application/json; charset=utf-8';
 	const NEXT_QUERY_PARAM_PREFIX = 'nxtP';
 	const NEXT_INTERCEPTION_MARKER_PREFIX = 'nxtI';
 	const MATCHED_PATH_HEADER = 'x-matched-path';
@@ -820,6 +838,8 @@ var constants = {};
 	const INFINITE_CACHE = 0xfffffffe;
 	const MIDDLEWARE_FILENAME = 'middleware';
 	const MIDDLEWARE_LOCATION_REGEXP = `(?:src/)?${MIDDLEWARE_FILENAME}`;
+	const PROXY_FILENAME = 'proxy';
+	const PROXY_LOCATION_REGEXP = `(?:src/)?${PROXY_FILENAME}`;
 	const INSTRUMENTATION_HOOK_FILENAME = 'instrumentation';
 	const PAGES_DIR_ALIAS = 'private-next-pages';
 	const DOT_NEXT_ALIAS = 'private-dot-next';
@@ -856,6 +876,7 @@ var constants = {};
 	    experimentalEdge: 'experimental-edge',
 	    nodejs: 'nodejs'
 	};
+	const WEB_SOCKET_MAX_RECONNECTIONS = 12;
 	/**
 	 * The names of the webpack layers. These layers are the primitives for the
 	 * webpack chunks.
@@ -1941,7 +1962,8 @@ var asyncLocalStorage = {};
 	    }
 	    return new FakeAsyncLocalStorage();
 	}
-	function bindSnapshot(fn) {
+	function bindSnapshot(// WARNING: Don't pass a named function to this argument! See: https://github.com/facebook/react/pull/34911
+	fn) {
 	    if (maybeGlobalAsyncLocalStorage) {
 	        return maybeGlobalAsyncLocalStorage.bind(fn);
 	    }
@@ -2093,9 +2115,15 @@ var appRouterHeaders = {exports: {}};
 	    NEXT_HMR_REFRESH_HEADER: function() {
 	        return NEXT_HMR_REFRESH_HEADER;
 	    },
+	    NEXT_HTML_REQUEST_ID_HEADER: function() {
+	        return NEXT_HTML_REQUEST_ID_HEADER;
+	    },
 	    NEXT_IS_PRERENDER_HEADER: function() {
 	        return NEXT_IS_PRERENDER_HEADER;
 	    },
+	    NEXT_REQUEST_ID_HEADER: function() {
+	        return NEXT_REQUEST_ID_HEADER;
+	    },
 	    NEXT_REWRITTEN_PATH_HEADER: function() {
 	        return NEXT_REWRITTEN_PATH_HEADER;
 	    },
@@ -2127,14 +2155,14 @@ var appRouterHeaders = {exports: {}};
 	        return RSC_HEADER;
 	    }
 	});
-	const RSC_HEADER = 'RSC';
-	const ACTION_HEADER = 'Next-Action';
-	const NEXT_ROUTER_STATE_TREE_HEADER = 'Next-Router-State-Tree';
-	const NEXT_ROUTER_PREFETCH_HEADER = 'Next-Router-Prefetch';
-	const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'Next-Router-Segment-Prefetch';
-	const NEXT_HMR_REFRESH_HEADER = 'Next-HMR-Refresh';
+	const RSC_HEADER = 'rsc';
+	const ACTION_HEADER = 'next-action';
+	const NEXT_ROUTER_STATE_TREE_HEADER = 'next-router-state-tree';
+	const NEXT_ROUTER_PREFETCH_HEADER = 'next-router-prefetch';
+	const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = 'next-router-segment-prefetch';
+	const NEXT_HMR_REFRESH_HEADER = 'next-hmr-refresh';
 	const NEXT_HMR_REFRESH_HASH_COOKIE = '__next_hmr_refresh_hash__';
-	const NEXT_URL = 'Next-Url';
+	const NEXT_URL = 'next-url';
 	const RSC_CONTENT_TYPE_HEADER = 'text/x-component';
 	const FLIGHT_HEADERS = [
 	    RSC_HEADER,
@@ -2150,6 +2178,8 @@ var appRouterHeaders = {exports: {}};
 	const NEXT_REWRITTEN_QUERY_HEADER = 'x-nextjs-rewritten-query';
 	const NEXT_IS_PRERENDER_HEADER = 'x-nextjs-prerender';
 	const NEXT_ACTION_NOT_FOUND_HEADER = 'x-nextjs-action-not-found';
+	const NEXT_REQUEST_ID_HEADER = 'x-nextjs-request-id';
+	const NEXT_HTML_REQUEST_ID_HEADER = 'x-nextjs-html-request-id';
 
 	if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
 	  Object.defineProperty(exports.default, '__esModule', { value: true });
@@ -2162,6 +2192,28 @@ var appRouterHeaders = {exports: {}};
 
 var appRouterHeadersExports = appRouterHeaders.exports;
 
+var invariantError = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	Object.defineProperty(exports, "InvariantError", {
+	    enumerable: true,
+	    get: function() {
+	        return InvariantError;
+	    }
+	});
+	class InvariantError extends Error {
+	    constructor(message, options){
+	        super(`Invariant: ${message.endsWith('.') ? message : message + '.'} This is a bug in Next.js.`, options);
+	        this.name = 'InvariantError';
+	    }
+	}
+
+	
+} (invariantError));
+
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", {
 	    value: true
@@ -2173,12 +2225,12 @@ var appRouterHeadersExports = appRouterHeaders.exports;
 	    });
 	}
 	_export(exports, {
+	    getCacheSignal: function() {
+	        return getCacheSignal;
+	    },
 	    getDraftModeProviderForCacheScope: function() {
 	        return getDraftModeProviderForCacheScope;
 	    },
-	    getExpectedRequestStore: function() {
-	        return getExpectedRequestStore;
-	    },
 	    getHmrRefreshHash: function() {
 	        return getHmrRefreshHash;
 	    },
@@ -2188,50 +2240,28 @@ var appRouterHeadersExports = appRouterHeaders.exports;
 	    getRenderResumeDataCache: function() {
 	        return getRenderResumeDataCache;
 	    },
+	    getRuntimeStagePromise: function() {
+	        return getRuntimeStagePromise;
+	    },
+	    getServerComponentsHmrCache: function() {
+	        return getServerComponentsHmrCache;
+	    },
+	    isHmrRefresh: function() {
+	        return isHmrRefresh;
+	    },
 	    throwForMissingRequestStore: function() {
 	        return throwForMissingRequestStore;
 	    },
+	    throwInvariantForMissingStore: function() {
+	        return throwInvariantForMissingStore;
+	    },
 	    workUnitAsyncStorage: function() {
 	        return _workunitasyncstorageinstance.workUnitAsyncStorageInstance;
 	    }
 	});
 	const _workunitasyncstorageinstance = workUnitAsyncStorageInstance;
 	const _approuterheaders = appRouterHeadersExports;
-	function getExpectedRequestStore(callingExpression) {
-	    const workUnitStore = _workunitasyncstorageinstance.workUnitAsyncStorageInstance.getStore();
-	    if (!workUnitStore) {
-	        throwForMissingRequestStore(callingExpression);
-	    }
-	    switch(workUnitStore.type){
-	        case 'request':
-	            return workUnitStore;
-	        case 'prerender':
-	        case 'prerender-client':
-	        case 'prerender-ppr':
-	        case 'prerender-legacy':
-	            // This should not happen because we should have checked it already.
-	            throw Object.defineProperty(new Error(`\`${callingExpression}\` cannot be called inside a prerender. This is a bug in Next.js.`), "__NEXT_ERROR_CODE", {
-	                value: "E401",
-	                enumerable: false,
-	                configurable: true
-	            });
-	        case 'cache':
-	            throw Object.defineProperty(new Error(`\`${callingExpression}\` cannot be called inside "use cache". Call it outside and pass an argument instead. Read more: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-	                value: "E37",
-	                enumerable: false,
-	                configurable: true
-	            });
-	        case 'unstable-cache':
-	            throw Object.defineProperty(new Error(`\`${callingExpression}\` cannot be called inside unstable_cache. Call it outside and pass an argument instead. Read more: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
-	                value: "E69",
-	                enumerable: false,
-	                configurable: true
-	            });
-	        default:
-	            const _exhaustiveCheck = workUnitStore;
-	            return _exhaustiveCheck;
-	    }
-	}
+	const _invarianterror = invariantError;
 	function throwForMissingRequestStore(callingExpression) {
 	    throw Object.defineProperty(new Error(`\`${callingExpression}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
 	        value: "E251",
@@ -2239,18 +2269,45 @@ var appRouterHeadersExports = appRouterHeaders.exports;
 	        configurable: true
 	    });
 	}
+	function throwInvariantForMissingStore() {
+	    throw Object.defineProperty(new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.'), "__NEXT_ERROR_CODE", {
+	        value: "E696",
+	        enumerable: false,
+	        configurable: true
+	    });
+	}
 	function getPrerenderResumeDataCache(workUnitStore) {
-	    if (workUnitStore.type === 'prerender' || // TODO eliminate fetch caching in client scope and stop exposing this data cache during SSR
-	    workUnitStore.type === 'prerender-client' || workUnitStore.type === 'prerender-ppr') {
-	        return workUnitStore.prerenderResumeDataCache;
+	    switch(workUnitStore.type){
+	        case 'prerender':
+	        case 'prerender-runtime':
+	        case 'prerender-ppr':
+	            return workUnitStore.prerenderResumeDataCache;
+	        case 'prerender-client':
+	            // TODO eliminate fetch caching in client scope and stop exposing this data
+	            // cache during SSR.
+	            return workUnitStore.prerenderResumeDataCache;
+	        case 'request':
+	            {
+	                // In dev, we might fill caches even during a dynamic request.
+	                if (workUnitStore.prerenderResumeDataCache) {
+	                    return workUnitStore.prerenderResumeDataCache;
+	                }
+	            // fallthrough
+	            }
+	        case 'prerender-legacy':
+	        case 'cache':
+	        case 'private-cache':
+	        case 'unstable-cache':
+	            return null;
+	        default:
+	            return workUnitStore;
 	    }
-	    return null;
 	}
 	function getRenderResumeDataCache(workUnitStore) {
 	    switch(workUnitStore.type){
 	        case 'request':
-	            return workUnitStore.renderResumeDataCache;
 	        case 'prerender':
+	        case 'prerender-runtime':
 	        case 'prerender-client':
 	            if (workUnitStore.renderResumeDataCache) {
 	                // If we are in a prerender, we might have a render resume data cache
@@ -2261,31 +2318,107 @@ var appRouterHeadersExports = appRouterHeaders.exports;
 	        case 'prerender-ppr':
 	            // Otherwise we return the mutable resume data cache here as an immutable
 	            // version of the cache as it can also be used for reading.
-	            return workUnitStore.prerenderResumeDataCache;
-	        default:
+	            return workUnitStore.prerenderResumeDataCache ?? null;
+	        case 'cache':
+	        case 'private-cache':
+	        case 'unstable-cache':
+	        case 'prerender-legacy':
 	            return null;
+	        default:
+	            return workUnitStore;
 	    }
 	}
 	function getHmrRefreshHash(workStore, workUnitStore) {
-	    var _workUnitStore_cookies_get;
-	    if (!workStore.dev) {
-	        return undefined;
+	    if (workStore.dev) {
+	        switch(workUnitStore.type){
+	            case 'cache':
+	            case 'private-cache':
+	            case 'prerender':
+	            case 'prerender-runtime':
+	                return workUnitStore.hmrRefreshHash;
+	            case 'request':
+	                var _workUnitStore_cookies_get;
+	                return (_workUnitStore_cookies_get = workUnitStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _workUnitStore_cookies_get.value;
+	        }
+	    }
+	    return undefined;
+	}
+	function isHmrRefresh(workStore, workUnitStore) {
+	    if (workStore.dev) {
+	        switch(workUnitStore.type){
+	            case 'cache':
+	            case 'private-cache':
+	            case 'request':
+	                return workUnitStore.isHmrRefresh ?? false;
+	        }
+	    }
+	    return false;
+	}
+	function getServerComponentsHmrCache(workStore, workUnitStore) {
+	    if (workStore.dev) {
+	        switch(workUnitStore.type){
+	            case 'cache':
+	            case 'private-cache':
+	            case 'request':
+	                return workUnitStore.serverComponentsHmrCache;
+	        }
 	    }
-	    return workUnitStore.type === 'cache' || workUnitStore.type === 'prerender' ? workUnitStore.hmrRefreshHash : workUnitStore.type === 'request' ? (_workUnitStore_cookies_get = workUnitStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _workUnitStore_cookies_get.value : undefined;
+	    return undefined;
 	}
 	function getDraftModeProviderForCacheScope(workStore, workUnitStore) {
 	    if (workStore.isDraftMode) {
 	        switch(workUnitStore.type){
 	            case 'cache':
+	            case 'private-cache':
 	            case 'unstable-cache':
+	            case 'prerender-runtime':
 	            case 'request':
 	                return workUnitStore.draftMode;
-	            default:
-	                return undefined;
 	        }
 	    }
 	    return undefined;
 	}
+	function getCacheSignal(workUnitStore) {
+	    switch(workUnitStore.type){
+	        case 'prerender':
+	        case 'prerender-client':
+	        case 'prerender-runtime':
+	            return workUnitStore.cacheSignal;
+	        case 'request':
+	            {
+	                // In dev, we might fill caches even during a dynamic request.
+	                if (workUnitStore.cacheSignal) {
+	                    return workUnitStore.cacheSignal;
+	                }
+	            // fallthrough
+	            }
+	        case 'prerender-ppr':
+	        case 'prerender-legacy':
+	        case 'cache':
+	        case 'private-cache':
+	        case 'unstable-cache':
+	            return null;
+	        default:
+	            return workUnitStore;
+	    }
+	}
+	function getRuntimeStagePromise(workUnitStore) {
+	    switch(workUnitStore.type){
+	        case 'prerender-runtime':
+	        case 'private-cache':
+	            return workUnitStore.runtimeStagePromise;
+	        case 'prerender':
+	        case 'prerender-client':
+	        case 'prerender-ppr':
+	        case 'prerender-legacy':
+	        case 'request':
+	        case 'cache':
+	        case 'unstable-cache':
+	            return null;
+	        default:
+	            return workUnitStore;
+	    }
+	}
 
 	
 } (workUnitAsyncStorage_external));
@@ -4172,7 +4305,7 @@ var hooksServerContext = {exports: {}};
 	const DYNAMIC_ERROR_CODE = 'DYNAMIC_SERVER_USAGE';
 	class DynamicServerError extends Error {
 	    constructor(description){
-	        super("Dynamic server usage: " + description), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
+	        super(`Dynamic server usage: ${description}`), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
 	    }
 	}
 	function isDynamicServerError(err) {
@@ -4253,6 +4386,9 @@ var dynamicRenderingUtils = {};
 	    isHangingPromiseRejectionError: function() {
 	        return isHangingPromiseRejectionError;
 	    },
+	    makeDevtoolsIOAwarePromise: function() {
+	        return makeDevtoolsIOAwarePromise;
+	    },
 	    makeHangingPromise: function() {
 	        return makeHangingPromise;
 	    }
@@ -4265,17 +4401,17 @@ var dynamicRenderingUtils = {};
 	}
 	const HANGING_PROMISE_REJECTION = 'HANGING_PROMISE_REJECTION';
 	class HangingPromiseRejectionError extends Error {
-	    constructor(expression){
-	        super(`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context.`), this.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
+	    constructor(route, expression){
+	        super(`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context. This occurred at route "${route}".`), this.route = route, this.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
 	    }
 	}
 	const abortListenersBySignal = new WeakMap();
-	function makeHangingPromise(signal, expression) {
+	function makeHangingPromise(signal, route, expression) {
 	    if (signal.aborted) {
-	        return Promise.reject(new HangingPromiseRejectionError(expression));
+	        return Promise.reject(new HangingPromiseRejectionError(route, expression));
 	    } else {
 	        const hangingPromise = new Promise((_, reject)=>{
-	            const boundRejection = reject.bind(null, new HangingPromiseRejectionError(expression));
+	            const boundRejection = reject.bind(null, new HangingPromiseRejectionError(route, expression));
 	            let currentListeners = abortListenersBySignal.get(signal);
 	            if (currentListeners) {
 	                currentListeners.push(boundRejection);
@@ -4301,11 +4437,25 @@ var dynamicRenderingUtils = {};
 	    }
 	}
 	function ignoreReject() {}
+	function makeDevtoolsIOAwarePromise(underlying, requestStore, stage) {
+	    if (requestStore.stagedRendering) {
+	        // We resolve each stage in a timeout, so React DevTools will pick this up as IO.
+	        return requestStore.stagedRendering.delayUntilStage(stage, undefined, underlying);
+	    }
+	    // in React DevTools if we resolve in a setTimeout we will observe
+	    // the promise resolution as something that can suspend a boundary or root.
+	    return new Promise((resolve)=>{
+	        // Must use setTimeout to be considered IO React DevTools. setImmediate will not work.
+	        setTimeout(()=>{
+	            resolve(underlying);
+	        }, 0);
+	    });
+	}
 
 	
 } (dynamicRenderingUtils));
 
-var metadataConstants = {};
+var boundaryConstants = {};
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", {
@@ -4324,6 +4474,9 @@ var metadataConstants = {};
 	    OUTLET_BOUNDARY_NAME: function() {
 	        return OUTLET_BOUNDARY_NAME;
 	    },
+	    ROOT_LAYOUT_BOUNDARY_NAME: function() {
+	        return ROOT_LAYOUT_BOUNDARY_NAME;
+	    },
 	    VIEWPORT_BOUNDARY_NAME: function() {
 	        return VIEWPORT_BOUNDARY_NAME;
 	    }
@@ -4331,9 +4484,10 @@ var metadataConstants = {};
 	const METADATA_BOUNDARY_NAME = '__next_metadata_boundary__';
 	const VIEWPORT_BOUNDARY_NAME = '__next_viewport_boundary__';
 	const OUTLET_BOUNDARY_NAME = '__next_outlet_boundary__';
+	const ROOT_LAYOUT_BOUNDARY_NAME = '__next_root_layout_boundary__';
 
 	
-} (metadataConstants));
+} (boundaryConstants));
 
 var scheduler = {};
 
@@ -4397,6 +4551,198 @@ var scheduler = {};
 	
 } (scheduler));
 
+var bailoutToCsr = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	function _export(target, all) {
+	    for(var name in all)Object.defineProperty(target, name, {
+	        enumerable: true,
+	        get: all[name]
+	    });
+	}
+	_export(exports, {
+	    BailoutToCSRError: function() {
+	        return BailoutToCSRError;
+	    },
+	    isBailoutToCSRError: function() {
+	        return isBailoutToCSRError;
+	    }
+	});
+	const BAILOUT_TO_CSR = 'BAILOUT_TO_CLIENT_SIDE_RENDERING';
+	class BailoutToCSRError extends Error {
+	    constructor(reason){
+	        super(`Bail out to client-side rendering: ${reason}`), this.reason = reason, this.digest = BAILOUT_TO_CSR;
+	    }
+	}
+	function isBailoutToCSRError(err) {
+	    if (typeof err !== 'object' || err === null || !('digest' in err)) {
+	        return false;
+	    }
+	    return err.digest === BAILOUT_TO_CSR;
+	}
+
+	
+} (bailoutToCsr));
+
+var stagedRendering = {};
+
+var promiseWithResolvers = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	Object.defineProperty(exports, "createPromiseWithResolvers", {
+	    enumerable: true,
+	    get: function() {
+	        return createPromiseWithResolvers;
+	    }
+	});
+	function createPromiseWithResolvers() {
+	    // Shim of Stage 4 Promise.withResolvers proposal
+	    let resolve;
+	    let reject;
+	    const promise = new Promise((res, rej)=>{
+	        resolve = res;
+	        reject = rej;
+	    });
+	    return {
+	        resolve: resolve,
+	        reject: reject,
+	        promise
+	    };
+	}
+
+	
+} (promiseWithResolvers));
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	function _export(target, all) {
+	    for(var name in all)Object.defineProperty(target, name, {
+	        enumerable: true,
+	        get: all[name]
+	    });
+	}
+	_export(exports, {
+	    RenderStage: function() {
+	        return RenderStage;
+	    },
+	    StagedRenderingController: function() {
+	        return StagedRenderingController;
+	    }
+	});
+	const _invarianterror = invariantError;
+	const _promisewithresolvers = promiseWithResolvers;
+	var RenderStage = /*#__PURE__*/ function(RenderStage) {
+	    RenderStage[RenderStage["Static"] = 1] = "Static";
+	    RenderStage[RenderStage["Runtime"] = 2] = "Runtime";
+	    RenderStage[RenderStage["Dynamic"] = 3] = "Dynamic";
+	    return RenderStage;
+	}({});
+	class StagedRenderingController {
+	    constructor(abortSignal = null){
+	        this.abortSignal = abortSignal;
+	        this.currentStage = 1;
+	        this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+	        this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+	        if (abortSignal) {
+	            abortSignal.addEventListener('abort', ()=>{
+	                const { reason } = abortSignal;
+	                if (this.currentStage < 2) {
+	                    this.runtimeStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
+	                    ;
+	                    this.runtimeStagePromise.reject(reason);
+	                }
+	                if (this.currentStage < 3) {
+	                    this.dynamicStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
+	                    ;
+	                    this.dynamicStagePromise.reject(reason);
+	                }
+	            }, {
+	                once: true
+	            });
+	        }
+	    }
+	    advanceStage(stage) {
+	        // If we're already at the target stage or beyond, do nothing.
+	        // (this can happen e.g. if sync IO advanced us to the dynamic stage)
+	        if (this.currentStage >= stage) {
+	            return;
+	        }
+	        this.currentStage = stage;
+	        // Note that we might be going directly from Static to Dynamic,
+	        // so we need to resolve the runtime stage as well.
+	        if (stage >= 2) {
+	            this.runtimeStagePromise.resolve();
+	        }
+	        if (stage >= 3) {
+	            this.dynamicStagePromise.resolve();
+	        }
+	    }
+	    getStagePromise(stage) {
+	        switch(stage){
+	            case 2:
+	                {
+	                    return this.runtimeStagePromise.promise;
+	                }
+	            case 3:
+	                {
+	                    return this.dynamicStagePromise.promise;
+	                }
+	            default:
+	                {
+	                    throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+	                        value: "E881",
+	                        enumerable: false,
+	                        configurable: true
+	                    });
+	                }
+	        }
+	    }
+	    waitForStage(stage) {
+	        return this.getStagePromise(stage);
+	    }
+	    delayUntilStage(stage, displayName, resolvedValue) {
+	        const ioTriggerPromise = this.getStagePromise(stage);
+	        const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
+	        // Analogously to `makeHangingPromise`, we might reject this promise if the signal is invoked.
+	        // (e.g. in the case where we don't want want the render to proceed to the dynamic stage and abort it).
+	        // We shouldn't consider this an unhandled rejection, so we attach a noop catch handler here to suppress this warning.
+	        if (this.abortSignal) {
+	            promise.catch(ignoreReject);
+	        }
+	        return promise;
+	    }
+	}
+	function ignoreReject() {}
+	// TODO(restart-on-cache-miss): the layering of `delayUntilStage`,
+	// `makeDevtoolsIOPromiseFromIOTrigger` and and `makeDevtoolsIOAwarePromise`
+	// is confusing, we should clean it up.
+	function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) {
+	    // If we create a `new Promise` and give it a displayName
+	    // (with no userspace code above us in the stack)
+	    // React Devtools will use it as the IO cause when determining "suspended by".
+	    // In particular, it should shadow any inner IO that resolved/rejected the promise
+	    // (in case of staged rendering, this will be the `setTimeout` that triggers the relevant stage)
+	    const promise = new Promise((resolve, reject)=>{
+	        ioTrigger.then(resolve.bind(null, resolvedValue), reject);
+	    });
+	    if (displayName !== undefined) {
+	        // @ts-expect-error
+	        promise.displayName = displayName;
+	    }
+	    return promise;
+	}
+
+	
+} (stagedRendering));
+
 /**
  * The functions provided by this module are used to communicate certain properties
  * about the currently running code so that Next.js can make decisions on how to handle
@@ -4460,8 +4806,11 @@ var scheduler = {};
 	    createHangingInputAbortSignal: function() {
 	        return createHangingInputAbortSignal;
 	    },
-	    createPostponedAbortSignal: function() {
-	        return createPostponedAbortSignal;
+	    createRenderInBrowserAbortSignal: function() {
+	        return createRenderInBrowserAbortSignal;
+	    },
+	    delayUntilRuntimeStage: function() {
+	        return delayUntilRuntimeStage;
 	    },
 	    formatDynamicAPIAccesses: function() {
 	        return formatDynamicAPIAccesses;
@@ -4475,6 +4824,9 @@ var scheduler = {};
 	    isPrerenderInterruptedError: function() {
 	        return isPrerenderInterruptedError;
 	    },
+	    logDisallowedDynamicError: function() {
+	        return logDisallowedDynamicError;
+	    },
 	    markCurrentScopeAsDynamic: function() {
 	        return markCurrentScopeAsDynamic;
 	    },
@@ -4493,17 +4845,14 @@ var scheduler = {};
 	    trackDynamicDataInDynamicRender: function() {
 	        return trackDynamicDataInDynamicRender;
 	    },
-	    trackFallbackParamAccessed: function() {
-	        return trackFallbackParamAccessed;
-	    },
 	    trackSynchronousPlatformIOAccessInDev: function() {
 	        return trackSynchronousPlatformIOAccessInDev;
 	    },
-	    trackSynchronousRequestDataAccessInDev: function() {
-	        return trackSynchronousRequestDataAccessInDev;
-	    },
 	    useDynamicRouteParams: function() {
 	        return useDynamicRouteParams;
+	    },
+	    useDynamicSearchParams: function() {
+	        return useDynamicSearchParams;
 	    }
 	});
 	const _react = /*#__PURE__*/ _interop_require_default(reactExports);
@@ -4512,8 +4861,11 @@ var scheduler = {};
 	const _workunitasyncstorageexternal = workUnitAsyncStorage_external;
 	const _workasyncstorageexternal = workAsyncStorage_external;
 	const _dynamicrenderingutils = dynamicRenderingUtils;
-	const _metadataconstants = metadataConstants;
+	const _boundaryconstants = boundaryConstants;
 	const _scheduler = scheduler;
+	const _bailouttocsr = bailoutToCsr;
+	const _invarianterror = invariantError;
+	const _stagedrendering = stagedRendering;
 	function _interop_require_default(obj) {
 	    return obj && obj.__esModule ? obj : {
 	        default: obj
@@ -4542,11 +4894,17 @@ var scheduler = {};
 	}
 	function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
 	    if (workUnitStore) {
-	        if (workUnitStore.type === 'cache' || workUnitStore.type === 'unstable-cache') {
-	            // inside cache scopes marking a scope as dynamic has no effect because the outer cache scope
-	            // creates a cache boundary. This is subtly different from reading a dynamic data source which is
-	            // forbidden inside a cache scope.
-	            return;
+	        switch(workUnitStore.type){
+	            case 'cache':
+	            case 'unstable-cache':
+	                // Inside cache scopes, marking a scope as dynamic has no effect,
+	                // because the outer cache scope creates a cache boundary. This is
+	                // subtly different from reading a dynamic data source, which is
+	                // forbidden inside a cache scope.
+	                return;
+	            case 'private-cache':
+	                // A private cache scope is already dynamic by definition.
+	                return;
 	        }
 	    }
 	    // If we're forcing dynamic rendering or we're forcing static rendering, we
@@ -4561,29 +4919,29 @@ var scheduler = {};
 	        });
 	    }
 	    if (workUnitStore) {
-	        if (workUnitStore.type === 'prerender-ppr') {
-	            postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
-	        } else if (workUnitStore.type === 'prerender-legacy') {
-	            workUnitStore.revalidate = 0;
-	            // We aren't prerendering but we are generating a static page. We need to bail out of static generation
-	            const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
-	                value: "E550",
-	                enumerable: false,
-	                configurable: true
-	            });
-	            store.dynamicUsageDescription = expression;
-	            store.dynamicUsageStack = err.stack;
-	            throw err;
-	        } else if (process.env.NODE_ENV === 'development' && workUnitStore && workUnitStore.type === 'request') {
-	            workUnitStore.usedDynamic = true;
+	        switch(workUnitStore.type){
+	            case 'prerender-ppr':
+	                return postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
+	            case 'prerender-legacy':
+	                workUnitStore.revalidate = 0;
+	                // We aren't prerendering, but we are generating a static page. We need
+	                // to bail out of static generation.
+	                const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+	                    value: "E550",
+	                    enumerable: false,
+	                    configurable: true
+	                });
+	                store.dynamicUsageDescription = expression;
+	                store.dynamicUsageStack = err.stack;
+	                throw err;
+	            case 'request':
+	                if (process.env.NODE_ENV !== 'production') {
+	                    workUnitStore.usedDynamic = true;
+	                }
+	                break;
 	        }
 	    }
 	}
-	function trackFallbackParamAccessed(store, expression) {
-	    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-	    if (!prerenderStore || prerenderStore.type !== 'prerender-ppr') return;
-	    postponeWithTracking(store.route, expression, prerenderStore.dynamicTracking);
-	}
 	function throwToInterruptStaticGeneration(expression, store, prerenderStore) {
 	    // We aren't prerendering but we are generating a static page. We need to bail out of static generation
 	    const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
@@ -4596,21 +4954,29 @@ var scheduler = {};
 	    store.dynamicUsageStack = err.stack;
 	    throw err;
 	}
-	function trackDynamicDataInDynamicRender(_store, workUnitStore) {
-	    if (workUnitStore) {
-	        if (workUnitStore.type === 'cache' || workUnitStore.type === 'unstable-cache') {
-	            // inside cache scopes marking a scope as dynamic has no effect because the outer cache scope
-	            // creates a cache boundary. This is subtly different from reading a dynamic data source which is
+	function trackDynamicDataInDynamicRender(workUnitStore) {
+	    switch(workUnitStore.type){
+	        case 'cache':
+	        case 'unstable-cache':
+	            // Inside cache scopes, marking a scope as dynamic has no effect,
+	            // because the outer cache scope creates a cache boundary. This is
+	            // subtly different from reading a dynamic data source, which is
 	            // forbidden inside a cache scope.
 	            return;
-	        }
-	        // TODO: it makes no sense to have these work unit store types during a dev render.
-	        if (workUnitStore.type === 'prerender' || workUnitStore.type === 'prerender-client' || workUnitStore.type === 'prerender-legacy') {
-	            workUnitStore.revalidate = 0;
-	        }
-	        if (process.env.NODE_ENV === 'development' && workUnitStore.type === 'request') {
-	            workUnitStore.usedDynamic = true;
-	        }
+	        case 'private-cache':
+	            // A private cache scope is already dynamic by definition.
+	            return;
+	        case 'prerender':
+	        case 'prerender-runtime':
+	        case 'prerender-legacy':
+	        case 'prerender-ppr':
+	        case 'prerender-client':
+	            break;
+	        case 'request':
+	            if (process.env.NODE_ENV !== 'production') {
+	                workUnitStore.usedDynamic = true;
+	            }
+	            break;
 	    }
 	}
 	function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
@@ -4642,8 +5008,12 @@ var scheduler = {};
 	}
 	function trackSynchronousPlatformIOAccessInDev(requestStore) {
 	    // We don't actually have a controller to abort but we do the semantic equivalent by
-	    // advancing the request store out of prerender mode
-	    requestStore.prerenderPhase = false;
+	    // advancing the request store out of the prerender stage
+	    if (requestStore.stagedRendering) {
+	        // TODO: error for sync IO in the runtime stage
+	        // (which is not currently covered by the validation render in `spawnDynamicValidationInDev`)
+	        requestStore.stagedRendering.advanceStage(_stagedrendering.RenderStage.Dynamic);
+	    }
 	}
 	function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
 	    const prerenderSignal = prerenderStore.controller.signal;
@@ -4667,7 +5037,6 @@ var scheduler = {};
 	    }
 	    throw createPrerenderInterruptedError(`Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`);
 	}
-	const trackSynchronousRequestDataAccessInDev = trackSynchronousPlatformIOAccessInDev;
 	function Postpone({ reason, route }) {
 	    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
 	    const dynamicTracking = prerenderStore && prerenderStore.type === 'prerender-ppr' ? prerenderStore.dynamicTracking : null;
@@ -4759,35 +5128,57 @@ var scheduler = {};
 	        });
 	    }
 	}
-	function createPostponedAbortSignal(reason) {
-	    assertPostpone();
+	function createRenderInBrowserAbortSignal() {
 	    const controller = new AbortController();
-	    // We get our hands on a postpone instance by calling postpone and catching the throw
-	    try {
-	        _react.default.unstable_postpone(reason);
-	    } catch (x) {
-	        controller.abort(x);
-	    }
+	    controller.abort(Object.defineProperty(new _bailouttocsr.BailoutToCSRError('Render in Browser'), "__NEXT_ERROR_CODE", {
+	        value: "E721",
+	        enumerable: false,
+	        configurable: true
+	    }));
 	    return controller.signal;
 	}
 	function createHangingInputAbortSignal(workUnitStore) {
-	    const controller = new AbortController();
-	    if (workUnitStore.cacheSignal) {
-	        // If we have a cacheSignal it means we're in a prospective render. If the input
-	        // we're waiting on is coming from another cache, we do want to wait for it so that
-	        // we can resolve this cache entry too.
-	        workUnitStore.cacheSignal.inputReady().then(()=>{
-	            controller.abort();
-	        });
-	    } else {
-	        // Otherwise we're in the final render and we should already have all our caches
-	        // filled. We might still be waiting on some microtasks so we wait one tick before
-	        // giving up. When we give up, we still want to render the content of this cache
-	        // as deeply as we can so that we can suspend as deeply as possible in the tree
-	        // or not at all if we don't end up waiting for the input.
-	        (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
+	    switch(workUnitStore.type){
+	        case 'prerender':
+	        case 'prerender-runtime':
+	            const controller = new AbortController();
+	            if (workUnitStore.cacheSignal) {
+	                // If we have a cacheSignal it means we're in a prospective render. If
+	                // the input we're waiting on is coming from another cache, we do want
+	                // to wait for it so that we can resolve this cache entry too.
+	                workUnitStore.cacheSignal.inputReady().then(()=>{
+	                    controller.abort();
+	                });
+	            } else {
+	                // Otherwise we're in the final render and we should already have all
+	                // our caches filled.
+	                // If the prerender uses stages, we have wait until the runtime stage,
+	                // at which point all runtime inputs will be resolved.
+	                // (otherwise, a runtime prerender might consider `cookies()` hanging
+	                //  even though they'd resolve in the next task.)
+	                //
+	                // We might still be waiting on some microtasks so we
+	                // wait one tick before giving up. When we give up, we still want to
+	                // render the content of this cache as deeply as we can so that we can
+	                // suspend as deeply as possible in the tree or not at all if we don't
+	                // end up waiting for the input.
+	                const runtimeStagePromise = (0, _workunitasyncstorageexternal.getRuntimeStagePromise)(workUnitStore);
+	                if (runtimeStagePromise) {
+	                    runtimeStagePromise.then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()));
+	                } else {
+	                    (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
+	                }
+	            }
+	            return controller.signal;
+	        case 'prerender-client':
+	        case 'prerender-ppr':
+	        case 'prerender-legacy':
+	        case 'request':
+	        case 'cache':
+	        case 'private-cache':
+	        case 'unstable-cache':
+	            return undefined;
 	    }
-	    return controller.signal;
 	}
 	function annotateDynamicAccess(expression, prerenderStore) {
 	    const dynamicTracking = prerenderStore.dynamicTracking;
@@ -4800,31 +5191,111 @@ var scheduler = {};
 	}
 	function useDynamicRouteParams(expression) {
 	    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-	    if (workStore && workStore.isStaticGeneration && workStore.fallbackRouteParams && workStore.fallbackRouteParams.size > 0) {
-	        // There are fallback route params, we should track these as dynamic
-	        // accesses.
-	        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-	        if (workUnitStore) {
-	            // We're prerendering with dynamicIO or PPR or both
-	            if (workUnitStore.type === 'prerender-client') {
-	                // We are in a prerender with dynamicIO semantics
-	                // We are going to hang here and never resolve. This will cause the currently
-	                // rendering component to effectively be a dynamic hole
-	                _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, expression));
-	            } else if (workUnitStore.type === 'prerender-ppr') {
-	                // We're prerendering with PPR
-	                postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
-	            } else if (workUnitStore.type === 'prerender-legacy') {
-	                throwToInterruptStaticGeneration(expression, workStore, workUnitStore);
-	            }
+	    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+	    if (workStore && workUnitStore) {
+	        switch(workUnitStore.type){
+	            case 'prerender-client':
+	            case 'prerender':
+	                {
+	                    const fallbackParams = workUnitStore.fallbackRouteParams;
+	                    if (fallbackParams && fallbackParams.size > 0) {
+	                        // We are in a prerender with cacheComponents semantics. We are going to
+	                        // hang here and never resolve. This will cause the currently
+	                        // rendering component to effectively be a dynamic hole.
+	                        _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
+	                    }
+	                    break;
+	                }
+	            case 'prerender-ppr':
+	                {
+	                    const fallbackParams = workUnitStore.fallbackRouteParams;
+	                    if (fallbackParams && fallbackParams.size > 0) {
+	                        return postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
+	                    }
+	                    break;
+	                }
+	            case 'prerender-runtime':
+	                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called during a runtime prerender. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+	                    value: "E771",
+	                    enumerable: false,
+	                    configurable: true
+	                });
+	            case 'cache':
+	            case 'private-cache':
+	                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called inside a cache scope. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+	                    value: "E745",
+	                    enumerable: false,
+	                    configurable: true
+	                });
 	        }
 	    }
 	}
+	function useDynamicSearchParams(expression) {
+	    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+	    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+	    if (!workStore) {
+	        // We assume pages router context and just return
+	        return;
+	    }
+	    if (!workUnitStore) {
+	        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(expression);
+	    }
+	    switch(workUnitStore.type){
+	        case 'prerender-client':
+	            {
+	                _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
+	                break;
+	            }
+	        case 'prerender-legacy':
+	        case 'prerender-ppr':
+	            {
+	                if (workStore.forceStatic) {
+	                    return;
+	                }
+	                throw Object.defineProperty(new _bailouttocsr.BailoutToCSRError(expression), "__NEXT_ERROR_CODE", {
+	                    value: "E394",
+	                    enumerable: false,
+	                    configurable: true
+	                });
+	            }
+	        case 'prerender':
+	        case 'prerender-runtime':
+	            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called from a Server Component. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+	                value: "E795",
+	                enumerable: false,
+	                configurable: true
+	            });
+	        case 'cache':
+	        case 'unstable-cache':
+	        case 'private-cache':
+	            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called inside a cache scope. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+	                value: "E745",
+	                enumerable: false,
+	                configurable: true
+	            });
+	        case 'request':
+	            return;
+	    }
+	}
 	const hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
-	const hasSuspenseAfterBodyOrHtmlRegex = /\n\s+at (?:body|html) \(<anonymous>\)[\s\S]*?\n\s+at Suspense \(<anonymous>\)/;
-	const hasMetadataRegex = new RegExp(`\\n\\s+at ${_metadataconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
-	const hasViewportRegex = new RegExp(`\\n\\s+at ${_metadataconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
-	const hasOutletRegex = new RegExp(`\\n\\s+at ${_metadataconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
+	// Common implicit body tags that React will treat as body when placed directly in html
+	const bodyAndImplicitTags = 'body|div|main|section|article|aside|header|footer|nav|form|p|span|h1|h2|h3|h4|h5|h6';
+	// Detects when RootLayoutBoundary (our framework marker component) appears
+	// after Suspense in the component stack, indicating the root layout is wrapped
+	// within a Suspense boundary. Ensures no body/html/implicit-body components are in between.
+	//
+	// Example matches:
+	//   at Suspense (<anonymous>)
+	//   at __next_root_layout_boundary__ (<anonymous>)
+	//
+	// Or with other components in between (but not body/html/implicit-body):
+	//   at Suspense (<anonymous>)
+	//   at SomeComponent (<anonymous>)
+	//   at __next_root_layout_boundary__ (<anonymous>)
+	const hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp(`\\n\\s+at Suspense \\(<anonymous>\\)(?:(?!\\n\\s+at (?:${bodyAndImplicitTags}) \\(<anonymous>\\))[\\s\\S])*?\\n\\s+at ${_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME} \\([^\\n]*\\)`);
+	const hasMetadataRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
+	const hasViewportRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
+	const hasOutletRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
 	function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation, clientDynamic) {
 	    if (hasOutletRegex.test(componentStack)) {
 	        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
@@ -4835,9 +5306,10 @@ var scheduler = {};
 	    } else if (hasViewportRegex.test(componentStack)) {
 	        dynamicValidation.hasDynamicViewport = true;
 	        return;
-	    } else if (hasSuspenseAfterBodyOrHtmlRegex.test(componentStack)) {
-	        // This prerender has a Suspense boundary above the body which
-	        // effectively opts the page into allowing 100% dynamic rendering
+	    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
+	        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
+	        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
+	        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
 	        dynamicValidation.hasAllowedDynamic = true;
 	        dynamicValidation.hasSuspenseAboveBody = true;
 	        return;
@@ -4851,7 +5323,7 @@ var scheduler = {};
 	        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
 	        return;
 	    } else {
-	        const message = `Route "${workStore.route}": A component accessed data, headers, params, searchParams, or a short-lived cache without a Suspense boundary nor a "use cache" above it. See more info: https://nextjs.org/docs/messages/next-prerender-missing-suspense`;
+	        const message = `Route "${workStore.route}": Uncached data was accessed outside of ` + '<Suspense>. This delays the entire page from rendering, resulting in a ' + 'slow user experience. Learn more: ' + 'https://nextjs.org/docs/messages/blocking-route';
 	        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
 	        dynamicValidation.dynamicErrors.push(error);
 	        return;
@@ -4889,8 +5361,8 @@ var scheduler = {};
 	    }
 	}
 	function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
-	    if (workStore.invalidDynamicUsageError) {
-	        logDisallowedDynamicError(workStore, workStore.invalidDynamicUsageError);
+	    if (serverDynamic.syncDynamicErrorWithStack) {
+	        logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
 	        throw new _staticgenerationbailout.StaticGenBailoutError();
 	    }
 	    if (prelude !== 0) {
@@ -4900,13 +5372,6 @@ var scheduler = {};
 	            // a lack of a shell is not considered disallowed so we simply return
 	            return;
 	        }
-	        if (serverDynamic.syncDynamicErrorWithStack) {
-	            // There is no shell and the server did something sync dynamic likely
-	            // leading to an early termination of the prerender before the shell
-	            // could be completed. We terminate the build/validating render.
-	            logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
-	            throw new _staticgenerationbailout.StaticGenBailoutError();
-	        }
 	        // We didn't have any sync bailouts but there may be user code which
 	        // blocked the root. We would have captured these during the prerender
 	        // and can log them here and then terminate the build/validating render
@@ -4939,6 +5404,12 @@ var scheduler = {};
 	        }
 	    }
 	}
+	function delayUntilRuntimeStage(prerenderStore, result) {
+	    if (prerenderStore.runtimeStagePromise) {
+	        return prerenderStore.runtimeStagePromise.then(()=>result);
+	    }
+	    return result;
+	}
 
 	
 } (dynamicRendering));
@@ -4997,22 +5468,12 @@ var afterTaskAsyncStorageInstance = {};
 	    throwForSearchParamsAccessInUseCache: function() {
 	        return throwForSearchParamsAccessInUseCache;
 	    },
-	    throwWithStaticGenerationBailoutError: function() {
-	        return throwWithStaticGenerationBailoutError;
-	    },
 	    throwWithStaticGenerationBailoutErrorWithDynamicError: function() {
 	        return throwWithStaticGenerationBailoutErrorWithDynamicError;
 	    }
 	});
 	const _staticgenerationbailout = staticGenerationBailoutExports;
 	const _aftertaskasyncstorageexternal = afterTaskAsyncStorage_external;
-	function throwWithStaticGenerationBailoutError(route, expression) {
-	    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
-	        value: "E576",
-	        enumerable: false,
-	        configurable: true
-	    });
-	}
 	function throwWithStaticGenerationBailoutErrorWithDynamicError(route, expression) {
 	    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
 	        value: "E543",
@@ -5021,8 +5482,8 @@ var afterTaskAsyncStorageInstance = {};
 	    });
 	}
 	function throwForSearchParamsAccessInUseCache(workStore, constructorOpt) {
-	    const error = Object.defineProperty(new Error(`Route ${workStore.route} used "searchParams" inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "searchParams" outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-	        value: "E634",
+	    const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`searchParams\` inside "use cache". Accessing dynamic request data inside a cache scope is not supported. If you need some search params inside a cached function await \`searchParams\` outside of the cached function and pass only the required search params as arguments to the cached function. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+	        value: "E842",
 	        enumerable: false,
 	        configurable: true
 	    });
@@ -5054,294 +5515,100 @@ var afterTaskAsyncStorageInstance = {};
 	const _staticgenerationbailout = staticGenerationBailoutExports;
 	const _dynamicrenderingutils = dynamicRenderingUtils;
 	const _utils = utils;
+	const _stagedrendering = stagedRendering;
 	function connection() {
+	    const callingExpression = 'connection';
 	    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
 	    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
 	    if (workStore) {
 	        if (workUnitStore && workUnitStore.phase === 'after' && !(0, _utils.isRequestAPICallableInsideAfter)()) {
-	            throw Object.defineProperty(new Error(`Route ${workStore.route} used "connection" inside "after(...)". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but "after(...)" executes after the request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
-	                value: "E186",
+	            throw Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside \`after()\`. The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but \`after()\` executes after the request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+	                value: "E827",
 	                enumerable: false,
 	                configurable: true
 	            });
 	        }
 	        if (workStore.forceStatic) {
-	            // When using forceStatic we override all other logic and always just return an empty
-	            // headers object without tracking
+	            // When using forceStatic, we override all other logic and always just
+	            // return a resolving promise without tracking.
 	            return Promise.resolve(undefined);
 	        }
-	        if (workUnitStore) {
-	            if (workUnitStore.type === 'cache') {
-	                throw Object.defineProperty(new Error(`Route ${workStore.route} used "connection" inside "use cache". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but caches must be able to be produced before a Request so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-	                    value: "E111",
-	                    enumerable: false,
-	                    configurable: true
-	                });
-	            } else if (workUnitStore.type === 'unstable-cache') {
-	                throw Object.defineProperty(new Error(`Route ${workStore.route} used "connection" inside a function cached with "unstable_cache(...)". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but caches must be able to be produced before a Request so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
-	                    value: "E1",
-	                    enumerable: false,
-	                    configurable: true
-	                });
-	            }
-	        }
 	        if (workStore.dynamicShouldError) {
-	            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`connection\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
-	                value: "E562",
+	            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`connection()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+	                value: "E847",
 	                enumerable: false,
 	                configurable: true
 	            });
 	        }
 	        if (workUnitStore) {
-	            if (workUnitStore.type === 'prerender' || workUnitStore.type === 'prerender-client') {
-	                // dynamicIO Prerender
-	                // We return a promise that never resolves to allow the prender to stall at this point
-	                return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, '`connection()`');
-	            } else if (workUnitStore.type === 'prerender-ppr') {
-	                // PPR Prerender (no dynamicIO)
-	                // We use React's postpone API to interrupt rendering here to create a dynamic hole
-	                (0, _dynamicrendering.postponeWithTracking)(workStore.route, 'connection', workUnitStore.dynamicTracking);
-	            } else if (workUnitStore.type === 'prerender-legacy') {
-	                // Legacy Prerender
-	                // We throw an error here to interrupt prerendering to mark the route as dynamic
-	                (0, _dynamicrendering.throwToInterruptStaticGeneration)('connection', workStore, workUnitStore);
-	            }
-	        }
-	        // We fall through to the dynamic context below but we still track dynamic access
-	        // because in dev we can still error for things like using headers inside a cache context
-	        (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workStore, workUnitStore);
-	    }
-	    return Promise.resolve(undefined);
-	}
-
-	
-} (connection));
-
-var rootParams = {};
-
-var invariantError = {};
-
-(function (exports) {
-	Object.defineProperty(exports, "__esModule", {
-	    value: true
-	});
-	Object.defineProperty(exports, "InvariantError", {
-	    enumerable: true,
-	    get: function() {
-	        return InvariantError;
-	    }
-	});
-	class InvariantError extends Error {
-	    constructor(message, options){
-	        super("Invariant: " + (message.endsWith('.') ? message : message + '.') + " This is a bug in Next.js.", options);
-	        this.name = 'InvariantError';
-	    }
-	}
-
-	
-} (invariantError));
-
-var reflectUtils = {};
-
-(function (exports) {
-	Object.defineProperty(exports, "__esModule", {
-	    value: true
-	});
-	function _export(target, all) {
-	    for(var name in all)Object.defineProperty(target, name, {
-	        enumerable: true,
-	        get: all[name]
-	    });
-	}
-	_export(exports, {
-	    describeHasCheckingStringProperty: function() {
-	        return describeHasCheckingStringProperty;
-	    },
-	    describeStringPropertyAccess: function() {
-	        return describeStringPropertyAccess;
-	    },
-	    wellKnownProperties: function() {
-	        return wellKnownProperties;
-	    }
-	});
-	const isDefinitelyAValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-	function describeStringPropertyAccess(target, prop) {
-	    if (isDefinitelyAValidIdentifier.test(prop)) {
-	        return "`" + target + "." + prop + "`";
-	    }
-	    return "`" + target + "[" + JSON.stringify(prop) + "]`";
-	}
-	function describeHasCheckingStringProperty(target, prop) {
-	    const stringifiedProp = JSON.stringify(prop);
-	    return "`Reflect.has(" + target + ", " + stringifiedProp + ")`, `" + stringifiedProp + " in " + target + "`, or similar";
-	}
-	const wellKnownProperties = new Set([
-	    'hasOwnProperty',
-	    'isPrototypeOf',
-	    'propertyIsEnumerable',
-	    'toString',
-	    'valueOf',
-	    'toLocaleString',
-	    // Promise prototype
-	    // fallthrough
-	    'then',
-	    'catch',
-	    'finally',
-	    // React Promise extension
-	    // fallthrough
-	    'status',
-	    // React introspection
-	    'displayName',
-	    '_debugInfo',
-	    // Common tested properties
-	    // fallthrough
-	    'toJSON',
-	    '$$typeof',
-	    '__esModule'
-	]);
-
-	
-} (reflectUtils));
-
-(function (exports) {
-	Object.defineProperty(exports, "__esModule", {
-	    value: true
-	});
-	Object.defineProperty(exports, "unstable_rootParams", {
-	    enumerable: true,
-	    get: function() {
-	        return unstable_rootParams;
-	    }
-	});
-	const _invarianterror = invariantError;
-	const _dynamicrendering = dynamicRendering;
-	const _workasyncstorageexternal = workAsyncStorage_external;
-	const _workunitasyncstorageexternal = workUnitAsyncStorage_external;
-	const _dynamicrenderingutils = dynamicRenderingUtils;
-	const _reflectutils = reflectUtils;
-	const CachedParams = new WeakMap();
-	async function unstable_rootParams() {
-	    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-	    if (!workStore) {
-	        throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in unstable_rootParams'), "__NEXT_ERROR_CODE", {
-	            value: "E615",
-	            enumerable: false,
-	            configurable: true
-	        });
-	    }
-	    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-	    if (!workUnitStore) {
-	        throw Object.defineProperty(new Error(`Route ${workStore.route} used \`unstable_rootParams()\` in Pages Router. This API is only available within App Router.`), "__NEXT_ERROR_CODE", {
-	            value: "E641",
-	            enumerable: false,
-	            configurable: true
-	        });
-	    }
-	    switch(workUnitStore.type){
-	        case 'unstable-cache':
-	        case 'cache':
-	            {
-	                throw Object.defineProperty(new Error(`Route ${workStore.route} used \`unstable_rootParams()\` inside \`"use cache"\` or \`unstable_cache\`. Support for this API inside cache scopes is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
-	                    value: "E642",
-	                    enumerable: false,
-	                    configurable: true
-	                });
-	            }
-	        case 'prerender':
-	        case 'prerender-client':
-	        case 'prerender-ppr':
-	        case 'prerender-legacy':
-	            return createPrerenderRootParams(workUnitStore.rootParams, workStore, workUnitStore);
-	        default:
-	            return Promise.resolve(workUnitStore.rootParams);
-	    }
-	}
-	function createPrerenderRootParams(underlyingParams, workStore, prerenderStore) {
-	    const fallbackParams = workStore.fallbackRouteParams;
-	    if (fallbackParams) {
-	        let hasSomeFallbackParams = false;
-	        for(const key in underlyingParams){
-	            if (fallbackParams.has(key)) {
-	                hasSomeFallbackParams = true;
-	                break;
-	            }
-	        }
-	        if (hasSomeFallbackParams) {
-	            // params need to be treated as dynamic because we have at least one fallback param
-	            switch(prerenderStore.type){
-	                case 'prerender':
-	                    // We are in a dynamicIO prerender
-	                    const cachedParams = CachedParams.get(underlyingParams);
-	                    if (cachedParams) {
-	                        return cachedParams;
+	            switch(workUnitStore.type){
+	                case 'cache':
+	                    {
+	                        const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside "use cache". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual request, but caches must be able to be produced before a request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+	                            value: "E841",
+	                            enumerable: false,
+	                            configurable: true
+	                        });
+	                        Error.captureStackTrace(error, connection);
+	                        workStore.invalidDynamicUsageError ??= error;
+	                        throw error;
 	                    }
-	                    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, '`unstable_rootParams`');
-	                    CachedParams.set(underlyingParams, promise);
-	                    return promise;
-	                case 'prerender-client':
-	                    const exportName = '`unstable_rootParams`';
-	                    throw Object.defineProperty(new _invarianterror.InvariantError(`${exportName} must not be used within a client component. Next.js should be preventing ${exportName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-	                        value: "E693",
+	                case 'private-cache':
+	                    {
+	                        // It might not be intuitive to throw for private caches as well, but
+	                        // we don't consider runtime prefetches as "actual requests" (in the
+	                        // navigation sense), despite allowing them to read cookies.
+	                        const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside "use cache: private". The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual navigation request, but caches must be able to be produced before a navigation request, so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+	                            value: "E837",
+	                            enumerable: false,
+	                            configurable: true
+	                        });
+	                        Error.captureStackTrace(error, connection);
+	                        workStore.invalidDynamicUsageError ??= error;
+	                        throw error;
+	                    }
+	                case 'unstable-cache':
+	                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside a function cached with \`unstable_cache()\`. The \`connection()\` function is used to indicate the subsequent code must only run when there is an actual Request, but caches must be able to be produced before a Request so this function is not allowed in this scope. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+	                        value: "E840",
 	                        enumerable: false,
 	                        configurable: true
 	                    });
-	                default:
-	                    // remaining cases are prerender-ppr and prerender-legacy
-	                    // We aren't in a dynamicIO prerender but we do have fallback params at this
-	                    // level so we need to make an erroring params object which will postpone
-	                    // if you access the fallback params
-	                    return makeErroringRootParams(underlyingParams, fallbackParams, workStore, prerenderStore);
-	            }
-	        }
-	    }
-	    // We don't have any fallback params so we have an entirely static safe params object
-	    return Promise.resolve(underlyingParams);
-	}
-	function makeErroringRootParams(underlyingParams, fallbackParams, workStore, prerenderStore) {
-	    const cachedParams = CachedParams.get(underlyingParams);
-	    if (cachedParams) {
-	        return cachedParams;
-	    }
-	    const augmentedUnderlying = {
-	        ...underlyingParams
-	    };
-	    // We don't use makeResolvedReactPromise here because params
-	    // supports copying with spread and we don't want to unnecessarily
-	    // instrument the promise with spreadable properties of ReactPromise.
-	    const promise = Promise.resolve(augmentedUnderlying);
-	    CachedParams.set(underlyingParams, promise);
-	    Object.keys(underlyingParams).forEach((prop)=>{
-	        if (_reflectutils.wellKnownProperties.has(prop)) ; else {
-	            if (fallbackParams.has(prop)) {
-	                Object.defineProperty(augmentedUnderlying, prop, {
-	                    get () {
-	                        const expression = (0, _reflectutils.describeStringPropertyAccess)('unstable_rootParams', prop);
-	                        // In most dynamic APIs we also throw if `dynamic = "error"` however
-	                        // for params is only dynamic when we're generating a fallback shell
-	                        // and even when `dynamic = "error"` we still support generating dynamic
-	                        // fallback shells
-	                        // TODO remove this comment when dynamicIO is the default since there
-	                        // will be no `dynamic = "error"`
-	                        if (prerenderStore.type === 'prerender-ppr') {
-	                            // PPR Prerender (no dynamicIO)
-	                            (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
-	                        } else {
-	                            // Legacy Prerender
-	                            (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
+	                case 'prerender':
+	                case 'prerender-client':
+	                case 'prerender-runtime':
+	                    // We return a promise that never resolves to allow the prerender to
+	                    // stall at this point.
+	                    return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`connection()`');
+	                case 'prerender-ppr':
+	                    // We use React's postpone API to interrupt rendering here to create a
+	                    // dynamic hole
+	                    return (0, _dynamicrendering.postponeWithTracking)(workStore.route, 'connection', workUnitStore.dynamicTracking);
+	                case 'prerender-legacy':
+	                    // We throw an error here to interrupt prerendering to mark the route
+	                    // as dynamic
+	                    return (0, _dynamicrendering.throwToInterruptStaticGeneration)('connection', workStore, workUnitStore);
+	                case 'request':
+	                    (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
+	                    if (process.env.NODE_ENV === 'development') {
+	                        // Semantically we only need the dev tracking when running in `next dev`
+	                        // but since you would never use next dev with production NODE_ENV we use this
+	                        // as a proxy so we can statically exclude this code from production builds.
+	                        if (workUnitStore.asyncApiPromises) {
+	                            return workUnitStore.asyncApiPromises.connection;
 	                        }
-	                    },
-	                    enumerable: true
-	                });
-	            } else {
-	                promise[prop] = underlyingParams[prop];
+	                        return (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, _stagedrendering.RenderStage.Dynamic);
+	                    } else {
+	                        return Promise.resolve(undefined);
+	                    }
 	            }
 	        }
-	    });
-	    return promise;
+	    }
+	    // If we end up here, there was no work store or work unit store present.
+	    (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
 	}
 
 	
-} (rootParams));
+} (connection));
 
 (function (module, exports) {
 	const serverExports = {
@@ -5359,8 +5626,6 @@ var reflectUtils = {};
 	    .URLPattern,
 	  after: after$1.after,
 	  connection: connection.connection,
-	  unstable_rootParams: rootParams
-	    .unstable_rootParams,
 	};
 
 	// https://nodejs.org/api/esm.html#commonjs-namespaces
@@ -5375,8 +5640,7 @@ var reflectUtils = {};
 	exports.userAgent = serverExports.userAgent;
 	exports.URLPattern = serverExports.URLPattern;
 	exports.after = serverExports.after;
-	exports.connection = serverExports.connection;
-	exports.unstable_rootParams = serverExports.unstable_rootParams; 
+	exports.connection = serverExports.connection; 
 } (server, server.exports));
 
 var serverExports = server.exports;
@@ -9342,7 +9606,7 @@ const unknownType = ZodUnknown.create;
 ZodNever.create;
 const arrayType = ZodArray.create;
 const objectType = ZodObject.create;
-ZodUnion.create;
+const unionType = ZodUnion.create;
 const discriminatedUnionType = ZodDiscriminatedUnion.create;
 ZodIntersection.create;
 ZodTuple.create;
@@ -9561,7 +9825,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '2.2.0'; // x-release-please-version
+const VERSION = '2.4.6'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 /**
@@ -10311,6 +10575,9 @@ class CheckoutSessions extends APIResource {
     create(body, options) {
         return this._client.post('/checkouts', { body, ...options });
     }
+    retrieve(id, options) {
+        return this._client.get(path `/checkouts/${id}`, options);
+    }
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
@@ -10989,1398 +11256,323 @@ let Headers$1 = class Headers extends APIResource {
     }
 };
 
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-let Webhooks$1 = class Webhooks extends APIResource {
-    constructor() {
-        super(...arguments);
-        this.headers = new Headers$1(this._client);
+var dist = {};
+
+var timing_safe_equal = {};
+
+Object.defineProperty(timing_safe_equal, "__esModule", { value: true });
+timing_safe_equal.timingSafeEqual = void 0;
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new Error(msg);
     }
-    /**
-     * Create a new webhook
-     */
-    create(body, options) {
-        return this._client.post('/webhooks', { body, ...options });
+}
+function timingSafeEqual(a, b) {
+    if (a.byteLength !== b.byteLength) {
+        return false;
     }
-    /**
-     * Get a webhook by id
-     */
-    retrieve(webhookID, options) {
-        return this._client.get(path `/webhooks/${webhookID}`, options);
+    if (!(a instanceof DataView)) {
+        a = new DataView(ArrayBuffer.isView(a) ? a.buffer : a);
     }
-    /**
-     * Patch a webhook by id
-     */
-    update(webhookID, body, options) {
-        return this._client.patch(path `/webhooks/${webhookID}`, { body, ...options });
+    if (!(b instanceof DataView)) {
+        b = new DataView(ArrayBuffer.isView(b) ? b.buffer : b);
     }
-    /**
-     * List all webhooks
-     */
-    list(query = {}, options) {
-        return this._client.getAPIList('/webhooks', (CursorPagePagination), { query, ...options });
-    }
-    /**
-     * Delete a webhook by id
-     */
-    delete(webhookID, options) {
-        return this._client.delete(path `/webhooks/${webhookID}`, {
-            ...options,
-            headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-        });
-    }
-    /**
-     * Get webhook secret by id
-     */
-    retrieveSecret(webhookID, options) {
-        return this._client.get(path `/webhooks/${webhookID}/secret`, options);
+    assert(a instanceof DataView);
+    assert(b instanceof DataView);
+    const length = a.byteLength;
+    let out = 0;
+    let i = -1;
+    while (++i < length) {
+        out |= a.getUint8(i) ^ b.getUint8(i);
     }
-};
-Webhooks$1.Headers = Headers$1;
+    return out === 0;
+}
+timing_safe_equal.timingSafeEqual = timingSafeEqual;
 
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+var base64$1 = {};
+
+// Copyright (C) 2016 Dmitry Chestnykh
+// MIT License. See LICENSE file for details.
+var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(base64$1, "__esModule", { value: true });
 /**
- * Read an environment variable.
- *
- * Trims beginning and trailing whitespace.
- *
- * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ * Package base64 implements Base64 encoding and decoding.
  */
-const readEnv = (env) => {
-    if (typeof globalThis.process !== 'undefined') {
-        return globalThis.process.env?.[env]?.trim() ?? undefined;
-    }
-    if (typeof globalThis.Deno !== 'undefined') {
-        return globalThis.Deno.env?.get?.(env)?.trim();
-    }
-    return undefined;
-};
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-var _DodoPayments_instances, _a, _DodoPayments_encoder, _DodoPayments_baseURLOverridden;
-const environments = {
-    live_mode: 'https://live.dodopayments.com',
-    test_mode: 'https://test.dodopayments.com',
-};
+// Invalid character used in decoding to indicate
+// that the character to decode is out of range of
+// alphabet and cannot be decoded.
+var INVALID_BYTE = 256;
 /**
- * API Client for interfacing with the Dodo Payments API.
+ * Implements standard Base64 encoding.
+ *
+ * Operates in constant time.
  */
-class DodoPayments {
-    /**
-     * API Client for interfacing with the Dodo Payments API.
-     *
-     * @param {string | undefined} [opts.bearerToken=process.env['DODO_PAYMENTS_API_KEY'] ?? undefined]
-     * @param {Environment} [opts.environment=live_mode] - Specifies the environment URL to use for the API.
-     * @param {string} [opts.baseURL=process.env['DODO_PAYMENTS_BASE_URL'] ?? https://live.dodopayments.com] - Override the default base URL for the API.
-     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
-     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
-     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
-     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
-     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
-     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
-     */
-    constructor({ baseURL = readEnv('DODO_PAYMENTS_BASE_URL'), bearerToken = readEnv('DODO_PAYMENTS_API_KEY'), ...opts } = {}) {
-        _DodoPayments_instances.add(this);
-        _DodoPayments_encoder.set(this, void 0);
-        this.checkoutSessions = new CheckoutSessions(this);
-        this.payments = new Payments(this);
-        this.subscriptions = new Subscriptions(this);
-        this.invoices = new Invoices(this);
-        this.licenses = new Licenses(this);
-        this.licenseKeys = new LicenseKeys(this);
-        this.licenseKeyInstances = new LicenseKeyInstances(this);
-        this.customers = new Customers(this);
-        this.refunds = new Refunds(this);
-        this.disputes = new Disputes(this);
-        this.payouts = new Payouts(this);
-        this.webhookEvents = new WebhookEvents(this);
-        this.products = new Products(this);
-        this.misc = new Misc(this);
-        this.discounts = new Discounts(this);
-        this.addons = new Addons(this);
-        this.brands = new Brands(this);
-        this.webhooks = new Webhooks$1(this);
-        this.usageEvents = new UsageEvents(this);
-        this.meters = new Meters(this);
-        if (bearerToken === undefined) {
-            throw new DodoPaymentsError("The DODO_PAYMENTS_API_KEY environment variable is missing or empty; either provide it, or instantiate the DodoPayments client with an bearerToken option, like new DodoPayments({ bearerToken: 'My Bearer Token' }).");
+var Coder = /** @class */ (function () {
+    // TODO(dchest): methods to encode chunk-by-chunk.
+    function Coder(_paddingCharacter) {
+        if (_paddingCharacter === void 0) { _paddingCharacter = "="; }
+        this._paddingCharacter = _paddingCharacter;
+    }
+    Coder.prototype.encodedLength = function (length) {
+        if (!this._paddingCharacter) {
+            return (length * 8 + 5) / 6 | 0;
         }
-        const options = {
-            bearerToken,
-            ...opts,
-            baseURL,
-            environment: opts.environment ?? 'live_mode',
-        };
-        if (baseURL && opts.environment) {
-            throw new DodoPaymentsError('Ambiguous URL; The `baseURL` option (or DODO_PAYMENTS_BASE_URL env var) and the `environment` option are given. If you want to use the environment you must pass baseURL: null');
+        return (length + 2) / 3 * 4 | 0;
+    };
+    Coder.prototype.encode = function (data) {
+        var out = "";
+        var i = 0;
+        for (; i < data.length - 2; i += 3) {
+            var c = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
+            out += this._encodeByte((c >>> 3 * 6) & 63);
+            out += this._encodeByte((c >>> 2 * 6) & 63);
+            out += this._encodeByte((c >>> 1 * 6) & 63);
+            out += this._encodeByte((c >>> 0 * 6) & 63);
         }
-        this.baseURL = options.baseURL || environments[options.environment || 'live_mode'];
-        this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT /* 1 minute */;
-        this.logger = options.logger ?? console;
-        const defaultLogLevel = 'warn';
-        // Set default logLevel early so that we can log a warning in parseLogLevel.
-        this.logLevel = defaultLogLevel;
-        this.logLevel =
-            parseLogLevel(options.logLevel, 'ClientOptions.logLevel', this) ??
-                parseLogLevel(readEnv('DODO_PAYMENTS_LOG'), "process.env['DODO_PAYMENTS_LOG']", this) ??
-                defaultLogLevel;
-        this.fetchOptions = options.fetchOptions;
-        this.maxRetries = options.maxRetries ?? 2;
-        this.fetch = options.fetch ?? getDefaultFetch();
-        __classPrivateFieldSet(this, _DodoPayments_encoder, FallbackEncoder);
-        this._options = options;
-        this.bearerToken = bearerToken;
-    }
-    /**
-     * Create a new client instance re-using the same options given to the current client with optional overriding.
-     */
-    withOptions(options) {
-        const client = new this.constructor({
-            ...this._options,
-            environment: options.environment ? options.environment : undefined,
-            baseURL: options.environment ? undefined : this.baseURL,
-            maxRetries: this.maxRetries,
-            timeout: this.timeout,
-            logger: this.logger,
-            logLevel: this.logLevel,
-            fetch: this.fetch,
-            fetchOptions: this.fetchOptions,
-            bearerToken: this.bearerToken,
-            ...options,
-        });
-        return client;
-    }
-    defaultQuery() {
-        return this._options.defaultQuery;
-    }
-    validateHeaders({ values, nulls }) {
-        return;
-    }
-    async authHeaders(opts) {
-        return buildHeaders([{ Authorization: `Bearer ${this.bearerToken}` }]);
-    }
-    /**
-     * Basic re-implementation of `qs.stringify` for primitive types.
-     */
-    stringifyQuery(query) {
-        return Object.entries(query)
-            .filter(([_, value]) => typeof value !== 'undefined')
-            .map(([key, value]) => {
-            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-                return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+        var left = data.length - i;
+        if (left > 0) {
+            var c = (data[i] << 16) | (left === 2 ? data[i + 1] << 8 : 0);
+            out += this._encodeByte((c >>> 3 * 6) & 63);
+            out += this._encodeByte((c >>> 2 * 6) & 63);
+            if (left === 2) {
+                out += this._encodeByte((c >>> 1 * 6) & 63);
             }
-            if (value === null) {
-                return `${encodeURIComponent(key)}=`;
+            else {
+                out += this._paddingCharacter || "";
             }
-            throw new DodoPaymentsError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
-        })
-            .join('&');
-    }
-    getUserAgent() {
-        return `${this.constructor.name}/JS ${VERSION}`;
-    }
-    defaultIdempotencyKey() {
-        return `stainless-node-retry-${uuid4()}`;
-    }
-    makeStatusError(status, error, message, headers) {
-        return APIError.generate(status, error, message, headers);
-    }
-    buildURL(path, query, defaultBaseURL) {
-        const baseURL = (!__classPrivateFieldGet(this, _DodoPayments_instances, "m", _DodoPayments_baseURLOverridden).call(this) && defaultBaseURL) || this.baseURL;
-        const url = isAbsoluteURL(path) ?
-            new URL(path)
-            : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
-        const defaultQuery = this.defaultQuery();
-        if (!isEmptyObj(defaultQuery)) {
-            query = { ...defaultQuery, ...query };
+            out += this._paddingCharacter || "";
         }
-        if (typeof query === 'object' && query && !Array.isArray(query)) {
-            url.search = this.stringifyQuery(query);
+        return out;
+    };
+    Coder.prototype.maxDecodedLength = function (length) {
+        if (!this._paddingCharacter) {
+            return (length * 6 + 7) / 8 | 0;
         }
-        return url.toString();
-    }
-    /**
-     * Used as a callback for mutating the given `FinalRequestOptions` object.
-     */
-    async prepareOptions(options) { }
-    /**
-     * Used as a callback for mutating the given `RequestInit` object.
-     *
-     * This is useful for cases where you want to add certain headers based off of
-     * the request properties, e.g. `method` or `url`.
-     */
-    async prepareRequest(request, { url, options }) { }
-    get(path, opts) {
-        return this.methodRequest('get', path, opts);
-    }
-    post(path, opts) {
-        return this.methodRequest('post', path, opts);
-    }
-    patch(path, opts) {
-        return this.methodRequest('patch', path, opts);
-    }
-    put(path, opts) {
-        return this.methodRequest('put', path, opts);
-    }
-    delete(path, opts) {
-        return this.methodRequest('delete', path, opts);
-    }
-    methodRequest(method, path, opts) {
-        return this.request(Promise.resolve(opts).then((opts) => {
-            return { method, path, ...opts };
-        }));
-    }
-    request(options, remainingRetries = null) {
-        return new APIPromise(this, this.makeRequest(options, remainingRetries, undefined));
-    }
-    async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
-        const options = await optionsInput;
-        const maxRetries = options.maxRetries ?? this.maxRetries;
-        if (retriesRemaining == null) {
-            retriesRemaining = maxRetries;
-        }
-        await this.prepareOptions(options);
-        const { req, url, timeout } = await this.buildRequest(options, {
-            retryCount: maxRetries - retriesRemaining,
-        });
-        await this.prepareRequest(req, { url, options });
-        /** Not an API request ID, just for correlating local log entries. */
-        const requestLogID = 'log_' + ((Math.random() * (1 << 24)) | 0).toString(16).padStart(6, '0');
-        const retryLogStr = retryOfRequestLogID === undefined ? '' : `, retryOf: ${retryOfRequestLogID}`;
-        const startTime = Date.now();
-        loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({
-            retryOfRequestLogID,
-            method: options.method,
-            url,
-            options,
-            headers: req.headers,
-        }));
-        if (options.signal?.aborted) {
-            throw new APIUserAbortError();
-        }
-        const controller = new AbortController();
-        const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
-        const headersTime = Date.now();
-        if (response instanceof globalThis.Error) {
-            const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
-            if (options.signal?.aborted) {
-                throw new APIUserAbortError();
-            }
-            // detect native connection timeout errors
-            // deno throws "TypeError: error sending request for url (https://example/): client error (Connect): tcp connect error: Operation timed out (os error 60): Operation timed out (os error 60)"
-            // undici throws "TypeError: fetch failed" with cause "ConnectTimeoutError: Connect Timeout Error (attempted address: example:443, timeout: 1ms)"
-            // others do not provide enough information to distinguish timeouts from other connection errors
-            const isTimeout = isAbortError(response) ||
-                /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : ''));
-            if (retriesRemaining) {
-                loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`);
-                loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (${retryMessage})`, formatRequestDetails({
-                    retryOfRequestLogID,
-                    url,
-                    durationMs: headersTime - startTime,
-                    message: response.message,
-                }));
-                return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
-            }
-            loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - error; no more retries left`);
-            loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (error; no more retries left)`, formatRequestDetails({
-                retryOfRequestLogID,
-                url,
-                durationMs: headersTime - startTime,
-                message: response.message,
-            }));
-            if (isTimeout) {
-                throw new APIConnectionTimeoutError();
-            }
-            throw new APIConnectionError({ cause: response });
-        }
-        const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? 'succeeded' : 'failed'} with status ${response.status} in ${headersTime - startTime}ms`;
-        if (!response.ok) {
-            const shouldRetry = await this.shouldRetry(response);
-            if (retriesRemaining && shouldRetry) {
-                const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
-                // We don't need the body of this response.
-                await CancelReadableStream(response.body);
-                loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
-                loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
-                    retryOfRequestLogID,
-                    url: response.url,
-                    status: response.status,
-                    headers: response.headers,
-                    durationMs: headersTime - startTime,
-                }));
-                return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
-            }
-            const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
-            loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
-            const errText = await response.text().catch((err) => castToError(err).message);
-            const errJSON = safeJSON(errText);
-            const errMessage = errJSON ? undefined : errText;
-            loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
-                retryOfRequestLogID,
-                url: response.url,
-                status: response.status,
-                headers: response.headers,
-                message: errMessage,
-                durationMs: Date.now() - startTime,
-            }));
-            const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
-            throw err;
-        }
-        loggerFor(this).info(responseInfo);
-        loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
-            retryOfRequestLogID,
-            url: response.url,
-            status: response.status,
-            headers: response.headers,
-            durationMs: headersTime - startTime,
-        }));
-        return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
-    }
-    getAPIList(path, Page, opts) {
-        return this.requestAPIList(Page, { method: 'get', path, ...opts });
-    }
-    requestAPIList(Page, options) {
-        const request = this.makeRequest(options, null, undefined);
-        return new PagePromise(this, request, Page);
-    }
-    async fetchWithTimeout(url, init, ms, controller) {
-        const { signal, method, ...options } = init || {};
-        if (signal)
-            signal.addEventListener('abort', () => controller.abort());
-        const timeout = setTimeout(() => controller.abort(), ms);
-        const isReadableBody = (globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream) ||
-            (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body);
-        const fetchOptions = {
-            signal: controller.signal,
-            ...(isReadableBody ? { duplex: 'half' } : {}),
-            method: 'GET',
-            ...options,
-        };
-        if (method) {
-            // Custom methods like 'patch' need to be uppercased
-            // See https://github.com/nodejs/undici/issues/2294
-            fetchOptions.method = method.toUpperCase();
+        return length / 4 * 3 | 0;
+    };
+    Coder.prototype.decodedLength = function (s) {
+        return this.maxDecodedLength(s.length - this._getPaddingLength(s));
+    };
+    Coder.prototype.decode = function (s) {
+        if (s.length === 0) {
+            return new Uint8Array(0);
         }
-        try {
-            // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
-            return await this.fetch.call(undefined, url, fetchOptions);
+        var paddingLength = this._getPaddingLength(s);
+        var length = s.length - paddingLength;
+        var out = new Uint8Array(this.maxDecodedLength(length));
+        var op = 0;
+        var i = 0;
+        var haveBad = 0;
+        var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
+        for (; i < length - 4; i += 4) {
+            v0 = this._decodeChar(s.charCodeAt(i + 0));
+            v1 = this._decodeChar(s.charCodeAt(i + 1));
+            v2 = this._decodeChar(s.charCodeAt(i + 2));
+            v3 = this._decodeChar(s.charCodeAt(i + 3));
+            out[op++] = (v0 << 2) | (v1 >>> 4);
+            out[op++] = (v1 << 4) | (v2 >>> 2);
+            out[op++] = (v2 << 6) | v3;
+            haveBad |= v0 & INVALID_BYTE;
+            haveBad |= v1 & INVALID_BYTE;
+            haveBad |= v2 & INVALID_BYTE;
+            haveBad |= v3 & INVALID_BYTE;
         }
-        finally {
-            clearTimeout(timeout);
+        if (i < length - 1) {
+            v0 = this._decodeChar(s.charCodeAt(i));
+            v1 = this._decodeChar(s.charCodeAt(i + 1));
+            out[op++] = (v0 << 2) | (v1 >>> 4);
+            haveBad |= v0 & INVALID_BYTE;
+            haveBad |= v1 & INVALID_BYTE;
         }
-    }
-    async shouldRetry(response) {
-        // Note this is not a standard header.
-        const shouldRetryHeader = response.headers.get('x-should-retry');
-        // If the server explicitly says whether or not to retry, obey.
-        if (shouldRetryHeader === 'true')
-            return true;
-        if (shouldRetryHeader === 'false')
-            return false;
-        // Retry on request timeouts.
-        if (response.status === 408)
-            return true;
-        // Retry on lock timeouts.
-        if (response.status === 409)
-            return true;
-        // Retry on rate limits.
-        if (response.status === 429)
-            return true;
-        // Retry internal errors.
-        if (response.status >= 500)
-            return true;
-        return false;
-    }
-    async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
-        let timeoutMillis;
-        // Note the `retry-after-ms` header may not be standard, but is a good idea and we'd like proactive support for it.
-        const retryAfterMillisHeader = responseHeaders?.get('retry-after-ms');
-        if (retryAfterMillisHeader) {
-            const timeoutMs = parseFloat(retryAfterMillisHeader);
-            if (!Number.isNaN(timeoutMs)) {
-                timeoutMillis = timeoutMs;
-            }
+        if (i < length - 2) {
+            v2 = this._decodeChar(s.charCodeAt(i + 2));
+            out[op++] = (v1 << 4) | (v2 >>> 2);
+            haveBad |= v2 & INVALID_BYTE;
         }
-        // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
-        const retryAfterHeader = responseHeaders?.get('retry-after');
-        if (retryAfterHeader && !timeoutMillis) {
-            const timeoutSeconds = parseFloat(retryAfterHeader);
-            if (!Number.isNaN(timeoutSeconds)) {
-                timeoutMillis = timeoutSeconds * 1000;
-            }
-            else {
-                timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
-            }
+        if (i < length - 3) {
+            v3 = this._decodeChar(s.charCodeAt(i + 3));
+            out[op++] = (v2 << 6) | v3;
+            haveBad |= v3 & INVALID_BYTE;
         }
-        // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
-        // just do what it says, but otherwise calculate a default
-        if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
-            const maxRetries = options.maxRetries ?? this.maxRetries;
-            timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+        if (haveBad !== 0) {
+            throw new Error("Base64Coder: incorrect characters for decoding");
         }
-        await sleep(timeoutMillis);
-        return this.makeRequest(options, retriesRemaining - 1, requestLogID);
-    }
-    calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
-        const initialRetryDelay = 0.5;
-        const maxRetryDelay = 8.0;
-        const numRetries = maxRetries - retriesRemaining;
-        // Apply exponential backoff, but not more than the max.
-        const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
-        // Apply some jitter, take up to at most 25 percent of the retry time.
-        const jitter = 1 - Math.random() * 0.25;
-        return sleepSeconds * jitter * 1000;
-    }
-    async buildRequest(inputOptions, { retryCount = 0 } = {}) {
-        const options = { ...inputOptions };
-        const { method, path, query, defaultBaseURL } = options;
-        const url = this.buildURL(path, query, defaultBaseURL);
-        if ('timeout' in options)
-            validatePositiveInteger('timeout', options.timeout);
-        options.timeout = options.timeout ?? this.timeout;
-        const { bodyHeaders, body } = this.buildBody({ options });
-        const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
-        const req = {
-            method,
-            headers: reqHeaders,
-            ...(options.signal && { signal: options.signal }),
-            ...(globalThis.ReadableStream &&
-                body instanceof globalThis.ReadableStream && { duplex: 'half' }),
-            ...(body && { body }),
-            ...(this.fetchOptions ?? {}),
-            ...(options.fetchOptions ?? {}),
-        };
-        return { req, url, timeout: options.timeout };
-    }
-    async buildHeaders({ options, method, bodyHeaders, retryCount, }) {
-        let idempotencyHeaders = {};
-        if (this.idempotencyHeader && method !== 'get') {
-            if (!options.idempotencyKey)
-                options.idempotencyKey = this.defaultIdempotencyKey();
-            idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
-        }
-        const headers = buildHeaders([
-            idempotencyHeaders,
-            {
-                Accept: 'application/json',
-                'User-Agent': this.getUserAgent(),
-                'X-Stainless-Retry-Count': String(retryCount),
-                ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
-                ...getPlatformHeaders(),
-            },
-            await this.authHeaders(options),
-            this._options.defaultHeaders,
-            bodyHeaders,
-            options.headers,
-        ]);
-        this.validateHeaders(headers);
-        return headers.values;
-    }
-    buildBody({ options: { body, headers: rawHeaders } }) {
-        if (!body) {
-            return { bodyHeaders: undefined, body: undefined };
-        }
-        const headers = buildHeaders([rawHeaders]);
-        if (
-        // Pass raw type verbatim
-        ArrayBuffer.isView(body) ||
-            body instanceof ArrayBuffer ||
-            body instanceof DataView ||
-            (typeof body === 'string' &&
-                // Preserve legacy string encoding behavior for now
-                headers.values.has('content-type')) ||
-            // `Blob` is superset of `File`
-            (globalThis.Blob && body instanceof globalThis.Blob) ||
-            // `FormData` -> `multipart/form-data`
-            body instanceof FormData ||
-            // `URLSearchParams` -> `application/x-www-form-urlencoded`
-            body instanceof URLSearchParams ||
-            // Send chunked stream (each chunk has own `length`)
-            (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) {
-            return { bodyHeaders: undefined, body: body };
-        }
-        else if (typeof body === 'object' &&
-            (Symbol.asyncIterator in body ||
-                (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
-            return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
-        }
-        else {
-            return __classPrivateFieldGet(this, _DodoPayments_encoder, "f").call(this, { body, headers });
+        return out;
+    };
+    // Standard encoding have the following encoded/decoded ranges,
+    // which we need to convert between.
+    //
+    // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  +   /
+    // Index:   0 - 25                    26 - 51              52 - 61   62  63
+    // ASCII:  65 - 90                    97 - 122             48 - 57   43  47
+    //
+    // Encode 6 bits in b into a new character.
+    Coder.prototype._encodeByte = function (b) {
+        // Encoding uses constant time operations as follows:
+        //
+        // 1. Define comparison of A with B using (A - B) >>> 8:
+        //          if A > B, then result is positive integer
+        //          if A <= B, then result is 0
+        //
+        // 2. Define selection of C or 0 using bitwise AND: X & C:
+        //          if X == 0, then result is 0
+        //          if X != 0, then result is C
+        //
+        // 3. Start with the smallest comparison (b >= 0), which is always
+        //    true, so set the result to the starting ASCII value (65).
+        //
+        // 4. Continue comparing b to higher ASCII values, and selecting
+        //    zero if comparison isn't true, otherwise selecting a value
+        //    to add to result, which:
+        //
+        //          a) undoes the previous addition
+        //          b) provides new value to add
+        //
+        var result = b;
+        // b >= 0
+        result += 65;
+        // b > 25
+        result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
+        // b > 51
+        result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
+        // b > 61
+        result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 43);
+        // b > 62
+        result += ((62 - b) >>> 8) & ((62 - 43) - 63 + 47);
+        return String.fromCharCode(result);
+    };
+    // Decode a character code into a byte.
+    // Must return 256 if character is out of alphabet range.
+    Coder.prototype._decodeChar = function (c) {
+        // Decoding works similar to encoding: using the same comparison
+        // function, but now it works on ranges: result is always incremented
+        // by value, but this value becomes zero if the range is not
+        // satisfied.
+        //
+        // Decoding starts with invalid value, 256, which is then
+        // subtracted when the range is satisfied. If none of the ranges
+        // apply, the function returns 256, which is then checked by
+        // the caller to throw error.
+        var result = INVALID_BYTE; // start with invalid character
+        // c == 43 (c > 42 and c < 44)
+        result += (((42 - c) & (c - 44)) >>> 8) & (-INVALID_BYTE + c - 43 + 62);
+        // c == 47 (c > 46 and c < 48)
+        result += (((46 - c) & (c - 48)) >>> 8) & (-INVALID_BYTE + c - 47 + 63);
+        // c > 47 and c < 58
+        result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
+        // c > 64 and c < 91
+        result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
+        // c > 96 and c < 123
+        result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
+        return result;
+    };
+    Coder.prototype._getPaddingLength = function (s) {
+        var paddingLength = 0;
+        if (this._paddingCharacter) {
+            for (var i = s.length - 1; i >= 0; i--) {
+                if (s[i] !== this._paddingCharacter) {
+                    break;
+                }
+                paddingLength++;
+            }
+            if (s.length < 4 || paddingLength > 2) {
+                throw new Error("Base64Coder: incorrect padding");
+            }
         }
+        return paddingLength;
+    };
+    return Coder;
+}());
+base64$1.Coder = Coder;
+var stdCoder = new Coder();
+function encode(data) {
+    return stdCoder.encode(data);
+}
+base64$1.encode = encode;
+function decode(s) {
+    return stdCoder.decode(s);
+}
+base64$1.decode = decode;
+/**
+ * Implements URL-safe Base64 encoding.
+ * (Same as Base64, but '+' is replaced with '-', and '/' with '_').
+ *
+ * Operates in constant time.
+ */
+var URLSafeCoder = /** @class */ (function (_super) {
+    __extends(URLSafeCoder, _super);
+    function URLSafeCoder() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
+    // URL-safe encoding have the following encoded/decoded ranges:
+    //
+    // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  -   _
+    // Index:   0 - 25                    26 - 51              52 - 61   62  63
+    // ASCII:  65 - 90                    97 - 122             48 - 57   45  95
+    //
+    URLSafeCoder.prototype._encodeByte = function (b) {
+        var result = b;
+        // b >= 0
+        result += 65;
+        // b > 25
+        result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
+        // b > 51
+        result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
+        // b > 61
+        result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 45);
+        // b > 62
+        result += ((62 - b) >>> 8) & ((62 - 45) - 63 + 95);
+        return String.fromCharCode(result);
+    };
+    URLSafeCoder.prototype._decodeChar = function (c) {
+        var result = INVALID_BYTE;
+        // c == 45 (c > 44 and c < 46)
+        result += (((44 - c) & (c - 46)) >>> 8) & (-INVALID_BYTE + c - 45 + 62);
+        // c == 95 (c > 94 and c < 96)
+        result += (((94 - c) & (c - 96)) >>> 8) & (-INVALID_BYTE + c - 95 + 63);
+        // c > 47 and c < 58
+        result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
+        // c > 64 and c < 91
+        result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
+        // c > 96 and c < 123
+        result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
+        return result;
+    };
+    return URLSafeCoder;
+}(Coder));
+base64$1.URLSafeCoder = URLSafeCoder;
+var urlSafeCoder = new URLSafeCoder();
+function encodeURLSafe(data) {
+    return urlSafeCoder.encode(data);
 }
-_a = DodoPayments, _DodoPayments_encoder = new WeakMap(), _DodoPayments_instances = new WeakSet(), _DodoPayments_baseURLOverridden = function _DodoPayments_baseURLOverridden() {
-    return this.baseURL !== environments[this._options.environment || 'live_mode'];
+base64$1.encodeURLSafe = encodeURLSafe;
+function decodeURLSafe(s) {
+    return urlSafeCoder.decode(s);
+}
+base64$1.decodeURLSafe = decodeURLSafe;
+base64$1.encodedLength = function (length) {
+    return stdCoder.encodedLength(length);
 };
-DodoPayments.DodoPayments = _a;
-DodoPayments.DEFAULT_TIMEOUT = 60000; // 1 minute
-DodoPayments.DodoPaymentsError = DodoPaymentsError;
-DodoPayments.APIError = APIError;
-DodoPayments.APIConnectionError = APIConnectionError;
-DodoPayments.APIConnectionTimeoutError = APIConnectionTimeoutError;
-DodoPayments.APIUserAbortError = APIUserAbortError;
-DodoPayments.NotFoundError = NotFoundError;
-DodoPayments.ConflictError = ConflictError;
-DodoPayments.RateLimitError = RateLimitError;
-DodoPayments.BadRequestError = BadRequestError;
-DodoPayments.AuthenticationError = AuthenticationError;
-DodoPayments.InternalServerError = InternalServerError;
-DodoPayments.PermissionDeniedError = PermissionDeniedError;
-DodoPayments.UnprocessableEntityError = UnprocessableEntityError;
-DodoPayments.toFile = toFile;
-DodoPayments.CheckoutSessions = CheckoutSessions;
-DodoPayments.Payments = Payments;
-DodoPayments.Subscriptions = Subscriptions;
-DodoPayments.Invoices = Invoices;
-DodoPayments.Licenses = Licenses;
-DodoPayments.LicenseKeys = LicenseKeys;
-DodoPayments.LicenseKeyInstances = LicenseKeyInstances;
-DodoPayments.Customers = Customers;
-DodoPayments.Refunds = Refunds;
-DodoPayments.Disputes = Disputes;
-DodoPayments.Payouts = Payouts;
-DodoPayments.WebhookEvents = WebhookEvents;
-DodoPayments.Products = Products;
-DodoPayments.Misc = Misc;
-DodoPayments.Discounts = Discounts;
-DodoPayments.Addons = Addons;
-DodoPayments.Brands = Brands;
-DodoPayments.Webhooks = Webhooks$1;
-DodoPayments.UsageEvents = UsageEvents;
-DodoPayments.Meters = Meters;
-
-// src/checkout/checkout.ts
-var checkoutQuerySchema = objectType({
-  productId: stringType(),
-  quantity: stringType().optional(),
-  // Customer fields
-  fullName: stringType().optional(),
-  firstName: stringType().optional(),
-  lastName: stringType().optional(),
-  email: stringType().optional(),
-  country: stringType().optional(),
-  addressLine: stringType().optional(),
-  city: stringType().optional(),
-  state: stringType().optional(),
-  zipCode: stringType().optional(),
-  // Disable flags
-  disableFullName: stringType().optional(),
-  disableFirstName: stringType().optional(),
-  disableLastName: stringType().optional(),
-  disableEmail: stringType().optional(),
-  disableCountry: stringType().optional(),
-  disableAddressLine: stringType().optional(),
-  disableCity: stringType().optional(),
-  disableState: stringType().optional(),
-  disableZipCode: stringType().optional(),
-  // Advanced controls
-  paymentCurrency: stringType().optional(),
-  showCurrencySelector: stringType().optional(),
-  paymentAmount: stringType().optional(),
-  showDiscounts: stringType().optional()
-  // Metadata (allow any key starting with metadata_)
-  // We'll handle metadata separately in the handler
-}).catchall(unknownType());
-var dynamicCheckoutBodySchema = objectType({
-  // For subscription
-  product_id: stringType().optional(),
-  quantity: numberType().optional(),
-  // For one-time payment
-  product_cart: arrayType(
-    objectType({
-      product_id: stringType(),
-      quantity: numberType()
-    })
-  ).optional(),
-  // Common fields
-  billing: objectType({
-    city: stringType(),
-    country: stringType(),
-    state: stringType(),
-    street: stringType(),
-    zipcode: stringType()
-  }),
-  customer: objectType({
-    customer_id: stringType().optional(),
-    email: stringType().optional(),
-    name: stringType().optional()
-  }),
-  discount_id: stringType().optional(),
-  addons: arrayType(
-    objectType({
-      addon_id: stringType(),
-      quantity: numberType()
-    })
-  ).optional(),
-  metadata: recordType(stringType(), stringType()).optional(),
-  currency: stringType().optional()
-  // Allow any additional fields (for future compatibility)
-}).catchall(unknownType());
-var checkoutSessionProductCartItemSchema = objectType({
-  product_id: stringType().min(1, "Product ID is required"),
-  quantity: numberType().int().positive("Quantity must be a positive integer")
-});
-var checkoutSessionCustomerSchema = objectType({
-  email: stringType().email().optional(),
-  name: stringType().min(1).optional(),
-  phone_number: stringType().optional()
-}).optional();
-var checkoutSessionBillingAddressSchema = objectType({
-  street: stringType().optional(),
-  city: stringType().optional(),
-  state: stringType().optional(),
-  country: stringType().length(2, "Country must be a 2-letter ISO code"),
-  zipcode: stringType().optional()
-}).optional();
-var paymentMethodTypeSchema = enumType([
-  "credit",
-  "debit",
-  "upi_collect",
-  "upi_intent",
-  "apple_pay",
-  "google_pay",
-  "amazon_pay",
-  "klarna",
-  "affirm",
-  "afterpay_clearpay",
-  "sepa",
-  "ach"
-]);
-var checkoutSessionCustomizationSchema = objectType({
-  theme: enumType(["light", "dark", "system"]).optional(),
-  show_order_details: booleanType().optional(),
-  show_on_demand_tag: booleanType().optional()
-}).optional();
-var checkoutSessionFeatureFlagsSchema = objectType({
-  allow_currency_selection: booleanType().optional(),
-  allow_discount_code: booleanType().optional(),
-  allow_phone_number_collection: booleanType().optional(),
-  allow_tax_id: booleanType().optional(),
-  always_create_new_customer: booleanType().optional()
-}).optional();
-var checkoutSessionSubscriptionDataSchema = objectType({
-  trial_period_days: numberType().int().nonnegative().optional()
-}).optional();
-var checkoutSessionPayloadSchema = objectType({
-  // Required fields
-  product_cart: arrayType(checkoutSessionProductCartItemSchema).min(1, "At least one product is required"),
-  // Optional fields
-  customer: checkoutSessionCustomerSchema,
-  billing_address: checkoutSessionBillingAddressSchema,
-  return_url: stringType().url().optional(),
-  allowed_payment_method_types: arrayType(paymentMethodTypeSchema).optional(),
-  billing_currency: stringType().length(3, "Currency must be a 3-letter ISO code").optional(),
-  show_saved_payment_methods: booleanType().optional(),
-  confirm: booleanType().optional(),
-  discount_code: stringType().optional(),
-  metadata: recordType(stringType(), stringType()).optional(),
-  customization: checkoutSessionCustomizationSchema,
-  feature_flags: checkoutSessionFeatureFlagsSchema,
-  subscription_data: checkoutSessionSubscriptionDataSchema
-});
-var checkoutSessionResponseSchema = objectType({
-  session_id: stringType().min(1, "Session ID is required"),
-  checkout_url: stringType().url("Invalid checkout URL")
-});
-var createCheckoutSession = async (payload, config) => {
-  const validation = checkoutSessionPayloadSchema.safeParse(payload);
-  if (!validation.success) {
-    throw new Error(
-      `Invalid checkout session payload: ${validation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ")}`
-    );
-  }
-  const dodopayments = new DodoPayments({
-    bearerToken: config.bearerToken,
-    environment: config.environment
-  });
-  try {
-    const sdkPayload = {
-      ...validation.data,
-      ...validation.data.billing_address && {
-        billing_address: {
-          ...validation.data.billing_address,
-          country: validation.data.billing_address.country
-        }
-      }
-    };
-    const session = await dodopayments.checkoutSessions.create(
-      sdkPayload
-    );
-    const responseValidation = checkoutSessionResponseSchema.safeParse(session);
-    if (!responseValidation.success) {
-      throw new Error(
-        `Invalid checkout session response from API: ${responseValidation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ")}`
-      );
-    }
-    return responseValidation.data;
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error("Dodo Payments Checkout Session API Error:", {
-        message: error.message,
-        payload: validation.data,
-        config: {
-          environment: config.environment,
-          hasBearerToken: !!config.bearerToken
-        }
-      });
-      throw new Error(`Failed to create checkout session: ${error.message}`);
-    }
-    console.error("Unknown error creating checkout session:", error);
-    throw new Error(
-      "Failed to create checkout session due to an unknown error"
-    );
-  }
+base64$1.maxDecodedLength = function (length) {
+    return stdCoder.maxDecodedLength(length);
 };
-var buildCheckoutUrl = async ({
-  queryParams,
-  body,
-  sessionPayload,
-  returnUrl,
-  bearerToken,
-  environment,
-  type = "static"
-}) => {
-  if (type === "session") {
-    if (!sessionPayload) {
-      throw new Error("sessionPayload is required when type is 'session'");
-    }
-    const session = await createCheckoutSession(sessionPayload, {
-      bearerToken,
-      environment
-    });
-    return session.checkout_url;
-  }
-  const inputData = type === "dynamic" ? body : queryParams;
-  let parseResult;
-  if (type === "dynamic") {
-    parseResult = dynamicCheckoutBodySchema.safeParse(inputData);
-  } else {
-    parseResult = checkoutQuerySchema.safeParse(inputData);
-  }
-  const { success, data, error } = parseResult;
-  if (!success) {
-    throw new Error(
-      `Invalid ${type === "dynamic" ? "body" : "query parameters"}.
- ${error.message}`
-    );
-  }
-  if (type !== "dynamic") {
-    const {
-      productId,
-      quantity: quantity2,
-      fullName,
-      firstName,
-      lastName,
-      email,
-      country,
-      addressLine,
-      city,
-      state,
-      zipCode,
-      disableFullName,
-      disableFirstName,
-      disableLastName,
-      disableEmail,
-      disableCountry,
-      disableAddressLine,
-      disableCity,
-      disableState,
-      disableZipCode,
-      paymentCurrency,
-      showCurrencySelector,
-      paymentAmount,
-      showDiscounts
-      // metadata handled below
-    } = data;
-    const dodopayments2 = new DodoPayments({
-      bearerToken,
-      environment
-    });
-    if (!productId) throw new Error("Missing required field: productId");
-    try {
-      await dodopayments2.products.retrieve(productId);
-    } catch (err) {
-      console.error(err);
-      throw new Error("Product not found");
-    }
-    const url = new URL(
-      `${environment === "test_mode" ? "https://test.checkout.dodopayments.com" : "https://checkout.dodopayments.com"}/buy/${productId}`
-    );
-    url.searchParams.set("quantity", quantity2 ? String(quantity2) : "1");
-    if (returnUrl) url.searchParams.set("redirect_url", returnUrl);
-    if (fullName) url.searchParams.set("fullName", String(fullName));
-    if (firstName) url.searchParams.set("firstName", String(firstName));
-    if (lastName) url.searchParams.set("lastName", String(lastName));
-    if (email) url.searchParams.set("email", String(email));
-    if (country) url.searchParams.set("country", String(country));
-    if (addressLine) url.searchParams.set("addressLine", String(addressLine));
-    if (city) url.searchParams.set("city", String(city));
-    if (state) url.searchParams.set("state", String(state));
-    if (zipCode) url.searchParams.set("zipCode", String(zipCode));
-    if (disableFullName === "true")
-      url.searchParams.set("disableFullName", "true");
-    if (disableFirstName === "true")
-      url.searchParams.set("disableFirstName", "true");
-    if (disableLastName === "true")
-      url.searchParams.set("disableLastName", "true");
-    if (disableEmail === "true") url.searchParams.set("disableEmail", "true");
-    if (disableCountry === "true")
-      url.searchParams.set("disableCountry", "true");
-    if (disableAddressLine === "true")
-      url.searchParams.set("disableAddressLine", "true");
-    if (disableCity === "true") url.searchParams.set("disableCity", "true");
-    if (disableState === "true") url.searchParams.set("disableState", "true");
-    if (disableZipCode === "true")
-      url.searchParams.set("disableZipCode", "true");
-    if (paymentCurrency)
-      url.searchParams.set("paymentCurrency", String(paymentCurrency));
-    if (showCurrencySelector)
-      url.searchParams.set(
-        "showCurrencySelector",
-        String(showCurrencySelector)
-      );
-    if (paymentAmount)
-      url.searchParams.set("paymentAmount", String(paymentAmount));
-    if (showDiscounts)
-      url.searchParams.set("showDiscounts", String(showDiscounts));
-    for (const [key, value] of Object.entries(queryParams || {})) {
-      if (key.startsWith("metadata_") && value && typeof value !== "object") {
-        url.searchParams.set(key, String(value));
-      }
-    }
-    return url.toString();
-  }
-  const dyn = data;
-  const {
-    product_id,
-    product_cart,
-    quantity,
-    billing,
-    customer,
-    addons,
-    metadata,
-    allowed_payment_method_types,
-    billing_currency,
-    discount_code,
-    on_demand,
-    return_url: bodyReturnUrl,
-    show_saved_payment_methods,
-    tax_id,
-    trial_period_days
-  } = dyn;
-  const dodopayments = new DodoPayments({
-    bearerToken,
-    environment
-  });
-  let isSubscription = false;
-  let productIdToFetch = product_id;
-  if (!product_id && product_cart && product_cart.length > 0) {
-    productIdToFetch = product_cart[0].product_id;
-  }
-  if (!productIdToFetch)
-    throw new Error(
-      "Missing required field: product_id or product_cart[0].product_id"
-    );
-  let product;
-  try {
-    product = await dodopayments.products.retrieve(productIdToFetch);
-  } catch (err) {
-    console.error(err);
-    throw new Error("Product not found");
-  }
-  isSubscription = Boolean(product.is_recurring);
-  if (isSubscription && !product_id)
-    throw new Error("Missing required field: product_id for subscription");
-  if (!billing) throw new Error("Missing required field: billing");
-  if (!customer) throw new Error("Missing required field: customer");
-  if (isSubscription) {
-    const subscriptionPayload = {
-      billing,
-      customer,
-      product_id,
-      quantity: quantity ? Number(quantity) : 1
-    };
-    if (metadata) subscriptionPayload.metadata = metadata;
-    if (discount_code) subscriptionPayload.discount_code = discount_code;
-    if (addons) subscriptionPayload.addons = addons;
-    if (allowed_payment_method_types)
-      subscriptionPayload.allowed_payment_method_types = allowed_payment_method_types;
-    if (billing_currency)
-      subscriptionPayload.billing_currency = billing_currency;
-    if (on_demand) subscriptionPayload.on_demand = on_demand;
-    subscriptionPayload.payment_link = true;
-    if (bodyReturnUrl) {
-      subscriptionPayload.return_url = bodyReturnUrl;
-    } else if (returnUrl) {
-      subscriptionPayload.return_url = returnUrl;
-    }
-    if (show_saved_payment_methods)
-      subscriptionPayload.show_saved_payment_methods = show_saved_payment_methods;
-    if (tax_id) subscriptionPayload.tax_id = tax_id;
-    if (trial_period_days)
-      subscriptionPayload.trial_period_days = trial_period_days;
-    let subscription;
-    try {
-      subscription = await dodopayments.subscriptions.create(subscriptionPayload);
-    } catch (err) {
-      console.error("Error when creating subscription", err);
-      throw new Error(err instanceof Error ? err.message : String(err));
-    }
-    if (!subscription || !subscription.payment_link) {
-      throw new Error(
-        "No payment link returned from Dodo Payments API (subscription). Make sure to set payment_link as true in payload"
-      );
-    }
-    return subscription.payment_link;
-  } else {
-    let cart = product_cart;
-    if (!cart && product_id) {
-      cart = [
-        { product_id, quantity: quantity ? Number(quantity) : 1 }
-      ];
-    }
-    if (!cart || cart.length === 0)
-      throw new Error("Missing required field: product_cart or product_id");
-    const paymentPayload = {
-      billing,
-      customer,
-      product_cart: cart
-    };
-    if (metadata) paymentPayload.metadata = metadata;
-    paymentPayload.payment_link = true;
-    if (allowed_payment_method_types)
-      paymentPayload.allowed_payment_method_types = allowed_payment_method_types;
-    if (billing_currency) paymentPayload.billing_currency = billing_currency;
-    if (discount_code) paymentPayload.discount_code = discount_code;
-    if (bodyReturnUrl) {
-      paymentPayload.return_url = bodyReturnUrl;
-    } else if (returnUrl) {
-      paymentPayload.return_url = returnUrl;
-    }
-    if (show_saved_payment_methods)
-      paymentPayload.show_saved_payment_methods = show_saved_payment_methods;
-    if (tax_id) paymentPayload.tax_id = tax_id;
-    let payment;
-    try {
-      payment = await dodopayments.payments.create(paymentPayload);
-    } catch (err) {
-      console.error("Error when creating payment link", err);
-      throw new Error(err instanceof Error ? err.message : String(err));
-    }
-    if (!payment || !payment.payment_link) {
-      throw new Error(
-        "No payment link returned from Dodo Payments API. Make sure to set payment_link as true in payload."
-      );
-    }
-    return payment.payment_link;
-  }
+base64$1.decodedLength = function (s) {
+    return stdCoder.decodedLength(s);
 };
 
-const Checkout = (config) => {
-    const getHandler = async (req) => {
-        const { searchParams } = new URL(req.url);
-        const queryParams = Object.fromEntries(searchParams);
-        if (!queryParams.productId) {
-            return new serverExports.NextResponse("Please provide productId query parameter", {
-                status: 400,
-            });
-        }
-        const { success, data, error } = checkoutQuerySchema.safeParse(queryParams);
-        if (!success) {
-            if (error.errors.some((e) => e.path.toString() === "productId")) {
-                return new serverExports.NextResponse("Please provide productId query parameter", {
-                    status: 400,
-                });
-            }
-            return new serverExports.NextResponse(`Invalid query parameters.\n ${error.message}`, {
-                status: 400,
-            });
-        }
-        let url = "";
-        try {
-            url = await buildCheckoutUrl({ queryParams: data, ...config });
-        }
-        catch (error) {
-            return new serverExports.NextResponse(error.message, { status: 400 });
-        }
-        return serverExports.NextResponse.json({ checkout_url: url });
-    };
-    const postHandler = async (req) => {
-        let body;
-        try {
-            body = await req.json();
-        }
-        catch (e) {
-            return new serverExports.NextResponse("Invalid JSON body", { status: 400 });
-        }
-        if (config.type === "dynamic") {
-            // Handle dynamic checkout
-            const { success, data, error } = dynamicCheckoutBodySchema.safeParse(body);
-            if (!success) {
-                return new serverExports.NextResponse(`Invalid request body.\n ${error.message}`, {
-                    status: 400,
-                });
-            }
-            let url = "";
-            try {
-                url = await buildCheckoutUrl({
-                    body: data,
-                    ...config,
-                    type: "dynamic",
-                });
-            }
-            catch (error) {
-                return new serverExports.NextResponse(error.message, { status: 400 });
-            }
-            return serverExports.NextResponse.json({ checkout_url: url });
-        }
-        else {
-            // Handle checkout session
-            const { success, data, error } = checkoutSessionPayloadSchema.safeParse(body);
-            if (!success) {
-                return new serverExports.NextResponse(`Invalid checkout session payload.\n ${error.message}`, {
-                    status: 400,
-                });
-            }
-            let url = "";
-            try {
-                url = await buildCheckoutUrl({
-                    sessionPayload: data,
-                    ...config,
-                    type: "session",
-                });
-            }
-            catch (error) {
-                return new serverExports.NextResponse(error.message, { status: 400 });
-            }
-            return serverExports.NextResponse.json({ checkout_url: url });
-        }
-    };
-    return (req) => {
-        if (req.method === "POST") {
-            return postHandler(req);
-        }
-        return getHandler(req);
-    };
-};
-
-var dist = {};
-
-var timing_safe_equal = {};
-
-Object.defineProperty(timing_safe_equal, "__esModule", { value: true });
-timing_safe_equal.timingSafeEqual = void 0;
-function assert(expr, msg = "") {
-    if (!expr) {
-        throw new Error(msg);
-    }
-}
-function timingSafeEqual(a, b) {
-    if (a.byteLength !== b.byteLength) {
-        return false;
-    }
-    if (!(a instanceof DataView)) {
-        a = new DataView(ArrayBuffer.isView(a) ? a.buffer : a);
-    }
-    if (!(b instanceof DataView)) {
-        b = new DataView(ArrayBuffer.isView(b) ? b.buffer : b);
-    }
-    assert(a instanceof DataView);
-    assert(b instanceof DataView);
-    const length = a.byteLength;
-    let out = 0;
-    let i = -1;
-    while (++i < length) {
-        out |= a.getUint8(i) ^ b.getUint8(i);
-    }
-    return out === 0;
-}
-timing_safe_equal.timingSafeEqual = timingSafeEqual;
-
-var base64$1 = {};
-
-// Copyright (C) 2016 Dmitry Chestnykh
-// MIT License. See LICENSE file for details.
-var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(base64$1, "__esModule", { value: true });
-/**
- * Package base64 implements Base64 encoding and decoding.
- */
-// Invalid character used in decoding to indicate
-// that the character to decode is out of range of
-// alphabet and cannot be decoded.
-var INVALID_BYTE = 256;
-/**
- * Implements standard Base64 encoding.
- *
- * Operates in constant time.
- */
-var Coder = /** @class */ (function () {
-    // TODO(dchest): methods to encode chunk-by-chunk.
-    function Coder(_paddingCharacter) {
-        if (_paddingCharacter === void 0) { _paddingCharacter = "="; }
-        this._paddingCharacter = _paddingCharacter;
-    }
-    Coder.prototype.encodedLength = function (length) {
-        if (!this._paddingCharacter) {
-            return (length * 8 + 5) / 6 | 0;
-        }
-        return (length + 2) / 3 * 4 | 0;
-    };
-    Coder.prototype.encode = function (data) {
-        var out = "";
-        var i = 0;
-        for (; i < data.length - 2; i += 3) {
-            var c = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
-            out += this._encodeByte((c >>> 3 * 6) & 63);
-            out += this._encodeByte((c >>> 2 * 6) & 63);
-            out += this._encodeByte((c >>> 1 * 6) & 63);
-            out += this._encodeByte((c >>> 0 * 6) & 63);
-        }
-        var left = data.length - i;
-        if (left > 0) {
-            var c = (data[i] << 16) | (left === 2 ? data[i + 1] << 8 : 0);
-            out += this._encodeByte((c >>> 3 * 6) & 63);
-            out += this._encodeByte((c >>> 2 * 6) & 63);
-            if (left === 2) {
-                out += this._encodeByte((c >>> 1 * 6) & 63);
-            }
-            else {
-                out += this._paddingCharacter || "";
-            }
-            out += this._paddingCharacter || "";
-        }
-        return out;
-    };
-    Coder.prototype.maxDecodedLength = function (length) {
-        if (!this._paddingCharacter) {
-            return (length * 6 + 7) / 8 | 0;
-        }
-        return length / 4 * 3 | 0;
-    };
-    Coder.prototype.decodedLength = function (s) {
-        return this.maxDecodedLength(s.length - this._getPaddingLength(s));
-    };
-    Coder.prototype.decode = function (s) {
-        if (s.length === 0) {
-            return new Uint8Array(0);
-        }
-        var paddingLength = this._getPaddingLength(s);
-        var length = s.length - paddingLength;
-        var out = new Uint8Array(this.maxDecodedLength(length));
-        var op = 0;
-        var i = 0;
-        var haveBad = 0;
-        var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
-        for (; i < length - 4; i += 4) {
-            v0 = this._decodeChar(s.charCodeAt(i + 0));
-            v1 = this._decodeChar(s.charCodeAt(i + 1));
-            v2 = this._decodeChar(s.charCodeAt(i + 2));
-            v3 = this._decodeChar(s.charCodeAt(i + 3));
-            out[op++] = (v0 << 2) | (v1 >>> 4);
-            out[op++] = (v1 << 4) | (v2 >>> 2);
-            out[op++] = (v2 << 6) | v3;
-            haveBad |= v0 & INVALID_BYTE;
-            haveBad |= v1 & INVALID_BYTE;
-            haveBad |= v2 & INVALID_BYTE;
-            haveBad |= v3 & INVALID_BYTE;
-        }
-        if (i < length - 1) {
-            v0 = this._decodeChar(s.charCodeAt(i));
-            v1 = this._decodeChar(s.charCodeAt(i + 1));
-            out[op++] = (v0 << 2) | (v1 >>> 4);
-            haveBad |= v0 & INVALID_BYTE;
-            haveBad |= v1 & INVALID_BYTE;
-        }
-        if (i < length - 2) {
-            v2 = this._decodeChar(s.charCodeAt(i + 2));
-            out[op++] = (v1 << 4) | (v2 >>> 2);
-            haveBad |= v2 & INVALID_BYTE;
-        }
-        if (i < length - 3) {
-            v3 = this._decodeChar(s.charCodeAt(i + 3));
-            out[op++] = (v2 << 6) | v3;
-            haveBad |= v3 & INVALID_BYTE;
-        }
-        if (haveBad !== 0) {
-            throw new Error("Base64Coder: incorrect characters for decoding");
-        }
-        return out;
-    };
-    // Standard encoding have the following encoded/decoded ranges,
-    // which we need to convert between.
-    //
-    // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  +   /
-    // Index:   0 - 25                    26 - 51              52 - 61   62  63
-    // ASCII:  65 - 90                    97 - 122             48 - 57   43  47
-    //
-    // Encode 6 bits in b into a new character.
-    Coder.prototype._encodeByte = function (b) {
-        // Encoding uses constant time operations as follows:
-        //
-        // 1. Define comparison of A with B using (A - B) >>> 8:
-        //          if A > B, then result is positive integer
-        //          if A <= B, then result is 0
-        //
-        // 2. Define selection of C or 0 using bitwise AND: X & C:
-        //          if X == 0, then result is 0
-        //          if X != 0, then result is C
-        //
-        // 3. Start with the smallest comparison (b >= 0), which is always
-        //    true, so set the result to the starting ASCII value (65).
-        //
-        // 4. Continue comparing b to higher ASCII values, and selecting
-        //    zero if comparison isn't true, otherwise selecting a value
-        //    to add to result, which:
-        //
-        //          a) undoes the previous addition
-        //          b) provides new value to add
-        //
-        var result = b;
-        // b >= 0
-        result += 65;
-        // b > 25
-        result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
-        // b > 51
-        result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
-        // b > 61
-        result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 43);
-        // b > 62
-        result += ((62 - b) >>> 8) & ((62 - 43) - 63 + 47);
-        return String.fromCharCode(result);
-    };
-    // Decode a character code into a byte.
-    // Must return 256 if character is out of alphabet range.
-    Coder.prototype._decodeChar = function (c) {
-        // Decoding works similar to encoding: using the same comparison
-        // function, but now it works on ranges: result is always incremented
-        // by value, but this value becomes zero if the range is not
-        // satisfied.
-        //
-        // Decoding starts with invalid value, 256, which is then
-        // subtracted when the range is satisfied. If none of the ranges
-        // apply, the function returns 256, which is then checked by
-        // the caller to throw error.
-        var result = INVALID_BYTE; // start with invalid character
-        // c == 43 (c > 42 and c < 44)
-        result += (((42 - c) & (c - 44)) >>> 8) & (-INVALID_BYTE + c - 43 + 62);
-        // c == 47 (c > 46 and c < 48)
-        result += (((46 - c) & (c - 48)) >>> 8) & (-INVALID_BYTE + c - 47 + 63);
-        // c > 47 and c < 58
-        result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
-        // c > 64 and c < 91
-        result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
-        // c > 96 and c < 123
-        result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
-        return result;
-    };
-    Coder.prototype._getPaddingLength = function (s) {
-        var paddingLength = 0;
-        if (this._paddingCharacter) {
-            for (var i = s.length - 1; i >= 0; i--) {
-                if (s[i] !== this._paddingCharacter) {
-                    break;
-                }
-                paddingLength++;
-            }
-            if (s.length < 4 || paddingLength > 2) {
-                throw new Error("Base64Coder: incorrect padding");
-            }
-        }
-        return paddingLength;
-    };
-    return Coder;
-}());
-base64$1.Coder = Coder;
-var stdCoder = new Coder();
-function encode(data) {
-    return stdCoder.encode(data);
-}
-base64$1.encode = encode;
-function decode(s) {
-    return stdCoder.decode(s);
-}
-base64$1.decode = decode;
-/**
- * Implements URL-safe Base64 encoding.
- * (Same as Base64, but '+' is replaced with '-', and '/' with '_').
- *
- * Operates in constant time.
- */
-var URLSafeCoder = /** @class */ (function (_super) {
-    __extends(URLSafeCoder, _super);
-    function URLSafeCoder() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    // URL-safe encoding have the following encoded/decoded ranges:
-    //
-    // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  -   _
-    // Index:   0 - 25                    26 - 51              52 - 61   62  63
-    // ASCII:  65 - 90                    97 - 122             48 - 57   45  95
-    //
-    URLSafeCoder.prototype._encodeByte = function (b) {
-        var result = b;
-        // b >= 0
-        result += 65;
-        // b > 25
-        result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
-        // b > 51
-        result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
-        // b > 61
-        result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 45);
-        // b > 62
-        result += ((62 - b) >>> 8) & ((62 - 45) - 63 + 95);
-        return String.fromCharCode(result);
-    };
-    URLSafeCoder.prototype._decodeChar = function (c) {
-        var result = INVALID_BYTE;
-        // c == 45 (c > 44 and c < 46)
-        result += (((44 - c) & (c - 46)) >>> 8) & (-INVALID_BYTE + c - 45 + 62);
-        // c == 95 (c > 94 and c < 96)
-        result += (((94 - c) & (c - 96)) >>> 8) & (-INVALID_BYTE + c - 95 + 63);
-        // c > 47 and c < 58
-        result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
-        // c > 64 and c < 91
-        result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
-        // c > 96 and c < 123
-        result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
-        return result;
-    };
-    return URLSafeCoder;
-}(Coder));
-base64$1.URLSafeCoder = URLSafeCoder;
-var urlSafeCoder = new URLSafeCoder();
-function encodeURLSafe(data) {
-    return urlSafeCoder.encode(data);
-}
-base64$1.encodeURLSafe = encodeURLSafe;
-function decodeURLSafe(s) {
-    return urlSafeCoder.decode(s);
-}
-base64$1.decodeURLSafe = decodeURLSafe;
-base64$1.encodedLength = function (length) {
-    return stdCoder.encodedLength(length);
-};
-base64$1.maxDecodedLength = function (length) {
-    return stdCoder.maxDecodedLength(length);
-};
-base64$1.decodedLength = function (s) {
-    return stdCoder.decodedLength(s);
-};
-
-var sha256$1 = {exports: {}};
+var sha256$1 = {exports: {}};
 
 (function (module) {
 	(function (root, factory) {
@@ -12822,96 +12014,1230 @@ class ExtendableError extends Error {
         this.name = "ExtendableError";
         this.stack = new Error(message).stack;
     }
-}
-class WebhookVerificationError extends ExtendableError {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, WebhookVerificationError.prototype);
-        this.name = "WebhookVerificationError";
+}
+class WebhookVerificationError extends ExtendableError {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, WebhookVerificationError.prototype);
+        this.name = "WebhookVerificationError";
+    }
+}
+var WebhookVerificationError_1 = dist.WebhookVerificationError = WebhookVerificationError;
+class Webhook {
+    constructor(secret, options) {
+        if (!secret) {
+            throw new Error("Secret can't be empty.");
+        }
+        if ((options === null || options === void 0 ? void 0 : options.format) === "raw") {
+            if (secret instanceof Uint8Array) {
+                this.key = secret;
+            }
+            else {
+                this.key = Uint8Array.from(secret, (c) => c.charCodeAt(0));
+            }
+        }
+        else {
+            if (typeof secret !== "string") {
+                throw new Error("Expected secret to be of type string");
+            }
+            if (secret.startsWith(Webhook.prefix)) {
+                secret = secret.substring(Webhook.prefix.length);
+            }
+            this.key = base64.decode(secret);
+        }
+    }
+    verify(payload, headers_) {
+        const headers = {};
+        for (const key of Object.keys(headers_)) {
+            headers[key.toLowerCase()] = headers_[key];
+        }
+        const msgId = headers["webhook-id"];
+        const msgSignature = headers["webhook-signature"];
+        const msgTimestamp = headers["webhook-timestamp"];
+        if (!msgSignature || !msgId || !msgTimestamp) {
+            throw new WebhookVerificationError("Missing required headers");
+        }
+        const timestamp = this.verifyTimestamp(msgTimestamp);
+        const computedSignature = this.sign(msgId, timestamp, payload);
+        const expectedSignature = computedSignature.split(",")[1];
+        const passedSignatures = msgSignature.split(" ");
+        const encoder = new globalThis.TextEncoder();
+        for (const versionedSignature of passedSignatures) {
+            const [version, signature] = versionedSignature.split(",");
+            if (version !== "v1") {
+                continue;
+            }
+            if ((0, timing_safe_equal_1.timingSafeEqual)(encoder.encode(signature), encoder.encode(expectedSignature))) {
+                return JSON.parse(payload.toString());
+            }
+        }
+        throw new WebhookVerificationError("No matching signature found");
+    }
+    sign(msgId, timestamp, payload) {
+        if (typeof payload === "string") ;
+        else if (payload.constructor.name === "Buffer") {
+            payload = payload.toString();
+        }
+        else {
+            throw new Error("Expected payload to be of type string or Buffer.");
+        }
+        const encoder = new TextEncoder();
+        const timestampNumber = Math.floor(timestamp.getTime() / 1000);
+        const toSign = encoder.encode(`${msgId}.${timestampNumber}.${payload}`);
+        const expectedSignature = base64.encode(sha256.hmac(this.key, toSign));
+        return `v1,${expectedSignature}`;
+    }
+    verifyTimestamp(timestampHeader) {
+        const now = Math.floor(Date.now() / 1000);
+        const timestamp = parseInt(timestampHeader, 10);
+        if (isNaN(timestamp)) {
+            throw new WebhookVerificationError("Invalid Signature Headers");
+        }
+        if (now - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
+            throw new WebhookVerificationError("Message timestamp too old");
+        }
+        if (timestamp > now + WEBHOOK_TOLERANCE_IN_SECONDS) {
+            throw new WebhookVerificationError("Message timestamp too new");
+        }
+        return new Date(timestamp * 1000);
+    }
+}
+Webhook_1 = dist.Webhook = Webhook;
+Webhook.prefix = "whsec_";
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+let Webhooks$1 = class Webhooks extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.headers = new Headers$1(this._client);
+    }
+    /**
+     * Create a new webhook
+     */
+    create(body, options) {
+        return this._client.post('/webhooks', { body, ...options });
+    }
+    /**
+     * Get a webhook by id
+     */
+    retrieve(webhookID, options) {
+        return this._client.get(path `/webhooks/${webhookID}`, options);
+    }
+    /**
+     * Patch a webhook by id
+     */
+    update(webhookID, body, options) {
+        return this._client.patch(path `/webhooks/${webhookID}`, { body, ...options });
+    }
+    /**
+     * List all webhooks
+     */
+    list(query = {}, options) {
+        return this._client.getAPIList('/webhooks', (CursorPagePagination), { query, ...options });
+    }
+    /**
+     * Delete a webhook by id
+     */
+    delete(webhookID, options) {
+        return this._client.delete(path `/webhooks/${webhookID}`, {
+            ...options,
+            headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+    /**
+     * Get webhook secret by id
+     */
+    retrieveSecret(webhookID, options) {
+        return this._client.get(path `/webhooks/${webhookID}/secret`, options);
+    }
+    unsafeUnwrap(body) {
+        return JSON.parse(body);
+    }
+    unwrap(body, { headers, key }) {
+        if (headers !== undefined) {
+            const keyStr = key === undefined ? this._client.webhookKey : key;
+            if (keyStr === null)
+                throw new Error('Webhook key must not be null in order to unwrap');
+            const wh = new Webhook_1(keyStr);
+            wh.verify(body, headers);
+        }
+        return JSON.parse(body);
+    }
+};
+Webhooks$1.Headers = Headers$1;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Read an environment variable.
+ *
+ * Trims beginning and trailing whitespace.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+const readEnv = (env) => {
+    if (typeof globalThis.process !== 'undefined') {
+        return globalThis.process.env?.[env]?.trim() ?? undefined;
+    }
+    if (typeof globalThis.Deno !== 'undefined') {
+        return globalThis.Deno.env?.get?.(env)?.trim();
+    }
+    return undefined;
+};
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+var _DodoPayments_instances, _a, _DodoPayments_encoder, _DodoPayments_baseURLOverridden;
+const environments = {
+    live_mode: 'https://live.dodopayments.com',
+    test_mode: 'https://test.dodopayments.com',
+};
+/**
+ * API Client for interfacing with the Dodo Payments API.
+ */
+class DodoPayments {
+    /**
+     * API Client for interfacing with the Dodo Payments API.
+     *
+     * @param {string | undefined} [opts.bearerToken=process.env['DODO_PAYMENTS_API_KEY'] ?? undefined]
+     * @param {string | null | undefined} [opts.webhookKey=process.env['DODO_PAYMENTS_WEBHOOK_KEY'] ?? null]
+     * @param {Environment} [opts.environment=live_mode] - Specifies the environment URL to use for the API.
+     * @param {string} [opts.baseURL=process.env['DODO_PAYMENTS_BASE_URL'] ?? https://live.dodopayments.com] - Override the default base URL for the API.
+     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
+     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
+     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
+     */
+    constructor({ baseURL = readEnv('DODO_PAYMENTS_BASE_URL'), bearerToken = readEnv('DODO_PAYMENTS_API_KEY'), webhookKey = readEnv('DODO_PAYMENTS_WEBHOOK_KEY') ?? null, ...opts } = {}) {
+        _DodoPayments_instances.add(this);
+        _DodoPayments_encoder.set(this, void 0);
+        this.checkoutSessions = new CheckoutSessions(this);
+        this.payments = new Payments(this);
+        this.subscriptions = new Subscriptions(this);
+        this.invoices = new Invoices(this);
+        this.licenses = new Licenses(this);
+        this.licenseKeys = new LicenseKeys(this);
+        this.licenseKeyInstances = new LicenseKeyInstances(this);
+        this.customers = new Customers(this);
+        this.refunds = new Refunds(this);
+        this.disputes = new Disputes(this);
+        this.payouts = new Payouts(this);
+        this.products = new Products(this);
+        this.misc = new Misc(this);
+        this.discounts = new Discounts(this);
+        this.addons = new Addons(this);
+        this.brands = new Brands(this);
+        this.webhooks = new Webhooks$1(this);
+        this.webhookEvents = new WebhookEvents(this);
+        this.usageEvents = new UsageEvents(this);
+        this.meters = new Meters(this);
+        if (bearerToken === undefined) {
+            throw new DodoPaymentsError("The DODO_PAYMENTS_API_KEY environment variable is missing or empty; either provide it, or instantiate the DodoPayments client with an bearerToken option, like new DodoPayments({ bearerToken: 'My Bearer Token' }).");
+        }
+        const options = {
+            bearerToken,
+            webhookKey,
+            ...opts,
+            baseURL,
+            environment: opts.environment ?? 'live_mode',
+        };
+        if (baseURL && opts.environment) {
+            throw new DodoPaymentsError('Ambiguous URL; The `baseURL` option (or DODO_PAYMENTS_BASE_URL env var) and the `environment` option are given. If you want to use the environment you must pass baseURL: null');
+        }
+        this.baseURL = options.baseURL || environments[options.environment || 'live_mode'];
+        this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT /* 1 minute */;
+        this.logger = options.logger ?? console;
+        const defaultLogLevel = 'warn';
+        // Set default logLevel early so that we can log a warning in parseLogLevel.
+        this.logLevel = defaultLogLevel;
+        this.logLevel =
+            parseLogLevel(options.logLevel, 'ClientOptions.logLevel', this) ??
+                parseLogLevel(readEnv('DODO_PAYMENTS_LOG'), "process.env['DODO_PAYMENTS_LOG']", this) ??
+                defaultLogLevel;
+        this.fetchOptions = options.fetchOptions;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.fetch = options.fetch ?? getDefaultFetch();
+        __classPrivateFieldSet(this, _DodoPayments_encoder, FallbackEncoder);
+        this._options = options;
+        this.bearerToken = bearerToken;
+        this.webhookKey = webhookKey;
+    }
+    /**
+     * Create a new client instance re-using the same options given to the current client with optional overriding.
+     */
+    withOptions(options) {
+        const client = new this.constructor({
+            ...this._options,
+            environment: options.environment ? options.environment : undefined,
+            baseURL: options.environment ? undefined : this.baseURL,
+            maxRetries: this.maxRetries,
+            timeout: this.timeout,
+            logger: this.logger,
+            logLevel: this.logLevel,
+            fetch: this.fetch,
+            fetchOptions: this.fetchOptions,
+            bearerToken: this.bearerToken,
+            webhookKey: this.webhookKey,
+            ...options,
+        });
+        return client;
+    }
+    defaultQuery() {
+        return this._options.defaultQuery;
+    }
+    validateHeaders({ values, nulls }) {
+        return;
+    }
+    async authHeaders(opts) {
+        return buildHeaders([{ Authorization: `Bearer ${this.bearerToken}` }]);
+    }
+    /**
+     * Basic re-implementation of `qs.stringify` for primitive types.
+     */
+    stringifyQuery(query) {
+        return Object.entries(query)
+            .filter(([_, value]) => typeof value !== 'undefined')
+            .map(([key, value]) => {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+            }
+            if (value === null) {
+                return `${encodeURIComponent(key)}=`;
+            }
+            throw new DodoPaymentsError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
+        })
+            .join('&');
+    }
+    getUserAgent() {
+        return `${this.constructor.name}/JS ${VERSION}`;
+    }
+    defaultIdempotencyKey() {
+        return `stainless-node-retry-${uuid4()}`;
+    }
+    makeStatusError(status, error, message, headers) {
+        return APIError.generate(status, error, message, headers);
+    }
+    buildURL(path, query, defaultBaseURL) {
+        const baseURL = (!__classPrivateFieldGet(this, _DodoPayments_instances, "m", _DodoPayments_baseURLOverridden).call(this) && defaultBaseURL) || this.baseURL;
+        const url = isAbsoluteURL(path) ?
+            new URL(path)
+            : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
+        const defaultQuery = this.defaultQuery();
+        if (!isEmptyObj(defaultQuery)) {
+            query = { ...defaultQuery, ...query };
+        }
+        if (typeof query === 'object' && query && !Array.isArray(query)) {
+            url.search = this.stringifyQuery(query);
+        }
+        return url.toString();
+    }
+    /**
+     * Used as a callback for mutating the given `FinalRequestOptions` object.
+     */
+    async prepareOptions(options) { }
+    /**
+     * Used as a callback for mutating the given `RequestInit` object.
+     *
+     * This is useful for cases where you want to add certain headers based off of
+     * the request properties, e.g. `method` or `url`.
+     */
+    async prepareRequest(request, { url, options }) { }
+    get(path, opts) {
+        return this.methodRequest('get', path, opts);
+    }
+    post(path, opts) {
+        return this.methodRequest('post', path, opts);
+    }
+    patch(path, opts) {
+        return this.methodRequest('patch', path, opts);
+    }
+    put(path, opts) {
+        return this.methodRequest('put', path, opts);
+    }
+    delete(path, opts) {
+        return this.methodRequest('delete', path, opts);
+    }
+    methodRequest(method, path, opts) {
+        return this.request(Promise.resolve(opts).then((opts) => {
+            return { method, path, ...opts };
+        }));
+    }
+    request(options, remainingRetries = null) {
+        return new APIPromise(this, this.makeRequest(options, remainingRetries, undefined));
+    }
+    async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
+        const options = await optionsInput;
+        const maxRetries = options.maxRetries ?? this.maxRetries;
+        if (retriesRemaining == null) {
+            retriesRemaining = maxRetries;
+        }
+        await this.prepareOptions(options);
+        const { req, url, timeout } = await this.buildRequest(options, {
+            retryCount: maxRetries - retriesRemaining,
+        });
+        await this.prepareRequest(req, { url, options });
+        /** Not an API request ID, just for correlating local log entries. */
+        const requestLogID = 'log_' + ((Math.random() * (1 << 24)) | 0).toString(16).padStart(6, '0');
+        const retryLogStr = retryOfRequestLogID === undefined ? '' : `, retryOf: ${retryOfRequestLogID}`;
+        const startTime = Date.now();
+        loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({
+            retryOfRequestLogID,
+            method: options.method,
+            url,
+            options,
+            headers: req.headers,
+        }));
+        if (options.signal?.aborted) {
+            throw new APIUserAbortError();
+        }
+        const controller = new AbortController();
+        const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+        const headersTime = Date.now();
+        if (response instanceof globalThis.Error) {
+            const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+            if (options.signal?.aborted) {
+                throw new APIUserAbortError();
+            }
+            // detect native connection timeout errors
+            // deno throws "TypeError: error sending request for url (https://example/): client error (Connect): tcp connect error: Operation timed out (os error 60): Operation timed out (os error 60)"
+            // undici throws "TypeError: fetch failed" with cause "ConnectTimeoutError: Connect Timeout Error (attempted address: example:443, timeout: 1ms)"
+            // others do not provide enough information to distinguish timeouts from other connection errors
+            const isTimeout = isAbortError(response) ||
+                /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : ''));
+            if (retriesRemaining) {
+                loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`);
+                loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (${retryMessage})`, formatRequestDetails({
+                    retryOfRequestLogID,
+                    url,
+                    durationMs: headersTime - startTime,
+                    message: response.message,
+                }));
+                return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
+            }
+            loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - error; no more retries left`);
+            loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (error; no more retries left)`, formatRequestDetails({
+                retryOfRequestLogID,
+                url,
+                durationMs: headersTime - startTime,
+                message: response.message,
+            }));
+            if (isTimeout) {
+                throw new APIConnectionTimeoutError();
+            }
+            throw new APIConnectionError({ cause: response });
+        }
+        const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? 'succeeded' : 'failed'} with status ${response.status} in ${headersTime - startTime}ms`;
+        if (!response.ok) {
+            const shouldRetry = await this.shouldRetry(response);
+            if (retriesRemaining && shouldRetry) {
+                const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+                // We don't need the body of this response.
+                await CancelReadableStream(response.body);
+                loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+                loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+                    retryOfRequestLogID,
+                    url: response.url,
+                    status: response.status,
+                    headers: response.headers,
+                    durationMs: headersTime - startTime,
+                }));
+                return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
+            }
+            const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
+            loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+            const errText = await response.text().catch((err) => castToError(err).message);
+            const errJSON = safeJSON(errText);
+            const errMessage = errJSON ? undefined : errText;
+            loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+                retryOfRequestLogID,
+                url: response.url,
+                status: response.status,
+                headers: response.headers,
+                message: errMessage,
+                durationMs: Date.now() - startTime,
+            }));
+            const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+            throw err;
+        }
+        loggerFor(this).info(responseInfo);
+        loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
+            retryOfRequestLogID,
+            url: response.url,
+            status: response.status,
+            headers: response.headers,
+            durationMs: headersTime - startTime,
+        }));
+        return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
+    }
+    getAPIList(path, Page, opts) {
+        return this.requestAPIList(Page, { method: 'get', path, ...opts });
+    }
+    requestAPIList(Page, options) {
+        const request = this.makeRequest(options, null, undefined);
+        return new PagePromise(this, request, Page);
+    }
+    async fetchWithTimeout(url, init, ms, controller) {
+        const { signal, method, ...options } = init || {};
+        if (signal)
+            signal.addEventListener('abort', () => controller.abort());
+        const timeout = setTimeout(() => controller.abort(), ms);
+        const isReadableBody = (globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream) ||
+            (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body);
+        const fetchOptions = {
+            signal: controller.signal,
+            ...(isReadableBody ? { duplex: 'half' } : {}),
+            method: 'GET',
+            ...options,
+        };
+        if (method) {
+            // Custom methods like 'patch' need to be uppercased
+            // See https://github.com/nodejs/undici/issues/2294
+            fetchOptions.method = method.toUpperCase();
+        }
+        try {
+            // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
+            return await this.fetch.call(undefined, url, fetchOptions);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async shouldRetry(response) {
+        // Note this is not a standard header.
+        const shouldRetryHeader = response.headers.get('x-should-retry');
+        // If the server explicitly says whether or not to retry, obey.
+        if (shouldRetryHeader === 'true')
+            return true;
+        if (shouldRetryHeader === 'false')
+            return false;
+        // Retry on request timeouts.
+        if (response.status === 408)
+            return true;
+        // Retry on lock timeouts.
+        if (response.status === 409)
+            return true;
+        // Retry on rate limits.
+        if (response.status === 429)
+            return true;
+        // Retry internal errors.
+        if (response.status >= 500)
+            return true;
+        return false;
+    }
+    async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
+        let timeoutMillis;
+        // Note the `retry-after-ms` header may not be standard, but is a good idea and we'd like proactive support for it.
+        const retryAfterMillisHeader = responseHeaders?.get('retry-after-ms');
+        if (retryAfterMillisHeader) {
+            const timeoutMs = parseFloat(retryAfterMillisHeader);
+            if (!Number.isNaN(timeoutMs)) {
+                timeoutMillis = timeoutMs;
+            }
+        }
+        // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+        const retryAfterHeader = responseHeaders?.get('retry-after');
+        if (retryAfterHeader && !timeoutMillis) {
+            const timeoutSeconds = parseFloat(retryAfterHeader);
+            if (!Number.isNaN(timeoutSeconds)) {
+                timeoutMillis = timeoutSeconds * 1000;
+            }
+            else {
+                timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+            }
+        }
+        // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
+        // just do what it says, but otherwise calculate a default
+        if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
+            const maxRetries = options.maxRetries ?? this.maxRetries;
+            timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+        }
+        await sleep(timeoutMillis);
+        return this.makeRequest(options, retriesRemaining - 1, requestLogID);
+    }
+    calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+        const initialRetryDelay = 0.5;
+        const maxRetryDelay = 8.0;
+        const numRetries = maxRetries - retriesRemaining;
+        // Apply exponential backoff, but not more than the max.
+        const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
+        // Apply some jitter, take up to at most 25 percent of the retry time.
+        const jitter = 1 - Math.random() * 0.25;
+        return sleepSeconds * jitter * 1000;
+    }
+    async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+        const options = { ...inputOptions };
+        const { method, path, query, defaultBaseURL } = options;
+        const url = this.buildURL(path, query, defaultBaseURL);
+        if ('timeout' in options)
+            validatePositiveInteger('timeout', options.timeout);
+        options.timeout = options.timeout ?? this.timeout;
+        const { bodyHeaders, body } = this.buildBody({ options });
+        const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
+        const req = {
+            method,
+            headers: reqHeaders,
+            ...(options.signal && { signal: options.signal }),
+            ...(globalThis.ReadableStream &&
+                body instanceof globalThis.ReadableStream && { duplex: 'half' }),
+            ...(body && { body }),
+            ...(this.fetchOptions ?? {}),
+            ...(options.fetchOptions ?? {}),
+        };
+        return { req, url, timeout: options.timeout };
+    }
+    async buildHeaders({ options, method, bodyHeaders, retryCount, }) {
+        let idempotencyHeaders = {};
+        if (this.idempotencyHeader && method !== 'get') {
+            if (!options.idempotencyKey)
+                options.idempotencyKey = this.defaultIdempotencyKey();
+            idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
+        }
+        const headers = buildHeaders([
+            idempotencyHeaders,
+            {
+                Accept: 'application/json',
+                'User-Agent': this.getUserAgent(),
+                'X-Stainless-Retry-Count': String(retryCount),
+                ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
+                ...getPlatformHeaders(),
+            },
+            await this.authHeaders(options),
+            this._options.defaultHeaders,
+            bodyHeaders,
+            options.headers,
+        ]);
+        this.validateHeaders(headers);
+        return headers.values;
+    }
+    buildBody({ options: { body, headers: rawHeaders } }) {
+        if (!body) {
+            return { bodyHeaders: undefined, body: undefined };
+        }
+        const headers = buildHeaders([rawHeaders]);
+        if (
+        // Pass raw type verbatim
+        ArrayBuffer.isView(body) ||
+            body instanceof ArrayBuffer ||
+            body instanceof DataView ||
+            (typeof body === 'string' &&
+                // Preserve legacy string encoding behavior for now
+                headers.values.has('content-type')) ||
+            // `Blob` is superset of `File`
+            (globalThis.Blob && body instanceof globalThis.Blob) ||
+            // `FormData` -> `multipart/form-data`
+            body instanceof FormData ||
+            // `URLSearchParams` -> `application/x-www-form-urlencoded`
+            body instanceof URLSearchParams ||
+            // Send chunked stream (each chunk has own `length`)
+            (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) {
+            return { bodyHeaders: undefined, body: body };
+        }
+        else if (typeof body === 'object' &&
+            (Symbol.asyncIterator in body ||
+                (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
+            return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
+        }
+        else {
+            return __classPrivateFieldGet(this, _DodoPayments_encoder, "f").call(this, { body, headers });
+        }
+    }
+}
+_a = DodoPayments, _DodoPayments_encoder = new WeakMap(), _DodoPayments_instances = new WeakSet(), _DodoPayments_baseURLOverridden = function _DodoPayments_baseURLOverridden() {
+    return this.baseURL !== environments[this._options.environment || 'live_mode'];
+};
+DodoPayments.DodoPayments = _a;
+DodoPayments.DEFAULT_TIMEOUT = 60000; // 1 minute
+DodoPayments.DodoPaymentsError = DodoPaymentsError;
+DodoPayments.APIError = APIError;
+DodoPayments.APIConnectionError = APIConnectionError;
+DodoPayments.APIConnectionTimeoutError = APIConnectionTimeoutError;
+DodoPayments.APIUserAbortError = APIUserAbortError;
+DodoPayments.NotFoundError = NotFoundError;
+DodoPayments.ConflictError = ConflictError;
+DodoPayments.RateLimitError = RateLimitError;
+DodoPayments.BadRequestError = BadRequestError;
+DodoPayments.AuthenticationError = AuthenticationError;
+DodoPayments.InternalServerError = InternalServerError;
+DodoPayments.PermissionDeniedError = PermissionDeniedError;
+DodoPayments.UnprocessableEntityError = UnprocessableEntityError;
+DodoPayments.toFile = toFile;
+DodoPayments.CheckoutSessions = CheckoutSessions;
+DodoPayments.Payments = Payments;
+DodoPayments.Subscriptions = Subscriptions;
+DodoPayments.Invoices = Invoices;
+DodoPayments.Licenses = Licenses;
+DodoPayments.LicenseKeys = LicenseKeys;
+DodoPayments.LicenseKeyInstances = LicenseKeyInstances;
+DodoPayments.Customers = Customers;
+DodoPayments.Refunds = Refunds;
+DodoPayments.Disputes = Disputes;
+DodoPayments.Payouts = Payouts;
+DodoPayments.Products = Products;
+DodoPayments.Misc = Misc;
+DodoPayments.Discounts = Discounts;
+DodoPayments.Addons = Addons;
+DodoPayments.Brands = Brands;
+DodoPayments.Webhooks = Webhooks$1;
+DodoPayments.WebhookEvents = WebhookEvents;
+DodoPayments.UsageEvents = UsageEvents;
+DodoPayments.Meters = Meters;
+
+// src/checkout/checkout.ts
+var checkoutQuerySchema = objectType({
+  productId: stringType(),
+  quantity: stringType().optional(),
+  // Customer fields
+  fullName: stringType().optional(),
+  firstName: stringType().optional(),
+  lastName: stringType().optional(),
+  email: stringType().optional(),
+  country: stringType().optional(),
+  addressLine: stringType().optional(),
+  city: stringType().optional(),
+  state: stringType().optional(),
+  zipCode: stringType().optional(),
+  // Disable flags
+  disableFullName: stringType().optional(),
+  disableFirstName: stringType().optional(),
+  disableLastName: stringType().optional(),
+  disableEmail: stringType().optional(),
+  disableCountry: stringType().optional(),
+  disableAddressLine: stringType().optional(),
+  disableCity: stringType().optional(),
+  disableState: stringType().optional(),
+  disableZipCode: stringType().optional(),
+  // Advanced controls
+  paymentCurrency: stringType().optional(),
+  showCurrencySelector: stringType().optional(),
+  paymentAmount: stringType().optional(),
+  showDiscounts: stringType().optional()
+  // Metadata (allow any key starting with metadata_)
+  // We'll handle metadata separately in the handler
+}).catchall(unknownType());
+var dynamicCheckoutBodySchema = objectType({
+  // For subscription
+  product_id: stringType().optional(),
+  quantity: numberType().optional(),
+  // For one-time payment
+  product_cart: arrayType(
+    objectType({
+      product_id: stringType(),
+      quantity: numberType()
+    })
+  ).optional(),
+  // Common fields
+  billing: objectType({
+    city: stringType(),
+    country: stringType(),
+    state: stringType(),
+    street: stringType(),
+    zipcode: stringType()
+  }),
+  customer: objectType({
+    customer_id: stringType().optional(),
+    email: stringType().optional(),
+    name: stringType().optional()
+  }),
+  discount_id: stringType().optional(),
+  addons: arrayType(
+    objectType({
+      addon_id: stringType(),
+      quantity: numberType()
+    })
+  ).optional(),
+  metadata: recordType(stringType(), stringType()).optional(),
+  currency: stringType().optional()
+  // Allow any additional fields (for future compatibility)
+}).catchall(unknownType());
+var checkoutSessionProductCartItemSchema = objectType({
+  product_id: stringType().min(1, "Product ID is required"),
+  quantity: numberType().int().positive("Quantity must be a positive integer"),
+  addons: arrayType(
+    objectType({
+      addon_id: stringType(),
+      quantity: numberType().int().nonnegative()
+    })
+  ).optional(),
+  amount: numberType().int().nonnegative(
+    "Amount must be a non-negative integer (for pay-what-you-want products)"
+  ).optional()
+});
+var checkoutSessionCustomerSchema = unionType([
+  objectType({
+    email: stringType().email(),
+    name: stringType().min(1).optional(),
+    phone_number: stringType().optional()
+  }),
+  objectType({
+    customer_id: stringType()
+  })
+]).optional();
+var checkoutSessionBillingAddressSchema = objectType({
+  street: stringType().optional(),
+  city: stringType().optional(),
+  state: stringType().optional(),
+  country: stringType().length(2, "Country must be a 2-letter ISO code"),
+  zipcode: stringType().optional()
+}).optional();
+var paymentMethodTypeSchema = enumType([
+  "credit",
+  "debit",
+  "upi_collect",
+  "upi_intent",
+  "apple_pay",
+  "cashapp",
+  "google_pay",
+  "multibanco",
+  "bancontact_card",
+  "eps",
+  "ideal",
+  "przelewy24",
+  "paypal",
+  "affirm",
+  "klarna",
+  "sepa",
+  "ach",
+  "amazon_pay",
+  "afterpay_clearpay"
+]);
+var checkoutSessionCustomizationSchema = objectType({
+  theme: enumType(["light", "dark", "system"]).optional(),
+  show_order_details: booleanType().optional(),
+  show_on_demand_tag: booleanType().optional(),
+  force_language: stringType().optional()
+}).optional();
+var checkoutSessionFeatureFlagsSchema = objectType({
+  allow_currency_selection: booleanType().optional(),
+  allow_customer_editing_city: booleanType().optional(),
+  allow_customer_editing_country: booleanType().optional(),
+  allow_customer_editing_email: booleanType().optional(),
+  allow_customer_editing_name: booleanType().optional(),
+  allow_customer_editing_state: booleanType().optional(),
+  allow_customer_editing_street: booleanType().optional(),
+  allow_customer_editing_zipcode: booleanType().optional(),
+  allow_discount_code: booleanType().optional(),
+  allow_phone_number_collection: booleanType().optional(),
+  allow_tax_id: booleanType().optional(),
+  always_create_new_customer: booleanType().optional()
+}).optional();
+var checkoutSessionOnDemandSchema = objectType({
+  mandate_only: booleanType(),
+  product_price: numberType().int().optional(),
+  product_currency: stringType().length(3).optional(),
+  product_description: stringType().optional(),
+  adaptive_currency_fees_inclusive: booleanType().optional()
+}).optional();
+var checkoutSessionSubscriptionDataSchema = objectType({
+  trial_period_days: numberType().int().nonnegative().optional(),
+  on_demand: checkoutSessionOnDemandSchema
+}).optional();
+var checkoutSessionPayloadSchema = objectType({
+  // Required fields
+  product_cart: arrayType(checkoutSessionProductCartItemSchema).min(1, "At least one product is required"),
+  // Optional fields
+  customer: checkoutSessionCustomerSchema,
+  billing_address: checkoutSessionBillingAddressSchema,
+  return_url: stringType().url().optional(),
+  allowed_payment_method_types: arrayType(paymentMethodTypeSchema).optional(),
+  billing_currency: stringType().length(3, "Currency must be a 3-letter ISO code").optional(),
+  show_saved_payment_methods: booleanType().optional(),
+  confirm: booleanType().optional(),
+  discount_code: stringType().optional(),
+  metadata: recordType(stringType(), stringType()).optional(),
+  customization: checkoutSessionCustomizationSchema,
+  feature_flags: checkoutSessionFeatureFlagsSchema,
+  subscription_data: checkoutSessionSubscriptionDataSchema,
+  force_3ds: booleanType().optional()
+});
+var checkoutSessionResponseSchema = objectType({
+  session_id: stringType().min(1, "Session ID is required"),
+  checkout_url: stringType().url("Invalid checkout URL")
+});
+var createCheckoutSession = async (payload, config) => {
+  const validation = checkoutSessionPayloadSchema.safeParse(payload);
+  if (!validation.success) {
+    throw new Error(
+      `Invalid checkout session payload: ${validation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ")}`
+    );
+  }
+  const dodopayments = new DodoPayments({
+    bearerToken: config.bearerToken,
+    environment: config.environment
+  });
+  try {
+    const sdkPayload = {
+      ...validation.data,
+      ...validation.data.billing_address && {
+        billing_address: {
+          ...validation.data.billing_address,
+          country: validation.data.billing_address.country
+        }
+      }
+    };
+    const session = await dodopayments.checkoutSessions.create(
+      sdkPayload
+    );
+    const responseValidation = checkoutSessionResponseSchema.safeParse(session);
+    if (!responseValidation.success) {
+      throw new Error(
+        `Invalid checkout session response from API: ${responseValidation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ")}`
+      );
+    }
+    return responseValidation.data;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("Dodo Payments Checkout Session API Error:", {
+        message: error.message,
+        payload: validation.data,
+        config: {
+          environment: config.environment,
+          hasBearerToken: !!config.bearerToken
+        }
+      });
+      throw new Error(`Failed to create checkout session: ${error.message}`);
+    }
+    console.error("Unknown error creating checkout session:", error);
+    throw new Error(
+      "Failed to create checkout session due to an unknown error"
+    );
+  }
+};
+var buildCheckoutUrl = async ({
+  queryParams,
+  body,
+  sessionPayload,
+  returnUrl,
+  bearerToken,
+  environment,
+  type = "static"
+}) => {
+  if (type === "session") {
+    if (!sessionPayload) {
+      throw new Error("sessionPayload is required when type is 'session'");
+    }
+    const finalPayload = {
+      ...sessionPayload,
+      return_url: sessionPayload.return_url ?? returnUrl
+    };
+    const session = await createCheckoutSession(finalPayload, {
+      bearerToken,
+      environment
+    });
+    return session.checkout_url;
+  }
+  const inputData = type === "dynamic" ? body : queryParams;
+  let parseResult;
+  if (type === "dynamic") {
+    parseResult = dynamicCheckoutBodySchema.safeParse(inputData);
+  } else {
+    parseResult = checkoutQuerySchema.safeParse(inputData);
+  }
+  const { success, data, error } = parseResult;
+  if (!success) {
+    throw new Error(
+      `Invalid ${type === "dynamic" ? "body" : "query parameters"}.
+ ${error.message}`
+    );
+  }
+  if (type !== "dynamic") {
+    const {
+      productId,
+      quantity: quantity2,
+      fullName,
+      firstName,
+      lastName,
+      email,
+      country,
+      addressLine,
+      city,
+      state,
+      zipCode,
+      disableFullName,
+      disableFirstName,
+      disableLastName,
+      disableEmail,
+      disableCountry,
+      disableAddressLine,
+      disableCity,
+      disableState,
+      disableZipCode,
+      paymentCurrency,
+      showCurrencySelector,
+      paymentAmount,
+      showDiscounts
+      // metadata handled below
+    } = data;
+    const dodopayments2 = new DodoPayments({
+      bearerToken,
+      environment
+    });
+    if (!productId) throw new Error("Missing required field: productId");
+    try {
+      await dodopayments2.products.retrieve(productId);
+    } catch (err) {
+      console.error(err);
+      throw new Error("Product not found");
+    }
+    const url = new URL(
+      `${environment === "test_mode" ? "https://test.checkout.dodopayments.com" : "https://checkout.dodopayments.com"}/buy/${productId}`
+    );
+    url.searchParams.set("quantity", quantity2 ? String(quantity2) : "1");
+    if (returnUrl) url.searchParams.set("redirect_url", returnUrl);
+    if (fullName) url.searchParams.set("fullName", String(fullName));
+    if (firstName) url.searchParams.set("firstName", String(firstName));
+    if (lastName) url.searchParams.set("lastName", String(lastName));
+    if (email) url.searchParams.set("email", String(email));
+    if (country) url.searchParams.set("country", String(country));
+    if (addressLine) url.searchParams.set("addressLine", String(addressLine));
+    if (city) url.searchParams.set("city", String(city));
+    if (state) url.searchParams.set("state", String(state));
+    if (zipCode) url.searchParams.set("zipCode", String(zipCode));
+    if (disableFullName === "true")
+      url.searchParams.set("disableFullName", "true");
+    if (disableFirstName === "true")
+      url.searchParams.set("disableFirstName", "true");
+    if (disableLastName === "true")
+      url.searchParams.set("disableLastName", "true");
+    if (disableEmail === "true") url.searchParams.set("disableEmail", "true");
+    if (disableCountry === "true")
+      url.searchParams.set("disableCountry", "true");
+    if (disableAddressLine === "true")
+      url.searchParams.set("disableAddressLine", "true");
+    if (disableCity === "true") url.searchParams.set("disableCity", "true");
+    if (disableState === "true") url.searchParams.set("disableState", "true");
+    if (disableZipCode === "true")
+      url.searchParams.set("disableZipCode", "true");
+    if (paymentCurrency)
+      url.searchParams.set("paymentCurrency", String(paymentCurrency));
+    if (showCurrencySelector)
+      url.searchParams.set(
+        "showCurrencySelector",
+        String(showCurrencySelector)
+      );
+    if (paymentAmount)
+      url.searchParams.set("paymentAmount", String(paymentAmount));
+    if (showDiscounts)
+      url.searchParams.set("showDiscounts", String(showDiscounts));
+    for (const [key, value] of Object.entries(queryParams || {})) {
+      if (key.startsWith("metadata_") && value && typeof value !== "object") {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  const dyn = data;
+  const {
+    product_id,
+    product_cart,
+    quantity,
+    billing,
+    customer,
+    addons,
+    metadata,
+    allowed_payment_method_types,
+    billing_currency,
+    discount_code,
+    on_demand,
+    return_url: bodyReturnUrl,
+    show_saved_payment_methods,
+    tax_id,
+    trial_period_days
+  } = dyn;
+  const dodopayments = new DodoPayments({
+    bearerToken,
+    environment
+  });
+  let isSubscription = false;
+  let productIdToFetch = product_id;
+  if (!product_id && product_cart && product_cart.length > 0) {
+    productIdToFetch = product_cart[0].product_id;
+  }
+  if (!productIdToFetch)
+    throw new Error(
+      "Missing required field: product_id or product_cart[0].product_id"
+    );
+  let product;
+  try {
+    product = await dodopayments.products.retrieve(productIdToFetch);
+  } catch (err) {
+    console.error(err);
+    throw new Error("Product not found");
+  }
+  isSubscription = Boolean(product.is_recurring);
+  if (isSubscription && !product_id)
+    throw new Error("Missing required field: product_id for subscription");
+  if (!billing) throw new Error("Missing required field: billing");
+  if (!customer) throw new Error("Missing required field: customer");
+  if (isSubscription) {
+    const subscriptionPayload = {
+      billing,
+      customer,
+      product_id,
+      quantity: quantity ? Number(quantity) : 1
+    };
+    if (metadata) subscriptionPayload.metadata = metadata;
+    if (discount_code) subscriptionPayload.discount_code = discount_code;
+    if (addons) subscriptionPayload.addons = addons;
+    if (allowed_payment_method_types)
+      subscriptionPayload.allowed_payment_method_types = allowed_payment_method_types;
+    if (billing_currency)
+      subscriptionPayload.billing_currency = billing_currency;
+    if (on_demand) subscriptionPayload.on_demand = on_demand;
+    subscriptionPayload.payment_link = true;
+    if (bodyReturnUrl) {
+      subscriptionPayload.return_url = bodyReturnUrl;
+    } else if (returnUrl) {
+      subscriptionPayload.return_url = returnUrl;
+    }
+    if (show_saved_payment_methods)
+      subscriptionPayload.show_saved_payment_methods = show_saved_payment_methods;
+    if (tax_id) subscriptionPayload.tax_id = tax_id;
+    if (trial_period_days)
+      subscriptionPayload.trial_period_days = trial_period_days;
+    let subscription;
+    try {
+      subscription = await dodopayments.subscriptions.create(subscriptionPayload);
+    } catch (err) {
+      console.error("Error when creating subscription", err);
+      throw new Error(err instanceof Error ? err.message : String(err));
     }
-}
-var WebhookVerificationError_1 = dist.WebhookVerificationError = WebhookVerificationError;
-class Webhook {
-    constructor(secret, options) {
-        if (!secret) {
-            throw new Error("Secret can't be empty.");
+    if (!subscription || !subscription.payment_link) {
+      throw new Error(
+        "No payment link returned from Dodo Payments API (subscription). Make sure to set payment_link as true in payload"
+      );
+    }
+    return subscription.payment_link;
+  } else {
+    let cart = product_cart;
+    if (!cart && product_id) {
+      cart = [
+        { product_id, quantity: quantity ? Number(quantity) : 1 }
+      ];
+    }
+    if (!cart || cart.length === 0)
+      throw new Error("Missing required field: product_cart or product_id");
+    const paymentPayload = {
+      billing,
+      customer,
+      product_cart: cart
+    };
+    if (metadata) paymentPayload.metadata = metadata;
+    paymentPayload.payment_link = true;
+    if (allowed_payment_method_types)
+      paymentPayload.allowed_payment_method_types = allowed_payment_method_types;
+    if (billing_currency) paymentPayload.billing_currency = billing_currency;
+    if (discount_code) paymentPayload.discount_code = discount_code;
+    if (bodyReturnUrl) {
+      paymentPayload.return_url = bodyReturnUrl;
+    } else if (returnUrl) {
+      paymentPayload.return_url = returnUrl;
+    }
+    if (show_saved_payment_methods)
+      paymentPayload.show_saved_payment_methods = show_saved_payment_methods;
+    if (tax_id) paymentPayload.tax_id = tax_id;
+    let payment;
+    try {
+      payment = await dodopayments.payments.create(paymentPayload);
+    } catch (err) {
+      console.error("Error when creating payment link", err);
+      throw new Error(err instanceof Error ? err.message : String(err));
+    }
+    if (!payment || !payment.payment_link) {
+      throw new Error(
+        "No payment link returned from Dodo Payments API. Make sure to set payment_link as true in payload."
+      );
+    }
+    return payment.payment_link;
+  }
+};
+
+const Checkout = (config) => {
+    const getHandler = async (req) => {
+        const { searchParams } = new URL(req.url);
+        const queryParams = Object.fromEntries(searchParams);
+        if (!queryParams.productId) {
+            return new serverExports.NextResponse("Please provide productId query parameter", {
+                status: 400,
+            });
         }
-        if ((options === null || options === void 0 ? void 0 : options.format) === "raw") {
-            if (secret instanceof Uint8Array) {
-                this.key = secret;
-            }
-            else {
-                this.key = Uint8Array.from(secret, (c) => c.charCodeAt(0));
+        const { success, data, error } = checkoutQuerySchema.safeParse(queryParams);
+        if (!success) {
+            if (error.errors.some((e) => e.path.toString() === "productId")) {
+                return new serverExports.NextResponse("Please provide productId query parameter", {
+                    status: 400,
+                });
             }
+            return new serverExports.NextResponse(`Invalid query parameters.\n ${error.message}`, {
+                status: 400,
+            });
         }
-        else {
-            if (typeof secret !== "string") {
-                throw new Error("Expected secret to be of type string");
-            }
-            if (secret.startsWith(Webhook.prefix)) {
-                secret = secret.substring(Webhook.prefix.length);
-            }
-            this.key = base64.decode(secret);
+        let url = "";
+        try {
+            url = await buildCheckoutUrl({ queryParams: data, ...config });
         }
-    }
-    verify(payload, headers_) {
-        const headers = {};
-        for (const key of Object.keys(headers_)) {
-            headers[key.toLowerCase()] = headers_[key];
+        catch (error) {
+            return new serverExports.NextResponse(error.message, { status: 400 });
         }
-        const msgId = headers["webhook-id"];
-        const msgSignature = headers["webhook-signature"];
-        const msgTimestamp = headers["webhook-timestamp"];
-        if (!msgSignature || !msgId || !msgTimestamp) {
-            throw new WebhookVerificationError("Missing required headers");
+        return serverExports.NextResponse.json({ checkout_url: url });
+    };
+    const postHandler = async (req) => {
+        let body;
+        try {
+            body = await req.json();
         }
-        const timestamp = this.verifyTimestamp(msgTimestamp);
-        const computedSignature = this.sign(msgId, timestamp, payload);
-        const expectedSignature = computedSignature.split(",")[1];
-        const passedSignatures = msgSignature.split(" ");
-        const encoder = new globalThis.TextEncoder();
-        for (const versionedSignature of passedSignatures) {
-            const [version, signature] = versionedSignature.split(",");
-            if (version !== "v1") {
-                continue;
+        catch (e) {
+            return new serverExports.NextResponse("Invalid JSON body", { status: 400 });
+        }
+        if (config.type === "dynamic") {
+            // Handle dynamic checkout
+            const { success, data, error } = dynamicCheckoutBodySchema.safeParse(body);
+            if (!success) {
+                return new serverExports.NextResponse(`Invalid request body.\n ${error.message}`, {
+                    status: 400,
+                });
             }
-            if ((0, timing_safe_equal_1.timingSafeEqual)(encoder.encode(signature), encoder.encode(expectedSignature))) {
-                return JSON.parse(payload.toString());
+            let url = "";
+            try {
+                url = await buildCheckoutUrl({
+                    body: data,
+                    ...config,
+                    type: "dynamic",
+                });
             }
-        }
-        throw new WebhookVerificationError("No matching signature found");
-    }
-    sign(msgId, timestamp, payload) {
-        if (typeof payload === "string") ;
-        else if (payload.constructor.name === "Buffer") {
-            payload = payload.toString();
+            catch (error) {
+                return new serverExports.NextResponse(error.message, { status: 400 });
+            }
+            return serverExports.NextResponse.json({ checkout_url: url });
         }
         else {
-            throw new Error("Expected payload to be of type string or Buffer.");
-        }
-        const encoder = new TextEncoder();
-        const timestampNumber = Math.floor(timestamp.getTime() / 1000);
-        const toSign = encoder.encode(`${msgId}.${timestampNumber}.${payload}`);
-        const expectedSignature = base64.encode(sha256.hmac(this.key, toSign));
-        return `v1,${expectedSignature}`;
-    }
-    verifyTimestamp(timestampHeader) {
-        const now = Math.floor(Date.now() / 1000);
-        const timestamp = parseInt(timestampHeader, 10);
-        if (isNaN(timestamp)) {
-            throw new WebhookVerificationError("Invalid Signature Headers");
-        }
-        if (now - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
-            throw new WebhookVerificationError("Message timestamp too old");
+            // Handle checkout session
+            const { success, data, error } = checkoutSessionPayloadSchema.safeParse(body);
+            if (!success) {
+                return new serverExports.NextResponse(`Invalid checkout session payload.\n ${error.message}`, {
+                    status: 400,
+                });
+            }
+            let url = "";
+            try {
+                url = await buildCheckoutUrl({
+                    sessionPayload: data,
+                    ...config,
+                    type: "session",
+                });
+            }
+            catch (error) {
+                return new serverExports.NextResponse(error.message, { status: 400 });
+            }
+            return serverExports.NextResponse.json({ checkout_url: url });
         }
-        if (timestamp > now + WEBHOOK_TOLERANCE_IN_SECONDS) {
-            throw new WebhookVerificationError("Message timestamp too new");
+    };
+    return (req) => {
+        if (req.method === "POST") {
+            return postHandler(req);
         }
-        return new Date(timestamp * 1000);
-    }
-}
-Webhook_1 = dist.Webhook = Webhook;
-Webhook.prefix = "whsec_";
+        return getHandler(req);
+    };
+};
 
 // src/schemas/webhook.ts
 var PaymentSchema = objectType({
@@ -13224,6 +13550,12 @@ var SubscriptionExpiredPayloadSchema = objectType({
   timestamp: stringType().transform((d) => new Date(d)),
   data: SubscriptionSchema
 });
+var SubscriptionUpdatedPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("subscription.updated"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
+});
 var LicenseKeyCreatedPayloadSchema = objectType({
   business_id: stringType(),
   type: literalType("license_key.created"),
@@ -13252,6 +13584,7 @@ var WebhookPayloadSchema = discriminatedUnionType("type", [
   SubscriptionCancelledPayloadSchema,
   SubscriptionFailedPayloadSchema,
   SubscriptionExpiredPayloadSchema,
+  SubscriptionUpdatedPayloadSchema,
   LicenseKeyCreatedPayloadSchema
 ]);
 
@@ -13326,6 +13659,9 @@ async function handleWebhookPayload(payload, config, context) {
   if (payload.type === "subscription.expired") {
     await callHandler(config.onSubscriptionExpired, payload);
   }
+  if (payload.type === "subscription.updated") {
+    await callHandler(config.onSubscriptionUpdated, payload);
+  }
   if (payload.type === "license_key.created") {
     await callHandler(config.onLicenseKeyCreated, payload);
   }