@qzsy/vinext 0.1.7

package/dist/plugins/postcss.js

@@ -0,0 +1,96 @@
+import { importExportWithCommonJsFallback } from "../utils/commonjs-loader.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/plugins/postcss.ts
+async function loadPluginExport(resolvedPath) {
+	return importExportWithCommonJsFallback(resolvedPath);
+}
+/**
+* PostCSS config file names to search for, in priority order.
+* Matches the same search order as postcss-load-config / lilconfig.
+*/
+const POSTCSS_CONFIG_FILES = [
+	"postcss.config.js",
+	"postcss.config.cjs",
+	"postcss.config.mjs",
+	"postcss.config.ts",
+	"postcss.config.cts",
+	"postcss.config.mts",
+	".postcssrc",
+	".postcssrc.js",
+	".postcssrc.cjs",
+	".postcssrc.mjs",
+	".postcssrc.ts",
+	".postcssrc.cts",
+	".postcssrc.mts",
+	".postcssrc.json",
+	".postcssrc.yaml",
+	".postcssrc.yml"
+];
+/**
+* Module-level cache for resolvePostcssStringPlugins — avoids re-scanning per Vite environment.
+* Stores the Promise itself so concurrent calls (RSC/SSR/Client config() hooks firing in
+* parallel) all await the same in-flight scan rather than each starting their own.
+*/
+const postcssCache = /* @__PURE__ */ new Map();
+/**
+* Resolve PostCSS string plugin names in a project's PostCSS config.
+*
+* Next.js (via postcss-load-config) resolves string plugin names in the
+* object form `{ plugins: { "pkg-name": opts } }` but NOT in the array form
+* `{ plugins: ["pkg-name"] }`. Since many Next.js projects use the array
+* form (particularly with Tailwind CSS v4), we detect this case and resolve
+* the string names to actual plugin functions so Vite can use them.
+*
+* Returns the resolved PostCSS config object to inject into Vite's
+* `css.postcss`, or `undefined` if no resolution is needed.
+*/
+function resolvePostcssStringPlugins(projectRoot) {
+	if (postcssCache.has(projectRoot)) return postcssCache.get(projectRoot);
+	const promise = resolvePostcssStringPluginsUncached(projectRoot);
+	postcssCache.set(projectRoot, promise);
+	return promise;
+}
+async function resolvePostcssStringPluginsUncached(projectRoot) {
+	let configPath = null;
+	for (const name of POSTCSS_CONFIG_FILES) {
+		const candidate = path.join(projectRoot, name);
+		if (fs.existsSync(candidate)) {
+			configPath = candidate;
+			break;
+		}
+	}
+	if (!configPath) return;
+	let config;
+	try {
+		if (configPath.endsWith(".json") || configPath.endsWith(".yaml") || configPath.endsWith(".yml")) return;
+		if (configPath.endsWith(".postcssrc")) {
+			if (fs.readFileSync(configPath, "utf-8").trim().startsWith("{")) return;
+		}
+		config = await importExportWithCommonJsFallback(configPath);
+	} catch {
+		return;
+	}
+	if (!config || !Array.isArray(config.plugins)) return;
+	if (!config.plugins.some((p) => typeof p === "string" || Array.isArray(p) && typeof p[0] === "string")) return;
+	const req = createRequire(path.join(projectRoot, "package.json"));
+	try {
+		return { plugins: await Promise.all(config.plugins.filter(Boolean).map(async (plugin) => {
+			if (typeof plugin === "string") {
+				const fn = await loadPluginExport(req.resolve(plugin));
+				return typeof fn === "function" ? fn() : fn;
+			}
+			if (Array.isArray(plugin) && typeof plugin[0] === "string") {
+				const [name, options] = plugin;
+				const fn = await loadPluginExport(req.resolve(name));
+				return typeof fn === "function" ? fn(options) : fn;
+			}
+			return plugin;
+		})) };
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { postcssCache, resolvePostcssStringPlugins };

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

@@ -0,0 +1,21 @@
+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
+ * that the name is not in the excluded set and that `console` is not shadowed
+ * at this scope. If all conditions pass, replace the entire statement with `;`.
+ *
+ * Returns `null` if no console calls are removed.
+ */
+declare function removeConsoleCalls(code: string, config: RemoveConsoleConfig): RemoveConsoleResult | null;
+//#endregion
+export { removeConsoleCalls };

package/dist/plugins/remove-console.js

@@ -0,0 +1,177 @@
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/remove-console.ts
+/**
+* Strip `console.*` calls from client bundle code.
+*
+* Mirrors Next.js's SWC `remove_console` transform:
+*   - Strips all `console.<method>()` calls regardless of context (top-level,
+*     JSX expressions, function arguments, return values, ternary branches)
+*   - Replaces removed calls with `void 0` to keep the AST valid in every
+*     position a CallExpression can appear
+*   - Respects `exclude: ["error"]` to preserve certain methods (case-insensitive)
+*   - Preserves calls when `console` is shadowed (local variable, function
+*     parameter, or destructured binding)
+*   - Preserves computed property access `console[prop]()`
+*
+* Uses Vite's `parseAst` (OXC/acorn) for parsing and `MagicString` for
+* surgical source replacement. Returns `null` when no changes are made.
+*/
+const SCOPE_ENTERING_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* Walk the AST body looking for expression statements whose expression is a
+* CallExpression with a callee of `console.<identifier>`. When found, check
+* that the name is not in the excluded set and that `console` is not shadowed
+* at this scope. If all conditions pass, replace the entire statement with `;`.
+*
+* Returns `null` if no console calls are removed.
+*/
+function removeConsoleCalls(code, config) {
+	if (config === false) return null;
+	if (!code.match(/\bconsole\b/)) return null;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} 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];
+	}
+	function pushScope() {
+		scopeStack.push({ shadowed: currentScope().shadowed });
+	}
+	function popScope() {
+		scopeStack.pop();
+	}
+	const s = new MagicString(code);
+	let changed = false;
+	/**
+	* Check if a node introduces a binding named "console" and mark scope.
+	* Recurses into all binding-pattern node types (destructuring shapes,
+	* defaults, rest elements).
+	*/
+	function checkBinding(node) {
+		if (!node) return;
+		switch (node.type) {
+			case "Identifier":
+				if (node.name === "console") currentScope().shadowed = true;
+				break;
+			case "ObjectPattern":
+				for (const prop of node.properties) checkBinding(prop);
+				break;
+			case "Property": {
+				const propertyNode = node;
+				if (propertyNode.value) checkBinding(propertyNode.value);
+				break;
+			}
+			case "ArrayPattern": {
+				const elements = node.elements;
+				if (elements) for (const el of elements) checkBinding(el);
+				break;
+			}
+			case "AssignmentPattern": {
+				const left = node.left;
+				checkBinding(left);
+				break;
+			}
+			case "RestElement": {
+				const argument = node.argument;
+				checkBinding(argument);
+				break;
+			}
+			default: break;
+		}
+	}
+	/**
+	* Check if an identifier refers to the *global* console.
+	* It's global only when:
+	*   1. Its name is "console"
+	*   2. No local binding of that name shadows it at this point
+	*/
+	function isGlobalConsole(node) {
+		return node.type === "Identifier" && node.name === "console" && !currentScope().shadowed;
+	}
+	/**
+	* Determine if a call expression is a `console.<method>()` that should be
+	* removed. The callee must be a MemberExpression with:
+	*   - object: Identifier "console" (global, not shadowed)
+	*   - property: Identifier (NOT computed — computed access like
+	*     `console[prop]()` is preserved per Next.js behavior)
+	* The method name must NOT be in the excluded set.
+	*/
+	function shouldRemove(node) {
+		if (node.type !== "CallExpression") return false;
+		const callee = node.callee;
+		if (callee.type !== "MemberExpression") return false;
+		if (callee.computed) return false;
+		if (!isGlobalConsole(callee.object)) return false;
+		const prop = callee.property;
+		if (prop.type !== "Identifier") return false;
+		const method = prop.name.toLowerCase();
+		if (excluded.has(method)) return false;
+		return true;
+	}
+	/**
+	* Recursively walk a node tree, managing scope for shadow detection.
+	* When a CallExpression matches `console.<method>()`, replace it with
+	* `void 0`. If the call is the sole expression of an ExpressionStatement,
+	* replace the entire statement with `;` for cleaner output.
+	*/
+	function walk(node, parent) {
+		if (!node) return;
+		if (node.type === "CallExpression" && shouldRemove(node)) {
+			if (parent?.type === "ExpressionStatement") s.overwrite(parent.start, parent.end, ";");
+			else s.overwrite(node.start, node.end, "void 0");
+			changed = true;
+			return;
+		}
+		if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+			const id = node.id;
+			checkBinding(id);
+		}
+		const isScopeEntering = SCOPE_ENTERING_TYPES.has(node.type);
+		if (isScopeEntering) {
+			pushScope();
+			if (node.type === "FunctionExpression") {
+				const id = node.id;
+				checkBinding(id);
+			}
+			const params = node.params;
+			if (params) for (const param of params) checkBinding(param);
+		}
+		const isCatchScope = node.type === "CatchClause";
+		if (isCatchScope) {
+			pushScope();
+			const param = node.param;
+			if (param) checkBinding(param);
+		}
+		const isBlockScope = node.type === "BlockStatement" || node.type === "Program" || node.type === "SwitchCase";
+		if (isBlockScope && !isScopeEntering) pushScope();
+		if (node.type === "VariableDeclaration") for (const decl of node.declarations ?? []) checkBinding(decl.id);
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "start" || key === "end") continue;
+			const child = node[key];
+			if (child && typeof child === "object") {
+				if (Array.isArray(child)) {
+					for (const item of child) if (item && typeof item === "object" && "type" in item) walk(item, node);
+				} else if ("type" in child) walk(child, node);
+			}
+		}
+		if (isScopeEntering || isBlockScope || isCatchScope) popScope();
+	}
+	for (const node of ast.body) walk(node);
+	if (!changed) return null;
+	return {
+		code: s.toString(),
+		map: s.generateMap({ hires: "boundary" })
+	};
+}
+//#endregion
+export { removeConsoleCalls };

