vinext 0.1.0 → 0.1.2

package/dist/plugins/require-context.js

@@ -0,0 +1,184 @@
+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(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;
+			}
+			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(".");
+	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/sass.d.ts

@@ -1,33 +1,62 @@
+import { ResolvedConfig } from "vite";
+
 //#region src/plugins/sass.d.ts
-/**
- * Map a Next.js `sassOptions` object onto Vite's
- * `css.preprocessorOptions.scss` / `.sass` shape.
- *
- * Next.js (webpack + sass-loader) accepts:
- * - `additionalData` (or legacy `prependData`) — prepended to every source
- * - `includePaths` — directories searched by `@import`
- * - `loadPaths`    — modern Sass equivalent of `includePaths`
- * - `implementation` — Sass implementation package name (e.g. `sass-embedded`)
- * - other Sass options that get forwarded as-is
- *
- * Reference (Next.js source — destructures the same keys before forwarding
- * the rest to sass-loader):
- *   .nextjs-ref/packages/next/src/build/webpack/config/blocks/css/index.ts#L150-L180
- *   https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/config/blocks/css/index.ts
- *
- * Vite expects:
- * - `additionalData` (string or function) on the preprocessor options
- * - modern Sass options (`loadPaths`, `importers`, `implementation`, …)
- *   flattened next to `additionalData`
- *
- * @see https://vite.dev/config/shared-options.html#css-preprocessoroptions
- */
 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 };
+export { buildSassPreprocessorOptions, createSassAwareFileSystemLoader, createSassTildeImporter };

package/dist/plugins/sass.js

@@ -1,4 +1,80 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { preprocessCSS } from "vite";
+import { pathToFileURL } from "node:url";
 //#region src/plugins/sass.ts
