@teardown/metro-config 2.0.87 → 2.0.89

package/dist/bun.js

@@ -0,0 +1,124 @@
+"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[/\\].*/;
+/**
+ * Try to resolve a module using an existing resolver.
+ * Returns null if no resolver provided or resolution fails.
+ */
+function tryExistingResolver(existingResolver, context, moduleName, platform) {
+    if (!existingResolver) {
+        return null;
+    }
+    return existingResolver(context, moduleName, platform);
+}
+/**
+ * Find an alternative path for a module when the resolved path contains .bun.
+ * Searches through available module paths, skipping any that are in .bun directories.
+ */
+function findAlternativePathForBun(moduleName, modulesPaths) {
+    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))
+            continue;
+        const mainFile = resolvePackageMain(packagePath);
+        if (mainFile) {
+            return { type: "sourceFile", filePath: mainFile };
+        }
+    }
+    return null;
+}
+/**
+ * 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) => {
+        const result = tryExistingResolver(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/")) {
+            const alternative = findAlternativePathForBun(moduleName, modulesPaths);
+            if (alternative) {
+                return alternative;
+            }
+        }
+        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/dev-client.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTeardownDevClient = withTeardownDevClient;
+/**
+ * Get the path to the bootstrap module
+ */
+function getBootstrapModulePath(projectRoot, customPath) {
+    if (customPath) {
+        return customPath;
+    }
+    // Resolve @teardown/dev-client/bootstrap from the project
+    try {
+        return require.resolve("@teardown/dev-client/bootstrap", {
+            paths: [projectRoot],
+        });
+    }
+    catch {
+        // Fallback - the module should be resolvable at runtime
+        return "@teardown/dev-client/bootstrap";
+    }
+}
+/**
+ * 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;
+ * ```
+ */
+function withTeardownDevClient(config, options = {}) {
+    const { enabled = true, bootstrapModule, verbose = false } = options;
+    // Don't modify config if disabled
+    if (!enabled) {
+        if (verbose) {
+            console.log("[teardown/dev-client] Dev client disabled");
+        }
+        return config;
+    }
+    const projectRoot = config.projectRoot || process.cwd();
+    const bootstrapPath = getBootstrapModulePath(projectRoot, bootstrapModule);
+    if (verbose) {
+        console.log("[teardown/dev-client] Enabling dev client launcher");
+        console.log(`[teardown/dev-client] Bootstrap module: ${bootstrapPath}`);
+    }
+    // Get existing getModulesRunBeforeMainModule function
+    const existingGetModules = config.serializer?.getModulesRunBeforeMainModule;
+    return {
+        ...config,
+        serializer: {
+            ...config.serializer,
+            /**
+             * Returns modules to run before the main entry point.
+             * We prepend our bootstrap module to intercept app registration.
+             */
+            getModulesRunBeforeMainModule: (entryFilePath) => {
+                // Get any existing modules
+                const existing = existingGetModules?.(entryFilePath) ?? [];
+                // Add our bootstrap module at the beginning
+                return [bootstrapPath, ...existing];
+            },
+        },
+    };
+}

package/dist/index.js

@@ -0,0 +1,163 @@
+"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.withTeardownDevClient = 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 dev-client utilities
+var dev_client_1 = require("./dev-client");
+Object.defineProperty(exports, "withTeardownDevClient", { enumerable: true, get: function () { return dev_client_1.withTeardownDevClient; } });
+// 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

