@teardown/metro-config 2.0.85 → 2.0.87

package/dist/bun.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../src/bun.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAAwB,CAAC;AAEvD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,CAkCjH;AAmCD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,CAQ5E"}
+{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../src/bun.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAAwB,CAAC;AAwCvD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,CAsBjH;AAmCD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,CAQ5E"}

package/dist/dev-client.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Dev Client Metro Configuration
+ *
+ * Provides Metro configuration for injecting the dev client launcher
+ * before the main application entry point. This enables expo-dev-client-like
+ * behavior for bare React Native apps.
+ *
+ * @packageDocumentation
+ */
+import type { MetroConfig } from "./types";
+/**
+ * Dev client configuration options
+ */
+export interface DevClientOptions {
+    /**
+     * Whether to enable the dev client launcher.
+     * Only applies in development mode (__DEV__).
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Custom bootstrap module path (advanced usage).
+     * Defaults to @teardown/dev-client/bootstrap
+     */
+    bootstrapModule?: string;
+    /**
+     * Enable verbose logging
+     * @default false
+     */
+    verbose?: boolean;
+}
+/**
+ * Wrap Metro config with dev client launcher support.
+ *
+ * This injects a bootstrap module that runs before the main entry point,
+ * allowing the dev client launcher to show before the app loads.
+ * The bootstrap module:
+ * - Patches AppRegistry.registerComponent to capture app registrations
+ * - Shows a launcher UI before the main app
+ * - Automatically wraps the app with DevClientProvider when launched
+ *
+ * @param config - Metro configuration
+ * @param options - Dev client options
+ * @returns Enhanced Metro configuration
+ *
+ * @example
+ * ```js
+ * // metro.config.js
+ * const { withTeardown, withTeardownDevClient } = require('@teardown/metro-config');
+ * const { getDefaultConfig } = require('@react-native/metro-config');
+ *
+ * let config = getDefaultConfig(__dirname);
+ * config = withTeardown(config);
+ * config = withTeardownDevClient(config);
+ *
+ * module.exports = config;
+ * ```
+ */
+export declare function withTeardownDevClient(config: MetroConfig, options?: DevClientOptions): MetroConfig;
+//# sourceMappingURL=dev-client.d.ts.map

package/dist/dev-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-client.d.ts","sourceRoot":"","sources":["../src/dev-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAqBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB,GAAG,WAAW,CAyCtG"}

package/dist/index.d.ts

@@ -56,6 +56,7 @@ import type { MetroConfig, TeardownMetroOptions } from "./types";
 export declare function withTeardown(config: MetroConfig, options?: TeardownMetroOptions): MetroConfig;
 export { getStoredOptions };
 export { BUN_BLOCK_PATTERN, getBlockList } from "./bun";
+export { type DevClientOptions, withTeardownDevClient } from "./dev-client";
 export { createTsConfigPathsResolver, parseTsConfigPaths } from "./tsconfig-paths";
 export { getMetroServerRoot, getModulesPaths, getRelativeProjectRoot, getWatchFolders, getWorkspaceRoot, isInMonorepo, } from "./workspace";
 export type { TeardownMetroOptions, MetroConfig };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,gBAAgB,EAAiB,MAAM,yBAAyB,CAAC;AAG1E,OAAO,KAAK,EAAE,WAAW,EAAoB,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAUnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,oBAAyB,GAAG,WAAW,CAmGjG;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAG5B,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAExD,OAAO,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEnF,OAAO,EACN,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,YAAY,GACZ,MAAM,aAAa,CAAC;AAGrB,YAAY,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,gBAAgB,EAAiB,MAAM,yBAAyB,CAAC;AAG1E,OAAO,KAAK,EAAE,WAAW,EAAoB,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAUnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,oBAAyB,GAAG,WAAW,CAmGjG;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAG5B,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAExD,OAAO,EAAE,KAAK,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE5E,OAAO,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEnF,OAAO,EACN,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,YAAY,GACZ,MAAM,aAAa,CAAC;AAGrB,YAAY,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAC"}

package/dist/tsconfig-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsconfig-paths.d.ts","sourceRoot":"","sources":["../src/tsconfig-paths.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,UAAU,aAAa;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACjC;AAED,UAAU,WAAW;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CACvB;AAoGD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAqB5E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,WAAW,EAAE,CAsB3F;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,GAAG,IAAI,CA0CnG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAC1C,WAAW,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,gBAAgB,EAC/B,OAAO,UAAQ,GACb,gBAAgB,CAyClB"}
+{"version":3,"file":"tsconfig-paths.d.ts","sourceRoot":"","sources":["../src/tsconfig-paths.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,UAAU,aAAa;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACjC;AAED,UAAU,WAAW;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CACvB;AAoGD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAqB5E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,WAAW,EAAE,CAsB3F;AAmGD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,GAAG,IAAI,CAQnG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAC1C,WAAW,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,gBAAgB,EAC/B,OAAO,UAAQ,GACb,gBAAgB,CAyClB"}

package/dist/types.d.ts

@@ -18,6 +18,14 @@ export interface MetroConfig extends FacetpackMetroConfig {
         customTransformOptions?: Record<string, unknown>;
         [key: string]: unknown;
     };
+    serializer?: {
+        /**
+         * Function that returns modules to run before the main entry point.
+         * Used by dev-client to inject bootstrap code.
+         */
+        getModulesRunBeforeMainModule?: (entryFilePath: string) => string[];
+        [key: string]: unknown;
+    };
     [key: string]: unknown;
 }
 /**

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,oBAAoB;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE;QACV,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QAC9B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;QAC5B,cAAc,CAAC,EAAE,gBAAgB,CAAC;QAClC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACvB,CAAC;IACF,WAAW,CAAC,EAAE;QACb,sBAAsB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACvB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC9B,OAAO,EAAE;IAAE,cAAc,EAAE,gBAAgB,CAAA;CAAE,EAC7C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,KACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,oBAAoB;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE;QACV,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QAC9B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;QAC5B,cAAc,CAAC,EAAE,gBAAgB,CAAC;QAClC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACvB,CAAC;IACF,WAAW,CAAC,EAAE;QACb,sBAAsB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACvB,CAAC;IACF,UAAU,CAAC,EAAE;QACZ;;;WAGG;QACH,6BAA6B,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;QACpE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACvB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC9B,OAAO,EAAE;IAAE,cAAc,EAAE,gBAAgB,CAAA;CAAE,EAC7C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,KACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teardown/metro-config",
-	"version": "2.0.85",
+	"version": "2.0.87",
 	"description": "Metro configuration for Teardown - Rust-powered transforms via Facetpack",
 	"private": false,
 	"publishConfig": {
@@ -14,6 +14,11 @@
 			"require": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
+		"./dev-client": {
+			"types": "./dist/dev-client.d.ts",
+			"require": "./dist/dev-client.js",
+			"default": "./dist/dev-client.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"files": [
@@ -22,7 +27,7 @@
 	"scripts": {
 		"build": "tsc",
 		"prepublishOnly": "bun run build",
-		"typecheck": "bun x tsgo --noEmit",
+		"typecheck": "bunx tsgo --noEmit",
 		"lint": "bun x biome lint --write ./src",
 		"fmt": "bun x biome format --write ./src",
 		"check": "bun x biome check ./src"
@@ -45,8 +50,11 @@
 		"resolve-workspace-root": "^2.0.0"
 	},
 	"devDependencies": {
-		"@teardown/tsconfig": "2.0.85",
-		"@types/bun": "1.3.5",
+		"@typescript/native-preview": "^7.0.0-dev.20260203.1",
+		"@ecrindigital/facetpack": "^0.2.0",
+		"@teardown/tsconfig": "2.0.87",
+		"@types/bun": "1.3.8",
+		"@types/node": "24.10.1",
 		"typescript": "5.9.3"
 	},
 	"keywords": [

package/dist/bun.js

@@ -1,107 +0,0 @@
-"use strict";
-/**
- * Bun-specific Metro configuration utilities.
- *
- * Handles blocking of .bun directories which can cause Metro resolution issues.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUN_BLOCK_PATTERN = void 0;
-exports.createBunAwareResolver = createBunAwareResolver;
-exports.getBlockList = getBlockList;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const workspace_1 = require("./workspace");
-/**
- * Block pattern for .bun directories.
- * Metro's blockList prevents processing of matched paths.
- */
-exports.BUN_BLOCK_PATTERN = /.*[/\\]\.bun[/\\].*/;
-/**
- * Create a custom resolver that filters out .bun paths during module resolution.
- *
- * Note: The primary mechanism for blocking .bun directories is the blockList pattern.
- * This resolver provides an additional layer of protection by finding alternative
- * paths when a resolution from an existing custom resolver points to .bun.
- *
- * IMPORTANT: This resolver returns null when it doesn't handle resolution, signaling
- * Metro to use its default resolution. Do NOT call context.resolveRequest as that
- * points to the outermost resolver (e.g., Uniwind) and creates infinite loops.
- *
- * @param projectRoot - The project root directory
- * @param existingResolver - Optional existing resolver from the config that should be preserved.
- */
-function createBunAwareResolver(projectRoot, existingResolver) {
-    const modulesPaths = (0, workspace_1.getModulesPaths)(projectRoot);
-    return (context, moduleName, platform) => {
-        // If there's an existing resolver, try it first
-        let result = null;
-        if (existingResolver) {
-            result = existingResolver(context, moduleName, platform);
-        }
-        // If no result from existing resolver, return null to let Metro use its default
-        // Do NOT call context.resolveRequest - it points to the outermost resolver
-        if (!result) {
-            return null;
-        }
-        // If resolved path contains .bun, try to find alternative
-        if (result.filePath?.includes("/.bun/")) {
-            for (const modulesPath of modulesPaths) {
-                if (modulesPath.includes("/.bun/"))
-                    continue;
-                const packagePath = node_path_1.default.join(modulesPath, moduleName);
-                if ((0, node_fs_1.existsSync)(packagePath)) {
-                    const mainFile = resolvePackageMain(packagePath);
-                    if (mainFile) {
-                        return { type: "sourceFile", filePath: mainFile };
-                    }
-                }
-            }
-        }
-        return result;
-    };
-}
-/**
- * Resolve the main entry point of a package.
- */
-function resolvePackageMain(packagePath) {
-    const packageJsonPath = node_path_1.default.join(packagePath, "package.json");
-    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
-        try {
-            const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
-            const main = pkg.main || pkg.module || "index.js";
-            const mainPath = node_path_1.default.join(packagePath, main);
-            if ((0, node_fs_1.existsSync)(mainPath)) {
-                return mainPath;
-            }
-            // Try with .js extension
-            const mainPathJs = mainPath + ".js";
-            if ((0, node_fs_1.existsSync)(mainPathJs)) {
-                return mainPathJs;
-            }
-        }
-        catch {
-            // Ignore parse errors
-        }
-    }
-    // Fallback to index.js
-    const indexPath = node_path_1.default.join(packagePath, "index.js");
-    if ((0, node_fs_1.existsSync)(indexPath)) {
-        return indexPath;
-    }
-    return null;
-}
-/**
- * Get blockList patterns for Metro config.
- * Includes .bun directory blocking.
- */
-function getBlockList(existingBlockList) {
-    const blockListArray = Array.isArray(existingBlockList)
-        ? existingBlockList
-        : existingBlockList
-            ? [existingBlockList]
-            : [];
-    return [...blockListArray, exports.BUN_BLOCK_PATTERN];
-}

package/dist/index.js

@@ -1,160 +0,0 @@
-"use strict";
-/**
- * @teardown/metro-config
- *
- * Metro configuration wrapper that provides:
- * - Rust-powered transforms via Facetpack (36x faster than Babel)
- * - Automatic monorepo/workspace detection and configuration
- * - Bun-specific handling (blocks .bun directories)
- *
- * @example
- * ```js
- * // metro.config.js
- * const { withTeardown } = require('@teardown/metro-config')
- * const { getDefaultConfig } = require('@react-native/metro-config')
- *
- * module.exports = withTeardown(getDefaultConfig(__dirname))
- * ```
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInMonorepo = exports.getWorkspaceRoot = exports.getWatchFolders = exports.getRelativeProjectRoot = exports.getModulesPaths = exports.getMetroServerRoot = exports.parseTsConfigPaths = exports.createTsConfigPathsResolver = exports.getBlockList = exports.BUN_BLOCK_PATTERN = exports.getStoredOptions = void 0;
-exports.withTeardown = withTeardown;
-const facetpack_1 = require("@ecrindigital/facetpack");
-Object.defineProperty(exports, "getStoredOptions", { enumerable: true, get: function () { return facetpack_1.getStoredOptions; } });
-const bun_1 = require("./bun");
-const tsconfig_paths_1 = require("./tsconfig-paths");
-const workspace_1 = require("./workspace");
-/**
- * Wraps a Metro configuration with Teardown's enhancements.
- *
- * This function applies:
- * - Facetpack for Rust-powered transforms (36x faster)
- * - Automatic monorepo detection and watch folder configuration
- * - Bun-specific handling (.bun directory blocking)
- * - Proper nodeModulesPaths for monorepo resolution
- *
- * @param config - Base Metro configuration
- * @param options - Optional configuration options
- * @returns Enhanced Metro configuration
- *
- * @example
- * ```js
- * // Basic usage - all monorepo handling is automatic
- * const { withTeardown } = require('@teardown/metro-config')
- * const { getDefaultConfig } = require('@react-native/metro-config')
- *
- * module.exports = withTeardown(getDefaultConfig(__dirname))
- * ```
- *
- * @example
- * ```js
- * // With options
- * const { withTeardown } = require('@teardown/metro-config')
- * const { getDefaultConfig } = require('@react-native/metro-config')
- *
- * module.exports = withTeardown(getDefaultConfig(__dirname), {
- *   verbose: true,
- *   projectRoot: __dirname, // explicitly set project root
- * })
- * ```
- */
-function withTeardown(config, options = {}) {
-    const { verbose, projectRoot: explicitProjectRoot, tsconfigPaths = true, ...facetpackOptions } = options;
-    // Determine project root
-    const projectRoot = explicitProjectRoot || config.projectRoot || process.cwd();
-    if (verbose) {
-        console.log("[teardown/metro-config] Applying Teardown configuration...");
-        console.log(`[teardown/metro-config] Project root: ${projectRoot}`);
-    }
-    // Check if in monorepo
-    const inMonorepo = (0, workspace_1.isInMonorepo)(projectRoot);
-    if (verbose && inMonorepo) {
-        const workspaceRoot = (0, workspace_1.getWorkspaceRoot)(projectRoot);
-        console.log(`[teardown/metro-config] Monorepo detected: ${workspaceRoot}`);
-    }
-    // Get monorepo-aware watch folders
-    const additionalWatchFolders = (0, workspace_1.getWatchFolders)(projectRoot);
-    const existingWatchFolders = config.watchFolders || [];
-    // Get monorepo-aware node modules paths
-    const modulesPaths = (0, workspace_1.getModulesPaths)(projectRoot);
-    const existingNodeModulesPaths = config.resolver?.nodeModulesPaths || [];
-    // Get block list with .bun blocking
-    const blockList = (0, bun_1.getBlockList)(config.resolver?.blockList);
-    // Get any existing custom resolver from the config
-    const existingResolver = config.resolver?.resolveRequest;
-    // Create resolver chain: tsconfig paths -> bun-aware -> existing/default
-    // The bun-aware resolver handles .bun path filtering
-    const bunAwareResolver = (0, bun_1.createBunAwareResolver)(projectRoot, existingResolver);
-    // Apply tsconfig paths resolver on top (so it runs first)
-    const chainedResolver = tsconfigPaths
-        ? (0, tsconfig_paths_1.createTsConfigPathsResolver)(projectRoot, bunAwareResolver, verbose)
-        : bunAwareResolver;
-    // Wrap with null-safe handling so external plugins (like Uniwind) don't receive null
-    // When our resolver chain returns null, use Metro's internal resolver as fallback
-    const nullSafeResolver = (context, moduleName, platform) => {
-        const result = chainedResolver(context, moduleName, platform);
-        if (result === null) {
-            return context.resolveRequest(context, moduleName, platform);
-        }
-        return result;
-    };
-    // Build enhanced config
-    const enhancedConfig = {
-        ...config,
-        projectRoot,
-        watchFolders: [...new Set([...existingWatchFolders, ...additionalWatchFolders])],
-        resolver: {
-            ...config.resolver,
-            blockList,
-            nodeModulesPaths: [...new Set([...modulesPaths, ...existingNodeModulesPaths])],
-            resolveRequest: nullSafeResolver,
-        },
-    };
-    // Set unstable_serverRoot for monorepo web support
-    if (inMonorepo) {
-        const serverRoot = (0, workspace_1.getMetroServerRoot)(projectRoot);
-        enhancedConfig.unstable_serverRoot = serverRoot;
-        // Add relative project root to transformer cache key for cache collision prevention
-        const relativeRoot = (0, workspace_1.getRelativeProjectRoot)(projectRoot);
-        if (relativeRoot) {
-            const existingCacheKey = config.transformer?.customTransformOptions || {};
-            enhancedConfig.transformer = {
-                ...config.transformer,
-                customTransformOptions: {
-                    ...existingCacheKey,
-                    _teardownRelativeProjectRoot: relativeRoot,
-                },
-            };
-        }
-    }
-    if (verbose) {
-        const watchFoldersCount = enhancedConfig.watchFolders?.length || 0;
-        const nodeModulesPathsCount = enhancedConfig.resolver?.nodeModulesPaths?.length || 0;
-        console.log(`[teardown/metro-config] Watch folders: ${watchFoldersCount}`);
-        console.log(`[teardown/metro-config] Node modules paths: ${nodeModulesPathsCount}`);
-    }
-    // Apply Facetpack for Rust-powered transforms
-    const finalConfig = (0, facetpack_1.withFacetpack)(enhancedConfig, facetpackOptions);
-    if (verbose) {
-        console.log("[teardown/metro-config] Metro config enhanced successfully");
-    }
-    return finalConfig;
-}
-// Re-export Bun utilities
-var bun_2 = require("./bun");
-Object.defineProperty(exports, "BUN_BLOCK_PATTERN", { enumerable: true, get: function () { return bun_2.BUN_BLOCK_PATTERN; } });
-Object.defineProperty(exports, "getBlockList", { enumerable: true, get: function () { return bun_2.getBlockList; } });
-// Re-export tsconfig paths utilities
-var tsconfig_paths_2 = require("./tsconfig-paths");
-Object.defineProperty(exports, "createTsConfigPathsResolver", { enumerable: true, get: function () { return tsconfig_paths_2.createTsConfigPathsResolver; } });
-Object.defineProperty(exports, "parseTsConfigPaths", { enumerable: true, get: function () { return tsconfig_paths_2.parseTsConfigPaths; } });
-// Re-export workspace utilities for advanced use cases
-var workspace_2 = require("./workspace");
-Object.defineProperty(exports, "getMetroServerRoot", { enumerable: true, get: function () { return workspace_2.getMetroServerRoot; } });
-Object.defineProperty(exports, "getModulesPaths", { enumerable: true, get: function () { return workspace_2.getModulesPaths; } });
-Object.defineProperty(exports, "getRelativeProjectRoot", { enumerable: true, get: function () { return workspace_2.getRelativeProjectRoot; } });
-Object.defineProperty(exports, "getWatchFolders", { enumerable: true, get: function () { return workspace_2.getWatchFolders; } });
-Object.defineProperty(exports, "getWorkspaceRoot", { enumerable: true, get: function () { return workspace_2.getWorkspaceRoot; } });
-Object.defineProperty(exports, "isInMonorepo", { enumerable: true, get: function () { return workspace_2.isInMonorepo; } });

