vinext 0.1.0 → 0.1.2

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

package/dist/utils/hash.js

@@ -2,6 +2,11 @@
 /**
 * 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.
 */
 function fnv1a64(input) {
 	let h1 = 2166136261;
@@ -16,5 +21,35 @@ function fnv1a64(input) {
 	}
 	return h1.toString(16).padStart(8, "0") + h2.toString(16).padStart(8, "0");
 }
+/**
+* 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.
+*/
+function fnv1a52(str) {
+	const len = str.length;
+	let i = 0, t0 = 0, v0 = 8997, t1 = 0, v1 = 33826, t2 = 0, v2 = 40164, t3 = 0, v3 = 52210;
+	while (i < len) {
+		v0 ^= str.charCodeAt(i++);
+		t0 = v0 * 435;
+		t1 = v1 * 435;
+		t2 = v2 * 435;
+		t3 = v3 * 435;
+		t2 += v0 << 8;
+		t3 += v1 << 8;
+		t1 += t0 >>> 16;
+		v0 = t0 & 65535;
+		t2 += t1 >>> 16;
+		v1 = t1 & 65535;
+		v3 = t3 + (t2 >>> 16) & 65535;
+		v2 = t2 & 65535;
+	}
+	return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+}
 //#endregion
-export { fnv1a64 };
+export { fnv1a52, fnv1a64 };

package/dist/utils/lazy-chunks.d.ts

@@ -29,5 +29,31 @@ type BuildManifestChunk = {
  *   should be excluded from modulepreload hints.
  */
 declare function computeLazyChunks(buildManifest: Record<string, BuildManifestChunk>): string[];
+/**
+ * Compute the production preload files for each module referenced by a
+ * `next/dynamic()` boundary.
+ *
+ * Next.js records module IDs during compilation, then resolves those IDs
+ * against its react-loadable manifest at render time. Vinext's equivalent
+ * source of truth is Vite's build manifest: each chunk lists the modules it
+ * reaches through `dynamicImports`, and each dynamic entry lists the JS/CSS
+ * files required to evaluate it.
+ *
+ * Note on shared chunks: a boundary's static-import tree (`collectStaticChunkFiles`)
+ * can include chunks that the page entry ALSO loads eagerly (a shared vendor
+ * chunk imported by both). Those files are intentionally NOT subtracted here, so
+ * a rendered boundary may emit a `<link rel="preload">` / `<link rel="stylesheet">`
+ * for a chunk the page already `<link rel="modulepreload">`s. This is harmless —
+ * the browser dedupes preloads by URL, `ReactDOM.preload()` dedupes script hints,
+ * and React's stylesheet resource model dedupes by href + precedence — and it
+ * mirrors Next.js listing a module's full file set in its react-loadable
+ * manifest. Subtracting the eager set would couple this to the entry's import
+ * closure for no correctness gain.
+ *
+ * @returns A map keyed by root-relative module ID, with JS/CSS files that
+ * should be preloaded when that dynamic boundary is rendered.
+ */
+declare function computeDynamicImportPreloads(buildManifest: Record<string, BuildManifestChunk>): Record<string, string[]>;
+declare function dynamicImportPreloadsWithBase(preloads: Record<string, string[]>, applyBase: (file: string) => string): Record<string, string[]>;
 //#endregion
-export { BuildManifestChunk, computeLazyChunks };
+export { BuildManifestChunk, computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase };

package/dist/utils/lazy-chunks.js

@@ -44,5 +44,69 @@ function computeLazyChunks(buildManifest) {
 	}
 	return lazyChunks;
 }
