vinext 0.1.1 → 0.1.3

package/dist/shims/script-nonce-context.d.ts

@@ -1,7 +1,7 @@
 import React from "react";
 
 //#region src/shims/script-nonce-context.d.ts
-declare const ScriptNonceContext: React.Context<string | undefined>;
+declare const ScriptNonceContext: React.Context<string | undefined> | null;
 declare function ScriptNonceProvider(props: React.PropsWithChildren<{
   nonce?: string;
 }>): React.ReactElement;

package/dist/shims/script-nonce-context.js

@@ -1,15 +1,23 @@
 import React from "react";
 //#region src/shims/script-nonce-context.tsx
-const ScriptNonceContext = React.createContext(void 0);
+const ScriptNonceContext = typeof React.createContext === "function" ? React.createContext(void 0) : null;
 function ScriptNonceProvider(props) {
+	if (!ScriptNonceContext) return React.createElement(React.Fragment, null, props.children);
 	return React.createElement(ScriptNonceContext.Provider, { value: props.nonce }, props.children);
 }
 function withScriptNonce(element, nonce) {
-	if (!nonce) return element;
+	if (!nonce || !ScriptNonceContext) return element;
 	return React.createElement(ScriptNonceProvider, { nonce }, element);
 }
+function createScriptNonceHook(context) {
+	if (!context || typeof React.useContext !== "function") return function useScriptNonceFromContext() {};
+	return function useScriptNonceFromContext() {
+		return React.useContext(context);
+	};
+}
+const useScriptNonceFromContext = createScriptNonceHook(ScriptNonceContext);
 function useScriptNonce() {
-	return React.useContext(ScriptNonceContext);
+	return useScriptNonceFromContext();
 }
 //#endregion
 export { ScriptNonceContext, ScriptNonceProvider, useScriptNonce, withScriptNonce };

package/dist/shims/server.d.ts

@@ -19,6 +19,11 @@ declare class NextRequest extends Request {
       i18n?: {
         locales: string[];
         defaultLocale: string;
+        domains?: Array<{
+          domain: string;
+          defaultLocale: string;
+          locales?: string[];
+        }>;
       };
       trailingSlash?: boolean;
     };