package/dist/plugins/require-context.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/require-context.d.ts
+declare function createRequireContextPlugin(): Plugin;
+//#endregion
+export { createRequireContextPlugin };

package/dist/plugins/require-context.js

@@ -0,0 +1,185 @@
+import { forEachAstChild, hasRange, isAstRecord, nodeArray } from "./ast-utils.js";
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/require-context.ts
+const TRANSFORMABLE_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+]);
+function createRequireContextPlugin() {
+	return {
+		name: "vinext:require-context",
+		enforce: "pre",
+		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" })
+				};
+			}
+		}
+	};
+}
+function langForId(id) {
+	const clean = id.split("?", 1)[0];
+	const dot = clean.lastIndexOf(".");
+	if (dot < 0) return null;
+	const ext = clean.slice(dot).toLowerCase();
+	if (!TRANSFORMABLE_EXTENSIONS.has(ext)) return null;
+	switch (ext) {
+		case ".ts":
+		case ".cts":
+		case ".mts": return "ts";
+		case ".tsx": return "tsx";
+		case ".jsx": return "jsx";
+		default: return "jsx";
+	}
+}
+function collectRequireContextCalls(ast) {
+	const calls = [];
+	function visit(value) {
+		if (!isAstRecord(value)) return;
+		const parsed = parseRequireContextCall(value);
+		if (parsed) {
+			calls.push(parsed);
+			return;
+		}
+		forEachAstChild(value, visit);
+	}
+	visit(ast);
+	return calls;
+}
+function parseRequireContextCall(node) {
+	if (node.type !== "CallExpression" || !hasRange(node)) return null;
+	const callee = node.callee;
+	if (!isAstRecord(callee) || callee.type !== "MemberExpression" || callee.computed === true || callee.optional === true) return null;
+	if (!isPropertyNamed(callee.property, "context")) return null;
+	if (!isRequireExpression(callee.object)) return null;
+	const args = nodeArray(node.arguments);
+	const dir = stringLiteralValue(args[0]);
+	if (dir == null || !(dir.startsWith("./") || dir.startsWith("../"))) return null;
+	let recursive = true;
+	if (args.length >= 2) {
+		const value = booleanLiteralValue(args[1]);
+		if (value == null) return null;
+		recursive = value;
+	}
+	let pattern = "";
+	let flags = "";
+	if (args.length >= 3) {
+		const regex = regexLiteralValue(args[2]);
+		if (regex == null) return null;
+		pattern = regex.pattern;
+		flags = regex.flags;
+	} else if (args.length > 3) return null;
+	return {
+		range: node,
+		dir,
+		recursive,
+		pattern,
+		flags
+	};
+}
+function isRequireExpression(value) {
+	let node = value;
+	while (isAstRecord(node)) {
+		if (node.type === "Identifier") return node.name === "require";
+		if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
+			node = node.expression;
+			continue;
+		}
+		if (node.type === "TSNonNullExpression") {
+			node = node.expression;
+			continue;
+		}
+		if (node.type === "ParenthesizedExpression") {
+			node = node.expression;
+			continue;
+		}
+		return false;
+	}
+	return false;
+}
+function isPropertyNamed(value, name) {
+	return isAstRecord(value) && value.type === "Identifier" && value.name === name;
+}
+function stringLiteralValue(value) {
+	if (isAstRecord(value) && value.type === "Literal" && typeof value.value === "string") return value.value;
+	return null;
+}
+function booleanLiteralValue(value) {
+	if (isAstRecord(value) && value.type === "Literal" && typeof value.value === "boolean") return value.value;
+	return null;
+}
+function regexLiteralValue(value) {
+	if (!isAstRecord(value) || value.type !== "Literal") return null;
+	const regex = value.regex;
+	if (typeof regex === "object" && regex !== null && typeof regex.pattern === "string" && typeof regex.flags === "string") return {
+		pattern: regex.pattern,
+		flags: regex.flags
+	};
+	return null;
+}
+function buildReplacement(call) {
+	const globPattern = globPatternFor(call.dir, call.recursive);
+	const glob = `import.meta.glob(${JSON.stringify(globPattern)}, { eager: true })`;
+	const base = JSON.stringify(stripTrailingSlash(call.dir));
+	const filterFlags = call.flags.replace(/[gy]/g, "");
+	const regexArgs = `${JSON.stringify(call.pattern)}, ${JSON.stringify(filterFlags)}`;
+	return [
+		"(() => {",
+		`  const __modules = ${glob};`,
+		`  const __base = ${base};`,
+		`  const __re = ${call.pattern ? `new RegExp(${regexArgs})` : "null"};`,
+		"  const __prefix = __base.endsWith('/') ? __base : __base + '/';",
+		"  const __map = Object.create(null);",
+		"  for (const __abs in __modules) {",
+		"    if (!__abs.startsWith(__prefix)) continue;",
+		"    const __key = './' + __abs.slice(__prefix.length);",
+		"    if (__re && !__re.test(__key)) continue;",
+		"    __map[__key] = __modules[__abs];",
+		"  }",
+		"  const __keys = Object.keys(__map).sort();",
+		"  const __ctx = (__key) => {",
+		"    if (__key in __map) return __map[__key];",
+		"    const __err = new Error('Cannot find module \\'' + __key + '\\'');",
+		"    __err.code = 'MODULE_NOT_FOUND';",
+		"    throw __err;",
+		"  };",
+		"  __ctx.keys = () => __keys.slice();",
+		"  __ctx.resolve = (__key) => __key;",
+		`  __ctx.id = __base;`,
+		"  return __ctx;",
+		"})()"
+	].join("\n");
+}
+function globPatternFor(dir, recursive) {
+	const base = stripTrailingSlash(dir);
+	return recursive ? `${base}/**/*` : `${base}/*`;
+}
+function stripTrailingSlash(value) {
+	return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+//#endregion
+export { createRequireContextPlugin };

package/dist/plugins/rsc-client-reference-loaders.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/rsc-client-reference-loaders.d.ts
+declare function createRscClientReferenceLoadersPlugin(): Plugin;
+//#endregion
+export { createRscClientReferenceLoadersPlugin };

package/dist/plugins/rsc-client-reference-loaders.js

@@ -0,0 +1,46 @@
+//#region src/plugins/rsc-client-reference-loaders.ts
+const CLIENT_REFERENCES_ID = "\0virtual:vite-rsc/client-references";
+const RESOLVED_ID_PROXY_PREFIX = "virtual:vite-rsc/resolved-id/";
+function withResolvedIdProxy(resolvedId) {
+	return resolvedId.startsWith("\0") ? RESOLVED_ID_PROXY_PREFIX + encodeURIComponent(resolvedId) : resolvedId;
+}
+function generateClientReferenceObject(meta) {
+	const exports = meta.renderedExports.slice().sort().map((name) => `      get ${JSON.stringify(name)}() { return m[${JSON.stringify(name)}]; },`).join("\n");
+	return exports ? `{\n${exports}\n    }` : "{}";
+}
+function generateDirectClientReferenceLoaders(metas) {
+	return `export default {\n${metas.slice().sort((a, b) => a.referenceKey.localeCompare(b.referenceKey)).map((meta) => {
+		const importId = withResolvedIdProxy(meta.importId);
+		return [
+			`  ${JSON.stringify(meta.referenceKey)}: async () => {`,
+			`    const m = await import(${JSON.stringify(importId)});`,
+			`    return ${generateClientReferenceObject(meta)};`,
+			`  },`
+		].join("\n");
+	}).join("\n")}\n};\n`;
+}
+function createRscClientReferenceLoadersPlugin() {
+	let rscApi;
+	return {
+		name: "vinext:rsc-client-reference-loaders",
+		enforce: "post",
+		configResolved(config) {
+			rscApi = config.plugins.find((plugin) => plugin.name === "rsc:minimal")?.api;
+		},
+		transform(_code, id) {
+			if (id !== CLIENT_REFERENCES_ID) return null;
+			const manager = rscApi?.manager;
+			if (!manager || manager.isScanBuild) return null;
+			const metaEntries = Object.entries(manager.clientReferenceMetaMap).filter(([, meta]) => meta.serverChunk);
+			const metas = metaEntries.map(([, meta]) => meta);
+			if (metas.length === 0) return null;
+			for (const [id, meta] of metaEntries) meta.groupChunkId = id;
+			return {
+				code: generateDirectClientReferenceLoaders(metas),
+				map: null
+			};
+		}
+	};
+}
+//#endregion
+export { createRscClientReferenceLoadersPlugin };

package/dist/plugins/rsc-client-shim-excludes.d.ts

@@ -0,0 +1,6 @@
+//#region src/plugins/rsc-client-shim-excludes.d.ts
+declare const VINEXT_OPTIMIZE_DEPS_EXCLUDE: readonly string[];
+declare const SSR_EXTERNAL_REACT_ENTRIES: readonly string[];
+declare function mergeOptimizeDepsExclude(...excludeGroups: readonly (readonly string[])[]): string[];
+//#endregion
+export { SSR_EXTERNAL_REACT_ENTRIES, VINEXT_OPTIMIZE_DEPS_EXCLUDE, mergeOptimizeDepsExclude };

package/dist/plugins/rsc-client-shim-excludes.js

@@ -0,0 +1,35 @@
+//#region src/plugins/rsc-client-shim-excludes.ts
+const RSC_CLIENT_SHIM_OPTIMIZE_DEPS_EXCLUDE = Object.freeze([
+	"vinext/shims/error-boundary",
+	"vinext/shims/form",
+	"vinext/shims/layout-segment-context",
+	"vinext/shims/link",
+	"vinext/shims/script",
+	"vinext/shims/slot",
+	"vinext/shims/offline"
+]);
+const VINEXT_OPTIMIZE_DEPS_EXCLUDE = Object.freeze([
+	"vinext",
+	"@vercel/og",
+	"private-next-instrumentation-client",
+	...RSC_CLIENT_SHIM_OPTIMIZE_DEPS_EXCLUDE
+]);
+const SSR_EXTERNAL_REACT_ENTRIES = Object.freeze([
+	"react",
+	"react-dom",
+	"react-dom/server.edge",
+	"react-dom/static.edge",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime",
+	"react-server-dom-webpack/client.edge"
+]);
+function mergeOptimizeDepsExclude(...excludeGroups) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const group of excludeGroups) for (const entry of group) {
+		if (seen.has(entry)) continue;
+		seen.add(entry);
+	}
+	return [...seen];
+}
+//#endregion
+export { SSR_EXTERNAL_REACT_ENTRIES, VINEXT_OPTIMIZE_DEPS_EXCLUDE, mergeOptimizeDepsExclude };

package/dist/plugins/sass.d.ts

@@ -0,0 +1,62 @@
+import { ResolvedConfig } from "vite";
+
+//#region src/plugins/sass.d.ts
+type AdditionalData = string | ((source: string, filename: string) => string | Promise<string>);
+type VitePreprocessorOptions = {
+  additionalData?: AdditionalData;
+  loadPaths?: string[];
+  [key: string]: any;
+};
+/**
+ * Create a Sass `FileImporter` that resolves webpack-style tilde (`~`) imports.
+ *
+ * Next.js (via sass-loader's `webpackImporter`) supports two tilde forms:
+ *
+ * 1. `~pkg/path` — resolves `pkg/path` from `node_modules`. Used for
+ *    third-party SCSS/CSS, e.g. `@import '~nprogress/nprogress.css'`.
+ *
+ * 2. `~/path` — resolves relative to the **project root** (the `~` acts as
+ *    an alias for the root). Used with Turbopack's `resolveAlias: { '~*': '*' }`
+ *    convention, e.g. `@use '~/styles/variables' as *`.
+ *
+ * Vite's built-in Sass resolver does not strip the `~` prefix, so any SCSS
+ * that uses tilde imports fails with "Can't find stylesheet to import" errors.
+ * This `FileImporter` runs before Vite's internal importer (added at the end
+ * of `importers[]` in the vite:css plugin) and canonicalises tilde URLs so
+ * Sass can load them from the filesystem.
+ *
+ * The returned object implements the modern Sass `FileImporter` interface:
+ * `findFileUrl` returns a `file://` URL and Sass automatically handles partial
+ * resolution (`_variables.scss` for `variables`), index files, and extensions.
+ *
+ * @param root - Absolute path to the Vite project root (used as the base for
+ *   `~/path` resolution and for locating `node_modules`).
+ */
+declare function createSassTildeImporter(root: string): {
+  findFileUrl(url: string): URL | null;
+};
+declare function buildSassPreprocessorOptions(sassOptions: Record<string, unknown> | null | undefined): VitePreprocessorOptions | undefined;
+/**
+ * Create a per-build binding of {@link SassAwareFileSystemLoader}.
+ *
+ * Returns:
+ * - `Loader` — a class to inject as postcss-modules' `css.modules.Loader`
+ *   option. postcss-modules instantiates it with the fixed
+ *   `(root, plugins, fileResolve)` signature, so the resolved Vite config is
+ *   captured in this factory's closure rather than passed to the constructor.
+ * - `setResolvedConfig` — called from vinext's `configResolved` hook to bind
+ *   that build's resolved config.
+ *
+ * One binding is created per vinext plugin instance, so concurrent or
+ * back-to-back builds in a single process never observe another build's
+ * config (root, sass options, `generateScopedName`, logger, …).
+ */
+declare function createSassAwareFileSystemLoader(): {
+  Loader: new (root: string, plugins: unknown[], fileResolve?: (newPath: string, relativeTo: string) => Promise<string>) => {
+    fetch(newPath: string, relativeTo: string, trace?: string): Promise<Record<string, string>>;
+    readonly finalSource: string;
+  };
+  setResolvedConfig: (config: ResolvedConfig) => void;
+};
+//#endregion
+export { buildSassPreprocessorOptions, createSassAwareFileSystemLoader, createSassTildeImporter };