+function normalizeManifestKey(key) {
+	return key.split("?")[0].replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function addFile(files, seen, file) {
+	if (!file || seen.has(file)) return;
+	seen.add(file);
+	files.push(file);
+}
+function collectStaticChunkFiles(buildManifest, key, files, seenFiles, visitedChunks) {
+	if (visitedChunks.has(key)) return;
+	visitedChunks.add(key);
+	const chunk = buildManifest[key];
+	if (!chunk) return;
+	if (chunk.file.endsWith(".js")) addFile(files, seenFiles, chunk.file);
+	for (const cssFile of chunk.css ?? []) addFile(files, seenFiles, cssFile);
+	for (const importedKey of chunk.imports ?? []) collectStaticChunkFiles(buildManifest, importedKey, files, seenFiles, visitedChunks);
+}
+/**
+* Compute the production preload files for each module referenced by a
+* `next/dynamic()` boundary.
+*
+* Next.js records module IDs during compilation, then resolves those IDs
+* against its react-loadable manifest at render time. Vinext's equivalent
+* source of truth is Vite's build manifest: each chunk lists the modules it
+* reaches through `dynamicImports`, and each dynamic entry lists the JS/CSS
+* files required to evaluate it.
+*
+* Note on shared chunks: a boundary's static-import tree (`collectStaticChunkFiles`)
+* can include chunks that the page entry ALSO loads eagerly (a shared vendor
+* chunk imported by both). Those files are intentionally NOT subtracted here, so
+* a rendered boundary may emit a `<link rel="preload">` / `<link rel="stylesheet">`
+* for a chunk the page already `<link rel="modulepreload">`s. This is harmless —
+* the browser dedupes preloads by URL, `ReactDOM.preload()` dedupes script hints,
+* and React's stylesheet resource model dedupes by href + precedence — and it
+* mirrors Next.js listing a module's full file set in its react-loadable
+* manifest. Subtracting the eager set would couple this to the entry's import
+* closure for no correctness gain.
+*
+* @returns A map keyed by root-relative module ID, with JS/CSS files that
+* should be preloaded when that dynamic boundary is rendered.
+*/
+function computeDynamicImportPreloads(buildManifest) {
+	const preloads = {};
+	for (const chunk of Object.values(buildManifest)) for (const dynamicKey of chunk.dynamicImports ?? []) {
+		const files = [];
+		collectStaticChunkFiles(buildManifest, dynamicKey, files, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+		if (files.length === 0) continue;
+		const normalizedKey = normalizeManifestKey(dynamicKey);
+		const existing = preloads[normalizedKey] ?? [];
+		const merged = new Set(existing);
+		for (const file of files) {
+			if (merged.has(file)) continue;
+			merged.add(file);
+			existing.push(file);
+		}
+		preloads[normalizedKey] = existing;
+	}
+	return preloads;
+}
+function dynamicImportPreloadsWithBase(preloads, applyBase) {
+	const withBase = {};
+	for (const [key, files] of Object.entries(preloads)) withBase[key] = files.map(applyBase);
+	return withBase;
+}
 //#endregion
-export { computeLazyChunks };
+export { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase };

package/dist/utils/manifest-paths.d.ts

@@ -1,6 +1,24 @@
 //#region src/utils/manifest-paths.d.ts
 declare function manifestFileWithBase(file: string, base: string): string;
-declare function manifestFilesWithBase(files: string[], base: string): string[];
+declare function manifestFileWithAssetPrefix(file: string, base: string, assetPrefix: string): string;
+/**
+ * Resolve the URL a client asset is actually SERVED from, starting from a
+ * base-anchored manifest / SSR-manifest value (no leading slash), e.g.
+ * `"docs/cdn/_next/static/x.js"`.
+ *
+ * Next.js semantics: `assetPrefix` REPLACES `basePath` for asset URLs (they do
+ * not stack). So when an `assetPrefix` is configured we strip the basePath
+ * segment and re-anchor under the assetPrefix — matching how `next/dynamic`
+ * preloads are computed (`manifestFileWithAssetPrefix`) and what the prod server
+ * / Cloudflare ASSETS binding actually serve. Without this, a `basePath` +
+ * path-style `assetPrefix` build emits `/<basePath>/<assetPrefix>/_next/...`
+ * which 404s. When no `assetPrefix` is set, the base-anchored value is already
+ * the served URL and is returned unchanged (just root-anchored).
+ *
+ * Returns an absolute URL for an absolute `assetPrefix`, otherwise a
+ * root-relative URL beginning with `/`.
+ */
+declare function assetServingUrlFromBaseAnchored(value: string, basePath: string, assetPrefix: string): string;
 /**
  * Strip a `base` prefix that Vite applied twice: it bakes `base` into the
  * on-disk chunk fileName and then prepends it again in `ssr-manifest.json`,
@@ -9,4 +27,4 @@ declare function manifestFilesWithBase(files: string[], base: string): string[];
  */
 declare function collapseDuplicateBase(file: string, base: string): string;
 //#endregion
-export { collapseDuplicateBase, manifestFileWithBase, manifestFilesWithBase };
+export { assetServingUrlFromBaseAnchored, collapseDuplicateBase, manifestFileWithAssetPrefix, manifestFileWithBase };

package/dist/utils/manifest-paths.js

@@ -1,3 +1,4 @@
+import { ASSET_PREFIX_URL_DIR, isAbsoluteAssetPrefix, resolveAssetUrlPrefix, resolveAssetsDir } from "./asset-prefix.js";
 //#region src/utils/manifest-paths.ts
 function normalizeManifestFile(file) {
 	return file.startsWith("/") ? file.slice(1) : file;
@@ -10,8 +11,42 @@ function manifestFileWithBase(file, base) {
 	if (normalizedFile.startsWith(normalizedBase + "/")) return normalizedFile;
 	return normalizedBase + "/" + normalizedFile;
 }
-function manifestFilesWithBase(files, base) {
-	return files.map((file) => manifestFileWithBase(file, base));
+function manifestFileWithAssetPrefix(file, base, assetPrefix) {
+	if (!assetPrefix) return manifestFileWithBase(file, base);
+	const normalizedFile = normalizeManifestFile(file);
+	const onDiskDirPrefix = normalizeManifestFile(resolveAssetsDir(assetPrefix)) + "/";
+	const staticDirPrefix = ASSET_PREFIX_URL_DIR + "/";
+	const stripped = normalizedFile.startsWith(onDiskDirPrefix) ? normalizedFile.slice(onDiskDirPrefix.length) : normalizedFile.startsWith(staticDirPrefix) ? normalizedFile.slice(staticDirPrefix.length) : normalizedFile;
+	const urlPrefix = resolveAssetUrlPrefix(assetPrefix);
+	return (isAbsoluteAssetPrefix(assetPrefix) ? urlPrefix : normalizeManifestFile(urlPrefix)) + stripped;
+}
+function stripBasePathSegment(file, basePath) {
+	const normalizedBase = normalizeManifestFile(basePath).replace(/\/+$/, "");
+	if (!normalizedBase) return file;
+	return file.startsWith(normalizedBase + "/") ? file.slice(normalizedBase.length + 1) : file;
+}
+/**
+* Resolve the URL a client asset is actually SERVED from, starting from a
+* base-anchored manifest / SSR-manifest value (no leading slash), e.g.
+* `"docs/cdn/_next/static/x.js"`.
+*
+* Next.js semantics: `assetPrefix` REPLACES `basePath` for asset URLs (they do
+* not stack). So when an `assetPrefix` is configured we strip the basePath
+* segment and re-anchor under the assetPrefix — matching how `next/dynamic`
+* preloads are computed (`manifestFileWithAssetPrefix`) and what the prod server
+* / Cloudflare ASSETS binding actually serve. Without this, a `basePath` +
+* path-style `assetPrefix` build emits `/<basePath>/<assetPrefix>/_next/...`
+* which 404s. When no `assetPrefix` is set, the base-anchored value is already
+* the served URL and is returned unchanged (just root-anchored).
+*
+* Returns an absolute URL for an absolute `assetPrefix`, otherwise a
+* root-relative URL beginning with `/`.
+*/
+function assetServingUrlFromBaseAnchored(value, basePath, assetPrefix) {
+	const normalized = normalizeManifestFile(value);
+	if (!assetPrefix) return "/" + normalized;
+	const anchored = manifestFileWithAssetPrefix(stripBasePathSegment(normalized, basePath), "/", assetPrefix);
+	return isAbsoluteAssetPrefix(assetPrefix) ? anchored : "/" + anchored;
 }
 /**
 * Strip a `base` prefix that Vite applied twice: it bakes `base` into the
@@ -28,4 +63,4 @@ function collapseDuplicateBase(file, base) {
 	return normalizedFile.startsWith(doubledPrefix) ? normalizedFile.slice(normalizedBase.length + 1) : normalizedFile;
 }
 //#endregion
-export { collapseDuplicateBase, manifestFileWithBase, manifestFilesWithBase };
+export { assetServingUrlFromBaseAnchored, collapseDuplicateBase, manifestFileWithAssetPrefix, manifestFileWithBase };

package/dist/utils/path.d.ts

@@ -11,5 +11,6 @@
  * appear in filesystem paths on Linux/macOS.
  */
 declare function normalizePathSeparators(p: string): string;
+declare function stripViteModuleQuery(id: string): string;
 //#endregion
-export { normalizePathSeparators };
+export { normalizePathSeparators, stripViteModuleQuery };

package/dist/utils/path.js

@@ -14,5 +14,9 @@ const isWindows = process.platform === "win32";
 function normalizePathSeparators(p) {
 	return isWindows ? p.replace(/\\/g, "/") : p;
 }
+function stripViteModuleQuery(id) {
+	const queryIndex = id.search(/[?#]/);
+	return queryIndex === -1 ? id : id.slice(0, queryIndex);
+}
 //#endregion
-export { normalizePathSeparators };
+export { normalizePathSeparators, stripViteModuleQuery };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "license": "MIT",
   "repository": {
@@ -49,6 +49,10 @@
       "types": "./dist/server/request-pipeline.d.ts",
       "import": "./dist/server/request-pipeline.js"
     },
+    "./server/pages-request-pipeline": {
+      "types": "./dist/server/pages-request-pipeline.d.ts",
+      "import": "./dist/server/pages-request-pipeline.js"
+    },
     "./server/app-router-entry": {
       "types": "./dist/server/app-router-entry.d.ts",
       "import": "./dist/server/app-router-entry.js"
@@ -97,7 +101,7 @@
     "react-server-dom-webpack": "^19.2.7",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.1.24",
     "vite-plus": "0.1.24",
-    "@vinext/cloudflare": "0.1.0"
+    "@vinext/cloudflare": "0.1.1"
   },
   "peerDependencies": {
     "@mdx-js/rollup": "^3.0.0",