@qzsy/vinext 0.1.7

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

@@ -0,0 +1,4 @@
+//#region src/utils/compare.d.ts
+declare const compareStrings: (left: string, right: string) => number;
+//#endregion
+export { compareStrings };

package/dist/utils/compare.js

@@ -0,0 +1,8 @@
+//#region src/utils/compare.ts
+const compareStrings = (left, right) => {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+};
+//#endregion
+export { compareStrings };

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/dev-error-recovery-event.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/dev-error-recovery-event.d.ts
+declare const VINEXT_DEV_ERROR_RECOVERY_EVENT = "vinext:dev-error-recovery";
+//#endregion
+export { VINEXT_DEV_ERROR_RECOVERY_EVENT };

package/dist/utils/dev-error-recovery-event.js

@@ -0,0 +1,4 @@
+//#region src/utils/dev-error-recovery-event.ts
+const VINEXT_DEV_ERROR_RECOVERY_EVENT = "vinext:dev-error-recovery";
+//#endregion
+export { VINEXT_DEV_ERROR_RECOVERY_EVENT };

package/dist/utils/domain-locale.d.ts

@@ -0,0 +1,26 @@
+import { NextI18nConfig } from "../config/next-config.js";
+
+//#region src/utils/domain-locale.d.ts
+type DomainLocale = NonNullable<NextI18nConfig["domains"]>[number];
+declare function normalizeDomainHostname(hostname: string | null | undefined): string | undefined;
+/**
+ * Match a configured domain either by hostname or locale.
+ * When both are provided, the checks intentionally use OR semantics so the
+ * same helper can cover Next.js's hostname lookup and preferred-locale lookup.
+ * If both are passed, the first domain matching either input wins, so callers
+ * should pass hostname or detectedLocale, not both.
+ */
+declare function detectDomainLocale(domainItems?: readonly DomainLocale[], hostname?: string, detectedLocale?: string): DomainLocale | undefined;
+declare function addLocalePrefix(path: string, locale: string, localeDefault: string): string;
+declare function getLocalePathPrefix(path: string, locales: readonly string[] | undefined): string | undefined;
+declare function getDomainLocaleUrl(url: string, locale: string, {
+  basePath,
+  currentHostname,
+  domainItems
+}: {
+  basePath?: string;
+  currentHostname?: string | null;
+  domainItems?: readonly DomainLocale[];
+}): string | undefined;
+//#endregion
+export { DomainLocale, addLocalePrefix, detectDomainLocale, getDomainLocaleUrl, getLocalePathPrefix, normalizeDomainHostname };

package/dist/utils/domain-locale.js

