vinext 0.1.5 → 0.1.7

package/dist/plugins/og-asset-ownership.js

@@ -0,0 +1,285 @@
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+//#region src/plugins/og-asset-ownership.ts
+const realpathNative = promisify(fs.realpath.native);
+function isPathInside(root, target) {
+	const relative = path.relative(root, target);
+	return relative === "" || !path.isAbsolute(relative) && !relative.startsWith(`..${path.sep}`) && relative !== "..";
+}
+async function findPackageRoot(moduleDir, expectedPackageName) {
+	let currentDir = moduleDir;
+	while (true) {
+		try {
+			const packageJsonPath = path.join(currentDir, "package.json");
+			if ((await fs.promises.stat(packageJsonPath)).isFile()) {
+				const manifest = JSON.parse(await fs.promises.readFile(packageJsonPath, "utf8"));
+				return expectedPackageName === void 0 || manifest.name === expectedPackageName ? currentDir : null;
+			}
+		} catch {}
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function getPackageNameFromSpecifier(specifier) {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("\0") || specifier.startsWith("#")) return null;
+	const segments = specifier.split("/");
+	if (specifier.startsWith("@")) return segments.length >= 2 ? `${segments[0]}/${segments[1]}` : null;
+	return segments[0] || null;
+}
+function getAliasedPackageName(value) {
+	if (typeof value !== "string") return null;
+	return value.match(/^(?:npm:|workspace:)(@[^/]+\/[^@]+|[^@*~^]+)(?:@|$)/)?.[1] ?? null;
+}
+function aliasMatches(find, source) {
+	if (typeof find === "string") return source === find || source.startsWith(`${find}/`);
+	find.lastIndex = 0;
+	return find.test(source);
+}
+function applyAlias(find, replacement, source) {
+	if (typeof find === "string") return replacement + source.slice(find.length);
+	find.lastIndex = 0;
+	return source.replace(find, replacement);
+}
+function getNodeModulesPackageRoot(logicalProjectRoot, logicalModulePath) {
+	const isProjectPath = isPathInside(logicalProjectRoot, logicalModulePath);
+	const parsedPath = path.parse(logicalModulePath);
+	const baseRoot = isProjectPath ? logicalProjectRoot : parsedPath.root;
+	const segments = (isProjectPath ? path.relative(logicalProjectRoot, logicalModulePath) : logicalModulePath.slice(parsedPath.root.length)).split(path.sep);
+	const nodeModulesIndex = segments.lastIndexOf("node_modules");
+	if (nodeModulesIndex === -1) return null;
+	const packageSegment = segments[nodeModulesIndex + 1];
+	if (!packageSegment) return null;
+	const packageSegmentCount = packageSegment.startsWith("@") ? 2 : 1;
+	if (segments.length <= nodeModulesIndex + packageSegmentCount) return null;
+	if (packageSegmentCount === 2 && !segments[nodeModulesIndex + 2]) return null;
+	return path.join(baseRoot, ...segments.slice(0, nodeModulesIndex + 1 + packageSegmentCount));
+}
+async function readPackageName(packageRoot) {
+	try {
+		const manifest = JSON.parse(await fs.promises.readFile(path.join(packageRoot, "package.json"), "utf8"));
+		return typeof manifest.name === "string" ? manifest.name : null;
+	} catch {
+		return null;
+	}
+}
+async function packageOwnsAliasFile(packageRoot, packageName, aliasFile) {
+	try {
+		const manifest = JSON.parse(await fs.promises.readFile(path.join(packageRoot, "package.json"), "utf8"));
+		if (packageName !== null && manifest.name === packageName) return true;
+		return [
+			"main",
+			"module",
+			"source",
+			"browser"
+		].some((field) => typeof manifest[field] === "string" && path.resolve(packageRoot, manifest[field]) === aliasFile);
+	} catch {
+		return false;
+	}
+}
+async function packageOwnsAliasDirectory(packageRoot, packageName, aliasDirectory) {
+	if (aliasDirectory === packageRoot) return true;
+	try {
+		const manifest = JSON.parse(await fs.promises.readFile(path.join(packageRoot, "package.json"), "utf8"));
+		if (packageName !== null && manifest.name === packageName) return true;
+		return [
+			"main",
+			"module",
+			"source",
+			"browser"
+		].some((field) => typeof manifest[field] === "string" && isPathInside(aliasDirectory, path.resolve(packageRoot, manifest[field])));
+	} catch {
+		return false;
+	}
+}
+var OgAssetOwnership = class {
+	projectRoot = process.cwd();
+	linkedPackageRoots = /* @__PURE__ */ new Set();
+	dependencyPackageNames = /* @__PURE__ */ new Map();
+	stringAliasesByFirstCharacter = /* @__PURE__ */ new Map();
+	regularExpressionAliases = [];
+	configuredAliases = [];
+	configure(projectRoot, aliases) {
+		this.projectRoot = path.resolve(projectRoot);
+		this.dependencyPackageNames.clear();
+		try {
+			const manifest = JSON.parse(fs.readFileSync(path.join(this.projectRoot, "package.json"), "utf8"));
+			for (const field of [
+				"dependencies",
+				"devDependencies",
+				"optionalDependencies",
+				"peerDependencies"
+			]) {
+				const dependencies = manifest[field];
+				if (dependencies === null || typeof dependencies !== "object") continue;
+				for (const [packageName, value] of Object.entries(dependencies)) this.dependencyPackageNames.set(packageName, getAliasedPackageName(value) ?? packageName);
+			}
+		} catch {}
+		this.stringAliasesByFirstCharacter.clear();
+		this.regularExpressionAliases = [];
+		this.configuredAliases = [];
+		for (const [index, alias] of aliases.entries()) {
+			const indexedAlias = {
+				...alias,
+				index
+			};
+			this.configuredAliases.push(indexedAlias);
+			if (typeof alias.find === "string") {
+				const firstCharacter = alias.find[0];
+				if (firstCharacter === void 0) continue;
+				const matchingAliases = this.stringAliasesByFirstCharacter.get(firstCharacter) ?? [];
+				matchingAliases.push(indexedAlias);
+				this.stringAliasesByFirstCharacter.set(firstCharacter, matchingAliases);
+			} else this.regularExpressionAliases.push(indexedAlias);
+		}
+	}
+	reset() {
+		this.linkedPackageRoots.clear();
+	}
+	shouldTrackImport(source) {
+		return this.findAlias(source) !== void 0 || this.getExpectedPackageName(source) !== void 0;
+	}
+	async recordResolvedImport(source, resolvedId) {
+		const configuredAlias = this.findAlias(source);
+		const sourcePackageName = getPackageNameFromSpecifier(source);
+		const expectedPackageName = this.getExpectedPackageName(source);
+		if (configuredAlias === void 0 && expectedPackageName === void 0) return;
+		let realResolvedPath;
+		try {
+			realResolvedPath = await realpathNative(path.resolve(resolvedId.split("?")[0]));
+		} catch {
+			return;
+		}
+		let packageRoot;
+		if (configuredAlias !== void 0) packageRoot = await this.resolveAliasPackageRoot(configuredAlias, source, sourcePackageName, realResolvedPath);
+		else packageRoot = await findPackageRoot(path.dirname(realResolvedPath), expectedPackageName);
+		if (packageRoot !== null) this.linkedPackageRoots.add(packageRoot);
+	}
+	async resolveModuleBoundary(moduleId) {
+		const modulePath = path.resolve(moduleId.split("?")[0]);
+		let realProjectRoot;
+		let realModulePath;
+		try {
+			[realProjectRoot, realModulePath] = await Promise.all([realpathNative(this.projectRoot), realpathNative(modulePath)]);
+		} catch {
+			try {
+				realProjectRoot = await realpathNative(this.projectRoot);
+				const realModuleDir = await realpathNative(path.dirname(modulePath));
+				realModulePath = path.join(realModuleDir, path.basename(modulePath));
+			} catch {
+				return null;
+			}
+		}
+		const moduleDir = path.dirname(realModulePath);
+		const logicalPackageRoot = getNodeModulesPackageRoot(this.projectRoot, modulePath);
+		if (logicalPackageRoot !== null) {
+			let realPackageRoot;
+			try {
+				realPackageRoot = await realpathNative(logicalPackageRoot);
+			} catch {
+				return null;
+			}
+			if (isPathInside(realPackageRoot, realModulePath)) return {
+				assetRoot: realPackageRoot,
+				moduleDir
+			};
+			const declaredPackageName = await readPackageName(logicalPackageRoot);
+			if (declaredPackageName === null) return null;
+			const logicalModuleRelativePath = path.relative(logicalPackageRoot, modulePath);
+			if (path.isAbsolute(logicalModuleRelativePath) || logicalModuleRelativePath === ".." || logicalModuleRelativePath.startsWith(`..${path.sep}`)) return null;
+			const canonicalPackageRoot = await findPackageRoot(moduleDir, declaredPackageName);
+			if (canonicalPackageRoot === null) return null;
+			if (path.relative(canonicalPackageRoot, realModulePath) !== logicalModuleRelativePath) return null;
+			return {
+				assetRoot: canonicalPackageRoot,
+				moduleDir
+			};
+		}
+		if (isPathInside(realProjectRoot, realModulePath)) return {
+			assetRoot: realProjectRoot,
+			moduleDir
+		};
+		const linkedPackageRoot = [...this.linkedPackageRoots].filter((root) => isPathInside(root, realModulePath)).sort((a, b) => b.length - a.length)[0];
+		if (linkedPackageRoot !== void 0) return {
+			assetRoot: linkedPackageRoot,
+			moduleDir
+		};
+		const configuredAliasRoot = await this.resolveConfiguredAliasRoot(realModulePath);
+		return configuredAliasRoot === null ? null : {
+			assetRoot: configuredAliasRoot,
+			moduleDir
+		};
+	}
+	async resolveContainedAsset(assetRoot, assetPath) {
+		try {
+			const realPath = await realpathNative(assetPath);
+			return isPathInside(assetRoot, realPath) ? realPath : null;
+		} catch {
+			return null;
+		}
+	}
+	findAlias(source) {
+		return [...this.stringAliasesByFirstCharacter.get(source[0] ?? "") ?? [], ...this.regularExpressionAliases].filter((alias) => aliasMatches(alias.find, source)).sort((a, b) => a.index - b.index)[0];
+	}
+	getExpectedPackageName(source) {
+		const packageName = getPackageNameFromSpecifier(source);
+		return packageName === null ? void 0 : this.dependencyPackageNames.get(packageName);
+	}
+	async resolveAliasPackageRoot(alias, source, sourcePackageName, realResolvedPath) {
+		const aliasTarget = applyAlias(alias.find, alias.replacement, source);
+		if (!path.isAbsolute(aliasTarget)) return null;
+		try {
+			const realAliasTarget = await realpathNative(aliasTarget);
+			const aliasTargetStat = await fs.promises.stat(realAliasTarget);
+			const hasCapture = alias.find instanceof RegExp && alias.replacement.includes("$");
+			let configuredDirectory = null;
+			if (!hasCapture) {
+				const realReplacement = await realpathNative(alias.replacement);
+				if ((await fs.promises.stat(realReplacement)).isDirectory()) configuredDirectory = realReplacement;
+			}
+			if (configuredDirectory !== null || aliasTargetStat.isDirectory()) {
+				const aliasBoundary = configuredDirectory ?? realAliasTarget;
+				const packageRoot = await findPackageRoot(path.dirname(realResolvedPath));
+				if (packageRoot === null || !isPathInside(aliasBoundary, packageRoot) || !isPathInside(packageRoot, realResolvedPath)) return null;
+				return packageRoot;
+			}
+			const packageRoot = await findPackageRoot(path.dirname(realResolvedPath));
+			if (packageRoot === null || !await packageOwnsAliasFile(packageRoot, sourcePackageName, realAliasTarget) || !isPathInside(packageRoot, realResolvedPath)) return null;
+			return packageRoot;
+		} catch {
+			return null;
+		}
+	}
+	async resolveConfiguredAliasRoot(realModulePath) {
+		const packageRoot = await findPackageRoot(path.dirname(realModulePath));
+		if (packageRoot === null || !isPathInside(packageRoot, realModulePath)) return null;
+		for (const alias of this.configuredAliases) {
+			if (!path.isAbsolute(alias.replacement)) continue;
+			const packageName = typeof alias.find === "string" ? getPackageNameFromSpecifier(alias.find) : null;
+			if (alias.replacement.indexOf("$") !== -1) {
+				const packageManifestName = await readPackageName(packageRoot);
+				if (packageManifestName === null || !aliasMatches(alias.find, packageManifestName)) continue;
+				const aliasTarget = applyAlias(alias.find, alias.replacement, packageManifestName);
+				if (!path.isAbsolute(aliasTarget)) continue;
+				try {
+					const realAliasTarget = await realpathNative(aliasTarget);
+					const aliasTargetStat = await fs.promises.stat(realAliasTarget);
+					if (aliasTargetStat.isDirectory() && isPathInside(realAliasTarget, realModulePath) || aliasTargetStat.isFile() && realAliasTarget === realModulePath) return packageRoot;
+				} catch {}
+				continue;
+			}
+			try {
+				const realReplacement = await realpathNative(alias.replacement);
+				if ((await fs.promises.stat(realReplacement)).isDirectory()) {
+					if (isPathInside(packageRoot, realReplacement) && isPathInside(realReplacement, realModulePath) && await packageOwnsAliasDirectory(packageRoot, packageName, realReplacement)) return packageRoot;
+					continue;
+				}
+				if (realReplacement === realModulePath && await packageOwnsAliasFile(packageRoot, packageName, realReplacement)) return packageRoot;
+			} catch {}
+		}
+		return null;
+	}
+};
+//#endregion
+export { OgAssetOwnership };

package/dist/plugins/og-assets.js

@@ -1,3 +1,4 @@
+import { OgAssetOwnership } from "./og-asset-ownership.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
@@ -15,29 +16,46 @@ import MagicString from "magic-string";
 */
 function createOgInlineFetchAssetsPlugin() {
 	const cache = /* @__PURE__ */ new Map();
+	const ownership = new OgAssetOwnership();
 	let isBuild = false;
 	return {
 		name: "vinext:og-inline-fetch-assets",
 		enforce: "pre",
 		configResolved(config) {
 			isBuild = config.command === "build";
+			ownership.configure(config.root, config.resolve.alias);
 		},
 		buildStart() {
 			if (isBuild) cache.clear();
+			ownership.reset();
+		},
+		async resolveId(source, importer, options) {
+			if (!ownership.shouldTrackImport(source)) return null;
+			const resolved = await this.resolve(source, importer, {
+				...options,
+				skipSelf: true
+			});
+			if (resolved === null || resolved.external) return null;
+			await ownership.recordResolvedImport(source, resolved.id);
+			return null;
 		},
 		transform: {
 			filter: { code: "import.meta.url" },
 			async handler(code, id) {
 				const useCache = isBuild;
-				const moduleDir = path.dirname(id);
-				let newCode = code;
+				const boundary = await ownership.resolveModuleBoundary(id);
+				if (boundary === null) return null;
+				const { assetRoot, moduleDir } = boundary;
+				const s = new MagicString(code);
 				let didReplace = false;
 				const readAsBase64 = async (absPath) => {
-					const cached = useCache ? cache.get(absPath) : void 0;
+					const realPath = await ownership.resolveContainedAsset(assetRoot, absPath);
+					if (realPath === null) return null;
+					const cached = useCache ? cache.get(realPath) : void 0;
 					if (cached !== void 0) return cached;
 					try {
-						const b64 = (await fs.promises.readFile(absPath)).toString("base64");
-						if (useCache) cache.set(absPath, b64);
+						const b64 = (await fs.promises.readFile(realPath)).toString("base64");
+						if (useCache) cache.set(realPath, b64);
 						return b64;
 					} catch {
 						return null;
@@ -57,22 +75,22 @@ function createOgInlineFetchAssetsPlugin() {
 						`return Promise.resolve(a.buffer);`,
 						`})()`
 					].join("");
-					newCode = newCode.replaceAll(fullMatch, inlined);
+					s.overwrite(match.index, match.index + fullMatch.length, inlined);
 					didReplace = true;
 				}
-				if (code.includes("readFileSync(")) for (const match of newCode.matchAll(/[a-zA-Z_$][a-zA-Z0-9_$]*\.readFileSync\(\s*(?:[a-zA-Z_$][a-zA-Z0-9_$]*\.)?fileURLToPath\(\s*new URL\(\s*(["'])(\.[^"']+)\1\s*,\s*import\.meta\.url\s*\)\s*\)\s*\)/g)) {
+				if (code.includes("readFileSync(")) for (const match of code.matchAll(/[a-zA-Z_$][a-zA-Z0-9_$]*\.readFileSync\(\s*(?:[a-zA-Z_$][a-zA-Z0-9_$]*\.)?fileURLToPath\(\s*new URL\(\s*(["'])(\.[^"']+)\1\s*,\s*import\.meta\.url\s*\)\s*\)\s*\)/g)) {
 					const fullMatch = match[0];
 					const relPath = match[2];
 					const fileBase64 = await readAsBase64(path.resolve(moduleDir, relPath));
 					if (fileBase64 === null) continue;
 					const inlined = `Buffer.from(${JSON.stringify(fileBase64)},"base64")`;
-					newCode = newCode.replaceAll(fullMatch, inlined);
+					s.overwrite(match.index, match.index + fullMatch.length, inlined);
 					didReplace = true;
 				}
 				if (!didReplace) return null;
 				return {
-					code: newCode,
-					map: null
+					code: s.toString(),
+					map: s.generateMap({ hires: "boundary" })
 				};
 			}
 		}

package/dist/plugins/remove-console.js

@@ -32,7 +32,6 @@ const SCOPE_ENTERING_TYPES = new Set([
 */
 function removeConsoleCalls(code, config) {
 	if (config === false) return null;
-	const excluded = typeof config === "object" ? new Set(config.exclude.map((s) => s.toLowerCase())) : /* @__PURE__ */ new Set();
 	if (!code.match(/\bconsole\b/)) return null;
 	let ast;
 	try {
@@ -40,6 +39,7 @@ function removeConsoleCalls(code, config) {
 	} catch {
 		return null;
 	}
+	const excluded = typeof config === "object" ? new Set(config.exclude.map((s) => s.toLowerCase())) : /* @__PURE__ */ new Set();
 	const scopeStack = [{ shadowed: false }];
 	function currentScope() {
 		return scopeStack[scopeStack.length - 1];

package/dist/plugins/strip-server-exports.js

@@ -13,7 +13,8 @@ const SERVER_EXPORTS = new Set([
 const SERVER_PROPS_SSG_CONFLICT = "You can not use getStaticProps or getStaticPaths with getServerSideProps. To use SSG, please remove getServerSideProps";
 const EXPORT_ALL_IN_PAGE_ERROR = "Using `export * from '...'` in a page is disallowed. Please use `export { default } from '...'` instead.\nRead more: https://nextjs.org/docs/messages/export-all-in-page";
 function hasServerExportCandidate(code) {
-	return [...SERVER_EXPORTS].some((name) => code.includes(name));
+	for (const name of SERVER_EXPORTS) if (code.includes(name)) return true;
+	return false;
 }
 function hasExportAllCandidate(code) {
 	let searchFrom = 0;

package/dist/server/accept-encoding.d.ts

@@ -0,0 +1,29 @@
+import { IncomingMessage } from "node:http";
+
+//#region src/server/accept-encoding.d.ts
+type ContentEncoding = "zstd" | "br" | "gzip" | "deflate";
+type NegotiatedEncoding = ContentEncoding | "identity";
+/** Parsed explicit coding qualities plus the wildcard quality, when present. */
+type ParsedAcceptEncoding = {
+  qualities: Map<string, number>;
+  orders: Map<string, number>;
+  wildcardQuality: number | null;
+};
+/** Parse an Accept-Encoding header into exact-token numeric qualities. */
+declare function parseAcceptedEncodings(accept: string): ParsedAcceptEncoding;
+/** Return the effective quality for a coding, including wildcard/identity rules. */
+declare function getEncodingQuality(parsed: ParsedAcceptEncoding, encoding: string): number;
+declare function isEncodingAccepted(parsed: ParsedAcceptEncoding, encoding: string): boolean;
+/** Choose the highest-quality available coding, using array order as the tie-breaker. */
+declare function selectAcceptedEncoding<T extends string>(parsed: ParsedAcceptEncoding, available: readonly T[]): T | null;
+/**
+ * Select a content coding while matching Next.js's compression middleware:
+ * an explicit identity preference can win, but implicit identity remains a
+ * fallback rather than suppressing an otherwise acceptable encoding.
+ */
+declare function selectContentEncoding<T extends ContentEncoding>(parsed: ParsedAcceptEncoding, available: readonly T[]): T | "identity";
+declare const HAS_ZSTD: boolean;
+/** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
+declare function negotiateEncoding(req: IncomingMessage): NegotiatedEncoding;
+//#endregion
+export { HAS_ZSTD, NegotiatedEncoding, ParsedAcceptEncoding, getEncodingQuality, isEncodingAccepted, negotiateEncoding, parseAcceptedEncodings, selectAcceptedEncoding, selectContentEncoding };

package/dist/server/accept-encoding.js

@@ -0,0 +1,95 @@
+import zlib from "node:zlib";
+//#region src/server/accept-encoding.ts
+/** Parse an Accept-Encoding header into exact-token numeric qualities. */
+function parseAcceptedEncodings(accept) {
+	const qualities = /* @__PURE__ */ new Map();
+	const orders = /* @__PURE__ */ new Map();
+	let wildcardQuality = null;
+	for (const [order, part] of accept.split(",").entries()) {
+		const trimmed = part.trim();
+		if (trimmed.length === 0) continue;
+		const semi = trimmed.indexOf(";");
+		const token = (semi === -1 ? trimmed : trimmed.slice(0, semi)).trim().toLowerCase();
+		if (token.length === 0) continue;
+		let quality = 1;
+		if (semi !== -1) {
+			let qStr;
+			for (const param of trimmed.slice(semi + 1).split(";")) {
+				const [name, value] = param.trim().split("=");
+				if (name !== "q") continue;
+				qStr = value ?? "";
+				break;
+			}
+			if (qStr !== void 0) quality = Number.parseFloat(qStr);
+		}
+		if (token === "*") {
+			if (wildcardQuality === null || Number.isNaN(quality) || Number.isNaN(wildcardQuality) || quality >= wildcardQuality) wildcardQuality = quality;
+		} else {
+			const currentQuality = qualities.get(token);
+			if (currentQuality === void 0 || Number.isNaN(quality) || Number.isNaN(currentQuality) || quality >= currentQuality) {
+				qualities.set(token, quality);
+				orders.set(token, order);
+			}
+		}
+	}
+	return {
+		qualities,
+		orders,
+		wildcardQuality
+	};
+}
+/** Return the effective quality for a coding, including wildcard/identity rules. */
+function getEncodingQuality(parsed, encoding) {
+	const normalized = encoding.toLowerCase();
+	const explicit = parsed.qualities.get(normalized);
+	if (explicit !== void 0) return Number.isNaN(explicit) ? 0 : explicit;
+	if (normalized === "identity") return parsed.wildcardQuality === 0 ? 0 : 1;
+	if (parsed.wildcardQuality !== null) return Number.isNaN(parsed.wildcardQuality) ? 0 : parsed.wildcardQuality;
+	return 0;
+}
+function isEncodingAccepted(parsed, encoding) {
+	return getEncodingQuality(parsed, encoding) > 0;
+}
+/** Choose the highest-quality available coding, using array order as the tie-breaker. */
+function selectAcceptedEncoding(parsed, available) {
+	let selected = null;
+	let selectedQuality = 0;
+	for (const encoding of available) {
+		const quality = getEncodingQuality(parsed, encoding);
+		if (quality > selectedQuality) {
+			selected = encoding;
+			selectedQuality = quality;
+		}
+	}
+	return selected;
+}
+/**
+* Select a content coding while matching Next.js's compression middleware:
+* an explicit identity preference can win, but implicit identity remains a
+* fallback rather than suppressing an otherwise acceptable encoding.
+*/
+function selectContentEncoding(parsed, available) {
+	const selected = selectAcceptedEncoding(parsed, available);
+	if (selected === null) return "identity";
+	const identityQuality = parsed.qualities.get("identity");
+	if (identityQuality === void 0 || Number.isNaN(identityQuality)) return selected;
+	const selectedQuality = getEncodingQuality(parsed, selected);
+	if (identityQuality > selectedQuality) return "identity";
+	if (identityQuality < selectedQuality) return selected;
+	if (!parsed.qualities.has(selected)) return "identity";
+	return (parsed.orders.get("identity") ?? Number.POSITIVE_INFINITY) < (parsed.orders.get(selected) ?? Number.POSITIVE_INFINITY) ? "identity" : selected;
+}
+const HAS_ZSTD = typeof zlib.createZstdCompress === "function";
+/** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
+function negotiateEncoding(req) {
+	const accept = req.headers["accept-encoding"];
+	if (typeof accept !== "string") return "identity";
+	return selectContentEncoding(parseAcceptedEncodings(accept), [
+		...HAS_ZSTD ? ["zstd"] : [],
+		"br",
+		"gzip",
+		"deflate"
+	]);
+}
+//#endregion
+export { HAS_ZSTD, getEncodingQuality, isEncodingAccepted, negotiateEncoding, parseAcceptedEncodings, selectAcceptedEncoding, selectContentEncoding };

package/dist/server/app-action-request.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/app-action-request.d.ts
+declare function isPossibleAppRouteActionRequest(request: Pick<Request, "headers" | "method">): boolean;
+//#endregion
+export { isPossibleAppRouteActionRequest };

package/dist/server/app-action-request.js

@@ -0,0 +1,9 @@
+import "./headers.js";
+//#region src/server/app-action-request.ts
+function isPossibleAppRouteActionRequest(request) {
+	if (request.method.toUpperCase() !== "POST") return false;
+	const contentType = request.headers.get("content-type");
+	return request.headers.has("x-rsc-action") || request.headers.has("next-action") || contentType === "application/x-www-form-urlencoded" || contentType?.startsWith("multipart/form-data") === true;
+}
+//#endregion
+export { isPossibleAppRouteActionRequest };

package/dist/server/app-bfcache-identity.d.ts

@@ -1,13 +1,23 @@
-import { AppElements } from "./app-elements-wire.js";
+import { AppElements, AppElementsWire } from "./app-elements-wire.js";
 import { BfcacheIdMap } from "./app-history-state.js";
 
 //#region src/server/app-bfcache-identity.d.ts
 type BfcacheStateKeyMap = Readonly<Record<string, string>>;
+type InitialBfcacheMaps = Readonly<{
+  bfcacheIds: BfcacheIdMap;
+  stateKeys: BfcacheStateKeyMap;
+}>;
+type AppElementsMetadata = ReturnType<typeof AppElementsWire.readMetadata>;
 declare function createInitialBfcacheIdMap(elements: AppElements): BfcacheIdMap;
 declare function createBfcacheSegmentStateKeyMap(options: {
   elements: AppElements;
   pathname: string;
 }): BfcacheStateKeyMap;
+declare function createInitialBfcacheMaps(options: {
+  elements: AppElements;
+  metadata: AppElementsMetadata;
+  pathname: string;
+}): InitialBfcacheMaps;
 declare function createNextBfcacheIdMap(options: {
   current: BfcacheIdMap;
   currentElements: AppElements;
@@ -23,4 +33,4 @@ declare function preserveBfcacheIdsForMergedElements(options: {
   previous: BfcacheIdMap;
 }): BfcacheIdMap;
 //#endregion
-export { BfcacheStateKeyMap, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };
+export { BfcacheStateKeyMap, InitialBfcacheMaps, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createInitialBfcacheMaps, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements };