vinext 0.1.1 → 0.1.3

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/html-limited-bots.d.ts

@@ -1,4 +1,21 @@
 //#region src/utils/html-limited-bots.d.ts
 declare function getHtmlLimitedBotRegex(htmlLimitedBots: string | undefined): RegExp;
+/**
+ * Returns true when the User-Agent matches a known crawler/bot. Combines
+ * Next.js's "headless browser bot" check (Googlebot proper) with the
+ * "HTML-limited bot" list (Bingbot, DuckDuckBot, facebookexternalhit, …).
+ *
+ * Used by the Pages Router fallback path: a bot hitting an unlisted
+ * `fallback: true` route should get a synchronous render (real content) and
+ * not the loading shell, so the crawler indexes the actual page. Mirrors
+ * Next.js's `isBot()` in `.nextjs-ref/packages/next/src/shared/lib/router/utils/is-bot.ts`
+ * and the bot-aware fallback flip in
+ * `.nextjs-ref/packages/next/src/server/route-modules/pages/pages-handler.ts`.
+ *
+ * `htmlLimitedBots` allows next.config to override the HTML-limited list
+ * (same flag that drives `getHtmlLimitedBotRegex`), so a custom list applies
+ * to both streaming metadata gating and bot-aware fallback rendering.
+ */
+declare function isBotUserAgent(userAgent: string, htmlLimitedBots?: string): boolean;
 //#endregion
-export { getHtmlLimitedBotRegex };
+export { getHtmlLimitedBotRegex, isBotUserAgent };

package/dist/utils/html-limited-bots.js

@@ -1,5 +1,6 @@
 //#region src/utils/html-limited-bots.ts
 const HTML_LIMITED_BOT_UA_RE_STRING = String.raw`[\w-]+-Google|Google-[\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight`;
+const HEADLESS_BROWSER_BOT_UA_RE = /Googlebot(?!-)|Googlebot$/i;
 const htmlLimitedBotRegexCache = /* @__PURE__ */ new Map();
 function getHtmlLimitedBotRegex(htmlLimitedBots) {
 	const source = htmlLimitedBots || HTML_LIMITED_BOT_UA_RE_STRING;
@@ -9,5 +10,26 @@ function getHtmlLimitedBotRegex(htmlLimitedBots) {
 	htmlLimitedBotRegexCache.set(source, regex);
 	return regex;
 }
+/**
+* Returns true when the User-Agent matches a known crawler/bot. Combines
+* Next.js's "headless browser bot" check (Googlebot proper) with the
+* "HTML-limited bot" list (Bingbot, DuckDuckBot, facebookexternalhit, …).
+*
+* Used by the Pages Router fallback path: a bot hitting an unlisted
+* `fallback: true` route should get a synchronous render (real content) and
+* not the loading shell, so the crawler indexes the actual page. Mirrors
+* Next.js's `isBot()` in `.nextjs-ref/packages/next/src/shared/lib/router/utils/is-bot.ts`
+* and the bot-aware fallback flip in
+* `.nextjs-ref/packages/next/src/server/route-modules/pages/pages-handler.ts`.
+*
+* `htmlLimitedBots` allows next.config to override the HTML-limited list
+* (same flag that drives `getHtmlLimitedBotRegex`), so a custom list applies
+* to both streaming metadata gating and bot-aware fallback rendering.
+*/
+function isBotUserAgent(userAgent, htmlLimitedBots) {
+	if (!userAgent) return false;
+	if (HEADLESS_BROWSER_BOT_UA_RE.test(userAgent)) return true;
+	return getHtmlLimitedBotRegex(htmlLimitedBots).test(userAgent);
+}
 //#endregion
-export { getHtmlLimitedBotRegex };
+export { getHtmlLimitedBotRegex, isBotUserAgent };

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/parse-cookie.d.ts

@@ -0,0 +1,13 @@
+//#region src/utils/parse-cookie.d.ts
+type ParsedCookies = Record<string, string>;
+/**
+ * Parse a Cookie header using the semantics of Next.js's compiled `cookie`
+ * package.
+ */
+declare function parseCookieHeader(cookieHeader: string | null | undefined): ParsedCookies;
+/**
+ * Parse a Cookie header using Next.js/@edge-runtime RequestCookies semantics.
+ */
+declare function parseEdgeRequestCookieHeader(cookieHeader: string): Map<string, string>;
+//#endregion
+export { ParsedCookies, parseCookieHeader, parseEdgeRequestCookieHeader };

package/dist/utils/parse-cookie.js

@@ -0,0 +1,52 @@
+//#region src/utils/parse-cookie.ts
+function decodeCookieValue(value) {
+	try {
+		return {
+			ok: true,
+			value: decodeURIComponent(value)
+		};
+	} catch {
+		return { ok: false };
+	}
+}
+function forEachCookieHeaderPart(cookieHeader, visit) {
+	for (const part of cookieHeader.split(/; */)) {
+		if (!part) continue;
+		visit(part, part.indexOf("="));
+	}
+}
+/**
+* Parse a Cookie header using the semantics of Next.js's compiled `cookie`
+* package.
+*/
+function parseCookieHeader(cookieHeader) {
+	const cookies = {};
+	if (!cookieHeader) return cookies;
+	forEachCookieHeaderPart(cookieHeader, (part, separator) => {
+		if (separator < 0) return;
+		const key = part.slice(0, separator).trim();
+		let value = part.slice(separator + 1).trim();
+		if (cookies[key] !== void 0) return;
+		if (value.startsWith("\"")) value = value.slice(1, -1);
+		const decoded = decodeCookieValue(value);
+		cookies[key] = decoded.ok ? decoded.value : value;
+	});
+	return cookies;
+}
+/**
+* Parse a Cookie header using Next.js/@edge-runtime RequestCookies semantics.
+*/
+function parseEdgeRequestCookieHeader(cookieHeader) {
+	const cookies = /* @__PURE__ */ new Map();
+	forEachCookieHeaderPart(cookieHeader, (part, separator) => {
+		if (separator === -1) {
+			cookies.set(part, "true");
+			return;
+		}
+		const decoded = decodeCookieValue(part.slice(separator + 1));
+		if (decoded.ok) cookies.set(part.slice(0, separator), decoded.value);
+	});
+	return cookies;
+}
+//#endregion
+export { parseCookieHeader, parseEdgeRequestCookieHeader };

package/dist/utils/path.d.ts

@@ -11,5 +11,12 @@
  * appear in filesystem paths on Linux/macOS.
  */
 declare function normalizePathSeparators(p: string): string;
+declare function stripViteModuleQuery(id: string): string;
+/** Strip a trailing `.js` extension from a module specifier so
+ *  `resolveShimModulePath` looks for the correct base name (e.g. `headers.js`
+ *  → `headers`). Public and internal shim imports may carry extensionful
+ *  subpaths; normalising before resolution prevents looking for non-existent
+ *  files like `headers.js.ts`. */
+declare function stripJsExtension(name: string): string;
 //#endregion
-export { normalizePathSeparators };
+export { normalizePathSeparators, stripJsExtension, stripViteModuleQuery };

package/dist/utils/path.js

@@ -14,5 +14,17 @@ 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);
+}
+/** Strip a trailing `.js` extension from a module specifier so
+*  `resolveShimModulePath` looks for the correct base name (e.g. `headers.js`
+*  → `headers`). Public and internal shim imports may carry extensionful
+*  subpaths; normalising before resolution prevents looking for non-existent
+*  files like `headers.js.ts`. */
+function stripJsExtension(name) {
+	return name.endsWith(".js") ? name.slice(0, -3) : name;
+}
 //#endregion