@@ -0,0 +1,294 @@
+"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;
+}
+/** File extensions to try when resolving modules */
+const FILE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".json"];
+/** Extensions to try for index files in directories */
+const INDEX_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+/**
+ * Check if a path is an existing file.
+ */
+function isExistingFile(filePath) {
+    return (0, node_fs_1.existsSync)(filePath) && (0, node_fs_1.statSync)(filePath).isFile();
+}
+/**
+ * Try to resolve a path by appending common file extensions.
+ * Returns the resolved path or null if not found.
+ */
+function tryResolveWithExtensions(basePath) {
+    for (const ext of FILE_EXTENSIONS) {
+        const fullPath = basePath + ext;
+        if (isExistingFile(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+/**
+ * Try to resolve a directory by looking for index files.
+ * Returns the resolved index path or null if not found.
+ */
+function tryResolveDirectoryIndex(dirPath) {
+    for (const ext of INDEX_EXTENSIONS) {
+        const indexPath = node_path_1.default.join(dirPath, `index${ext}`);
+        if (isExistingFile(indexPath)) {
+            return indexPath;
+        }
+    }
+    return null;
+}
+/**
+ * Try to resolve an exact path (file or directory with index).
+ * Returns the resolved path or null if not found.
+ */
+function tryResolveExactPath(resolvedPath) {
+    if (!(0, node_fs_1.existsSync)(resolvedPath)) {
+        return null;
+    }
+    const stat = (0, node_fs_1.statSync)(resolvedPath);
+    if (stat.isFile()) {
+        return resolvedPath;
+    }
+    if (stat.isDirectory()) {
+        return tryResolveDirectoryIndex(resolvedPath);
+    }
+    return null;
+}
+/**
+ * Try to resolve a single replacement path with all resolution strategies.
+ * Returns the resolved path or null if not found.
+ */
+function tryResolveReplacement(replacement, captured) {
+    const resolvedPath = replacement.replace("*", captured);
+    // Try with file extensions first
+    const withExtension = tryResolveWithExtensions(resolvedPath);
+    if (withExtension) {
+        return withExtension;
+    }
+    // Try exact path (file or directory with index)
+    return tryResolveExactPath(resolvedPath);
+}
+/**
+ * Try to resolve a module against a single path mapping.
+ * Returns the resolved path or null if no match.
+ */
+function tryResolveMapping(moduleName, mapping) {
+    const match = moduleName.match(mapping.pattern);
+    if (!match) {
+        return null;
+    }
+    const captured = match[1] || "";
+    for (const replacement of mapping.replacements) {
+        const resolved = tryResolveReplacement(replacement, captured);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a module using tsconfig paths.
+ * Returns the resolved file path or null if not matched.
+ */
+function resolveWithTsConfigPaths(moduleName, mappings) {
+    for (const mapping of mappings) {
+        const resolved = tryResolveMapping(moduleName, mapping);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    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

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

package/dist/workspace.js

@@ -0,0 +1,231 @@
+"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);
+}

package/package.json

@@ -1,13 +1,13 @@
 {
 	"name": "@teardown/metro-config",
-	"version": "2.0.87",
+	"version": "2.0.89",
 	"description": "Metro configuration for Teardown - Rust-powered transforms via Facetpack",
 	"private": false,
 	"publishConfig": {
 		"access": "public"
 	},
-	"type": "commonjs",
-	"main": "./dist/index.js",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
@@ -25,12 +25,13 @@
 		"dist/**/*"
 	],
 	"scripts": {
-		"build": "tsc",
+		"build": "rm -rf dist && tsc -p tsconfig.json",
 		"prepublishOnly": "bun run build",
 		"typecheck": "bunx tsgo --noEmit",
 		"lint": "bun x biome lint --write ./src",
 		"fmt": "bun x biome format --write ./src",
-		"check": "bun x biome check ./src"
+		"check": "bun x biome check ./src",
+		"test": "bun test"
 	},
 	"peerDependencies": {
 		"@ecrindigital/facetpack": "^0.2.0",
@@ -52,7 +53,7 @@
 	"devDependencies": {
 		"@typescript/native-preview": "^7.0.0-dev.20260203.1",
 		"@ecrindigital/facetpack": "^0.2.0",
-		"@teardown/tsconfig": "2.0.87",
+		"@teardown/tsconfig": "2.0.89",
 		"@types/bun": "1.3.8",
 		"@types/node": "24.10.1",
 		"typescript": "5.9.3"