+/**
+* Map a Next.js `sassOptions` object onto Vite's
+* `css.preprocessorOptions.scss` / `.sass` shape.
+*
+* Next.js (webpack + sass-loader) accepts:
+* - `additionalData` (or legacy `prependData`) — prepended to every source
+* - `includePaths` — directories searched by `@import`
+* - `loadPaths`    — modern Sass equivalent of `includePaths`
+* - `implementation` — Sass implementation package name (e.g. `sass-embedded`)
+* - other Sass options that get forwarded as-is
+*
+* Reference (Next.js source — destructures the same keys before forwarding
+* the rest to sass-loader):
+*   .nextjs-ref/packages/next/src/build/webpack/config/blocks/css/index.ts#L150-L180
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/config/blocks/css/index.ts
+*
+* Vite expects:
+* - `additionalData` (string or function) on the preprocessor options
+* - modern Sass options (`loadPaths`, `importers`, `implementation`, …)
+*   flattened next to `additionalData`
+*
+* @see https://vite.dev/config/shared-options.html#css-preprocessoroptions
+*/
+/**
+* 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`).
+*/
+function createSassTildeImporter(root) {
+	const rootBaseUrl = pathToFileURL(root.endsWith("/") ? root : root + "/");
+	const nodeModulesBaseUrl = pathToFileURL(path.join(root, "node_modules") + "/");
+	return { findFileUrl(url) {
+		if (!url.startsWith("~")) return null;
+		const stripped = url.slice(1);
+		if (stripped.startsWith("/")) return new URL(stripped.slice(1), rootBaseUrl);
+		if (!stripped) return null;
+		const simpleResolved = new URL(stripped, nodeModulesBaseUrl);
+		const pkgName = stripped.startsWith("@") ? stripped.split("/").slice(0, 2).join("/") : stripped.split("/")[0] ?? "";
+		const directPkgDir = path.join(root, "node_modules", pkgName);
+		if (pkgName && fs.existsSync(directPkgDir)) return simpleResolved;
+		const req = createRequire(path.join(root, "package.json"));
+		try {
+			const pkgJsonPath = req.resolve(`${pkgName}/package.json`);
+			const pkgDir = path.dirname(pkgJsonPath);
+			const afterPkg = stripped.startsWith("@") ? stripped.split("/").slice(2).join("/") : stripped.split("/").slice(1).join("/");
+			return pathToFileURL(afterPkg ? path.join(pkgDir, afterPkg) : pkgDir);
+		} catch {
+			return null;
+		}
+	} };
+}
 function buildSassPreprocessorOptions(sassOptions) {
 	if (!sassOptions || typeof sassOptions !== "object") return void 0;
 	const { prependData, additionalData, includePaths, loadPaths, ...rest } = sassOptions;
@@ -16,5 +92,177 @@ function buildSassPreprocessorOptions(sassOptions) {
 	if (Object.keys(out).length === 0) return void 0;
 	return out;
 }
+/**
+* Sort key comparator used by postcss-modules' FileSystemLoader to determine
+* the order in which dependency CSS is prepended to the output.
+* Mirrors the original `traceKeySorter` from postcss-modules source.
+*/
+function traceKeySorter(a, b) {
+	if (a.length < b.length) return a < b.substring(0, a.length) ? -1 : 1;
+	if (a.length > b.length) return a.substring(0, b.length) <= b ? -1 : 1;
+	return a < b ? -1 : 1;
+}
+/**
+* Mirrors Vite's internal `cssModuleRE` (`/\.module\.(css|less|sass|scss|…)/`).
+*
+* postcss-modules treats *every* `composes: x from './file'` dependency as a
+* CSS module regardless of its filename, but Vite's pipeline only applies
+* CSS-module scoping to `*.module.*` files. When a dependency is not named
+* `*.module.*` (e.g. `composes: x from './plain.css'`), we hand
+* `preprocessCSS` a virtual `*.module.*` filename (same directory, so Sass
+* imports and relative resolution are unaffected) so the dependency's classes
+* are scoped and its export tokens extracted — matching what postcss-modules'
+* built-in `FileSystemLoader` did.
+*/
+const CSS_MODULE_RE = /\.module\.\w+$/;
+/**
+* Sass-aware replacement for postcss-modules' `FileSystemLoader`.
+*
+* Implements the same constructor + `fetch` + `finalSource` interface that
+* postcss-modules calls when resolving `composes: className from 'file'`
+* dependencies.
+*
+* For every dependency file, Vite's `preprocessCSS` is used so that:
+* - `.scss`/`.sass` files are compiled through Sass *before* CSS-module
+*   scoping runs (fixing the "Invalid empty selector" LightningCSS crash).
+* - `.module.css` and `.module.scss` files have their class names scoped and
+*   export tokens extracted in exactly the same way as the top-level file.
+*
+* Failure handling: a missing Sass implementation is downgraded to a logged
+* warning and an empty token map so the build continues (class composition
+* will be incomplete); any other preprocessing error (e.g. a syntax error in
+* the composed dependency) propagates and fails the build, matching the
+* built-in `FileSystemLoader`. When no resolved config has been bound —
+* only reachable if the Loader is used outside vinext's `configResolved`
+* wiring — the Loader silently returns an empty token map.
+*
+* Recursion boundary: nested `composes` chains are handled by delegating to
+* `preprocessCSS`, which re-applies postcss-modules (and therefore this
+* Loader) for each dependency — every composed subtree gets its own inner
+* Loader instance rather than sharing this instance's `tokensByFile`/
+* `sources` state. Two intentional consequences, versus the built-in
+* single-loader recursion:
+* - A dependency reached from two sibling `composes` branches is inlined
+*   once per subtree; the duplicate identical rules are collapsed by
+*   LightningCSS during minification (bloat-free in practice, but the
+*   pre-minification CSS differs from the built-in loader's single pass).
+* - Circular `composes` chains are not short-circuited across the
+*   `preprocessCSS` boundary (the built-in loader's shared cache caught
+*   them). Cycles are invalid CSS-module inputs — webpack/Next.js errors on
+*   them too — so no cycle bookkeeping is layered on here.
+*
+* Not exported directly: postcss-modules constructs the Loader itself with a
+* fixed `(root, plugins, fileResolve)` signature, so the resolved Vite config
+* cannot be a constructor argument. `createSassAwareFileSystemLoader` returns
+* a subclass with the config bound per factory call (i.e. per vinext plugin
+* instance) instead of a module-level singleton, so multiple builds in one
+* process (monorepos, programmatic multi-build runners) each preprocess
+* `composes` dependencies with their own root/sass options/scoped-name
+* generator.
+*/
+var SassAwareFileSystemLoader = class {
+	root;
+	fileResolve;
+	sources;
+	traces;
+	importNr;
+	tokensByFile;
+	constructor(root, _plugins, fileResolve) {
+		if (root === "/" && process.platform === "win32") {
+			const cwdDrive = process.cwd().slice(0, 3);
+			if (!/^[A-Za-z]:\\$/.test(cwdDrive)) throw new Error(`Failed to obtain root from "${process.cwd()}".`);
+			root = cwdDrive;
+		}
+		this.root = root;
+		this.fileResolve = fileResolve;
+		this.sources = {};
+		this.traces = {};
+		this.importNr = 0;
+		this.tokensByFile = {};
+	}
+	/**
+	* The resolved Vite config used to preprocess `composes` dependencies.
+	* The base implementation has no config (`fetch` silently returns empty
+	* tokens); `createSassAwareFileSystemLoader` overrides this with the
+	* config bound to that factory call.
+	*/
+	getResolvedConfig() {
+		return null;
+	}
+	async fetch(_newPath, relativeTo, _trace) {
+		const newPath = _newPath.replace(/^["']|["']$/g, "");
+		const trace = _trace ?? String.fromCharCode(this.importNr++);
+		const useFileResolve = typeof this.fileResolve === "function";
+		const fileResolvedPath = useFileResolve ? await this.fileResolve(newPath, relativeTo) : void 0;
+		if (fileResolvedPath !== void 0 && !path.isAbsolute(fileResolvedPath)) throw new Error("The returned path from the \"fileResolve\" option must be absolute.");
+		const relativeDir = path.dirname(relativeTo);
+		const fileRelativePath = fileResolvedPath ?? (() => {
+			let resolved = path.resolve(path.resolve(this.root, relativeDir), newPath);
+			if (!useFileResolve && newPath[0] !== "." && !path.isAbsolute(newPath)) try {
+				resolved = createRequire(import.meta.url).resolve(newPath);
+			} catch {}
+			return resolved;
+		})();
+		const cached = this.tokensByFile[fileRelativePath];
+		if (cached) return cached;
+		const config = this.getResolvedConfig();
+		const rawSource = await fs.promises.readFile(fileRelativePath, "utf-8");
+		if (config) try {
+			const ext = path.extname(fileRelativePath);
+			const result = await preprocessCSS(rawSource, CSS_MODULE_RE.test(fileRelativePath) ? fileRelativePath : ext === "" ? `${fileRelativePath}.module.css` : `${fileRelativePath.slice(0, -ext.length)}.module${ext}`, config);
+			const exportTokens = result.modules ?? {};
+			this.sources[fileRelativePath] = result.code;
+			this.traces[trace] = fileRelativePath;
+			this.tokensByFile[fileRelativePath] = exportTokens;
+			return exportTokens;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (!message.includes("Preprocessor dependency")) throw error;
+			config.logger.warn(`[vinext] Failed to preprocess \`composes\` dependency ${fileRelativePath}: ${message}. Classes composed from this file will be missing from the build output.`);
+		}
+		this.sources[fileRelativePath] = "";
+		this.traces[trace] = fileRelativePath;
+		this.tokensByFile[fileRelativePath] = {};
+		return {};
+	}
+	get finalSource() {
+		const { traces, sources } = this;
+		const written = /* @__PURE__ */ new Set();
+		return Object.keys(traces).sort(traceKeySorter).map((key) => {
+			const filename = traces[key];
+			if (!filename || written.has(filename)) return null;
+			written.add(filename);
+			return sources[filename];
+		}).join("");
+	}
+};
+/**
+* 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, …).
+*/
+function createSassAwareFileSystemLoader() {
+	let resolvedConfig = null;
+	return {
+		Loader: class extends SassAwareFileSystemLoader {
+			getResolvedConfig() {
+				return resolvedConfig;
+			}
+		},
+		setResolvedConfig(config) {
+			resolvedConfig = config;
+		}
+	};
+}
 //#endregion
-export { buildSassPreprocessorOptions };
+export { buildSassPreprocessorOptions, createSassAwareFileSystemLoader, createSassTildeImporter };

package/dist/plugins/wasm-module-import.d.ts

@@ -0,0 +1,15 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/wasm-module-import.d.ts
+/**
+ * vinext:wasm-module-import — handle `import x from '*.wasm?module'`.
+ *
+ * Resolutions marked external by Vite or a target adapter are preserved. For
+ * non-external resolutions, this plugin reads the WASM file, inlines it as
+ * base64, and exports a compiled WebAssembly.Module.
+ *
+ * Fixes #1351.
+ */
+declare function createWasmModuleImportPlugin(): Plugin;
+//#endregion
+export { createWasmModuleImportPlugin };

package/dist/plugins/wasm-module-import.js

@@ -0,0 +1,50 @@
+import { stripViteModuleQuery } from "../utils/path.js";
+import fs from "node:fs";
+//#region src/plugins/wasm-module-import.ts
+/**
+* vinext:wasm-module-import — handle `import x from '*.wasm?module'`.
+*
+* Resolutions marked external by Vite or a target adapter are preserved. For
+* non-external resolutions, this plugin reads the WASM file, inlines it as
+* base64, and exports a compiled WebAssembly.Module.
+*
+* Fixes #1351.
+*/
+function createWasmModuleImportPlugin() {
+	return {
+		name: "vinext:wasm-module-import",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: /\.wasm\?module$/ },
+			async handler(source, importer) {
+				if (this.environment?.name === "client") return null;
+				if ((importer ? (importer.startsWith("\0") ? importer.slice(1) : importer).split("?")[0] : "").includes("@vercel/og")) return null;
+				const resolved = await this.resolve(source, importer, { skipSelf: true });
+				if (!resolved) return null;
+				if (resolved.external) return resolved;
+				return `\0vinext-wasm-module:${stripViteModuleQuery(resolved.id)}`;
+			}
+		},
+		load: {
+			filter: { id: /^\u0000vinext-wasm-module:/ },
+			handler(id) {
+				const filePath = id.replace(/^\u0000vinext-wasm-module:/, "");
+				this.addWatchFile(filePath);
+				let bytes;
+				try {
+					bytes = fs.readFileSync(filePath);
+				} catch {
+					return this.error(`[vinext] Could not read WASM file: ${filePath}`);
+				}
+				const base64 = bytes.toString("base64");
+				return [
+					`const _b64 = ${JSON.stringify(base64)};`,
+					`const _buf = Uint8Array.from(atob(_b64), c => c.charCodeAt(0));`,
+					`export default await WebAssembly.compile(_buf.buffer);`
+				].join("\n");
+			}
+		}
+	};
+}
+//#endregion
+export { createWasmModuleImportPlugin };

package/dist/routing/app-route-graph.d.ts

@@ -24,6 +24,11 @@ type InterceptingRoute = {
   pagePath: string; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
   layoutPaths: string[]; /** Parameter names for dynamic segments */
   params: string[];
+  /**
+   * Synthetic page-carrier slot id for sibling (slot-less) interception.
+   * Set only when the marker has no `@slot` wrapper; undefined for slot intercepts.
+   */
+  slotId?: string;
 };
 type ParallelSlot = {
   /** Graph-owned semantic slot identity. Required on AppRouteGraphParallelSlot. */id?: string; /** Stable slot identity (name + owning directory), used for route serialization keys. */
@@ -73,7 +78,13 @@ type AppRoute = {
   routePath: string | null; /** Ordered list of layout files from root to leaf */
   layouts: string[]; /** Ordered list of all discovered template files from root to leaf (not necessarily aligned 1:1 with layouts) */
   templates: string[]; /** Parallel route slots (from @slot directories at the route's directory level) */
-  parallelSlots: ParallelSlot[]; /** Loading component path */
+  parallelSlots: ParallelSlot[];
+  /**
+   * Interception markers not wrapped in an `@slot` directory.
+   * On soft-nav, the intercepting page replaces the entire page response.
+   * Empty array when there are no sibling-style interception markers.
+   */
+  siblingIntercepts: InterceptingRoute[]; /** Loading component path */
   loadingPath: string | null; /** Error component path (leaf directory only) */
   errorPath: string | null;
   /**
@@ -265,6 +276,28 @@ declare function buildAppRouteGraph(appDir: string, matcher: ValidFileMatcher):
   routeManifest: RouteManifest;
 }>;
 declare function computeRootParamNames(routeSegments: readonly string[], layoutTreePositions: readonly number[]): string[];
+/**
+ * Find the best route to attach a sibling intercept to, given the directory
+ * that contains the interception marker.
+ *
+ * 1. Exact hit: a route whose page/handler lives directly in `dir`.
+ * 2. Subtree hit: shallowest route whose page lives anywhere under `dir`
+ *    (handles catch-all routes like `/templates/:catchAll+`).
+ * 3. Ancestor walk: walk up the directory tree toward `appDir` looking for
+ *    any of the above. This handles the case where the marker directory has
+ *    no sibling pages at all (e.g. `deep/path/(...)target` with no
+ *    `deep/path/page.tsx`).
+ *
+ * All comparisons happen in forward-slash space: `appDir` is forward-slash
+ * (normalized once in the config hook), but `dir` and route file paths
+ * descend through native `path.join`/`path.dirname`, which reintroduce
+ * backslashes on Windows. Without normalizing, the `current === appDir`
+ * termination never fires there and the walk overshoots the app root.
+ * `routesByDir` keys must be forward-slash dirnames of the route file paths.
+ *
+ * Exported for tests.
+ */
+declare function findOwnerRouteForDir(dir: string, appDir: string, routes: readonly AppRouteGraphRoute[], routesByDir: Map<string, AppRouteGraphRoute>): AppRouteGraphRoute | null;
 /**
  * Convert filesystem path segments to URL route parts, skipping invisible segments
  * (route groups, @slots, ".") and converting dynamic segment syntax to Express-style
@@ -299,4 +332,4 @@ declare function computeAppRouteStaticSiblings(allRoutes: readonly {
   patternParts?: readonly string[] | null;
 }): string[];
 //#endregion
-export { AppRoute, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, RootBoundaryId, RouteManifest, RouteManifestInterception, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
+export { AppRoute, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, RootBoundaryId, RouteManifest, RouteManifestInterception, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };