vinext 1.0.0-beta.8 → 1.0.0

package/dist/shims/cdn-cache.js

@@ -1,31 +1,29 @@
-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) {
+	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;
+			start = index + 1;
+			continue;
+		}
+		if (quoted && char === "\\" && !escaped) {
+			escaped = true;
+			continue;
+		}
+		if (char === "\"" && !escaped) quoted = !quoted;
+		escaped = false;
+	}
+	return false;
+}
 const PENDING_DYNAMIC_CACHE_CONTROL = "no-store, must-revalidate";
 /**
 * Default origin-managed ISR strategy: store page artifacts in the data cache,
@@ -35,21 +33,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 };
 	}
+	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
@@ -62,29 +67,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, setCdnCacheAdapter };
+export { DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter };

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

package/dist/shims/constants.d.ts

@@ -5,20 +5,20 @@
  * Provides build/runtime phase constants used by next.config.js
  * and some third-party libraries.
  */
-declare const MODERN_BROWSERSLIST_TARGET: string[];
-type ValueOf<T> = Required<T>[keyof T];
-declare const COMPILER_NAMES: {
+export declare const MODERN_BROWSERSLIST_TARGET: string[];
+export type ValueOf<T> = Required<T>[keyof T];
+export declare const COMPILER_NAMES: {
   readonly client: "client";
   readonly server: "server";
   readonly edgeServer: "edge-server";
 };
-type CompilerNameValues = ValueOf<typeof COMPILER_NAMES>;
-declare const COMPILER_INDEXES: { [compilerKey in CompilerNameValues]: number; };
-declare const UNDERSCORE_NOT_FOUND_ROUTE = "/_not-found";
-declare const UNDERSCORE_NOT_FOUND_ROUTE_ENTRY = "/_not-found/page";
-declare const UNDERSCORE_GLOBAL_ERROR_ROUTE = "/_global-error";
-declare const UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY = "/_global-error/page";
-declare enum AdapterOutputType {
+export type CompilerNameValues = ValueOf<typeof COMPILER_NAMES>;
+export declare const COMPILER_INDEXES: { [compilerKey in CompilerNameValues]: number; };
+export declare const UNDERSCORE_NOT_FOUND_ROUTE = "/_not-found";
+export declare const UNDERSCORE_NOT_FOUND_ROUTE_ENTRY = "/_not-found/page";
+export declare const UNDERSCORE_GLOBAL_ERROR_ROUTE = "/_global-error";
+export declare const UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY = "/_global-error/page";
+export declare enum AdapterOutputType {
   /**
    * `PAGES` represents all the React pages that are under `pages/`.
    */
@@ -51,80 +51,79 @@ declare enum AdapterOutputType {
    */
   MIDDLEWARE = "MIDDLEWARE"
 }
-declare const PHASE_EXPORT = "phase-export";
-declare const PHASE_ANALYZE = "phase-analyze";
-declare const PHASE_PRODUCTION_BUILD = "phase-production-build";
-declare const PHASE_PRODUCTION_SERVER = "phase-production-server";
-declare const PHASE_DEVELOPMENT_SERVER = "phase-development-server";
-declare const PHASE_TEST = "phase-test";
-declare const PHASE_INFO = "phase-info";
-type PHASE_TYPE = typeof PHASE_INFO | typeof PHASE_TEST | typeof PHASE_EXPORT | typeof PHASE_ANALYZE | typeof PHASE_PRODUCTION_BUILD | typeof PHASE_PRODUCTION_SERVER | typeof PHASE_DEVELOPMENT_SERVER;
-declare const PAGES_MANIFEST = "pages-manifest.json";
-declare const APP_PATHS_MANIFEST = "app-paths-manifest.json";
-declare const APP_PATH_ROUTES_MANIFEST = "app-path-routes-manifest.json";
-declare const BUILD_MANIFEST = "build-manifest.json";
-declare const FUNCTIONS_CONFIG_MANIFEST = "functions-config-manifest.json";
-declare const SUBRESOURCE_INTEGRITY_MANIFEST = "subresource-integrity-manifest";
-declare const NEXT_FONT_MANIFEST = "next-font-manifest";
-declare const EXPORT_MARKER = "export-marker.json";
-declare const EXPORT_DETAIL = "export-detail.json";
-declare const PREFETCH_HINTS = "prefetch-hints.json";
-declare const PRERENDER_MANIFEST = "prerender-manifest.json";
-declare const ROUTES_MANIFEST = "routes-manifest.json";
-declare const IMAGES_MANIFEST = "images-manifest.json";
-declare const SERVER_FILES_MANIFEST = "required-server-files";
-declare const DEV_CLIENT_PAGES_MANIFEST = "_devPagesManifest.json";
-declare const MIDDLEWARE_MANIFEST = "middleware-manifest.json";
-declare const TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST = "_clientMiddlewareManifest.js";
-declare const TURBOPACK_CLIENT_BUILD_MANIFEST = "client-build-manifest.json";
-declare const DEV_CLIENT_MIDDLEWARE_MANIFEST = "_devMiddlewareManifest.json";
-declare const REACT_LOADABLE_MANIFEST = "react-loadable-manifest.json";
-declare const SERVER_DIRECTORY = "server";
-declare const CONFIG_FILES: string[];
-declare const BUILD_ID_FILE = "BUILD_ID";
-declare const BLOCKED_PAGES: string[];
-declare const CLIENT_PUBLIC_FILES_PATH = "public";
-declare const CLIENT_STATIC_FILES_PATH = "static";
-declare const STRING_LITERAL_DROP_BUNDLE = "__NEXT_DROP_CLIENT_FILE__";
-declare const NEXT_BUILTIN_DOCUMENT = "__NEXT_BUILTIN_DOCUMENT__";
-declare const BARREL_OPTIMIZATION_PREFIX = "__barrel_optimize__";
-declare const CLIENT_REFERENCE_MANIFEST = "client-reference-manifest";
-declare const SERVER_REFERENCE_MANIFEST = "server-reference-manifest";
-declare const MIDDLEWARE_BUILD_MANIFEST = "middleware-build-manifest";
-declare const MIDDLEWARE_REACT_LOADABLE_MANIFEST = "middleware-react-loadable-manifest";
-declare const INTERCEPTION_ROUTE_REWRITE_MANIFEST = "interception-route-rewrite-manifest";
-declare const DYNAMIC_CSS_MANIFEST = "dynamic-css-manifest";
-declare const CLIENT_STATIC_FILES_RUNTIME_MAIN = "main";
-declare const CLIENT_STATIC_FILES_RUNTIME_MAIN_APP = "main-app";
-declare const APP_CLIENT_INTERNALS = "app-pages-internals";
-declare const CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH = "react-refresh";
-declare const CLIENT_STATIC_FILES_RUNTIME_WEBPACK = "webpack";
-declare const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS = "polyfills";
-declare const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL: unique symbol;
-declare const DEFAULT_RUNTIME_WEBPACK = "webpack-runtime";
-declare const EDGE_RUNTIME_WEBPACK = "edge-runtime-webpack";
-declare const STATIC_PROPS_ID = "__N_SSG";
-declare const SERVER_PROPS_ID = "__N_SSP";
-declare const DEFAULT_SERIF_FONT: {
+export declare const PHASE_EXPORT = "phase-export";
+export declare const PHASE_ANALYZE = "phase-analyze";
+export declare const PHASE_PRODUCTION_BUILD = "phase-production-build";
+export declare const PHASE_PRODUCTION_SERVER = "phase-production-server";
+export declare const PHASE_DEVELOPMENT_SERVER = "phase-development-server";
+export declare const PHASE_TEST = "phase-test";
+export declare const PHASE_INFO = "phase-info";
+export type PHASE_TYPE = typeof PHASE_INFO | typeof PHASE_TEST | typeof PHASE_EXPORT | typeof PHASE_ANALYZE | typeof PHASE_PRODUCTION_BUILD | typeof PHASE_PRODUCTION_SERVER | typeof PHASE_DEVELOPMENT_SERVER;
+export declare const PAGES_MANIFEST = "pages-manifest.json";
+export declare const APP_PATHS_MANIFEST = "app-paths-manifest.json";
+export declare const APP_PATH_ROUTES_MANIFEST = "app-path-routes-manifest.json";
+export declare const BUILD_MANIFEST = "build-manifest.json";
+export declare const FUNCTIONS_CONFIG_MANIFEST = "functions-config-manifest.json";
+export declare const SUBRESOURCE_INTEGRITY_MANIFEST = "subresource-integrity-manifest";
+export declare const NEXT_FONT_MANIFEST = "next-font-manifest";
+export declare const EXPORT_MARKER = "export-marker.json";
+export declare const EXPORT_DETAIL = "export-detail.json";
+export declare const PREFETCH_HINTS = "prefetch-hints.json";
+export declare const PRERENDER_MANIFEST = "prerender-manifest.json";
+export declare const ROUTES_MANIFEST = "routes-manifest.json";
+export declare const IMAGES_MANIFEST = "images-manifest.json";
+export declare const SERVER_FILES_MANIFEST = "required-server-files";
+export declare const DEV_CLIENT_PAGES_MANIFEST = "_devPagesManifest.json";
+export declare const MIDDLEWARE_MANIFEST = "middleware-manifest.json";
+export declare const TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST = "_clientMiddlewareManifest.js";
+export declare const TURBOPACK_CLIENT_BUILD_MANIFEST = "client-build-manifest.json";
+export declare const DEV_CLIENT_MIDDLEWARE_MANIFEST = "_devMiddlewareManifest.json";
+export declare const REACT_LOADABLE_MANIFEST = "react-loadable-manifest.json";
+export declare const SERVER_DIRECTORY = "server";
+export declare const CONFIG_FILES: string[];
+export declare const BUILD_ID_FILE = "BUILD_ID";
+export declare const BLOCKED_PAGES: string[];
+export declare const CLIENT_PUBLIC_FILES_PATH = "public";
+export declare const CLIENT_STATIC_FILES_PATH = "static";
+export declare const STRING_LITERAL_DROP_BUNDLE = "__NEXT_DROP_CLIENT_FILE__";
+export declare const NEXT_BUILTIN_DOCUMENT = "__NEXT_BUILTIN_DOCUMENT__";
+export declare const BARREL_OPTIMIZATION_PREFIX = "__barrel_optimize__";
+export declare const CLIENT_REFERENCE_MANIFEST = "client-reference-manifest";
+export declare const SERVER_REFERENCE_MANIFEST = "server-reference-manifest";
+export declare const MIDDLEWARE_BUILD_MANIFEST = "middleware-build-manifest";
+export declare const MIDDLEWARE_REACT_LOADABLE_MANIFEST = "middleware-react-loadable-manifest";
+export declare const INTERCEPTION_ROUTE_REWRITE_MANIFEST = "interception-route-rewrite-manifest";
+export declare const DYNAMIC_CSS_MANIFEST = "dynamic-css-manifest";
+export declare const CLIENT_STATIC_FILES_RUNTIME_MAIN = "main";
+export declare const CLIENT_STATIC_FILES_RUNTIME_MAIN_APP = "main-app";
+export declare const APP_CLIENT_INTERNALS = "app-pages-internals";
+export declare const CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH = "react-refresh";
+export declare const CLIENT_STATIC_FILES_RUNTIME_WEBPACK = "webpack";
+export declare const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS = "polyfills";
+export declare const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL: unique symbol;
+export declare const DEFAULT_RUNTIME_WEBPACK = "webpack-runtime";
+export declare const EDGE_RUNTIME_WEBPACK = "edge-runtime-webpack";
+export declare const STATIC_PROPS_ID = "__N_SSG";
+export declare const SERVER_PROPS_ID = "__N_SSP";
+export declare const DEFAULT_SERIF_FONT: {
   name: string;
   xAvgCharWidth: number;
   azAvgWidth: number;
   unitsPerEm: number;
 };
-declare const DEFAULT_SANS_SERIF_FONT: {
+export declare const DEFAULT_SANS_SERIF_FONT: {
   name: string;
   xAvgCharWidth: number;
   azAvgWidth: number;
   unitsPerEm: number;
 };
-declare const STATIC_STATUS_PAGES: string[];
-declare const TRACE_OUTPUT_VERSION = 1;
-declare const TURBO_TRACE_DEFAULT_MEMORY_LIMIT = 6000;
-declare const RSC_MODULE_TYPES: {
+export declare const STATIC_STATUS_PAGES: string[];
+export declare const TRACE_OUTPUT_VERSION = 1;
+export declare const TURBO_TRACE_DEFAULT_MEMORY_LIMIT = 6000;
+export declare const RSC_MODULE_TYPES: {
   readonly client: "client";
   readonly server: "server";
 };
-declare const EDGE_UNSUPPORTED_NODE_APIS: string[];
-declare const SYSTEM_ENTRYPOINTS: Set<string>;
-//#endregion
-export { APP_CLIENT_INTERNALS, APP_PATHS_MANIFEST, APP_PATH_ROUTES_MANIFEST, AdapterOutputType, BARREL_OPTIMIZATION_PREFIX, BLOCKED_PAGES, BUILD_ID_FILE, BUILD_MANIFEST, CLIENT_PUBLIC_FILES_PATH, CLIENT_REFERENCE_MANIFEST, CLIENT_STATIC_FILES_PATH, CLIENT_STATIC_FILES_RUNTIME_MAIN, CLIENT_STATIC_FILES_RUNTIME_MAIN_APP, CLIENT_STATIC_FILES_RUNTIME_POLYFILLS, CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL, CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH, CLIENT_STATIC_FILES_RUNTIME_WEBPACK, COMPILER_INDEXES, COMPILER_NAMES, CONFIG_FILES, CompilerNameValues, DEFAULT_RUNTIME_WEBPACK, DEFAULT_SANS_SERIF_FONT, DEFAULT_SERIF_FONT, DEV_CLIENT_MIDDLEWARE_MANIFEST, DEV_CLIENT_PAGES_MANIFEST, DYNAMIC_CSS_MANIFEST, EDGE_RUNTIME_WEBPACK, EDGE_UNSUPPORTED_NODE_APIS, EXPORT_DETAIL, EXPORT_MARKER, FUNCTIONS_CONFIG_MANIFEST, IMAGES_MANIFEST, INTERCEPTION_ROUTE_REWRITE_MANIFEST, MIDDLEWARE_BUILD_MANIFEST, MIDDLEWARE_MANIFEST, MIDDLEWARE_REACT_LOADABLE_MANIFEST, MODERN_BROWSERSLIST_TARGET, NEXT_BUILTIN_DOCUMENT, NEXT_FONT_MANIFEST, PAGES_MANIFEST, PHASE_ANALYZE, PHASE_DEVELOPMENT_SERVER, PHASE_EXPORT, PHASE_INFO, PHASE_PRODUCTION_BUILD, PHASE_PRODUCTION_SERVER, PHASE_TEST, PHASE_TYPE, PREFETCH_HINTS, PRERENDER_MANIFEST, REACT_LOADABLE_MANIFEST, ROUTES_MANIFEST, RSC_MODULE_TYPES, SERVER_DIRECTORY, SERVER_FILES_MANIFEST, SERVER_PROPS_ID, SERVER_REFERENCE_MANIFEST, STATIC_PROPS_ID, STATIC_STATUS_PAGES, STRING_LITERAL_DROP_BUNDLE, SUBRESOURCE_INTEGRITY_MANIFEST, SYSTEM_ENTRYPOINTS, TRACE_OUTPUT_VERSION, TURBOPACK_CLIENT_BUILD_MANIFEST, TURBOPACK_CLIENT_MIDDLEWARE_MANIFEST, TURBO_TRACE_DEFAULT_MEMORY_LIMIT, UNDERSCORE_GLOBAL_ERROR_ROUTE, UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY, UNDERSCORE_NOT_FOUND_ROUTE, UNDERSCORE_NOT_FOUND_ROUTE_ENTRY, ValueOf };
+export declare const EDGE_UNSUPPORTED_NODE_APIS: string[];
+export declare const SYSTEM_ENTRYPOINTS: Set<string>;
+//#endregion

package/dist/shims/constants.js

@@ -91,7 +91,7 @@ const CONFIG_FILES = [
 	"next.config.js",
 	"next.config.mjs",
 	"next.config.ts",
-	...process?.features?.typescript ? ["next.config.mts"] : []
+	...typeof process !== "undefined" && process.features?.typescript ? ["next.config.mts"] : []
 ];
 const BUILD_ID_FILE = "BUILD_ID";
 const BLOCKED_PAGES = [

package/dist/shims/default-not-found.d.ts

@@ -5,6 +5,5 @@ import React from "react";
  * from Next.js. Kept in sync with the upstream component's structure so HTML
  * snapshot diffs between Next.js and vinext stay minimal.
  */
-declare function DefaultNotFound(): React.ReactElement;
-//#endregion
-export { DefaultNotFound as default };
+export default function DefaultNotFound(): React.ReactElement;
+//#endregion

package/dist/shims/document.d.ts

@@ -2,7 +2,7 @@ import React from "react";
 import { DocumentContext, DocumentInitialProps, DocumentProps } from "@vinext/types/next/upstream/dist/shared/lib/utils";
 import { HtmlProps } from "@vinext/types/next/upstream/dist/shared/lib/html-context.shared-runtime";
 //#region src/shims/document.d.ts
-type OriginProps = {
+export type OriginProps = {
   nonce?: string;
   crossOrigin?: "anonymous" | "use-credentials" | "" | undefined;
   children?: React.ReactNode;
@@ -13,11 +13,11 @@ type DocumentFiles = {
   allFiles: readonly string[];
 };
 type HeadProps = OriginProps & React.ComponentPropsWithoutRef<"head">;
-declare function Html(props: React.DetailedHTMLProps<React.HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>): React.ReactElement;
-interface Head {
+export declare function Html(props: React.DetailedHTMLProps<React.HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>): React.ReactElement;
+export interface Head {
   context: HtmlProps;
 }
-declare class Head extends React.Component<HeadProps> {
+export declare class Head extends React.Component<HeadProps> {
   static contextType: React.Context<HtmlProps | undefined>;
   getCssLinks(_files: DocumentFiles): React.ReactElement[] | null;
   getPreloadDynamicChunks(): Array<React.ReactElement | null>;
@@ -29,11 +29,11 @@ declare class Head extends React.Component<HeadProps> {
   getPolyfillScripts(): React.ReactElement[];
   render(): React.ReactElement;
 }
-declare function Main(): React.ReactElement;
-interface NextScript {
+export declare function Main(): React.ReactElement;
+export interface NextScript {
   context: HtmlProps;
 }
-declare class NextScript extends React.Component<OriginProps> {
+export declare class NextScript extends React.Component<OriginProps> {
   static contextType: React.Context<HtmlProps | undefined>;
   getDynamicChunks(_files: DocumentFiles): Array<React.ReactElement | null>;
   getPreNextScripts(): React.ReactElement;
@@ -42,9 +42,9 @@ declare class NextScript extends React.Component<OriginProps> {
   static getInlineScriptSource(context: Readonly<HtmlProps>): string;
   render(): React.ReactElement;
 }
-declare class Document<P = {}> extends React.Component<DocumentProps & P> {
+export default class Document<P = {}> extends React.Component<DocumentProps & P> {
   static getInitialProps(ctx: DocumentContext): Promise<DocumentInitialProps>;
   render(): React.ReactElement;
 }
 //#endregion
-export { type DocumentContext, type DocumentInitialProps, type DocumentProps, Head, Html, Main, NextScript, OriginProps, Document as default };
+export type { DocumentContext, DocumentInitialProps, DocumentProps };

package/dist/shims/dynamic-preload-chunks.d.ts

@@ -1,7 +1,6 @@
 import React from "react";
 //#region src/shims/dynamic-preload-chunks.d.ts
-declare function DynamicPreloadChunks(props: {
+export declare function DynamicPreloadChunks(props: {
   moduleIds?: readonly string[];
 }): React.FunctionComponentElement<React.FragmentProps> | null;
-//#endregion
-export { DynamicPreloadChunks };
+//#endregion

package/dist/shims/dynamic-preload-chunks.js

@@ -1,8 +1,7 @@
 "use client";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
-import { useScriptNonce } from "./script-nonce-context.js";
+import { useInitialStylesheetHrefs, useScriptNonce } from "./script-nonce-context.js";
 import React from "react";
-import * as ReactDOM from "react-dom";
 import { getPagesClientAssets } from "vinext/server/pages-client-assets";
 //#region src/shims/dynamic-preload-chunks.tsx
 /**
@@ -48,33 +47,38 @@ function resolveDynamicPreloadFiles(moduleIds) {
 }
 function DynamicPreloadChunks(props) {
 	const nonce = useScriptNonce();
+	const initialStylesheetHrefs = useInitialStylesheetHrefs();
 	if (typeof window !== "undefined") return null;
 	const files = resolveDynamicPreloadFiles(props.moduleIds);
 	if (files.length === 0) return null;
-	const stylesheets = [];
+	const crossOrigin = getPagesClientAssets().crossOrigin ?? "";
+	const preloadLinks = [];
 	for (const file of files) {
 		const assetHref = dynamicPreloadHref(file);
 		if (assetHref.endsWith(".css")) {
 			const href = appendAssetDeploymentIdQuery(assetHref);
-			stylesheets.push(React.createElement("link", {
+			if (initialStylesheetHrefs?.has(href)) continue;
+			preloadLinks.push(React.createElement("link", {
 				key: href,
 				rel: "stylesheet",
 				href,
+				crossOrigin,
 				nonce,
 				precedence: "dynamic"
 			}));
 			continue;
 		}
-		if (assetHref.endsWith(".js") && typeof ReactDOM.preload === "function") {
-			const preloadOptions = {
-				as: "script",
-				fetchPriority: "low",
-				nonce
-			};
-			ReactDOM.preload(assetHref, preloadOptions);
-		}
+		if (assetHref.endsWith(".js")) preloadLinks.push(React.createElement("link", {
+			key: assetHref,
+			rel: "modulepreload",
+			href: assetHref,
+			as: "script",
+			crossOrigin,
+			fetchPriority: "low",
+			nonce
+		}));
 	}
-	return stylesheets.length > 0 ? React.createElement(React.Fragment, null, ...stylesheets) : null;
+	return preloadLinks.length > 0 ? React.createElement(React.Fragment, null, ...preloadLinks) : null;
 }
 //#endregion
 export { DynamicPreloadChunks };