@granite-js/vitest 1.0.21 → 1.0.23

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.0.23
+
+### Patch Changes
+
+- faf7ec4: feat: change react-native package tree to object + virtual
+
+## 1.0.22
+
+### Patch Changes
+
+- 3553158: feat(vitest): fast-flow-transform -> flow-remove-types
+
 ## 1.0.21
 
 ### Patch Changes

package/README.md

@@ -21,31 +21,37 @@ export default defineConfig({
 });
 ```
 
-`reactNative()` injects the React Native mirror aliases, the Vitest `node` environment, `globals: true`, Jest-like test globs, the packaged React Native runtime/setup files, and Jest-preset-style asset mocks.
+`reactNative()` injects the React Native manifest resolver, the Vitest `node` environment, `globals: true`, Jest-like test globs, the packaged React Native runtime/setup files, and Jest-preset-style asset mocks.
 
-## Mirror Cache
+## Transform Cache
 
-The React Native mirror is stored as a content-addressed local cache:
+React Native sources are stored as a content-addressed flat transform cache:
 
 - cache root: `<cacheDir>/vitest-react-native-cache`
-- entries: `<cacheDir>/vitest-react-native-cache/entries/<cache-key>/packages`
+- transformed objects: `<cacheDir>/vitest-react-native-cache/entries/<cache-key>/objects/<content-hash>.<ext>`
+- manifest: `<cacheDir>/vitest-react-native-cache/entries/<cache-key>/manifest.json`
 - metadata: `<cacheDir>/vitest-react-native-cache/entries/<cache-key>/meta.json`
 
 By default, `cacheDir` is Vitest's `.vitest` directory unless your `vitest.config.*` overrides it.
 
 The cache key is derived from:
 
-- the mirrored `react-native` and installed RN-family allowlist package contents
+- the `react-native` and installed RN-family allowlist package contents
 - the local mirror/transform implementation
 - transform dependency versions
 
-If the cache key matches, `reactNative()` reuses the existing mirror immediately instead of rebuilding it.
+If the cache key matches, `reactNative()` reuses the existing transform cache immediately instead of rebuilding it.
+Only one completed React Native transform cache entry is retained per cache directory. When the cache key changes,
+the previous entry is removed before the new cache is transformed and materialized.
 
-Local garbage collection runs opportunistically while resolving the mirror cache:
+The cache intentionally does not materialize package trees such as `packages/react-native/package.json`.
+React Native package and relative imports are resolved through `manifest.json` and then redirected to flat
+object files, so file scanners do not discover duplicate package boundaries inside the cache.
+
+Local garbage collection runs opportunistically while resolving the transform cache:
 
-- stale entries older than 7 days are removed
 - temporary entries left behind by interrupted builds are removed
-- the cache is trimmed back to roughly 1 GB using least-recently-used eviction
+- inactive completed entries are removed
 
 ## React Native Jest Preset Parity
 

package/dist/index.d.ts

@@ -7,11 +7,43 @@ declare const REACT_NATIVE_ASSET_EXTENSIONS: readonly ["bmp", "gif", "jpg", "jpe
 declare const DEFAULT_PLATFORM = "ios";
 declare const GRANITE_VITEST_RN_CACHE_DIRECTORY = "vitest-react-native-cache";
 declare const GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY = "entries";
+declare const GRANITE_VITEST_RN_OBJECTS_DIRECTORY = "objects";
+declare const GRANITE_VITEST_RN_MANIFEST_FILENAME = "manifest.json";
 declare const GRANITE_VITEST_RN_PACKAGES_DIRECTORY = "packages";
 declare const REACT_NATIVE_PLATFORMS: readonly ["android", "ios", "native"];
+type ReactNativePackageEntry = {
+  packageName: string;
+  packageRoot: string;
+  requireRoot: string;
+};
+type ReactNativeTransformCacheManifest = {
+  cacheKey: string;
+  createdAt: string;
+  lastAccessedAt: string;
+  objectsRoot: string;
+  packageRoots: string[];
+  packages: ReactNativePackageEntry[];
+  sourceToObject: Record<string, string>;
+  objectToSource: Record<string, string>;
+  transformDependencyVersions: {
+    flowRemoveTypes: string;
+  };
+  transformImplementationHash: string;
+};
+type ReactNativeTransformCache = {
+  entryRoot: string;
+  manifest: ReactNativeTransformCacheManifest;
+  manifestPath: string;
+  objectsRoot: string;
+};
+type ReactNativeResolvedModule = {
+  objectPath: string;
+  sourcePath: string;
+};
 declare function resolvePackageRoot(packageName: string, requireRoot: string): string;
 declare function resolveReactNativePackageRoots(workspaceRoot: string): string[];
-declare function synthesizeDefaultPlatformFiles(destinationRoot: string): void;
+declare function resolveReactNativeModuleFromManifest(request: string, importer: string | undefined, manifest: ReactNativeTransformCacheManifest): ReactNativeResolvedModule | null;
+declare function buildReactNativeTransformCache(workspaceRoot: string, resolvedCacheDir?: string): Promise<ReactNativeTransformCache>;
 declare function buildReactNativeMirror(workspaceRoot: string, resolvedCacheDir?: string): Promise<string>;
 //#endregion
 //#region src/transpile.d.ts
@@ -33,4 +65,4 @@ declare const _default: {
   resolveReactNativeSetupFiles: typeof resolveReactNativeSetupFiles;
 };
 //#endregion
-export { DEFAULT_PLATFORM, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY, GRANITE_VITEST_RN_PACKAGES_DIRECTORY, JEST_LIKE_TEST_PATTERNS, REACT_NATIVE_ASSET_EXTENSIONS, REACT_NATIVE_EXPORT_CONDITIONS, REACT_NATIVE_PLATFORMS, REACT_NATIVE_RESOLVE_EXTENSIONS, REACT_NATIVE_TRANSFORM_ALLOWLIST, REACT_NATIVE_TRANSFORM_EXTENSIONS, buildReactNativeMirror, _default as default, reactNative, resolvePackageRoot, resolveReactNativePackageRoots, resolveReactNativeSetupFiles, shouldInlineReactNativeDependency, shouldTransformReactNativeFile, synthesizeDefaultPlatformFiles };
+export { DEFAULT_PLATFORM, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY, GRANITE_VITEST_RN_MANIFEST_FILENAME, GRANITE_VITEST_RN_OBJECTS_DIRECTORY, GRANITE_VITEST_RN_PACKAGES_DIRECTORY, JEST_LIKE_TEST_PATTERNS, REACT_NATIVE_ASSET_EXTENSIONS, REACT_NATIVE_EXPORT_CONDITIONS, REACT_NATIVE_PLATFORMS, REACT_NATIVE_RESOLVE_EXTENSIONS, REACT_NATIVE_TRANSFORM_ALLOWLIST, REACT_NATIVE_TRANSFORM_EXTENSIONS, buildReactNativeMirror, buildReactNativeTransformCache, _default as default, reactNative, resolvePackageRoot, resolveReactNativeModuleFromManifest, resolveReactNativePackageRoots, resolveReactNativeSetupFiles, shouldInlineReactNativeDependency, shouldTransformReactNativeFile };

package/dist/index.js

@@ -1,401 +1,9 @@
-import { n as REACT_NATIVE_ASSET_MODULE_ID_PATTERN, t as REACT_NATIVE_ASSET_EXTENSIONS } from "./assets-DoucBOz0.js";
-import { createRequire } from "node:module";
+import { _ as shouldTransformReactNativeFile, a as GRANITE_VITEST_RN_OBJECTS_DIRECTORY, c as buildReactNativeMirror, d as resolvePackageRoot, f as resolveReactNativeModuleFromManifest, g as shouldInlineReactNativeDependency, h as REACT_NATIVE_TRANSFORM_EXTENSIONS, i as GRANITE_VITEST_RN_MANIFEST_FILENAME, l as buildReactNativeTransformCache, m as REACT_NATIVE_TRANSFORM_ALLOWLIST, n as GRANITE_VITEST_RN_CACHE_DIRECTORY, o as GRANITE_VITEST_RN_PACKAGES_DIRECTORY, p as resolveReactNativePackageRoots, r as GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY, s as REACT_NATIVE_PLATFORMS, t as DEFAULT_PLATFORM, v as REACT_NATIVE_ASSET_EXTENSIONS, y as REACT_NATIVE_ASSET_MODULE_ID_PATTERN } from "./mirror-e92G5HdG.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as vite from "vitest/node";
-import { createHash } from "node:crypto";
-import transform from "fast-flow-transform";
 
-//#region src/transpile.ts
-const REACT_NATIVE_TRANSFORM_EXTENSIONS = [
-	".js",
-	".jsx",
-	".ts",
-	".tsx"
-];
-const REACT_NATIVE_TRANSFORM_ALLOWLIST = [
-	"react-native",
-	"jest-react-native",
-	"@react-native",
-	"@react-native-community"
-];
-function normalizePath(filename) {
-	return filename.replace(/\\/g, "/");
-}
-function isWithinPackageRoots(filename, packageRoots) {
-	const normalizedFilename = normalizePath(path.resolve(filename));
-	return packageRoots.some((packageRoot) => {
-		const normalizedPackageRoot = normalizePath(path.resolve(packageRoot));
-		return normalizedFilename === normalizedPackageRoot || normalizedFilename.startsWith(`${normalizedPackageRoot}/`);
-	});
-}
-function shouldTransformReactNativeFile(filename, packageRoots = []) {
-	const normalized = normalizePath(filename);
-	const isReactNativeSource = packageRoots.length > 0 ? isWithinPackageRoots(normalized, packageRoots) : normalized.includes("/react-native/") || normalized.includes("/@react-native/");
-	return /\.(?:js|jsx|ts|tsx)$/.test(normalized) && !normalized.includes("/Renderer/implementations/") && isReactNativeSource;
-}
-function shouldInlineReactNativeDependency(filename, packageRoots = []) {
-	const normalized = normalizePath(filename);
-	if (packageRoots.length > 0) return isWithinPackageRoots(normalized, packageRoots);
-	return REACT_NATIVE_TRANSFORM_ALLOWLIST.some((allowlistEntry) => normalized.includes(`/${allowlistEntry}/`));
-}
-async function transformReactNativeSource(sourcePath, source) {
-	return (await transform({
-		filename: sourcePath,
-		source,
-		dialect: "flow-detect",
-		format: "compact",
-		comments: false,
-		reactRuntimeTarget: "19",
-		sourcemap: false
-	})).code;
-}
-
-//#endregion
-//#region src/mirror.ts
-const DEFAULT_PLATFORM = "ios";
-const GRANITE_VITEST_RN_CACHE_DIRECTORY = "vitest-react-native-cache";
-const GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY = "entries";
-const GRANITE_VITEST_RN_PACKAGES_DIRECTORY = "packages";
-const REACT_NATIVE_PLATFORMS = [
-	"android",
-	"ios",
-	"native"
-];
-const GRANITE_VITEST_RN_CACHE_GC_LOCK_FILENAME = ".gc.lock";
-const GRANITE_VITEST_RN_CACHE_METADATA_FILENAME = "meta.json";
-const GRANITE_VITEST_RN_CACHE_TMP_PREFIX = ".tmp-";
-const GRANITE_VITEST_RN_CACHE_MAX_AGE_MS = 10080 * 60 * 1e3;
-const GRANITE_VITEST_RN_CACHE_MAX_SIZE_BYTES = 1024 * 1024 * 1024;
-const GRANITE_VITEST_RN_TEMP_ENTRY_MAX_AGE_MS = 3600 * 1e3;
-const DEFAULT_VITEST_CACHE_DIRECTORY = ".vitest";
-const MIRROR_CACHE_KEY_VERSION = "v1";
-const currentMirrorModulePath = fs.realpathSync(fileURLToPath(import.meta.url));
-const currentMirrorModuleDirectory = path.dirname(currentMirrorModulePath);
-function getFastFlowTransformVersion() {
-	const fastFlowTransformEntryPath = createRequire(import.meta.url).resolve("fast-flow-transform");
-	const fastFlowTransformPackageRoot = path.dirname(path.dirname(fastFlowTransformEntryPath));
-	const fastFlowTransformPackageJsonPath = path.join(fastFlowTransformPackageRoot, "package.json");
-	return JSON.parse(fs.readFileSync(fastFlowTransformPackageJsonPath, "utf8")).version ?? "unknown";
-}
-function getPackageManifestDependencyNames(packageManifest) {
-	return Object.keys({
-		...packageManifest.dependencies ?? {},
-		...packageManifest.devDependencies ?? {},
-		...packageManifest.optionalDependencies ?? {},
-		...packageManifest.peerDependencies ?? {}
-	}).sort();
-}
-function shouldMirrorReactNativeDependency(packageName) {
-	return packageName === "jest-react-native" || packageName.startsWith("@react-native/") || packageName.startsWith("@react-native-community/");
-}
-function hashDirectoryContents(hasher, rootPath, currentPath = rootPath) {
-	const entries = fs.readdirSync(currentPath, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
-	for (const entry of entries) {
-		const entryPath = path.join(currentPath, entry.name);
-		if (entry.isDirectory()) {
-			hashDirectoryContents(hasher, rootPath, entryPath);
-			continue;
-		}
-		if (!entry.isFile()) continue;
-		hasher.update(path.relative(rootPath, entryPath));
-		hasher.update("\0");
-		hasher.update(fs.readFileSync(entryPath));
-		hasher.update("\0");
-	}
-}
-function hashImplementationFiles() {
-	const hasher = createHash("sha256");
-	const extension = path.extname(currentMirrorModulePath);
-	const implementationFiles = [currentMirrorModulePath, path.join(currentMirrorModuleDirectory, `transpile${extension}`)].filter((implementationFile, index, allFiles) => {
-		if (!fs.existsSync(implementationFile)) return false;
-		return allFiles.indexOf(implementationFile) === index;
-	}).sort();
-	for (const implementationFile of implementationFiles) {
-		hasher.update(path.basename(implementationFile));
-		hasher.update("\0");
-		hasher.update(fs.readFileSync(implementationFile));
-		hasher.update("\0");
-	}
-	return hasher.digest("hex");
-}
-function collectMirroredReactNativePackageNames(workspacePackageManifest, reactNativePackageManifest) {
-	const packageNames = /* @__PURE__ */ new Set();
-	for (const dependencyName of Object.keys(reactNativePackageManifest.dependencies ?? {})) if (dependencyName.startsWith("@react-native/")) packageNames.add(dependencyName);
-	for (const dependencyName of getPackageManifestDependencyNames(workspacePackageManifest)) if (dependencyName !== "react-native" && shouldMirrorReactNativeDependency(dependencyName)) packageNames.add(dependencyName);
-	return [...packageNames].sort();
-}
-function getMirroredReactNativePackages(workspaceRoot) {
-	const reactNativeRoot = resolvePackageRoot("react-native", workspaceRoot);
-	const workspacePackageManifest = JSON.parse(fs.readFileSync(path.join(workspaceRoot, "package.json"), "utf8"));
-	const reactNativePackageManifest = JSON.parse(fs.readFileSync(path.join(reactNativeRoot, "package.json"), "utf8"));
-	const workspaceDependencyNames = new Set(getPackageManifestDependencyNames(workspacePackageManifest));
-	return collectMirroredReactNativePackageNames(workspacePackageManifest, reactNativePackageManifest).map((packageName) => ({
-		packageName,
-		requireRoot: workspaceDependencyNames.has(packageName) ? workspaceRoot : reactNativeRoot
-	}));
-}
-function computeReactNativeMirrorCacheKey(workspaceRoot) {
-	const hasher = createHash("sha256");
-	const packageRoots = resolveReactNativePackageRoots(workspaceRoot).sort();
-	const transformImplementationHash = hashImplementationFiles();
-	const transformDependencyVersions = { fastFlowTransform: getFastFlowTransformVersion() };
-	hasher.update(`granite-vitest-rn-cache:${MIRROR_CACHE_KEY_VERSION}`);
-	hasher.update("\0");
-	hasher.update(`fast-flow-transform:${transformDependencyVersions.fastFlowTransform}`);
-	hasher.update("\0");
-	hasher.update(`transform:${transformImplementationHash}`);
-	hasher.update("\0");
-	for (const packageRoot of packageRoots) {
-		hasher.update(path.basename(packageRoot));
-		hasher.update("\0");
-		hashDirectoryContents(hasher, packageRoot);
-	}
-	return {
-		cacheKey: hasher.digest("hex"),
-		packageRoots,
-		transformDependencyVersions,
-		transformImplementationHash
-	};
-}
-function getDirectorySize(targetPath) {
-	const stat = fs.statSync(targetPath);
-	if (stat.isFile()) return stat.size;
-	if (!stat.isDirectory()) return 0;
-	return fs.readdirSync(targetPath, { withFileTypes: true }).reduce((totalSize, entry) => {
-		const entryPath = path.join(targetPath, entry.name);
-		if (entry.isDirectory() || entry.isFile()) return totalSize + getDirectorySize(entryPath);
-		return totalSize;
-	}, 0);
-}
-function readMirrorCacheMetadata(entryRoot) {
-	const metadataPath = path.join(entryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
-	if (!fs.existsSync(metadataPath)) return null;
-	try {
-		return JSON.parse(fs.readFileSync(metadataPath, "utf8"));
-	} catch {
-		return null;
-	}
-}
-function withMirrorCacheGcLock(workspaceRoot, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY), callback) {
-	const cacheRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY);
-	const lockPath = path.join(cacheRoot, GRANITE_VITEST_RN_CACHE_GC_LOCK_FILENAME);
-	fs.mkdirSync(cacheRoot, { recursive: true });
-	let lockHandle = null;
-	try {
-		lockHandle = fs.openSync(lockPath, "wx");
-	} catch (error) {
-		if (error.code === "EEXIST") return;
-		throw error;
-	}
-	try {
-		callback();
-	} finally {
-		if (lockHandle != null) {
-			fs.closeSync(lockHandle);
-			fs.rmSync(lockPath, {
-				force: true,
-				recursive: true
-			});
-		}
-	}
-}
-function gcReactNativeMirrorCache(workspaceRoot, activeCacheKey, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY)) {
-	withMirrorCacheGcLock(workspaceRoot, resolvedCacheDir, () => {
-		const entriesRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY);
-		if (!fs.existsSync(entriesRoot)) return;
-		const now = Date.now();
-		const retainedEntries = [];
-		for (const entry of fs.readdirSync(entriesRoot, { withFileTypes: true })) {
-			if (!entry.isDirectory()) continue;
-			const entryRoot = path.join(entriesRoot, entry.name);
-			if (entry.name.startsWith(GRANITE_VITEST_RN_CACHE_TMP_PREFIX)) {
-				if (now - fs.statSync(entryRoot).mtimeMs > GRANITE_VITEST_RN_TEMP_ENTRY_MAX_AGE_MS) fs.rmSync(entryRoot, {
-					force: true,
-					recursive: true
-				});
-				continue;
-			}
-			if (entry.name === activeCacheKey) {
-				const activeMetadata = readMirrorCacheMetadata(entryRoot);
-				retainedEntries.push({
-					cacheKey: entry.name,
-					entryRoot,
-					lastAccessedAtMs: activeMetadata == null ? now : Date.parse(activeMetadata.lastAccessedAt),
-					sizeBytes: activeMetadata?.sizeBytes ?? getDirectorySize(path.join(entryRoot, GRANITE_VITEST_RN_PACKAGES_DIRECTORY))
-				});
-				continue;
-			}
-			const metadata = readMirrorCacheMetadata(entryRoot);
-			const packagesRoot = path.join(entryRoot, GRANITE_VITEST_RN_PACKAGES_DIRECTORY);
-			if (metadata == null || !fs.existsSync(packagesRoot)) {
-				fs.rmSync(entryRoot, {
-					force: true,
-					recursive: true
-				});
-				continue;
-			}
-			const lastAccessedAtMs = Date.parse(metadata.lastAccessedAt);
-			if (Number.isNaN(lastAccessedAtMs) || now - lastAccessedAtMs > GRANITE_VITEST_RN_CACHE_MAX_AGE_MS) {
-				fs.rmSync(entryRoot, {
-					force: true,
-					recursive: true
-				});
-				continue;
-			}
-			retainedEntries.push({
-				cacheKey: entry.name,
-				entryRoot,
-				lastAccessedAtMs,
-				sizeBytes: metadata.sizeBytes
-			});
-		}
-		let totalSizeBytes = retainedEntries.reduce((totalSize, entry) => totalSize + entry.sizeBytes, 0);
-		for (const entry of retainedEntries.filter((cacheEntry) => cacheEntry.cacheKey !== activeCacheKey).sort((left, right) => left.lastAccessedAtMs - right.lastAccessedAtMs)) {
-			if (totalSizeBytes <= GRANITE_VITEST_RN_CACHE_MAX_SIZE_BYTES) break;
-			fs.rmSync(entry.entryRoot, {
-				force: true,
-				recursive: true
-			});
-			totalSizeBytes -= entry.sizeBytes;
-		}
-	});
-}
-function resolvePackageRoot(packageName, requireRoot) {
-	const packageJsonPath = createRequire(path.join(requireRoot, "package.json")).resolve(`${packageName}/package.json`);
-	return path.dirname(packageJsonPath);
-}
-function resolveReactNativePackageRoots(workspaceRoot) {
-	return [resolvePackageRoot("react-native", workspaceRoot), ...getMirroredReactNativePackages(workspaceRoot).map(({ packageName, requireRoot }) => resolvePackageRoot(packageName, requireRoot))];
-}
-async function mirrorFile(sourcePath, destinationPath, packageRoots) {
-	fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
-	if (shouldTransformReactNativeFile(sourcePath, packageRoots)) {
-		const source = fs.readFileSync(sourcePath, "utf8");
-		try {
-			const transformed = await transformReactNativeSource(sourcePath, source);
-			fs.writeFileSync(destinationPath, transformed);
-			return;
-		} catch {
-			fs.writeFileSync(destinationPath, source);
-			return;
-		}
-	}
-	fs.copyFileSync(sourcePath, destinationPath);
-}
-async function mirrorTree(sourceRoot, destinationRoot, packageRoots) {
-	const entries = fs.readdirSync(sourceRoot, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
-	for (const entry of entries) {
-		const sourcePath = path.join(sourceRoot, entry.name);
-		const destinationPath = path.join(destinationRoot, entry.name);
-		if (entry.isDirectory()) {
-			await mirrorTree(sourcePath, destinationPath, packageRoots);
-			continue;
-		}
-		if (!entry.isFile()) continue;
-		await mirrorFile(sourcePath, destinationPath, packageRoots);
-	}
-}
-function synthesizeDefaultPlatformFiles(destinationRoot) {
-	const platformFallbackOrder = [
-		DEFAULT_PLATFORM,
-		"native",
-		...REACT_NATIVE_PLATFORMS.filter((platform) => platform !== DEFAULT_PLATFORM && platform !== "native")
-	];
-	const platformPriority = new Map(platformFallbackOrder.map((platform, index) => [platform, index]));
-	const fallbackCandidates = [];
-	function collectCandidates(currentRoot) {
-		const entries = fs.readdirSync(currentRoot, { withFileTypes: true });
-		for (const entry of entries) {
-			const entryPath = path.join(currentRoot, entry.name);
-			if (entry.isDirectory()) {
-				collectCandidates(entryPath);
-				continue;
-			}
-			const match = entry.name.match(new RegExp(`^(.*)\\.(${REACT_NATIVE_PLATFORMS.join("|")})\\.(js|jsx|ts|tsx)$`));
-			if (match == null) continue;
-			const [, basename, platform, extension] = match;
-			if (basename == null || platform == null || extension == null) continue;
-			fallbackCandidates.push({
-				sourcePath: entryPath,
-				fallbackPath: path.join(currentRoot, `${basename}.${extension}`),
-				priority: platformPriority.get(platform) ?? platformFallbackOrder.length
-			});
-		}
-	}
-	collectCandidates(destinationRoot);
-	fallbackCandidates.sort((left, right) => left.priority - right.priority).forEach(({ sourcePath, fallbackPath }) => {
-		if (!fs.existsSync(fallbackPath)) fs.copyFileSync(sourcePath, fallbackPath);
-	});
-}
-async function buildReactNativeMirror(workspaceRoot, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY)) {
-	const cacheEntry = computeReactNativeMirrorCacheKey(workspaceRoot);
-	const entriesRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY);
-	const entryRoot = path.join(entriesRoot, cacheEntry.cacheKey);
-	const packagesRoot = path.join(entryRoot, GRANITE_VITEST_RN_PACKAGES_DIRECTORY);
-	const metadataPath = path.join(entryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
-	fs.mkdirSync(entriesRoot, { recursive: true });
-	if (fs.existsSync(entryRoot) && (!fs.existsSync(packagesRoot) || !fs.existsSync(metadataPath))) fs.rmSync(entryRoot, {
-		force: true,
-		recursive: true
-	});
-	if (fs.existsSync(packagesRoot) && fs.existsSync(metadataPath)) {
-		const metadata = readMirrorCacheMetadata(entryRoot);
-		if (metadata != null) {
-			metadata.lastAccessedAt = (/* @__PURE__ */ new Date()).toISOString();
-			fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
-		}
-		gcReactNativeMirrorCache(workspaceRoot, cacheEntry.cacheKey, resolvedCacheDir);
-		return packagesRoot;
-	}
-	const temporaryEntryRoot = path.join(entriesRoot, `${GRANITE_VITEST_RN_CACHE_TMP_PREFIX}${process.pid}-${Date.now()}-${cacheEntry.cacheKey}`);
-	const temporaryPackagesRoot = path.join(temporaryEntryRoot, GRANITE_VITEST_RN_PACKAGES_DIRECTORY);
-	const temporaryMetadataPath = path.join(temporaryEntryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
-	fs.rmSync(temporaryEntryRoot, {
-		force: true,
-		recursive: true
-	});
-	fs.mkdirSync(temporaryPackagesRoot, { recursive: true });
-	try {
-		await mirrorTree(resolvePackageRoot("react-native", workspaceRoot), path.join(temporaryPackagesRoot, "react-native"), cacheEntry.packageRoots);
-		for (const { packageName, requireRoot } of getMirroredReactNativePackages(workspaceRoot)) await mirrorTree(resolvePackageRoot(packageName, requireRoot), path.join(temporaryPackagesRoot, ...packageName.split("/")), cacheEntry.packageRoots);
-		synthesizeDefaultPlatformFiles(temporaryPackagesRoot);
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		fs.writeFileSync(temporaryMetadataPath, JSON.stringify({
-			cacheKey: cacheEntry.cacheKey,
-			createdAt: now,
-			lastAccessedAt: now,
-			packageRoots: cacheEntry.packageRoots,
-			sizeBytes: getDirectorySize(temporaryPackagesRoot),
-			transformDependencyVersions: cacheEntry.transformDependencyVersions,
-			transformImplementationHash: cacheEntry.transformImplementationHash
-		}, null, 2));
-		try {
-			fs.renameSync(temporaryEntryRoot, entryRoot);
-		} catch (error) {
-			const errorCode = error.code;
-			if (errorCode !== "EEXIST" && errorCode !== "ENOTEMPTY") throw error;
-		}
-	} finally {
-		fs.rmSync(temporaryEntryRoot, {
-			force: true,
-			recursive: true
-		});
-	}
-	if (fs.existsSync(packagesRoot) && fs.existsSync(metadataPath)) {
-		const metadata = readMirrorCacheMetadata(entryRoot);
-		if (metadata != null) {
-			metadata.lastAccessedAt = (/* @__PURE__ */ new Date()).toISOString();
-			fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
-		}
-		gcReactNativeMirrorCache(workspaceRoot, cacheEntry.cacheKey, resolvedCacheDir);
-		return packagesRoot;
-	}
-	throw new Error(`Failed to materialize React Native mirror cache at ${entryRoot}`);
-}
-
-//#endregion
 //#region src/reactNative.ts
 const PLATFORM_RESOLUTION_ORDER = [
 	DEFAULT_PLATFORM,
@@ -435,49 +43,20 @@ function resolveReactNativeSetupFiles() {
 	return [path.join(currentDirectory, `reactNativeRuntime${extension}`), path.join(currentDirectory, `setup${extension}`)];
 }
 function reactNative() {
+	let reactNativeTransformCache = null;
 	return {
 		enforce: "pre",
 		name: "granite-react-native",
 		async config(conf) {
 			const workspaceRoot = conf.root ?? conf.test?.root ?? process.cwd();
 			const cacheDir = conf.cacheDir ?? ".vitest";
-			const reactNativeMirrorRoot = await buildReactNativeMirror(workspaceRoot, path.isAbsolute(cacheDir) ? cacheDir : path.join(workspaceRoot, cacheDir));
+			reactNativeTransformCache = await buildReactNativeTransformCache(workspaceRoot, path.isAbsolute(cacheDir) ? cacheDir : path.join(workspaceRoot, cacheDir));
 			const resolve = {
-				alias: [
-					{
-						find: /^react-native$/,
-						replacement: path.join(reactNativeMirrorRoot, "react-native", "index.js")
-					},
-					{
-						find: /^react-native\/(.*)$/,
-						replacement: path.join(reactNativeMirrorRoot, "react-native", "$1")
-					},
-					{
-						find: /^@react-native\/(.*)$/,
-						replacement: path.join(reactNativeMirrorRoot, "@react-native", "$1")
-					},
-					{
-						find: /^@react-native-community\/([^/]+)$/,
-						replacement: path.join(reactNativeMirrorRoot, "@react-native-community", "$1")
-					},
-					{
-						find: /^@react-native-community\/([^/]+)\/(.*)$/,
-						replacement: path.join(reactNativeMirrorRoot, "@react-native-community", "$1", "$2")
-					},
-					{
-						find: /^jest-react-native$/,
-						replacement: path.join(reactNativeMirrorRoot, "jest-react-native")
-					},
-					{
-						find: /^jest-react-native\/(.*)$/,
-						replacement: path.join(reactNativeMirrorRoot, "jest-react-native", "$1")
-					}
-				],
 				conditions: [...REACT_NATIVE_EXPORT_CONDITIONS],
 				extensions: [...REACT_NATIVE_RESOLVE_EXTENSIONS]
 			};
 			const commonConfig = {
-				define: { "globalThis.__GRANITE_VITEST_RN_CACHE_ROOT__": JSON.stringify(reactNativeMirrorRoot) },
+				define: { "globalThis.__GRANITE_VITEST_RN_CACHE_MANIFEST__": JSON.stringify(reactNativeTransformCache.manifestPath) },
 				resolve,
 				test: {
 					environment: "node",
@@ -501,6 +80,10 @@ function reactNative() {
 				...commonConfig
 			};
 		},
+		resolveId(id, importer) {
+			if (reactNativeTransformCache == null) return;
+			return resolveReactNativeModuleFromManifest(id, importer, reactNativeTransformCache.manifest)?.objectPath;
+		},
 		load(id) {
 			if (!REACT_NATIVE_ASSET_MODULE_ID_PATTERN.test(id)) return;
 			const asset = { testUri: path.relative(currentDirectory, id.replace(/[?#].*$/, "")).replace(/\\/g, "/") };
@@ -521,4 +104,4 @@ var src_default = {
 };
 
 //#endregion
-export { DEFAULT_PLATFORM, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY, GRANITE_VITEST_RN_PACKAGES_DIRECTORY, JEST_LIKE_TEST_PATTERNS, REACT_NATIVE_ASSET_EXTENSIONS, REACT_NATIVE_EXPORT_CONDITIONS, REACT_NATIVE_PLATFORMS, REACT_NATIVE_RESOLVE_EXTENSIONS, REACT_NATIVE_TRANSFORM_ALLOWLIST, REACT_NATIVE_TRANSFORM_EXTENSIONS, buildReactNativeMirror, src_default as default, reactNative, resolvePackageRoot, resolveReactNativePackageRoots, resolveReactNativeSetupFiles, shouldInlineReactNativeDependency, shouldTransformReactNativeFile, synthesizeDefaultPlatformFiles };
+export { DEFAULT_PLATFORM, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY, GRANITE_VITEST_RN_MANIFEST_FILENAME, GRANITE_VITEST_RN_OBJECTS_DIRECTORY, GRANITE_VITEST_RN_PACKAGES_DIRECTORY, JEST_LIKE_TEST_PATTERNS, REACT_NATIVE_ASSET_EXTENSIONS, REACT_NATIVE_EXPORT_CONDITIONS, REACT_NATIVE_PLATFORMS, REACT_NATIVE_RESOLVE_EXTENSIONS, REACT_NATIVE_TRANSFORM_ALLOWLIST, REACT_NATIVE_TRANSFORM_EXTENSIONS, buildReactNativeMirror, buildReactNativeTransformCache, src_default as default, reactNative, resolvePackageRoot, resolveReactNativeModuleFromManifest, resolveReactNativePackageRoots, resolveReactNativeSetupFiles, shouldInlineReactNativeDependency, shouldTransformReactNativeFile };

package/dist/mirror-e92G5HdG.js

@@ -0,0 +1,484 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import flowRemoveTypes from "flow-remove-types";
+
+//#region src/assets.ts
+const REACT_NATIVE_ASSET_EXTENSIONS = [
+	"bmp",
+	"gif",
+	"jpg",
+	"jpeg",
+	"mp4",
+	"png",
+	"psd",
+	"svg",
+	"webp"
+];
+const REACT_NATIVE_ASSET_MODULE_ID_PATTERN = new RegExp(`\\.(${REACT_NATIVE_ASSET_EXTENSIONS.join("|")})(?:[?#].*)?$`, "i");
+
+//#endregion
+//#region src/transpile.ts
+const REACT_NATIVE_TRANSFORM_EXTENSIONS = [
+	".js",
+	".jsx",
+	".ts",
+	".tsx"
+];
+const REACT_NATIVE_TRANSFORM_ALLOWLIST = [
+	"react-native",
+	"jest-react-native",
+	"@react-native",
+	"@react-native-community"
+];
+function normalizePath$1(filename) {
+	return filename.replace(/\\/g, "/");
+}
+function isWithinPackageRoots(filename, packageRoots) {
+	const normalizedFilename = normalizePath$1(path.resolve(filename));
+	return packageRoots.some((packageRoot) => {
+		const normalizedPackageRoot = normalizePath$1(path.resolve(packageRoot));
+		return normalizedFilename === normalizedPackageRoot || normalizedFilename.startsWith(`${normalizedPackageRoot}/`);
+	});
+}
+function shouldTransformReactNativeFile(filename, packageRoots = []) {
+	const normalized = normalizePath$1(filename);
+	const isReactNativeSource = packageRoots.length > 0 ? isWithinPackageRoots(normalized, packageRoots) : normalized.includes("/react-native/") || normalized.includes("/@react-native/");
+	return /\.(?:js|jsx|ts|tsx)$/.test(normalized) && !normalized.includes("/Renderer/implementations/") && isReactNativeSource;
+}
+function shouldInlineReactNativeDependency(filename, packageRoots = []) {
+	const normalized = normalizePath$1(filename);
+	if (packageRoots.length > 0) return isWithinPackageRoots(normalized, packageRoots);
+	return REACT_NATIVE_TRANSFORM_ALLOWLIST.some((allowlistEntry) => normalized.includes(`/${allowlistEntry}/`));
+}
+async function transformReactNativeSource(_sourcePath, source) {
+	return flowRemoveTypes(source, {
+		all: true,
+		pretty: true,
+		removeEmptyImports: true
+	}).toString();
+}
+
+//#endregion
+//#region src/mirror.ts
+const DEFAULT_PLATFORM = "ios";
+const GRANITE_VITEST_RN_CACHE_DIRECTORY = "vitest-react-native-cache";
+const GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY = "entries";
+const GRANITE_VITEST_RN_OBJECTS_DIRECTORY = "objects";
+const GRANITE_VITEST_RN_MANIFEST_FILENAME = "manifest.json";
+const GRANITE_VITEST_RN_PACKAGES_DIRECTORY = "packages";
+const REACT_NATIVE_PLATFORMS = [
+	"android",
+	"ios",
+	"native"
+];
+const GRANITE_VITEST_RN_CACHE_GC_LOCK_FILENAME = ".gc.lock";
+const GRANITE_VITEST_RN_CACHE_METADATA_FILENAME = "meta.json";
+const GRANITE_VITEST_RN_CACHE_TMP_PREFIX = ".tmp-";
+const GRANITE_VITEST_RN_TEMP_ENTRY_MAX_AGE_MS = 3600 * 1e3;
+const DEFAULT_VITEST_CACHE_DIRECTORY = ".vitest";
+const MIRROR_CACHE_KEY_VERSION = "v2-flat";
+const PLATFORM_EXTENSION_SUFFIXES = [
+	"tsx",
+	"ts",
+	"jsx",
+	"js"
+];
+const FALLBACK_EXTENSIONS = [
+	...[
+		DEFAULT_PLATFORM,
+		"native",
+		...REACT_NATIVE_PLATFORMS.filter((platform) => platform !== DEFAULT_PLATFORM && platform !== "native")
+	].flatMap((platform) => PLATFORM_EXTENSION_SUFFIXES.map((extension) => `.${platform}.${extension}`)),
+	".tsx",
+	".ts",
+	".jsx",
+	".js",
+	".json",
+	...REACT_NATIVE_ASSET_EXTENSIONS.map((extension) => `.${extension}`)
+];
+const currentMirrorModulePath = fs.realpathSync(fileURLToPath(import.meta.url));
+const currentMirrorModuleDirectory = path.dirname(currentMirrorModulePath);
+function normalizePath(filename) {
+	return path.resolve(filename.replace(/[?#].*$/, ""));
+}
+function getFlowRemoveTypesVersion() {
+	const flowRemoveTypesPackageJsonPath = createRequire(import.meta.url).resolve("flow-remove-types/package.json");
+	return JSON.parse(fs.readFileSync(flowRemoveTypesPackageJsonPath, "utf8")).version ?? "unknown";
+}
+function getPackageManifestDependencyNames(packageManifest) {
+	return Object.keys({
+		...packageManifest.dependencies ?? {},
+		...packageManifest.devDependencies ?? {},
+		...packageManifest.optionalDependencies ?? {},
+		...packageManifest.peerDependencies ?? {}
+	}).sort();
+}
+function shouldMirrorReactNativeDependency(packageName) {
+	return packageName === "jest-react-native" || packageName.startsWith("@react-native/") || packageName.startsWith("@react-native-community/");
+}
+function hashDirectoryContents(hasher, rootPath, currentPath = rootPath) {
+	const entries = fs.readdirSync(currentPath, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+	for (const entry of entries) {
+		const entryPath = path.join(currentPath, entry.name);
+		if (entry.isDirectory()) {
+			hashDirectoryContents(hasher, rootPath, entryPath);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		hasher.update(path.relative(rootPath, entryPath));
+		hasher.update("\0");
+		hasher.update(fs.readFileSync(entryPath));
+		hasher.update("\0");
+	}
+}
+function hashImplementationFiles() {
+	const hasher = createHash("sha256");
+	const extension = path.extname(currentMirrorModulePath);
+	const implementationFiles = [currentMirrorModulePath, path.join(currentMirrorModuleDirectory, `transpile${extension}`)].filter((implementationFile, index, allFiles) => {
+		if (!fs.existsSync(implementationFile)) return false;
+		return allFiles.indexOf(implementationFile) === index;
+	}).sort();
+	for (const implementationFile of implementationFiles) {
+		hasher.update(path.basename(implementationFile));
+		hasher.update("\0");
+		hasher.update(fs.readFileSync(implementationFile));
+		hasher.update("\0");
+	}
+	return hasher.digest("hex");
+}
+function collectMirroredReactNativePackageNames(workspacePackageManifest, reactNativePackageManifest) {
+	const packageNames = /* @__PURE__ */ new Set();
+	for (const dependencyName of Object.keys(reactNativePackageManifest.dependencies ?? {})) if (dependencyName.startsWith("@react-native/")) packageNames.add(dependencyName);
+	for (const dependencyName of getPackageManifestDependencyNames(workspacePackageManifest)) if (dependencyName !== "react-native" && shouldMirrorReactNativeDependency(dependencyName)) packageNames.add(dependencyName);
+	return [...packageNames].sort();
+}
+function getMirroredReactNativePackages(workspaceRoot) {
+	const reactNativeRoot = resolvePackageRoot("react-native", workspaceRoot);
+	const workspacePackageManifest = JSON.parse(fs.readFileSync(path.join(workspaceRoot, "package.json"), "utf8"));
+	const reactNativePackageManifest = JSON.parse(fs.readFileSync(path.join(reactNativeRoot, "package.json"), "utf8"));
+	const workspaceDependencyNames = new Set(getPackageManifestDependencyNames(workspacePackageManifest));
+	return collectMirroredReactNativePackageNames(workspacePackageManifest, reactNativePackageManifest).map((packageName) => ({
+		packageName,
+		requireRoot: workspaceDependencyNames.has(packageName) ? workspaceRoot : reactNativeRoot
+	}));
+}
+function getReactNativePackageEntries(workspaceRoot) {
+	return [{
+		packageName: "react-native",
+		packageRoot: resolvePackageRoot("react-native", workspaceRoot),
+		requireRoot: workspaceRoot
+	}, ...getMirroredReactNativePackages(workspaceRoot).map(({ packageName, requireRoot }) => ({
+		packageName,
+		packageRoot: resolvePackageRoot(packageName, requireRoot),
+		requireRoot
+	}))];
+}
+function computeReactNativeTransformCacheKey(workspaceRoot) {
+	const hasher = createHash("sha256");
+	const packageRoots = resolveReactNativePackageRoots(workspaceRoot).sort();
+	const transformImplementationHash = hashImplementationFiles();
+	const transformDependencyVersions = { flowRemoveTypes: getFlowRemoveTypesVersion() };
+	hasher.update(`granite-vitest-rn-cache:${MIRROR_CACHE_KEY_VERSION}`);
+	hasher.update("\0");
+	hasher.update(`flow-remove-types:${transformDependencyVersions.flowRemoveTypes}`);
+	hasher.update("\0");
+	hasher.update(`transform:${transformImplementationHash}`);
+	hasher.update("\0");
+	for (const packageRoot of packageRoots) {
+		hasher.update(path.basename(packageRoot));
+		hasher.update("\0");
+		hashDirectoryContents(hasher, packageRoot);
+	}
+	return {
+		cacheKey: hasher.digest("hex"),
+		packageRoots,
+		transformDependencyVersions,
+		transformImplementationHash
+	};
+}
+function getDirectorySize(targetPath) {
+	const stat = fs.statSync(targetPath);
+	if (stat.isFile()) return stat.size;
+	if (!stat.isDirectory()) return 0;
+	return fs.readdirSync(targetPath, { withFileTypes: true }).reduce((totalSize, entry) => {
+		const entryPath = path.join(targetPath, entry.name);
+		if (entry.isDirectory() || entry.isFile()) return totalSize + getDirectorySize(entryPath);
+		return totalSize;
+	}, 0);
+}
+function readMirrorCacheMetadata(entryRoot) {
+	const metadataPath = path.join(entryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
+	if (!fs.existsSync(metadataPath)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function gcReactNativeMirrorCache(workspaceRoot, activeCacheKey, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY)) {
+	gcReactNativeMirrorCacheAsync(activeCacheKey, resolvedCacheDir).catch(() => void 0);
+}
+async function gcReactNativeMirrorCacheAsync(activeCacheKey, resolvedCacheDir) {
+	const cacheRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY);
+	const lockPath = path.join(cacheRoot, GRANITE_VITEST_RN_CACHE_GC_LOCK_FILENAME);
+	await fs.promises.mkdir(cacheRoot, { recursive: true });
+	let lockHandle = null;
+	try {
+		lockHandle = await fs.promises.open(lockPath, "wx");
+	} catch (error) {
+		if (error.code === "EEXIST") return;
+		throw error;
+	}
+	try {
+		const entriesRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY);
+		if (!await fs.promises.access(entriesRoot).then(() => true).catch(() => false)) return;
+		const now = Date.now();
+		const removeEntryPromises = [];
+		for (const entry of await fs.promises.readdir(entriesRoot, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const entryRoot = path.join(entriesRoot, entry.name);
+			if (entry.name.startsWith(GRANITE_VITEST_RN_CACHE_TMP_PREFIX)) {
+				const stat = await fs.promises.stat(entryRoot).catch(() => null);
+				if ((stat == null ? 0 : now - stat.mtimeMs) > GRANITE_VITEST_RN_TEMP_ENTRY_MAX_AGE_MS) removeEntryPromises.push(fs.promises.rm(entryRoot, {
+					force: true,
+					recursive: true
+				}));
+				continue;
+			}
+			if (entry.name === activeCacheKey) continue;
+			removeEntryPromises.push(fs.promises.rm(entryRoot, {
+				force: true,
+				recursive: true
+			}));
+		}
+		await Promise.allSettled(removeEntryPromises);
+	} catch {} finally {
+		if (lockHandle != null) {
+			await lockHandle.close().catch(() => void 0);
+			await fs.promises.rm(lockPath, {
+				force: true,
+				recursive: true
+			}).catch(() => void 0);
+		}
+	}
+}
+function resolvePackageRoot(packageName, requireRoot) {
+	const packageJsonPath = createRequire(path.join(requireRoot, "package.json")).resolve(`${packageName}/package.json`);
+	return path.dirname(packageJsonPath);
+}
+function resolveReactNativePackageRoots(workspaceRoot) {
+	return getReactNativePackageEntries(workspaceRoot).map(({ packageRoot }) => packageRoot);
+}
+function readPackageManifest(packageRoot) {
+	return JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+}
+function findPackageForRequest(request, manifest) {
+	return manifest.packages.sort((left, right) => right.packageName.length - left.packageName.length).find(({ packageName }) => request === packageName || request.startsWith(`${packageName}/`));
+}
+function getPackageSubpath(request, packageName) {
+	if (request === packageName) return null;
+	return request.slice(packageName.length + 1);
+}
+function getObjectForSourcePath(sourcePath, manifest) {
+	const normalizedSourcePath = normalizePath(sourcePath);
+	const objectPath = manifest.sourceToObject[normalizedSourcePath];
+	if (objectPath == null) return null;
+	return {
+		objectPath,
+		sourcePath: normalizedSourcePath
+	};
+}
+function resolvePackageEntrySourcePath(packageEntry, manifest) {
+	const packageManifest = readPackageManifest(packageEntry.packageRoot);
+	const entryPath = packageEntry.packageName === "react-native" ? "index.js" : packageManifest["react-native"] ?? packageManifest.module ?? packageManifest.main ?? "index.js";
+	if (typeof entryPath === "string") return resolveSourcePathCandidate(path.join(packageEntry.packageRoot, entryPath), manifest);
+	return resolveSourcePathCandidate(path.join(packageEntry.packageRoot, "index"), manifest);
+}
+function resolveSourcePathCandidate(candidatePath, manifest) {
+	const normalizedCandidatePath = normalizePath(candidatePath);
+	if (fs.existsSync(normalizedCandidatePath)) {
+		const stat = fs.statSync(normalizedCandidatePath);
+		if (stat.isFile()) return getObjectForSourcePath(normalizedCandidatePath, manifest);
+		if (stat.isDirectory()) {
+			const packageJsonPath = path.join(normalizedCandidatePath, "package.json");
+			if (fs.existsSync(packageJsonPath)) {
+				const packageManifest = readPackageManifest(normalizedCandidatePath);
+				const entryPath = packageManifest["react-native"] ?? packageManifest.module ?? packageManifest.main ?? "index.js";
+				if (typeof entryPath === "string") {
+					const resolvedEntry = resolveSourcePathCandidate(path.join(normalizedCandidatePath, entryPath), manifest);
+					if (resolvedEntry != null) return resolvedEntry;
+				}
+			}
+			return resolveSourcePathCandidate(path.join(normalizedCandidatePath, "index"), manifest);
+		}
+	}
+	if (path.extname(normalizedCandidatePath).length > 0) return null;
+	for (const extension of FALLBACK_EXTENSIONS) {
+		const resolved = getObjectForSourcePath(`${normalizedCandidatePath}${extension}`, manifest);
+		if (resolved != null) return resolved;
+	}
+	return null;
+}
+function resolveReactNativeModuleFromManifest(request, importer, manifest) {
+	if (request.startsWith(".") && importer != null) {
+		const importerSourcePath = manifest.objectToSource[normalizePath(importer)];
+		if (importerSourcePath == null) return null;
+		return resolveSourcePathCandidate(path.resolve(path.dirname(importerSourcePath), request), manifest);
+	}
+	const packageEntry = findPackageForRequest(request, manifest);
+	if (packageEntry == null) return null;
+	const subpath = getPackageSubpath(request, packageEntry.packageName);
+	if (subpath == null) return resolvePackageEntrySourcePath(packageEntry, manifest);
+	return resolveSourcePathCandidate(path.join(packageEntry.packageRoot, subpath), manifest);
+}
+async function writeObjectFile(sourcePath, objectsRoot, packageRoots, manifest) {
+	const normalizedSourcePath = normalizePath(sourcePath);
+	const sourceBuffer = fs.readFileSync(normalizedSourcePath);
+	const extension = path.extname(normalizedSourcePath) || ".js";
+	let outputBuffer = sourceBuffer;
+	if (shouldTransformReactNativeFile(normalizedSourcePath, packageRoots)) try {
+		const transformed = await transformReactNativeSource(normalizedSourcePath, sourceBuffer.toString("utf8"));
+		outputBuffer = Buffer.from(transformed);
+	} catch {
+		outputBuffer = sourceBuffer;
+	}
+	const objectHash = createHash("sha256").update(normalizedSourcePath).update("\0").update(outputBuffer).digest("hex");
+	const objectPath = path.join(objectsRoot, `${objectHash}${extension}`);
+	if (!fs.existsSync(objectPath)) fs.writeFileSync(objectPath, outputBuffer);
+	manifest.sourceToObject[normalizedSourcePath] = objectPath;
+	manifest.objectToSource[objectPath] = normalizedSourcePath;
+}
+async function writePackageTreeObjects(sourceRoot, objectsRoot, packageRoots, manifest) {
+	const entries = fs.readdirSync(sourceRoot, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+	for (const entry of entries) {
+		const sourcePath = path.join(sourceRoot, entry.name);
+		if (entry.isDirectory()) {
+			await writePackageTreeObjects(sourcePath, objectsRoot, packageRoots, manifest);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		await writeObjectFile(sourcePath, objectsRoot, packageRoots, manifest);
+	}
+}
+function readTransformCacheManifest(manifestPath) {
+	return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+}
+function loadReactNativeTransformCacheManifest(manifestPath) {
+	return readTransformCacheManifest(manifestPath);
+}
+async function buildReactNativeTransformCache(workspaceRoot, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY)) {
+	const cacheEntry = computeReactNativeTransformCacheKey(workspaceRoot);
+	const entriesRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY);
+	const entryRoot = path.join(entriesRoot, cacheEntry.cacheKey);
+	const objectsRoot = path.join(entryRoot, GRANITE_VITEST_RN_OBJECTS_DIRECTORY);
+	const manifestPath = path.join(entryRoot, GRANITE_VITEST_RN_MANIFEST_FILENAME);
+	const metadataPath = path.join(entryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
+	fs.mkdirSync(entriesRoot, { recursive: true });
+	if (fs.existsSync(entryRoot) && (!fs.existsSync(objectsRoot) || !fs.existsSync(manifestPath))) fs.rmSync(entryRoot, {
+		force: true,
+		recursive: true
+	});
+	gcReactNativeMirrorCache(workspaceRoot, cacheEntry.cacheKey, resolvedCacheDir);
+	if (fs.existsSync(objectsRoot) && fs.existsSync(manifestPath) && fs.existsSync(metadataPath)) {
+		const manifest = readTransformCacheManifest(manifestPath);
+		const metadata = readMirrorCacheMetadata(entryRoot);
+		const lastAccessedAt = (/* @__PURE__ */ new Date()).toISOString();
+		manifest.lastAccessedAt = lastAccessedAt;
+		fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+		if (metadata != null) {
+			metadata.lastAccessedAt = lastAccessedAt;
+			fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+		}
+		return {
+			entryRoot,
+			manifest,
+			manifestPath,
+			objectsRoot
+		};
+	}
+	const temporaryEntryRoot = path.join(entriesRoot, `${GRANITE_VITEST_RN_CACHE_TMP_PREFIX}${process.pid}-${Date.now()}-${cacheEntry.cacheKey}`);
+	const temporaryObjectsRoot = path.join(temporaryEntryRoot, GRANITE_VITEST_RN_OBJECTS_DIRECTORY);
+	const temporaryManifestPath = path.join(temporaryEntryRoot, GRANITE_VITEST_RN_MANIFEST_FILENAME);
+	const temporaryMetadataPath = path.join(temporaryEntryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const packages = getReactNativePackageEntries(workspaceRoot);
+	const manifest = {
+		cacheKey: cacheEntry.cacheKey,
+		createdAt: now,
+		lastAccessedAt: now,
+		objectsRoot,
+		packageRoots: cacheEntry.packageRoots,
+		packages,
+		sourceToObject: {},
+		objectToSource: {},
+		transformDependencyVersions: cacheEntry.transformDependencyVersions,
+		transformImplementationHash: cacheEntry.transformImplementationHash
+	};
+	fs.rmSync(temporaryEntryRoot, {
+		force: true,
+		recursive: true
+	});
+	fs.mkdirSync(temporaryObjectsRoot, { recursive: true });
+	try {
+		const temporaryManifest = {
+			...manifest,
+			objectsRoot: temporaryObjectsRoot
+		};
+		for (const { packageRoot } of packages) await writePackageTreeObjects(packageRoot, temporaryObjectsRoot, cacheEntry.packageRoots, temporaryManifest);
+		const finalizedManifest = {
+			...temporaryManifest,
+			objectsRoot,
+			sourceToObject: Object.fromEntries(Object.entries(temporaryManifest.sourceToObject).map(([sourcePath, objectPath]) => [sourcePath, path.join(objectsRoot, path.basename(objectPath))])),
+			objectToSource: Object.fromEntries(Object.entries(temporaryManifest.objectToSource).map(([objectPath, sourcePath]) => [path.join(objectsRoot, path.basename(objectPath)), sourcePath]))
+		};
+		fs.writeFileSync(temporaryManifestPath, JSON.stringify(finalizedManifest, null, 2));
+		fs.writeFileSync(temporaryMetadataPath, JSON.stringify({
+			cacheKey: cacheEntry.cacheKey,
+			createdAt: now,
+			lastAccessedAt: now,
+			packageRoots: cacheEntry.packageRoots,
+			sizeBytes: getDirectorySize(temporaryObjectsRoot),
+			transformDependencyVersions: cacheEntry.transformDependencyVersions,
+			transformImplementationHash: cacheEntry.transformImplementationHash
+		}, null, 2));
+		try {
+			fs.renameSync(temporaryEntryRoot, entryRoot);
+		} catch (error) {
+			const errorCode = error.code;
+			if (errorCode !== "EEXIST" && errorCode !== "ENOTEMPTY") throw error;
+		}
+	} finally {
+		fs.rmSync(temporaryEntryRoot, {
+			force: true,
+			recursive: true
+		});
+	}
+	if (fs.existsSync(objectsRoot) && fs.existsSync(manifestPath) && fs.existsSync(metadataPath)) {
+		const manifest = readTransformCacheManifest(manifestPath);
+		const metadata = readMirrorCacheMetadata(entryRoot);
+		const lastAccessedAt = (/* @__PURE__ */ new Date()).toISOString();
+		manifest.lastAccessedAt = lastAccessedAt;
+		fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+		if (metadata != null) {
+			metadata.lastAccessedAt = lastAccessedAt;
+			fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+		}
+		gcReactNativeMirrorCache(workspaceRoot, cacheEntry.cacheKey, resolvedCacheDir);
+		return {
+			entryRoot,
+			manifest,
+			manifestPath,
+			objectsRoot
+		};
+	}
+	throw new Error(`Failed to materialize React Native transform cache at ${entryRoot}`);
+}
+async function buildReactNativeMirror(workspaceRoot, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY)) {
+	return (await buildReactNativeTransformCache(workspaceRoot, resolvedCacheDir)).objectsRoot;
+}
+
+//#endregion
+export { shouldTransformReactNativeFile as _, GRANITE_VITEST_RN_OBJECTS_DIRECTORY as a, buildReactNativeMirror as c, resolvePackageRoot as d, resolveReactNativeModuleFromManifest as f, shouldInlineReactNativeDependency as g, REACT_NATIVE_TRANSFORM_EXTENSIONS as h, GRANITE_VITEST_RN_MANIFEST_FILENAME as i, buildReactNativeTransformCache as l, REACT_NATIVE_TRANSFORM_ALLOWLIST as m, GRANITE_VITEST_RN_CACHE_DIRECTORY as n, GRANITE_VITEST_RN_PACKAGES_DIRECTORY as o, resolveReactNativePackageRoots as p, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY as r, REACT_NATIVE_PLATFORMS as s, DEFAULT_PLATFORM as t, loadReactNativeTransformCacheManifest as u, REACT_NATIVE_ASSET_EXTENSIONS as v, REACT_NATIVE_ASSET_MODULE_ID_PATTERN as y };

package/dist/reactNativeRuntime.js

@@ -1,4 +1,4 @@
-import { n as REACT_NATIVE_ASSET_MODULE_ID_PATTERN } from "./assets-DoucBOz0.js";
+import { f as resolveReactNativeModuleFromManifest, u as loadReactNativeTransformCacheManifest, y as REACT_NATIVE_ASSET_MODULE_ID_PATTERN } from "./mirror-e92G5HdG.js";
 import { n as installNativeModuleProxy, r as installReactNativeGlobals, t as defineGlobalProperty } from "./runtimeBootstrap-CHWitCG1.js";
 import Module, { createRequire } from "node:module";
 import path from "node:path";
@@ -9,11 +9,16 @@ import { vi } from "vitest";
 const runtimeGlobals = globalThis;
 const runtimeDirectory = path.dirname(fileURLToPath(import.meta.url));
 const runtimeRequire = createRequire(import.meta.url);
-function resolveReactNativeMirrorRoot() {
-	if (typeof globalThis.__GRANITE_VITEST_RN_CACHE_ROOT__ === "string" && globalThis.__GRANITE_VITEST_RN_CACHE_ROOT__.length > 0) return path.resolve(globalThis.__GRANITE_VITEST_RN_CACHE_ROOT__);
-	throw new Error("[@granite-js/vitest] reactNativeRuntime requires reactNative() in vitest.config to set __GRANITE_VITEST_RN_CACHE_ROOT__.");
+function resolveReactNativeManifestPath() {
+	if (typeof globalThis.__GRANITE_VITEST_RN_CACHE_MANIFEST__ === "string" && globalThis.__GRANITE_VITEST_RN_CACHE_MANIFEST__.length > 0) return path.resolve(globalThis.__GRANITE_VITEST_RN_CACHE_MANIFEST__);
+	throw new Error("[@granite-js/vitest] reactNativeRuntime requires reactNative() in vitest.config to set __GRANITE_VITEST_RN_CACHE_MANIFEST__.");
+}
+const reactNativeTransformCacheManifest = loadReactNativeTransformCacheManifest(resolveReactNativeManifestPath());
+function resolveReactNativeObjectPath(request, importer, manifest = reactNativeTransformCacheManifest) {
+	const resolved = resolveReactNativeModuleFromManifest(request, importer, manifest);
+	if (resolved == null) throw new Error(`[@granite-js/vitest] Failed to resolve React Native module: ${request}`);
+	return resolved.objectPath;
 }
-const reactNativeMirrorRoot = resolveReactNativeMirrorRoot();
 let nextNativeTag = 1;
 function createMockNativeMethods() {
 	return {
@@ -1625,83 +1630,52 @@ function patchReactNativeResolution() {
 	const moduleWithPrivateResolver = Module;
 	const originalResolveFilename = moduleWithPrivateResolver._resolveFilename;
 	const originalLoad = moduleWithPrivateResolver._load;
-	const reactNativeIndexPath = path.join(reactNativeMirrorRoot, "react-native", "index.js");
-	const nativeComponentRegistryMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "NativeComponent", "NativeComponentRegistry.js");
-	const requireNativeComponentMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "ReactNative", "requireNativeComponent.js");
-	const initializeCoreMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Core", "InitializeCore.js");
-	const nativeExceptionsManagerMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Core", "NativeExceptionsManager.js");
-	const accessibilityInfoMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "AccessibilityInfo", "AccessibilityInfo.js");
-	const clipboardMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "Clipboard", "Clipboard.js");
-	const codegenNativeCommandsMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Utilities", "codegenNativeCommands.js");
-	const codegenNativeComponentMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Utilities", "codegenNativeComponent.js");
-	const refreshControlMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "RefreshControl", "RefreshControl.js");
-	const activityIndicatorMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "ActivityIndicator", "ActivityIndicator.js");
-	const imageMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Image", "Image.js");
-	const textMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Text", "Text.js");
-	const textInputMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "TextInput", "TextInput.js");
-	const modalMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Modal", "Modal.js");
-	const viewMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "View", "View.js");
-	const scrollViewMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "ScrollView", "ScrollView.js");
-	const nativeModulesMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "BatchedBridge", "NativeModules.js");
-	const uiManagerMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "ReactNative", "UIManager.js");
-	const appStateMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "AppState", "AppState.js");
-	const linkingMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Linking", "Linking.js");
-	const vibrationMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Vibration", "Vibration.js");
-	const viewNativeComponentMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Components", "View", "ViewNativeComponent.js");
-	const useColorSchemeMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Utilities", "useColorScheme.js");
-	const platformMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "Utilities", "Platform.js");
-	const styleSheetMockPath = path.join(reactNativeMirrorRoot, "react-native", "Libraries", "StyleSheet", "StyleSheet.js");
+	const reactNativeIndexPath = resolveReactNativeObjectPath("react-native");
 	const sharedMockModules = getSharedReactNativeMockModules();
