vinext 0.1.5 → 0.1.6

package/dist/init.d.ts

@@ -10,7 +10,7 @@
  *   4. Rename CJS config files to .cjs
  *   5. Add vinext scripts to package.json
  *   6. Generate vite.config.ts
- *   7. Update .gitignore to include /dist/
+ *   7. Update .gitignore to include /dist/ and .vinext/
  *   8. Print summary
  *
  * Non-destructive: does NOT modify next.config, tsconfig, or source files.
@@ -32,7 +32,7 @@ type InitResult = {
   renamedConfigs: Array<[string, string]>; /** Whether scripts were added to package.json */
   addedScripts: string[]; /** Whether vite.config.ts was generated */
   generatedViteConfig: boolean; /** Whether vite.config.ts generation was skipped (already exists) */
-  skippedViteConfig: boolean; /** Whether .gitignore was updated to include /dist/ */
+  skippedViteConfig: boolean; /** Whether .gitignore was updated to include vinext-generated output */
   updatedGitignore: boolean;
 };
 declare function generateViteConfig(_isAppRouter: boolean): string;
@@ -59,8 +59,9 @@ declare function isDepInstalled(root: string, dep: string): boolean;
  */
 declare function getReactUpgradeDeps(root: string): string[];
 /**
- * Ensure /dist/ is listed in .gitignore. Creates the file if it doesn't exist.
- * Returns true if the file was modified (or created), false if /dist/ was already present.
+ * Ensure vinext-generated output directories are listed in .gitignore.
+ * Creates the file if it doesn't exist. Returns true if the file was modified
+ * (or created), false if all entries were already present.
  */
 declare function updateGitignore(root: string): boolean;
 declare function init(options: InitOptions): Promise<InitResult>;

package/dist/init.js

@@ -16,7 +16,7 @@ import { execFileSync } from "node:child_process";
 *   4. Rename CJS config files to .cjs
 *   5. Add vinext scripts to package.json
 *   6. Generate vite.config.ts
-*   7. Update .gitignore to include /dist/
+*   7. Update .gitignore to include /dist/ and .vinext/
 *   8. Print summary
 *
 * Non-destructive: does NOT modify next.config, tsconfig, or source files.
