deslop-js 0.6.3 → 0.7.1

package/dist/entries-worker.mjs

@@ -0,0 +1,3736 @@
+import { a as OUTPUT_DIRECTORIES, c as SCRIPT_ENTRY_PATTERNS, d as SOURCE_EXTENSIONS$3, f as STANDALONE_PROJECT_LOCKFILES, i as MONOREPO_ROOT_MARKERS, l as SCRIPT_EXTENSIONLESS_FILE_PATTERN, o as RESOLVER_EXTENSIONS, r as LOCKFILE_MARKERS, s as SCRIPT_CONFIG_FILE_PATTERN, t as extractReactRouterRouteModuleEntries, u as SCRIPT_FILE_PATTERN } from "./parse-xkrZfjHl.mjs";
+import { parentPort } from "node:worker_threads";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import fg from "fast-glob";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { readFile } from "node:fs/promises";
+import ts from "typescript";
+import "oxc-resolver";
+
+//#region src/collect/workspaces.ts
+const resolveWorkspaces = (rootDir) => {
+	const rootPatterns = collectWorkspacePatterns(rootDir);
+	const hasRootLevelWorkspacePatterns = rootPatterns.length > 0;
+	let expandedDirectories = hasRootLevelWorkspacePatterns ? expandWorkspaceGlobs(rootPatterns, rootDir) : [];
+	const implicitSubProjects = discoverImplicitSubProjects(rootDir, expandedDirectories);
+	if (expandedDirectories.length === 0 && implicitSubProjects.length > 0) for (const subProjectDirectory of implicitSubProjects) {
+		const subPatterns = collectWorkspacePatterns(subProjectDirectory);
+		if (subPatterns.length > 0) {
+			const subExpanded = expandWorkspaceGlobs(subPatterns, subProjectDirectory);
+			expandedDirectories.push(subProjectDirectory, ...subExpanded);
+		}
+	}
+	const declaredDirectorySet = new Set(expandedDirectories);
+	const excludedDirectories = [];
+	const filteredImplicitSubProjects = implicitSubProjects;
+	const allDirectories = [...new Set([...expandedDirectories, ...filteredImplicitSubProjects])];
+	const workspacePackages = [];
+	for (const directory of allDirectories) {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+		try {
+			const packageContent = readFileSync(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(packageContent);
+			const packageName = packageJson.name || relative(rootDir, directory);
+			const entryFiles = extractWorkspaceEntries(packageJson, directory);
+			const depthFromRoot = relative(rootDir, directory).split("/").filter(Boolean).length;
+			workspacePackages.push({
+				name: packageName,
+				directory,
+				entryFiles,
+				isDeclaredWorkspace: declaredDirectorySet.has(directory),
+				depthFromRoot
+			});
+		} catch {}
+	}
+	return {
+		packages: workspacePackages,
+		excludedDirectories,
+		hasRootLevelWorkspacePatterns
+	};
+};
+const IMPLICIT_SUB_PROJECT_SEARCH_DEPTH = 3;
+const isStandaloneProject = (directory) => STANDALONE_PROJECT_LOCKFILES.some((lockfile) => existsSync(join(directory, lockfile)));
+const discoverImplicitSubProjects = (rootDir, alreadyDiscoveredDirectories) => {
+	const knownDirectories = new Set(alreadyDiscoveredDirectories);
+	const hasDeclaredWorkspaces = alreadyDiscoveredDirectories.length > 0;
+	const subProjectDirectories = [];
+	const subPackageJsonPaths = fg.sync("**/package.json", {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**",
+			"**/.git/**"
+		],
+		deep: IMPLICIT_SUB_PROJECT_SEARCH_DEPTH + 1
+	});
+	for (const packageJsonPath of subPackageJsonPaths) {
+		const directory = packageJsonPath.replace(/\/package\.json$/, "");
+		if (directory === rootDir) continue;
+		if (knownDirectories.has(directory)) continue;
+		if (hasDeclaredWorkspaces && isStandaloneProject(directory)) continue;
+		subProjectDirectories.push(directory);
+	}
+	return subProjectDirectories;
+};
+const collectWorkspacePatterns = (rootDir) => {
+	const patterns = [];
+	const packageJsonPath = join(rootDir, "package.json");
+	if (existsSync(packageJsonPath)) try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		if (Array.isArray(packageJson.workspaces)) patterns.push(...packageJson.workspaces);
+		else if (packageJson.workspaces?.packages) patterns.push(...packageJson.workspaces.packages);
+	} catch {}
+	const pnpmWorkspacePath = join(rootDir, "pnpm-workspace.yaml");
+	if (existsSync(pnpmWorkspacePath)) try {
+		const packageLines = extractPnpmWorkspacePackages(readFileSync(pnpmWorkspacePath, "utf-8"));
+		patterns.push(...packageLines);
+	} catch {}
+	const lernaJsonPath = join(rootDir, "lerna.json");
+	if (existsSync(lernaJsonPath)) try {
+		const content = readFileSync(lernaJsonPath, "utf-8");
+		const lernaJson = JSON.parse(content);
+		if (Array.isArray(lernaJson.packages)) patterns.push(...lernaJson.packages.filter((pattern) => typeof pattern === "string" && !pattern.startsWith("!")));
+	} catch {}
+	return patterns;
+};
+const extractPnpmWorkspacePackages = (yamlContent) => {
+	const packages = [];
+	let inPackagesSection = false;
+	for (const line of yamlContent.split("\n")) {
+		const trimmedLine = line.trim();
+		if (trimmedLine === "packages:") {
+			inPackagesSection = true;
+			continue;
+		}
+		if (inPackagesSection) {
+			if (trimmedLine.startsWith("- ")) {
+				const pattern = trimmedLine.slice(2).trim().replace(/^["']|["']$/g, "");
+				if (pattern && !pattern.startsWith("!")) packages.push(pattern);
+			} else if (trimmedLine && !trimmedLine.startsWith("#")) break;
+		}
+	}
+	return packages;
+};
+const expandWorkspaceGlobs = (patterns, rootDir) => {
+	const directories = [];
+	for (const pattern of patterns) if (pattern.includes("*")) {
+		const globPattern = pattern.endsWith("/") ? `${pattern}package.json` : `${pattern}/package.json`;
+		try {
+			const matchedFiles = fg.sync(globPattern, {
+				cwd: rootDir,
+				absolute: true,
+				onlyFiles: true
+			});
+			for (const matchedPath of matchedFiles) directories.push(matchedPath.replace(/\/package\.json$/, ""));
+		} catch {}
+	} else {
+		const absoluteDirectory = resolve(rootDir, pattern);
+		if (existsSync(join(absoluteDirectory, "package.json"))) directories.push(absoluteDirectory);
+	}
+	return [...new Set(directories)];
+};
+const SOURCE_EXTENSIONS$2 = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs"
+];
+const OUTPUT_DIR_PREFIXES$1 = [
+	"dist/",
+	"build/",
+	"lib/",
+	"lib-dist/",
+	"esm/",
+	"cjs/",
+	"out/",
+	"./dist/",
+	"./lib-dist/"
+];
+const SOURCE_INDEX_FALLBACK_STEMS$1 = [
+	"src/index",
+	"src/main",
+	"index",
+	"main"
+];
+const resolveSourcePath$1 = (distPath, directory) => {
+	const relativeToDist = relative(directory, distPath);
+	if (OUTPUT_DIR_PREFIXES$1.some((prefix) => relativeToDist.startsWith(prefix))) {
+		const sourceVariants = OUTPUT_DIR_PREFIXES$1.map((prefix) => relativeToDist.replace(new RegExp(`^${prefix.replace(".", "\\.")}`), "src/")).filter((variant) => variant !== relativeToDist);
+		for (const variant of sourceVariants) {
+			const withoutExtension = variant.replace(/\.[^.]+$/, "");
+			for (const sourceExtension of SOURCE_EXTENSIONS$2) {
+				const sourceCandidate = resolve(directory, withoutExtension + sourceExtension);
+				if (existsSync(sourceCandidate)) return [sourceCandidate];
+			}
+		}
+		for (const stem of SOURCE_INDEX_FALLBACK_STEMS$1) for (const sourceExtension of SOURCE_EXTENSIONS$2) {
+			const fallbackCandidate = resolve(directory, stem + sourceExtension);
+			if (existsSync(fallbackCandidate)) return [fallbackCandidate];
+		}
+		return [];
+	}
+	const resolvedDistPath = resolve(directory, relativeToDist);
+	const candidates = [];
+	const withoutJsExtension = relativeToDist.replace(/\.[cm]?js$/, "");
+	if (withoutJsExtension !== relativeToDist) {
+		for (const sourceExtension of SOURCE_EXTENSIONS$2) {
+			const directSourceCandidate = resolve(directory, withoutJsExtension + sourceExtension);
+			if (existsSync(directSourceCandidate)) candidates.push(directSourceCandidate);
+		}
+		const indexCandidate = resolve(directory, withoutJsExtension, "index.ts");
+		if (existsSync(indexCandidate) && !candidates.includes(indexCandidate)) candidates.push(indexCandidate);
+	}
+	const withoutTsExtension = relativeToDist.replace(/\.ts$/, "");
+	if (withoutTsExtension !== relativeToDist && !existsSync(resolvedDistPath)) {
+		const tsxCandidate = resolve(directory, withoutTsExtension + ".tsx");
+		if (existsSync(tsxCandidate) && !candidates.includes(tsxCandidate)) candidates.push(tsxCandidate);
+	}
+	if (candidates.length === 0 && existsSync(resolvedDistPath)) candidates.push(resolvedDistPath);
+	return candidates;
+};
+const extractWorkspaceEntries = (packageJson, directory) => {
+	const entries = [];
+	const addWithSourceResolution = (filePath) => {
+		const resolved = resolve(directory, filePath);
+		const sourceVariants = resolveSourcePath$1(resolved, directory);
+		if (sourceVariants.length > 0) entries.push(...sourceVariants);
+		else entries.push(resolved);
+	};
+	for (const field of [
+		"main",
+		"module",
+		"browser",
+		"types",
+		"typings",
+		"source"
+	]) {
+		const fieldValue = packageJson[field];
+		if (typeof fieldValue === "string") addWithSourceResolution(fieldValue);
+	}
+	if (packageJson.exports) {
+		const exportPaths = [];
+		collectExportPaths$1(packageJson.exports, directory, exportPaths);
+		for (const exportPath of exportPaths) {
+			const sourceVariants = resolveSourcePath$1(exportPath, directory);
+			if (sourceVariants.length > 0) entries.push(...sourceVariants);
+			else entries.push(exportPath);
+		}
+	}
+	if (packageJson.bin) {
+		if (typeof packageJson.bin === "string") addWithSourceResolution(packageJson.bin);
+		else if (typeof packageJson.bin === "object" && packageJson.bin !== null) {
+			for (const binPath of Object.values(packageJson.bin)) if (typeof binPath === "string") addWithSourceResolution(binPath);
+		}
+	}
+	return [...new Set(entries)];
+};
+const collectExportPaths$1 = (exportValue, rootDir, entries) => {
+	if (typeof exportValue === "string") {
+		if (exportValue.startsWith(".")) if (exportValue.includes("*")) {
+			const globPattern = exportValue.replace(/^\.\/?/, "");
+			try {
+				const expandedFiles = fg.sync(globPattern, {
+					cwd: rootDir,
+					absolute: true,
+					onlyFiles: true,
+					ignore: ["**/node_modules/**"]
+				});
+				entries.push(...expandedFiles);
+			} catch {}
+		} else entries.push(resolve(rootDir, exportValue));
+		return;
+	}
+	if (typeof exportValue !== "object" || exportValue === null) return;
+	for (const nestedValue of Object.values(exportValue)) collectExportPaths$1(nestedValue, rootDir, entries);
+};
+const NEXTJS_APP_ROUTER_CONVENTIONS = [
+	"page",
+	"layout",
+	"loading",
+	"error",
+	"not-found",
+	"template",
+	"default",
+	"route",
+	"global-error",
+	"forbidden",
+	"unauthorized",
+	"middleware",
+	"instrumentation",
+	"manifest",
+	"robots",
+	"sitemap",
+	"opengraph-image",
+	"twitter-image",
+	"icon",
+	"apple-icon",
+	"actions"
+];
+const FRAMEWORK_FILE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs}";
+const FRAMEWORK_FILE_GLOB_WITH_MDX = "**/*.{ts,tsx,js,jsx,mdx,md,mjs,cjs}";
+const NEXTJS_ENABLERS = ["next"];
+const REACT_ROUTER_ENABLERS = ["@react-router/dev"];
+const REMIX_ENABLERS = [
+	"@remix-run/node",
+	"@remix-run/react",
+	"@remix-run/cloudflare",
+	"@remix-run/cloudflare-pages",
+	"@remix-run/deno"
+];
+const NUXT_ENABLERS = ["nuxt"];
+const SVELTEKIT_ENABLERS = ["@sveltejs/kit"];
+const ASTRO_ENABLERS = ["astro"];
+const GATSBY_ENABLERS = ["gatsby"];
+const readDependencies = (directory) => {
+	const packageJsonPath = join(directory, "package.json");
+	if (!existsSync(packageJsonPath)) return {};
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		return {
+			...packageJson.dependencies,
+			...packageJson.devDependencies,
+			...packageJson.optionalDependencies
+		};
+	} catch {
+		return {};
+	}
+};
+const hasAnyEnabler = (dependencies, enablers) => enablers.some((enabler) => enabler in dependencies);
+const extractReactRouterAppDirectory = (directory) => {
+	for (const configFile of [
+		"react-router.config.ts",
+		"react-router.config.js",
+		"react-router.config.mjs",
+		"react-router.config.cjs"
+	]) {
+		const configPath = join(directory, configFile);
+		if (!existsSync(configPath)) continue;
+		try {
+			const appDirectoryMatch = readFileSync(configPath, "utf-8").match(/appDirectory\s*:\s*['"`]([^'"`]+)['"`]/);
+			if (appDirectoryMatch) return appDirectoryMatch[1].replace(/^\.\//, "");
+		} catch {}
+	}
+	return "app";
+};
+const ROUTE_FILE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+];
+const resolveRouteModulePath = (modulePath, routesFileDirectory) => {
+	const normalizedPath = modulePath.startsWith("./") ? modulePath.slice(2) : modulePath;
+	if (ROUTE_FILE_EXTENSIONS.some((extension) => normalizedPath.endsWith(extension))) {
+		const absolutePath = resolve(routesFileDirectory, normalizedPath);
+		if (existsSync(absolutePath)) return absolutePath;
+		return;
+	}
+	for (const extension of ROUTE_FILE_EXTENSIONS) {
+		const absolutePath = resolve(routesFileDirectory, normalizedPath + extension);
+		if (existsSync(absolutePath)) return absolutePath;
+	}
+	for (const extension of ROUTE_FILE_EXTENSIONS) {
+		const absolutePath = resolve(routesFileDirectory, normalizedPath, `index${extension}`);
+		if (existsSync(absolutePath)) return absolutePath;
+	}
+};
+const extractRouteModuleEntriesFromRoutesFiles = (rootDir, appDirectory) => {
+	const routesFileCandidates = fg.sync([
+		`${appDirectory}/routes.{ts,js,mts,mjs}`,
+		`${appDirectory}/routes/**/*.{ts,js,mts,mjs}`,
+		`src/routes.{ts,js,mts,mjs}`
+	], {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const resolvedEntries = [];
+	for (const routesFilePath of routesFileCandidates) {
+		const routesFileDirectory = dirname(routesFilePath);
+		const modulePaths = extractReactRouterRouteModuleEntries(routesFilePath);
+		for (const modulePath of modulePaths) {
+			const resolvedPath = resolveRouteModulePath(modulePath, routesFileDirectory);
+			if (resolvedPath) resolvedEntries.push(resolvedPath);
+		}
+	}
+	return resolvedEntries;
+};
+const detectFrameworkEntries = (rootDir) => {
+	const entryPoints = [];
+	const dependencies = readDependencies(rootDir);
+	const isNextjs = hasAnyEnabler(dependencies, NEXTJS_ENABLERS);
+	const isReactRouter = hasAnyEnabler(dependencies, REACT_ROUTER_ENABLERS);
+	const isRemix = hasAnyEnabler(dependencies, REMIX_ENABLERS);
+	const isNuxt = hasAnyEnabler(dependencies, NUXT_ENABLERS);
+	const isSvelteKit = hasAnyEnabler(dependencies, SVELTEKIT_ENABLERS);
+	const isAstro = hasAnyEnabler(dependencies, ASTRO_ENABLERS);
+	const isGatsby = hasAnyEnabler(dependencies, GATSBY_ENABLERS);
+	if (isNextjs) {
+		const appRouterConventionGlob = NEXTJS_APP_ROUTER_CONVENTIONS.map((convention) => `**/${convention}.{ts,tsx,js,jsx,mdx}`).join(",");
+		const appDirs = [join(rootDir, "app"), join(rootDir, "src", "app")];
+		for (const appDir of appDirs) if (existsSync(appDir) && statSync(appDir).isDirectory()) entryPoints.push(...fg.sync(`{${appRouterConventionGlob}}`, {
+			cwd: appDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+		const pagesDirs = [join(rootDir, "pages"), join(rootDir, "src", "pages")];
+		for (const pagesDir of pagesDirs) if (existsSync(pagesDir) && statSync(pagesDir).isDirectory()) entryPoints.push(...fg.sync(FRAMEWORK_FILE_GLOB, {
+			cwd: pagesDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+		entryPoints.push(...fg.sync([
+			"middleware.{ts,js}",
+			"src/middleware.{ts,js}",
+			"instrumentation.{ts,js}",
+			"instrumentation-client.{ts,js}",
+			"src/instrumentation.{ts,js}",
+			"src/instrumentation-client.{ts,js}",
+			"mdx-components.{ts,tsx,js,jsx}",
+			"src/mdx-components.{ts,tsx,js,jsx}"
+		], {
+			cwd: rootDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	if (isReactRouter || isRemix) {
+		const reactRouterAppDirectory = extractReactRouterAppDirectory(rootDir);
+		entryPoints.push(...fg.sync([
+			`${reactRouterAppDirectory}/routes/**/*.{ts,tsx,js,jsx}`,
+			`${reactRouterAppDirectory}/root.{ts,tsx,js,jsx}`,
+			`${reactRouterAppDirectory}/entry.client.{ts,tsx,js,jsx}`,
+			`${reactRouterAppDirectory}/entry.server.{ts,tsx,js,jsx}`,
+			`${reactRouterAppDirectory}/routes.{ts,js,mts,mjs}`
+		], {
+			cwd: rootDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+		const routeModuleEntries = extractRouteModuleEntriesFromRoutesFiles(rootDir, reactRouterAppDirectory);
+		entryPoints.push(...routeModuleEntries);
+	}
+	if (isNuxt) for (const nuxtDir of [
+		"pages",
+		"layouts",
+		"middleware",
+		"server",
+		"composables",
+		"plugins"
+	]) {
+		const dirPath = join(rootDir, nuxtDir);
+		if (existsSync(dirPath) && statSync(dirPath).isDirectory()) entryPoints.push(...fg.sync("**/*.{ts,tsx,js,jsx,vue}", {
+			cwd: dirPath,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	if (isSvelteKit) {
+		const svelteDirs = [
+			join(rootDir, "src", "routes"),
+			join(rootDir, "src", "lib"),
+			join(rootDir, "src", "params")
+		];
+		for (const svelteDir of svelteDirs) if (existsSync(svelteDir) && statSync(svelteDir).isDirectory()) entryPoints.push(...fg.sync("**/*.{ts,tsx,js,jsx,svelte}", {
+			cwd: svelteDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	if (isAstro) {
+		const astroDirs = [
+			join(rootDir, "src", "pages"),
+			join(rootDir, "src", "layouts"),
+			join(rootDir, "src", "content")
+		];
+		for (const astroDir of astroDirs) if (existsSync(astroDir) && statSync(astroDir).isDirectory()) entryPoints.push(...fg.sync(FRAMEWORK_FILE_GLOB_WITH_MDX, {
+			cwd: astroDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	if (isGatsby) {
+		const gatsbyDirs = [join(rootDir, "src", "pages"), join(rootDir, "src", "templates")];
+		for (const gatsbyDir of gatsbyDirs) if (existsSync(gatsbyDir) && statSync(gatsbyDir).isDirectory()) entryPoints.push(...fg.sync(FRAMEWORK_FILE_GLOB, {
+			cwd: gatsbyDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	entryPoints.push(...fg.sync([
+		"**/*.stories.{ts,tsx,js,jsx,mts,mjs}",
+		"**/*.story.{ts,tsx,js,jsx,mts,mjs}",
+		".storybook/**/*.{ts,tsx,js,jsx,mts,mjs}"
+	], {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		dot: true
+	}));
+	entryPoints.push(...fg.sync([
+		"env.{ts,js,mjs}",
+		"src/env.{ts,js,mjs}",
+		"src/routeTree.gen.{ts,tsx}",
+		"src/router.{ts,tsx}"
+	], {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		dot: true
+	}));
+	for (const entryDir of ["e2e", "cypress"]) {
+		const dirPath = join(rootDir, entryDir);
+		if (existsSync(dirPath) && statSync(dirPath).isDirectory()) entryPoints.push(...fg.sync(FRAMEWORK_FILE_GLOB, {
+			cwd: dirPath,
+			absolute: true,
+			onlyFiles: true,
+			dot: entryDir.startsWith(".")
+		}));
+	}
+	entryPoints.push(...discoverElectronEntryPoints(rootDir));
+	entryPoints.push(...discoverMobileEntryPoints(rootDir));
+	return [...new Set(entryPoints)];
+};
+const ELECTRON_ENABLERS = [
+	"electron",
+	"electron-builder",
+	"@electron-forge/cli",
+	"electron-vite"
+];
+const ELECTRON_ENTRY_PATTERNS = [
+	"src/main/**/*.{ts,js}",
+	"src/preload/**/*.{ts,js}",
+	"electron/main.{ts,js}",
+	"electron.vite.config.{ts,js,mjs}",
+	"forge.config.{ts,js,cjs}",
+	"electron-builder.{yml,yaml,json,json5,toml}"
+];
+const discoverElectronEntryPoints = (rootDir) => {
+	const packageJsonPath = join(rootDir, "package.json");
+	if (!existsSync(packageJsonPath)) return [];
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		const allDependencies = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies,
+			...packageJson.optionalDependencies
+		};
+		if (!ELECTRON_ENABLERS.some((enabler) => enabler in allDependencies)) return [];
+		return fg.sync(ELECTRON_ENTRY_PATTERNS, {
+			cwd: rootDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		});
+	} catch {
+		return [];
+	}
+};
+const EXPO_ENABLERS = ["expo"];
+const EXPO_ROUTER_ENABLERS = ["expo-router"];
+const EXPO_ENTRY_PATTERNS = [
+	"App.{ts,tsx,js,jsx}",
+	"src/App.{ts,tsx,js,jsx}",
+	"app.config.{ts,js,mjs,cjs}",
+	"metro.config.{ts,js,mjs,cjs}",
+	"babel.config.{ts,js,mjs,cjs}"
+];
+const EXPO_ROUTER_ENTRY_PATTERNS = [
+	"app/**/*.{ts,tsx,js,jsx}",
+	"src/app/**/*.{ts,tsx,js,jsx}",
+	"app.config.{ts,js,mjs,cjs}",
+	"metro.config.{ts,js,mjs,cjs}",
+	"babel.config.{ts,js,mjs,cjs}"
+];
+const REACT_NATIVE_ENABLERS = ["react-native"];
+const REACT_NATIVE_ENTRY_PATTERNS = [
+	"index.{ts,tsx,js,jsx}",
+	"index.android.{ts,tsx,js,jsx}",
+	"index.ios.{ts,tsx,js,jsx}",
+	"index.native.{ts,tsx,js,jsx}",
+	"App.{ts,tsx,js,jsx}",
+	"src/App.{ts,tsx,js,jsx}",
+	"metro.config.{ts,js}",
+	"react-native.config.{ts,js}"
+];
+const discoverMobileEntryPoints = (directory) => {
+	const packageJsonPath = join(directory, "package.json");
+	if (!existsSync(packageJsonPath)) return [];
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		const allDependencies = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies,
+			...packageJson.optionalDependencies
+		};
+		const detectedPatterns = [];
+		if (EXPO_ROUTER_ENABLERS.some((enabler) => enabler in allDependencies)) detectedPatterns.push(...EXPO_ROUTER_ENTRY_PATTERNS);
+		else if (EXPO_ENABLERS.some((enabler) => enabler in allDependencies)) detectedPatterns.push(...EXPO_ENTRY_PATTERNS);
+		if (REACT_NATIVE_ENABLERS.some((enabler) => enabler in allDependencies)) detectedPatterns.push(...REACT_NATIVE_ENTRY_PATTERNS);
+		if (detectedPatterns.length === 0) return [];
+		return fg.sync(detectedPatterns, {
+			cwd: directory,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		});
+	} catch {
+		return [];
+	}
+};
+
+//#endregion
+//#region src/collect/expo-config-plugin-entries.ts
+const EXPO_CONFIG_FILE_GLOBS = ["app.config.{ts,mts,cts,js,mjs,cjs}", "app.json"];
+const NESTED_EXPO_CONFIG_FILE_GLOBS = [
+	...EXPO_CONFIG_FILE_GLOBS,
+	"**/app.config.{ts,mts,cts,js,mjs,cjs}",
+	"**/app.json"
+];
+const EXPO_REACT_NATIVE_DEPENDENCIES = new Set(["expo", "react-native"]);
+const EXPO_PLUGIN_RESOLVABLE_EXTENSIONS = SOURCE_EXTENSIONS$3.map((sourceExtension) => `.${sourceExtension}`);
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isExpoOrReactNativeWorkspace = (dependencies) => [...EXPO_REACT_NATIVE_DEPENDENCIES].some((dependencyName) => dependencyName in dependencies);
+const isLocalExpoPluginPath = (value) => (value.startsWith("./") || value.startsWith("../")) && !value.includes("*") && !value.includes("?");
+const isFile = (filePath) => {
+	try {
+		return statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+};
+const resolveExpoPluginPath = (configDirectory, pluginPath) => {
+	const candidatePath = resolve(configDirectory, pluginPath);
+	if (isFile(candidatePath)) return candidatePath;
+	for (const extension of EXPO_PLUGIN_RESOLVABLE_EXTENSIONS) {
+		const candidatePathWithExtension = `${candidatePath}${extension}`;
+		if (isFile(candidatePathWithExtension)) return candidatePathWithExtension;
+	}
+	for (const extension of EXPO_PLUGIN_RESOLVABLE_EXTENSIONS) {
+		const indexCandidatePath = join(candidatePath, `index${extension}`);
+		if (isFile(indexCandidatePath)) return indexCandidatePath;
+	}
+};
+const addExpoPluginEntry = (entries, packageNamePlugins, rootDirectory, configDirectory, pluginPath) => {
+	if (!isLocalExpoPluginPath(pluginPath)) {
+		packageNamePlugins.add(pluginPath);
+		return;
+	}
+	const resolvedPath = resolveExpoPluginPath(configDirectory, pluginPath);
+	if (!resolvedPath) return;
+	const relativePath = relative(rootDirectory, resolvedPath);
+	if (relativePath !== "" && (relativePath.startsWith("..") || isAbsolute(relativePath))) return;
+	entries.add(resolvedPath);
+};
+const getPropertyName = (name) => {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+};
+const unwrapExpression = (expression) => {
+	let currentExpression = expression;
+	while (ts.isParenthesizedExpression(currentExpression)) currentExpression = currentExpression.expression;
+	return currentExpression;
+};
+const collectExpoPluginPathsFromArray = (array, entries, packageNamePlugins, rootDirectory, configDirectory) => {
+	for (const element of array.elements) {
+		if (ts.isStringLiteral(element) || ts.isNoSubstitutionTemplateLiteral(element)) {
+			addExpoPluginEntry(entries, packageNamePlugins, rootDirectory, configDirectory, element.text);
+			continue;
+		}
+		if (ts.isArrayLiteralExpression(element)) {
+			const [pluginName] = element.elements;
+			if (pluginName && (ts.isStringLiteral(pluginName) || ts.isNoSubstitutionTemplateLiteral(pluginName))) addExpoPluginEntry(entries, packageNamePlugins, rootDirectory, configDirectory, pluginName.text);
+		}
+	}
+};
+const collectExpoPluginPathsFromConfigObject = (objectLiteral, entries, packageNamePlugins, rootDirectory, configDirectory) => {
+	for (const property of objectLiteral.properties) {
+		if (!ts.isPropertyAssignment(property)) continue;
+		const propertyName = getPropertyName(property.name);
+		if (propertyName === "plugins" && ts.isArrayLiteralExpression(property.initializer)) collectExpoPluginPathsFromArray(property.initializer, entries, packageNamePlugins, rootDirectory, configDirectory);
+		if (propertyName === "expo" && ts.isObjectLiteralExpression(property.initializer)) collectExpoPluginPathsFromConfigObject(property.initializer, entries, packageNamePlugins, rootDirectory, configDirectory);
+	}
+};
+const collectReturnedExpoConfigPluginPaths = (body, entries, packageNamePlugins, rootDirectory, configDirectory) => {
+	if (!ts.isBlock(body)) {
+		const expression = unwrapExpression(body);
+		if (ts.isObjectLiteralExpression(expression)) collectExpoPluginPathsFromConfigObject(expression, entries, packageNamePlugins, rootDirectory, configDirectory);
+		return;
+	}
+	const visit = (node) => {
+		if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return;
+		if (ts.isReturnStatement(node) && node.expression) {
+			const expression = unwrapExpression(node.expression);
+			if (ts.isObjectLiteralExpression(expression)) collectExpoPluginPathsFromConfigObject(expression, entries, packageNamePlugins, rootDirectory, configDirectory);
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(body);
+};
+const collectExpoPluginPathsFromConfigExpression = (expression, entries, packageNamePlugins, rootDirectory, configDirectory, bindings, seenIdentifiers = /* @__PURE__ */ new Set()) => {
+	const configExpression = unwrapExpression(expression);
+	if (ts.isObjectLiteralExpression(configExpression)) {
+		collectExpoPluginPathsFromConfigObject(configExpression, entries, packageNamePlugins, rootDirectory, configDirectory);
+		return;
+	}
+	if (ts.isIdentifier(configExpression)) {
+		if (seenIdentifiers.has(configExpression.text)) return;
+		seenIdentifiers.add(configExpression.text);
+		const boundExpression = bindings.expressions.get(configExpression.text);
+		if (boundExpression) {
+			collectExpoPluginPathsFromConfigExpression(boundExpression, entries, packageNamePlugins, rootDirectory, configDirectory, bindings, seenIdentifiers);
+			return;
+		}
+		const boundFunction = bindings.functions.get(configExpression.text);
+		if (boundFunction?.body) collectReturnedExpoConfigPluginPaths(boundFunction.body, entries, packageNamePlugins, rootDirectory, configDirectory);
+		return;
+	}
+	if (ts.isArrowFunction(configExpression)) {
+		collectReturnedExpoConfigPluginPaths(configExpression.body, entries, packageNamePlugins, rootDirectory, configDirectory);
+		return;
+	}
+	if (ts.isFunctionExpression(configExpression) && configExpression.body) collectReturnedExpoConfigPluginPaths(configExpression.body, entries, packageNamePlugins, rootDirectory, configDirectory);
+};
+const hasDefaultExportModifier = (node) => Boolean(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword));
+const isModuleExportsAssignmentTarget = (node) => ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "module" && node.name.text === "exports";
+const collectStaticConfigBindings = (sourceFile) => {
+	const expressions = /* @__PURE__ */ new Map();
+	const functions = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) expressions.set(declaration.name.text, declaration.initializer);
+			continue;
+		}
+		if (ts.isFunctionDeclaration(statement) && statement.name) functions.set(statement.name.text, statement);
+	}
+	return {
+		expressions,
+		functions
+	};
+};
+const collectExpoPluginPathsFromAppConfig = (configPath, entries, packageNamePlugins, rootDirectory) => {
+	const extension = extname(configPath);
+	const sourceFile = ts.createSourceFile(configPath, readFileSync(configPath, "utf8"), ts.ScriptTarget.Latest, true, extension === ".ts" || extension === ".mts" || extension === ".cts" ? ts.ScriptKind.TS : ts.ScriptKind.JS);
+	const configDirectory = dirname(configPath);
+	const bindings = collectStaticConfigBindings(sourceFile);
+	const visit = (node) => {
+		if (ts.isExportAssignment(node)) {
+			collectExpoPluginPathsFromConfigExpression(node.expression, entries, packageNamePlugins, rootDirectory, configDirectory, bindings);
+			return;
+		}
+		if (ts.isFunctionDeclaration(node) && hasDefaultExportModifier(node) && node.body) {
+			collectReturnedExpoConfigPluginPaths(node.body, entries, packageNamePlugins, rootDirectory, configDirectory);
+			return;
+		}
+		if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && isModuleExportsAssignmentTarget(node.left)) {
+			collectExpoPluginPathsFromConfigExpression(node.right, entries, packageNamePlugins, rootDirectory, configDirectory, bindings);
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+};
+const collectPluginPathsFromJsonValue = (value) => {
+	if (!Array.isArray(value)) return [];
+	const pluginPaths = [];
+	for (const plugin of value) {
+		if (typeof plugin === "string") {
+			pluginPaths.push(plugin);
+			continue;
+		}
+		if (Array.isArray(plugin) && typeof plugin[0] === "string") pluginPaths.push(plugin[0]);
+	}
+	return pluginPaths;
+};
+const collectExpoPluginPathsFromAppJson = (configPath, entries, packageNamePlugins, rootDirectory) => {
+	const parsedJson = JSON.parse(readFileSync(configPath, "utf8"));
+	const configDirectory = dirname(configPath);
+	if (!isRecord(parsedJson)) return;
+	const expoConfig = parsedJson.expo;
+	const expoPluginPaths = isRecord(expoConfig) ? collectPluginPathsFromJsonValue(expoConfig.plugins) : [];
+	for (const pluginPath of [...expoPluginPaths, ...collectPluginPathsFromJsonValue(parsedJson.plugins)]) addExpoPluginEntry(entries, packageNamePlugins, rootDirectory, configDirectory, pluginPath);
+};
+const collectExpoPluginPathsFromConfig = (configPath, entries, packageNamePlugins, rootDirectory) => {
+	try {
+		if (basename(configPath) === "app.json") {
+			collectExpoPluginPathsFromAppJson(configPath, entries, packageNamePlugins, rootDirectory);
+			return;
+		}
+		collectExpoPluginPathsFromAppConfig(configPath, entries, packageNamePlugins, rootDirectory);
+	} catch {}
+};
+const extractExpoConfigPluginEntries = (directory, dependencies, rootDirectory = directory, includeNestedConfigs = true) => {
+	if (!isExpoOrReactNativeWorkspace(dependencies)) return {
+		filePaths: [],
+		packageNames: []
+	};
+	const entries = /* @__PURE__ */ new Set();
+	const packageNamePlugins = /* @__PURE__ */ new Set();
+	const configPaths = fg.sync(includeNestedConfigs ? NESTED_EXPO_CONFIG_FILE_GLOBS : EXPO_CONFIG_FILE_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 6
+	});
+	for (const configPath of configPaths) collectExpoPluginPathsFromConfig(configPath, entries, packageNamePlugins, rootDirectory);
+	return {
+		filePaths: [...entries],
+		packageNames: [...packageNamePlugins]
+	};
+};
+
+//#endregion
+//#region src/resolver/source-path.ts
+const SOURCE_EXTENSIONS$1 = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs"
+];
+const OUTPUT_DIR_PREFIXES = [
+	"dist/esm/",
+	"dist/cjs/",
+	"dist/es/",
+	"dist/lib/",
+	"dist/",
+	"build/",
+	"lib/",
+	"lib-dist/",
+	"esm/",
+	"cjs/",
+	"out/"
+];
+const DIST_WILDCARD_PATTERN = /^dist-[^/]+\//;
+const SOURCE_INDEX_FALLBACK_STEMS = ["src/index", "src/main"];
+const matchesOutputDirectory = (relativePath) => OUTPUT_DIR_PREFIXES.some((prefix) => relativePath.startsWith(prefix)) || DIST_WILDCARD_PATTERN.test(relativePath);
+const resolveSourcePath = (distPath, directory) => {
+	if (existsSync(distPath)) return distPath;
+	const relativeToDist = relative(directory, distPath);
+	const sourceReplacements = ["src/"];
+	const allPrefixes = [...OUTPUT_DIR_PREFIXES];
+	const wildcardMatch = DIST_WILDCARD_PATTERN.exec(relativeToDist);
+	if (wildcardMatch) allPrefixes.push(wildcardMatch[0]);
+	const sourceVariants = allPrefixes.flatMap((prefix) => sourceReplacements.map((replacement) => relativeToDist.replace(new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), replacement))).filter((variant) => variant !== relativeToDist);
+	for (const variant of sourceVariants) {
+		const withoutExtension = variant.replace(/\.[^.]+$/, "");
+		for (const sourceExtension of SOURCE_EXTENSIONS$1) {
+			const sourceCandidate = resolve(directory, withoutExtension + sourceExtension);
+			if (existsSync(sourceCandidate)) return sourceCandidate;
+		}
+		const indexPrefixedCandidate = resolveWithIndexPrefix(withoutExtension, directory);
+		if (indexPrefixedCandidate) return indexPrefixedCandidate;
+	}
+	if (matchesOutputDirectory(relativeToDist)) for (const stem of SOURCE_INDEX_FALLBACK_STEMS) for (const sourceExtension of SOURCE_EXTENSIONS$1) {
+		const fallbackCandidate = resolve(directory, stem + sourceExtension);
+		if (existsSync(fallbackCandidate)) return fallbackCandidate;
+	}
+	const withoutExtension = relativeToDist.replace(/\.[cm]?js$/, "");
+	if (withoutExtension !== relativeToDist) {
+		for (const sourceExtension of SOURCE_EXTENSIONS$1) {
+			const directSourceCandidate = resolve(directory, withoutExtension + sourceExtension);
+			if (existsSync(directSourceCandidate)) return directSourceCandidate;
+		}
+		const indexCandidate = resolve(directory, withoutExtension, "index.ts");
+		if (existsSync(indexCandidate)) return indexCandidate;
+		const indexPrefixedCandidate = resolveWithIndexPrefix(withoutExtension, directory);
+		if (indexPrefixedCandidate) return indexPrefixedCandidate;
+	}
+};
+const resolveWithIndexPrefix = (stemPath, directory) => {
+	const indexPrefixedStem = `${dirname(stemPath)}/index.${basename(stemPath)}`;
+	for (const sourceExtension of SOURCE_EXTENSIONS$1) {
+		const candidate = resolve(directory, indexPrefixedStem + sourceExtension);
+		if (existsSync(candidate)) return candidate;
+	}
+};
+
+//#endregion
+//#region src/utils/find-monorepo-root.ts
+const MAX_MONOREPO_WALK_DEPTH = 5;
+const findMonorepoRoot = (rootDir) => {
+	let currentDirectory = resolve(rootDir);
+	let walkedDepth = 0;
+	while (walkedDepth < MAX_MONOREPO_WALK_DEPTH) {
+		const parentDirectory = dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+		walkedDepth++;
+		if (existsSync(join(currentDirectory, ".git"))) {
+			for (const marker of MONOREPO_ROOT_MARKERS) if (existsSync(join(currentDirectory, marker))) return currentDirectory;
+			const packageJsonPath = join(currentDirectory, "package.json");
+			if (existsSync(packageJsonPath)) try {
+				const content = readFileSync(packageJsonPath, "utf-8");
+				if (JSON.parse(content).workspaces) return currentDirectory;
+			} catch {}
+			for (const lockfile of LOCKFILE_MARKERS) if (existsSync(join(currentDirectory, lockfile))) return currentDirectory;
+			return;
+		}
+		for (const marker of MONOREPO_ROOT_MARKERS) if (existsSync(join(currentDirectory, marker))) return currentDirectory;
+		const packageJsonPath = join(currentDirectory, "package.json");
+		if (existsSync(packageJsonPath)) try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			if (JSON.parse(content).workspaces) return currentDirectory;
+		} catch {
+			continue;
+		}
+		for (const lockfile of LOCKFILE_MARKERS) if (existsSync(join(currentDirectory, lockfile))) return currentDirectory;
+	}
+};
+
+//#endregion
+//#region src/utils/resolve-entry-with-extensions.ts
+const RESOLVABLE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".cjs",
+	".cts"
+];
+const resolveEntryWithExtensions = (basePath) => {
+	if (existsSync(basePath)) return basePath;
+	for (const extension of RESOLVABLE_EXTENSIONS) {
+		const withExtension = basePath + extension;
+		if (existsSync(withExtension)) return withExtension;
+	}
+	for (const extension of RESOLVABLE_EXTENSIONS) {
+		const indexCandidate = join(basePath, `index${extension}`);
+		if (existsSync(indexCandidate)) return indexCandidate;
+	}
+};
+const resolveEntryPathWithExtensions = (entryPath, rootDirectory) => {
+	return resolveEntryWithExtensions(resolve(rootDirectory, entryPath));
+};
+
+//#endregion
+//#region src/collect/config-string-entries.ts
+const CONFIG_STRING_ENTRY_GLOBS = [
+	"webpack.config.{js,ts,mjs,cjs}",
+	"**/webpack*.config.{js,ts,mjs,cjs,babel.js}",
+	"**/configs/webpack.config.{js,ts,mjs,cjs,babel.js}",
+	"**/configs/webpack*.config.{js,ts,mjs,cjs,babel.js}",
+	"jest.config.{js,ts,mjs,cjs,cts}",
+	"**/jest.config.{js,ts,mjs,cjs,cts}",
+	"vitest.config.{js,ts,mjs,mts}",
+	"**/vitest.config.{js,ts,mjs,mts}",
+	"**/vitest.*.config.{js,ts,mjs,mts}",
+	"vite.config.{js,ts,mjs,mts}",
+	"tailwind.config.{js,ts,cjs,mjs}",
+	"**/tailwind.config.{js,ts,cjs,mjs}",
+	"electron.vite.config.{js,ts,mjs}",
+	"electron-builder.config.{js,ts,cjs}",
+	"esbuild*.ts",
+	"**/esbuild.entrypoints.ts",
+	"metro.config.{js,ts}",
+	"playwright.config.{js,ts}",
+	"cypress.config.{js,ts}",
+	"rollup.config.{js,ts,mjs,cjs}",
+	"rollup.*.config.js",
+	"**/.erb/configs/webpack*.config.{js,ts}",
+	"**/.erb/configs/webpack.config.*.{js,ts}",
+	"**/astro-tina-directive/register.js",
+	"rspack.config.{js,ts,mjs,cjs}",
+	"rsbuild.config.{js,ts,mjs,cjs}",
+	"**/scripts/build.ts",
+	"**/scripts/utils/createJestConfig.js"
+];
+const CONFIG_RELATIVE_PATH_PATTERN = /['"`]((\.{1,2}\/|\.\.\/)[^'"`\n]+?|\.\/[^'"`\n]+?)['"`]/g;
+const JEST_ROOT_DIR_PATH_PATTERN = /<rootDir>\/([^'"`\n]+?)(?:['"`]|$)/g;
+const RESOLVE_CALL_PATH_PATTERN = /resolve\s*\(\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const PATH_JOIN_STRING_PATTERN = /path\.(?:join|resolve)\(\s*[^,]+,\s*['"`]([^'"`\n]+?)['"`]/g;
+const ENTRY_POINTS_STRING_PATTERN = /entryPoints:\s*\[\s*['"`]([^'"`\n]+?)['"`]/g;
+const ADD_PREAMBLE_PATTERN = /addPreamble\s*\(\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const ROLLUP_INPUT_PATTERN = /\binput\s*:\s*['"`]([^'"`\n]+?)['"`]/g;
+const VITEST_ENVIRONMENT_PATTERN = /environment\s*:\s*['"`](\.\/[^'"`\n]+?)['"`]/g;
+const ASTRO_ENTRYPOINT_PATTERN = /entrypoint\s*:\s*['"`](\.\/[^'"`\n]+?)['"`]/g;
+const WEBPACK_PATH_JOIN_ENTRY_PATTERN = /path\.join\(\s*[^,]+,\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const WEBPACK_RENDERER_PATH_JOIN_PATTERN = /path\.join\(\s*webpackPaths\.srcRendererPath\s*,\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const WEBPACK_MAIN_PATH_JOIN_PATTERN = /path\.join\(\s*webpackPaths\.srcMainPath\s*,\s*['"`]([^'"`\n]+?)['"`]\s*\)/g;
+const BARE_CONFIG_PATH_PATTERN = /['"`](config\/[^'"`\n]+?)['"`]/g;
+const stripModuleImportStatements = (content) => content.replace(/^\s*import\s+(?:type\s+)?[\s\S]*?\sfrom\s+['"`][^'"`\n]+['"`]\s*;?\s*$/gm, "").replace(/^\s*import\s+['"`][^'"`\n]+['"`]\s*;?\s*$/gm, "");
+const shouldSkipConfigPath = (rawPath) => {
+	if (rawPath.includes("*") || rawPath.includes("?")) return true;
+	if (rawPath.endsWith(".json") && !rawPath.includes("/src/")) return true;
+	if (rawPath.startsWith("node:")) return true;
+	if (rawPath.startsWith("@")) return true;
+	return false;
+};
+const addResolvedConfigPath = (rawPath, configDirectory, projectRootDirectory, entries) => {
+	if (shouldSkipConfigPath(rawPath)) return;
+	const resolvedEntry = resolveEntryWithExtensions(resolve(rawPath.startsWith(".") ? configDirectory : projectRootDirectory, rawPath.startsWith(".") ? rawPath : `./${rawPath}`));
+	if (resolvedEntry) {
+		entries.add(resolvedEntry);
+		return;
+	}
+	if (rawPath.startsWith(".")) {
+		const projectRootResolvedEntry = resolveEntryWithExtensions(resolve(projectRootDirectory, rawPath));
+		if (projectRootResolvedEntry) entries.add(projectRootResolvedEntry);
+	}
+};
+const collectResolvedPathsFromStrings = (content, configDirectory, projectRootDirectory, entries) => {
+	const contentWithoutImports = stripModuleImportStatements(content);
+	const patterns = [
+		CONFIG_RELATIVE_PATH_PATTERN,
+		RESOLVE_CALL_PATH_PATTERN,
+		PATH_JOIN_STRING_PATTERN,
+		ENTRY_POINTS_STRING_PATTERN,
+		ADD_PREAMBLE_PATTERN,
+		ROLLUP_INPUT_PATTERN,
+		VITEST_ENVIRONMENT_PATTERN,
+		ASTRO_ENTRYPOINT_PATTERN,
+		WEBPACK_PATH_JOIN_ENTRY_PATTERN,
+		BARE_CONFIG_PATH_PATTERN
+	];
+	for (const pattern of patterns) {
+		let pathMatch;
+		pattern.lastIndex = 0;
+		while ((pathMatch = pattern.exec(contentWithoutImports)) !== null) addResolvedConfigPath(pathMatch[1], configDirectory, projectRootDirectory, entries);
+	}
+	let rendererEntryMatch;
+	WEBPACK_RENDERER_PATH_JOIN_PATTERN.lastIndex = 0;
+	while ((rendererEntryMatch = WEBPACK_RENDERER_PATH_JOIN_PATTERN.exec(contentWithoutImports)) !== null) addResolvedConfigPath(`src/renderer/${rendererEntryMatch[1]}`, configDirectory, projectRootDirectory, entries);
+	let mainEntryMatch;
+	WEBPACK_MAIN_PATH_JOIN_PATTERN.lastIndex = 0;
+	while ((mainEntryMatch = WEBPACK_MAIN_PATH_JOIN_PATTERN.exec(contentWithoutImports)) !== null) addResolvedConfigPath(`src/main/${mainEntryMatch[1]}`, configDirectory, projectRootDirectory, entries);
+	let rootDirMatch;
+	JEST_ROOT_DIR_PATH_PATTERN.lastIndex = 0;
+	while ((rootDirMatch = JEST_ROOT_DIR_PATH_PATTERN.exec(content)) !== null) addResolvedConfigPath(rootDirMatch[1], configDirectory, projectRootDirectory, entries);
+};
+const extractConfigStringReferencedEntries = (directory) => {
+	const entries = /* @__PURE__ */ new Set();
+	const configPaths = fg.sync(CONFIG_STRING_ENTRY_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 6
+	});
+	for (const configPath of configPaths) try {
+		collectResolvedPathsFromStrings(readFileSync(configPath, "utf-8"), dirname(configPath), directory, entries);
+	} catch {
+		continue;
+	}
+	return [...entries];
+};
+
+//#endregion
+//#region src/collect/sections-module-entries.ts
+const SECTIONS_FILE_GLOBS = ["sections.js", "**/sections.js"];
+const CALYPSO_MODULE_PATTERN = /module:\s*['"]calypso\/([^'"]+)['"]/g;
+const SECTION_BOOTSTRAP_SUFFIXES = [
+	"",
+	"/index",
+	"/index.js",
+	"/index.jsx",
+	"/index.ts",
+	"/index.tsx",
+	"/main",
+	"/controller",
+	"/controller.js",
+	"/controller.jsx"
+];
+const addSectionModuleEntry = (modulePath, projectRootDirectory, entries) => {
+	const moduleBasePath = resolve(projectRootDirectory, modulePath.replace(/^calypso\//, ""));
+	for (const suffix of SECTION_BOOTSTRAP_SUFFIXES) {
+		const resolvedEntry = resolveEntryWithExtensions(suffix ? `${moduleBasePath}${suffix}` : moduleBasePath);
+		if (resolvedEntry) entries.add(resolvedEntry);
+	}
+};
+const extractSectionsModuleEntries = (directory) => {
+	const entries = /* @__PURE__ */ new Set();
+	const sectionsFilePaths = fg.sync(SECTIONS_FILE_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 4
+	});
+	for (const sectionsFilePath of sectionsFilePaths) {
+		if (!sectionsFilePath.endsWith("/client/sections.js")) continue;
+		try {
+			const content = readFileSync(sectionsFilePath, "utf-8");
+			let moduleMatch;
+			CALYPSO_MODULE_PATTERN.lastIndex = 0;
+			while ((moduleMatch = CALYPSO_MODULE_PATTERN.exec(content)) !== null) addSectionModuleEntry(moduleMatch[1], directory, entries);
+		} catch {
+			continue;
+		}
+	}
+	return [...entries];
+};
+
+//#endregion
+//#region src/utils/to-posix-path.ts
+const toPosixPath = (filePath) => filePath.replace(/\\/g, "/");
+
+//#endregion
+//#region src/resolver/resolve.ts
+const fileExistsCache = /* @__PURE__ */ new Map();
+const pathExistsCache = /* @__PURE__ */ new Map();
+const fileContentCache = /* @__PURE__ */ new Map();
+const cachedReadFileSync = (filePath) => {
+	const cached = fileContentCache.get(filePath);
+	if (cached !== void 0) return cached;
+	const content = readFileSync(filePath, "utf-8");
+	fileContentCache.set(filePath, content);
+	return content;
+};
+const cachedExistsSync = (targetPath) => {
+	const cached = pathExistsCache.get(targetPath);
+	if (cached !== void 0) return cached;
+	const result = existsSync(targetPath);
+	pathExistsCache.set(targetPath, result);
+	return result;
+};
+const existsAsFile = (filePath) => {
+	const cached = fileExistsCache.get(filePath);
+	if (cached !== void 0) return cached;
+	try {
+		const result = cachedExistsSync(filePath) && statSync(filePath).isFile();
+		fileExistsCache.set(filePath, result);
+		return result;
+	} catch {
+		fileExistsCache.set(filePath, false);
+		return false;
+	}
+};
+const trySourceFallback = (resolvedPath) => {
+	const segments = resolvedPath.split(sep);
+	const isOutputDirectory = (segment) => OUTPUT_DIRECTORIES.some((outputDirectory) => segment === outputDirectory || segment.startsWith(`${outputDirectory}-`));
+	let lastOutputPosition = -1;
+	for (let index = segments.length - 1; index >= 0; index--) if (isOutputDirectory(segments[index])) {
+		lastOutputPosition = index;
+		break;
+	}
+	if (lastOutputPosition === -1) return void 0;
+	let firstOutputPosition = lastOutputPosition;
+	while (firstOutputPosition > 0 && isOutputDirectory(segments[firstOutputPosition - 1])) firstOutputPosition--;
+	const prefix = segments.slice(0, firstOutputPosition).join(sep);
+	const suffix = segments.slice(lastOutputPosition + 1).join(sep);
+	if (!suffix) return void 0;
+	const fileExtension = extname(basename(suffix));
+	const stemmedSuffix = fileExtension ? suffix.slice(0, suffix.length - fileExtension.length) : suffix;
+	for (const sourceExtension of SOURCE_EXTENSIONS$3) {
+		const sourceCandidate = join(prefix, "src", `${stemmedSuffix}.${sourceExtension}`);
+		if (existsAsFile(sourceCandidate)) return sourceCandidate;
+	}
+};
+const resolvePathWithExtensionFallback = (candidatePath) => {
+	if (existsAsFile(candidatePath)) return candidatePath;
+	for (const extension of RESOLVER_EXTENSIONS) {
+		const withExtension = candidatePath + extension;
+		if (existsAsFile(withExtension)) return withExtension;
+	}
+	for (const extension of RESOLVER_EXTENSIONS) {
+		const indexCandidate = join(candidatePath, `index${extension}`);
+		if (existsAsFile(indexCandidate)) return indexCandidate;
+	}
+	return candidatePath;
+};
+const isExportConditionRecord = (value) => typeof value === "object" && value !== null;
+const EXPORT_CONDITION_PRIORITY = [
+	"import",
+	"require",
+	"default",
+	"types"
+];
+const resolveExportConditionTarget = (exportValue) => {
+	if (typeof exportValue === "string") return exportValue;
+	if (!isExportConditionRecord(exportValue)) return void 0;
+	for (const condition of EXPORT_CONDITION_PRIORITY) {
+		const conditionTarget = resolveExportConditionTarget(exportValue[condition]);
+		if (conditionTarget) return conditionTarget;
+	}
+};
+const resolveWorkspaceSubpath = (workspaceDirectory, subpath) => {
+	const workspacePackageJsonPath = join(workspaceDirectory, "package.json");
+	try {
+		const workspacePackageContent = cachedReadFileSync(workspacePackageJsonPath);
+		const workspacePackageJson = JSON.parse(workspacePackageContent);
+		let resolvedEntryPath;
+		if (subpath && workspacePackageJson.exports) {
+			const exportKey = `./${subpath}`;
+			const exactExportTarget = resolveExportConditionTarget(workspacePackageJson.exports[exportKey]);
+			if (exactExportTarget) {
+				const candidatePath = resolvePathWithExtensionFallback(resolve(workspaceDirectory, exactExportTarget));
+				resolvedEntryPath = existsAsFile(candidatePath) ? candidatePath : trySourceFallback(candidatePath);
+			}
+			if (!resolvedEntryPath) for (const [wildcardPattern, wildcardTarget] of Object.entries(workspacePackageJson.exports)) {
+				if (!wildcardPattern.includes("*")) continue;
+				const wildcardTargetValue = resolveExportConditionTarget(wildcardTarget);
+				if (!wildcardTargetValue) continue;
+				const wildcardPrefix = wildcardPattern.slice(0, wildcardPattern.indexOf("*"));
+				const wildcardSuffix = wildcardPattern.slice(wildcardPattern.indexOf("*") + 1);
+				if (exportKey.startsWith(wildcardPrefix) && exportKey.endsWith(wildcardSuffix)) {
+					const matchedSegment = exportKey.slice(wildcardPrefix.length, exportKey.length - wildcardSuffix.length || void 0);
+					const candidatePath = resolvePathWithExtensionFallback(resolve(workspaceDirectory, wildcardTargetValue.split("*").join(matchedSegment)));
+					resolvedEntryPath = existsAsFile(candidatePath) ? candidatePath : trySourceFallback(candidatePath);
+					break;
+				}
+			}
+		}
+		if (subpath && !resolvedEntryPath) {
+			const subpathCandidates = [resolve(workspaceDirectory, subpath), resolve(workspaceDirectory, "src", subpath)];
+			for (const directSubpath of subpathCandidates) {
+				for (const candidateExtension of RESOLVER_EXTENSIONS) {
+					const candidate = directSubpath + candidateExtension;
+					if (cachedExistsSync(candidate)) {
+						resolvedEntryPath = candidate;
+						break;
+					}
+				}
+				if (resolvedEntryPath) break;
+				for (const candidateExtension of RESOLVER_EXTENSIONS) {
+					const indexCandidate = join(directSubpath, `index${candidateExtension}`);
+					if (cachedExistsSync(indexCandidate)) {
+						resolvedEntryPath = indexCandidate;
+						break;
+					}
+				}
+				if (resolvedEntryPath) break;
+			}
+		}
+		if (!subpath) {
+			const mainField = workspacePackageJson.main ?? workspacePackageJson.module;
+			if (typeof mainField === "string") resolvedEntryPath = resolve(workspaceDirectory, mainField);
+			if (!resolvedEntryPath && workspacePackageJson.exports?.["."]) {
+				const dotExportTarget = resolveExportConditionTarget(workspacePackageJson.exports["."]);
+				if (dotExportTarget) resolvedEntryPath = resolve(workspaceDirectory, dotExportTarget);
+			}
+		}
+		if (resolvedEntryPath) {
+			const finalPath = resolveSourcePath(resolvedEntryPath, workspaceDirectory) ?? resolvedEntryPath;
+			if (cachedExistsSync(finalPath)) return finalPath;
+			const sourceFallbackPath = trySourceFallback(resolvedEntryPath);
+			if (sourceFallbackPath) return sourceFallbackPath;
+		}
+	} catch {}
+};
+
+//#endregion
+//#region src/collect/sibling-workspace-import-entries.ts
+const IMPORT_SPECIFIER_PATTERN = /(?:\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|\bimport\s+)["']([^"'\n]+)["']/g;
+const SIBLING_SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}";
+const SIBLING_IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/.git/**"
+];
+const readPackageName = (directory) => {
+	try {
+		const content = readFileSync(join(directory, "package.json"), "utf-8");
+		const packageJson = JSON.parse(content);
+		return typeof packageJson.name === "string" ? packageJson.name : void 0;
+	} catch {
+		return;
+	}
+};
+const extractImportSpecifiers = (sourceText) => {
+	const specifiers = [];
+	for (const specifierMatch of sourceText.matchAll(IMPORT_SPECIFIER_PATTERN)) specifiers.push(specifierMatch[1]);
+	return specifiers;
+};
+const extractSiblingWorkspaceImportEntries = (absoluteRoot) => {
+	const monorepoRoot = findMonorepoRoot(absoluteRoot);
+	if (!monorepoRoot || monorepoRoot === absoluteRoot) return [];
+	const packageName = readPackageName(absoluteRoot);
+	if (!packageName) return [];
+	const siblingDirectories = resolveWorkspaces(monorepoRoot).packages.map((workspacePackage) => workspacePackage.directory).filter((workspaceDirectory) => workspaceDirectory !== absoluteRoot && !workspaceDirectory.startsWith(`${absoluteRoot}/`) && !absoluteRoot.startsWith(`${workspaceDirectory}/`));
+	if (siblingDirectories.length === 0) return [];
+	const importedEntries = [];
+	for (const siblingDirectory of siblingDirectories) {
+		const siblingSourceFiles = fg.sync(SIBLING_SOURCE_GLOB, {
+			cwd: siblingDirectory,
+			absolute: true,
+			onlyFiles: true,
+			ignore: SIBLING_IGNORE_PATTERNS
+		});
+		for (const siblingSourceFile of siblingSourceFiles) {
+			let sourceText;
+			try {
+				sourceText = readFileSync(siblingSourceFile, "utf-8");
+			} catch {
+				continue;
+			}
+			if (!sourceText.includes(packageName)) continue;
+			for (const importSpecifier of extractImportSpecifiers(sourceText)) {
+				if (importSpecifier !== packageName && !importSpecifier.startsWith(`${packageName}/`)) continue;
+				const subpath = importSpecifier.slice(packageName.length + 1);
+				if (!subpath) continue;
+				const resolvedEntry = resolveWorkspaceSubpath(absoluteRoot, subpath);
+				if (resolvedEntry) importedEntries.push(trySourceFallback(resolvedEntry) ?? resolvedEntry);
+			}
+		}
+	}
+	return [...new Set(importedEntries)];
+};
+
+//#endregion
+//#region src/collect/entries.ts
+const resolveEntries = async (config) => {
+	const absoluteRoot = resolve(config.rootDir);
+	const entryFiles = config.entryPatterns.length > 0 ? await fg(config.entryPatterns, {
+		cwd: absoluteRoot,
+		absolute: true,
+		onlyFiles: true
+	}) : [];
+	const packageJsonEntries = await extractPackageJsonEntries(resolve(absoluteRoot, "package.json"));
+	const workspaceDiscovery = resolveWorkspaces(absoluteRoot);
+	const workspacePackages = workspaceDiscovery.packages;
+	const isEntryEligible = (workspacePackage) => {
+		if (workspaceDiscovery.hasRootLevelWorkspacePatterns) return true;
+		return workspacePackage.depthFromRoot <= 2;
+	};
+	const hasDeclaredWorkspaces = workspacePackages.some((workspacePackage) => workspacePackage.isDeclaredWorkspace);
+	const workspaceEntries = [];
+	for (const workspacePackage of workspacePackages) {
+		const isEligible = isEntryEligible(workspacePackage);
+		if (workspaceDiscovery.hasRootLevelWorkspacePatterns && hasDeclaredWorkspaces ? workspacePackage.isDeclaredWorkspace && isEligible : isEligible) {
+			const workspaceFrameworkEntries = detectFrameworkEntries(workspacePackage.directory);
+			workspaceEntries.push(...workspaceFrameworkEntries);
+		}
+		if (isEligible && (workspacePackage.isDeclaredWorkspace || !workspaceDiscovery.hasRootLevelWorkspacePatterns)) {
+			const workspacePackageJsonEntries = await extractPackageJsonEntries(resolve(workspacePackage.directory, "package.json"));
+			if (workspacePackageJsonEntries.some((entryPath) => existsSync(entryPath))) workspaceEntries.push(...workspacePackageJsonEntries);
+			else {
+				const defaultFallback = findDefaultIndexEntry(workspacePackage.directory);
+				if (defaultFallback) workspaceEntries.push(defaultFallback);
+			}
+		}
+	}
+	const frameworkEntries = detectFrameworkEntries(absoluteRoot);
+	const entryEligiblePackages = workspacePackages.filter(isEntryEligible);
+	const monorepoRootForEntries = findMonorepoRoot(absoluteRoot);
+	const ancestorPackageJsonRoots = monorepoRootForEntries && monorepoRootForEntries !== absoluteRoot ? [monorepoRootForEntries] : [];
+	const scriptEntries = extractScriptEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) scriptEntries.push(...extractScriptEntries(workspacePackage.directory));
+	for (const ancestorRoot of ancestorPackageJsonRoots) for (const entryPath of extractScriptEntries(ancestorRoot)) if (entryPath.startsWith(`${absoluteRoot}/`)) scriptEntries.push(entryPath);
+	const webpackEntries = extractWebpackEntryPoints(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) webpackEntries.push(...extractWebpackEntryPoints(workspacePackage.directory));
+	const viteEntries = extractViteEntryPoints(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) viteEntries.push(...extractViteEntryPoints(workspacePackage.directory));
+	const bundlerConfigEntries = extractBundlerConfigEntryPoints(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) bundlerConfigEntries.push(...extractBundlerConfigEntryPoints(workspacePackage.directory));
+	const htmlScriptEntries = extractHtmlScriptEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) htmlScriptEntries.push(...extractHtmlScriptEntries(workspacePackage.directory));
+	const allDiscoveredEntries = [
+		...scriptEntries,
+		...webpackEntries,
+		...viteEntries,
+		...bundlerConfigEntries
+	];
+	for (const entryPath of allDiscoveredEntries) if (entryPath.endsWith(".html") && existsSync(entryPath)) htmlScriptEntries.push(...extractScriptTagsFromHtmlFile(entryPath));
+	const angularEntries = extractAngularEntryPoints(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) angularEntries.push(...extractAngularEntryPoints(workspacePackage.directory));
+	const browserExtensionEntries = extractBrowserExtensionEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) browserExtensionEntries.push(...extractBrowserExtensionEntries(workspacePackage.directory));
+	const webWorkerEntries = extractWebWorkerEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) webWorkerEntries.push(...extractWebWorkerEntries(workspacePackage.directory));
+	const tsConfigIncludeEntries = extractTsConfigIncludeFilesEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) tsConfigIncludeEntries.push(...extractTsConfigIncludeFilesEntries(workspacePackage.directory));
+	const configStringEntries = extractConfigStringReferencedEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) configStringEntries.push(...extractConfigStringReferencedEntries(workspacePackage.directory));
+	const expoConfigPluginEntries = [...extractExpoConfigPluginEntries(absoluteRoot, readPackageJsonDependencies(join(absoluteRoot, "package.json")), absoluteRoot, false).filePaths];
+	for (const workspacePackage of entryEligiblePackages) {
+		const workspacePackageDependencies = readPackageJsonDependencies(join(workspacePackage.directory, "package.json"));
+		const workspaceExpoCollection = extractExpoConfigPluginEntries(workspacePackage.directory, workspacePackageDependencies, absoluteRoot);
+		expoConfigPluginEntries.push(...workspaceExpoCollection.filePaths);
+	}
+	const sectionsModuleEntries = extractSectionsModuleEntries(absoluteRoot);
+	const siblingWorkspaceImportEntries = extractSiblingWorkspaceImportEntries(absoluteRoot);
+	const wranglerEntries = extractWranglerEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) wranglerEntries.push(...extractWranglerEntries(workspacePackage.directory));
+	const testSetupEntries = extractTestSetupFiles(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) testSetupEntries.push(...extractTestSetupFiles(workspacePackage.directory));
+	const pluginFileEntries = extractNextConfigPluginFiles(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) pluginFileEntries.push(...extractNextConfigPluginFiles(workspacePackage.directory));
+	const testRunnerDiscovery = discoverTestRunnerEntryPoints(absoluteRoot, entryEligiblePackages);
+	const toolingDiscovery = discoverToolingEntryPoints(absoluteRoot, entryEligiblePackages);
+	const ciEntries = extractCiWorkflowEntries(absoluteRoot);
+	const testEntries = [...new Set([...testRunnerDiscovery.entryFiles, ...testSetupEntries].map(toPosixPath))];
+	const testEntryPathSet = new Set(testEntries);
+	return {
+		productionEntries: [...new Set([
+			...entryFiles,
+			...packageJsonEntries,
+			...workspaceEntries,
+			...frameworkEntries,
+			...scriptEntries,
+			...webpackEntries,
+			...viteEntries,
+			...bundlerConfigEntries,
+			...htmlScriptEntries,
+			...angularEntries,
+			...browserExtensionEntries,
+			...webWorkerEntries,
+			...tsConfigIncludeEntries,
+			...configStringEntries,
+			...expoConfigPluginEntries,
+			...sectionsModuleEntries,
+			...siblingWorkspaceImportEntries,
+			...wranglerEntries,
+			...pluginFileEntries,
+			...toolingDiscovery.entryFiles,
+			...ciEntries
+		].map(toPosixPath))].filter((entryPath) => !testEntryPathSet.has(entryPath)),
+		testEntries,
+		alwaysUsedFiles: [...new Set([...toolingDiscovery.alwaysUsedFiles, ...testRunnerDiscovery.alwaysUsedFiles].map(toPosixPath))]
+	};
+};
+const DEFAULT_INDEX_PATTERNS = [
+	"src/index.ts",
+	"src/index.tsx",
+	"src/index.js",
+	"src/index.jsx",
+	"src/main.ts",
+	"src/main.tsx",
+	"src/main.js",
+	"src/main.jsx",
+	"index.ts",
+	"index.tsx",
+	"index.js",
+	"index.jsx",
+	"main.ts",
+	"main.tsx",
+	"main.js",
+	"main.jsx"
+];
+const findDefaultIndexEntry = (directory) => {
+	for (const pattern of DEFAULT_INDEX_PATTERNS) {
+		const candidatePath = resolve(directory, pattern);
+		if (existsSync(candidatePath)) return candidatePath;
+	}
+};
+const SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+];
+const COMMON_SOURCE_DIRECTORIES = [
+	"src",
+	"lib",
+	"main",
+	"app",
+	"source"
+];
+const BUILD_OUTPUT_DIRECTORY_PATTERN = /^(?:\.\/)?(?:dist(?:-[a-z]+)?|build|out|esm|cjs)\/(?:(?:esm|cjs|es|lib|commonjs|module)\/)?/;
+const findSourceFile = (baseDir, relativePath) => {
+	const pathWithoutExtension = join(baseDir, relativePath).replace(/\.[cm]?js(x?)$/, "");
+	for (const sourceExtension of SOURCE_EXTENSIONS) {
+		const candidatePath = pathWithoutExtension + sourceExtension;
+		if (existsSync(candidatePath)) return candidatePath;
+	}
+	const indexCandidate = join(pathWithoutExtension, "index.ts");
+	if (existsSync(indexCandidate)) return indexCandidate;
+};
+const findSourceFileStrict = (baseDir, relativePath) => {
+	const pathWithoutExtension = join(baseDir, relativePath).replace(/\.[cm]?js(x?)$/, "");
+	for (const sourceExtension of SOURCE_EXTENSIONS) {
+		const candidatePath = pathWithoutExtension + sourceExtension;
+		if (existsSync(candidatePath)) return candidatePath;
+	}
+	const exactPath = join(baseDir, relativePath);
+	if (existsSync(exactPath)) return exactPath;
+};
+const resolveBuiltPathToSource = (builtAbsolutePath, rootDir) => {
+	if (existsSync(builtAbsolutePath)) return void 0;
+	try {
+		const tsconfigPath = join(rootDir, "tsconfig.json");
+		if (!existsSync(tsconfigPath)) return void 0;
+		const tsconfigContent = readFileSync(tsconfigPath, "utf-8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+		const tsconfig = JSON.parse(tsconfigContent);
+		const outDir = tsconfig?.compilerOptions?.outDir;
+		if (!outDir) return void 0;
+		const absoluteOutDir = resolve(rootDir, outDir);
+		const relativeToBuild = builtAbsolutePath.startsWith(absoluteOutDir) ? builtAbsolutePath.slice(absoluteOutDir.length) : void 0;
+		if (!relativeToBuild) return void 0;
+		const rootDirOption = tsconfig?.compilerOptions?.rootDir;
+		const sourceRoot = rootDirOption ? resolve(rootDir, rootDirOption) : rootDir;
+		const sourceFileMatch = findSourceFile(sourceRoot, relativeToBuild);
+		if (sourceFileMatch) return sourceFileMatch;
+		const directCandidate = join(sourceRoot, relativeToBuild);
+		if (existsSync(directCandidate)) return directCandidate;
+		if (!rootDirOption) for (const sourceDir of COMMON_SOURCE_DIRECTORIES) {
+			const candidate = findSourceFile(resolve(rootDir, sourceDir), relativeToBuild);
+			if (candidate) return candidate;
+		}
+	} catch {}
+};
+const resolveEntryPathViaHeuristic = (entryPath, rootDir) => {
+	if (!BUILD_OUTPUT_DIRECTORY_PATTERN.test(entryPath)) return void 0;
+	const buildDirMatch = entryPath.match(BUILD_OUTPUT_DIRECTORY_PATTERN);
+	if (!buildDirMatch) return void 0;
+	const relativeToBuildDir = entryPath.slice(buildDirMatch[0].length);
+	for (const sourceDir of COMMON_SOURCE_DIRECTORIES) {
+		const sourceBaseDir = resolve(rootDir, sourceDir);
+		if (!existsSync(sourceBaseDir)) continue;
+		const sourceFileMatch = findSourceFileStrict(sourceBaseDir, relativeToBuildDir);
+		if (sourceFileMatch) return sourceFileMatch;
+	}
+};
+const resolveEntryPath = (entryPath, rootDir) => {
+	const absolutePath = resolve(rootDir, entryPath);
+	const normalizedEntry = entryPath.replace(/^\.\//, "");
+	if (BUILD_OUTPUT_DIRECTORY_PATTERN.test(normalizedEntry)) {
+		const sourcePath = resolveBuiltPathToSource(absolutePath, rootDir);
+		if (sourcePath) return sourcePath;
+		const heuristicMatch = resolveEntryPathViaHeuristic(normalizedEntry, rootDir);
+		if (heuristicMatch) return heuristicMatch;
+	}
+	if (existsSync(absolutePath)) return absolutePath;
+	const sourcePath = resolveBuiltPathToSource(absolutePath, rootDir);
+	if (sourcePath) return sourcePath;
+	const directSourceMatch = findSourceFile(rootDir, normalizedEntry);
+	if (directSourceMatch) return directSourceMatch;
+	const heuristicMatch = resolveEntryPathViaHeuristic(normalizedEntry, rootDir);
+	if (heuristicMatch) return heuristicMatch;
+	return absolutePath;
+};
+const extractPackageJsonEntries = async (packageJsonPath) => {
+	const entries = [];
+	try {
+		const content = await readFile(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		const rootDir = packageJsonPath.replace(/\/package\.json$/, "");
+		for (const field of [
+			"main",
+			"module",
+			"browser",
+			"types",
+			"typings",
+			"style",
+			"source"
+		]) if (typeof packageJson[field] === "string") entries.push(resolveEntryPath(packageJson[field], rootDir));
+		if (packageJson.exports) {
+			const exportEntries = [];
+			collectExportPaths(packageJson.exports, rootDir, exportEntries);
+			for (const exportEntry of exportEntries) {
+				const resolvedExportEntry = resolveEntryWithExtensions(exportEntry) ?? resolveEntryPathWithExtensions(exportEntry, rootDir) ?? resolveSourcePath(exportEntry, rootDir);
+				if (resolvedExportEntry && existsSync(resolvedExportEntry)) {
+					entries.push(resolvedExportEntry);
+					continue;
+				}
+				if (exportEntry.endsWith(".ts")) {
+					const tsxFallback = exportEntry.replace(/\.ts$/, ".tsx");
+					if (existsSync(tsxFallback)) {
+						entries.push(tsxFallback);
+						continue;
+					}
+				}
+				if (existsSync(exportEntry)) entries.push(exportEntry);
+				else entries.push(resolveEntryPath(exportEntry, rootDir));
+			}
+		}
+		if (packageJson.bin) {
+			if (typeof packageJson.bin === "string") entries.push(resolveEntryPath(packageJson.bin, rootDir));
+			else if (typeof packageJson.bin === "object") {
+				for (const binPath of Object.values(packageJson.bin)) if (typeof binPath === "string") entries.push(resolveEntryPath(binPath, rootDir));
+			}
+		}
+		if (Array.isArray(packageJson.sideEffects)) for (const sideEffectPattern of packageJson.sideEffects) {
+			if (typeof sideEffectPattern !== "string") continue;
+			const sourcePatterns = expandSideEffectGlobToSourcePatterns(sideEffectPattern);
+			for (const sourcePattern of sourcePatterns) {
+				const matchedSideEffectFiles = fg.sync(sourcePattern, {
+					cwd: rootDir,
+					absolute: true,
+					onlyFiles: true,
+					ignore: [
+						"**/node_modules/**",
+						"**/dist/**",
+						"**/build/**"
+					]
+				});
+				for (const matchedSideEffectFile of matchedSideEffectFiles) if (isImportableSourceFile(matchedSideEffectFile)) entries.push(matchedSideEffectFile);
+			}
+		}
+		if (packageJson.build && typeof packageJson.build === "object") {
+			const buildConfig = packageJson.build;
+			if (Array.isArray(buildConfig.files)) for (const buildFileEntry of buildConfig.files) {
+				if (typeof buildFileEntry !== "string") continue;
+				if (buildFileEntry.includes("*")) continue;
+				const resolvedBuildFile = resolveEntryWithExtensions(resolve(rootDir, buildFileEntry)) ?? resolveEntryPathWithExtensions(buildFileEntry, rootDir);
+				if (resolvedBuildFile && existsSync(resolvedBuildFile)) entries.push(resolvedBuildFile);
+			}
+		}
+		if (packageJson.jest && typeof packageJson.jest === "object") {
+			const jestRootDirMatches = JSON.stringify(packageJson.jest).matchAll(/<rootDir>\/([^"\\]+)/g);
+			for (const jestRootDirMatch of jestRootDirMatches) {
+				const resolvedJestFile = resolveEntryPathWithExtensions(jestRootDirMatch[1], rootDir);
+				if (resolvedJestFile && existsSync(resolvedJestFile)) entries.push(resolvedJestFile);
+			}
+		}
+	} catch {}
+	return entries;
+};
+const expandSideEffectGlobToSourcePatterns = (pattern) => {
+	const patterns = new Set([pattern]);
+	if (pattern.endsWith(".js")) {
+		patterns.add(pattern.replace(/\.js$/, ".ts"));
+		patterns.add(pattern.replace(/\.js$/, ".tsx"));
+	}
+	if (pattern.includes("/lib/") || pattern.startsWith("lib/")) patterns.add(pattern.replace(/\blib\b/g, "src"));
+	if (pattern.includes("/esm/") || pattern.startsWith("esm/")) patterns.add(pattern.replace(/\besm\b/g, "src"));
+	return [...patterns];
+};
+const SHELL_OPERATORS_PATTERN = /\s*(?:&&|\|\||[;&|])\s*/;
+const SCRIPT_MULTIPLEXERS = new Set([
+	"concurrently",
+	"run-s",
+	"run-p",
+	"npm-run-all",
+	"npm-run-all2",
+	"wireit",
+	"turbo",
+	"lerna",
+	"ultra"
+]);
+const TSCONFIG_PROJECT_FLAGS = new Set(["--project", "-p"]);
+const CONFIG_LIKE_FLAGS = new Set([
+	"--config",
+	"-c",
+	"--format",
+	"--formatter",
+	"--tsconfig",
+	"--project",
+	"-p",
+	"--setup",
+	"--global-setup"
+]);
+const ENV_WRAPPER_BINARIES = new Set([
+	"cross-env",
+	"dotenv",
+	"dotenv-flow",
+	"env-cmd"
+]);
+const IGNORED_CLI_TOOLS = new Set([
+	"prettier",
+	"eslint",
+	"tslint",
+	"stylelint",
+	"biome",
+	"oxlint",
+	"oxfmt",
+	"tsc",
+	"tsup",
+	"tsdown",
+	"rollup",
+	"webpack",
+	"rimraf",
+	"del-cli",
+	"shx",
+	"cpy-cli",
+	"cpx",
+	"echo",
+	"cat",
+	"mkdir",
+	"rm",
+	"cp",
+	"mv",
+	"ls",
+	"pwd",
+	"test",
+	"husky",
+	"lint-staged",
+	"commitlint",
+	"changeset",
+	"changesets",
+	"typedoc",
+	"api-extractor",
+	"madge",
+	"depcheck",
+	"deslop",
+	"sort-package-json",
+	"pnpm",
+	"npm",
+	"yarn",
+	"ni",
+	"nr",
+	"nun",
+	"next",
+	"nuxt",
+	"astro",
+	"vite",
+	"svelte-kit",
+	"prisma",
+	"drizzle-kit",
+	"formatjs",
+	"i18next",
+	"i18next-parser",
+	"lingui",
+	"storybook",
+	"chromatic",
+	"msw",
+	"patch-package",
+	"syncpack",
+	"manypkg",
+	"jest",
+	"vitest",
+	"mocha",
+	"ava",
+	"tap",
+	"c8",
+	"nyc",
+	"playwright",
+	"cypress",
+	"puppeteer",
+	"webdriver",
+	"sequelize",
+	"typeorm",
+	"mikro-orm",
+	"wait-on",
+	"start-server-and-test",
+	"remark",
+	"markdownlint",
+	"markdownlint-cli2",
+	"textlint",
+	"alex",
+	"cspell",
+	"ncu",
+	"npm-check-updates",
+	"size-limit",
+	"bundlewatch",
+	"dbdocs",
+	"lobe-i18n",
+	"lobe-seo"
+]);
+const looksLikeFilePath = (token) => {
+	if (token.startsWith("-") || token.includes("${{") || token.includes("://")) return false;
+	if (token.includes("}}") && !token.includes("{{")) return false;
+	if (/\.(?:[cm]?[jt]sx?|css|scss|json|yaml|yml|toml|html|mjs|cjs|mts|cts|graphql|gql|mdx|astro|vue|svelte)$/.test(token)) return true;
+	if (/\.\{[^}]+\}$/.test(token)) return true;
+	if (token.startsWith("./") || token.startsWith("../")) return true;
+	return token.includes("/") && !token.startsWith("@");
+};
+const isGlobPattern = (token) => {
+	return token.includes("*") || token.includes("{") || token.includes("?");
+};
+const extractScriptFileArguments = (scriptCommand, directory) => {
+	const entries = [];
+	const segments = scriptCommand.split(SHELL_OPERATORS_PATTERN);
+	for (const segment of segments) {
+		const trimmedSegment = segment.trim();
+		if (!trimmedSegment) continue;
+		const tokens = trimmedSegment.split(/\s+/);
+		if (tokens.length === 0) continue;
+		let startIndex = 0;
+		const firstBinary = tokens[0].replace(/^.*\//, "");
+		if (ENV_WRAPPER_BINARIES.has(firstBinary)) {
+			startIndex = 1;
+			while (startIndex < tokens.length && /^[A-Z_][A-Z0-9_]*=/.test(tokens[startIndex])) startIndex++;
+			if (startIndex >= tokens.length) continue;
+		}
+		const binaryName = tokens[startIndex].replace(/^.*\//, "");
+		if (SCRIPT_MULTIPLEXERS.has(binaryName)) continue;
+		const effectiveBinaryName = binaryName === "npx" || binaryName === "pnpx" || binaryName === "bunx" ? tokens[startIndex + 1]?.replace(/^.*\//, "") ?? "" : binaryName;
+		const isNonEntryBinary = IGNORED_CLI_TOOLS.has(binaryName) || effectiveBinaryName !== "" && IGNORED_CLI_TOOLS.has(effectiveBinaryName);
+		for (let tokenIndex = startIndex + 1; tokenIndex < tokens.length; tokenIndex++) {
+			const token = tokens[tokenIndex].replace(/^['"]|['"]$/g, "");
+			if (CONFIG_LIKE_FLAGS.has(token)) {
+				if (tokenIndex + 1 < tokens.length && !tokens[tokenIndex + 1].startsWith("-")) {
+					const configPath = tokens[tokenIndex + 1].replace(/^['"]|['"]$/g, "");
+					if (looksLikeFilePath(configPath)) {
+						const absoluteConfigPath = resolve(directory, configPath);
+						if (existsSync(absoluteConfigPath)) if (TSCONFIG_PROJECT_FLAGS.has(token) && TSCONFIG_PROJECT_PATTERN.test(absoluteConfigPath)) entries.push(...expandTsConfigProjectEntries(absoluteConfigPath));
+						else entries.push(absoluteConfigPath);
+					}
+					tokenIndex++;
+				}
+				continue;
+			}
+			const equalsIndex = token.indexOf("=");
+			if (equalsIndex > 0 && CONFIG_LIKE_FLAGS.has(token.slice(0, equalsIndex))) {
+				const configValue = token.slice(equalsIndex + 1);
+				const flagName = token.slice(0, equalsIndex);
+				if (configValue && looksLikeFilePath(configValue)) {
+					const absoluteConfigPath = resolve(directory, configValue);
+					if (existsSync(absoluteConfigPath)) if (TSCONFIG_PROJECT_FLAGS.has(flagName) && TSCONFIG_PROJECT_PATTERN.test(absoluteConfigPath)) entries.push(...expandTsConfigProjectEntries(absoluteConfigPath));
+					else entries.push(absoluteConfigPath);
+				}
+				continue;
+			}
+			if (token.startsWith("-")) continue;
+			if (isNonEntryBinary) continue;
+			if (!looksLikeFilePath(token)) continue;
+			if (isGlobPattern(token)) {
+				const expandedFiles = fg.sync(token, {
+					cwd: directory,
+					absolute: true,
+					onlyFiles: true,
+					ignore: ["**/node_modules/**"]
+				});
+				entries.push(...expandedFiles);
+			} else {
+				const absoluteFilePath = resolve(directory, token);
+				if (existsSync(absoluteFilePath)) entries.push(absoluteFilePath);
+				else {
+					const sourcePath = resolveSourcePath(absoluteFilePath, directory);
+					if (sourcePath) entries.push(sourcePath);
+				}
+			}
+		}
+	}
+	return entries;
+};
+const EXTENSIONLESS_SCRIPT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs",
+	".cjs"
+];
+const resolveExtensionlessScriptPath = (basePath) => {
+	for (const extension of EXTENSIONLESS_SCRIPT_EXTENSIONS) {
+		const candidate = basePath + extension;
+		if (existsSync(candidate)) return candidate;
+	}
+	const indexCandidate = resolve(basePath, "index.ts");
+	if (existsSync(indexCandidate)) return indexCandidate;
+};
+const extractScriptEntries = (directory) => {
+	const packageJsonPath = resolve(directory, "package.json");
+	if (!existsSync(packageJsonPath)) return [];
+	const entries = [];
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const scripts = JSON.parse(content).scripts;
+		if (scripts && typeof scripts === "object") for (const scriptCommand of Object.values(scripts)) {
+			if (typeof scriptCommand !== "string") continue;
+			const match = scriptCommand.match(SCRIPT_FILE_PATTERN);
+			if (match?.[1]) {
+				const scriptFilePath = resolve(directory, match[1]);
+				if (existsSync(scriptFilePath)) entries.push(scriptFilePath);
+				else {
+					const sourcePath = resolveSourcePath(scriptFilePath, directory);
+					if (sourcePath) entries.push(sourcePath);
+				}
+			} else {
+				const extensionlessMatch = scriptCommand.match(SCRIPT_EXTENSIONLESS_FILE_PATTERN);
+				if (extensionlessMatch?.[1]) {
+					const extensionlessPath = extensionlessMatch[1];
+					const resolved = resolveExtensionlessScriptPath(resolve(directory, extensionlessPath));
+					if (resolved) entries.push(resolved);
+				}
+			}
+			const configMatch = scriptCommand.match(SCRIPT_CONFIG_FILE_PATTERN);
+			if (configMatch?.[1]) {
+				const configFilePath = resolve(directory, configMatch[1]);
+				if (existsSync(configFilePath)) entries.push(configFilePath);
+				else {
+					const sourcePath = resolveSourcePath(configFilePath, directory);
+					if (sourcePath) entries.push(sourcePath);
+				}
+			}
+			entries.push(...extractScriptFileArguments(scriptCommand, directory));
+		}
+	} catch {}
+	const scriptDirectoryFiles = fg.sync(SCRIPT_ENTRY_PATTERNS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	entries.push(...scriptDirectoryFiles);
+	return entries;
+};
+const isYamlMapping = (line) => {
+	const firstWord = line.split(/\s/)[0];
+	if (!firstWord) return false;
+	return firstWord.endsWith(":") && !firstWord.startsWith("http") && !firstWord.startsWith("ftp");
+};
+const extractCiRunCommands = (content) => {
+	const commands = [];
+	let inMultilineRun = false;
+	let multilineIndent = 0;
+	for (const line of content.split("\n")) {
+		const trimmedLine = line.trim();
+		if (trimmedLine === "" || trimmedLine.startsWith("#")) continue;
+		if (inMultilineRun) {
+			if (line.length - line.trimStart().length > multilineIndent && trimmedLine !== "") {
+				commands.push(trimmedLine);
+				continue;
+			}
+			inMultilineRun = false;
+		}
+		const runMatch = trimmedLine.match(/^(?:-\s+)?run:\s*(.*)$/);
+		if (runMatch) {
+			const runValue = runMatch[1].trim();
+			if (runValue === "|" || runValue === "|-" || runValue === "|+") {
+				inMultilineRun = true;
+				multilineIndent = line.length - line.trimStart().length;
+			} else if (runValue !== "") commands.push(runValue);
+			continue;
+		}
+		if (trimmedLine.startsWith("- ")) {
+			const listItem = trimmedLine.slice(2).trim();
+			if (listItem !== "" && !listItem.startsWith("{") && !listItem.startsWith("[") && !isYamlMapping(listItem)) commands.push(listItem);
+		}
+	}
+	return commands;
+};
+const extractCiWorkflowEntries = (rootDir) => {
+	const entries = [];
+	const workflowsDir = join(rootDir, ".github", "workflows");
+	if (!existsSync(workflowsDir)) return entries;
+	const workflowFiles = fg.sync("*.{yml,yaml}", {
+		cwd: workflowsDir,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const workflowFile of workflowFiles) try {
+		const runCommands = extractCiRunCommands(readFileSync(workflowFile, "utf-8"));
+		for (const command of runCommands) {
+			const scriptMatch = command.match(SCRIPT_FILE_PATTERN);
+			if (scriptMatch?.[1]) {
+				const scriptFilePath = resolve(rootDir, scriptMatch[1]);
+				if (existsSync(scriptFilePath)) entries.push(scriptFilePath);
+			}
+			const configMatch = command.match(SCRIPT_CONFIG_FILE_PATTERN);
+			if (configMatch?.[1]) {
+				const configFilePath = resolve(rootDir, configMatch[1]);
+				if (existsSync(configFilePath)) entries.push(configFilePath);
+			}
+		}
+	} catch {}
+	return entries;
+};
+const VITE_INPUT_BLOCK_PATTERN = /input\s*:\s*(?:\{[^}]*\}|\[[^\]]*\]|['"][^'"]+['"])/gs;
+const BUNDLER_ENTRY_FILE_PATTERN = /['"]([^'"]+\.(?:js|ts|tsx|jsx|mjs|mts|less|scss|css|sass|html))['"]/g;
+const extractViteEntryPoints = (directory) => {
+	const entries = [];
+	const viteConfigPaths = fg.sync("vite.config.{js,ts,mjs,mts}", {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const configPath of viteConfigPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		let inputMatch;
+		VITE_INPUT_BLOCK_PATTERN.lastIndex = 0;
+		while ((inputMatch = VITE_INPUT_BLOCK_PATTERN.exec(content)) !== null) {
+			const inputBlock = inputMatch[0];
+			let valueMatch;
+			BUNDLER_ENTRY_FILE_PATTERN.lastIndex = 0;
+			while ((valueMatch = BUNDLER_ENTRY_FILE_PATTERN.exec(inputBlock)) !== null) {
+				const entryPath = valueMatch[1];
+				if (entryPath.startsWith("./") || entryPath.startsWith("../") || !entryPath.startsWith("/")) {
+					const absoluteEntryPath = resolve(directory, entryPath);
+					if (existsSync(absoluteEntryPath)) entries.push(absoluteEntryPath);
+				}
+			}
+		}
+	} catch {}
+	return entries;
+};
+const BUNDLER_CONFIG_ENTRY_BLOCK_PATTERN = /entry\s*:\s*\[([^\]]*)\]/gs;
+const BUNDLER_CONFIG_ENTRY_STRING_PATTERN = /['"]([^'"]+)['"]/g;
+const extractBundlerConfigEntryPoints = (directory) => {
+	const entries = [];
+	const configPaths = fg.sync(["tsdown.config.{ts,js,cjs,mjs}", "tsup.config.{ts,js,cjs,mjs}"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const configPath of configPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		let blockMatch;
+		BUNDLER_CONFIG_ENTRY_BLOCK_PATTERN.lastIndex = 0;
+		while ((blockMatch = BUNDLER_CONFIG_ENTRY_BLOCK_PATTERN.exec(content)) !== null) {
+			const arrayContent = blockMatch[1];
+			let stringMatch;
+			BUNDLER_CONFIG_ENTRY_STRING_PATTERN.lastIndex = 0;
+			while ((stringMatch = BUNDLER_CONFIG_ENTRY_STRING_PATTERN.exec(arrayContent)) !== null) {
+				const entryPath = stringMatch[1];
+				const resolvedPath = resolveEntryWithExtensions(resolve(directory, entryPath));
+				if (resolvedPath) entries.push(resolvedPath);
+			}
+		}
+	} catch {}
+	return entries;
+};
+const WEBPACK_ENTRY_BLOCK_PATTERN = /entry\s*:\s*(?:\{[^}]*\}|\[[^\]]*\]|['"][^'"]+['"]|path\.(?:join|resolve)\([^)]*\))/gs;
+const WEBPACK_ENTRY_FILE_PATTERN = /['"]([^'"]+)['"]/g;
+const WEBPACK_PATH_JOIN_PATTERN = /path\.(?:join|resolve)\(\s*__dirname\s*,\s*((?:['"][^'"]*['"][\s,]*)+)\)/g;
+const REQUIRE_RESOLVE_PATTERN = /require\.resolve\(\s*['"]([^'"]+)['"]\s*\)/g;
+const extractWebpackEntryPoints = (directory) => {
+	const entries = [];
+	const webpackConfigPaths = fg.sync([
+		"webpack.config.{js,ts,mjs,cjs}",
+		"**/webpack*.config.{js,ts,mjs,cjs}",
+		"**/webpack.config*.{js,ts,mjs,cjs}",
+		"**/webpack*.config*.babel.{js,ts}"
+	], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		deep: 3
+	});
+	for (const configPath of webpackConfigPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const configDirectory = dirname(configPath);
+		let pathJoinMatch;
+		WEBPACK_PATH_JOIN_PATTERN.lastIndex = 0;
+		while ((pathJoinMatch = WEBPACK_PATH_JOIN_PATTERN.exec(content)) !== null) {
+			const segments = [...pathJoinMatch[1].matchAll(/['"]([^'"]*)['"]/g)].map((match) => match[1]);
+			if (segments.length > 0) {
+				const resolvedEntry = resolveEntryWithExtensions(resolve(configDirectory, ...segments));
+				if (resolvedEntry) entries.push(resolvedEntry);
+			}
+		}
+		let requireResolveMatch;
+		REQUIRE_RESOLVE_PATTERN.lastIndex = 0;
+		while ((requireResolveMatch = REQUIRE_RESOLVE_PATTERN.exec(content)) !== null) {
+			const requirePath = requireResolveMatch[1];
+			if (requirePath.startsWith("./") || requirePath.startsWith("../")) {
+				const resolvedEntry = resolveEntryWithExtensions(resolve(configDirectory, requirePath));
+				if (resolvedEntry) entries.push(resolvedEntry);
+			}
+		}
+		let entryMatch;
+		WEBPACK_ENTRY_BLOCK_PATTERN.lastIndex = 0;
+		while ((entryMatch = WEBPACK_ENTRY_BLOCK_PATTERN.exec(content)) !== null) {
+			const entryBlock = entryMatch[0];
+			if (entryBlock.includes("path.join") || entryBlock.includes("path.resolve")) continue;
+			let valueMatch;
+			WEBPACK_ENTRY_FILE_PATTERN.lastIndex = 0;
+			while ((valueMatch = WEBPACK_ENTRY_FILE_PATTERN.exec(entryBlock)) !== null) {
+				const entryPath = valueMatch[1];
+				if (entryPath.startsWith("./") || entryPath.startsWith("../") || !entryPath.startsWith("/")) {
+					const resolvedEntry = resolveEntryWithExtensions(resolve(configDirectory, entryPath));
+					if (resolvedEntry) entries.push(resolvedEntry);
+				}
+			}
+		}
+	} catch {}
+	return entries;
+};
+const HTML_SCRIPT_SRC_PATTERN = /<script[^>]+src=["']([^"']+\.(?:ts|tsx|js|jsx|mts|mjs))["'][^>]*>/gi;
+const extractHtmlScriptEntries = (directory) => {
+	const entries = [];
+	const htmlFiles = fg.sync(["index.html", "*.html"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 1
+	});
+	for (const htmlPath of htmlFiles) try {
+		const content = readFileSync(htmlPath, "utf-8");
+		let scriptMatch;
+		HTML_SCRIPT_SRC_PATTERN.lastIndex = 0;
+		while ((scriptMatch = HTML_SCRIPT_SRC_PATTERN.exec(content)) !== null) {
+			const scriptSrc = scriptMatch[1].replace(/^\//, "");
+			const absoluteScriptPath = resolve(htmlPath.replace(/\/[^/]+$/, ""), scriptSrc);
+			if (existsSync(absoluteScriptPath)) entries.push(absoluteScriptPath);
+		}
+	} catch {}
+	return entries;
+};
+const extractScriptTagsFromHtmlFile = (htmlFilePath) => {
+	const entries = [];
+	try {
+		const content = readFileSync(htmlFilePath, "utf-8");
+		let scriptMatch;
+		HTML_SCRIPT_SRC_PATTERN.lastIndex = 0;
+		while ((scriptMatch = HTML_SCRIPT_SRC_PATTERN.exec(content)) !== null) {
+			const scriptSrc = scriptMatch[1].replace(/^\//, "");
+			const absoluteScriptPath = resolve(dirname(htmlFilePath), scriptSrc);
+			if (existsSync(absoluteScriptPath)) entries.push(absoluteScriptPath);
+		}
+	} catch {}
+	return entries;
+};
+const TSCONFIG_FILENAME_GLOBS = ["tsconfig.json", "tsconfig.*.json"];
+const TSCONFIG_PROJECT_PATTERN = /(?:^|[\\/])tsconfig(?:\.[^.]+)?\.json$/;
+const stripJsoncCommentsLocal = (sourceText) => {
+	let result = "";
+	let insideString = false;
+	let index = 0;
+	while (index < sourceText.length) {
+		const ch = sourceText[index];
+		if (insideString) {
+			if (ch === "\\" && index + 1 < sourceText.length) {
+				result += sourceText[index] + sourceText[index + 1];
+				index += 2;
+				continue;
+			}
+			if (ch === "\"") insideString = false;
+			result += ch;
+			index++;
+			continue;
+		}
+		if (ch === "\"") {
+			insideString = true;
+			result += ch;
+			index++;
+			continue;
+		}
+		if (ch === "/" && index + 1 < sourceText.length) {
+			if (sourceText[index + 1] === "/") {
+				while (index < sourceText.length && sourceText[index] !== "\n") index++;
+				continue;
+			}
+			if (sourceText[index + 1] === "*") {
+				index += 2;
+				while (index + 1 < sourceText.length && !(sourceText[index] === "*" && sourceText[index + 1] === "/")) index++;
+				index += 2;
+				continue;
+			}
+		}
+		result += ch;
+		index++;
+	}
+	return result.replace(/,(\s*[}\]])/g, "$1");
+};
+const extractTsConfigIncludeFilesEntries = (directory) => {
+	const entries = [];
+	const tsconfigPaths = fg.sync(TSCONFIG_FILENAME_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 1
+	});
+	for (const tsconfigPath of tsconfigPaths) try {
+		const cleaned = stripJsoncCommentsLocal(readFileSync(tsconfigPath, "utf-8"));
+		const tsconfigJson = JSON.parse(cleaned);
+		const tsconfigDir = dirname(tsconfigPath);
+		const collectPaths = (rawList) => {
+			if (!Array.isArray(rawList)) return;
+			for (const item of rawList) {
+				if (typeof item !== "string") continue;
+				if (item.includes("*") || item.includes("?")) continue;
+				const candidatePath = resolve(tsconfigDir, item);
+				if (existsSync(candidatePath)) entries.push(candidatePath);
+			}
+		};
+		collectPaths(tsconfigJson.include);
+		collectPaths(tsconfigJson.files);
+	} catch {}
+	return entries;
+};
+const expandTsConfigProjectEntries = (tsconfigAbsolutePath) => {
+	const entries = [];
+	try {
+		const cleaned = stripJsoncCommentsLocal(readFileSync(tsconfigAbsolutePath, "utf-8"));
+		const tsconfigJson = JSON.parse(cleaned);
+		const tsconfigDir = dirname(tsconfigAbsolutePath);
+		if (Array.isArray(tsconfigJson.files)) for (const fileItem of tsconfigJson.files) {
+			if (typeof fileItem !== "string") continue;
+			const candidatePath = resolve(tsconfigDir, fileItem);
+			if (existsSync(candidatePath)) entries.push(candidatePath);
+		}
+		if (Array.isArray(tsconfigJson.include)) for (const includePattern of tsconfigJson.include) {
+			if (typeof includePattern !== "string") continue;
+			const expandedFiles = fg.sync(includePattern, {
+				cwd: tsconfigDir,
+				absolute: true,
+				onlyFiles: true,
+				ignore: [
+					"**/node_modules/**",
+					"**/dist/**",
+					"**/build/**"
+				]
+			});
+			entries.push(...expandedFiles);
+		}
+	} catch {}
+	return entries;
+};
+const WRANGLER_TOML_MAIN_PATTERN = /^\s*main\s*=\s*['"]([^'"\n]+)['"]/m;
+const WRANGLER_JSON_MAIN_PATTERN = /"main"\s*:\s*"([^"]+)"/;
+const WRANGLER_SERVICE_BINDINGS_PATTERN = /entry_point\s*=\s*['"]([^'"\n]+)['"]/g;
+const extractWranglerEntries = (directory) => {
+	const entries = [];
+	const wranglerPaths = fg.sync([
+		"wrangler.toml",
+		"wrangler.json",
+		"wrangler.jsonc"
+	], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		deep: 1
+	});
+	for (const wranglerPath of wranglerPaths) try {
+		const content = readFileSync(wranglerPath, "utf-8");
+		const wranglerDir = dirname(wranglerPath);
+		const mainMatch = wranglerPath.endsWith(".toml") ? content.match(WRANGLER_TOML_MAIN_PATTERN) : content.match(WRANGLER_JSON_MAIN_PATTERN);
+		if (mainMatch?.[1]) {
+			const candidatePath = resolve(wranglerDir, mainMatch[1]);
+			if (existsSync(candidatePath)) entries.push(candidatePath);
+			else {
+				const sourceCandidate = resolveSourcePath(candidatePath, wranglerDir);
+				if (sourceCandidate) entries.push(sourceCandidate);
+			}
+		}
+		let entryPointMatch;
+		WRANGLER_SERVICE_BINDINGS_PATTERN.lastIndex = 0;
+		while ((entryPointMatch = WRANGLER_SERVICE_BINDINGS_PATTERN.exec(content)) !== null) {
+			const candidatePath = resolve(wranglerDir, entryPointMatch[1]);
+			if (existsSync(candidatePath)) entries.push(candidatePath);
+		}
+	} catch {}
+	return entries;
+};
+const WORKER_FILE_GLOBS = [
+	"**/*.worker.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"**/*.sw.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"**/sw.{ts,tsx,js,jsx,mts,mjs,cts,cjs}",
+	"**/service-worker.{ts,tsx,js,jsx,mts,mjs,cts,cjs}"
+];
+const extractWebWorkerEntries = (directory) => {
+	return fg.sync(WORKER_FILE_GLOBS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**",
+			"**/.next/**",
+			"**/out/**"
+		],
+		deep: 8
+	});
+};
+const collectBrowserExtensionManifestPaths = (manifest) => {
+	const candidatePaths = [];
+	if (typeof manifest !== "object" || manifest === null) return candidatePaths;
+	const manifestRecord = manifest;
+	const background = manifestRecord.background;
+	if (typeof background === "object" && background !== null) {
+		const backgroundRecord = background;
+		if (typeof backgroundRecord.service_worker === "string") candidatePaths.push(backgroundRecord.service_worker);
+		if (typeof backgroundRecord.page === "string") candidatePaths.push(backgroundRecord.page);
+		if (typeof backgroundRecord.scripts === "string") candidatePaths.push(backgroundRecord.scripts);
+		if (Array.isArray(backgroundRecord.scripts)) {
+			for (const scriptPath of backgroundRecord.scripts) if (typeof scriptPath === "string") candidatePaths.push(scriptPath);
+		}
+	}
+	const contentScripts = manifestRecord.content_scripts;
+	if (Array.isArray(contentScripts)) for (const contentScript of contentScripts) {
+		if (typeof contentScript !== "object" || contentScript === null) continue;
+		const contentScriptRecord = contentScript;
+		if (Array.isArray(contentScriptRecord.js)) {
+			for (const scriptPath of contentScriptRecord.js) if (typeof scriptPath === "string") candidatePaths.push(scriptPath);
+		}
+		if (Array.isArray(contentScriptRecord.css)) {
+			for (const stylePath of contentScriptRecord.css) if (typeof stylePath === "string") candidatePaths.push(stylePath);
+		}
+	}
+	const action = manifestRecord.action ?? manifestRecord.browser_action ?? manifestRecord.page_action;
+	if (typeof action === "object" && action !== null) {
+		const actionRecord = action;
+		if (typeof actionRecord.default_popup === "string") candidatePaths.push(actionRecord.default_popup);
+	}
+	if (typeof manifestRecord.devtools_page === "string") candidatePaths.push(manifestRecord.devtools_page);
+	if (typeof manifestRecord.options_page === "string") candidatePaths.push(manifestRecord.options_page);
+	if (typeof manifestRecord.options_ui === "object" && manifestRecord.options_ui !== null) {
+		const optionsRecord = manifestRecord.options_ui;
+		if (typeof optionsRecord.page === "string") candidatePaths.push(optionsRecord.page);
+	}
+	if (typeof manifestRecord.sandbox === "object" && manifestRecord.sandbox !== null) {
+		const sandboxRecord = manifestRecord.sandbox;
+		if (Array.isArray(sandboxRecord.pages)) {
+			for (const pagePath of sandboxRecord.pages) if (typeof pagePath === "string") candidatePaths.push(pagePath);
+		}
+	}
+	return candidatePaths;
+};
+const isLikelyBrowserExtensionManifest = (manifest) => {
+	if (typeof manifest !== "object" || manifest === null) return false;
+	return typeof manifest.manifest_version === "number";
+};
+const extractBrowserExtensionEntries = (directory) => {
+	const entries = [];
+	const manifestPaths = fg.sync([
+		"manifest.json",
+		"manifest.*.json",
+		"src/manifest.json",
+		"src/manifest.*.json",
+		"public/manifest.json",
+		"public/manifest.*.json",
+		"static/manifest.json"
+	], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 3
+	});
+	for (const manifestPath of manifestPaths) try {
+		const content = readFileSync(manifestPath, "utf-8");
+		const manifest = JSON.parse(content);
+		if (!isLikelyBrowserExtensionManifest(manifest)) continue;
+		const manifestDir = dirname(manifestPath);
+		const candidatePaths = collectBrowserExtensionManifestPaths(manifest);
+		const resolutionRoots = [
+			manifestDir,
+			resolve(manifestDir, ".."),
+			directory
+		];
+		for (const candidatePath of candidatePaths) for (const resolutionRoot of resolutionRoots) {
+			const candidateAbsolutePath = resolve(resolutionRoot, candidatePath);
+			if (existsSync(candidateAbsolutePath)) {
+				entries.push(candidateAbsolutePath);
+				break;
+			}
+			const sourceFile = resolveSourcePath(candidateAbsolutePath, resolutionRoot);
+			if (sourceFile) {
+				entries.push(sourceFile);
+				break;
+			}
+		}
+	} catch {}
+	return entries;
+};
+const ANGULAR_ENTRY_KEYS = [
+	"main",
+	"polyfills",
+	"styles"
+];
+const extractAngularEntryPoints = (directory) => {
+	const entries = [];
+	const angularJsonPaths = fg.sync(["angular.json", ".angular-cli.json"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const angularJsonPath of angularJsonPaths) try {
+		const content = readFileSync(angularJsonPath, "utf-8");
+		const projects = JSON.parse(content).projects ?? {};
+		const angularDir = angularJsonPath.replace(/\/[^/]+$/, "");
+		for (const projectConfig of Object.values(projects)) {
+			const projectRecord = projectConfig;
+			const architect = projectRecord.architect;
+			if (architect) for (const targetConfig of Object.values(architect)) {
+				const options = targetConfig.options;
+				if (!options) continue;
+				for (const entryKey of ANGULAR_ENTRY_KEYS) {
+					const entryValue = options[entryKey];
+					if (typeof entryValue === "string") {
+						const absolutePath = resolve(angularDir, entryValue);
+						if (existsSync(absolutePath)) entries.push(absolutePath);
+					}
+					if (Array.isArray(entryValue)) {
+						for (const entryItem of entryValue) if (typeof entryItem === "string") {
+							const absolutePath = resolve(angularDir, entryItem);
+							if (existsSync(absolutePath)) entries.push(absolutePath);
+						}
+					}
+				}
+			}
+			const projectDir = resolve(angularDir, typeof projectRecord.root === "string" ? projectRecord.root : "");
+			const ngPackagePaths = fg.sync(["ng-package.json", "**/ng-package.json"], {
+				cwd: projectDir,
+				absolute: true,
+				onlyFiles: true,
+				deep: 2,
+				ignore: ["**/node_modules/**"]
+			});
+			for (const ngPackagePath of ngPackagePaths) try {
+				const ngContent = readFileSync(ngPackagePath, "utf-8");
+				const ngPackage = JSON.parse(ngContent);
+				const ngDir = ngPackagePath.replace(/\/[^/]+$/, "");
+				const libEntry = ngPackage?.lib?.entryFile;
+				if (typeof libEntry === "string") {
+					const absoluteEntry = resolve(ngDir, libEntry);
+					if (existsSync(absoluteEntry)) entries.push(absoluteEntry);
+				}
+			} catch {}
+		}
+	} catch {}
+	return entries;
+};
+const PLUGIN_FILE_ARGUMENT_PATTERN = /(?:createNextIntlPlugin|createMDX|withContentlayer|withPlaiceholder)\s*\(\s*['"]([^'"]+)['"]/g;
+const NEXT_INTL_IMPORT_PATTERN = /createNextIntlPlugin/;
+const NEXT_INTL_DEFAULT_PATHS = [
+	"src/i18n/request.ts",
+	"src/i18n/request.tsx",
+	"src/i18n/request.js",
+	"i18n/request.ts",
+	"i18n/request.tsx",
+	"i18n/request.js",
+	"i18n.ts",
+	"i18n.tsx"
+];
+const extractNextConfigPluginFiles = (directory) => {
+	const entries = [];
+	const nextConfigPaths = fg.sync(["next.config.{ts,js,mjs,mts}"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	for (const configPath of nextConfigPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const configDirectory = configPath.replace(/\/[^/]+$/, "");
+		let pluginMatch;
+		PLUGIN_FILE_ARGUMENT_PATTERN.lastIndex = 0;
+		let didMatchNextIntlWithPath = false;
+		while ((pluginMatch = PLUGIN_FILE_ARGUMENT_PATTERN.exec(content)) !== null) {
+			const filePath = pluginMatch[1];
+			const absolutePath = resolve(configDirectory, filePath);
+			if (existsSync(absolutePath)) entries.push(absolutePath);
+			if (pluginMatch[0].includes("createNextIntlPlugin")) didMatchNextIntlWithPath = true;
+		}
+		if (!didMatchNextIntlWithPath && NEXT_INTL_IMPORT_PATTERN.test(content)) for (const defaultPath of NEXT_INTL_DEFAULT_PATHS) {
+			const absolutePath = resolve(configDirectory, defaultPath);
+			if (existsSync(absolutePath)) {
+				entries.push(absolutePath);
+				break;
+			}
+		}
+	} catch {}
+	return entries;
+};
+const VITEST_INCLUDE_ITEM_PATTERN = /['"]([^'"]+)['"]/g;
+const COVERAGE_BLOCK_PATTERN = /coverage\s*:\s*\{/g;
+const TEST_MATCH_ARRAY_PATTERN = /testMatch\s*:\s*\[([^\]]*)\]/;
+const STRING_LITERAL_PATTERN = /['"]([^'"]+)['"]/g;
+const extractJestTestMatchPatterns = (directory) => {
+	const configPaths = fg.sync(["jest.config.{ts,js,mjs,cjs}"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	if (configPaths.length === 0) {
+		try {
+			const packageContent = readFileSync(join(directory, "package.json"), "utf-8");
+			const packageJson = JSON.parse(packageContent);
+			if (packageJson.jest?.testMatch) return convertJestTestMatchToGlobs(packageJson.jest.testMatch);
+		} catch {}
+		return [];
+	}
+	for (const configPath of configPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const testMatchMatch = TEST_MATCH_ARRAY_PATTERN.exec(content);
+		if (!testMatchMatch) continue;
+		const arrayContent = testMatchMatch[1];
+		const patterns = [];
+		STRING_LITERAL_PATTERN.lastIndex = 0;
+		let itemMatch;
+		while ((itemMatch = STRING_LITERAL_PATTERN.exec(arrayContent)) !== null) patterns.push(itemMatch[1]);
+		if (patterns.length > 0) return convertJestTestMatchToGlobs(patterns);
+	} catch {}
+	return [];
+};
+const convertJestTestMatchToGlobs = (patterns) => {
+	return patterns.map((pattern) => {
+		let converted = pattern.replace(/<rootDir>\/?/g, "");
+		converted = converted.replace(/\?\(\*\.\)/g, "*.");
+		converted = converted.replace(/\?\(([^)]+)\)/g, (_, group) => {
+			return `{${[...group.includes("|") ? group.split("|") : [group], ""].join(",")}}`;
+		});
+		converted = converted.replace(/\+\(([^)]+)\)/g, (_, group) => {
+			return group.includes("|") ? `{${group.replace(/\|/g, ",")}}` : group;
+		});
+		converted = converted.replace(/\(([^)]+)\)/g, (_, group) => {
+			return group.includes("|") ? `{${group.replace(/\|/g, ",")}}` : group;
+		});
+		return converted;
+	});
+};
+const extractVitestIncludePatterns = (directory) => {
+	const configPaths = fg.sync(["vitest.config.{ts,js,mts,mjs}", "vitest.web.config.{ts,js,mts,mjs}"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const patterns = [];
+	for (const configPath of configPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const coverageBlockRanges = findNestedBlockRanges(content, COVERAGE_BLOCK_PATTERN);
+		const includePattern = /include\s*:\s*\[([^\]]*)\]/g;
+		includePattern.lastIndex = 0;
+		let includeMatch;
+		while ((includeMatch = includePattern.exec(content)) !== null) {
+			const matchStart = includeMatch.index;
+			if (coverageBlockRanges.some(([blockStart, blockEnd]) => matchStart > blockStart && matchStart < blockEnd)) continue;
+			const arrayContent = includeMatch[1];
+			VITEST_INCLUDE_ITEM_PATTERN.lastIndex = 0;
+			let itemMatch;
+			while ((itemMatch = VITEST_INCLUDE_ITEM_PATTERN.exec(arrayContent)) !== null) patterns.push(itemMatch[1]);
+		}
+	} catch {}
+	return patterns;
+};
+const findNestedBlockRanges = (content, blockStartPattern) => {
+	const ranges = [];
+	blockStartPattern.lastIndex = 0;
+	let blockMatch;
+	while ((blockMatch = blockStartPattern.exec(content)) !== null) {
+		const openBraceIndex = content.indexOf("{", blockMatch.index);
+		if (openBraceIndex === -1) continue;
+		let braceDepth = 1;
+		let position = openBraceIndex + 1;
+		while (position < content.length && braceDepth > 0) {
+			if (content[position] === "{") braceDepth++;
+			if (content[position] === "}") braceDepth--;
+			position++;
+		}
+		ranges.push([blockMatch.index, position]);
+	}
+	return ranges;
+};
+const SETUP_FILES_PATTERN = /(?:setupFiles|setupFilesAfterEnv|globalSetup|globalTeardown)\s*:\s*(?:\[([^\]]*)\]|['"]([^'"]+)['"])/gs;
+const SETUP_FILE_PATH_PATTERN = /['"]([^'"]+)['"]/g;
+const extractTestSetupFiles = (directory) => {
+	const entries = [];
+	const configPaths = fg.sync([
+		"vitest.config.{ts,js,mts,mjs}",
+		"vitest.web.config.{ts,js,mts,mjs}",
+		"vite.config.{ts,js,mts,mjs}",
+		"jest.config.{ts,js,mjs,cjs}",
+		"**/vitest.config.{ts,js,mts,mjs}"
+	], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		deep: 3
+	});
+	for (const configPath of configPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const configDirectory = configPath.replace(/\/[^/]+$/, "");
+		let setupMatch;
+		SETUP_FILES_PATTERN.lastIndex = 0;
+		while ((setupMatch = SETUP_FILES_PATTERN.exec(content)) !== null) {
+			const arrayContent = setupMatch[1];
+			const singleValue = setupMatch[2];
+			if (singleValue) {
+				const resolvedPath = resolveEntryWithExtensions(resolve(configDirectory, singleValue));
+				if (resolvedPath) entries.push(resolvedPath);
+			}
+			if (arrayContent) {
+				let pathMatch;
+				SETUP_FILE_PATH_PATTERN.lastIndex = 0;
+				while ((pathMatch = SETUP_FILE_PATH_PATTERN.exec(arrayContent)) !== null) {
+					const resolvedPath = resolveEntryWithExtensions(resolve(configDirectory, pathMatch[1]));
+					if (resolvedPath) entries.push(resolvedPath);
+				}
+			}
+		}
+	} catch {}
+	return entries;
+};
+const IMPORTABLE_EXTENSION_SET = new Set(SOURCE_EXTENSIONS$3.map((extension) => `.${extension}`));
+const isImportableSourceFile = (filePath) => IMPORTABLE_EXTENSION_SET.has(filePath.slice(filePath.lastIndexOf(".")));
+const expandWildcardExportPattern = (pattern, rootDir) => {
+	const normalized = pattern.startsWith("./") ? pattern.slice(2) : pattern;
+	return fg.sync(normalized, {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	}).filter(isImportableSourceFile);
+};
+const collectExportPaths = (exportValue, rootDir, entries) => {
+	if (typeof exportValue === "string") {
+		if (exportValue.includes("*")) {
+			const expandedFiles = expandWildcardExportPattern(exportValue, rootDir);
+			entries.push(...expandedFiles);
+			return;
+		}
+		entries.push(resolveEntryPath(exportValue, rootDir));
+		return;
+	}
+	if (typeof exportValue !== "object" || exportValue === null) return;
+	for (const [, nestedValue] of Object.entries(exportValue)) collectExportPaths(nestedValue, rootDir, entries);
+};
+const TEST_FRAMEWORK_PATTERNS = [
+	{
+		enablers: [
+			"vitest",
+			"@vitest/runner",
+			"vite-plus"
+		],
+		configFileActivators: [
+			"vitest.config.ts",
+			"vitest.config.js",
+			"vitest.config.mts",
+			"vitest.config.mjs"
+		],
+		entryPatterns: [
+			"**/*.test.{ts,tsx,js,jsx}",
+			"**/*.spec.{ts,tsx,js,jsx}",
+			"**/__tests__/**/*.{ts,tsx,js,jsx}",
+			"**/*.bench.{ts,tsx,js,jsx}"
+		],
+		fixturePatterns: ["**/__fixtures__/**/*.{ts,tsx,js,jsx,json}", "**/fixtures/**/*.{ts,tsx,js,jsx,json}"],
+		alwaysUsed: [
+			"vitest.config.{ts,js,mts,mjs}",
+			"vitest.setup.{ts,js}",
+			"vitest.workspace.{ts,js}",
+			"**/src/setupTests.{ts,tsx,js,jsx}",
+			"**/src/test-setup.{ts,tsx,js,jsx}"
+		]
+	},
+	{
+		enablers: [
+			"jest",
+			"@jest/core",
+			"ts-jest",
+			"react-scripts",
+			"react-app-rewired"
+		],
+		configFileActivators: [
+			"jest.config.ts",
+			"jest.config.js",
+			"jest.config.mjs",
+			"jest.config.cjs"
+		],
+		entryPatterns: [
+			"**/*.test.{ts,tsx,js,jsx}",
+			"**/*.spec.{ts,tsx,js,jsx}",
+			"**/__tests__/**/*.{ts,tsx,js,jsx}",
+			"**/__mocks__/**/*.{ts,tsx,js,jsx,mjs,cjs}"
+		],
+		fixturePatterns: ["**/__fixtures__/**/*.{ts,tsx,js,jsx,json}", "**/fixtures/**/*.{ts,tsx,js,jsx,json}"],
+		alwaysUsed: ["jest.config.{ts,js,mjs,cjs}", "jest.setup.{ts,js,tsx,jsx}"]
+	},
+	{
+		enablers: ["@playwright/test", "playwright"],
+		configFileActivators: ["playwright.config.ts", "playwright.config.js"],
+		entryPatterns: [
+			"**/*.spec.{ts,tsx,js,jsx}",
+			"**/*.test.{ts,tsx,js,jsx}",
+			"tests/**/*.{ts,tsx,js,jsx}",
+			"e2e/**/*.{ts,tsx,js,jsx}"
+		],
+		fixturePatterns: ["**/fixtures/**/*.{ts,tsx,js,jsx,json}"],
+		alwaysUsed: ["playwright.config.{ts,js}"]
+	},
+	{
+		enablers: ["mocha"],
+		configFileActivators: [
+			".mocharc.js",
+			".mocharc.yaml",
+			".mocharc.yml",
+			".mocharc.json"
+		],
+		entryPatterns: [
+			"test/**/*.{ts,tsx,js,jsx}",
+			"tests/**/*.{ts,tsx,js,jsx}",
+			"spec/**/*.{ts,tsx,js,jsx}",
+			"**/*.test.{ts,tsx,js,jsx}",
+			"**/*.spec.{ts,tsx,js,jsx}"
+		],
+		fixturePatterns: [],
+		alwaysUsed: [".mocharc.*"]
+	},
+	{
+		enablers: ["ava", "@ava/typescript"],
+		configFileActivators: [
+			"ava.config.js",
+			"ava.config.cjs",
+			"ava.config.mjs"
+		],
+		entryPatterns: [
+			"test/**/*.{ts,tsx,js,jsx}",
+			"tests/**/*.{ts,tsx,js,jsx}",
+			"**/*.test.{ts,tsx,js,jsx}",
+			"**/*.spec.{ts,tsx,js,jsx}"
+		],
+		fixturePatterns: [],
+		alwaysUsed: ["ava.config.{js,cjs,mjs}"]
+	},
+	{
+		enablers: ["cypress"],
+		configFileActivators: ["cypress.config.ts", "cypress.config.js"],
+		entryPatterns: [
+			"**/*.cy.{ts,tsx,js,jsx}",
+			"cypress/**/*.{ts,tsx,js,jsx}",
+			"cypress/support/**/*.{ts,js}"
+		],
+		fixturePatterns: ["**/fixtures/**/*.{ts,tsx,js,jsx,json}"],
+		alwaysUsed: ["cypress.config.{ts,js}", "cypress.config.*.{ts,js}"]
+	}
+];
+const JS_TS_COMPONENT_EXTENSIONS = "{ts,tsx,js,jsx}";
+const INERTIA_COMPONENT_EXTENSIONS = "{ts,tsx,js,jsx,vue,svelte}";
+const VIKE_ROUTE_EXTENSIONS = "{ts,tsx,js,jsx,md,mdx}";
+const FRAMEWORK_PATTERNS = [
+	{
+		enablers: ["storybook"],
+		enablerPrefixes: ["@storybook/"],
+		entryPatterns: ["**/*.stories.{ts,tsx,js,jsx,mdx}", ".storybook/**/*.{ts,tsx,js,jsx}"],
+		alwaysUsed: [
+			".storybook/main.{ts,js,mjs,cjs}",
+			".storybook/preview.{ts,tsx,js,jsx}",
+			".storybook/manager.{ts,tsx,js,jsx}"
+		]
+	},
+	{
+		enablers: ["msw"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			"mocks/**/*.{ts,tsx,js,jsx}",
+			"src/mocks/**/*.{ts,tsx,js,jsx}",
+			"**/mocks/**/*.{ts,tsx,js,jsx}"
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["typeorm"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			"migrations/**/*.{ts,js}",
+			"src/migrations/**/*.{ts,js}",
+			"src/migration/**/*.{ts,js}",
+			"migration/**/*.{ts,js}",
+			"src/entity/**/*.{ts,js}"
+		],
+		alwaysUsed: ["ormconfig.{ts,js,json}"]
+	},
+	{
+		enablers: ["knex"],
+		enablerPrefixes: [],
+		entryPatterns: ["migrations/**/*.{ts,js}", "seeds/**/*.{ts,js}"],
+		alwaysUsed: ["knexfile.{ts,js}"]
+	},
+	{
+		enablers: ["drizzle-orm"],
+		enablerPrefixes: [],
+		entryPatterns: ["drizzle/**/*.{ts,js}"],
+		alwaysUsed: ["drizzle.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["kysely"],
+		enablerPrefixes: [],
+		entryPatterns: ["migrations/**/*.{ts,js}", "src/migrations/**/*.{ts,js}"],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["prisma", "@prisma/client"],
+		enablerPrefixes: [],
+		entryPatterns: ["prisma/**/*.{ts,js}", "prisma/seed.{ts,js}"],
+		alwaysUsed: [
+			"prisma/schema.prisma",
+			"schema.prisma",
+			"prisma/schema/*.prisma",
+			"prisma.config.{ts,mts,cts,js,mjs,cjs}",
+			".config/prisma.{ts,mts,cts,js,mjs,cjs}"
+		]
+	},
+	{
+		enablers: ["@nestjs/core"],
+		enablerPrefixes: ["@nestjs/"],
+		entryPatterns: [
+			"src/main.ts",
+			"src/**/*.module.ts",
+			"src/**/*.controller.ts",
+			"src/**/*.service.ts",
+			"src/**/*.guard.ts",
+			"src/**/*.interceptor.ts",
+			"src/**/*.pipe.ts",
+			"src/**/*.filter.ts",
+			"src/**/*.middleware.ts",
+			"src/**/*.decorator.ts",
+			"src/**/*.gateway.ts",
+			"src/**/*.resolver.ts"
+		],
+		alwaysUsed: ["nest-cli.json"]
+	},
+	{
+		enablers: ["wrangler"],
+		enablerPrefixes: ["@cloudflare/"],
+		entryPatterns: [
+			"src/index.{ts,js}",
+			"src/worker.{ts,js}",
+			"functions/**/*.{ts,js}"
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["gatsby"],
+		enablerPrefixes: ["gatsby-"],
+		entryPatterns: [
+			"src/pages/**/*.{ts,tsx,js,jsx}",
+			"src/templates/**/*.{ts,tsx,js,jsx}",
+			"src/api/**/*.{ts,js}"
+		],
+		alwaysUsed: [
+			"gatsby-config.{ts,js,mjs}",
+			"gatsby-node.{ts,js,mjs}",
+			"gatsby-browser.{ts,tsx,js,jsx}",
+			"gatsby-ssr.{ts,tsx,js,jsx}"
+		]
+	},
+	{
+		enablers: ["@angular/core"],
+		enablerPrefixes: ["@angular/"],
+		entryPatterns: [
+			"src/main.ts",
+			"src/app/**/*.ts",
+			"src/environments/**/*.ts",
+			"src/polyfills.ts",
+			"src/test.ts"
+		],
+		alwaysUsed: ["angular.json", "**/karma.conf.js"]
+	},
+	{
+		enablers: [
+			"@inertiajs/react",
+			"@inertiajs/inertia-react",
+			"@inertiajs/vue3",
+			"@inertiajs/inertia-vue3",
+			"@inertiajs/svelte",
+			"@inertiajs/inertia-svelte",
+			"@inertiajs/inertia"
+		],
+		enablerPrefixes: [],
+		entryPatterns: [
+			`resources/js/app.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`resources/js/App.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`resources/js/Pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`resources/js/pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`app/frontend/Pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`app/frontend/pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`app/frontend/entrypoints/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`app/javascript/Pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`app/javascript/pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`frontend/src/Pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`frontend/src/pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`inertia/Pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`inertia/pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`src/app.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`src/App.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`src/Pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`,
+			`src/pages/**/*.${INERTIA_COMPONENT_EXTENSIONS}`
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["@redwoodjs/router", "@redwoodjs/web"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			`web/src/App.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`web/src/Routes.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`web/src/index.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`web/src/layouts/**/*.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`web/src/pages/**/*.${JS_TS_COMPONENT_EXTENSIONS}`
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["react-scripts", "react-app-rewired"],
+		enablerPrefixes: [],
+		entryPatterns: ["src/index.{ts,tsx,js,jsx}"],
+		alwaysUsed: [
+			"src/setupTests.{ts,tsx,js,jsx}",
+			"src/reportWebVitals.{ts,tsx,js,jsx}",
+			"src/react-app-env.d.ts"
+		]
+	},
+	{
+		enablers: [
+			"@remix-run/node",
+			"@remix-run/react",
+			"@remix-run/cloudflare",
+			"@react-router/node",
+			"@react-router/serve",
+			"@react-router/dev"
+		],
+		enablerPrefixes: ["@remix-run/", "@react-router/"],
+		entryPatterns: [
+			"app/routes/**/*.{ts,tsx,js,jsx}",
+			"app/root.{ts,tsx,js,jsx}",
+			"app/entry.client.{ts,tsx,js,jsx}",
+			"app/entry.server.{ts,tsx,js,jsx}",
+			"app/routes.{ts,js,mts,mjs}",
+			"src/routes.{ts,js,mts,mjs}"
+		],
+		alwaysUsed: ["react-router.config.{ts,js,mjs}", "remix.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["@docusaurus/core"],
+		enablerPrefixes: ["@docusaurus/"],
+		entryPatterns: [
+			"**/*.{md,mdx}",
+			"src/pages/**/*.{ts,tsx,js,jsx}",
+			"src/theme/**/*.{ts,tsx,js,jsx}",
+			"src/theme/**/index.{ts,tsx,js,jsx}",
+			"plugins/**/*.{ts,js,mjs}"
+		],
+		alwaysUsed: [
+			"docusaurus.config.{ts,js,mjs}",
+			"sidebars.{ts,js,mjs,cjs}",
+			"sidebar*.{ts,js,mjs,cjs}",
+			"*-sidebar.{ts,js,mjs,cjs}",
+			"*-sidebars.{ts,js,mjs,cjs}",
+			"*Sidebar*.{ts,js,mjs,cjs}",
+			"*sidebar*.{ts,js,mjs,cjs}"
+		],
+		contentIgnorePatterns: ["versioned_sidebars/**"]
+	},
+	{
+		enablers: [
+			"fumadocs-core",
+			"fumadocs-ui",
+			"fumadocs-mdx"
+		],
+		enablerPrefixes: ["fumadocs-"],
+		entryPatterns: ["content/**/*.{md,mdx}", "content/**/*.{ts,tsx,js,jsx}"],
+		alwaysUsed: ["source.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: [
+			"nextra",
+			"nextra-theme-docs",
+			"nextra-theme-blog"
+		],
+		enablerPrefixes: ["nextra-"],
+		entryPatterns: [
+			"pages/**/*.{md,mdx}",
+			"src/pages/**/*.{md,mdx}",
+			"content/**/*.{md,mdx}"
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: [
+			"contentlayer",
+			"contentlayer2",
+			"contentlayer-source-files"
+		],
+		enablerPrefixes: ["contentlayer"],
+		entryPatterns: ["content/**/*.{md,mdx}", "posts/**/*.{md,mdx}"],
+		alwaysUsed: ["contentlayer.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["@graphql-codegen/cli", "@graphql-codegen/core"],
+		enablerPrefixes: ["@graphql-codegen/"],
+		entryPatterns: ["**/*.graphql", "**/*.gql"],
+		alwaysUsed: [
+			"codegen.{ts,js,yml,yaml}",
+			"codegen.config.{ts,js}",
+			".graphqlrc.{ts,js,json,yml,yaml}",
+			"graphql.config.{ts,js,json,yml,yaml}"
+		]
+	},
+	{
+		enablers: ["eslint", "@eslint/js"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["eslint.config.{js,mjs,cjs,ts,mts,cts}", ".eslintrc.{js,cjs,mjs,json,yaml,yml}"]
+	},
+	{
+		enablers: ["prettier"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".prettierrc.{js,cjs,mjs,json,yaml,yml}", "prettier.config.{js,mjs,cjs,ts}"]
+	},
+	{
+		enablers: ["tailwindcss", "@tailwindcss/postcss"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["tailwind.config.{ts,js,cjs,mjs}"]
+	},
+	{
+		enablers: ["postcss"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["postcss.config.{ts,js,cjs,mjs}"]
+	},
+	{
+		enablers: ["typescript"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["tsconfig.json", "tsconfig.*.json"]
+	},
+	{
+		enablers: ["lint-staged"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".lintstagedrc.{js,cjs,mjs,json}", "lint-staged.config.{js,mjs,cjs}"]
+	},
+	{
+		enablers: ["husky"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".husky/**/*"]
+	},
+	{
+		enablers: ["@biomejs/biome"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["biome.json", "biome.jsonc"]
+	},
+	{
+		enablers: ["@commitlint/cli"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["commitlint.config.{js,cjs,mjs,ts}", ".commitlintrc.{js,cjs,mjs,json,yaml,yml}"]
+	},
+	{
+		enablers: ["semantic-release"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".releaserc.{js,cjs,mjs,json,yaml,yml}", "release.config.{js,cjs,mjs,ts}"]
+	},
+	{
+		enablers: ["@changesets/cli"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".changeset/**/*"]
+	},
+	{
+		enablers: ["next"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			"app/**/page.{ts,tsx,js,jsx}",
+			"app/**/layout.{ts,tsx,js,jsx}",
+			"app/**/loading.{ts,tsx,js,jsx}",
+			"app/**/error.{ts,tsx,js,jsx}",
+			"app/**/not-found.{ts,tsx,js,jsx}",
+			"app/**/template.{ts,tsx,js,jsx}",
+			"app/**/default.{ts,tsx,js,jsx}",
+			"app/**/route.{ts,tsx,js,jsx}",
+			"app/**/global-error.{ts,tsx,js,jsx}",
+			"app/**/forbidden.{ts,tsx,js,jsx}",
+			"app/**/unauthorized.{ts,tsx,js,jsx}",
+			"app/global-not-found.{ts,tsx,js,jsx}",
+			"app/**/opengraph-image.{ts,tsx,js,jsx}",
+			"app/**/twitter-image.{ts,tsx,js,jsx}",
+			"app/**/icon.{ts,tsx,js,jsx}",
+			"app/**/apple-icon.{ts,tsx,js,jsx}",
+			"app/**/manifest.{ts,tsx,js,jsx}",
+			"app/**/sitemap.{ts,tsx,js,jsx}",
+			"app/**/robots.{ts,tsx,js,jsx}",
+			"pages/**/*.{ts,tsx,js,jsx}",
+			"src/app/**/page.{ts,tsx,js,jsx}",
+			"src/app/**/layout.{ts,tsx,js,jsx}",
+			"src/app/**/loading.{ts,tsx,js,jsx}",
+			"src/app/**/error.{ts,tsx,js,jsx}",
+			"src/app/**/not-found.{ts,tsx,js,jsx}",
+			"src/app/**/template.{ts,tsx,js,jsx}",
+			"src/app/**/default.{ts,tsx,js,jsx}",
+			"src/app/**/route.{ts,tsx,js,jsx}",
+			"src/app/**/global-error.{ts,tsx,js,jsx}",
+			"src/app/**/forbidden.{ts,tsx,js,jsx}",
+			"src/app/**/unauthorized.{ts,tsx,js,jsx}",
+			"src/app/global-not-found.{ts,tsx,js,jsx}",
+			"src/app/**/opengraph-image.{ts,tsx,js,jsx}",
+			"src/app/**/twitter-image.{ts,tsx,js,jsx}",
+			"src/app/**/icon.{ts,tsx,js,jsx}",
+			"src/app/**/apple-icon.{ts,tsx,js,jsx}",
+			"src/app/**/manifest.{ts,tsx,js,jsx}",
+			"src/app/**/sitemap.{ts,tsx,js,jsx}",
+			"src/app/**/robots.{ts,tsx,js,jsx}",
+			"src/pages/**/*.{ts,tsx,js,jsx}",
+			"middleware.{ts,js}",
+			"src/middleware.{ts,js}",
+			"proxy.{ts,js}",
+			"src/proxy.{ts,js}",
+			"instrumentation.{ts,js}",
+			"instrumentation-client.{ts,js}",
+			"src/instrumentation.{ts,js}",
+			"src/instrumentation-client.{ts,js}"
+		],
+		alwaysUsed: [
+			"next.config.{ts,js,mjs,mts}",
+			"next-env.d.ts",
+			"mdx-components.{ts,tsx,js,jsx}",
+			"src/mdx-components.{ts,tsx,js,jsx}",
+			"src/i18n/request.{ts,js}",
+			"src/i18n/routing.{ts,js}",
+			"i18n/request.{ts,js}",
+			"i18n/routing.{ts,js}"
+		]
+	},
+	{
+		enablers: [
+			"@tanstack/react-router",
+			"@tanstack/react-start",
+			"@tanstack/start",
+			"@tanstack/solid-router",
+			"@tanstack/solid-start"
+		],
+		enablerPrefixes: ["@tanstack/router"],
+		entryPatterns: [
+			"src/routes/**/*.{ts,tsx,js,jsx}",
+			"app/routes/**/*.{ts,tsx,js,jsx}",
+			"src/server.{ts,tsx,js,jsx}",
+			"src/client.{ts,tsx,js,jsx}",
+			"src/router.{ts,tsx,js,jsx}",
+			"src/routeTree.gen.{ts,js}"
+		],
+		alwaysUsed: ["tsr.config.json", "app.config.{ts,js}"]
+	},
+	{
+		enablers: ["waku"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			`src/pages/**/*.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`src/waku.client.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`src/waku.server.${JS_TS_COMPONENT_EXTENSIONS}`
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["vike", "vite-plugin-ssr"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			`pages/**/*.${VIKE_ROUTE_EXTENSIONS}`,
+			`renderer/**/*.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`src/pages/**/*.${VIKE_ROUTE_EXTENSIONS}`,
+			`src/renderer/**/*.${JS_TS_COMPONENT_EXTENSIONS}`
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["rakkasjs"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			`src/client.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`src/server.${JS_TS_COMPONENT_EXTENSIONS}`,
+			`src/routes/**/*.${JS_TS_COMPONENT_EXTENSIONS}`
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: [
+			"@module-federation/enhanced",
+			"@module-federation/node",
+			"@module-federation/vite",
+			"@originjs/vite-plugin-federation"
+		],
+		enablerPrefixes: [],
+		entryPatterns: ["federation.config.{ts,js,mjs,cjs,mts,cts}", "module-federation.config.{ts,js,mjs,cjs,mts,cts}"],
+		alwaysUsed: []
+	},
+	{
+		enablers: [
+			"vite",
+			"rolldown-vite",
+			"vite-plus",
+			"@voidzero-dev/vite-plus-core",
+			"@voidzero-dev/vite-plus-test"
+		],
+		enablerPrefixes: ["@vitejs/", "@voidzero-dev/vite-plus"],
+		entryPatterns: [
+			"src/main.{ts,tsx,js,jsx}",
+			"src/index.{ts,tsx,js,jsx}",
+			"index.html"
+		],
+		alwaysUsed: ["vite.config.{ts,js,mts,mjs}"]
+	},
+	{
+		enablers: ["vue", "@vue/cli-service"],
+		enablerPrefixes: ["@vue/"],
+		entryPatterns: ["src/main.{ts,js}", "src/App.vue"],
+		alwaysUsed: ["vue.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["nuxt", "nuxt3"],
+		enablerPrefixes: ["@nuxt/"],
+		entryPatterns: [
+			"pages/**/*.vue",
+			"layouts/**/*.vue",
+			"components/**/*.vue",
+			"composables/**/*.{ts,js}",
+			"plugins/**/*.{ts,js}",
+			"middleware/**/*.{ts,js}",
+			"server/**/*.{ts,js}",
+			"app.vue"
+		],
+		alwaysUsed: ["nuxt.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["svelte", "@sveltejs/kit"],
+		enablerPrefixes: ["@sveltejs/"],
+		entryPatterns: [
+			"src/routes/**/*.svelte",
+			"src/lib/**/*.svelte",
+			"src/routes/**/+page.{ts,js,svelte}",
+			"src/routes/**/+layout.{ts,js,svelte}",
+			"src/routes/**/+server.{ts,js}"
+		],
+		alwaysUsed: ["svelte.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["webpack", "webpack-cli"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["webpack.config.{ts,js,mjs,cjs}", "webpack.*.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["rollup"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["rollup.config.{ts,js,mjs,cjs}", "rollup.*.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["@rspack/core", "@rspack/cli"],
+		enablerPrefixes: ["@rspack/"],
+		entryPatterns: ["src/index.{ts,tsx,js,jsx}"],
+		alwaysUsed: ["rspack.config.{ts,js,mjs,cjs}", "rspack.*.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["@rsbuild/core"],
+		enablerPrefixes: ["@rsbuild/"],
+		entryPatterns: ["src/index.{ts,tsx,js,jsx}"],
+		alwaysUsed: ["rsbuild.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["tsup"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["tsup.config.{ts,js,cjs,mjs}"]
+	},
+	{
+		enablers: ["tsdown"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["tsdown.config.{ts,js,cjs,mjs}"]
+	},
+	{
+		enablers: ["@trigger.dev/sdk"],
+		enablerPrefixes: ["@trigger.dev/"],
+		entryPatterns: [],
+		alwaysUsed: ["trigger.config.{ts,js,mjs,mts}"]
+	},
+	{
+		enablers: ["@swc/core"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".swcrc"]
+	},
+	{
+		enablers: ["@babel/core"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["babel.config.{js,cjs,mjs,json}", ".babelrc.{js,cjs,mjs,json}"]
+	},
+	{
+		enablers: ["sanity", "@sanity/cli"],
+		enablerPrefixes: ["@sanity/"],
+		entryPatterns: [],
+		alwaysUsed: ["sanity.config.{ts,js}", "sanity.cli.{ts,js}"]
+	},
+	{
+		enablers: ["astro"],
+		enablerPrefixes: ["@astrojs/"],
+		entryPatterns: [
+			"src/pages/**/*.{astro,ts,tsx,js,jsx,mts,mjs,cts,cjs,md,mdx}",
+			"src/content/**/*.{ts,js,mts,mjs,cts,cjs,md,mdx}",
+			"src/layouts/**/*.astro",
+			"src/middleware.{js,ts,mjs,mts,cjs,cts}",
+			"src/middleware/index.{js,ts,mjs,mts,cjs,cts}",
+			"src/actions/index.{js,ts,mjs,mts,cjs,cts}"
+		],
+		alwaysUsed: [
+			"astro.config.{ts,js,mjs,cjs}",
+			"src/content/config.{js,ts,mjs,mts,cjs,cts}",
+			"src/content.config.{js,ts,mjs,mts,cjs,cts}",
+			"src/live.config.{js,ts,mjs,mts,cjs,cts}"
+		]
+	},
+	{
+		enablers: [
+			"i18next",
+			"react-i18next",
+			"vue-i18n",
+			"next-i18next"
+		],
+		enablerPrefixes: [],
+		entryPatterns: [
+			"src/i18n.{ts,js,mjs}",
+			"src/i18n/index.{ts,js}",
+			"i18n.{ts,js,mjs}",
+			"i18n/index.{ts,js}"
+		],
+		alwaysUsed: [
+			"src/i18n.{ts,js,mjs}",
+			"src/i18n/index.{ts,js}",
+			"i18n.{ts,js,mjs}",
+			"i18n/index.{ts,js}",
+			"i18next.config.{js,ts,mjs}",
+			"next-i18next.config.{js,mjs}",
+			"locales/**/*.json",
+			"public/locales/**/*.json",
+			"src/locales/**/*.json"
+		]
+	},
+	{
+		enablers: ["turbo"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["turbo.json", "turbo/generators/config.{ts,js}"]
+	},
+	{
+		enablers: [
+			"@sentry/nextjs",
+			"@sentry/react",
+			"@sentry/node",
+			"@sentry/browser"
+		],
+		enablerPrefixes: ["@sentry/"],
+		entryPatterns: [],
+		alwaysUsed: [
+			"sentry.client.config.{ts,js,mjs}",
+			"sentry.server.config.{ts,js,mjs}",
+			"sentry.edge.config.{ts,js,mjs}"
+		]
+	},
+	{
+		enablers: ["nodemon"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [
+			"nodemon.json",
+			".nodemonrc",
+			".nodemonrc.{json,yml,yaml}"
+		]
+	},
+	{
+		enablers: ["nx"],
+		enablerPrefixes: ["@nx/"],
+		entryPatterns: [],
+		alwaysUsed: ["nx.json", "**/project.json"]
+	},
+	{
+		enablers: ["react-native"],
+		enablerPrefixes: ["@react-native/", "@react-native-community/"],
+		entryPatterns: [
+			"index.{ts,tsx,js,jsx}",
+			"App.{ts,tsx,js,jsx}",
+			"src/App.{ts,tsx,js,jsx}"
+		],
+		alwaysUsed: [
+			"metro.config.{ts,js}",
+			"react-native.config.{ts,js}",
+			"app.json"
+		]
+	},
+	{
+		enablers: ["expo"],
+		enablerPrefixes: ["@expo/"],
+		entryPatterns: [
+			"App.{ts,tsx,js,jsx}",
+			"app/_layout.{ts,tsx,js,jsx}",
+			"app/index.{ts,tsx,js,jsx}"
+		],
+		alwaysUsed: ["app.json", "app.config.{ts,mts,cts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["wrangler"],
+		enablerPrefixes: ["@cloudflare/"],
+		entryPatterns: [
+			"src/index.{ts,js}",
+			"src/worker.{ts,js}",
+			"functions/**/*.{ts,js}"
+		],
+		alwaysUsed: [
+			"wrangler.toml",
+			"wrangler.json",
+			"wrangler.jsonc"
+		]
+	},
+	{
+		enablers: [
+			"electron",
+			"electron-builder",
+			"@electron-forge/cli",
+			"electron-vite",
+			"electron-webpack",
+			"electron-next"
+		],
+		enablerPrefixes: ["@electron-forge/", "@electron/"],
+		entryPatterns: [
+			"src/main/**/*.{ts,tsx,js,jsx}",
+			"src/preload/**/*.{ts,tsx,js,jsx}",
+			"electron/main.{ts,js}",
+			"main/index.{ts,tsx,js,jsx}",
+			"renderer/pages/**/*.{ts,tsx,js,jsx}"
+		],
+		alwaysUsed: [
+			"electron-builder.{yml,yaml,json,json5,toml}",
+			"forge.config.{ts,js,cjs}",
+			"electron.vite.config.{ts,js,mjs}"
+		]
+	},
+	{
+		enablers: ["lefthook"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [
+			"lefthook.yml",
+			"lefthook.yaml",
+			".lefthook.yml"
+		]
+	},
+	{
+		enablers: ["syncpack"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [
+			".syncpackrc",
+			".syncpackrc.{json,yaml,yml}",
+			"syncpack.config.{js,mjs,cjs}"
+		]
+	},
+	{
+		enablers: ["@capacitor/core", "@capacitor/cli"],
+		enablerPrefixes: ["@capacitor/"],
+		entryPatterns: [],
+		alwaysUsed: ["capacitor.config.{ts,js,json}"]
+	}
+];
+const detectNodeTestRunner = (directory) => {
+	try {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) return false;
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const scripts = JSON.parse(content).scripts ?? {};
+		return Object.values(scripts).some((scriptValue) => typeof scriptValue === "string" && /\bnode\b.*\s--test\b/.test(scriptValue));
+	} catch {
+		return false;
+	}
+};
+const detectBunTestRunner = (directory) => {
+	try {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) return false;
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const scripts = JSON.parse(content).scripts ?? {};
+		return Object.values(scripts).some((scriptValue) => typeof scriptValue === "string" && /\bbun\s+test\b/.test(scriptValue));
+	} catch {
+		return false;
+	}
+};
+const readPackageJsonDependencies = (packageJsonPath) => {
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		return {
+			...packageJson.dependencies,
+			...packageJson.devDependencies,
+			...packageJson.optionalDependencies
+		};
+	} catch {
+		return {};
+	}
+};
+const discoverTestRunnerEntryPoints = (rootDir, workspacePackages) => {
+	const allEntries = [];
+	const allAlwaysUsed = [];
+	const directoriesToCheck = [rootDir, ...workspacePackages.map((workspacePackage) => workspacePackage.directory)];
+	const monorepoRoot = findMonorepoRoot(rootDir);
+	const monorepoRootDeps = monorepoRoot && monorepoRoot !== rootDir ? readPackageJsonDependencies(join(monorepoRoot, "package.json")) : {};
+	for (const directory of directoriesToCheck) {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+		let allDependencies = {};
+		try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(content);
+			allDependencies = {
+				...packageJson.dependencies,
+				...packageJson.devDependencies,
+				...packageJson.optionalDependencies
+			};
+		} catch {
+			continue;
+		}
+		const activatedPatterns = [];
+		const activatedFixturePatterns = [];
+		const activatedAlwaysUsed = [];
+		const isRunnerEnabled = (runner, dependencies, checkDirectory) => {
+			if (runner.enablers.some((enabler) => {
+				return enabler in dependencies;
+			})) return true;
+			return runner.configFileActivators.some((configFile) => existsSync(join(checkDirectory, configFile)));
+		};
+		for (const runner of TEST_FRAMEWORK_PATTERNS) {
+			const enabledLocally = isRunnerEnabled(runner, allDependencies, directory);
+			const enabledViaMonorepo = !enabledLocally && monorepoRoot && (isRunnerEnabled(runner, monorepoRootDeps, monorepoRoot) || runner.configFileActivators.some((configFile) => existsSync(join(monorepoRoot, configFile))));
+			if (enabledLocally || enabledViaMonorepo) {
+				const isVitestRunner = runner.enablers.includes("vitest");
+				const isJestRunner = runner.enablers.includes("jest");
+				let customPatterns = [];
+				if (isVitestRunner) {
+					customPatterns = extractVitestIncludePatterns(directory);
+					if (customPatterns.length === 0 && monorepoRoot) customPatterns = extractVitestIncludePatterns(monorepoRoot);
+				} else if (isJestRunner) {
+					customPatterns = extractJestTestMatchPatterns(directory);
+					if (customPatterns.length === 0 && monorepoRoot) customPatterns = extractJestTestMatchPatterns(monorepoRoot);
+				}
+				if (customPatterns.length > 0) activatedPatterns.push(...customPatterns);
+				else activatedPatterns.push(...runner.entryPatterns);
+				activatedFixturePatterns.push(...runner.fixturePatterns);
+				activatedAlwaysUsed.push(...runner.alwaysUsed);
+			}
+		}
+		if (activatedPatterns.length === 0 && directory !== rootDir) {
+			const rootPackageJsonPath = join(rootDir, "package.json");
+			if (existsSync(rootPackageJsonPath)) try {
+				const rootContent = readFileSync(rootPackageJsonPath, "utf-8");
+				const rootPackageJson = JSON.parse(rootContent);
+				const rootDeps = {
+					...rootPackageJson.dependencies,
+					...rootPackageJson.devDependencies,
+					...rootPackageJson.optionalDependencies
+				};
+				for (const runner of TEST_FRAMEWORK_PATTERNS) if (isRunnerEnabled(runner, rootDeps, rootDir)) {
+					activatedPatterns.push(...runner.entryPatterns);
+					activatedFixturePatterns.push(...runner.fixturePatterns);
+					activatedAlwaysUsed.push(...runner.alwaysUsed);
+				}
+			} catch {}
+		}
+		if (detectNodeTestRunner(directory) || detectNodeTestRunner(rootDir)) activatedPatterns.push("**/*.test.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", "**/*.spec.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", "**/__tests__/**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}");
+		if (detectBunTestRunner(directory) || detectBunTestRunner(rootDir)) activatedPatterns.push("**/*.test.{ts,tsx,js,jsx,mts,mjs}", "**/*.spec.{ts,tsx,js,jsx,mts,mjs}", "**/*_test.{ts,tsx,js,jsx,mts,mjs}", "**/*_spec.{ts,tsx,js,jsx,mts,mjs}", "**/__tests__/**/*.{ts,tsx,js,jsx,mts,mjs}");
+		if (activatedPatterns.length === 0) continue;
+		const uniquePatterns = [...new Set(activatedPatterns)];
+		const testFiles = fg.sync(uniquePatterns, {
+			cwd: directory,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**", "**/*.gen.{ts,tsx,js,jsx}"]
+		});
+		allEntries.push(...testFiles);
+		const uniqueFixturePatterns = [...new Set(activatedFixturePatterns)];
+		if (uniqueFixturePatterns.length > 0) {
+			const fixtureFiles = fg.sync(uniqueFixturePatterns, {
+				cwd: directory,
+				absolute: true,
+				onlyFiles: true,
+				ignore: ["**/node_modules/**"]
+			});
+			allEntries.push(...fixtureFiles);
+		}
+		const uniqueAlwaysUsed = [...new Set(activatedAlwaysUsed)];
+		if (uniqueAlwaysUsed.length > 0) {
+			const alwaysUsedFiles = fg.sync(uniqueAlwaysUsed, {
+				cwd: directory,
+				absolute: true,
+				onlyFiles: true,
+				ignore: ["**/node_modules/**"],
+				dot: true
+			});
+			allAlwaysUsed.push(...alwaysUsedFiles);
+		}
+	}
+	return {
+		entryFiles: allEntries,
+		alwaysUsedFiles: allAlwaysUsed
+	};
+};
+const isToolingPluginEnabled = (plugin, dependencies) => {
+	if (plugin.enablers.some((enabler) => enabler in dependencies)) return true;
+	if (plugin.enablerPrefixes.length > 0) {
+		const depNames = Object.keys(dependencies);
+		return plugin.enablerPrefixes.some((prefix) => depNames.some((depName) => depName.startsWith(prefix)));
+	}
+	return false;
+};
+const FRAMEWORK_SCRIPT_BINARIES = {
+	next: ["next"],
+	nuxt: ["nuxt"],
+	astro: ["astro"],
+	gatsby: ["gatsby"],
+	"@remix-run/dev": ["remix"],
+	"@react-router/dev": ["react-router"],
+	"@sveltejs/kit": ["svelte-kit", "vite-svelte-kit"],
+	"@docusaurus/core": ["docusaurus"],
+	"@angular/core": ["ng"],
+	"@nestjs/core": ["nest"],
+	storybook: [
+		"storybook",
+		"start-storybook",
+		"build-storybook"
+	]
+};
+const detectFrameworkFromScripts = (scripts) => {
+	const enabledEnablers = /* @__PURE__ */ new Set();
+	if (!scripts || typeof scripts !== "object") return enabledEnablers;
+	for (const scriptValue of Object.values(scripts)) {
+		if (typeof scriptValue !== "string") continue;
+		const tokenized = scriptValue.split(/[\s|&;]+/);
+		for (const token of tokenized) {
+			const cleaned = token.replace(/^.*\//, "");
+			for (const [enabler, binaries] of Object.entries(FRAMEWORK_SCRIPT_BINARIES)) if (binaries.includes(cleaned)) enabledEnablers.add(enabler);
+		}
+	}
+	return enabledEnablers;
+};
+const readPackageScripts = (directory) => {
+	const packageJsonPath = join(directory, "package.json");
+	if (!existsSync(packageJsonPath)) return void 0;
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		return JSON.parse(content).scripts;
+	} catch {
+		return;
+	}
+};
+const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
+	const allEntries = [];
+	const allAlwaysUsed = [];
+	const directoriesToCheck = [rootDir, ...workspacePackages.map((workspacePackage) => workspacePackage.directory)];
+	let rootDependencies = {};
+	const rootPackageJsonPath = join(rootDir, "package.json");
+	if (existsSync(rootPackageJsonPath)) try {
+		const rootContent = readFileSync(rootPackageJsonPath, "utf-8");
+		const rootPackageJson = JSON.parse(rootContent);
+		rootDependencies = {
+			...rootPackageJson.dependencies,
+			...rootPackageJson.devDependencies,
+			...rootPackageJson.optionalDependencies
+		};
+	} catch {}
+	const monorepoRoot = findMonorepoRoot(rootDir);
+	const monorepoRootDeps = monorepoRoot && monorepoRoot !== rootDir ? readPackageJsonDependencies(join(monorepoRoot, "package.json")) : {};
+	for (const directory of directoriesToCheck) {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+		let workspaceDependencies = {};
+		try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(content);
+			workspaceDependencies = {
+				...packageJson.dependencies,
+				...packageJson.devDependencies,
+				...packageJson.optionalDependencies
+			};
+		} catch {
+			continue;
+		}
+		const scriptDetectedEnablers = detectFrameworkFromScripts(readPackageScripts(directory));
+		const mergedDependencies = { ...workspaceDependencies };
+		if (directory === rootDir) Object.assign(mergedDependencies, rootDependencies);
+		for (const enabler of scriptDetectedEnablers) if (enabler in workspaceDependencies || enabler in rootDependencies || enabler in monorepoRootDeps) mergedDependencies[enabler] = "*";
+		const activatedPatterns = [];
+		const activatedAlwaysUsed = [];
+		for (const plugin of FRAMEWORK_PATTERNS) if (isToolingPluginEnabled(plugin, mergedDependencies)) {
+			activatedPatterns.push(...plugin.entryPatterns);
+			activatedAlwaysUsed.push(...plugin.alwaysUsed);
+		}
+		if (activatedPatterns.length === 0 && activatedAlwaysUsed.length === 0) continue;
+		const uniquePatterns = [...new Set(activatedPatterns)];
+		const toolingFiles = fg.sync(uniquePatterns, {
+			cwd: directory,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"],
+			dot: true
+		});
+		allEntries.push(...toolingFiles);
+		const uniqueAlwaysUsed = [...new Set(activatedAlwaysUsed)];
+		if (uniqueAlwaysUsed.length > 0) {
+			const alwaysUsedFiles = fg.sync(uniqueAlwaysUsed, {
+				cwd: directory,
+				absolute: true,
+				onlyFiles: true,
+				ignore: ["**/node_modules/**"],
+				dot: true
+			});
+			allAlwaysUsed.push(...alwaysUsedFiles);
+		}
+	}
+	const rootActivatedGlobalPatterns = [];
+	for (const plugin of FRAMEWORK_PATTERNS) if (isToolingPluginEnabled(plugin, rootDependencies)) {
+		for (const pattern of plugin.alwaysUsed) if (!pattern.startsWith("**/")) rootActivatedGlobalPatterns.push(`**/${pattern}`);
+	}
+	if (rootActivatedGlobalPatterns.length > 0) {
+		const globalAlwaysUsedFiles = fg.sync([...new Set(rootActivatedGlobalPatterns)], {
+			cwd: rootDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"],
+			dot: true
+		});
+		allAlwaysUsed.push(...globalAlwaysUsedFiles);
+	}
+	return {
+		entryFiles: allEntries,
+		alwaysUsedFiles: allAlwaysUsed
+	};
+};
+
+//#endregion
+//#region src/collect/entries-worker.ts
+const port = parentPort;
+port.on("message", (message) => {
+	if (message.type !== "resolve-entries") return;
+	resolveEntries(message.config).then((entries) => {
+		const response = {
+			type: "result",
+			entries
+		};
+		port.postMessage(response);
+	}, (taskError) => {
+		const response = {
+			type: "error",
+			errorMessage: taskError instanceof Error ? taskError.message : String(taskError)
+		};
+		port.postMessage(response);
+	});
+});
+port.postMessage({ type: "ready" });
+
+//#endregion
+export {  };