vinext 1.0.0-beta.9 → 1.0.1

package/dist/shims/cdn-cache-state.js

@@ -0,0 +1,23 @@
+//#region src/shims/cdn-cache-state.ts
+const CDN_CACHE_ADAPTER_KEY = Symbol.for("vinext.cdnCacheAdapter");
+const globals = globalThis;
+/** Register an adapter without loading the origin cache implementation. */
+function setCdnCacheAdapter(adapter) {
+	globals[CDN_CACHE_ADAPTER_KEY] = adapter;
+}
+/**
+* Lazily keep the first declaratively configured adapter shared across
+* duplicated stage modules. Failed factories remain retryable so a later
+* entrypoint with the required runtime bindings can register successfully.
+*/
+function registerCdnCacheAdapter(factory) {
+	if (globals[CDN_CACHE_ADAPTER_KEY] !== void 0) return;
+	const adapter = factory();
+	if (globals[CDN_CACHE_ADAPTER_KEY] === void 0) globals[CDN_CACHE_ADAPTER_KEY] = adapter;
+}
+/** Read only an explicitly registered adapter; defaults belong to cdn-cache. */
+function getExplicitCdnCacheAdapter() {
+	return globals[CDN_CACHE_ADAPTER_KEY] ?? null;
+}
+//#endregion
+export { getExplicitCdnCacheAdapter, registerCdnCacheAdapter, setCdnCacheAdapter };

package/dist/shims/cdn-cache.d.ts

@@ -1,14 +1,18 @@
+import { VinextAssetFetcher } from "../server/multi-stage.js";
 import { CacheHandlerValue, IncrementalCacheValue } from "./cache-handler.js";
+import { setCdnCacheAdapter } from "./cdn-cache-state.js";
 //#region src/shims/cdn-cache.d.ts
 /** A map of response header name -> value the adapter wants applied or removed. */
