@qzsy/vinext 0.1.7

package/dist/plugins/import-meta-url.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from "vite";
+import MagicString from "magic-string";
+
+//#region src/plugins/import-meta-url.d.ts
+type ImportMetaUrlEnvironment = "client" | "server";
+type RewriteResult = {
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+};
+declare function createImportMetaUrlPlugin(options: {
+  getRoot: () => string | undefined;
+}): Plugin;
+declare function rewriteImportMetaUrl(code: string, id: string, root: string, environment: ImportMetaUrlEnvironment): RewriteResult | null;
+declare function rewriteServerCjsGlobals(code: string, id: string, root: string): RewriteResult | null;
+//#endregion
+export { createImportMetaUrlPlugin, rewriteImportMetaUrl, rewriteServerCjsGlobals };

package/dist/plugins/import-meta-url.js

@@ -0,0 +1,353 @@
+import { VIRTUAL_MODULE_ID_RE } from "../utils/virtual-module.js";
+import { collectBindingNames, forEachAstChild, hasRange, isAstRecord, isIdentifierNamed, nodeArray } from "./ast-utils.js";
+import { tryRealpathSync } from "../build/ssr-manifest.js";
+import path from "node:path";
+import { normalizePath, parseAst } from "vite";
+import { pathToFileURL } from "node:url";
+import MagicString from "magic-string";
+//#region src/plugins/import-meta-url.ts
+const TRANSFORMABLE_SCRIPT_EXTENSIONS = new Set([
+	".cjs",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".ts",
+	".tsx"
+]);
+function createImportMetaUrlPlugin(options) {
+	let rootPaths;
+	let outputDirs = [];
+	function getRootPaths() {
+		const root = options.getRoot();
+		if (!root) return rootPaths;
+		if (!rootPaths || rootPaths.root !== root) rootPaths = createRootPaths(root, { outputDirs });
+		return rootPaths;
+	}
+	return {
+		name: "vinext:import-meta-url",
+		enforce: "post",
+		configResolved(config) {
+			const root = options.getRoot() ?? config.root;
+			outputDirs = [config.build.outDir];
+			rootPaths = createRootPaths(root, { outputDirs });
+		},
+		transform: {
+			filter: {
+				id: {
+					include: /\.(?:[cm]?[jt]s|[jt]sx)(?:\?.*)?$/,
+					exclude: [/[\\/]node_modules[\\/]/, VIRTUAL_MODULE_ID_RE]
+				},
+				code: /import\.meta(?:\.|\?\.)url|__filename|__dirname/
+			},
+			handler(code, id) {
+				const paths = getRootPaths();
+				if (!paths) return null;
+				const canonicalId = transformableModuleCanonicalId(cleanModuleId(id), paths);
+				if (!canonicalId) return null;
+				const rewritten = rewriteCanonicalSourceIdentity(code, canonicalId, paths, this.environment?.name === "client" ? "client" : "server");
+				if (!rewritten) return null;
+				return {
+					code: rewritten.code,
+					map: rewritten.map
+				};
+			}
+		}
+	};
+}
+function rewriteImportMetaUrl(code, id, root, environment) {
+	if (!mayContainImportMetaUrl(code)) return null;
+	return rewriteCanonicalSourceIdentity(code, canonicalizePath(id), createRootPaths(root), environment);
+}
+function rewriteServerCjsGlobals(code, id, root) {
+	if (!mayContainServerCjsGlobal(code)) return null;
+	const rootPaths = createRootPaths(root);
+	const canonicalId = transformableModuleCanonicalId(id, rootPaths);
+	if (!canonicalId) return null;
+	return rewriteCanonicalSourceIdentity(code, canonicalId, rootPaths, "server");
+}
+function rewriteCanonicalSourceIdentity(code, canonicalId, rootPaths, environment) {
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return null;
+	}
+	const output = new MagicString(code);
+	let changed = false;
+	if (mayContainImportMetaUrl(code)) {
+		const importMetaRanges = collectImportMetaUrlRanges(ast);
+		if (importMetaRanges.length > 0) {
+			const replacement = JSON.stringify(importMetaUrlValue(canonicalId, rootPaths, environment));
+			for (const range of importMetaRanges) {
+				output.overwrite(range.start, range.end, replacement);
+				changed = true;
+			}
+		}
+	}
+	if (environment === "server" && mayContainServerCjsGlobal(code)) {
+		const injected = injectServerCjsGlobals(ast, canonicalId);
+		if (injected) {
+			output.appendLeft(findDirectivePrologueEnd(ast), `\n${injected}`);
+			changed = true;
+		}
+	}
+	if (!changed) return null;
+	return {
+		code: output.toString(),
+		map: output.generateMap({ hires: "boundary" })
+	};
+}
+function cleanModuleId(id) {
+	return id.split("?", 1)[0];
+}
+function createRootPaths(root, options = {}) {
+	const canonicalRoot = canonicalizePath(root);
+	const normalizedRoot = normalizePath(canonicalRoot);
+	return {
+		root,
+		canonicalRoot,
+		normalizedRoot,
+		excludedRelativePrefixes: excludedRelativePrefixes(canonicalRoot, normalizedRoot, options)
+	};
+}
+function transformableModuleCanonicalId(id, rootPaths) {
+	if (!id || id.startsWith("\0")) return null;
+	if (!path.isAbsolute(id)) return null;
+	const normalizedInputId = normalizePath(id);
+	if (normalizedInputId.includes("/node_modules/")) return null;
+	if (!TRANSFORMABLE_SCRIPT_EXTENSIONS.has(path.extname(normalizedInputId))) return null;
+	const canonicalId = canonicalizePath(id);
+	if (!isPathWithin(normalizePath(canonicalId), rootPaths.normalizedRoot)) return null;
+	if (isExcludedRelativePath(normalizePath(path.relative(rootPaths.canonicalRoot, canonicalId)), rootPaths.excludedRelativePrefixes)) return null;
+	return canonicalId;
+}
+function mayContainImportMetaUrl(code) {
+	return code.includes("import.meta.url") || code.includes("import.meta?.url");
+}
+function mayContainServerCjsGlobal(code) {
+	return code.includes("__filename") || code.includes("__dirname");
+}
+function excludedRelativePrefixes(canonicalRoot, normalizedRoot, options) {
+	const prefixes = new Set([
+		".next",
+		".vinext",
+		".vinext-local-package",
+		"dist",
+		"out"
+	]);
+	for (const outputDir of options.outputDirs ?? []) {
+		const canonicalOutputDir = canonicalizePath(path.isAbsolute(outputDir) ? outputDir : path.resolve(canonicalRoot, outputDir));
+		if (!isPathWithin(normalizePath(canonicalOutputDir), normalizedRoot)) continue;
+		const relativePath = normalizePath(path.relative(canonicalRoot, canonicalOutputDir));
+		if (relativePath && relativePath !== ".") prefixes.add(relativePath);
+	}
+	return [...prefixes];
+}
+function isExcludedRelativePath(relativePath, prefixes) {
+	return prefixes.some((prefix) => relativePath === prefix || relativePath.startsWith(`${prefix}/`));
+}
+function isPathWithin(candidate, root) {
+	return candidate === root || candidate.startsWith(root.endsWith("/") ? root : `${root}/`);
+}
+function importMetaUrlValue(canonicalId, rootPaths, environment) {
+	if (environment === "client") return `file:///ROOT/${normalizePath(path.relative(rootPaths.canonicalRoot, canonicalId))}`;
+	return pathToFileURL(canonicalId).href;
+}
+function canonicalizePath(value) {
+	return tryRealpathSync(value) ?? path.resolve(value);
+}
+function collectImportMetaUrlRanges(ast) {
+	const ranges = [];
+	function visit(value) {
+		if (!isAstRecord(value)) return;
+		if (isImportMetaUrlNode(value)) {
+			ranges.push({
+				start: value.start,
+				end: value.end
+			});
+			return;
+		}
+		if (isChainExpressionWrappingImportMetaUrl(value)) {
+			ranges.push({
+				start: value.start,
+				end: value.end
+			});
+			return;
+		}
+		if (isNewUrlExpression(value)) {
+			const args = nodeArray(value.arguments);
+			for (let index = 0; index < args.length; index += 1) {
+				if (index === 1 && isImportMetaUrlOrChainedNode(args[index])) continue;
+				visit(args[index]);
+			}
+			return;
+		}
+		forEachAstChild(value, visit);
+	}
+	visit(ast);
+	return ranges;
+}
+const CJS_GLOBALS = ["__filename", "__dirname"];
+function isCjsGlobalName(name) {
+	return name === "__filename" || name === "__dirname";
+}
+function injectServerCjsGlobals(ast, canonicalId) {
+	const analysis = analyzeServerCjsGlobals(ast);
+	const values = {
+		__filename: canonicalId,
+		__dirname: path.dirname(canonicalId)
+	};
+	const parts = CJS_GLOBALS.filter((name) => analysis.reads.has(name) && !analysis.moduleBindings.has(name)).map((name) => `var ${name} = ${JSON.stringify(values[name])};`);
+	return parts.length ? parts.join("") : null;
+}
+function analyzeServerCjsGlobals(ast) {
+	const reads = /* @__PURE__ */ new Set();
+	const moduleBindings = /* @__PURE__ */ new Set();
+	function recordBinding(pattern) {
+		const names = /* @__PURE__ */ new Set();
+		collectBindingNames(pattern, names);
+		for (const name of names) if (isCjsGlobalName(name)) moduleBindings.add(name);
+	}
+	function recordDirectTopLevelBindings(statement) {
+		switch (statement.type) {
+			case "ImportDeclaration":
+				for (const specifier of nodeArray(statement.specifiers)) {
+					if (!isAstRecord(specifier)) continue;
+					recordBinding(specifier.local);
+				}
+				return;
+			case "VariableDeclaration":
+				if (statement.kind === "var") return;
+				for (const declarator of nodeArray(statement.declarations)) {
+					if (!isAstRecord(declarator) || declarator.type !== "VariableDeclarator") continue;
+					recordBinding(declarator.id);
+				}
+				return;
+			case "FunctionDeclaration":
+			case "ClassDeclaration":
+				recordBinding(statement.id);
+				return;
+			case "ExportNamedDeclaration":
+			case "ExportDefaultDeclaration":
+				if (isAstRecord(statement.declaration)) recordDirectTopLevelBindings(statement.declaration);
+				return;
+		}
+	}
+	function recordModuleScopedVarBindings(node) {
+		if (!isAstRecord(node)) return;
+		switch (node.type) {
+			case "Program":
+				for (const statement of nodeArray(node.body)) {
+					if (!isAstRecord(statement)) continue;
+					recordDirectTopLevelBindings(statement);
+					recordModuleScopedVarBindings(statement);
+				}
+				return;
+			case "VariableDeclaration":
+				if (node.kind !== "var") return;
+				for (const declarator of nodeArray(node.declarations)) {
+					if (!isAstRecord(declarator) || declarator.type !== "VariableDeclarator") continue;
+					recordBinding(declarator.id);
+				}
+				return;
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+			case "ClassDeclaration":
+			case "ClassExpression": return;
+			default: for (const child of moduleScopeChildren(node)) recordModuleScopedVarBindings(child);
+		}
+	}
+	function moduleScopeChildren(node) {
+		switch (node.type) {
+			case "BlockStatement": return nodeArray(node.body);
+			case "IfStatement": return [node.consequent, node.alternate];
+			case "SwitchStatement": return nodeArray(node.cases);
+			case "SwitchCase": return nodeArray(node.consequent);
+			case "TryStatement": return [
+				node.block,
+				node.handler,
+				node.finalizer
+			];
+			case "CatchClause": return [node.body];
+			case "LabeledStatement": return [node.body];
+			case "ForStatement": return [node.init, node.body];
+			case "ForInStatement":
+			case "ForOfStatement": return [node.left, node.body];
+			case "WhileStatement":
+			case "DoWhileStatement":
+			case "WithStatement": return [node.body];
+			case "ExportNamedDeclaration":
+			case "ExportDefaultDeclaration": return [node.declaration];
+			default: return [];
+		}
+	}
+	function recordReads(value) {
+		if (!isAstRecord(value)) return;
+		switch (value.type) {
+			case "Identifier":
+				if (isCjsGlobalName(value.name)) reads.add(value.name);
+				return;
+			case "MemberExpression":
+				recordReads(value.object);
+				if (value.computed) recordReads(value.property);
+				return;
+			case "Property":
+				if (value.computed) recordReads(value.key);
+				recordReads(value.value);
+				return;
+			case "MethodDefinition":
+			case "PropertyDefinition":
+				if (value.computed) recordReads(value.key);
+				recordReads(value.value);
+				return;
+			case "ImportDeclaration": return;
+			case "ExportAllDeclaration": return;
+			case "ExportNamedDeclaration":
+				if (isAstRecord(value.declaration)) recordReads(value.declaration);
+				else if (!value.source) {
+					for (const specifier of nodeArray(value.specifiers)) if (isAstRecord(specifier)) recordReads(specifier.local);
+				}
+				return;
+			default: forEachAstChild(value, recordReads);
+		}
+	}
+	if (isAstRecord(ast) && ast.type === "Program") recordModuleScopedVarBindings(ast);
+	recordReads(ast);
+	return {
+		reads,
+		moduleBindings
+	};
+}
+function isImportMetaNode(value) {
+	return isAstRecord(value) && value.type === "MetaProperty" && isIdentifierNamed(value.meta, "import") && isIdentifierNamed(value.property, "meta");
+}
+function isImportMetaUrlNode(value) {
+	return isAstRecord(value) && value.type === "MemberExpression" && hasRange(value) && isImportMetaNode(value.object) && isIdentifierNamed(value.property, "url");
+}
+function isImportMetaUrlOrChainedNode(value) {
+	if (isImportMetaUrlNode(value)) return true;
+	return isAstRecord(value) && value.type === "ChainExpression" && isImportMetaUrlNode(value.expression);
+}
+function isChainExpressionWrappingImportMetaUrl(value) {
+	return isAstRecord(value) && value.type === "ChainExpression" && hasRange(value) && isImportMetaUrlNode(value.expression);
+}
+function isNewUrlExpression(value) {
+	return value.type === "NewExpression" && isIdentifierNamed(value.callee, "URL");
+}
+function findDirectivePrologueEnd(ast) {
+	if (!isAstRecord(ast) || ast.type !== "Program") return 0;
+	let end = 0;
+	const hashbang = ast.hashbang;
+	const hashbangEnd = typeof hashbang === "object" && hashbang !== null ? Reflect.get(hashbang, "end") : null;
+	if (typeof hashbangEnd === "number") end = hashbangEnd;
+	for (const statement of nodeArray(ast.body)) {
+		if (!isAstRecord(statement) || statement.type !== "ExpressionStatement" || !isAstRecord(statement.expression) || statement.expression.type !== "Literal" || typeof statement.expression.value !== "string" || typeof statement.end !== "number") break;
+		end = statement.end;
+	}
+	return end;
+}
+//#endregion
+export { createImportMetaUrlPlugin, rewriteImportMetaUrl, rewriteServerCjsGlobals };

