@qzsy/vinext 0.1.7

package/dist/utils/asset-prefix.d.ts

@@ -0,0 +1,96 @@
+//#region src/utils/asset-prefix.d.ts
+/**
+ * Shared helpers for next.config `assetPrefix`.
+ *
+ * Mirrors Next.js semantics: `assetPrefix` is prepended to every JS/CSS/image/
+ * static asset URL emitted in the page. It is distinct from `basePath`, which
+ * affects route URLs.
+ *
+ *  - A `assetPrefix` of `""` (empty) means "no prefix". URLs are emitted as
+ *    `/_next/static/...` (Next.js's canonical convention) and assets are
+ *    written to `dist/client/_next/static/...` so the on-disk layout matches.
+ *  - A path prefix like `"/custom-asset-prefix"` is applied as a URL prefix
+ *    relative to the deployment origin. The prod server must also serve assets
+ *    under that prefix.
+ *  - An absolute URL like `"https://cdn.example.com"` makes asset URLs fully
+ *    qualified. Runtime serving on the deployment origin is a no-op — the CDN
+ *    serves the assets directly.
+ *
+ * The path component of the asset URL after the prefix is always
+ * `/_next/static/<filename>` to match Next.js's convention. This is the
+ * convention upstream test suites assert against.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix
+ */
+/**
+ * Suffix appended to the assetPrefix (or used standalone when no prefix is
+ * configured) to form the leading portion of every emitted asset URL.
+ * Matches Next.js: assets always live under `/_next/static/`.
+ */
+declare const ASSET_PREFIX_URL_DIR = "_next/static";
+/** Whether `assetPrefix` is an absolute URL (vs a path prefix). */
+declare function isAbsoluteAssetPrefix(assetPrefix: string): boolean;
+/**
+ * Compute the on-disk `build.assetsDir` for the given `assetPrefix`.
+ *
+ *  - Path prefix (`/cdn`): write to `cdn/_next/static/` so the on-disk layout
+ *    matches the URL — the Cloudflare ASSETS binding (and any static file
+ *    server) serves them directly without a runtime rewrite.
+ *  - Absolute URL (with or without path component): write to `_next/static/`.
+ *    Runtime serving is best-effort — the CDN is expected to serve these.
+ *  - Empty: write to `_next/static/` so the on-disk layout matches the URL
+ *    Next.js itself emits (and that the Next.js client runtime + upstream
+ *    test suites assert against). This makes `assetPrefix` consistent in
+ *    both the configured and unconfigured cases — the URL contract is
+ *    always `/<prefix?>/_next/static/...`, and the on-disk layout mirrors
+ *    it 1:1 so the static-file layer can serve hits and return
+ *    `404 + "Not Found"` on misses without any URL-shape special-casing
+ *    upstream of it.
+ */
+declare function resolveAssetsDir(assetPrefix: string): string;
+/**
+ * Build the URL prefix to apply to emitted asset URLs. Returns the full URL
+ * prefix including the `_next/static/` directory, with a trailing slash.
+ *
+ * Examples:
+ *  - `""` → `"/_next/static/"`
+ *  - `"/cdn"` → `"/cdn/_next/static/"`
+ *  - `"https://cdn.example.com"` → `"https://cdn.example.com/_next/static/"`
+ *  - `"https://cdn.example.com/sub"` → `"https://cdn.example.com/sub/_next/static/"`
+ */
+declare function resolveAssetUrlPrefix(assetPrefix: string): string;
+/**
+ * Extract the path portion of `assetPrefix` for use in runtime URL matching.
+ *
+ *  - For a path prefix: returns it verbatim (e.g. `/custom-asset-prefix`).
+ *  - For an absolute URL: returns its pathname stripped of trailing slashes
+ *    (e.g. `"https://cdn.example.com/sub"` → `/sub`, plain origin → `""`).
+ *  - For empty input: returns `""`.
+ *
+ * Used by the prod server and Cloudflare worker entry to recognise asset
+ * requests that arrive at the deployment origin under the configured prefix.
+ */
+declare function assetPrefixPathname(assetPrefix: string): string;
+/**
+ * Whether the incoming request pathname targets the canonical `_next/static/`
+ * tree, after stripping any configured `basePath` and `assetPrefix` path
+ * component.
+ *
+ * Used by the Cloudflare worker entry to recognise asset-shaped requests
+ * that the ASSETS binding didn't serve, so they can short-circuit with a
+ * plain-text 404 instead of falling through to the RSC handler (which
+ * would render the full HTML 404 page). Mirrors Next.js's behaviour in
+ * `packages/next/src/server/lib/router-server.ts` where
+ * `realRequestPathname` is stripped of basePath/assetPrefix/i18n locale
+ * before the `startsWith('/_next/static/')` check.
+ *
+ *  - `pathname`: incoming request pathname (with leading slash, no query).
+ *  - `basePath`: configured `basePath` (e.g. `"/docs"`) or `""`.
+ *  - `assetPathPrefix`: path component of `assetPrefix` (e.g. `"/cdn"`) or
+ *    `""`. Use `assetPrefixPathname()` to derive this from a raw assetPrefix.
+ *
+ * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-server.ts
+ */
+declare function isNextStaticPath(pathname: string, basePath: string, assetPathPrefix: string): boolean;
+//#endregion
+export { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isNextStaticPath, resolveAssetUrlPrefix, resolveAssetsDir };