package/dist/tsconfig-paths.js

@@ -1,239 +0,0 @@
-"use strict";
-/**
- * TSConfig paths resolution for Metro.
- *
- * Enables `compilerOptions.paths` and `compilerOptions.baseUrl` support for import aliases.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTsConfigPaths = parseTsConfigPaths;
-exports.buildPathMappings = buildPathMappings;
-exports.resolveWithTsConfigPaths = resolveWithTsConfigPaths;
-exports.createTsConfigPathsResolver = createTsConfigPathsResolver;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Try to import TypeScript from the project.
- */
-function importTypeScriptFromProjectOptionally(projectRoot) {
-    try {
-        const tsPath = require.resolve("typescript", { paths: [projectRoot] });
-        return require(tsPath);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Evaluate tsconfig.json using TypeScript's parseJsonConfigFileContent.
- * This properly handles `extends` and all inheritance.
- */
-function evaluateTsConfig(ts, configPath) {
-    const configDir = node_path_1.default.dirname(configPath);
-    const configFileText = ts.sys.readFile(configPath);
-    if (!configFileText) {
-        return {};
-    }
-    const result = ts.parseConfigFileTextToJson(configPath, configFileText);
-    if (result.error) {
-        return {};
-    }
-    const parsedConfig = ts.parseJsonConfigFileContent(result.config, ts.sys, configDir, undefined, configPath);
-    return {
-        compilerOptions: {
-            baseUrl: parsedConfig.options.baseUrl,
-            paths: parsedConfig.options.paths,
-        },
-    };
-}
-/**
- * Clean JSON5 content (remove comments and trailing commas) for JSON.parse.
- */
-function cleanJsonContent(content) {
-    return content
-        .replace(/\/\*[\s\S]*?\*\//g, "") // Remove /* */ comments
-        .replace(/\/\/.*/g, "") // Remove // comments
-        .replace(/,(\s*[}\]])/g, "$1"); // Remove trailing commas
-}
-/**
- * Parse a config file manually (fallback when TypeScript isn't available).
- */
-function parseConfigFileManually(configPath) {
-    try {
-        const content = (0, node_fs_1.readFileSync)(configPath, "utf8");
-        const config = JSON.parse(cleanJsonContent(content));
-        const compilerOptions = config.compilerOptions || {};
-        return {
-            baseUrl: compilerOptions.baseUrl,
-            paths: compilerOptions.paths,
-        };
-    }
-    catch (error) {
-        console.warn(`[teardown/metro-config] Failed to parse ${node_path_1.default.basename(configPath)}: ${error}`);
-        return null;
-    }
-}
-/**
- * Normalize baseUrl from TypeScript's absolute path to relative.
- */
-function normalizeBaseUrl(baseUrl, projectRoot) {
-    if (!baseUrl)
-        return undefined;
-    return node_path_1.default.isAbsolute(baseUrl) ? node_path_1.default.relative(projectRoot, baseUrl) : baseUrl;
-}
-/**
- * Try to parse tsconfig using TypeScript for full extends support.
- */
-function parseTsConfigWithTypeScript(projectRoot, configPath) {
-    const ts = importTypeScriptFromProjectOptionally(projectRoot);
-    if (!ts)
-        return null;
-    try {
-        const config = evaluateTsConfig(ts, configPath);
-        return {
-            baseUrl: normalizeBaseUrl(config.compilerOptions?.baseUrl, projectRoot),
-            paths: config.compilerOptions?.paths,
-        };
-    }
-    catch (error) {
-        console.warn(`[teardown/metro-config] Failed to evaluate tsconfig with TypeScript: ${error}`);
-        return null;
-    }
-}
-/**
- * Parse tsconfig.json and extract paths configuration.
- * Properly evaluates the full config including `extends` inheritance.
- */
-function parseTsConfigPaths(projectRoot) {
-    const tsconfigPath = node_path_1.default.join(projectRoot, "tsconfig.json");
-    const jsconfigPath = node_path_1.default.join(projectRoot, "jsconfig.json");
-    // Try tsconfig.json first
-    if ((0, node_fs_1.existsSync)(tsconfigPath)) {
-        // Try TypeScript evaluation first (handles extends)
-        const tsResult = parseTsConfigWithTypeScript(projectRoot, tsconfigPath);
-        if (tsResult)
-            return tsResult;
-        // Fallback to manual parsing
-        const manualResult = parseConfigFileManually(tsconfigPath);
-        if (manualResult)
-            return manualResult;
-    }
-    // Try jsconfig.json as fallback
-    if ((0, node_fs_1.existsSync)(jsconfigPath)) {
-        return parseConfigFileManually(jsconfigPath);
-    }
-    return null;
-}
-/**
- * Convert tsconfig paths to regex patterns for efficient matching.
- */
-function buildPathMappings(projectRoot, config) {
-    if (!config.paths) {
-        return [];
-    }
-    const baseUrl = config.baseUrl ? node_path_1.default.resolve(projectRoot, config.baseUrl) : projectRoot;
-    const mappings = [];
-    for (const [alias, targets] of Object.entries(config.paths)) {
-        // Convert path pattern to regex
-        // @/* -> @/(.*) -> matches @/anything
-        const regexPattern = alias
-            .replace(/[.+?^${}()|[\]\\]/g, "\\$&") // Escape special regex chars except *
-            .replace(/\*/g, "(.*)"); // Convert * to capture group
-        mappings.push({
-            pattern: new RegExp(`^${regexPattern}$`),
-            replacements: targets.map((target) => node_path_1.default.join(baseUrl, target)),
-        });
-    }
-    return mappings;
-}
-/**
- * Resolve a module using tsconfig paths.
- * Returns the resolved file path or null if not matched.
- */
-function resolveWithTsConfigPaths(moduleName, mappings) {
-    for (const { pattern, replacements } of mappings) {
-        const match = moduleName.match(pattern);
-        if (match) {
-            // match[1] contains the captured part (the * replacement)
-            const captured = match[1] || "";
-            for (const replacement of replacements) {
-                // Replace * in the replacement path with the captured part
-                const resolvedPath = replacement.replace("*", captured);
-                // Try various extensions (file must exist and be a file, not directory)
-                const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-                for (const ext of extensions) {
-                    const fullPath = resolvedPath + ext;
-                    if ((0, node_fs_1.existsSync)(fullPath) && (0, node_fs_1.statSync)(fullPath).isFile()) {
-                        return fullPath;
-                    }
-                }
-                // Check if path exists without extension (could be exact file or directory)
-                if ((0, node_fs_1.existsSync)(resolvedPath)) {
-                    const stat = (0, node_fs_1.statSync)(resolvedPath);
-                    if (stat.isFile()) {
-                        return resolvedPath;
-                    }
-                    // If it's a directory, try index files
-                    if (stat.isDirectory()) {
-                        const indexExtensions = [".ts", ".tsx", ".js", ".jsx"];
-                        for (const ext of indexExtensions) {
-                            const indexPath = node_path_1.default.join(resolvedPath, `index${ext}`);
-                            if ((0, node_fs_1.existsSync)(indexPath) && (0, node_fs_1.statSync)(indexPath).isFile()) {
-                                return indexPath;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}
-/**
- * Create a resolver that handles tsconfig paths.
- *
- * IMPORTANT: This resolver returns null when it doesn't handle resolution, signaling
- * Metro to use its default resolution. Do NOT call context.resolveRequest as that
- * points to the outermost resolver (e.g., Uniwind) and creates infinite loops.
- *
- * @param projectRoot - The project root directory
- * @param nextResolver - Optional next resolver in the chain.
- * @param verbose - Whether to log debug information
- */
-function createTsConfigPathsResolver(projectRoot, nextResolver, verbose = false) {
-    const config = parseTsConfigPaths(projectRoot);
-    if (!config?.paths) {
-        if (verbose) {
-            console.log("[teardown/metro-config] No tsconfig paths found, skipping path resolution");
-        }
-        // Pass through to next resolver or return null for Metro's default
-        // Do NOT call context.resolveRequest - it points to the outermost resolver
-        return nextResolver ?? ((_context, _moduleName, _platform) => null);
-    }
-    const mappings = buildPathMappings(projectRoot, config);
-    if (verbose) {
-        console.log(`[teardown/metro-config] Loaded ${mappings.length} path mappings from tsconfig.json`);
-        for (const { pattern, replacements } of mappings) {
-            console.log(`  ${pattern.source} -> ${replacements.join(", ")}`);
-        }
-    }
-    return (context, moduleName, platform) => {
-        // Try tsconfig paths first for alias patterns (typically start with @ or other configured prefixes)
-        const resolvedPath = resolveWithTsConfigPaths(moduleName, mappings);
-        if (resolvedPath) {
-            if (verbose) {
-                console.log(`[teardown/metro-config] Resolved ${moduleName} -> ${resolvedPath}`);
-            }
-            return { type: "sourceFile", filePath: resolvedPath };
-        }
-        // Fall back to next resolver in chain
-        if (nextResolver) {
-            return nextResolver(context, moduleName, platform);
-        }
-        // Return null to let Metro use its default resolution
-        // Do NOT call context.resolveRequest - it points to the outermost resolver
-        return null;
-    };
-}

package/dist/types.js

@@ -1,5 +0,0 @@
-"use strict";
-/**
- * Type definitions for @teardown/metro-config
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/workspace.js

@@ -1,231 +0,0 @@
-"use strict";
-/**
- * Workspace and monorepo detection utilities for Metro configuration.
- *
- * Uses `resolve-workspace-root` to detect workspace roots across:
- * - Yarn workspaces
- * - npm workspaces
- * - pnpm workspaces
- * - Bun workspaces
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.globAllPackageJsonPaths = globAllPackageJsonPaths;
-exports.resolveAllWorkspacePackageJsonPaths = resolveAllWorkspacePackageJsonPaths;
-exports.getWorkspaceRoot = getWorkspaceRoot;
-exports.getWorkspaceGlobs = getWorkspaceGlobs;
-exports.isInMonorepo = isInMonorepo;
-exports.getMetroServerRoot = getMetroServerRoot;
-exports.getWatchFolders = getWatchFolders;
-exports.getModulesPaths = getModulesPaths;
-exports.getRelativeProjectRoot = getRelativeProjectRoot;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const glob_1 = require("glob");
-/**
- * Read and parse a JSON file, returning null if invalid.
- */
-function readJsonFile(filePath) {
-    const file = (0, node_fs_1.readFileSync)(filePath, "utf8");
-    return JSON.parse(file);
-}
-/**
- * Check if a file is a valid JSON file.
- */
-function isValidJsonFile(filePath) {
-    try {
-        readJsonFile(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Glob all package.json paths in a workspace.
- * Matches Expo's implementation pattern.
- *
- * @param workspaceRoot Root file path for the workspace
- * @param linkedPackages List of folders that contain linked node modules, ex: `['packages/*', 'apps/*']`
- * @returns List of valid package.json file paths
- */
-function globAllPackageJsonPaths(workspaceRoot, linkedPackages) {
-    return linkedPackages
-        .flatMap((pattern) => {
-        // Globs should only contain `/` as separator, even on Windows.
-        return (0, glob_1.globSync)(node_path_1.default.posix.join(pattern, "package.json").replace(/\\/g, "/"), {
-            cwd: workspaceRoot,
-            absolute: true,
-            ignore: ["**/@(Carthage|Pods|node_modules)/**"],
-        }).filter((pkgPath) => isValidJsonFile(pkgPath));
-    })
-        .map((p) => node_path_1.default.join(p));
-}
-/**
- * Resolve all workspace package.json paths.
- *
- * @param workspaceRoot root file path for a workspace.
- * @returns list of package.json file paths that are linked to the workspace.
- */
-function resolveAllWorkspacePackageJsonPaths(workspaceRoot) {
-    try {
-        const workspaceGlobs = getWorkspaceGlobs(workspaceRoot);
-        if (!workspaceGlobs?.length)
-            return [];
-        return globAllPackageJsonPaths(workspaceRoot, workspaceGlobs);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Resolve the workspace root directory.
- * Returns the project root if not in a workspace.
- */
-function getWorkspaceRoot(projectRoot) {
-    try {
-        // Dynamic import to handle the package
-        const { resolveWorkspaceRoot } = require("resolve-workspace-root");
-        const workspaceRoot = resolveWorkspaceRoot(projectRoot);
-        return workspaceRoot || projectRoot;
-    }
-    catch {
-        // Fallback: check for turbo.jsonc or package.json with workspaces
-        return findMonorepoRootFallback(projectRoot);
-    }
-}
-/**
- * Fallback monorepo root detection for when resolve-workspace-root fails.
- * Checks for turbo.jsonc or package.json with workspaces field.
- */
-function findMonorepoRootFallback(startDir) {
-    let current = startDir;
-    while (current !== node_path_1.default.dirname(current)) {
-        const turboConfig = node_path_1.default.join(current, "turbo.jsonc");
-        const turboJson = node_path_1.default.join(current, "turbo.json");
-        const packageJson = node_path_1.default.join(current, "package.json");
-        if ((0, node_fs_1.existsSync)(turboConfig) || (0, node_fs_1.existsSync)(turboJson)) {
-            return current;
-        }
-        if ((0, node_fs_1.existsSync)(packageJson)) {
-            try {
-                const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJson, "utf8"));
-                if (pkg.workspaces) {
-                    return current;
-                }
-            }
-            catch {
-                // Ignore parse errors
-            }
-        }
-        current = node_path_1.default.dirname(current);
-    }
-    return startDir;
-}
-/**
- * Get workspace glob patterns from the workspace root.
- */
-function getWorkspaceGlobs(workspaceRoot) {
-    try {
-        const { getWorkspaceGlobs: getGlobs } = require("resolve-workspace-root");
-        return getGlobs(workspaceRoot) ?? [];
-    }
-    catch {
-        // Fallback: try to read from package.json
-        const packageJsonPath = node_path_1.default.join(workspaceRoot, "package.json");
-        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
-            try {
-                const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
-                if (Array.isArray(pkg.workspaces)) {
-                    return pkg.workspaces;
-                }
-                if (pkg.workspaces?.packages) {
-                    return pkg.workspaces.packages;
-                }
-            }
-            catch {
-                // Ignore parse errors
-            }
-        }
-        return [];
-    }
-}
-/**
- * Check if the project is in a monorepo (workspace root differs from project root).
- */
-function isInMonorepo(projectRoot) {
-    const workspaceRoot = getWorkspaceRoot(projectRoot);
-    return workspaceRoot !== projectRoot;
-}
-/**
- * Get the Metro server root for monorepo support.
- * This should be set as `unstable_serverRoot` in Metro config.
- */
-function getMetroServerRoot(projectRoot) {
-    // Can be disabled with environment variable
-    if (process.env.TEARDOWN_NO_METRO_WORKSPACE_ROOT) {
-        return projectRoot;
-    }
-    return getWorkspaceRoot(projectRoot);
-}
-/**
- * Helper to get unique items from an array.
- */
-function uniqueItems(items) {
-    return [...new Set(items)];
-}
-/**
- * Get watch folders for Metro in a monorepo setup.
- *
- * Returns:
- * - Empty array if not in a monorepo
- * - Workspace root node_modules + all workspace package directories if in monorepo
- */
-function getWatchFolders(projectRoot) {
-    const resolvedProjectRoot = node_path_1.default.resolve(projectRoot);
-    const workspaceRoot = getMetroServerRoot(resolvedProjectRoot);
-    // Rely on default behavior in standard projects.
-    if (workspaceRoot === resolvedProjectRoot) {
-        return [];
-    }
-    const packages = resolveAllWorkspacePackageJsonPaths(workspaceRoot);
-    if (!packages?.length) {
-        return [];
-    }
-    return uniqueItems([node_path_1.default.join(workspaceRoot, "node_modules"), ...packages.map((pkg) => node_path_1.default.dirname(pkg))]);
-}
-/**
- * Get node module paths for Metro resolver.
- *
- * Returns paths in priority order:
- * 1. Project's local node_modules (always included)
- * 2. Workspace root node_modules (if in monorepo)
- *
- * The project's node_modules must always be included to support packages
- * that publish TypeScript source and need to resolve peer dependencies
- * (e.g., react-native) from deeply nested paths.
- */
-function getModulesPaths(projectRoot) {
-    const resolvedProjectRoot = node_path_1.default.resolve(projectRoot);
-    const workspaceRoot = getMetroServerRoot(resolvedProjectRoot);
-    // Always include project's node_modules for proper peer dependency resolution
-    const paths = [node_path_1.default.resolve(projectRoot, "node_modules")];
-    // Add workspace root node_modules if in a monorepo
-    if (workspaceRoot !== resolvedProjectRoot) {
-        paths.push(node_path_1.default.resolve(workspaceRoot, "node_modules"));
-    }
-    return paths;
-}
-/**
- * Get the relative project root from workspace root.
- * Used for cache key generation to prevent collisions in monorepos.
- */
-function getRelativeProjectRoot(projectRoot) {
-    const workspaceRoot = getWorkspaceRoot(projectRoot);
-    if (workspaceRoot === projectRoot) {
-        return "";
-    }
-    return node_path_1.default.relative(workspaceRoot, projectRoot);
-}