@@ -140,20 +140,39 @@ function installDeps(root, deps, exec, { dev = true } = {}) {
 	});
 }
 /**
-* Ensure /dist/ is listed in .gitignore. Creates the file if it doesn't exist.
-* Returns true if the file was modified (or created), false if /dist/ was already present.
+* Ensure vinext-generated output directories are listed in .gitignore.
+* Creates the file if it doesn't exist. Returns true if the file was modified
+* (or created), false if all entries were already present.
 */
 function updateGitignore(root) {
 	const gitignorePath = path.join(root, ".gitignore");
-	const exactEntry = "/dist/";
+	const entries = [{
+		entry: "/dist/",
+		coveredBy: new Set([
+			"/dist/",
+			"/dist",
+			"dist/",
+			"dist"
+		])
+	}, {
+		entry: ".vinext/",
+		coveredBy: new Set([
+			"/.vinext/",
+			"/.vinext",
+			".vinext/",
+			".vinext"
+		])
+	}];
 	let content = "";
+	let lines = [];
 	if (fs.existsSync(gitignorePath)) {
 		content = fs.readFileSync(gitignorePath, "utf-8");
-		const lines = content.split("\n").map((l) => l.trim());
-		if (lines.includes(exactEntry) || lines.includes("dist/") || lines.includes("dist")) return false;
+		lines = content.split("\n").map((l) => l.trim());
 	}
+	const missingEntries = entries.filter(({ coveredBy }) => !lines.some((line) => coveredBy.has(line))).map(({ entry }) => entry);
+	if (missingEntries.length === 0) return false;
 	const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-	fs.writeFileSync(gitignorePath, content + separator + "/dist/\n", "utf-8");
+	fs.writeFileSync(gitignorePath, content + separator + missingEntries.join("\n") + "\n", "utf-8");
 	return true;
 }
 async function init(options) {
@@ -212,7 +231,7 @@ async function init(options) {
 	for (const script of addedScripts) console.log(`    \u2713 Added ${script} script`);
 	if (generatedViteConfig) console.log(`    \u2713 Generated vite.config.ts`);
 	if (skippedViteConfig) console.log(`    - Skipped vite.config.ts (already exists, use --force to overwrite)`);
-	if (updatedGitignore) console.log(`    \u2713 Added /dist/ to .gitignore`);
+	if (updatedGitignore) console.log(`    \u2713 Added vinext output directories to .gitignore`);
 	console.log(`
   Next steps:
     ${pmName} run dev:vinext    Start the vinext dev server

package/dist/plugins/fonts.js

@@ -4,6 +4,7 @@ import { buildFallbackFontFace, getFallbackFontOverrideMetrics } from "../build/
 import { validateGoogleFontOptions } from "../build/google-fonts/validate.js";
 import { getFontAxes } from "../build/google-fonts/get-axes.js";
 import { buildGoogleFontsUrl } from "../build/google-fonts/build-url.js";
+import { findFontFilesInCss } from "../build/google-fonts/find-font-files-in-css.js";
 import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
 import { CONTENT_TYPES } from "../server/static-file-cache.js";
 import fs from "node:fs";
@@ -543,11 +544,12 @@ function createGoogleFontsPlugin(fontGoogleShimPath, shimsDir) {
 						return;
 					}
 					const servedCSS = _rewriteCachedFontCssToServedUrls(localCSS, cacheDir, transformAssetsDir);
+					const preloadUrls = findFontFilesInCss(servedCSS, validated.preload ? validated.subsets : void 0).filter((file) => file.preloadFontFile).map((file) => file.googleFontFileUrl);
 					const fallbackMetrics = validated.adjustFontFallback === false ? void 0 : getFallbackFontOverrideMetrics(family);
 					const adjustedFallbackCSS = fallbackMetrics ? buildFallbackFontFace(family, fallbackMetrics) : void 0;
 					const validatedFontWeight = validated.weights.length === 1 && validated.weights[0] !== "variable" ? Number(validated.weights[0]) : void 0;
 					const validatedFontStyle = validated.styles.length === 1 ? validated.styles[0] : void 0;
-					const internalFontProperties = [`selfHostedCSS: ${JSON.stringify(servedCSS)}`];
+					const internalFontProperties = [`selfHostedCSS: ${JSON.stringify(servedCSS)}`, `preloadUrls: ${JSON.stringify(preloadUrls)}`];
 					if (adjustedFallbackCSS) internalFontProperties.push(`adjustedFallbackCSS: ${JSON.stringify(adjustedFallbackCSS)}`);
 					if (Number.isFinite(validatedFontWeight)) internalFontProperties.push(`fontWeight: ${validatedFontWeight}`);
 					if (validatedFontStyle) internalFontProperties.push(`fontStyle: ${JSON.stringify(validatedFontStyle)}`);

package/dist/plugins/middleware-export-validation.d.ts

@@ -0,0 +1,5 @@
+//#region src/plugins/middleware-export-validation.d.ts
+declare function hasValidMiddlewareModuleExport(source: string, id: string, isProxy: boolean): boolean;
+declare function validateMiddlewareModuleExports(source: string, id: string, filePath: string, isProxy: boolean): void;
+//#endregion
+export { hasValidMiddlewareModuleExport, validateMiddlewareModuleExports };

package/dist/plugins/middleware-export-validation.js

@@ -0,0 +1,36 @@
+import { stripViteModuleQuery } from "../utils/path.js";
+import { createMiddlewareMissingExportError } from "../server/middleware-runtime.js";
+import { parseAst } from "vite";
+//#region src/plugins/middleware-export-validation.ts
+function parserLanguage(id) {
+	const cleanId = stripViteModuleQuery(id).toLowerCase();
+	if (cleanId.endsWith(".tsx")) return "tsx";
+	if (cleanId.endsWith(".ts") || cleanId.endsWith(".mts") || cleanId.endsWith(".cts")) return "ts";
+	return "jsx";
+}
+function astName(value) {
+	if (!value) return null;
+	if (typeof value.name === "string") return value.name;
+	if (typeof value.value === "string") return value.value;
+	return null;
+}
+function hasValidMiddlewareModuleExport(source, id, isProxy) {
+	const ast = parseAst(source, { lang: parserLanguage(id) });
+	const expectedExport = isProxy ? "proxy" : "middleware";
+	for (const statement of ast.body) {
+		if (statement.type === "ExportDefaultDeclaration") return true;
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		const declaration = statement.declaration;
+		if (declaration?.type === "FunctionDeclaration" && astName(declaration.id) === expectedExport) return true;
+		if (declaration?.type === "VariableDeclaration") {
+			for (const declarator of declaration.declarations ?? []) if (astName(declarator.id) === expectedExport) return true;
+		}
+		for (const specifier of statement.specifiers ?? []) if (astName(specifier.exported ?? specifier.local) === expectedExport) return true;
+	}
+	return false;
+}
+function validateMiddlewareModuleExports(source, id, filePath, isProxy) {
+	if (!hasValidMiddlewareModuleExport(source, id, isProxy)) throw createMiddlewareMissingExportError(filePath, isProxy);
+}
+//#endregion
+export { hasValidMiddlewareModuleExport, validateMiddlewareModuleExports };

package/dist/plugins/og-asset-ownership.d.ts

@@ -0,0 +1,27 @@
+import { Alias } from "vite";
+
+//#region src/plugins/og-asset-ownership.d.ts
+type OgAssetModuleBoundary = {
+  assetRoot: string;
+  moduleDir: string;
+};
+declare class OgAssetOwnership {
+  private projectRoot;
+  private readonly linkedPackageRoots;
+  private readonly dependencyPackageNames;
+  private readonly stringAliasesByFirstCharacter;
+  private regularExpressionAliases;
+  private configuredAliases;
+  configure(projectRoot: string, aliases: readonly Alias[]): void;
+  reset(): void;
+  shouldTrackImport(source: string): boolean;
+  recordResolvedImport(source: string, resolvedId: string): Promise<void>;
+  resolveModuleBoundary(moduleId: string): Promise<OgAssetModuleBoundary | null>;
+  resolveContainedAsset(assetRoot: string, assetPath: string): Promise<string | null>;
+  private findAlias;
+  private getExpectedPackageName;
+  private resolveAliasPackageRoot;
+  private resolveConfiguredAliasRoot;
+}
+//#endregion
+export { OgAssetModuleBoundary, OgAssetOwnership };

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);
+				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 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;

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