vinext 0.1.4 → 0.1.6

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,64 +16,83 @@ 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 transform(code, id) {
-			if (!code.includes("import.meta.url")) return null;
-			const useCache = isBuild;
-			const moduleDir = path.dirname(id);
-			let newCode = code;
-			let didReplace = false;
-			const readAsBase64 = async (absPath) => {
-				const cached = useCache ? cache.get(absPath) : void 0;
-				if (cached !== void 0) return cached;
-				try {
-					const b64 = (await fs.promises.readFile(absPath)).toString("base64");
-					if (useCache) cache.set(absPath, b64);
-					return b64;
-				} catch {
-					return null;
+		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 boundary = await ownership.resolveModuleBoundary(id);
+				if (boundary === null) return null;
+				const { assetRoot, moduleDir } = boundary;
+				let newCode = code;
+				let didReplace = false;
+				const readAsBase64 = async (absPath) => {
+					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(realPath)).toString("base64");
+						if (useCache) cache.set(realPath, b64);
+						return b64;
+					} catch {
+						return null;
+					}
+				};
+				if (code.includes("fetch(")) for (const match of code.matchAll(/fetch\(\s*new URL\(\s*(["'])(\.[^"']+)\1\s*,\s*import\.meta\.url\s*\)\s*\)(?:\.then\(\s*(?:function\s*\([^)]*\)|\([^)]*\)\s*=>)\s*\{?\s*return\s+[^.]+\.arrayBuffer\(\)\s*;?\s*\}?\s*,?\s*\)|\.then\(\s*\([^)]*\)\s*=>\s*[^.]+\.arrayBuffer\(\)\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 = [
+						`(function(){`,
+						`var b=${JSON.stringify(fileBase64)};`,
+						`var r=atob(b);`,
+						`var a=new Uint8Array(r.length);`,
+						`for(var i=0;i<r.length;i++)a[i]=r.charCodeAt(i);`,
+						`return Promise.resolve(a.buffer);`,
+						`})()`
+					].join("");
+					newCode = newCode.replaceAll(fullMatch, inlined);
+					didReplace = true;
 				}
-			};
-			if (code.includes("fetch(")) for (const match of code.matchAll(/fetch\(\s*new URL\(\s*(["'])(\.[^"']+)\1\s*,\s*import\.meta\.url\s*\)\s*\)(?:\.then\(\s*(?:function\s*\([^)]*\)|\([^)]*\)\s*=>)\s*\{?\s*return\s+[^.]+\.arrayBuffer\(\)\s*;?\s*\}?\s*,?\s*\)|\.then\(\s*\([^)]*\)\s*=>\s*[^.]+\.arrayBuffer\(\)\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 = [
-					`(function(){`,
-					`var b=${JSON.stringify(fileBase64)};`,
-					`var r=atob(b);`,
-					`var a=new Uint8Array(r.length);`,
-					`for(var i=0;i<r.length;i++)a[i]=r.charCodeAt(i);`,
-					`return Promise.resolve(a.buffer);`,
-					`})()`
-				].join("");
-				newCode = newCode.replaceAll(fullMatch, 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)) {
-				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);
-				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)) {
+					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);
+					didReplace = true;
+				}
+				if (!didReplace) return null;
+				return {
+					code: newCode,
+					map: null
+				};
 			}
-			if (!didReplace) return null;
-			return {
-				code: newCode,
-				map: null
-			};
 		}
 	};
 }

package/dist/plugins/optimize-imports.js

@@ -1,5 +1,6 @@
 import { normalizePathSeparators } from "../utils/path.js";
 import { escapeRegExp } from "../utils/regex.js";
+import { VIRTUAL_MODULE_ID_RE } from "../utils/virtual-module.js";
 import { getAstName } from "./ast-utils.js";
 import { createRequire } from "node:module";
 import path from "node:path";
@@ -445,12 +446,17 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 			return await this.resolve(source, barrelEntry, { skipSelf: true }) ?? void 0;
 		},
 		transform: {
-			filter: { id: { include: /\.(tsx?|jsx?|mjs)$/ } },
-			async handler(code, id) {
+			filter: {
+				id: {
+					include: /\.(tsx?|jsx?|mjs)$/,
+					exclude: VIRTUAL_MODULE_ID_RE
+				},
+				code: /\bimport\b[\s\S]*\bfrom\b/
+			},
+			async handler(code) {
 				const env = this.environment;
 				if (env?.name === "client") return null;
 				const preferReactServer = env?.name === "rsc";
-				if (id.startsWith("\0")) return null;
 				const packages = optimizedPackages;
 				if (!hasOptimizedImportSource(code)) return null;
 				let ast;

package/dist/plugins/remove-console.d.ts

@@ -1,7 +1,13 @@
+import MagicString from "magic-string";
+
 //#region src/plugins/remove-console.d.ts
 type RemoveConsoleConfig = boolean | {
   exclude: string[];
 };
+type RemoveConsoleResult = {
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+};
 /**
  * Walk the AST body looking for expression statements whose expression is a
  * CallExpression with a callee of `console.<identifier>`. When found, check
@@ -10,6 +16,6 @@ type RemoveConsoleConfig = boolean | {
  *
  * Returns `null` if no console calls are removed.
  */
-declare function removeConsoleCalls(code: string, config: RemoveConsoleConfig): string | null;
+declare function removeConsoleCalls(code: string, config: RemoveConsoleConfig): RemoveConsoleResult | null;
 //#endregion
 export { removeConsoleCalls };

package/dist/plugins/remove-console.js

@@ -168,7 +168,10 @@ function removeConsoleCalls(code, config) {
 	}
 	for (const node of ast.body) walk(node);
 	if (!changed) return null;
-	return s.toString();
+	return {
+		code: s.toString(),
+		map: s.generateMap({ hires: "boundary" })
+	};
 }
 //#endregion
 export { removeConsoleCalls };

package/dist/plugins/require-context.js

@@ -16,30 +16,31 @@ function createRequireContextPlugin() {
 	return {
 		name: "vinext:require-context",
 		enforce: "pre",
-		transform(code, id) {
-			if (!mayContainRequireContext(code)) return null;
-			const lang = langForId(id);
-			if (!lang) return null;
-			let ast;
-			try {
-				ast = parseAst(code, { lang });
-			} catch {
-				return null;
+		transform: {
+			filter: {
+				id: /\.(?:[cm]?[jt]s|[jt]sx)(?:\?.*)?$/i,
+				code: /\brequire\b[\s\S]*\.context/
+			},
+			handler(code, id) {
+				const lang = langForId(id);
+				let ast;
+				try {
+					ast = parseAst(code, { lang });
+				} catch {
+					return null;
+				}
+				const calls = collectRequireContextCalls(ast);
+				if (calls.length === 0) return null;
+				const output = new MagicString(code);
+				for (const call of calls) output.overwrite(call.range.start, call.range.end, buildReplacement(call));
+				return {
+					code: output.toString(),
+					map: output.generateMap({ hires: "boundary" })
+				};
 			}
-			const calls = collectRequireContextCalls(ast);
-			if (calls.length === 0) return null;
-			const output = new MagicString(code);
-			for (const call of calls) output.overwrite(call.range.start, call.range.end, buildReplacement(call));
-			return {
-				code: output.toString(),
-				map: output.generateMap({ hires: "boundary" })
-			};
 		}
 	};
 }
-function mayContainRequireContext(code) {
-	return code.includes("require") && code.includes(".context");
-}
 function langForId(id) {
 	const clean = id.split("?", 1)[0];
 	const dot = clean.lastIndexOf(".");

package/dist/plugins/strip-server-exports.d.ts

@@ -1,7 +1,13 @@
+import MagicString from "magic-string";
+
 //#region src/plugins/strip-server-exports.d.ts
 declare function hasServerExportCandidate(code: string): boolean;
 declare function hasExportAllCandidate(code: string): boolean;
 declare function validatePageExports(code: string): void;
+type StripServerExportsResult = {
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+};
 /**
  * Strip server-only Pages Router data-fetching exports and their unique
  * dependency graph from browser bundles.
@@ -10,6 +16,6 @@ declare function validatePageExports(code: string): void;
  * - test/unit/babel-plugin-next-ssg-transform.test.ts
  * - crates/next-custom-transforms/src/transforms/strip_page_exports.rs
  */
-declare function stripServerExports(code: string): string | null;
+declare function stripServerExports(code: string): StripServerExportsResult | null;
 //#endregion
 export { hasExportAllCandidate, hasServerExportCandidate, stripServerExports, validatePageExports };

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

@@ -509,7 +509,10 @@ function stripServerExports(code) {
 		string.overwrite(edit.start, edit.end, edit.replacement);
 		lastStart = edit.start;
 	}
-	return string.toString();
+	return {
+		code: string.toString(),
+		map: string.generateMap({ hires: "boundary" })
+	};
 }
 //#endregion
 export { hasExportAllCandidate, hasServerExportCandidate, stripServerExports, validatePageExports };

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