package/dist/plugins/instrumentation-client.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/instrumentation-client.d.ts
+declare function createInstrumentationClientTransformPlugin(getInstrumentationClientPath: () => string | null): Plugin;
+//#endregion
+export { createInstrumentationClientTransformPlugin };

package/dist/plugins/instrumentation-client.js

@@ -0,0 +1,27 @@
+import { normalizePath, parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/instrumentation-client.ts
+function createInstrumentationClientTransformPlugin(getInstrumentationClientPath) {
+	return {
+		name: "vinext:instrumentation-client",
+		apply: "serve",
+		transform(code, id) {
+			const instrumentationClientPath = getInstrumentationClientPath();
+			if (!instrumentationClientPath) return null;
+			if (normalizePath(id.split("?", 1)[0]) !== instrumentationClientPath) return null;
+			if (code.includes("__vinextInstrumentationClientStart")) return null;
+			const ast = parseAst(code);
+			let insertPos = 0;
+			for (const node of ast.body) if (node.type === "ImportDeclaration") insertPos = node.end;
+			const s = new MagicString(code);
+			s.appendLeft(insertPos, "\nconst __vinextInstrumentationClientStart = performance.now();\n");
+			s.append("\nconst __vinextInstrumentationClientEnd = performance.now();\nconst __vinextInstrumentationClientDuration = __vinextInstrumentationClientEnd - __vinextInstrumentationClientStart;\n// Match Next.js: only report slow client instrumentation during dev.\n// Production should execute the hook without additional timing overhead.\nif (__vinextInstrumentationClientDuration > 16) {\n  console.log(`[Client Instrumentation Hook] Slow execution detected: ${__vinextInstrumentationClientDuration.toFixed(0)}ms (Note: Code download overhead is not included in this measurement)`);\n}\n");
+			return {
+				code: s.toString(),
+				map: s.generateMap({ hires: true })
+			};
+		}
+	};
+}
+//#endregion
+export { createInstrumentationClientTransformPlugin };

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/middleware-server-only.d.ts

@@ -0,0 +1,53 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/middleware-server-only.d.ts
+/**
+ * Allow `import 'server-only'` from middleware (and any module reachable
+ * from middleware) in the SSR environment.
+ *
+ * Background: middleware runs server-side, so importing `server-only` is
+ * semantically correct. However, vinext bundles middleware into the SSR
+ * environment (via `virtual:vinext-server-entry`), and @vitejs/plugin-rsc's
+ * `rsc:validate-imports` plugin treats any non-RSC environment as a "client"
+ * build, rejecting `server-only` imports with:
+ *
+ *   'server-only' cannot be imported in client build ('ssr' environment)
+ *
+ * Next.js solves this with webpack `issuerLayer` rules: middleware (and
+ * `instrumentation`) sit in the `neutralTarget` layer where `server-only`
+ * is aliased to a no-op while `client-only` still errors. See
+ *   packages/next/src/build/webpack-config.ts ("Alias server-only and
+ *   client-only to proper exports based on bundling layers")
+ *
+ * Vite has no per-layer aliasing within a single environment, so we mirror
+ * the behavior with import-chain taint tracking:
+ *
+ *   1. Seed a `tainted` set with the middleware entry path (and its
+ *      canonical realpath).
+ *   2. For every resolveId call from a tainted importer, resolve the import
+ *      via `this.resolve(..., { skipSelf: true })` and add the resolved id
+ *      to the tainted set. This propagates the taint along the import graph
+ *      synchronously, before plugin-rsc's `order: "pre"` validate-imports
+ *      handler sees the next `server-only` request.
+ *   3. When a tainted module imports `server-only` in a non-RSC environment,
+ *      short-circuit to the no-op shim path so plugin-rsc's filter (which
+ *      matches the bare `^server-only$` specifier) never fires for that
+ *      import.
+ *
+ * The taint set is scoped to the middleware chain only — `server-only`
+ * imports from anywhere else (including client component code traversing
+ * through the SSR environment for `react-dom/server.edge` rendering) still
+ * hit the rsc:validate-imports rejection, preserving the original safety
+ * net for accidental client-side `server-only` leakage.
+ *
+ * Ported from Next.js handling of `WEBPACK_LAYERS.middleware` /
+ * `WEBPACK_LAYERS.GROUP.neutralTarget`:
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack-config.ts
+ */
+declare function createMiddlewareServerOnlyPlugin(options: {
+  getMiddlewarePath: () => string | null;
+  getCanonicalMiddlewarePath: () => string | null;
+  serverOnlyShimPath: string;
+}): Plugin;
+//#endregion
+export { createMiddlewareServerOnlyPlugin };

package/dist/plugins/middleware-server-only.js

@@ -0,0 +1,90 @@
+import { normalizePathSeparators } from "../utils/path.js";
+//#region src/plugins/middleware-server-only.ts
+/**
+* Allow `import 'server-only'` from middleware (and any module reachable
+* from middleware) in the SSR environment.
+*
+* Background: middleware runs server-side, so importing `server-only` is
+* semantically correct. However, vinext bundles middleware into the SSR
+* environment (via `virtual:vinext-server-entry`), and @vitejs/plugin-rsc's
+* `rsc:validate-imports` plugin treats any non-RSC environment as a "client"
+* build, rejecting `server-only` imports with:
+*
+*   'server-only' cannot be imported in client build ('ssr' environment)
+*
+* Next.js solves this with webpack `issuerLayer` rules: middleware (and
+* `instrumentation`) sit in the `neutralTarget` layer where `server-only`
+* is aliased to a no-op while `client-only` still errors. See
+*   packages/next/src/build/webpack-config.ts ("Alias server-only and
+*   client-only to proper exports based on bundling layers")
+*
+* Vite has no per-layer aliasing within a single environment, so we mirror
+* the behavior with import-chain taint tracking:
+*
+*   1. Seed a `tainted` set with the middleware entry path (and its
+*      canonical realpath).
+*   2. For every resolveId call from a tainted importer, resolve the import
+*      via `this.resolve(..., { skipSelf: true })` and add the resolved id
+*      to the tainted set. This propagates the taint along the import graph
+*      synchronously, before plugin-rsc's `order: "pre"` validate-imports
+*      handler sees the next `server-only` request.
+*   3. When a tainted module imports `server-only` in a non-RSC environment,
+*      short-circuit to the no-op shim path so plugin-rsc's filter (which
+*      matches the bare `^server-only$` specifier) never fires for that
+*      import.
+*
+* The taint set is scoped to the middleware chain only — `server-only`
+* imports from anywhere else (including client component code traversing
+* through the SSR environment for `react-dom/server.edge` rendering) still
+* hit the rsc:validate-imports rejection, preserving the original safety
+* net for accidental client-side `server-only` leakage.
+*
+* Ported from Next.js handling of `WEBPACK_LAYERS.middleware` /
+* `WEBPACK_LAYERS.GROUP.neutralTarget`:
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack-config.ts
+*/
+function createMiddlewareServerOnlyPlugin(options) {
+	const tainted = /* @__PURE__ */ new Set();
+	function canonicalizeId(id) {
+		const queryIndex = id.indexOf("?");
+		return normalizePathSeparators(queryIndex === -1 ? id : id.slice(0, queryIndex));
+	}
+	function isTainted(id) {
+		if (!id) return false;
+		return tainted.has(canonicalizeId(id));
+	}
+	function addTainted(id) {
+		tainted.add(canonicalizeId(id));
+	}
+	return {
+		name: "vinext:middleware-server-only",
+		// @vitejs/plugin-rsc's `rsc:validate-imports` (which is a normal-priority
+		enforce: "pre",
+		buildStart() {
+			tainted.clear();
+			const middlewarePath = options.getMiddlewarePath();
+			if (middlewarePath) addTainted(middlewarePath);
+			const canonical = options.getCanonicalMiddlewarePath();
+			if (canonical) addTainted(canonical);
+		},
+		resolveId: {
+			order: "pre",
+			async handler(id, importer, opts) {
+				if (this.environment?.name === "rsc") return;
+				if (!importer) return;
+				if (!isTainted(importer)) return;
+				if (id === "server-only") return {
+					id: options.serverOnlyShimPath,
+					moduleSideEffects: false
+				};
+				const resolved = await this.resolve(id, importer, {
+					...opts,
+					skipSelf: true
+				});
+				if (resolved && !resolved.external) addTainted(resolved.id);
+			}
+		}
+	};
+}
+//#endregion
+export { createMiddlewareServerOnlyPlugin };

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