-type CdnResponseHeaders = Record<string, string | null>;
-type CdnCacheableHeaderInput = {
+export type CdnResponseHeaders = Record<string, string | null>;
+export type CdnCacheableHeaderInput = {
   /**
    * The cacheable `Cache-Control` value the framework computed for shared
    * caches (e.g. `s-maxage=60, stale-while-revalidate`). May be an empty string
    * when no cacheable policy applies.
    */
   cacheControl: string;
+  /** Explicit endpoint policy returned to clients, independent of shared admission. */
+  browserCacheControl?: string;
   /**
    * True when this is a freshly-rendered **streaming** response whose
    * dynamic-ness is not yet proven (late Server Component request-API usage can
@@ -28,18 +32,40 @@ type CdnCacheableHeaderInput = {
    */
   tags?: readonly string[];
 };
+export type CdnResponsePolicy = {
+  /** Whether a provider-specific response header controls shared caching. */
+  isHeader(name: string): boolean;
+  /**
+   * Read the effective shared-cache policy from a response. The returned value
+   * uses Cache-Control syntax so core can apply the framework's cacheability
+   * rules without knowing which provider header carried it.
+   */
+  readCacheControl(headers: Headers): string | null;
+  /**
+   * Name the response header `readCacheControl` interpreted, or `null` when
+   * none did. Core uses it to tell which stage owns the effective policy;
+   * without it, core cannot attribute that policy to next.config.
+   */
+  readCacheControlHeaderName?(headers: Headers): string | null;
+  /** Whether provider policy explicitly opts out of storage. */
+  hasExplicitNonCacheablePolicy(headers: Headers, baseline?: Headers): boolean;
+};
+/** Split Cache-Control directives without treating quoted commas as separators. */
+export declare function splitCacheControlDirectives(cacheControl: string): string[];
 /** Whether a Cache-Control value contains an exact non-cacheable directive. */
-declare function isNonCacheableCacheControl(cacheControl: string): boolean;
+export declare function isNonCacheableCacheControl(cacheControl: string, scope?: "shared" | "browser"): boolean;
 /**
  * The serving strategy for page-level ISR. Implement this to delegate
  * page/route/image caching to a CDN edge instead of the origin store.
  */
-type CdnCacheAdapter = {
+export type CdnCacheAdapter = {
   /**
    * The shared cache selects response variants using every request header
    * named by `Vary`, comparing values verbatim.
    */
   readonly responseVary?: "verbatim";
+  /** Provider-specific response-policy interpretation, when the adapter has one. */
+  readonly responsePolicy?: CdnResponsePolicy;
   /**
    * Fresh App Page responses must reach clean EOF before this adapter may emit
    * shared-cache headers. Used by edge adapters whose cache sits in front of
@@ -47,6 +73,21 @@ type CdnCacheAdapter = {
    * the completed artifact.
    */
   readonly requiresCompletedResponseAdmission?: boolean;
+  /**
+   * This adapter's response-stage transport keys shared App page dispatches by
+   * `VinextResponseStageDispatchOptions.cacheIdentity` when core supplies one.
+   * Core supplies it only when completed-response admission is also required,
+   * because that admission is what makes a query-free identity safe.
+   */
+  readonly responseStageCacheIdentity?: "query-free";
+  /**
+   * Optionally return a foreground page response while completed-response
+   * admission continues on an independent body branch. Returning `null` keeps
+   * the normal blocking admission path. API responses are never passed here.
+   */
+  deferCompletedPageResponseAdmission?(response: Response, complete: (response: Response) => Promise<Response>): Response | null;
+  /** Capture the full-route RSC side stream while admitting a completed HTML response. */
+  captureAppPageRscData?(rscData: Promise<ArrayBuffer>): void;
   /**
    * Validate provider-specific request routing before the application handles
    * the request. Returning a response short-circuits the request pipeline;
@@ -64,6 +105,10 @@ type CdnCacheAdapter = {
    * edge owns serving.
    */
   get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  /** Also supplies build-time PAGES entries for pages without getStaticProps. */
+  readonly hasPrerenderedPages?: boolean;
+  /** Optional host asset fetcher resolved by the adapter's platform bindings. */
+  readonly assets?: VinextAssetFetcher;
   /**
    * Persist a freshly-rendered page-level artifact.
    *
@@ -85,14 +130,6 @@ type CdnCacheAdapter = {
    * paths that do not pass through cache-policy finalization.
    */
   buildResponseIdentityHeaders?(): CdnResponseHeaders;
-  /**
-   * Whether existing response headers explicitly opt out of storage. Adapters
-   * that split browser and provider cache policy should implement this so they
-   * can interpret the provider-specific headers they own.
-   *
-   * When omitted, core inspects only the generic `Cache-Control` header.
-   */
-  hasExplicitNonCacheableResponsePolicy?(headers: Headers): boolean;
   /**
    * Whether the **origin** runs in-process background regeneration when a stale
    * entry is served. Edge adapters set this to `false` because the CDN
@@ -118,11 +155,14 @@ type CdnCacheAdapter = {
  * response headers alone. Deployments where provider headers carry cache
  * semantics must configure the adapter that owns those headers.
  */
-declare class DefaultCdnCacheAdapter implements CdnCacheAdapter {
+export declare class DefaultCdnCacheAdapter implements CdnCacheAdapter {
+  private readonly buildIdentity?;
   readonly ownsBackgroundRevalidation = true;
+  constructor(buildIdentity?: string | undefined);
   get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
   set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
   buildResponseHeaders(input: CdnCacheableHeaderInput): CdnResponseHeaders;
+  buildResponseIdentityHeaders(): CdnResponseHeaders;
   revalidateTag(_tags: string | string[], _durations?: {
     expire?: number;
   }): Promise<void>;
@@ -138,23 +178,21 @@ declare class DefaultCdnCacheAdapter implements CdnCacheAdapter {
  *
  * ```ts
  * import { vinext } from "vinext";
- * import { cdnAdapter } from "@vinext/cloudflare/cache/cdn-adapter";
+ * import { workersCacheCdnAdapter } from "@vinext/cloudflare/cache/workers-cache-cdn-adapter";
  *
  * export default defineConfig({
- *   plugins: [vinext({ cache: { cdn: cdnAdapter() } })],
+ *   plugins: [vinext({ cache: { cdn: workersCacheCdnAdapter() } })],
  * });
  * ```
  *
  * The plugin registers the adapter across every runtime/router entry, so you
- * don't have to call this from a worker entry. This setter remains as the
- * internal registration target and for backwards compatibility, but is not the
- * recommended consumer API.
+ * don't have to call this from a worker entry. This setter remains for
+ * backwards compatibility, but is not the recommended consumer API.
  */
-declare function setCdnCacheAdapter(adapter: CdnCacheAdapter): void;
 /**
  * Get the active CDN cache adapter. An explicitly configured adapter wins;
  * otherwise the origin-managed {@link DefaultCdnCacheAdapter} is used.
  */
-declare function getCdnCacheAdapter(): CdnCacheAdapter;
+export declare function getCdnCacheAdapter(): CdnCacheAdapter;
 //#endregion
-export { CdnCacheAdapter, CdnCacheableHeaderInput, CdnResponseHeaders, DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter };
+export { setCdnCacheAdapter };

package/dist/shims/cdn-cache.js

@@ -1,43 +1,16 @@
-import { getDataCacheHandler } from "./cache-handler.js";
+import { getExplicitCdnCacheAdapter, setCdnCacheAdapter } from "./cdn-cache-state.js";
 //#region src/shims/cdn-cache.ts
-/**
-* CDN cache adapter — owns the *page-level ISR serving strategy*.
-*
-* This is deliberately distinct from the data cache handler (see `./cache.ts`):
-*
-* - The **data cache** stores cached data (fetch, `"use cache"`,
-*   `unstable_cache`, route-handler data). It is a pure key/value store.
-*
-* - The **CDN cache adapter** decides *how page-level ISR is served*: where the
-*   rendered page/route/image artifacts live, what cache headers the response
-*   carries, whether the origin runs background regeneration, and how
-*   invalidation propagates to a CDN edge.
-*
-* Two strategies sit behind one interface:
-*
-* | Concern            | DefaultCdnCacheAdapter (origin-managed) | Edge adapter (CDN-managed)                  |
-* | ------------------ | --------------------------------------- | ------------------------------------------- |
-* | Serve from store?  | Yes — reads the data cache              | No — origin renders fresh, edge caches      |
-* | Background regen   | In-process via `waitUntil`              | Edge re-requests origin                     |
-* | Response headers   | Framework cache policy                  | Provider-specific cache policy                         |
-* | Invalidation       | (data cache handles tag invalidation)   | purge / revalidate via request context      |
-*
-* The default adapter is a thin shim over the data cache + the framework's
-* existing header logic, so default behavior is byte-for-byte identical to the
-* pre-split implementation.
-*/
-/** Whether a Cache-Control value contains an exact non-cacheable directive. */
-function isNonCacheableCacheControl(cacheControl) {
+/** Split Cache-Control directives without treating quoted commas as separators. */
+function splitCacheControlDirectives(cacheControl) {
+	const directives = [];
 	let start = 0;
 	let quoted = false;
 	let escaped = false;
 	for (let index = 0; index <= cacheControl.length; index++) {
 		const char = cacheControl[index];
 		if (index === cacheControl.length || char === "," && !quoted) {
-			const directive = cacheControl.slice(start, index);
-			const equals = directive.indexOf("=");
-			const name = (equals === -1 ? directive : directive.slice(0, equals)).trim().toLowerCase();
-			if (name === "no-store" || equals === -1 && (name === "private" || name === "no-cache")) return true;
+			const directive = cacheControl.slice(start, index).trim();
+			if (directive) directives.push(directive);
 			start = index + 1;
 			continue;
 		}
@@ -48,7 +21,15 @@ function isNonCacheableCacheControl(cacheControl) {
 		if (char === "\"" && !escaped) quoted = !quoted;
 		escaped = false;
 	}
-	return false;
+	return directives;
+}
+/** Whether a Cache-Control value contains an exact non-cacheable directive. */
+function isNonCacheableCacheControl(cacheControl, scope = "shared") {
+	return splitCacheControlDirectives(cacheControl).some((directive) => {
+		const equals = directive.indexOf("=");
+		const name = (equals === -1 ? directive : directive.slice(0, equals)).trim().toLowerCase();
+		return name === "no-store" || equals === -1 && (name === "no-cache" || scope === "shared" && name === "private");
+	});
 }
 const PENDING_DYNAMIC_CACHE_CONTROL = "no-store, must-revalidate";
 /**
@@ -59,21 +40,28 @@ const PENDING_DYNAMIC_CACHE_CONTROL = "no-store, must-revalidate";
 * semantics must configure the adapter that owns those headers.
 */
 var DefaultCdnCacheAdapter = class {
+	buildIdentity;
 	ownsBackgroundRevalidation = true;
+	constructor(buildIdentity) {
+		this.buildIdentity = buildIdentity;
+	}
 	async get(key, ctx) {
+		const { getDataCacheHandler } = await import("./cache-handler.js");
 		return getDataCacheHandler().get(key, ctx);
 	}
 	async set(key, data, ctx) {
+		const { getDataCacheHandler } = await import("./cache-handler.js");
 		await getDataCacheHandler().set(key, data, ctx);
 	}
 	buildResponseHeaders(input) {
 		if (input.pendingDynamicCheck) return { "Cache-Control": PENDING_DYNAMIC_CACHE_CONTROL };
-		return { "Cache-Control": input.cacheControl };
+		return { "Cache-Control": input.browserCacheControl ?? input.cacheControl };
+	}
+	buildResponseIdentityHeaders() {
+		return this.buildIdentity ? { "X-Vinext-Build-Id": this.buildIdentity } : {};
 	}
 	async revalidateTag(_tags, _durations) {}
 };
-const _CDN_KEY = Symbol.for("vinext.cdnCacheAdapter");
-const _gCdn = globalThis;
 let _defaultAdapter = null;
 /**
 * Set a custom CDN cache adapter to delegate page-level ISR to a CDN edge. An
@@ -86,29 +74,25 @@ let _defaultAdapter = null;
 *
 * ```ts
 * import { vinext } from "vinext";
-* import { cdnAdapter } from "@vinext/cloudflare/cache/cdn-adapter";
+* import { workersCacheCdnAdapter } from "@vinext/cloudflare/cache/workers-cache-cdn-adapter";
 *
 * export default defineConfig({
-*   plugins: [vinext({ cache: { cdn: cdnAdapter() } })],
+*   plugins: [vinext({ cache: { cdn: workersCacheCdnAdapter() } })],
 * });
 * ```
 *
 * The plugin registers the adapter across every runtime/router entry, so you
-* don't have to call this from a worker entry. This setter remains as the
-* internal registration target and for backwards compatibility, but is not the
-* recommended consumer API.
+* don't have to call this from a worker entry. This setter remains for
+* backwards compatibility, but is not the recommended consumer API.
 */
-function setCdnCacheAdapter(adapter) {
-	_gCdn[_CDN_KEY] = adapter;
-}
 /**
 * Get the active CDN cache adapter. An explicitly configured adapter wins;
 * otherwise the origin-managed {@link DefaultCdnCacheAdapter} is used.
 */
 function getCdnCacheAdapter() {
-	const active = _gCdn[_CDN_KEY];
+	const active = getExplicitCdnCacheAdapter();
 	if (active) return active;
 	return _defaultAdapter ??= new DefaultCdnCacheAdapter();
 }
 //#endregion
-export { DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter };
+export { DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter, splitCacheControlDirectives };

package/dist/shims/client-hook-error.d.ts

@@ -7,7 +7,6 @@
  *
  * @see https://github.com/cloudflare/vinext/issues/834
  */
-declare function buildClientHookErrorMessage(hookName: string): string;
-declare function throwClientHookError(hookName: string): never;
-//#endregion
-export { buildClientHookErrorMessage, throwClientHookError };
+export declare function buildClientHookErrorMessage(hookName: string): string;
+export declare function throwClientHookError(hookName: string): never;
+//#endregion

package/dist/shims/client-locale.d.ts

@@ -1,9 +1,8 @@
 import { DomainLocale } from "../utils/domain-locale.js";
 //#region src/shims/client-locale.d.ts
-declare function getCurrentBrowserLocale({ basePath, domainLocales, hostname }: {
+export declare function getCurrentBrowserLocale({ basePath, domainLocales, hostname }: {
   basePath: string;
   domainLocales: readonly DomainLocale[] | undefined;
   hostname: string | null | undefined;
 }): string | undefined;
-//#endregion
-export { getCurrentBrowserLocale };
+//#endregion

package/dist/shims/client-page-root.d.ts

@@ -0,0 +1,24 @@
+import { ComponentType } from "react";
+//#region src/shims/client-page-root.d.ts
+type ClientPageSearchParams = Record<string, string | string[]>;
+export type ClientPageRootProps = {
+  Component: ComponentType<Record<string, unknown>>;
+  /** The page's other props (`params`, slot props). Never `searchParams`. */
+  pageProps: Readonly<Record<string, unknown>>;
+  /** The page always reads an empty query: `force-static`, or static export. */
+  emptySearchParams?: boolean;
+};
+/**
+ * Build an untracked `searchParams` promise, like Next.js 15's browser
+ * `makeUntrackedExoticSearchParams`: a settled promise whose query keys are
+ * also readable synchronously, except names Promise and React rely on.
+ *
+ * It matches the SSR thenable (`makeThenableParams`) wherever a page could
+ * tell them apart during hydration, so it is a proxy in the same way: the
+ * query keys are virtual, and the promise's methods run on the promise
+ * itself. As real own properties, a `constructor` key would replace the
+ * promise's species, and `await` would throw.
+ */
+export declare function createClientPageSearchParams(searchParams: URLSearchParams | null | undefined): Promise<ClientPageSearchParams>;
+export declare function ClientPageRoot({ Component, pageProps, emptySearchParams }: ClientPageRootProps): import("react").ReactElement<Record<string, unknown>, string | import("react").JSXElementConstructor<any>>;
+//#endregion

package/dist/shims/client-page-root.js

@@ -0,0 +1,121 @@
+"use client";
+import { searchParamsToRecord } from "../utils/query.js";
+import { getNavigationContext } from "./navigation-context-state.js";
+import "./navigation-server.js";
+import { isOwnPropertyCheck, isWellKnownProperty } from "./internal/thenable-well-known-properties.js";
+import { RenderedSearchContext } from "./slot.js";
+import { getClientNavigationRenderContext, useSearchParams } from "./navigation.js";
+import { createElement, use, useMemo } from "react";
+//#region src/shims/client-page-root.tsx
+/**
+* Wrapper for a "use client" App Router page, like Next.js's `ClientPageRoot`
+* (client/components/client-page.tsx).
+*
+* The server never sends a client page's `searchParams` through Flight. Flight
+* calls `then` on every promise prop while serializing it, so the page would
+* always count as reading the query, and the RSC payload would carry it. This
+* wrapper builds the prop where the page renders instead:
+*
+* - SSR: a promise per page from the navigation context (`app-ssr-entry.ts`),
+*   keyed by the page's props object like the browser's, so React's
+*   bookkeeping from one page's `use()` never shows on a sibling's. Reading
+*   it marks the render dynamic, so a render that uses the query is never
+*   stored, and a page that never reads it stays cacheable.
+* - Browser: the query the server rendered this page with, captured when the
+*   page's server output first renders. Next.js reads it from the page's own
+*   segment payload, so a rewritten query survives, and a page that stays
+*   mounted (an intercepted modal's background, a kept parallel slot) keeps
+*   its query when the URL changes. The router tags each payload's elements
+*   with the query they were rendered with (`RenderedSearchContext`), so a
+*   kept page that first renders under a later navigation (still streaming,
+*   or refreshed from its own URL) reads its own response's query.
+* - Browser, with Cache Components: the query `useSearchParams()` returns, as
+*   Next.js reads it from `SearchParamsContext` in that mode. That is the
+*   public URL's query rather than a rewritten one, and a kept page follows
+*   the URL.
+*
+* `emptySearchParams` pages (`dynamic = "force-static"`, static export) always
+* get an empty, untracked query, as the server renders them.
+*
+* This module runs in the browser, so it must not import server-only modules.
+*/
+const isServer = typeof window === "undefined";
+function isCacheComponentsEnabled() {
+	return String(process.env.__NEXT_CACHE_COMPONENTS) === "true";
+}
+/**
+* Build an untracked `searchParams` promise, like Next.js 15's browser
+* `makeUntrackedExoticSearchParams`: a settled promise whose query keys are
+* also readable synchronously, except names Promise and React rely on.
+*
+* It matches the SSR thenable (`makeThenableParams`) wherever a page could
+* tell them apart during hydration, so it is a proxy in the same way: the
+* query keys are virtual, and the promise's methods run on the promise
+* itself. As real own properties, a `constructor` key would replace the
+* promise's species, and `await` would throw.
+*/
+function createClientPageSearchParams(searchParams) {
+	const record = { ...searchParamsToRecord(searchParams) };
+	const promise = Promise.resolve(record);
+	const isQueryKey = (prop) => typeof prop === "string" && !isWellKnownProperty(prop) && Object.hasOwn(record, prop);
+	return new Proxy(promise, {
+		get(target, prop, receiver) {
+			if (isQueryKey(prop)) return record[prop];
+			const value = Reflect.get(target, prop);
+			if (typeof value !== "function") return value;
+			return value.bind(isOwnPropertyCheck(prop) ? receiver : target);
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			return isQueryKey(prop) ? {
+				configurable: true,
+				enumerable: true,
+				value: record[prop],
+				writable: true
+			} : Reflect.getOwnPropertyDescriptor(target, prop);
+		},
+		has(target, prop) {
+			return isQueryKey(prop) || Reflect.has(target, prop);
+		},
+		ownKeys() {
+			return Object.keys(record).filter((key) => !isWellKnownProperty(key));
+		}
+	});
+}
+const browserSearchParams = /* @__PURE__ */ new WeakMap();
+function useBrowserSearchParams(pageProps, emptySearchParams) {
+	const cached = browserSearchParams.get(pageProps);
+	if (cached) return cached;
+	let search = null;
+	if (!emptySearchParams) {
+		const context = getClientNavigationRenderContext();
+		const snapshot = context ? use(context) : null;
+		search = use(RenderedSearchContext) ?? (snapshot ? snapshot.renderedSearch ?? snapshot.search : window.location.search);
+	}
+	const searchParams = createClientPageSearchParams(search === null ? null : new URLSearchParams(search));
+	browserSearchParams.set(pageProps, searchParams);
+	return searchParams;
+}
+/**
+* Cache Components hands a client page the query `useSearchParams()` returns,
+* not the one its payload rendered, so a rewritten query stays internal.
+*/
+function useCanonicalSearchParams(emptySearchParams) {
+	const urlSearchParams = useSearchParams();
+	return useMemo(() => createClientPageSearchParams(emptySearchParams ? null : urlSearchParams), [emptySearchParams, urlSearchParams]);
+}
+function ClientPageRoot({ Component, pageProps, emptySearchParams }) {
+	let searchParams;
+	if (!isServer) searchParams = isCacheComponentsEnabled() ? useCanonicalSearchParams(emptySearchParams === true) : useBrowserSearchParams(pageProps, emptySearchParams === true);
+	else if (emptySearchParams === true) searchParams = createClientPageSearchParams(null);
+	else searchParams = getNavigationContext()?.getClientPageSearchParams?.(pageProps) ?? createClientPageSearchParams(null);
+	return useMemo(() => createElement(Component, {
+		...pageProps,
+		searchParams
+	}), [
+		Component,
+		pageProps,
+		searchParams
+	]);
+}
+//#endregion
+export { ClientPageRoot, createClientPageSearchParams };

package/dist/shims/compat-router.d.ts

@@ -10,6 +10,5 @@ import { NextRouter } from "./router.js";
  *
  * @returns The `NextRouter` instance if it's available, otherwise `null`.
  */
-declare function useRouter(): NextRouter | null;
-//#endregion
-export { useRouter };
+export declare function useRouter(): NextRouter | null;
+//#endregion

package/dist/shims/config.d.ts

@@ -18,11 +18,10 @@ type RuntimeConfig = {
  * Set the runtime config. Called during app bootstrap (by the plugin)
  * with values from next.config.js.
  */
-declare function setConfig(configValue: RuntimeConfig): void;
+export declare function setConfig(configValue: RuntimeConfig): void;
 /**
  * Get the current runtime config.
  * Default export — matches `import getConfig from "next/config"`.
  */
-declare function getConfig(): RuntimeConfig;
-//#endregion
-export { getConfig as default, setConfig };
+export default function getConfig(): RuntimeConfig;
+//#endregion