@@ -0,0 +1,50 @@
+//#region src/utils/domain-locale.ts
+function normalizeDomainHostname(hostname) {
+	if (!hostname) return void 0;
+	return hostname.split(",", 1)[0]?.trim().split(":", 1)[0]?.toLowerCase() || void 0;
+}
+/**
+* Match a configured domain either by hostname or locale.
+* When both are provided, the checks intentionally use OR semantics so the
+* same helper can cover Next.js's hostname lookup and preferred-locale lookup.
+* If both are passed, the first domain matching either input wins, so callers
+* should pass hostname or detectedLocale, not both.
+*/
+function detectDomainLocale(domainItems, hostname, detectedLocale) {
+	if (!domainItems?.length) return void 0;
+	const normalizedHostname = normalizeDomainHostname(hostname);
+	const normalizedLocale = detectedLocale?.toLowerCase();
+	for (const item of domainItems) if (normalizedHostname === normalizeDomainHostname(item.domain) || normalizedLocale === item.defaultLocale.toLowerCase() || item.locales?.some((locale) => locale.toLowerCase() === normalizedLocale)) return item;
+}
+function addLocalePrefix(path, locale, localeDefault) {
+	const normalizedLocale = locale.toLowerCase();
+	if (normalizedLocale === localeDefault.toLowerCase()) return path;
+	const pathWithLeadingSlash = path.startsWith("/") ? path : `/${path}`;
+	const normalizedPathname = (pathWithLeadingSlash.split(/[?#]/, 1)[0] ?? pathWithLeadingSlash).toLowerCase();
+	const localePrefix = `/${normalizedLocale}`;
+	if (normalizedPathname === localePrefix || normalizedPathname.startsWith(`${localePrefix}/`)) return path.startsWith("/") ? path : pathWithLeadingSlash;
+	return `/${locale}${pathWithLeadingSlash}`;
+}
+function getLocalePathPrefix(path, locales) {
+	if (!locales?.length) return void 0;
+	const pathWithLeadingSlash = path.startsWith("/") ? path : `/${path}`;
+	const firstSegment = (pathWithLeadingSlash.split(/[?#]/, 1)[0] ?? pathWithLeadingSlash).split("/").find(Boolean);
+	if (!firstSegment) return void 0;
+	const normalizedSegment = firstSegment.toLowerCase();
+	return locales.find((locale) => locale.toLowerCase() === normalizedSegment);
+}
+function prefixBasePath(path, basePath = "") {
+	if (!basePath) return path;
+	return basePath + path;
+}
+function getDomainLocaleUrl(url, locale, { basePath, currentHostname, domainItems }) {
+	if (!domainItems?.length) return void 0;
+	const targetDomain = detectDomainLocale(domainItems, void 0, locale);
+	if (!targetDomain) return void 0;
+	const currentDomain = detectDomainLocale(domainItems, currentHostname ?? void 0);
+	const localizedPath = addLocalePrefix(url, locale, targetDomain.defaultLocale);
+	if (currentDomain && normalizeDomainHostname(currentDomain.domain) === normalizeDomainHostname(targetDomain.domain)) return;
+	return `${`http${targetDomain.http ? "" : "s"}://`}${targetDomain.domain}${prefixBasePath(localizedPath, basePath)}`;
+}
+//#endregion
+export { addLocalePrefix, detectDomainLocale, getDomainLocaleUrl, getLocalePathPrefix, normalizeDomainHostname };

package/dist/utils/encode-cache-tag.d.ts

@@ -0,0 +1,30 @@
+//#region src/utils/encode-cache-tag.d.ts
+/**
+ * Cache-tag canonicalisation.
+ *
+ * Tags can flow into HTTP headers (e.g. `x-next-cache-tags` on ISR responses,
+ * Cloudflare cache-tag headers, downstream Worker code) where Node's
+ * `validateHeaderValue` rejects any byte outside `\t\x20-\x7e` and crashes
+ * the response with `ERR_INVALID_CHAR`. Even on platforms with permissive
+ * header setters, divergence between storage form and wire form silently
+ * breaks invalidation when a `revalidateTag` call's tag does not byte-match
+ * the form that was stored.
+ *
+ * The fix is to apply this encoding at every public boundary so storage,
+ * comparison, and the wire all see the same ASCII-safe form. The fast-path
+ * returns the input unchanged for already-ASCII tags (the common case), so
+ * pre-encoded `%xx` input round-trips losslessly without `decodeURIComponent`
+ * mangling literal `%xx` characters.
+ *
+ * The replacement matches *runs* of out-of-class code units rather than each
+ * code unit individually so surrogate pairs (emoji, non-BMP characters) are
+ * handed to `encodeURIComponent` as a complete code point — a per-code-unit
+ * regex would split the pair and throw `URIError`.
+ *
+ * Mirrors Next.js's `packages/next/src/server/lib/encode-cache-tag.ts`
+ * (introduced in vercel/next.js#93601).
+ */
+declare function encodeCacheTag(tag: string): string;
+declare function encodeCacheTags(tags: readonly string[]): string[];
+//#endregion
+export { encodeCacheTag, encodeCacheTags };

package/dist/utils/encode-cache-tag.js

@@ -0,0 +1,36 @@
+//#region src/utils/encode-cache-tag.ts
+/**
+* Cache-tag canonicalisation.
+*
+* Tags can flow into HTTP headers (e.g. `x-next-cache-tags` on ISR responses,
+* Cloudflare cache-tag headers, downstream Worker code) where Node's
+* `validateHeaderValue` rejects any byte outside `\t\x20-\x7e` and crashes
+* the response with `ERR_INVALID_CHAR`. Even on platforms with permissive
+* header setters, divergence between storage form and wire form silently
+* breaks invalidation when a `revalidateTag` call's tag does not byte-match
+* the form that was stored.
+*
+* The fix is to apply this encoding at every public boundary so storage,
+* comparison, and the wire all see the same ASCII-safe form. The fast-path
+* returns the input unchanged for already-ASCII tags (the common case), so
+* pre-encoded `%xx` input round-trips losslessly without `decodeURIComponent`
+* mangling literal `%xx` characters.
+*
+* The replacement matches *runs* of out-of-class code units rather than each
+* code unit individually so surrogate pairs (emoji, non-BMP characters) are
+* handed to `encodeURIComponent` as a complete code point — a per-code-unit
+* regex would split the pair and throw `URIError`.
+*
+* Mirrors Next.js's `packages/next/src/server/lib/encode-cache-tag.ts`
+* (introduced in vercel/next.js#93601).
+*/
+const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
+const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+function encodeCacheTag(tag) {
+	return OUT_OF_CLASS_CHAR.test(tag) ? tag.replace(OUT_OF_CLASS_RUN, (run) => encodeURIComponent(run)) : tag;
+}
+function encodeCacheTags(tags) {
+	return tags.map(encodeCacheTag);
+}
+//#endregion
+export { encodeCacheTag, encodeCacheTags };

package/dist/utils/error-cause.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/error-cause.d.ts
+declare function flattenErrorCauses(err: unknown): void;
+//#endregion
+export { flattenErrorCauses };

package/dist/utils/error-cause.js

@@ -0,0 +1,95 @@
+//#region src/utils/error-cause.ts
+/**
+* Embed an Error's `.cause` chain into its own `.message` and `.stack` so
+* single-pass formatters (Vite's "Internal server error: ${err.message}\n${err.stack}"
+* dev-server logger, anything that just prints message + stack) reveal the
+* underlying root cause instead of silently dropping it.
+*
+* Without this, a wrapper like `new Error("Failed query", { cause: pgError })`
+* shows up in the Vite dev console as just "Failed query" — the actual
+* ECONNREFUSED / role-missing / socket-error in `.cause` is lost.
+*
+* Intended for **dev-server use only**. Production loggers (Node's
+* `console.error` → `util.inspect`, workerd's runtime logger) already render
+* `.cause` natively, so calling this in prod would double-print the cause —
+* once in the synthesized message, once in util.inspect's `[cause]:` block.
+* Callers should gate on `process.env.NODE_ENV !== "production"` (Vite
+* build-time-replaces this, so the prod bundle gets a no-op).
+*
+* - Best-effort: never throws. Frozen / non-extensible errors are left untouched.
+* - Idempotent (repeat calls are no-ops via a non-enumerable module-private symbol).
+* - Cycle-safe and depth-capped (10) for pathological cause graphs.
+* - Cause stack frames are appended as `at` lines so stack-cleaning regexes
+*   like Vite's `/^\s*at/` filter preserve them.
+*/
+const FLATTENED_MARKER = Symbol("vinext.errorCausesFlattened");
+const MAX_CAUSE_DEPTH = 10;
+function stringifyNonError(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (value === null || value === void 0) return String(value);
+	try {
+		return JSON.stringify(value) ?? Object.prototype.toString.call(value);
+	} catch {
+		return Object.prototype.toString.call(value);
+	}
+}
+function flattenErrorCauses(err) {
+	if (!(err instanceof Error)) return;
+	const marked = err;
+	if (marked[FLATTENED_MARKER]) return;
+	try {
+		Object.defineProperty(marked, FLATTENED_MARKER, {
+			value: true,
+			enumerable: false,
+			configurable: false,
+			writable: false
+		});
+	} catch {
+		return;
+	}
+	const seen = new WeakSet([err]);
+	const causes = [];
+	let cur = err.cause;
+	let depth = 0;
+	while (cur != null && depth < MAX_CAUSE_DEPTH) {
+		if (typeof cur === "object") {
+			if (seen.has(cur)) break;
+			seen.add(cur);
+		}
+		if (cur instanceof Error) {
+			causes.push({
+				message: cur.message,
+				stack: cur.stack
+			});
+			cur = cur.cause;
+		} else {
+			causes.push({ message: stringifyNonError(cur) });
+			cur = null;
+		}
+		depth++;
+	}
+	if (causes.length === 0) return;
+	const messageSuffix = causes.map((c) => `  [cause]: ${c.message}`).join("\n");
+	try {
+		err.message = `${err.message}\n${messageSuffix}`;
+	} catch {
+		return;
+	}
+	if (typeof err.stack === "string") {
+		let stackSuffix = "";
+		for (const c of causes) {
+			const headline = c.message.split("\n", 1)[0];
+			stackSuffix += `\n    at [cause: ${headline}]`;
+			if (c.stack) {
+				const frames = c.stack.split("\n").filter((l) => /^\s*at\s/.test(l)).join("\n");
+				if (frames) stackSuffix += `\n${frames}`;
+			}
+		}
+		try {
+			err.stack = `${err.stack}${stackSuffix}`;
+		} catch {}
+	}
+}
+//#endregion
+export { flattenErrorCauses };

package/dist/utils/has-trailing-comma.d.ts

@@ -0,0 +1,24 @@
+//#region src/utils/has-trailing-comma.d.ts
+/**
+ * Return the last syntactically significant character of a JS source fragment,
+ * skipping whitespace and comments. A forward scan tracks string and comment
+ * state so that `//` or `/*` sequences appearing INSIDE a string literal (e.g. a
+ * URL such as `"https://example.com"` or a path with a double slash) are NOT
+ * mistaken for comments.
+ *
+ * This is deliberately stricter than a whole-string comment strip: stripping
+ * every `//...`/`/* ... *\/` would also delete those sequences from inside
+ * string literals, which can swallow the real trailing comma that follows them
+ * and corrupt the trailing-comma / empty-object detection this feeds.
+ *
+ * Returns "" for an empty / whitespace-only / comment-only fragment.
+ */
+declare function lastSignificantChar(source: string): string;
+/**
+ * True when `source` ends — ignoring trailing whitespace and comments — with a
+ * real trailing comma. Used to avoid splicing a second comma (`,,` is a syntax
+ * error) when injecting a property or argument into existing source.
+ */
+declare function hasTrailingComma(source: string): boolean;
+//#endregion
+export { hasTrailingComma, lastSignificantChar };

package/dist/utils/has-trailing-comma.js

@@ -0,0 +1,62 @@
+//#region src/utils/has-trailing-comma.ts
+/**
+* Return the last syntactically significant character of a JS source fragment,
+* skipping whitespace and comments. A forward scan tracks string and comment
+* state so that `//` or `/*` sequences appearing INSIDE a string literal (e.g. a
+* URL such as `"https://example.com"` or a path with a double slash) are NOT
+* mistaken for comments.
+*
+* This is deliberately stricter than a whole-string comment strip: stripping
+* every `//...`/`/* ... *\/` would also delete those sequences from inside
+* string literals, which can swallow the real trailing comma that follows them
+* and corrupt the trailing-comma / empty-object detection this feeds.
+*
+* Returns "" for an empty / whitespace-only / comment-only fragment.
+*/
+function lastSignificantChar(source) {
+	let last = "";
+	let i = 0;
+	const n = source.length;
+	while (i < n) {
+		const c = source[i];
+		const next = source[i + 1];
+		if (c === "/" && next === "/") {
+			i += 2;
+			while (i < n && source[i] !== "\n") i += 1;
+			continue;
+		}
+		if (c === "/" && next === "*") {
+			i += 2;
+			while (i < n && !(source[i] === "*" && source[i + 1] === "/")) i += 1;
+			i += 2;
+			continue;
+		}
+		if (c === "\"" || c === "'" || c === "`") {
+			i += 1;
+			while (i < n && source[i] !== c) {
+				if (source[i] === "\\") i += 1;
+				i += 1;
+			}
+			last = c;
+			i += 1;
+			continue;
+		}
+		if (/\s/.test(c)) {
+			i += 1;
+			continue;
+		}
+		last = c;
+		i += 1;
+	}
+	return last;
+}
+/**
+* True when `source` ends — ignoring trailing whitespace and comments — with a
+* real trailing comma. Used to avoid splicing a second comma (`,,` is a syntax
+* error) when injecting a property or argument into existing source.
+*/
+function hasTrailingComma(source) {
+	return lastSignificantChar(source) === ",";
+}
+//#endregion
+export { hasTrailingComma, lastSignificantChar };

package/dist/utils/hash.d.ts

@@ -0,0 +1,24 @@
+//#region src/utils/hash.d.ts
+/**
+ * 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 { fnv1a52, fnv1a64 };

package/dist/utils/hash.js

@@ -0,0 +1,55 @@
+//#region src/utils/hash.ts
+/**
+* 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;
+	for (let i = 0; i < input.length; i++) {
+		h1 ^= input.charCodeAt(i);
+		h1 = h1 * 16777619 >>> 0;
+	}
+	let h2 = 84696351;
+	for (let i = 0; i < input.length; i++) {
+		h2 ^= input.charCodeAt(i);
+		h2 = h2 * 16777619 >>> 0;
+	}
+	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 { fnv1a52, fnv1a64 };

package/dist/utils/html-limited-bots.d.ts

@@ -0,0 +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, isBotUserAgent };

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

@@ -0,0 +1,35 @@
+//#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;
+	const cached = htmlLimitedBotRegexCache.get(source);
+	if (cached) return cached;
+	const regex = new RegExp(source, "i");
+	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, isBotUserAgent };