@@ -78,6 +83,11 @@ type NextURLConfig = {
     i18n?: {
       locales: string[];
       defaultLocale: string;
+      domains?: Array<{
+        domain: string;
+        defaultLocale: string;
+        locales?: string[];
+      }>;
     };
     /**
      * When true, `href`/`toString()` formats non-root, non-file-like pathnames
@@ -91,16 +101,36 @@ type NextURLConfig = {
 declare class NextURL {
   /** Internal URL stores the pathname WITHOUT basePath or locale prefix. */
   private _url;
+  /**
+   * The configured basePath (from nextConfig). May differ from the active
+   * `_basePath`: parsing only activates basePath when the URL's pathname
+   * actually carries the configured prefix.
+   */
+  private _configBasePath;
   private _basePath;
   private _trailingSlash;
   private _locale;
+  private _configDefaultLocale;
   private _defaultLocale;
   private _locales;
+  private _domains;
+  private _domainLocale;
   constructor(input: string | URL, base?: string | URL, config?: NextURLConfig);
-  /** Strip basePath prefix from the internal pathname. */
+  /** Strip basePath prefix from the internal pathname.
+   * Mirrors Next.js's getNextPathnameInfo (re-run by NextURL.analyze() on
+   * every parse, including `href` reassignment): basePath is only considered
+   * active when the URL's pathname actually starts with the configured
+   * basePath prefix. If the pathname is outside the basePath, the active
+   * basePath is cleared to "" so that request.nextUrl.basePath reflects the
+   * actual URL rather than the config value; if a later `href` assignment
+   * moves the URL back inside the basePath, it is re-activated from the
+   * configured value. This matches the Next.js behavior tested by
+   * middleware-base-path's "should execute from absolute paths" case.
+   */
   private _stripBasePath;
   /** Extract locale from pathname, stripping it from the internal URL. */
-  private _analyzeLocale;
+  private _detectPathnameLocale;
+  private _analyzeI18n;
   /**
    * Reconstruct the full pathname with basePath + locale prefix and apply
    * the configured trailingSlash policy.
@@ -142,6 +172,7 @@ declare class NextURL {
   get locale(): string;
   set locale(value: string | undefined);
   get defaultLocale(): string | undefined;
+  get domainLocale(): typeof this._domainLocale;
   get locales(): string[] | undefined;
   clone(): NextURL;
   toString(): string;

package/dist/shims/server.js

@@ -1,9 +1,9 @@
-import { stripBasePath } from "../utils/base-path.js";
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "./request-context.js";
 import { MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER } from "../server/headers.js";
 import { encodeMiddlewareRequestHeaders } from "../server/middleware-request-headers.js";
 import { serializeSetCookie, validateCookieName } from "./internal/cookie-serialize.js";
-import { parseCookieHeader } from "./internal/parse-cookie-header.js";
+import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 //#region src/shims/server.ts
 /**
@@ -51,6 +51,12 @@ var NextRequest = class extends Request {
 		if (input instanceof Request) {
 			const requestInput = requestInit.body === void 0 && input.body && !input.bodyUsed ? input.clone() : input;
 			super(requestInput, requestInit);
+			const cf = Reflect.get(input, "cf");
+			if (cf !== void 0) Object.defineProperty(this, "cf", {
+				value: cf,
+				enumerable: true,
+				configurable: true
+			});
 		} else super(input, requestInit);
 		const url = typeof input === "string" ? new URL(input, "http://localhost") : input instanceof URL ? input : new URL(input.url, "http://localhost");
 		const urlConfig = _nextConfig ? {
@@ -183,37 +189,73 @@ var NextResponse = class NextResponse extends Response {
 var NextURL = class NextURL {
 	/** Internal URL stores the pathname WITHOUT basePath or locale prefix. */
 	_url;
+	/**
+	* The configured basePath (from nextConfig). May differ from the active
+	* `_basePath`: parsing only activates basePath when the URL's pathname
+	* actually carries the configured prefix.
+	*/
+	_configBasePath;
 	_basePath;
 	_trailingSlash;
 	_locale;
+	_configDefaultLocale;
 	_defaultLocale;
 	_locales;
+	_domains;
+	_domainLocale;
 	constructor(input, base, config) {
 		this._url = new URL(input.toString(), base);
-		this._basePath = config?.basePath ?? "";
+		this._configBasePath = config?.basePath ?? "";
+		this._basePath = this._configBasePath;
 		this._trailingSlash = config?.nextConfig?.trailingSlash ?? false;
 		this._stripBasePath();
 		const i18n = config?.nextConfig?.i18n;
 		if (i18n) {
 			this._locales = [...i18n.locales];
-			this._defaultLocale = i18n.defaultLocale;
-			this._analyzeLocale(this._locales);
+			this._domains = i18n.domains?.map((domain) => ({
+				...domain,
+				locales: domain.locales ? [...domain.locales] : void 0
+			}));
+			this._configDefaultLocale = i18n.defaultLocale;
+			this._analyzeI18n();
 		}
 	}
-	/** Strip basePath prefix from the internal pathname. */
+	/** Strip basePath prefix from the internal pathname.
+	* Mirrors Next.js's getNextPathnameInfo (re-run by NextURL.analyze() on
+	* every parse, including `href` reassignment): basePath is only considered
+	* active when the URL's pathname actually starts with the configured
+	* basePath prefix. If the pathname is outside the basePath, the active
+	* basePath is cleared to "" so that request.nextUrl.basePath reflects the
+	* actual URL rather than the config value; if a later `href` assignment
+	* moves the URL back inside the basePath, it is re-activated from the
+	* configured value. This matches the Next.js behavior tested by
+	* middleware-base-path's "should execute from absolute paths" case.
+	*/
 	_stripBasePath() {
-		if (!this._basePath) return;
-		this._url.pathname = stripBasePath(this._url.pathname, this._basePath);
+		if (!this._configBasePath) return;
+		if (!hasBasePath(this._url.pathname, this._configBasePath)) {
+			this._basePath = "";
+			return;
+		}
+		this._basePath = this._configBasePath;
+		this._url.pathname = stripBasePath(this._url.pathname, this._configBasePath);
 	}
 	/** Extract locale from pathname, stripping it from the internal URL. */
-	_analyzeLocale(locales) {
+	_detectPathnameLocale(locales) {
 		const segments = this._url.pathname.split("/");
 		const candidate = segments[1]?.toLowerCase();
 		const match = locales.find((l) => l.toLowerCase() === candidate);
-		if (match) {
-			this._locale = match;
-			this._url.pathname = "/" + segments.slice(2).join("/");
-		} else this._locale = this._defaultLocale;
+		if (match) this._url.pathname = "/" + segments.slice(2).join("/");
+		return match;
+	}
+	_analyzeI18n() {
+		if (!this._locales || !this._configDefaultLocale) return;
+		const detectedLocale = this._detectPathnameLocale(this._locales);
+		const detectedLocaleLower = detectedLocale?.toLowerCase();
+		const hostname = this._url.hostname.toLowerCase();
+		this._domainLocale = this._domains?.find((domain) => domain.domain.split(":", 1)[0].toLowerCase() === hostname || detectedLocaleLower === domain.defaultLocale.toLowerCase() || domain.locales?.some((locale) => locale.toLowerCase() === detectedLocaleLower));
+		this._defaultLocale = this._domainLocale?.defaultLocale ?? this._configDefaultLocale;
+		this._locale = detectedLocale ?? this._defaultLocale;
 	}
 	/**
 	* Reconstruct the full pathname with basePath + locale prefix and apply
@@ -222,8 +264,9 @@ var NextURL = class NextURL {
 	*/
 	_formatPathname() {
 		let prefix = this._basePath;
-		if (this._locale && this._locale !== this._defaultLocale) prefix += "/" + this._locale;
 		const inner = this._url.pathname;
+		const innerLower = inner.toLowerCase();
+		if (!(innerLower === "/api" || innerLower.startsWith("/api/")) && this._locale && this._locale !== this._defaultLocale) prefix += "/" + this._locale;
 		const composed = !prefix ? inner : inner === "/" ? prefix : prefix + inner;
 		return this._applyTrailingSlash(composed);
 	}
@@ -248,7 +291,7 @@ var NextURL = class NextURL {
 	set href(value) {
 		this._url.href = value;
 		this._stripBasePath();
-		if (this._locales) this._analyzeLocale(this._locales);
+		this._analyzeI18n();
 	}
 	get origin() {
 		return this._url.origin;
@@ -333,6 +376,13 @@ var NextURL = class NextURL {
 	get defaultLocale() {
 		return this._defaultLocale;
 	}
+	get domainLocale() {
+		if (!this._domainLocale) return void 0;
+		return {
+			...this._domainLocale,
+			locales: this._domainLocale.locales ? [...this._domainLocale.locales] : void 0
+		};
+	}
 	get locales() {
 		return this._locales ? [...this._locales] : void 0;
 	}
@@ -340,7 +390,11 @@ var NextURL = class NextURL {
 		const nextConfig = {};
 		if (this._locales) nextConfig.i18n = {
 			locales: [...this._locales],
-			defaultLocale: this._defaultLocale
+			defaultLocale: this._configDefaultLocale,
+			domains: this._domains?.map((domain) => ({
+				...domain,
+				locales: domain.locales ? [...domain.locales] : void 0
+			}))
 		};
 		if (this._trailingSlash) nextConfig.trailingSlash = true;
 		const config = {
@@ -367,7 +421,7 @@ var RequestCookies = class {
 	_parsed;
 	constructor(headers) {
 		this._headers = headers;
-		this._parsed = parseCookieHeader(headers.get("cookie") ?? "");
+		this._parsed = parseEdgeRequestCookieHeader(headers.get("cookie") ?? "");
 	}
 	get(name) {
 		const value = this._parsed.get(name);
@@ -655,10 +709,13 @@ function after(task) {
 * and sets Cache-Control: no-store on the response.
 */
 async function connection() {
-	const { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope } = await import("./headers.js");
+	const { getHeadersContext, markDynamicUsage, markRenderRequestApiUsage, suspendConnectionProbe, throwIfInsideCacheScope } = await import("./headers.js");
+	if (getHeadersContext()?.forceStatic) return;
 	markRenderRequestApiUsage("connection");
 	throwIfInsideCacheScope("connection()");
 	markDynamicUsage();
+	const pendingProbe = suspendConnectionProbe();
+	if (pendingProbe) await pendingProbe;
 }
 /**
 * URLPattern re-export — used in middleware for route matching.

package/dist/shims/slot.js

@@ -23,7 +23,7 @@ const MAX_BFCACHE_SLOT_ENTRIES_WITH_CACHE_COMPONENTS = 3;
 const MAX_BFCACHE_SLOT_ENTRIES_WITHOUT_CACHE_COMPONENTS = 1;
 const BfcacheStateKeyMapContext = React$1.createContext(EMPTY_BFCACHE_STATE_KEYS);
 function isCacheComponentsEnabled() {
-	return process.env.__NEXT_CACHE_COMPONENTS === "true";
+	return String(process.env.__NEXT_CACHE_COMPONENTS) === "true";
 }
 function getBfcacheSlotEntryLimit() {
 	return isCacheComponentsEnabled() ? MAX_BFCACHE_SLOT_ENTRIES_WITH_CACHE_COMPONENTS : MAX_BFCACHE_SLOT_ENTRIES_WITHOUT_CACHE_COMPONENTS;

package/dist/shims/unified-request-context.js

@@ -18,6 +18,7 @@ function createRequestContext(opts) {
 		actionRevalidationKind: 0,
 		dynamicUsageDetected: false,
 		renderRequestApiUsage: /* @__PURE__ */ new Set(),
+		connectionProbe: null,
 		invalidDynamicUsageError: null,
 		pendingSetCookies: [],
 		draftModeCookieHeader: null,
@@ -33,6 +34,7 @@ function createRequestContext(opts) {
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
+		currentForceDynamicFetchDefault: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		isFetchDedupeActive: false,
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),

package/dist/typegen.js

@@ -1,6 +1,7 @@
 import { decodeRouteSegment, isInvisibleSegment } from "./routing/utils.js";
 import { patternToNextFormat } from "./routing/route-validation.js";
 import { compareStrings } from "./utils/compare.js";
+import "./routing/app-route-graph.js";
 import { appRouteGraph } from "./routing/app-router.js";
 import path from "node:path";
 import fs from "node:fs/promises";

package/dist/utils/built-asset-url.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/built-asset-url.d.ts
+declare function renderVinextBuiltUrl(filename: string, assetPrefix: string, deploymentId?: string, hostType?: "js" | "css" | "html"): string;
+//#endregion
+export { renderVinextBuiltUrl };

package/dist/utils/built-asset-url.js

@@ -0,0 +1,11 @@
+import { appendDeploymentIdQuery } from "./deployment-id.js";
+import { ASSET_PREFIX_URL_DIR, resolveAssetUrlPrefix, resolveAssetsDir } from "./asset-prefix.js";
+//#region src/utils/built-asset-url.ts
+function renderVinextBuiltUrl(filename, assetPrefix, deploymentId, hostType) {
+	const urlPrefix = resolveAssetUrlPrefix(assetPrefix);
+	const dirPrefix = resolveAssetsDir(assetPrefix) + "/";
+	const url = urlPrefix + (filename.startsWith(dirPrefix) ? filename.slice(dirPrefix.length) : filename.startsWith(`_next/static/`) ? filename.slice(ASSET_PREFIX_URL_DIR.length + 1) : filename);
+	return hostType === "js" ? url : appendDeploymentIdQuery(url, deploymentId);
+}
+//#endregion
+export { renderVinextBuiltUrl };

package/dist/utils/client-build-manifest.js

@@ -47,16 +47,26 @@ function findEntryFileFromManifest(buildManifest, assetBase, markers, fallbackTo
 	const chosen = fallbackToFirstEntry ? entries[0] : void 0;
 	return chosen ? manifestFileWithBase(chosen.file, assetBase) : void 0;
 }
+function listFilesRecursive(dir) {
+	const out = [];
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...listFilesRecursive(full));
+		else if (entry.isFile()) out.push(full);
+	}
+	return out;
+}
 function findClientEntryFileInAssetsDir(options) {
 	const assetsDir = path.join(options.clientDir, options.assetsSubdir);
 	if (!fs.existsSync(assetsDir)) return void 0;
-	const files = fs.readdirSync(assetsDir);
-	let entry;
+	const files = listFilesRecursive(assetsDir);
+	let entryFull;
 	for (const marker of options.markers) {
-		entry = files.find((file) => file.includes(marker) && file.endsWith(".js"));
-		if (entry) break;
+		entryFull = files.find((file) => path.basename(file).includes(marker) && file.endsWith(".js"));
+		if (entryFull) break;
 	}
-	return entry ? manifestFileWithBase(`${options.assetsSubdir}/${entry}`, options.assetBase) : void 0;
+	if (!entryFull) return void 0;
+	return manifestFileWithBase(path.relative(options.clientDir, entryFull).split(path.sep).join("/"), options.assetBase);
 }
 function findClientEntryFile(options) {
 	return (options.buildManifest ? findClientEntryFileFromManifest(options.buildManifest, options.assetBase) : void 0) ?? findClientEntryFileInAssetsDir({

package/dist/utils/client-runtime-metadata.d.ts

@@ -0,0 +1,45 @@
+//#region src/utils/client-runtime-metadata.d.ts
+type ClientRuntimeMetadata = {
+  clientEntryFile?: string;
+  lazyChunks?: string[];
+  dynamicPreloads?: Record<string, string[]>;
+};
+/**
+ * Read the client build manifest and compute runtime metadata used by
+ * Cloudflare worker entry injection and Node production server startup.
+ *
+ * - `lazyChunks` — chunks only reachable through dynamic `import()`, excluded
+ *   from modulepreload hints.
+ * - `dynamicPreloads` — per-module JS/CSS files for rendered `next/dynamic()`
+ *   boundaries, injected as preload links during SSR.
+ * - `clientEntryFile` — the client entry chunk filename (optional, only
+ *   needed for Pages Router).
+ *
+ * All file paths are normalised with the configured `assetBase` (basePath)
+ * and `assetPrefix`.
+ */
+declare function computeClientRuntimeMetadata(opts: {
+  clientDir: string;
+  assetBase: string;
+  assetPrefix: string;
+  includeClientEntry?: boolean | "pages-client-entry";
+}): ClientRuntimeMetadata;
+/**
+ * Serialize runtime metadata into the `globalThis.__VINEXT_*` assignment script
+ * that the Cloudflare `closeBundle` hook prepends to the worker entry. Returns
+ * `""` when there is nothing to inject.
+ *
+ * Both the App Router and Pages Router closeBundle paths call this (and the
+ * deploy tests mirror it), so the injection shape stays in one place. The caller
+ * decides which fields to pass — e.g. App Router only forwards `clientEntryFile`
+ * for mixed app+pages builds (where `computeClientRuntimeMetadata` was asked for
+ * the Pages client entry); pure App Router leaves it undefined.
+ */
+declare function buildRuntimeGlobalsScript(input: {
+  clientEntryFile?: string | null;
+  ssrManifest?: Record<string, string[]> | null;
+  lazyChunks?: string[] | null;
+  dynamicPreloads?: Record<string, string[]> | null;
+}): string;
+//#endregion
+export { buildRuntimeGlobalsScript, computeClientRuntimeMetadata };

package/dist/utils/client-runtime-metadata.js

@@ -0,0 +1,63 @@
+import { resolveAssetsDir } from "./asset-prefix.js";
+import { manifestFileWithAssetPrefix, manifestFileWithBase } from "./manifest-paths.js";
+import { findClientEntryFile, findPagesClientEntryFile, readClientBuildManifest } from "./client-build-manifest.js";
+import { findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest } from "./client-entry-manifest.js";
+import { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase } from "./lazy-chunks.js";
+import path from "node:path";
+//#region src/utils/client-runtime-metadata.ts
+/**
+* Read the client build manifest and compute runtime metadata used by
+* Cloudflare worker entry injection and Node production server startup.
+*
+* - `lazyChunks` — chunks only reachable through dynamic `import()`, excluded
+*   from modulepreload hints.
+* - `dynamicPreloads` — per-module JS/CSS files for rendered `next/dynamic()`
+*   boundaries, injected as preload links during SSR.
+* - `clientEntryFile` — the client entry chunk filename (optional, only
+*   needed for Pages Router).
+*
+* All file paths are normalised with the configured `assetBase` (basePath)
+* and `assetPrefix`.
+*/
+function computeClientRuntimeMetadata(opts) {
+	const buildManifest = readClientBuildManifest(path.join(opts.clientDir, ".vite", "manifest.json"));
+	const metadata = {};
+	if (opts.includeClientEntry) {
+		const clientEntryManifest = readClientEntryManifest(opts.clientDir);
+		const entryOptions = {
+			buildManifest,
+			clientDir: opts.clientDir,
+			assetsSubdir: resolveAssetsDir(opts.assetPrefix),
+			assetBase: opts.assetBase
+		};
+		const entry = opts.includeClientEntry === "pages-client-entry" ? findPagesClientEntryFileFromVinextManifest(clientEntryManifest, opts.assetBase) ?? findPagesClientEntryFile(entryOptions) : findClientEntryFileFromVinextManifest(clientEntryManifest, opts.assetBase) ?? findClientEntryFile(entryOptions);
+		if (entry) metadata.clientEntryFile = entry;
+	}
+	if (!buildManifest) return metadata;
+	const lazyChunks = computeLazyChunks(buildManifest).map((file) => manifestFileWithBase(file, opts.assetBase));
+	if (lazyChunks.length > 0) metadata.lazyChunks = lazyChunks;
+	const dynamicPreloads = dynamicImportPreloadsWithBase(computeDynamicImportPreloads(buildManifest), (file) => manifestFileWithAssetPrefix(file, opts.assetBase, opts.assetPrefix));
+	if (Object.keys(dynamicPreloads).length > 0) metadata.dynamicPreloads = dynamicPreloads;
+	return metadata;
+}
+/**
+* Serialize runtime metadata into the `globalThis.__VINEXT_*` assignment script
+* that the Cloudflare `closeBundle` hook prepends to the worker entry. Returns
+* `""` when there is nothing to inject.
+*
+* Both the App Router and Pages Router closeBundle paths call this (and the
+* deploy tests mirror it), so the injection shape stays in one place. The caller
+* decides which fields to pass — e.g. App Router only forwards `clientEntryFile`
+* for mixed app+pages builds (where `computeClientRuntimeMetadata` was asked for
+* the Pages client entry); pure App Router leaves it undefined.
+*/
+function buildRuntimeGlobalsScript(input) {
+	const globals = [];
+	if (input.clientEntryFile) globals.push(`globalThis.__VINEXT_CLIENT_ENTRY__ = ${JSON.stringify(input.clientEntryFile)};`);
+	if (input.ssrManifest && Object.keys(input.ssrManifest).length > 0) globals.push(`globalThis.__VINEXT_SSR_MANIFEST__ = ${JSON.stringify(input.ssrManifest)};`);
+	if (input.lazyChunks && input.lazyChunks.length > 0) globals.push(`globalThis.__VINEXT_LAZY_CHUNKS__ = ${JSON.stringify(input.lazyChunks)};`);
+	if (input.dynamicPreloads && Object.keys(input.dynamicPreloads).length > 0) globals.push(`globalThis.__VINEXT_DYNAMIC_PRELOADS__ = ${JSON.stringify(input.dynamicPreloads)};`);
+	return globals.join("\n");
+}
+//#endregion
+export { buildRuntimeGlobalsScript, computeClientRuntimeMetadata };

package/dist/utils/commonjs-loader.d.ts

@@ -0,0 +1,16 @@
+//#region src/utils/commonjs-loader.d.ts
+declare function shouldRetryAsCommonJs(error: unknown, resolvedPath: string): boolean;
+/**
+ * Load a `.js` file as CommonJS even when a surrounding `package.json`
+ * declares `"type": "module"`. Nested misclassified `.js` dependencies are
+ * compiled the same way, while Node keeps handling builtins, JSON, native
+ * addons, and correctly classified modules through its normal loader.
+ */
+declare function loadCommonJsModule(resolvedPath: string): unknown;
+/**
+ * Import a module normally, retrying only `.js` files that fail because Node
+ * classified CommonJS source as ESM.
+ */
+declare function importExportWithCommonJsFallback(resolvedPath: string): Promise<unknown>;
+//#endregion
+export { importExportWithCommonJsFallback, loadCommonJsModule, shouldRetryAsCommonJs };

package/dist/utils/commonjs-loader.js

@@ -0,0 +1,100 @@
+import { Module, createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/utils/commonjs-loader.ts
+const CommonJsModule = Module;
+function canonicalPath(filePath) {
+	const normalizedPath = filePath.startsWith("/@fs/") ? filePath.slice(4) : filePath;
+	const resolvedPath = normalizedPath.startsWith("file://") ? fileURLToPath(normalizedPath) : normalizedPath;
+	try {
+		return fs.realpathSync.native(resolvedPath);
+	} catch {
+		return path.resolve(resolvedPath);
+	}
+}
+function shouldRetryAsCommonJs(error, resolvedPath) {
+	if (!resolvedPath.endsWith(".js") || !(error instanceof Error)) return false;
+	if ("code" in error && error.code === "ERR_REQUIRE_ESM") {
+		const canonicalResolvedPath = canonicalPath(resolvedPath);
+		return error.message.includes(canonicalResolvedPath) || error.message.includes(pathToFileURL(canonicalResolvedPath).href);
+	}
+	if (!(error instanceof ReferenceError)) return false;
+	const match = error.message.match(/^(module|exports|require|__dirname|__filename) is not defined(?: in ES module scope)?/);
+	if (!match || !error.stack) return false;
+	const identifier = match[1];
+	for (const line of error.stack.split("\n").slice(1)) {
+		const location = line.match(/(?:\(|at )(.+):(\d+):(\d+)\)?$/);
+		if (!location) continue;
+		const [, framePath, lineNumberText, columnNumberText] = location;
+		const canonicalFramePath = canonicalPath(framePath);
+		if (!canonicalFramePath.endsWith(".js")) continue;
+		let sourceLine;
+		try {
+			sourceLine = fs.readFileSync(canonicalFramePath, "utf8").split(/\r?\n/)[Number(lineNumberText) - 1];
+		} catch {
+			continue;
+		}
+		const column = Number(columnNumberText) - 1;
+		if (sourceLine?.slice(column, column + identifier.length) === identifier) return true;
+	}
+	return false;
+}
+function compileCommonJsModule(resolvedPath, parent) {
+	resolvedPath = canonicalPath(resolvedPath);
+	const req = createRequire(resolvedPath);
+	const cached = req.cache[resolvedPath];
+	if (cached) return cached.exports;
+	const mod = new CommonJsModule(resolvedPath, parent);
+	mod.filename = resolvedPath;
+	mod.paths = CommonJsModule._nodeModulePaths(path.dirname(resolvedPath));
+	req.cache[resolvedPath] = mod;
+	const originalRequire = mod.require.bind(mod);
+	mod.require = ((specifier) => {
+		let dependencyPath;
+		try {
+			dependencyPath = req.resolve(specifier);
+		} catch {
+			return originalRequire(specifier);
+		}
+		if (dependencyPath.endsWith(".cjs")) return compileCommonJsModule(dependencyPath, mod);
+		try {
+			return originalRequire(specifier);
+		} catch (error) {
+			if (!shouldRetryAsCommonJs(error, dependencyPath)) throw error;
+			return compileCommonJsModule(dependencyPath, mod);
+		}
+	});
+	try {
+		mod._compile(fs.readFileSync(resolvedPath, "utf8"), resolvedPath);
+		mod.loaded = true;
+		return mod.exports;
+	} catch (error) {
+		if (req.cache[resolvedPath] === mod) delete req.cache[resolvedPath];
+		throw error;
+	}
+}
+/**
+* Load a `.js` file as CommonJS even when a surrounding `package.json`
+* declares `"type": "module"`. Nested misclassified `.js` dependencies are
+* compiled the same way, while Node keeps handling builtins, JSON, native
+* addons, and correctly classified modules through its normal loader.
+*/
+function loadCommonJsModule(resolvedPath) {
+	return compileCommonJsModule(resolvedPath);
+}
+/**
+* Import a module normally, retrying only `.js` files that fail because Node
+* classified CommonJS source as ESM.
+*/
+async function importExportWithCommonJsFallback(resolvedPath) {
+	try {
+		const mod = await import(pathToFileURL(resolvedPath).href);
+		return mod.default ?? mod;
+	} catch (error) {
+		if (!shouldRetryAsCommonJs(error, resolvedPath)) throw error;
+		return loadCommonJsModule(resolvedPath);
+	}
+}
+//#endregion
+export { importExportWithCommonJsFallback, loadCommonJsModule, shouldRetryAsCommonJs };

package/dist/utils/deployment-id.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/deployment-id.d.ts
+declare const NEXT_DEPLOYMENT_ID_HEADER = "x-deployment-id";
+declare function getDeploymentId(): string | undefined;
+declare function appendDeploymentIdQuery(value: string, deploymentId?: string | undefined): string;
+declare function appendAssetDeploymentIdQuery(value: string, deploymentId?: string | undefined): string;
+declare function applyDeploymentIdHeader(headers: Headers, deploymentId?: string | undefined): void;
+//#endregion
+export { NEXT_DEPLOYMENT_ID_HEADER, appendAssetDeploymentIdQuery, appendDeploymentIdQuery, applyDeploymentIdHeader, getDeploymentId };

package/dist/utils/deployment-id.js

@@ -0,0 +1,22 @@
+//#region src/utils/deployment-id.ts
+const NEXT_DEPLOYMENT_ID_HEADER = "x-deployment-id";
+function getDeploymentId() {
+	return process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID || void 0;
+}
+function appendDeploymentIdQuery(value, deploymentId = getDeploymentId()) {
+	if (!deploymentId) return value;
+	const hashIndex = value.indexOf("#");
+	const url = hashIndex === -1 ? value : value.slice(0, hashIndex);
+	const fragment = hashIndex === -1 ? "" : value.slice(hashIndex);
+	if (new URL(url, "http://vinext.local").searchParams.has("dpl")) return value;
+	return `${url}${url.includes("?") ? "&" : "?"}dpl=${deploymentId}${fragment}`;
+}
+function appendAssetDeploymentIdQuery(value, deploymentId = getDeploymentId()) {
+	if (!new URL(value, "http://vinext.local").pathname.includes("/_next/static/")) return value;
+	return appendDeploymentIdQuery(value, deploymentId);
+}
+function applyDeploymentIdHeader(headers, deploymentId = getDeploymentId()) {
+	if (deploymentId) headers.set(NEXT_DEPLOYMENT_ID_HEADER, deploymentId);
+}
+//#endregion
+export { NEXT_DEPLOYMENT_ID_HEADER, appendAssetDeploymentIdQuery, appendDeploymentIdQuery, applyDeploymentIdHeader, getDeploymentId };

package/dist/utils/hash.d.ts

@@ -2,7 +2,23 @@
 /**
  * FNV-1a hash producing a 64-bit result (two 32-bit rounds with different seeds).
  * Used for deterministic key generation where collisions must be rare.
+ *
+ * This is a vinext-internal format: nothing outside vinext ever compares
+ * these values, so the algorithm only needs to be deterministic. For values
+ * that must be byte-for-byte identical to what Next.js emits (ETags), use
+ * `fnv1a52` below instead — the two are NOT interchangeable.
  */
 declare function fnv1a64(input: string): string;
+/**
+ * FNV-1a hash producing a 52-bit result, a byte-for-byte port of Next.js's
+ * `fnv1a52` in packages/next/src/server/lib/etag.ts (itself derived from
+ * fnv-plus). Used for ETag generation, where matching Next.js's exact output
+ * matters: clients and CDNs holding `If-None-Match` values from a Next.js
+ * deployment keep revalidating (304) against vinext for unchanged payloads.
+ *
+ * Deliberately separate from `fnv1a64` above — that one is a vinext-internal
+ * key format and produces different values. Do not swap one for the other.
+ */
+declare function fnv1a52(str: string): number;
 //#endregion
-export { fnv1a64 };
+export { fnv1a52, fnv1a64 };