vinext 0.2.1 → 1.0.0-beta.1

package/dist/build/standalone.js

@@ -2,7 +2,7 @@ import { readJsonFile } from "../utils/safe-json-file.js";
 import { resolveVinextPackageRoot } from "../utils/vinext-root.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
-import path from "node:path";
+import nodePath from "node:path";
 //#region src/build/standalone.ts
 function readPackageJson(packageJsonPath) {
 	return JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
@@ -29,7 +29,7 @@ function runtimeDeps(pkg) {
 * running against a build that predates this feature).
 */
 function readServerExternalsManifest(serverDir) {
-	const manifestPath = path.join(serverDir, "vinext-externals.json");
+	const manifestPath = nodePath.join(serverDir, "vinext-externals.json");
 	if (!fs.existsSync(manifestPath)) return [];
 	return readJsonFile(manifestPath, { onError: (err) => {
 		console.warn(`[vinext] Warning: failed to parse ${manifestPath}, proceeding without externals manifest: ${String(err)}`);
@@ -41,28 +41,28 @@ function resolvePackageJsonPath(packageName, resolver) {
 	} catch {
 		const lookupPaths = resolver.resolve.paths(packageName) ?? [];
 		for (const lookupPath of lookupPaths) {
-			const candidate = path.join(lookupPath, packageName, "package.json");
+			const candidate = nodePath.join(lookupPath, packageName, "package.json");
 			if (fs.existsSync(candidate)) {
 				if (readPackageJson(candidate).name === packageName) return candidate;
 			}
 		}
 		try {
 			const entryPath = resolver.resolve(packageName);
-			let dir = path.dirname(entryPath);
-			while (dir !== path.dirname(dir)) {
-				const candidate = path.join(dir, "package.json");
+			let dir = nodePath.dirname(entryPath);
+			while (dir !== nodePath.dirname(dir)) {
+				const candidate = nodePath.join(dir, "package.json");
 				if (fs.existsSync(candidate)) {
 					if (readPackageJson(candidate).name === packageName) return candidate;
 				}
-				dir = path.dirname(dir);
+				dir = nodePath.dirname(dir);
 			}
 		} catch {}
 		return null;
 	}
 }
 function copyPackageAndRuntimeDeps(root, targetNodeModulesDir, initialPackages, alreadyCopied) {
-	const rootResolver = createRequire(path.join(root, "package.json"));
-	const rootPkg = readPackageJson(path.join(root, "package.json"));
+	const rootResolver = createRequire(nodePath.join(root, "package.json"));
+	const rootPkg = readPackageJson(nodePath.join(root, "package.json"));
 	const rootOptional = new Set(Object.keys(rootPkg.optionalDependencies ?? {}));
 	const copied = alreadyCopied ?? /* @__PURE__ */ new Set();
 	const queue = initialPackages.map((packageName) => ({
@@ -80,14 +80,14 @@ function copyPackageAndRuntimeDeps(root, targetNodeModulesDir, initialPackages,
 			throw new Error(`Failed to resolve required runtime dependency "${entry.packageName}" for standalone output`);
 		}
 		const realPackageJsonPath = fs.realpathSync(packageJsonPath);
-		const packageRoot = path.dirname(realPackageJsonPath);
-		const packageTarget = path.join(targetNodeModulesDir, entry.packageName);
-		fs.mkdirSync(path.dirname(packageTarget), { recursive: true });
+		const packageRoot = nodePath.dirname(realPackageJsonPath);
+		const packageTarget = nodePath.join(targetNodeModulesDir, entry.packageName);
+		fs.mkdirSync(nodePath.dirname(packageTarget), { recursive: true });
 		fs.cpSync(packageRoot, packageTarget, {
 			recursive: true,
 			dereference: true,
 			filter: (src) => {
-				return !path.relative(packageRoot, src).split(path.sep).includes("node_modules");
+				return !nodePath.relative(packageRoot, src).split(nodePath.sep).includes("node_modules");
 			}
 		});
 		copied.add(entry.packageName);
@@ -144,58 +144,58 @@ function writeStandalonePackageJson(filePath) {
 * included.
 */
 function emitStandaloneOutput(options) {
-	const root = path.resolve(options.root);
-	const outDir = path.resolve(options.outDir);
-	const clientDir = path.join(outDir, "client");
-	const serverDir = path.join(outDir, "server");
+	const root = nodePath.resolve(options.root);
+	const outDir = nodePath.resolve(options.outDir);
+	const clientDir = nodePath.join(outDir, "client");
+	const serverDir = nodePath.join(outDir, "server");
 	if (!fs.existsSync(clientDir) || !fs.existsSync(serverDir)) throw new Error(`No build output found in ${outDir}. Run vinext build first.`);
-	const standaloneDir = path.join(outDir, "standalone");
-	const standaloneDistDir = path.join(standaloneDir, "dist");
-	const standaloneNodeModulesDir = path.join(standaloneDir, "node_modules");
+	const standaloneDir = nodePath.join(outDir, "standalone");
+	const standaloneDistDir = nodePath.join(standaloneDir, "dist");
+	const standaloneNodeModulesDir = nodePath.join(standaloneDir, "node_modules");
 	fs.rmSync(standaloneDir, {
 		recursive: true,
 		force: true
 	});
 	fs.mkdirSync(standaloneDistDir, { recursive: true });
-	fs.cpSync(clientDir, path.join(standaloneDistDir, "client"), {
+	fs.cpSync(clientDir, nodePath.join(standaloneDistDir, "client"), {
 		recursive: true,
 		dereference: true,
-		filter: (src) => !path.relative(clientDir, src).split(path.sep).includes("node_modules")
+		filter: (src) => !nodePath.relative(clientDir, src).split(nodePath.sep).includes("node_modules")
 	});
-	fs.cpSync(serverDir, path.join(standaloneDistDir, "server"), {
+	fs.cpSync(serverDir, nodePath.join(standaloneDistDir, "server"), {
 		recursive: true,
 		dereference: true,
-		filter: (src) => !path.relative(serverDir, src).split(path.sep).includes("node_modules")
+		filter: (src) => !nodePath.relative(serverDir, src).split(nodePath.sep).includes("node_modules")
 	});
-	const clientAssetsSidecar = path.join(outDir, "vinext-client-assets.js");
-	if (fs.existsSync(clientAssetsSidecar)) fs.copyFileSync(clientAssetsSidecar, path.join(standaloneDistDir, "vinext-client-assets.js"));
-	const publicDir = path.join(root, "public");
-	if (fs.existsSync(publicDir)) fs.cpSync(publicDir, path.join(standaloneDir, "public"), {
+	const clientAssetsSidecar = nodePath.join(outDir, "vinext-client-assets.js");
+	if (fs.existsSync(clientAssetsSidecar)) fs.copyFileSync(clientAssetsSidecar, nodePath.join(standaloneDistDir, "vinext-client-assets.js"));
+	const publicDir = nodePath.join(root, "public");
+	if (fs.existsSync(publicDir)) fs.cpSync(publicDir, nodePath.join(standaloneDir, "public"), {
 		recursive: true,
 		dereference: true,
-		filter: (src) => !path.relative(publicDir, src).split(path.sep).includes("node_modules")
+		filter: (src) => !nodePath.relative(publicDir, src).split(nodePath.sep).includes("node_modules")
 	});
 	fs.mkdirSync(standaloneNodeModulesDir, { recursive: true });
 	const initialPackages = readServerExternalsManifest(serverDir).filter((name) => name !== "vinext");
 	const copiedSet = /* @__PURE__ */ new Set();
 	copyPackageAndRuntimeDeps(root, standaloneNodeModulesDir, initialPackages, copiedSet);
 	const vinextPackageRoot = resolveVinextPackageRoot(options.vinextPackageRoot);
-	const vinextDistDir = path.join(vinextPackageRoot, "dist");
+	const vinextDistDir = nodePath.join(vinextPackageRoot, "dist");
 	if (!fs.existsSync(vinextDistDir)) throw new Error(`vinext runtime dist/ not found at ${vinextPackageRoot}`);
-	const vinextTargetDir = path.join(standaloneNodeModulesDir, "vinext");
+	const vinextTargetDir = nodePath.join(standaloneNodeModulesDir, "vinext");
 	fs.mkdirSync(vinextTargetDir, { recursive: true });
-	fs.copyFileSync(path.join(vinextPackageRoot, "package.json"), path.join(vinextTargetDir, "package.json"));
-	fs.cpSync(vinextDistDir, path.join(vinextTargetDir, "dist"), {
+	fs.copyFileSync(nodePath.join(vinextPackageRoot, "package.json"), nodePath.join(vinextTargetDir, "package.json"));
+	fs.cpSync(vinextDistDir, nodePath.join(vinextTargetDir, "dist"), {
 		recursive: true,
 		dereference: true,
 		filter: (src) => {
-			return !path.relative(vinextDistDir, src).split(path.sep).includes("node_modules");
+			return !nodePath.relative(vinextDistDir, src).split(nodePath.sep).includes("node_modules");
 		}
 	});
 	copiedSet.add("vinext");
-	copyPackageAndRuntimeDeps(vinextPackageRoot, standaloneNodeModulesDir, runtimeDeps(readPackageJson(path.join(vinextPackageRoot, "package.json"))).filter((name) => !copiedSet.has(name)), copiedSet);
-	writeStandaloneServerEntry(path.join(standaloneDir, "server.js"));
-	writeStandalonePackageJson(path.join(standaloneDir, "package.json"));
+	copyPackageAndRuntimeDeps(vinextPackageRoot, standaloneNodeModulesDir, runtimeDeps(readPackageJson(nodePath.join(vinextPackageRoot, "package.json"))).filter((name) => !copiedSet.has(name)), copiedSet);
+	writeStandaloneServerEntry(nodePath.join(standaloneDir, "server.js"));
+	writeStandalonePackageJson(nodePath.join(standaloneDir, "package.json"));
 	return {
 		standaloneDir,
 		copiedPackages: [...copiedSet]

package/dist/cache/cache-adapters-virtual.d.ts

@@ -1,20 +1,4 @@
 //#region src/cache/cache-adapters-virtual.d.ts
-/**
- * Code generation for the `virtual:vinext-cache-adapters` module, resolved by
- * the vinext vite plugin from the user's `cache` config ({@link VinextCacheConfig}).
- *
- * The generated module exports `registerConfiguredCacheAdapters(env)`, which the
- * server entries call on each request. It self-guards (adapters instantiate once
- * per isolate) and is a no-op when nothing is configured. Registration is
- * resilient: a factory that throws (e.g. a KV adapter on the Node.js server,
- * where the binding can't exist) is logged and skipped rather than failing every
- * request, so the same config can be registered from every runtime/router entry.
- *
- * Descriptor `options` are inlined into the generated module and forwarded to the
- * factory at runtime, so a config-time builder like `kvDataAdapter({ binding })`
- * never touches the Workers runtime — instantiation is deferred to the first
- * request.
- */
 /**
  * A serializable pointer to a cache adapter module — the shape of each `cache`
  * slot in the vinext() plugin config. Produced by an adapter builder (e.g.
@@ -41,10 +25,16 @@ type VinextCacheConfig = {
 };
 /** Public virtual module id imported by the server entries. */
 declare const VIRTUAL_CACHE_ADAPTERS = "virtual:vinext-cache-adapters";
+declare const VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY = "__vinextCacheConfig";
+type ViteConfigLoader = {
+  loadConfigFromFile: typeof import("vite").loadConfigFromFile;
+};
+declare function findVinextCacheConfigInPlugins(plugins: import("vite").PluginOption[] | undefined): Promise<VinextCacheConfig | null>;
+declare function loadVinextCacheConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<VinextCacheConfig | null>;
 /**
  * Generate the source of the `virtual:vinext-cache-adapters` module for the
  * given config. Always exports `registerConfiguredCacheAdapters(env)`.
  */
 declare function generateCacheAdaptersModule(cache?: VinextCacheConfig): string;
 //#endregion
-export { VIRTUAL_CACHE_ADAPTERS, VinextCacheConfig, generateCacheAdaptersModule };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, VinextCacheConfig, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, loadVinextCacheConfigFromViteConfig };

package/dist/cache/cache-adapters-virtual.js

@@ -1,6 +1,39 @@
+import { flattenPluginOptions } from "../utils/plugin-options.js";
 //#region src/cache/cache-adapters-virtual.ts
+/**
+* Code generation for the `virtual:vinext-cache-adapters` module, resolved by
+* the vinext vite plugin from the user's `cache` config ({@link VinextCacheConfig}).
+*
+* The generated module exports `registerConfiguredCacheAdapters(env)`, which the
+* server entries call on each request. It self-guards (adapters instantiate once
+* per isolate) and is a no-op when nothing is configured. Registration is
+* resilient: a factory that throws (e.g. a KV adapter on the Node.js server,
+* where the binding can't exist) is logged and skipped rather than failing every
+* request, so the same config can be registered from every runtime/router entry.
+*
+* Descriptor `options` are inlined into the generated module and forwarded to the
+* factory at runtime, so a config-time builder like `kvDataAdapter({ binding })`
+* never touches the Workers runtime — instantiation is deferred to the first
+* request.
+*/
 /** Public virtual module id imported by the server entries. */
 const VIRTUAL_CACHE_ADAPTERS = "virtual:vinext-cache-adapters";
+const VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY = "__vinextCacheConfig";
+async function findVinextCacheConfigInPlugins(plugins) {
+	const flattened = await flattenPluginOptions(plugins);
+	for (const plugin of flattened) {
+		if (!plugin || typeof plugin !== "object") continue;
+		const cacheConfig = plugin[VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY];
+		if (cacheConfig) return cacheConfig;
+	}
+	return null;
+}
+async function loadVinextCacheConfigFromViteConfig(vite, root) {
+	return await findVinextCacheConfigInPlugins((await vite.loadConfigFromFile({
+		command: "build",
+		mode: "production"
+	}, void 0, root))?.config.plugins);
+}
 /**
 * Serialize descriptor options into a JS expression for inlining. Plain JSON is
 * a valid JS literal; `undefined` when there are no options. Throws a clear
@@ -35,11 +68,11 @@ function generateCacheAdaptersModule(cache) {
 		lines.push(`import __vinextCdnAdapterFactory from ${JSON.stringify(cdn.adapter)};`);
 		lines.push(`import { setCdnCacheAdapter } from "vinext/shims/cdn-cache";`);
 	}
-	lines.push("", "// A factory that throws (e.g. a missing binding on an incompatible runtime)", "// is logged and skipped so the default handler stays in place.", "function __vinextFormatAdapterError(error) {", "  if (error instanceof Error && error.message) return error.message;", "  try {", "    return String(error);", "  } catch {", "    return '<unknown error>';", "  }", "}", "", "let __vinextCacheAdaptersRegistered = false;", "", "export function registerConfiguredCacheAdapters(env) {", "  if (__vinextCacheAdaptersRegistered) return;", "  __vinextCacheAdaptersRegistered = true;");
+	lines.push("", "// A factory that throws (e.g. a missing binding on an incompatible runtime)", "// is logged and skipped so the default handler stays in place.", "function __vinextFormatAdapterError(error) {", "  if (error instanceof Error && error.message) return error.message;", "  try {", "    return String(error);", "  } catch {", "    return '<unknown error>';", "  }", "}", "", "let __vinextCacheAdaptersRegistered = false;", "", "export function registerConfiguredCacheAdapters(env) {", "  if (typeof process !== 'undefined' && process.env?.__VINEXT_PRERENDER_PATH_DISCOVERY === '1') return;", "  if (__vinextCacheAdaptersRegistered) return;", "  __vinextCacheAdaptersRegistered = true;");
 	if (data?.adapter) lines.push("  try {", `    setDataCacheHandler(__vinextDataAdapterFactory({ env, options: ${inlineOptions(data.adapter, data.options)} }));`, "  } catch (error) {", "    console.warn(\"[vinext] failed to initialize the configured data cache adapter; using the default handler.\\n\" + __vinextFormatAdapterError(error));", "  }");
 	if (cdn?.adapter) lines.push("  try {", `    setCdnCacheAdapter(__vinextCdnAdapterFactory({ env, options: ${inlineOptions(cdn.adapter, cdn.options)} }));`, "  } catch (error) {", "    console.warn(\"[vinext] failed to initialize the configured CDN cache adapter; using the default adapter.\\n\" + __vinextFormatAdapterError(error));", "  }");
 	lines.push("}", "");
 	return lines.join("\n");
 }
 //#endregion
-export { VIRTUAL_CACHE_ADAPTERS, generateCacheAdaptersModule };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VIRTUAL_CACHE_ADAPTERS, findVinextCacheConfigInPlugins, generateCacheAdaptersModule, loadVinextCacheConfigFromViteConfig };

package/dist/check.d.ts

@@ -59,38 +59,22 @@ type CheckResult = {
 declare function hasFreeCjsGlobal(content: string): boolean;
 /**
  * Scan source files for `import ... from 'next/...'` statements.
- *
- * `root` must be forward-slash: it is passed to `findSourceFiles`, which
- * requires it.
  */
 declare function scanImports(root: string): CheckItem[];
 /**
  * Analyze next.config.js/mjs/ts for supported and unsupported options.
- *
- * `root` must be forward-slash — joined with `path.posix.join`. Only called
- * from `runCheck`, which normalizes it.
  */
 declare function analyzeConfig(root: string): CheckItem[];
 /**
  * Check package.json dependencies for known libraries.
- *
- * `root` must be forward-slash — joined with `path.posix.join`. Only called
- * from `runCheck`, which normalizes it.
  */
 declare function checkLibraries(root: string): CheckItem[];
 /**
  * Check file conventions (pages, app directory, middleware, etc.)
- *
- * `root` must be forward-slash — joined with `path.posix.join` and passed to
- * `findDir`. Only called from `runCheck`, which normalizes it.
  */
 declare function checkConventions(root: string): CheckItem[];
 /**
  * Run the full compatibility check.
- *
- * `root` must be forward-slash — callers normalize it at the CLI entry, and it
- * is forwarded to `scanImports` / `checkConventions` / `findDir`, which build
- * paths with `path.posix.*`.
  */
 declare function runCheck(root: string): CheckResult;
 /**

package/dist/check.js

@@ -1,7 +1,6 @@
+import path from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { detectPackageManager, findDir } from "./utils/project.js";
-import { normalizePathSeparators } from "./utils/path.js";
 import fs from "node:fs";
-import path from "node:path";
 import { parseAst } from "vite";
 //#region src/check.ts
 /**
@@ -215,6 +214,10 @@ const CONFIG_SUPPORT = {
 		status: "supported",
 		detail: "sourcemap-resolved stack traces during prerender"
 	},
+	cacheComponents: {
+		status: "partial",
+		detail: "experimental support; behavior is incomplete"
+	},
 	"experimental.ppr": {
 		status: "unsupported",
 		detail: "partial prerendering not yet implemented"
@@ -367,11 +370,6 @@ const LIBRARY_SUPPORT = {
 };
 /**
 * Recursively find all source files in a directory.
-*
-* `dir` must be forward-slash, and the returned paths are forward-slash too:
-* each entry is joined with `path.posix.join`, which only stays canonical when
-* the base already is. This keeps downstream substring checks (e.g.
-* `f.includes("/api/")`) and reported paths consistent across platforms.
 */
 function findSourceFiles(dir, extensions = [
 	".ts",
@@ -384,7 +382,7 @@ function findSourceFiles(dir, extensions = [
 	if (!fs.existsSync(dir)) return results;
 	const entries = fs.readdirSync(dir, { withFileTypes: true });
 	for (const entry of entries) {
-		const fullPath = path.posix.join(dir, entry.name);
+		const fullPath = path.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist" || entry.name === ".git") continue;
 			results.push(...findSourceFiles(fullPath, extensions));
@@ -398,8 +396,8 @@ function isIdentStart(c) {
 function isIdentChar(c) {
 	return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "$";
 }
-const CJS_GLOBALS = new Set(["__dirname", "__filename"]);
-const REGEX_PRECEDING_KEYWORDS = new Set([
+const CJS_GLOBALS = /* @__PURE__ */ new Set(["__dirname", "__filename"]);
+const REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
 	"return",
 	"typeof",
 	"instanceof",
@@ -588,9 +586,6 @@ function hasFreeCjsGlobal(content) {
 }
 /**
 * Scan source files for `import ... from 'next/...'` statements.
-*
-* `root` must be forward-slash: it is passed to `findSourceFiles`, which
-* requires it.
 */
 function scanImports(root) {
 	const files = findSourceFiles(root);
@@ -608,7 +603,7 @@ function scanImports(root) {
 			if (mod.startsWith("next/") || mod === "next" || mod === "server-only" || mod === "client-only") {
 				const normalized = mod === "next" ? "next" : mod;
 				if (!importUsage.has(normalized)) importUsage.set(normalized, []);
-				const relFile = normalizePathSeparators(path.relative(root, file));
+				const relFile = path.relative(root, file);
 				const usedInFiles = importUsage.get(normalized) ?? [];
 				if (!usedInFiles.includes(relFile)) usedInFiles.push(relFile);
 			}
@@ -735,9 +730,6 @@ function collectConfigKeys(source) {
 }
 /**
 * Analyze next.config.js/mjs/ts for supported and unsupported options.
-*
-* `root` must be forward-slash — joined with `path.posix.join`. Only called
-* from `runCheck`, which normalizes it.
 */
 function analyzeConfig(root) {
 	const configFiles = [
@@ -749,7 +741,7 @@ function analyzeConfig(root) {
 	];
 	let configPath = null;
 	for (const f of configFiles) {
-		const p = path.posix.join(root, f);
+		const p = path.join(root, f);
 		if (fs.existsSync(p)) {
 			configPath = p;
 			break;
@@ -775,6 +767,7 @@ function analyzeConfig(root) {
 		"output",
 		"transpilePackages",
 		"webpack",
+		"cacheComponents",
 		"reactStrictMode",
 		"poweredByHeader",
 		"skipMiddlewareUrlNormalize",
@@ -806,12 +799,9 @@ function analyzeConfig(root) {
 }
 /**
 * Check package.json dependencies for known libraries.
-*
-* `root` must be forward-slash — joined with `path.posix.join`. Only called
-* from `runCheck`, which normalizes it.
 */
 function checkLibraries(root) {
-	const pkgPath = path.posix.join(root, "package.json");
+	const pkgPath = path.join(root, "package.json");
 	if (!fs.existsSync(pkgPath)) return [];
 	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
 	const allDeps = {
@@ -829,16 +819,13 @@ function checkLibraries(root) {
 }
 /**
 * Check file conventions (pages, app directory, middleware, etc.)
-*
-* `root` must be forward-slash — joined with `path.posix.join` and passed to
-* `findDir`. Only called from `runCheck`, which normalizes it.
 */
 function checkConventions(root) {
 	const items = [];
 	const pagesDir = findDir(root, "pages", "src/pages");
 	const appDirPath = findDir(root, "app", "src/app");
-	const hasProxy = fs.existsSync(path.posix.join(root, "proxy.ts")) || fs.existsSync(path.posix.join(root, "proxy.js"));
-	const hasMiddleware = fs.existsSync(path.posix.join(root, "middleware.ts")) || fs.existsSync(path.posix.join(root, "middleware.js"));
+	const hasProxy = fs.existsSync(path.join(root, "proxy.ts")) || fs.existsSync(path.join(root, "proxy.js"));
+	const hasMiddleware = fs.existsSync(path.join(root, "middleware.ts")) || fs.existsSync(path.join(root, "middleware.js"));
 	if (pagesDir !== null) {
 		const isSrc = pagesDir.includes("src/pages");
 		items.push({
@@ -916,7 +903,7 @@ function checkConventions(root) {
 		status: "unsupported",
 		detail: "vinext requires a pages/ or app/ directory"
 	});
-	const pkgPath = path.posix.join(root, "package.json");
+	const pkgPath = path.join(root, "package.json");
 	if (fs.existsSync(pkgPath)) {
 		if (JSON.parse(fs.readFileSync(pkgPath, "utf-8")).type !== "module") items.push({
 			name: "Missing \"type\": \"module\" in package.json",
@@ -930,7 +917,7 @@ function checkConventions(root) {
 	const cjsGlobalFiles = [];
 	for (const file of allSourceFiles) {
 		const content = fs.readFileSync(file, "utf-8");
-		const rel = normalizePathSeparators(path.relative(root, file));
+		const rel = path.relative(root, file);
 		if (viewTransitionRegex.test(content)) viewTransitionFiles.push(rel);
 		if (hasFreeCjsGlobal(content)) cjsGlobalFiles.push(rel);
 	}
@@ -945,7 +932,7 @@ function checkConventions(root) {
 		"postcss.config.js",
 		"postcss.config.cjs"
 	]) {
-		const configPath = path.posix.join(root, configFile);
+		const configPath = path.join(root, configFile);
 		if (fs.existsSync(configPath)) {
 			const content = fs.readFileSync(configPath, "utf-8");
 			if (/plugins\s*:\s*\[\s*['"]/.test(content)) items.push({
@@ -966,10 +953,6 @@ function checkConventions(root) {
 }
 /**
 * Run the full compatibility check.
-*
-* `root` must be forward-slash — callers normalize it at the CLI entry, and it
-* is forwarded to `scanImports` / `checkConventions` / `findDir`, which build
-* paths with `path.posix.*`.
 */
 function runCheck(root) {
 	const imports = scanImports(root);