-export { normalizePathSeparators };
+export { normalizePathSeparators, stripJsExtension, stripViteModuleQuery };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "license": "MIT",
   "repository": {
@@ -101,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.2"
   },
   "peerDependencies": {
     "@mdx-js/rollup": "^3.0.0",

package/dist/shims/internal/parse-cookie-header.d.ts

@@ -1,14 +0,0 @@
-//#region src/shims/internal/parse-cookie-header.d.ts
-/**
- * Port of the current Next.js/@edge-runtime request cookie parser semantics.
- *
- * Important details:
- * - split on a semicolon-plus-optional-spaces pattern
- * - preserve whitespace around names/values otherwise
- * - bare tokens become "true"
- * - malformed percent-encoded values are skipped
- * - duplicate names collapse to the last value via Map.set()
- */
-declare function parseCookieHeader(cookieHeader: string): Map<string, string>;
-//#endregion
-export { parseCookieHeader };

package/dist/shims/internal/parse-cookie-header.js

@@ -1,30 +0,0 @@
-//#region src/shims/internal/parse-cookie-header.ts
-/**
-* Port of the current Next.js/@edge-runtime request cookie parser semantics.
-*
-* Important details:
-* - split on a semicolon-plus-optional-spaces pattern
-* - preserve whitespace around names/values otherwise
-* - bare tokens become "true"
-* - malformed percent-encoded values are skipped
-* - duplicate names collapse to the last value via Map.set()
-*/
-function parseCookieHeader(cookieHeader) {
-	const cookies = /* @__PURE__ */ new Map();
-	for (const pair of cookieHeader.split(/; */)) {
-		if (!pair) continue;
-		const splitAt = pair.indexOf("=");
-		if (splitAt === -1) {
-			cookies.set(pair, "true");
-			continue;
-		}
-		const key = pair.slice(0, splitAt);
-		const value = pair.slice(splitAt + 1);
-		try {
-			cookies.set(key, decodeURIComponent(value));
-		} catch {}
-	}
-	return cookies;
-}
-//#endregion
-export { parseCookieHeader };