vinext 0.1.2 → 0.1.4

package/dist/shims/script.js

@@ -113,8 +113,10 @@ function extractBeforeInteractiveInlineContent(children, dangerouslySetInnerHTML
 const REACT_TO_HTML_ATTR = {
 	acceptCharset: "accept-charset",
 	className: "class",
+	crossOrigin: "crossorigin",
 	htmlFor: "for",
-	httpEquiv: "http-equiv"
+	httpEquiv: "http-equiv",
+	referrerPolicy: "referrerpolicy"
 };
 /**
 * Convert the residual `<Script>` props into a plain string-attributes record
@@ -331,10 +333,11 @@ function Script(props) {
 		}
 		if (strategy === "beforeInteractive") {
 			const inlineContent = src ? null : extractBeforeInteractiveInlineContent(children, dangerouslySetInnerHTML);
-			if (inlineContent !== null && registerBeforeInteractive) {
+			if ((src || inlineContent !== null) && registerBeforeInteractive) {
 				registerBeforeInteractive({
 					id,
-					innerHTML: escapeInlineContent(inlineContent, "script"),
+					src: src ?? void 0,
+					innerHTML: inlineContent !== null ? escapeInlineContent(inlineContent, "script") : void 0,
 					nonce: resolvedNonce,
 					attributes: collectBeforeInteractiveAttributes(rest)
 				});
@@ -351,7 +354,8 @@ function Script(props) {
 		return null;
 	}
 	if (strategy === "beforeInteractive") {
-		if ((src ? null : extractBeforeInteractiveInlineContent(children, dangerouslySetInnerHTML)) !== null && hasAppNavigationRuntimeBootstrap()) return null;
+		const inlineContent = src ? null : extractBeforeInteractiveInlineContent(children, dangerouslySetInnerHTML);
+		if ((src || inlineContent !== null) && hasAppNavigationRuntimeBootstrap()) return null;
 		return React.createElement("script", buildBeforeInteractiveScriptProps({
 			src,
 			id,

package/dist/shims/server.d.ts

@@ -19,6 +19,11 @@ declare class NextRequest extends Request {
       i18n?: {
         locales: string[];
         defaultLocale: string;
+        domains?: Array<{
+          domain: string;
+          defaultLocale: string;
+          locales?: string[];
+        }>;
       };
       trailingSlash?: boolean;
     };
@@ -78,6 +83,11 @@ type NextURLConfig = {
     i18n?: {
       locales: string[];
       defaultLocale: string;
+      domains?: Array<{
+        domain: string;
+        defaultLocale: string;
+        locales?: string[];
+      }>;
     };
     /**
      * When true, `href`/`toString()` formats non-root, non-file-like pathnames
@@ -100,8 +110,11 @@ declare class NextURL {
   private _basePath;
   private _trailingSlash;
   private _locale;
+  private _configDefaultLocale;
   private _defaultLocale;
   private _locales;
+  private _domains;
+  private _domainLocale;
   constructor(input: string | URL, base?: string | URL, config?: NextURLConfig);
   /** Strip basePath prefix from the internal pathname.
    * Mirrors Next.js's getNextPathnameInfo (re-run by NextURL.analyze() on
@@ -116,7 +129,8 @@ declare class NextURL {
    */
   private _stripBasePath;
   /** Extract locale from pathname, stripping it from the internal URL. */
-  private _analyzeLocale;
+  private _detectPathnameLocale;
+  private _analyzeI18n;
   /**
    * Reconstruct the full pathname with basePath + locale prefix and apply
    * the configured trailingSlash policy.
@@ -158,6 +172,7 @@ declare class NextURL {
   get locale(): string;
   set locale(value: string | undefined);
   get defaultLocale(): string | undefined;
+  get domainLocale(): typeof this._domainLocale;
   get locales(): string[] | undefined;
   clone(): NextURL;
   toString(): string;

package/dist/shims/server.js

@@ -3,7 +3,7 @@ import { getRequestExecutionContext } from "./request-context.js";
 import { MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER } from "../server/headers.js";
 import { encodeMiddlewareRequestHeaders } from "../server/middleware-request-headers.js";
 import { serializeSetCookie, validateCookieName } from "./internal/cookie-serialize.js";
-import { parseCookieHeader } from "./internal/parse-cookie-header.js";
+import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 //#region src/shims/server.ts
 /**
@@ -51,6 +51,12 @@ var NextRequest = class extends Request {
 		if (input instanceof Request) {
 			const requestInput = requestInit.body === void 0 && input.body && !input.bodyUsed ? input.clone() : input;
 			super(requestInput, requestInit);
+			const cf = Reflect.get(input, "cf");
+			if (cf !== void 0) Object.defineProperty(this, "cf", {
+				value: cf,
+				enumerable: true,
+				configurable: true
+			});
 		} else super(input, requestInit);
 		const url = typeof input === "string" ? new URL(input, "http://localhost") : input instanceof URL ? input : new URL(input.url, "http://localhost");
 		const urlConfig = _nextConfig ? {
@@ -192,8 +198,11 @@ var NextURL = class NextURL {
 	_basePath;
 	_trailingSlash;
 	_locale;
+	_configDefaultLocale;
 	_defaultLocale;
 	_locales;
+	_domains;
+	_domainLocale;
 	constructor(input, base, config) {
 		this._url = new URL(input.toString(), base);
 		this._configBasePath = config?.basePath ?? "";
@@ -203,8 +212,12 @@ var NextURL = class NextURL {
 		const i18n = config?.nextConfig?.i18n;
 		if (i18n) {
 			this._locales = [...i18n.locales];
-			this._defaultLocale = i18n.defaultLocale;
-			this._analyzeLocale(this._locales);
+			this._domains = i18n.domains?.map((domain) => ({
+				...domain,
+				locales: domain.locales ? [...domain.locales] : void 0
+			}));
+			this._configDefaultLocale = i18n.defaultLocale;
+			this._analyzeI18n();
 		}
 	}
 	/** Strip basePath prefix from the internal pathname.
@@ -228,14 +241,21 @@ var NextURL = class NextURL {
 		this._url.pathname = stripBasePath(this._url.pathname, this._configBasePath);
 	}
 	/** Extract locale from pathname, stripping it from the internal URL. */
-	_analyzeLocale(locales) {
+	_detectPathnameLocale(locales) {
 		const segments = this._url.pathname.split("/");
 		const candidate = segments[1]?.toLowerCase();
 		const match = locales.find((l) => l.toLowerCase() === candidate);
-		if (match) {
-			this._locale = match;
-			this._url.pathname = "/" + segments.slice(2).join("/");
-		} else this._locale = this._defaultLocale;
+		if (match) this._url.pathname = "/" + segments.slice(2).join("/");
+		return match;
+	}
+	_analyzeI18n() {
+		if (!this._locales || !this._configDefaultLocale) return;
+		const detectedLocale = this._detectPathnameLocale(this._locales);
+		const detectedLocaleLower = detectedLocale?.toLowerCase();
+		const hostname = this._url.hostname.toLowerCase();
+		this._domainLocale = this._domains?.find((domain) => domain.domain.split(":", 1)[0].toLowerCase() === hostname || detectedLocaleLower === domain.defaultLocale.toLowerCase() || domain.locales?.some((locale) => locale.toLowerCase() === detectedLocaleLower));
+		this._defaultLocale = this._domainLocale?.defaultLocale ?? this._configDefaultLocale;
+		this._locale = detectedLocale ?? this._defaultLocale;
 	}
 	/**
 	* Reconstruct the full pathname with basePath + locale prefix and apply
@@ -244,8 +264,9 @@ var NextURL = class NextURL {
 	*/
 	_formatPathname() {
 		let prefix = this._basePath;
-		if (this._locale && this._locale !== this._defaultLocale) prefix += "/" + this._locale;
 		const inner = this._url.pathname;
+		const innerLower = inner.toLowerCase();
+		if (!(innerLower === "/api" || innerLower.startsWith("/api/")) && this._locale && this._locale !== this._defaultLocale) prefix += "/" + this._locale;
 		const composed = !prefix ? inner : inner === "/" ? prefix : prefix + inner;
 		return this._applyTrailingSlash(composed);
 	}
@@ -270,7 +291,7 @@ var NextURL = class NextURL {
 	set href(value) {
 		this._url.href = value;
 		this._stripBasePath();
-		if (this._locales) this._analyzeLocale(this._locales);
+		this._analyzeI18n();
 	}
 	get origin() {
 		return this._url.origin;
@@ -355,6 +376,13 @@ var NextURL = class NextURL {
 	get defaultLocale() {
 		return this._defaultLocale;
 	}
+	get domainLocale() {
+		if (!this._domainLocale) return void 0;
+		return {
+			...this._domainLocale,
+			locales: this._domainLocale.locales ? [...this._domainLocale.locales] : void 0
+		};
+	}
 	get locales() {
 		return this._locales ? [...this._locales] : void 0;
 	}
@@ -362,7 +390,11 @@ var NextURL = class NextURL {
 		const nextConfig = {};
 		if (this._locales) nextConfig.i18n = {
 			locales: [...this._locales],
-			defaultLocale: this._defaultLocale
+			defaultLocale: this._configDefaultLocale,
+			domains: this._domains?.map((domain) => ({
+				...domain,
+				locales: domain.locales ? [...domain.locales] : void 0
+			}))
 		};
 		if (this._trailingSlash) nextConfig.trailingSlash = true;
 		const config = {
@@ -389,7 +421,7 @@ var RequestCookies = class {
 	_parsed;
 	constructor(headers) {
 		this._headers = headers;
-		this._parsed = parseCookieHeader(headers.get("cookie") ?? "");
+		this._parsed = parseEdgeRequestCookieHeader(headers.get("cookie") ?? "");
 	}
 	get(name) {
 		const value = this._parsed.get(name);

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

@@ -34,6 +34,7 @@ function createRequestContext(opts) {
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
+		currentForceDynamicFetchDefault: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		isFetchDedupeActive: false,
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),

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

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

package/dist/utils/commonjs-loader.js

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

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

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

package/dist/utils/deployment-id.js

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

package/dist/utils/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/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/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

@@ -12,5 +12,11 @@
  */
 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, stripViteModuleQuery };
+export { normalizePathSeparators, stripJsExtension, stripViteModuleQuery };

package/dist/utils/path.js

@@ -18,5 +18,13 @@ 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, stripViteModuleQuery };
+export { normalizePathSeparators, stripJsExtension, stripViteModuleQuery };

package/dist/utils/text-stream.d.ts

@@ -16,7 +16,7 @@
 declare function readStreamAsText(stream: ReadableStream<Uint8Array>): Promise<string>;
 /**
  * Drain a UTF-8 byte stream up to `maxBytes` of *raw* input, returning the
- * decoded text. If the raw size limit is exceeded, the reader is cancelled
+ * decoded text. If the raw size limit is exceeded, cancellation is signalled
  * and `onLimitExceeded` is invoked; it MUST throw — its return type is
  * `never` to enforce that. Each caller passes its own error type.
  *