@teardown/metro-config 2.0.44

package/dist/bun.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Bun-specific Metro configuration utilities.
+ *
+ * Handles blocking of .bun directories which can cause Metro resolution issues.
+ */
+import type { ResolveRequestFn } from "./types";
+/**
+ * Block pattern for .bun directories.
+ * Metro's blockList prevents processing of matched paths.
+ */
+export declare const BUN_BLOCK_PATTERN: RegExp;
+/**
+ * Create a custom resolver that filters out .bun paths during module resolution.
+ *
+ * Metro's blockList only prevents processing after resolution, not during.
+ * This resolver intercepts resolution and redirects away from .bun paths.
+ */
+export declare function createBunAwareResolver(projectRoot: string, defaultResolveRequest: ResolveRequestFn): ResolveRequestFn;
+/**
+ * Get blockList patterns for Metro config.
+ * Includes .bun directory blocking.
+ */
+export declare function getBlockList(existingBlockList?: RegExp | RegExp[]): RegExp[];
+//# sourceMappingURL=bun.d.ts.map

package/dist/bun.d.ts.map

@@ -0,0 +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;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,qBAAqB,EAAE,gBAAgB,GAAG,gBAAgB,CAwBrH;AAmCD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,CAQ5E"}

package/dist/bun.js

@@ -0,0 +1,91 @@
+"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.
+ *
+ * Metro's blockList only prevents processing after resolution, not during.
+ * This resolver intercepts resolution and redirects away from .bun paths.
+ */
+function createBunAwareResolver(projectRoot, defaultResolveRequest) {
+    const modulesPaths = (0, workspace_1.getModulesPaths)(projectRoot);
+    return (context, moduleName, platform) => {
+        // Use Metro's default resolution
+        const result = defaultResolveRequest(context, moduleName, platform);
+        // 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.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @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
+ */
+import { getStoredOptions } from "@ecrindigital/facetpack";
+import type { MetroConfig, TeardownMetroOptions } from "./types";
+/**
+ * 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
+ * })
+ * ```
+ */
+export declare function withTeardown(config: MetroConfig, options?: TeardownMetroOptions): MetroConfig;
+export { getStoredOptions };
+export { BUN_BLOCK_PATTERN, getBlockList } from "./bun";
+export { getMetroServerRoot, getModulesPaths, getRelativeProjectRoot, getWatchFolders, getWorkspaceRoot, isInMonorepo, } from "./workspace";
+export type { TeardownMetroOptions, MetroConfig };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,gBAAgB,EAAiB,MAAM,yBAAyB,CAAC;AAE1E,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,CAoFjG;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAG5B,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAExD,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/index.js

@@ -0,0 +1,141 @@
+"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.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 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, ...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);
+    // Create Bun-aware resolver
+    const defaultResolveRequest = config.resolver?.resolveRequest ||
+        ((context, moduleName, platform) => context.resolveRequest(context, moduleName, platform));
+    const bunAwareResolver = (0, bun_1.createBunAwareResolver)(projectRoot, defaultResolveRequest);
+    // Build enhanced config
+    const enhancedConfig = {
+        ...config,
+        projectRoot,
+        watchFolders: [...new Set([...existingWatchFolders, ...additionalWatchFolders])],
+        resolver: {
+            ...config.resolver,
+            blockList,
+            nodeModulesPaths: [...new Set([...modulesPaths, ...existingNodeModulesPaths])],
+            resolveRequest: bunAwareResolver,
+        },
+    };
+    // 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
+const 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 workspace utilities for advanced use cases
+const 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/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Type definitions for @teardown/metro-config
+ */
+import type { MetroConfig as FacetpackMetroConfig } from "@ecrindigital/facetpack";
+/**
+ * Extended Metro configuration type with proper resolver and transformer types
+ */
+export interface MetroConfig extends FacetpackMetroConfig {
+    projectRoot?: string;
+    watchFolders?: string[];
+    resolver?: {
+        blockList?: RegExp | RegExp[];
+        nodeModulesPaths?: string[];
+        resolveRequest?: ResolveRequestFn;
+        [key: string]: unknown;
+    };
+    transformer?: {
+        customTransformOptions?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Metro resolve request function type
+ */
+export type ResolveRequestFn = (context: {
+    resolveRequest: ResolveRequestFn;
+}, moduleName: string, platform: string | null) => {
+    type: string;
+    filePath: string;
+} | null;
+/**
+ * Teardown-specific Metro configuration options
+ */
+export interface TeardownMetroOptions {
+    /**
+     * Enable verbose logging for debugging
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Explicit project root path.
+     * If not provided, uses config.projectRoot or process.cwd().
+     */
+    projectRoot?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +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;CACrB"}

package/dist/types.js

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

package/dist/workspace.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 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
+ */
+/**
+ * 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
+ */
+export declare function globAllPackageJsonPaths(workspaceRoot: string, linkedPackages: string[]): string[];
+/**
+ * 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.
+ */
+export declare function resolveAllWorkspacePackageJsonPaths(workspaceRoot: string): string[];
+/**
+ * Resolve the workspace root directory.
+ * Returns the project root if not in a workspace.
+ */
+export declare function getWorkspaceRoot(projectRoot: string): string;
+/**
+ * Get workspace glob patterns from the workspace root.
+ */
+export declare function getWorkspaceGlobs(workspaceRoot: string): string[];
+/**
+ * Check if the project is in a monorepo (workspace root differs from project root).
+ */
+export declare function isInMonorepo(projectRoot: string): boolean;
+/**
+ * Get the Metro server root for monorepo support.
+ * This should be set as `unstable_serverRoot` in Metro config.
+ */
+export declare function getMetroServerRoot(projectRoot: string): string;
+/**
+ * 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
+ */
+export declare function getWatchFolders(projectRoot: string): string[];
+/**
+ * Get node module paths for Metro resolver in a monorepo setup.
+ *
+ * Returns paths in priority order:
+ * 1. Project's local node_modules
+ * 2. Workspace root node_modules (if in monorepo)
+ */
+export declare function getModulesPaths(projectRoot: string): string[];
+/**
+ * Get the relative project root from workspace root.
+ * Used for cache key generation to prevent collisions in monorepos.
+ */
+export declare function getRelativeProjectRoot(projectRoot: string): string;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../src/workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA0BH;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAWjG;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,EAAE,CAQnF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAY5D;AAiCD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBjE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAGzD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAM9D;AASD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAe7D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAa7D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAMlE"}

package/dist/workspace.js

@@ -0,0 +1,227 @@
+"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 in a monorepo setup.
+ *
+ * Returns paths in priority order:
+ * 1. Project's local node_modules
+ * 2. Workspace root node_modules (if in monorepo)
+ */
+function getModulesPaths(projectRoot) {
+    const paths = [];
+    // Only add paths if in a monorepo - minimizes chance of Metro resolver breaking
+    const resolvedProjectRoot = node_path_1.default.resolve(projectRoot);
+    const workspaceRoot = getMetroServerRoot(resolvedProjectRoot);
+    if (workspaceRoot !== resolvedProjectRoot) {
+        paths.push(node_path_1.default.resolve(projectRoot, "node_modules"));
+        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);
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "@teardown/metro-config",
+	"version": "2.0.44",
+	"description": "Metro configuration for Teardown - Rust-powered transforms via Facetpack",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"require": "./dist/index.js",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"typecheck": "bun x tsgo --noEmit --project ./tsconfig.json",
+		"build": "bun x tsgo --project ./tsconfig.json",
+		"dev": "bun x tsgo --watch --project ./tsconfig.json"
+	},
+	"peerDependencies": {
+		"@ecrindigital/facetpack": "^0.2.0",
+		"metro": "*",
+		"metro-config": "*"
+	},
+	"peerDependenciesMeta": {
+		"metro": {
+			"optional": true
+		},
+		"metro-config": {
+			"optional": true
+		}
+	},
+	"dependencies": {
+		"glob": "^10.0.0",
+		"resolve-workspace-root": "^2.0.0"
+	},
+	"devDependencies": {
+		"@teardown/tsconfig": "2.0.44",
+		"@types/bun": "1.3.5",
+		"typescript": "5.9.3"
+	},
+	"keywords": [
+		"react-native",
+		"metro",
+		"facetpack",
+		"bundler",
+		"rust",
+		"oxc"
+	]
+}

package/src/bun.ts

@@ -0,0 +1,95 @@
+/**
+ * Bun-specific Metro configuration utilities.
+ *
+ * Handles blocking of .bun directories which can cause Metro resolution issues.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import type { ResolveRequestFn } from "./types";
+import { getModulesPaths } from "./workspace";
+
+/**
+ * Block pattern for .bun directories.
+ * Metro's blockList prevents processing of matched paths.
+ */
+export const BUN_BLOCK_PATTERN = /.*[/\\]\.bun[/\\].*/;
+
+/**
+ * Create a custom resolver that filters out .bun paths during module resolution.
+ *
+ * Metro's blockList only prevents processing after resolution, not during.
+ * This resolver intercepts resolution and redirects away from .bun paths.
+ */
+export function createBunAwareResolver(projectRoot: string, defaultResolveRequest: ResolveRequestFn): ResolveRequestFn {
+	const modulesPaths = getModulesPaths(projectRoot);
+
+	return (context: { resolveRequest: ResolveRequestFn }, moduleName: string, platform: string | null) => {
+		// Use Metro's default resolution
+		const result = defaultResolveRequest(context, moduleName, platform);
+
+		// 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 = path.join(modulesPath, moduleName);
+				if (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: string): string | null {
+	const packageJsonPath = path.join(packagePath, "package.json");
+	if (existsSync(packageJsonPath)) {
+		try {
+			const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			const main = pkg.main || pkg.module || "index.js";
+			const mainPath = path.join(packagePath, main);
+
+			if (existsSync(mainPath)) {
+				return mainPath;
+			}
+			// Try with .js extension
+			const mainPathJs = mainPath + ".js";
+			if (existsSync(mainPathJs)) {
+				return mainPathJs;
+			}
+		} catch {
+			// Ignore parse errors
+		}
+	}
+
+	// Fallback to index.js
+	const indexPath = path.join(packagePath, "index.js");
+	if (existsSync(indexPath)) {
+		return indexPath;
+	}
+
+	return null;
+}
+
+/**
+ * Get blockList patterns for Metro config.
+ * Includes .bun directory blocking.
+ */
+export function getBlockList(existingBlockList?: RegExp | RegExp[]): RegExp[] {
+	const blockListArray = Array.isArray(existingBlockList)
+		? existingBlockList
+		: existingBlockList
+			? [existingBlockList]
+			: [];
+
+	return [...blockListArray, BUN_BLOCK_PATTERN];
+}

package/src/index.ts

@@ -0,0 +1,169 @@
+/**
+ * @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
+ */
+
+import { getStoredOptions, withFacetpack } from "@ecrindigital/facetpack";
+import { createBunAwareResolver, getBlockList } from "./bun";
+import type { MetroConfig, ResolveRequestFn, TeardownMetroOptions } from "./types";
+import {
+	getMetroServerRoot,
+	getModulesPaths,
+	getRelativeProjectRoot,
+	getWatchFolders,
+	getWorkspaceRoot,
+	isInMonorepo,
+} from "./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
+ * })
+ * ```
+ */
+export function withTeardown(config: MetroConfig, options: TeardownMetroOptions = {}): MetroConfig {
+	const { verbose, projectRoot: explicitProjectRoot, ...facetpackOptions } = options;
+
+	// Determine project root
+	const projectRoot = explicitProjectRoot || (config.projectRoot as string | undefined) || 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 = isInMonorepo(projectRoot);
+	if (verbose && inMonorepo) {
+		const workspaceRoot = getWorkspaceRoot(projectRoot);
+		console.log(`[teardown/metro-config] Monorepo detected: ${workspaceRoot}`);
+	}
+
+	// Get monorepo-aware watch folders
+	const additionalWatchFolders = getWatchFolders(projectRoot);
+	const existingWatchFolders = (config.watchFolders as string[] | undefined) || [];
+
+	// Get monorepo-aware node modules paths
+	const modulesPaths = getModulesPaths(projectRoot);
+	const existingNodeModulesPaths = (config.resolver?.nodeModulesPaths as string[] | undefined) || [];
+
+	// Get block list with .bun blocking
+	const blockList = getBlockList(config.resolver?.blockList as RegExp | RegExp[] | undefined);
+
+	// Create Bun-aware resolver
+	const defaultResolveRequest: ResolveRequestFn =
+		(config.resolver?.resolveRequest as ResolveRequestFn | undefined) ||
+		((context, moduleName, platform) => context.resolveRequest(context, moduleName, platform));
+
+	const bunAwareResolver = createBunAwareResolver(projectRoot, defaultResolveRequest);
+
+	// Build enhanced config
+	const enhancedConfig: MetroConfig = {
+		...config,
+		projectRoot,
+		watchFolders: [...new Set([...existingWatchFolders, ...additionalWatchFolders])],
+		resolver: {
+			...config.resolver,
+			blockList,
+			nodeModulesPaths: [...new Set([...modulesPaths, ...existingNodeModulesPaths])],
+			resolveRequest: bunAwareResolver,
+		},
+	};
+
+	// Set unstable_serverRoot for monorepo web support
+	if (inMonorepo) {
+		const serverRoot = getMetroServerRoot(projectRoot);
+		(enhancedConfig as Record<string, unknown>).unstable_serverRoot = serverRoot;
+
+		// Add relative project root to transformer cache key for cache collision prevention
+		const relativeRoot = getRelativeProjectRoot(projectRoot);
+		if (relativeRoot) {
+			const existingCacheKey =
+				(config.transformer as Record<string, unknown> | undefined)?.customTransformOptions || {};
+			enhancedConfig.transformer = {
+				...config.transformer,
+				customTransformOptions: {
+					...(existingCacheKey as Record<string, unknown>),
+					_teardownRelativeProjectRoot: relativeRoot,
+				},
+			};
+		}
+	}
+
+	if (verbose) {
+		const watchFoldersCount = (enhancedConfig.watchFolders as string[] | undefined)?.length || 0;
+		const nodeModulesPathsCount = (enhancedConfig.resolver?.nodeModulesPaths as string[] | undefined)?.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 = withFacetpack(enhancedConfig, facetpackOptions);
+
+	if (verbose) {
+		console.log("[teardown/metro-config] Metro config enhanced successfully");
+	}
+
+	return finalConfig;
+}
+
+// Re-export useful utilities from Facetpack
+export { getStoredOptions };
+
+// Re-export Bun utilities
+export { BUN_BLOCK_PATTERN, getBlockList } from "./bun";
+// Re-export workspace utilities for advanced use cases
+export {
+	getMetroServerRoot,
+	getModulesPaths,
+	getRelativeProjectRoot,
+	getWatchFolders,
+	getWorkspaceRoot,
+	isInMonorepo,
+} from "./workspace";
+
+// Re-export types
+export type { TeardownMetroOptions, MetroConfig };

package/src/types.ts

@@ -0,0 +1,50 @@
+/**
+ * Type definitions for @teardown/metro-config
+ */
+
+import type { MetroConfig as FacetpackMetroConfig } from "@ecrindigital/facetpack";
+
+/**
+ * Extended Metro configuration type with proper resolver and transformer types
+ */
+export interface MetroConfig extends FacetpackMetroConfig {
+	projectRoot?: string;
+	watchFolders?: string[];
+	resolver?: {
+		blockList?: RegExp | RegExp[];
+		nodeModulesPaths?: string[];
+		resolveRequest?: ResolveRequestFn;
+		[key: string]: unknown;
+	};
+	transformer?: {
+		customTransformOptions?: Record<string, unknown>;
+		[key: string]: unknown;
+	};
+	[key: string]: unknown;
+}
+
+/**
+ * Metro resolve request function type
+ */
+export type ResolveRequestFn = (
+	context: { resolveRequest: ResolveRequestFn },
+	moduleName: string,
+	platform: string | null
+) => { type: string; filePath: string } | null;
+
+/**
+ * Teardown-specific Metro configuration options
+ */
+export interface TeardownMetroOptions {
+	/**
+	 * Enable verbose logging for debugging
+	 * @default false
+	 */
+	verbose?: boolean;
+
+	/**
+	 * Explicit project root path.
+	 * If not provided, uses config.projectRoot or process.cwd().
+	 */
+	projectRoot?: string;
+}

package/src/workspace.ts

@@ -0,0 +1,233 @@
+/**
+ * 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
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { globSync } from "glob";
+
+/**
+ * Read and parse a JSON file, returning null if invalid.
+ */
+function readJsonFile(filePath: string): unknown {
+	const file = readFileSync(filePath, "utf8");
+	return JSON.parse(file);
+}
+
+/**
+ * Check if a file is a valid JSON file.
+ */
+function isValidJsonFile(filePath: string): boolean {
+	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
+ */
+export function globAllPackageJsonPaths(workspaceRoot: string, linkedPackages: string[]): string[] {
+	return linkedPackages
+		.flatMap((pattern) => {
+			// Globs should only contain `/` as separator, even on Windows.
+			return globSync(path.posix.join(pattern, "package.json").replace(/\\/g, "/"), {
+				cwd: workspaceRoot,
+				absolute: true,
+				ignore: ["**/@(Carthage|Pods|node_modules)/**"],
+			}).filter((pkgPath) => isValidJsonFile(pkgPath));
+		})
+		.map((p) => path.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.
+ */
+export function resolveAllWorkspacePackageJsonPaths(workspaceRoot: string): string[] {
+	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.
+ */
+export function getWorkspaceRoot(projectRoot: string): string {
+	try {
+		// Dynamic import to handle the package
+		const { resolveWorkspaceRoot } = require("resolve-workspace-root") as {
+			resolveWorkspaceRoot: (cwd: string) => string | null;
+		};
+		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: string): string {
+	let current = startDir;
+	while (current !== path.dirname(current)) {
+		const turboConfig = path.join(current, "turbo.jsonc");
+		const turboJson = path.join(current, "turbo.json");
+		const packageJson = path.join(current, "package.json");
+
+		if (existsSync(turboConfig) || existsSync(turboJson)) {
+			return current;
+		}
+
+		if (existsSync(packageJson)) {
+			try {
+				const pkg = JSON.parse(readFileSync(packageJson, "utf8"));
+				if (pkg.workspaces) {
+					return current;
+				}
+			} catch {
+				// Ignore parse errors
+			}
+		}
+
+		current = path.dirname(current);
+	}
+	return startDir;
+}
+
+/**
+ * Get workspace glob patterns from the workspace root.
+ */
+export function getWorkspaceGlobs(workspaceRoot: string): string[] {
+	try {
+		const { getWorkspaceGlobs: getGlobs } = require("resolve-workspace-root") as {
+			getWorkspaceGlobs: (cwd: string) => string[] | null;
+		};
+		return getGlobs(workspaceRoot) ?? [];
+	} catch {
+		// Fallback: try to read from package.json
+		const packageJsonPath = path.join(workspaceRoot, "package.json");
+		if (existsSync(packageJsonPath)) {
+			try {
+				const pkg = JSON.parse(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).
+ */
+export function isInMonorepo(projectRoot: string): boolean {
+	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.
+ */
+export function getMetroServerRoot(projectRoot: string): string {
+	// 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: string[]): string[] {
+	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
+ */
+export function getWatchFolders(projectRoot: string): string[] {
+	const resolvedProjectRoot = path.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([path.join(workspaceRoot, "node_modules"), ...packages.map((pkg) => path.dirname(pkg))]);
+}
+
+/**
+ * Get node module paths for Metro resolver in a monorepo setup.
+ *
+ * Returns paths in priority order:
+ * 1. Project's local node_modules
+ * 2. Workspace root node_modules (if in monorepo)
+ */
+export function getModulesPaths(projectRoot: string): string[] {
+	const paths: string[] = [];
+
+	// Only add paths if in a monorepo - minimizes chance of Metro resolver breaking
+	const resolvedProjectRoot = path.resolve(projectRoot);
+	const workspaceRoot = getMetroServerRoot(resolvedProjectRoot);
+
+	if (workspaceRoot !== resolvedProjectRoot) {
+		paths.push(path.resolve(projectRoot, "node_modules"));
+		paths.push(path.resolve(workspaceRoot, "node_modules"));
+	}
+
+	return paths;
+}
+
+/**
+ * Get the relative project root from workspace root.
+ * Used for cache key generation to prevent collisions in monorepos.
+ */
+export function getRelativeProjectRoot(projectRoot: string): string {
+	const workspaceRoot = getWorkspaceRoot(projectRoot);
+	if (workspaceRoot === projectRoot) {
+		return "";
+	}
+	return path.relative(workspaceRoot, projectRoot);
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+	"extends": "@teardown/tsconfig/tsconfig.bun.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"module": "CommonJS",
+		"moduleResolution": "node",
+		"esModuleInterop": true,
+		"declaration": true,
+		"declarationMap": true,
+		"emitDeclarationOnly": false,
+		"allowImportingTsExtensions": false,
+		"verbatimModuleSyntax": false
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}