-	const tryResolveMirroredPackageRequest = (request) => {
-		if (request === "jest-react-native") return path.join(reactNativeMirrorRoot, "jest-react-native");
-		if (request.startsWith("jest-react-native/")) return path.join(reactNativeMirrorRoot, "jest-react-native", request.slice(18));
-		if (request.startsWith("@react-native-community/")) return path.join(reactNativeMirrorRoot, ...request.split("/"));
-		return null;
-	};
-	const isMirroredPackageManifestRequest = (request) => request === "react-native/package.json" || request === "jest-react-native/package.json" || request.startsWith("@react-native/") && request.endsWith("/package.json") || request.startsWith("@react-native-community/") && request.endsWith("/package.json");
+	const sharedMockModuleByPath = new Map([
+		[resolveReactNativeObjectPath("react-native/Libraries/NativeComponent/NativeComponentRegistry.js"), sharedMockModules.nativeComponentRegistryModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/ReactNative/requireNativeComponent.js"), sharedMockModules.requireNativeComponentModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Core/InitializeCore.js"), sharedMockModules.initializeCoreModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Core/NativeExceptionsManager.js"), sharedMockModules.nativeExceptionsManagerModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Components/AccessibilityInfo/AccessibilityInfo.js"), sharedMockModules.accessibilityInfoModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Components/Clipboard/Clipboard.js"), sharedMockModules.clipboardModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Utilities/codegenNativeCommands.js"), sharedMockModules.codegenNativeCommandsModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Utilities/codegenNativeComponent.js"), sharedMockModules.codegenNativeComponentModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Components/RefreshControl/RefreshControl.js"), sharedMockModules.refreshControlModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Components/ActivityIndicator/ActivityIndicator.js"), sharedMockModules.activityIndicatorModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Image/Image.js"), sharedMockModules.imageModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Text/Text.js"), sharedMockModules.textModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Components/TextInput/TextInput.js"), sharedMockModules.textInputModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Modal/Modal.js"), sharedMockModules.modalModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Components/View/View.js"), sharedMockModules.viewModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Components/ScrollView/ScrollView.js"), sharedMockModules.scrollViewModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/BatchedBridge/NativeModules.js"), sharedMockModules.nativeModulesModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/ReactNative/UIManager.js"), sharedMockModules.uiManagerModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/AppState/AppState.js"), sharedMockModules.appStateModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Linking/Linking.js"), sharedMockModules.linkingModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Vibration/Vibration.js"), sharedMockModules.vibrationModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Components/View/ViewNativeComponent.js"), sharedMockModules.viewNativeComponentModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Utilities/useColorScheme.js"), sharedMockModules.useColorSchemeModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/Utilities/Platform.js"), sharedMockModules.platformModule],
+		[resolveReactNativeObjectPath("react-native/Libraries/StyleSheet/StyleSheet.js"), sharedMockModules.styleSheetModule]
+	]);
+	const isReactNativePackageManifestRequest = (request) => request === "react-native/package.json" || request === "jest-react-native/package.json" || request.startsWith("@react-native/") && request.endsWith("/package.json") || request.startsWith("@react-native-community/") && request.endsWith("/package.json");
 	moduleWithPrivateResolver._resolveFilename = function patchedResolveFilename(request, parent, isMain, options) {
-		if (isMirroredPackageManifestRequest(request)) return originalResolveFilename.call(this, request, parent, isMain, options);
-		if (request === "react-native") return originalResolveFilename.call(this, reactNativeIndexPath, parent, isMain, options);
-		if (request.startsWith("react-native/")) return originalResolveFilename.call(this, path.join(reactNativeMirrorRoot, "react-native", request.slice(13)), parent, isMain, options);
-		if (request.startsWith("@react-native/")) return originalResolveFilename.call(this, path.join(reactNativeMirrorRoot, request), parent, isMain, options);
-		const mirroredPackageRequest = tryResolveMirroredPackageRequest(request);
-		if (mirroredPackageRequest != null) return originalResolveFilename.call(this, mirroredPackageRequest, parent, isMain, options);
+		if (isReactNativePackageManifestRequest(request)) return originalResolveFilename.call(this, request, parent, isMain, options);
+		const resolved = resolveReactNativeModuleFromManifest(request, parent?.filename, reactNativeTransformCacheManifest);
+		if (resolved != null) return resolved.objectPath;
 		return originalResolveFilename.call(this, request, parent, isMain, options);
 	};
 	moduleWithPrivateResolver._load = function patchedLoad(request, parent, isMain) {
 		const resolved = moduleWithPrivateResolver._resolveFilename(request, parent, isMain);
 		if (resolved === reactNativeIndexPath) return getSharedReactNativeExports();
-		if (resolved === nativeComponentRegistryMockPath) return sharedMockModules.nativeComponentRegistryModule;
-		if (resolved === requireNativeComponentMockPath) return sharedMockModules.requireNativeComponentModule;
-		if (resolved === initializeCoreMockPath) return sharedMockModules.initializeCoreModule;
-		if (resolved === nativeExceptionsManagerMockPath) return sharedMockModules.nativeExceptionsManagerModule;
-		if (resolved === accessibilityInfoMockPath) return sharedMockModules.accessibilityInfoModule;
-		if (resolved === clipboardMockPath) return sharedMockModules.clipboardModule;
-		if (resolved === codegenNativeCommandsMockPath) return sharedMockModules.codegenNativeCommandsModule;
-		if (resolved === codegenNativeComponentMockPath) return sharedMockModules.codegenNativeComponentModule;
-		if (resolved === refreshControlMockPath) return sharedMockModules.refreshControlModule;
-		if (resolved === activityIndicatorMockPath) return sharedMockModules.activityIndicatorModule;
-		if (resolved === imageMockPath) return sharedMockModules.imageModule;
-		if (resolved === textMockPath) return sharedMockModules.textModule;
-		if (resolved === textInputMockPath) return sharedMockModules.textInputModule;
-		if (resolved === modalMockPath) return sharedMockModules.modalModule;
-		if (resolved === viewMockPath) return sharedMockModules.viewModule;
-		if (resolved === scrollViewMockPath) return sharedMockModules.scrollViewModule;
-		if (resolved === nativeModulesMockPath) return sharedMockModules.nativeModulesModule;
-		if (resolved === uiManagerMockPath) return sharedMockModules.uiManagerModule;
-		if (resolved === appStateMockPath) return sharedMockModules.appStateModule;
-		if (resolved === linkingMockPath) return sharedMockModules.linkingModule;
-		if (resolved === vibrationMockPath) return sharedMockModules.vibrationModule;
-		if (resolved === viewNativeComponentMockPath) return sharedMockModules.viewNativeComponentModule;
-		if (resolved === useColorSchemeMockPath) return sharedMockModules.useColorSchemeModule;
-		if (resolved === platformMockPath) return sharedMockModules.platformModule;
-		if (resolved === styleSheetMockPath) return sharedMockModules.styleSheetModule;
+		if (sharedMockModuleByPath.has(resolved)) return sharedMockModuleByPath.get(resolved);
 		if (REACT_NATIVE_ASSET_MODULE_ID_PATTERN.test(resolved)) return { testUri: path.relative(runtimeDirectory, resolved.replace(/[?#].*$/, "")).replace(/\\/g, "/") };
 		return originalLoad.call(this, request, parent, isMain);
 	};
 	runtimeGlobals.__rntlVitestRnResolverPatched__ = true;
 }
-runtimeRequire(path.join(reactNativeMirrorRoot, "@react-native", "js-polyfills", "error-guard.js"));
+runtimeRequire(resolveReactNativeObjectPath("@react-native/js-polyfills/error-guard.js"));
 vi.mock("react-native", () => getSharedReactNativeExports());
 installReactNativeGlobals(runtimeGlobals);
 installNativeModuleProxy(runtimeGlobals);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@granite-js/vitest",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "type": "module",
   "description": "Vitest helpers for React Native",
   "types": "./dist/index.d.ts",
@@ -26,7 +26,7 @@
     "build": "tsdown"
   },
   "dependencies": {
-    "fast-flow-transform": "0.0.3"
+    "flow-remove-types": "2.291.0"
   },
   "devDependencies": {
     "@types/node": "24.10.12",

package/dist/assets-DoucBOz0.js

@@ -1,16 +0,0 @@
-//#region src/assets.ts
-const REACT_NATIVE_ASSET_EXTENSIONS = [
-	"bmp",
-	"gif",
-	"jpg",
-	"jpeg",
-	"mp4",
-	"png",
-	"psd",
-	"svg",
-	"webp"
-];
-const REACT_NATIVE_ASSET_MODULE_ID_PATTERN = new RegExp(`\\.(${REACT_NATIVE_ASSET_EXTENSIONS.join("|")})(?:[?#].*)?$`, "i");
-
-//#endregion
-export { REACT_NATIVE_ASSET_MODULE_ID_PATTERN as n, REACT_NATIVE_ASSET_EXTENSIONS as t };