package/dist/utils/asset-prefix.js

@@ -0,0 +1,122 @@
+//#region src/utils/asset-prefix.ts
+/**
+* Shared helpers for next.config `assetPrefix`.
+*
+* Mirrors Next.js semantics: `assetPrefix` is prepended to every JS/CSS/image/
+* static asset URL emitted in the page. It is distinct from `basePath`, which
+* affects route URLs.
+*
+*  - A `assetPrefix` of `""` (empty) means "no prefix". URLs are emitted as
+*    `/_next/static/...` (Next.js's canonical convention) and assets are
+*    written to `dist/client/_next/static/...` so the on-disk layout matches.
+*  - A path prefix like `"/custom-asset-prefix"` is applied as a URL prefix
+*    relative to the deployment origin. The prod server must also serve assets
+*    under that prefix.
+*  - An absolute URL like `"https://cdn.example.com"` makes asset URLs fully
+*    qualified. Runtime serving on the deployment origin is a no-op — the CDN
+*    serves the assets directly.
+*
+* The path component of the asset URL after the prefix is always
+* `/_next/static/<filename>` to match Next.js's convention. This is the
+* convention upstream test suites assert against.
+*
+* @see https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix
+*/
+/**
+* Suffix appended to the assetPrefix (or used standalone when no prefix is
+* configured) to form the leading portion of every emitted asset URL.
+* Matches Next.js: assets always live under `/_next/static/`.
+*/
+const ASSET_PREFIX_URL_DIR = "_next/static";
+/** Whether `assetPrefix` is an absolute URL (vs a path prefix). */
+function isAbsoluteAssetPrefix(assetPrefix) {
+	return /^https?:\/\//i.test(assetPrefix);
+}
+/**
+* Compute the on-disk `build.assetsDir` for the given `assetPrefix`.
+*
+*  - Path prefix (`/cdn`): write to `cdn/_next/static/` so the on-disk layout
+*    matches the URL — the Cloudflare ASSETS binding (and any static file
+*    server) serves them directly without a runtime rewrite.
+*  - Absolute URL (with or without path component): write to `_next/static/`.
+*    Runtime serving is best-effort — the CDN is expected to serve these.
+*  - Empty: write to `_next/static/` so the on-disk layout matches the URL
+*    Next.js itself emits (and that the Next.js client runtime + upstream
+*    test suites assert against). This makes `assetPrefix` consistent in
+*    both the configured and unconfigured cases — the URL contract is
+*    always `/<prefix?>/_next/static/...`, and the on-disk layout mirrors
+*    it 1:1 so the static-file layer can serve hits and return
+*    `404 + "Not Found"` on misses without any URL-shape special-casing
+*    upstream of it.
+*/
+function resolveAssetsDir(assetPrefix) {
+	if (!assetPrefix) return ASSET_PREFIX_URL_DIR;
+	if (isAbsoluteAssetPrefix(assetPrefix)) return ASSET_PREFIX_URL_DIR;
+	let stripped = assetPrefix;
+	while (stripped.startsWith("/")) stripped = stripped.slice(1);
+	return `${stripped}/${ASSET_PREFIX_URL_DIR}`;
+}
+/**
+* Build the URL prefix to apply to emitted asset URLs. Returns the full URL
+* prefix including the `_next/static/` directory, with a trailing slash.
+*
+* Examples:
+*  - `""` → `"/_next/static/"`
+*  - `"/cdn"` → `"/cdn/_next/static/"`
+*  - `"https://cdn.example.com"` → `"https://cdn.example.com/_next/static/"`
+*  - `"https://cdn.example.com/sub"` → `"https://cdn.example.com/sub/_next/static/"`
+*/
+function resolveAssetUrlPrefix(assetPrefix) {
+	if (!assetPrefix) return `/${ASSET_PREFIX_URL_DIR}/`;
+	return `${assetPrefix}/${ASSET_PREFIX_URL_DIR}/`;
+}
+/**
+* Extract the path portion of `assetPrefix` for use in runtime URL matching.
+*
+*  - For a path prefix: returns it verbatim (e.g. `/custom-asset-prefix`).
+*  - For an absolute URL: returns its pathname stripped of trailing slashes
+*    (e.g. `"https://cdn.example.com/sub"` → `/sub`, plain origin → `""`).
+*  - For empty input: returns `""`.
+*
+* Used by the prod server and Cloudflare worker entry to recognise asset
+* requests that arrive at the deployment origin under the configured prefix.
+*/
+function assetPrefixPathname(assetPrefix) {
+	if (!assetPrefix) return "";
+	if (!isAbsoluteAssetPrefix(assetPrefix)) return assetPrefix;
+	try {
+		let pathname = new URL(assetPrefix).pathname;
+		while (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+		return pathname === "" ? "" : pathname;
+	} catch {
+		return "";
+	}
+}
+/**
+* Whether the incoming request pathname targets the canonical `_next/static/`
+* tree, after stripping any configured `basePath` and `assetPrefix` path
+* component.
+*
+* Used by the Cloudflare worker entry to recognise asset-shaped requests
+* that the ASSETS binding didn't serve, so they can short-circuit with a
+* plain-text 404 instead of falling through to the RSC handler (which
+* would render the full HTML 404 page). Mirrors Next.js's behaviour in
+* `packages/next/src/server/lib/router-server.ts` where
+* `realRequestPathname` is stripped of basePath/assetPrefix/i18n locale
+* before the `startsWith('/_next/static/')` check.
+*
+*  - `pathname`: incoming request pathname (with leading slash, no query).
+*  - `basePath`: configured `basePath` (e.g. `"/docs"`) or `""`.
+*  - `assetPathPrefix`: path component of `assetPrefix` (e.g. `"/cdn"`) or
+*    `""`. Use `assetPrefixPathname()` to derive this from a raw assetPrefix.
+*
+* @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-server.ts
+*/
+function isNextStaticPath(pathname, basePath, assetPathPrefix) {
+	let p = pathname;
+	if (basePath && (p === basePath || p.startsWith(basePath + "/"))) p = p.slice(basePath.length) || "/";
+	if (assetPathPrefix && (p === assetPathPrefix || p.startsWith(assetPathPrefix + "/"))) p = p.slice(assetPathPrefix.length) || "/";
+	return p.startsWith(`/${ASSET_PREFIX_URL_DIR}/`);
+}
+//#endregion
+export { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isNextStaticPath, resolveAssetUrlPrefix, resolveAssetsDir };

package/dist/utils/base-path.d.ts

@@ -0,0 +1,31 @@
+//#region src/utils/base-path.d.ts
+/**
+ * Shared basePath helpers.
+ *
+ * Next.js only treats a pathname as being under basePath when it is an exact
+ * match ("/app") or starts with the basePath followed by a path separator
+ * ("/app/..."). Prefix-only matches like "/application" must be left intact.
+ */
+/**
+ * Check whether a pathname is inside the configured basePath.
+ */
+declare function hasBasePath(pathname: string, basePath: string): boolean;
+/**
+ * Strip the basePath prefix from a pathname when it matches on a segment
+ * boundary. Returns the original pathname when it is outside the basePath.
+ */
+declare function stripBasePath(pathname: string, basePath: string): string;
+/**
+ * Add the configured basePath to a pathname unless it is already inside that
+ * basePath. Query strings and hashes must be handled by callers before calling
+ * this pathname-only helper.
+ */
+declare function addBasePathToPathname(pathname: string, basePath: string | undefined): string;
+/**
+ * Remove trailing slashes from a pathname while preserving the root "/".
+ * Collapses any number of trailing slashes ("/a//" → "/a"). Used by the
+ * trailing-slash redirect path and route pattern normalization.
+ */
+declare function removeTrailingSlash(pathname: string): string;
+//#endregion
+export { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath };

package/dist/utils/base-path.js

@@ -0,0 +1,45 @@
+//#region src/utils/base-path.ts
+/**
+* Shared basePath helpers.
+*
+* Next.js only treats a pathname as being under basePath when it is an exact
+* match ("/app") or starts with the basePath followed by a path separator
+* ("/app/..."). Prefix-only matches like "/application" must be left intact.
+*/
+/**
+* Check whether a pathname is inside the configured basePath.
+*/
+function hasBasePath(pathname, basePath) {
+	if (!basePath) return false;
+	return pathname === basePath || pathname.startsWith(basePath + "/");
+}
+/**
+* Strip the basePath prefix from a pathname when it matches on a segment
+* boundary. Returns the original pathname when it is outside the basePath.
+*/
+function stripBasePath(pathname, basePath) {
+	if (!hasBasePath(pathname, basePath)) return pathname;
+	return pathname.slice(basePath.length) || "/";
+}
+/**
+* Add the configured basePath to a pathname unless it is already inside that
+* basePath. Query strings and hashes must be handled by callers before calling
+* this pathname-only helper.
+*/
+function addBasePathToPathname(pathname, basePath) {
+	if (!basePath || hasBasePath(pathname, basePath)) return pathname;
+	return pathname === "/" ? basePath : `${basePath}${pathname}`;
+}
+/**
+* Remove trailing slashes from a pathname while preserving the root "/".
+* Collapses any number of trailing slashes ("/a//" → "/a"). Used by the
+* trailing-slash redirect path and route pattern normalization.
+*/
+function removeTrailingSlash(pathname) {
+	if (pathname === "/") return "/";
+	let end = pathname.length;
+	while (end > 0 && pathname.charCodeAt(end - 1) === 47) end--;
+	return end === 0 ? "/" : pathname.slice(0, end);
+}
+//#endregion
+export { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath };

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/cache-control-metadata.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/cache-control-metadata.d.ts
+declare function readCacheControlNumberField(ctx: Record<string, unknown> | undefined, field: string): number | undefined;
+//#endregion
+export { readCacheControlNumberField };

package/dist/utils/cache-control-metadata.js

@@ -0,0 +1,12 @@
+import { isUnknownRecord } from "./record.js";
+//#region src/utils/cache-control-metadata.ts
+function readRecordField(ctx, field) {
+	const value = ctx?.[field];
+	return isUnknownRecord(value) ? value : void 0;
+}
+function readCacheControlNumberField(ctx, field) {
+	const value = readRecordField(ctx, "cacheControl")?.[field] ?? ctx?.[field];
+	return typeof value === "number" ? value : void 0;
+}
+//#endregion
+export { readCacheControlNumberField };

package/dist/utils/client-build-manifest.d.ts

@@ -0,0 +1,21 @@
+import { BuildManifestChunk } from "./lazy-chunks.js";
+
+//#region src/utils/client-build-manifest.d.ts
+type ClientBuildManifest = Record<string, BuildManifestChunk>;
+declare function readClientBuildManifest(manifestPath: string): ClientBuildManifest | undefined;
+declare function findClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
+declare function findPagesClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
+declare function findClientEntryFile(options: {
+  buildManifest?: ClientBuildManifest;
+  clientDir: string;
+  assetsSubdir: string;
+  assetBase: string;
+}): string | undefined;
+declare function findPagesClientEntryFile(options: {
+  buildManifest?: ClientBuildManifest;
+  clientDir: string;
+  assetsSubdir: string;
+  assetBase: string;
+}): string | undefined;
+//#endregion
+export { findClientEntryFile, findClientEntryFileFromManifest, findPagesClientEntryFile, findPagesClientEntryFileFromManifest, readClientBuildManifest };

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

@@ -0,0 +1,87 @@
+import { isUnknownRecord } from "./record.js";
+import { manifestFileWithBase } from "./manifest-paths.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/utils/client-build-manifest.ts
+const PAGES_CLIENT_ENTRY_MARKERS = ["vinext-client-entry"];
+const CLIENT_ENTRY_MARKERS = [...PAGES_CLIENT_ENTRY_MARKERS, "vinext-app-browser-entry"];
+function readClientBuildManifest(manifestPath) {
+	if (!fs.existsSync(manifestPath)) return void 0;
+	try {
+		const value = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+		if (!isUnknownRecord(value)) return void 0;
+		const manifest = {};
+		for (const [key, entry] of Object.entries(value)) {
+			if (!isUnknownRecord(entry) || typeof entry.file !== "string") continue;
+			const imports = readStringArray(entry.imports);
+			const dynamicImports = readStringArray(entry.dynamicImports);
+			const css = readStringArray(entry.css);
+			const assets = readStringArray(entry.assets);
+			manifest[key] = {
+				file: entry.file,
+				...entry.isEntry === true ? { isEntry: true } : {},
+				...entry.isDynamicEntry === true ? { isDynamicEntry: true } : {},
+				...imports ? { imports } : {},
+				...dynamicImports ? { dynamicImports } : {},
+				...css ? { css } : {},
+				...assets ? { assets } : {}
+			};
+		}
+		return manifest;
+	} catch {
+		return;
+	}
+}
+function findClientEntryFileFromManifest(buildManifest, assetBase) {
+	return findEntryFileFromManifest(buildManifest, assetBase, CLIENT_ENTRY_MARKERS, true);
+}
+function findPagesClientEntryFileFromManifest(buildManifest, assetBase) {
+	return findEntryFileFromManifest(buildManifest, assetBase, PAGES_CLIENT_ENTRY_MARKERS, false);
+}
+function findEntryFileFromManifest(buildManifest, assetBase, markers, fallbackToFirstEntry) {
+	const entries = Object.values(buildManifest).filter((entry) => entry.isEntry && entry.file);
+	for (const marker of markers) {
+		const markedEntry = entries.find((entry) => entry.file.includes(marker));
+		if (markedEntry) return manifestFileWithBase(markedEntry.file, assetBase);
+	}
+	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 = listFilesRecursive(assetsDir);
+	let entryFull;
+	for (const marker of options.markers) {
+		entryFull = files.find((file) => path.basename(file).includes(marker) && file.endsWith(".js"));
+		if (entryFull) break;
+	}
+	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({
+		...options,
+		markers: CLIENT_ENTRY_MARKERS
+	});
+}
+function findPagesClientEntryFile(options) {
+	return (options.buildManifest ? findPagesClientEntryFileFromManifest(options.buildManifest, options.assetBase) : void 0) ?? findClientEntryFileInAssetsDir({
+		...options,
+		markers: PAGES_CLIENT_ENTRY_MARKERS
+	});
+}
+function readStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+//#endregion
+export { findClientEntryFile, findClientEntryFileFromManifest, findPagesClientEntryFile, findPagesClientEntryFileFromManifest, readClientBuildManifest };

package/dist/utils/client-entry-manifest.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/client-entry-manifest.d.ts
+declare const VINEXT_CLIENT_ENTRY_MANIFEST = "vinext-client-entry-manifest.json";
+type ClientEntryManifest = {
+  pagesClientEntry?: string;
+  appBrowserEntry?: string;
+};
+declare function readClientEntryManifest(clientDir: string): ClientEntryManifest | undefined;
+declare function findClientEntryFileFromVinextManifest(manifest: ClientEntryManifest | undefined, assetBase: string): string | undefined;
+declare function findPagesClientEntryFileFromVinextManifest(manifest: ClientEntryManifest | undefined, assetBase: string): string | undefined;
+//#endregion
+export { ClientEntryManifest, VINEXT_CLIENT_ENTRY_MANIFEST, findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest };

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

@@ -0,0 +1,29 @@
+import { isUnknownRecord } from "./record.js";
+import { manifestFileWithBase } from "./manifest-paths.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/utils/client-entry-manifest.ts
+const VINEXT_CLIENT_ENTRY_MANIFEST = "vinext-client-entry-manifest.json";
+function readClientEntryManifest(clientDir) {
+	const manifestPath = path.join(clientDir, VINEXT_CLIENT_ENTRY_MANIFEST);
+	if (!fs.existsSync(manifestPath)) return void 0;
+	try {
+		const value = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+		if (!isUnknownRecord(value)) return void 0;
+		const manifest = {};
+		if (typeof value.pagesClientEntry === "string") manifest.pagesClientEntry = value.pagesClientEntry;
+		if (typeof value.appBrowserEntry === "string") manifest.appBrowserEntry = value.appBrowserEntry;
+		return manifest.pagesClientEntry || manifest.appBrowserEntry ? manifest : void 0;
+	} catch {
+		return;
+	}
+}
+function findClientEntryFileFromVinextManifest(manifest, assetBase) {
+	const entry = manifest?.pagesClientEntry ?? manifest?.appBrowserEntry;
+	return entry ? manifestFileWithBase(entry, assetBase) : void 0;
+}
+function findPagesClientEntryFileFromVinextManifest(manifest, assetBase) {
+	return manifest?.pagesClientEntry ? manifestFileWithBase(manifest.pagesClientEntry, assetBase) : void 0;
+}
+//#endregion
+export { VINEXT_CLIENT_ENTRY_MANIFEST, findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest };

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 };