@tamagui/metro-plugin 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/frontend.cjs

@@ -0,0 +1,870 @@
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var frontend_exports = {};
+__export(frontend_exports, {
+	METRO_RECORD_CACHE_VERSION: () => METRO_RECORD_CACHE_VERSION,
+	MetroCompilerFrontend: () => MetroCompilerFrontend,
+	describeMetroCompilerRoot: () => describeMetroCompilerRoot
+});
+module.exports = __toCommonJS(frontend_exports);
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_module = require("node:module");
+var import_node_path = require("node:path");
+var import_ignore = __toESM(require("ignore"), 1);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_static = __toESM(require("@tamagui/static"), 1);
+var import_babel = require("./babel.cjs");
+var import_zeroRuntime = require("./zeroRuntime.cjs");
+var import_compilerCache = require("./compilerCache.cjs");
+var import_diagnostics = require("./diagnostics.cjs");
+var import_metroResolver = require("./metroResolver.cjs");
+const import_meta = {};
+const METRO_RECORD_CACHE_VERSION = 1;
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+const requireFromFrontend = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const compilerImplementationVersions = [
+	"@tamagui/metro-plugin",
+	"@tamagui/static",
+	"@tamagui/compiler-core"
+].map((packageName) => {
+	const { version } = requireFromFrontend(`${packageName}/package.json`);
+	return `${packageName}@${version}`;
+});
+function scanOptionsHash(options, projectGeneration, projectSourcesHash) {
+	return (0, import_compiler_core.contentHash)(JSON.stringify({
+		options,
+		projectGeneration,
+		projectSourcesHash
+	}));
+}
+const speculativeWalkExcludedDirs = /* @__PURE__ */ new Set([
+	"__tests__",
+	"e2e",
+	"flows",
+	"plugins",
+	"screenshots",
+	"scripts",
+	"test",
+	"test-results",
+	"tests"
+]);
+async function walkProjectSources(root) {
+	const inherited = [];
+	let ancestor = root;
+	while (!(0, import_node_fs.existsSync)((0, import_node_path.join)(ancestor, ".git"))) {
+		const parent = (0, import_node_path.dirname)(ancestor);
+		if (parent === ancestor) break;
+		inherited.unshift(parent);
+		ancestor = parent;
+	}
+	const rootScopes = [];
+	for (const dir of inherited) {
+		const source = await (0, import_promises.readFile)((0, import_node_path.join)(dir, ".gitignore"), "utf8").catch(() => null);
+		if (source) rootScopes.push({
+			dir,
+			matcher: (0, import_ignore.default)().add(source)
+		});
+	}
+	const found = [];
+	const stack = [{
+		dir: root,
+		scopes: rootScopes
+	}];
+	while (stack.length) {
+		const { dir, scopes } = stack.pop();
+		let entries;
+		try {
+			entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		let active = scopes;
+		if (entries.some((entry) => entry.isFile() && entry.name === ".gitignore")) {
+			const source = await (0, import_promises.readFile)((0, import_node_path.join)(dir, ".gitignore"), "utf8").catch(() => null);
+			if (source) active = [...scopes, {
+				dir,
+				matcher: (0, import_ignore.default)().add(source)
+			}];
+		}
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+			const isDirectory = entry.isDirectory();
+			if (isDirectory && speculativeWalkExcludedDirs.has(entry.name)) continue;
+			if (!isDirectory && !(entry.isFile() && (0, import_metroResolver.isCompilerSourceFile)(entry.name))) continue;
+			if (!isDirectory && (/(?:^|[-.])(?:probe|run|spec|tests?)(?:[-.]|$)/i.test(entry.name) || /\.(?:build|config|workspace)\.[cm]?[jt]sx?$/.test(entry.name))) {
+				continue;
+			}
+			const path = (0, import_node_path.join)(dir, entry.name);
+			let ignored = false;
+			for (const scope of active) {
+				const relativePath = (0, import_node_path.relative)(scope.dir, path);
+				if (!relativePath || relativePath.startsWith("..")) continue;
+				const candidate = relativePath.split(import_node_path.sep).join("/") + (isDirectory ? "/" : "");
+				if (scope.matcher.ignores(candidate)) {
+					ignored = true;
+					break;
+				}
+			}
+			if (ignored) continue;
+			if (isDirectory) stack.push({
+				dir: path,
+				scopes: active
+			});
+			else found.push(path);
+		}
+	}
+	return found.sort(compareCodeUnits);
+}
+function compilerTarget(platform) {
+	return platform === "web" ? "web" : "native";
+}
+function retainsLiveGraph(options) {
+	return options.dev && options.hot;
+}
+var MetroCompilerFrontend = class {
+	constructor(config) {
+		this.config = config;
+		this.#cacheBaseRoot = config.cacheRoot ?? (0, import_compilerCache.defaultMetroCompilerCacheRoot)(config.projectRoot);
+		this.#resolver = (0, import_metroResolver.createMetroCompilerResolver)(config);
+	}
+	config;
+	#cacheBaseRoot;
+	#entries = /* @__PURE__ */ new Map();
+	#records = /* @__PURE__ */ new Map();
+	#watchers = /* @__PURE__ */ new Map();
+	#resolver;
+	#graph = null;
+	#host = null;
+	#projectGeneration = null;
+	#publishedGeneration = null;
+	#scanOptions = null;
+	#scanOptionsHash = null;
+	#operationQueue = Promise.resolve();
+	#tamaguiConfig = null;
+	#zeroEntryGraph = null;
+	#planKeys = /* @__PURE__ */ new Map();
+	#recordCache = null;
+	#recordCacheIdentity = null;
+	#planCache = null;
+	#planCacheStamp = null;
+	get metroResolverVersion() {
+		return this.#resolver.version;
+	}
+	/**
+	* Per-file cache accounting for the last scan. The point of these caches is
+	* that one edited module leaves every other module's entry valid, and this is
+	* how that is observed rather than assumed.
+	*/
+	get compileCacheStats() {
+		const empty = {
+			hits: 0,
+			misses: 0,
+			writes: 0
+		};
+		return {
+			plans: this.#planCache?.stats ?? empty,
+			records: this.#recordCache?.stats ?? empty
+		};
+	}
+	cacheRootFor(platform) {
+		return (0, import_node_path.join)(this.#cacheBaseRoot, platform ?? "default");
+	}
+	scan(options) {
+		return this.#enqueue(() => this.#scan(options));
+	}
+	async #scan(options, preparedProject, preparedProjectSources) {
+		this.#scanOptions = options;
+		this.#publishedGeneration = null;
+		const diagnostics = [];
+		const entryRoots = (await Promise.all(options.entryFiles.map((path) => (0, import_promises.realpath)((0, import_node_path.resolve)(this.config.projectRoot, path))))).sort(compareCodeUnits);
+		const compilerProject = preparedProject ?? await this.#loadCompilerProject(options, entryRoots[0], diagnostics);
+		this.#projectGeneration = compilerProject.generation;
+		const projectSources = preparedProjectSources ?? await walkProjectSources(this.config.projectRoot);
+		const projectSourcesHash = (0, import_compiler_core.contentHash)(JSON.stringify(projectSources));
+		this.#scanOptionsHash = scanOptionsHash(options, compilerProject.generation, projectSourcesHash);
+		this.#installCaches(options, compilerProject, projectSourcesHash);
+		const speculativeRoots = /* @__PURE__ */ new Set();
+		for (const file of projectSources) {
+			try {
+				const id = await (0, import_promises.realpath)(file);
+				if (!entryRoots.includes(id)) speculativeRoots.add(id);
+			} catch {}
+		}
+		const roots = [.../* @__PURE__ */ new Set([...entryRoots, ...speculativeRoots])].sort(compareCodeUnits);
+		const queue = [...roots];
+		const queued = new Set(queue);
+		for (const watcher of this.#watchers.values()) watcher.close();
+		this.#watchers.clear();
+		this.#records.clear();
+		while (queue.length) {
+			const path = queue.shift();
+			try {
+				const record = await this.#compileRecord(path, options, diagnostics);
+				this.#records.set(record.input.id, record);
+				for (const dependency of record.input.imports) {
+					if (dependency.external || !(0, import_metroResolver.isCompilerSourceFile)(dependency.resolvedId) || queued.has(dependency.resolvedId)) {
+						continue;
+					}
+					queued.add(dependency.resolvedId);
+					queue.push(dependency.resolvedId);
+				}
+			} catch (error) {
+				if (speculativeRoots.has(path)) continue;
+				const diagnostic = (0, import_diagnostics.metroDiagnostic)("metro/transform-failed", `Failed to compile ${path}: ${error instanceof Error ? error.message : String(error)}`, { moduleId: path });
+				diagnostics.push(diagnostic);
+				this.#report(diagnostic);
+			}
+		}
+		if (!compilerProject.projectInfo.tamaguiConfig || !compilerProject.projectInfo.components) {
+			throw new Error("Metro compiler project has no Tamagui config or components");
+		}
+		this.#tamaguiConfig = compilerProject.projectInfo.tamaguiConfig;
+		this.#entries.clear();
+		const unplanned = await this.#restorePlans(options);
+		const zero = this.config.zero;
+		this.#graph = null;
+		this.#host = null;
+		if (unplanned.length || retainsLiveGraph(options)) {
+			this.#graph = new import_compiler_core.ProjectGraph(import_compiler_core.yukuFactory, { modules: [...this.#records.values()].map(({ input }) => input) });
+			this.#host = (0, import_static.createTamaguiCompilerHost)({
+				target: compilerTarget(options.platform),
+				tamaguiConfig: compilerProject.projectInfo.tamaguiConfig,
+				components: compilerProject.projectInfo.components,
+				componentModules: compilerProject.componentModules.map(({ moduleName, id }) => ({
+					moduleName,
+					resolvedId: id
+				})),
+				disablePartialExtraction: compilerProject.disablePartialExtraction,
+				experimentalNativeFastPath: compilerProject.experimentalNativeFastPath,
+				zeroRuntime: compilerProject.zeroRuntime
+			});
+			if (zero) {
+				if (zero.isEnforcing) {
+					import_static.default.assertZeroConfigDrivers(compilerProject.projectInfo.tamaguiConfig);
+				}
+				zero.plansRestoredFromCache = false;
+				zero.configCSS = compilerProject.projectInfo.tamaguiConfig.getCSS?.() ?? "";
+				zero.artifact.clearGraphs();
+				zero.bridges.clear();
+				zero.violations.length = 0;
+				zero.transformed.clear();
+				zero.erasedExports.clear();
+				this.#zeroEntryGraph = this.#reachableFrom(entryRoots.map(import_compiler_core.resolvedModuleId));
+			}
+			for (const id of unplanned) this.#refreshEntry(id);
+			await this.#storePlans(unplanned);
+		}
+		if (zero) {
+			import_static.default.writeZeroViolationReport(zero.resolved.outDir, "metro-zero", {
+				integration: "metro-web",
+				mode: zero.isEnforcing ? "enforce" : "report",
+				violations: zero.violations
+			});
+			if (zero.isEnforcing && zero.violations.length) {
+				throw new Error(import_static.default.formatZeroViolations(zero.violations));
+			}
+		}
+		const totalFound = [...this.#entries.values()].reduce((sum, entry) => sum + entry.plan.stats.found, 0);
+		if (this.#entries.size > 0 && totalFound === 0) {
+			const componentNames = compilerProject.componentModules.map(({ moduleName }) => moduleName);
+			const cjsComponentImporters = [...this.#records.values()].filter((record) => record.requireSpecifiers.some((specifier) => componentNames.some((name) => specifier === name || specifier.startsWith(`${name}/`)))).length;
+			if (cjsComponentImporters > 0) {
+				const diagnostic = (0, import_diagnostics.metroDiagnostic)("metro/no-linked-components", `The Tamagui compiler linked 0 components across ${this.#entries.size} modules even though ${cjsComponentImporters} module(s) reference ${componentNames.join(", ")} through require() calls. Metro compiled modules to CommonJS before the compiler could analyze them, so component imports cannot be linked and nothing will be optimized. Enable experimentalImportSupport in your transformer's getTransformOptions (Expo enables it by default) to restore Tamagui compilation.`);
+				diagnostics.push(diagnostic);
+				this.#report(diagnostic);
+			}
+		}
+		const generation = await this.#publish(options.platform);
+		const moduleIds = [...this.#records.keys()].sort(compareCodeUnits);
+		if (this.config.watch !== false && retainsLiveGraph(options)) {
+			this.#installWatchers();
+		} else if (!retainsLiveGraph(options)) {
+			this.#releaseGraph();
+		}
+		return {
+			generation,
+			moduleIds,
+			diagnostics
+		};
+	}
+	ensureValidCache(options) {
+		return this.#enqueue(() => this.#ensureValidCache(options));
+	}
+	async #ensureValidCache(options) {
+		const diagnostics = [];
+		const firstEntry = options.entryFiles[0];
+		const importer = firstEntry ? await (0, import_promises.realpath)((0, import_node_path.resolve)(this.config.projectRoot, firstEntry)) : this.config.projectRoot;
+		const compilerProject = await this.#loadCompilerProject(options, importer, diagnostics);
+		const cache = new import_compilerCache.MetroCompilerCache(this.cacheRootFor(options.platform));
+		const validation = await cache.validate();
+		const projectSources = await walkProjectSources(this.config.projectRoot);
+		const optionsHash = scanOptionsHash(options, compilerProject.generation, (0, import_compiler_core.contentHash)(JSON.stringify(projectSources)));
+		if (validation.valid && validation.generation && validation.optionsHash === optionsHash && await this.#sourcesAreFresh(validation.sourceHashes) && (!retainsLiveGraph(options) && !this.#graph || this.#publishedGeneration && this.#scanOptionsHash === optionsHash) && await this.#rehydrateZeroCSS(cache, validation.generation)) {
+			this.#publishedGeneration = validation.generation;
+			this.#scanOptions = options;
+			this.#scanOptionsHash = optionsHash;
+			this.#projectGeneration = compilerProject.generation;
+			return {
+				generation: validation.generation,
+				moduleIds: validation.moduleIds,
+				diagnostics
+			};
+		}
+		for (const diagnostic of validation.diagnostics) this.#report(diagnostic);
+		await cache.discardManifest();
+		return await this.#scan(options, compilerProject, projectSources);
+	}
+	async updateFile(path) {
+		let result = {
+			changed: false,
+			affectedIds: [],
+			generation: null
+		};
+		return this.#enqueue(async () => {
+			const graph = this.#graph;
+			const options = this.#scanOptions;
+			if (!graph || !options) return result;
+			let record;
+			const diagnostics = [];
+			try {
+				record = await this.#compileRecord(path, options, diagnostics);
+			} catch (error) {
+				if (error.code === "ENOENT") {
+					const id = (0, import_compiler_core.resolvedModuleId)((0, import_node_path.resolve)(path));
+					const invalidation2 = graph.removeModule(id);
+					this.#watchers.get(id)?.close();
+					this.#watchers.delete(id);
+					this.#records.delete(id);
+					this.#entries.delete(id);
+					for (const affected of invalidation2.invalidatedIds) {
+						if (affected !== id) this.#refreshEntry(affected);
+					}
+					const generation2 = await this.#publish(options.platform);
+					result = {
+						changed: invalidation2.changed,
+						affectedIds: invalidation2.invalidatedIds,
+						generation: generation2
+					};
+					return result;
+				}
+				const diagnostic = (0, import_diagnostics.metroDiagnostic)("metro/transform-failed", `Failed to update ${path}: ${error instanceof Error ? error.message : String(error)}`, { moduleId: path });
+				this.#report(diagnostic);
+				return result;
+			}
+			for (const dependency of record.input.imports) {
+				if (dependency.external || !(0, import_metroResolver.isCompilerSourceFile)(dependency.resolvedId) || this.#records.has(dependency.resolvedId)) {
+					continue;
+				}
+				await this.#addDependency(dependency.resolvedId, options, diagnostics);
+			}
+			this.#records.set(record.input.id, record);
+			const invalidation = graph.updateModule(record.input);
+			for (const affected of invalidation.invalidatedIds) this.#refreshEntry(affected);
+			const generation = invalidation.changed ? await this.#publish(options.platform) : null;
+			result = {
+				changed: invalidation.changed,
+				affectedIds: invalidation.invalidatedIds,
+				generation
+			};
+			if (this.config.watch !== false && retainsLiveGraph(options)) {
+				this.#watchModule(record.input.id);
+			}
+			return result;
+		});
+	}
+	/** A published plan only applies while every recorded module source is unchanged. */
+	async #sourcesAreFresh(sourceHashes) {
+		const checks = Object.entries(sourceHashes).map(async ([moduleId, sourceHash]) => {
+			try {
+				return (0, import_compiler_core.contentHash)(await (0, import_promises.readFile)(moduleId, "utf8")) === sourceHash;
+			} catch {
+				return false;
+			}
+		});
+		return (await Promise.all(checks)).every(Boolean);
+	}
+	#enqueue(operation) {
+		const queued = this.#operationQueue.then(operation);
+		this.#operationQueue = queued.then(() => void 0, () => void 0);
+		return queued;
+	}
+	close() {
+		return this.#enqueue(async () => {
+			this.#releaseGraph();
+		});
+	}
+	#releaseGraph() {
+		for (const watcher of this.#watchers.values()) watcher.close();
+		this.#watchers.clear();
+		this.#entries.clear();
+		this.#records.clear();
+		this.#planKeys.clear();
+		this.#graph = null;
+		this.#host = null;
+		this.#projectGeneration = null;
+	}
+	async #loadCompilerProject(options, importer, diagnostics) {
+		const target = compilerTarget(options.platform);
+		if (this.config.loadCompilerProject) {
+			return await this.config.loadCompilerProject(target, options.platform);
+		}
+		return import_static.default.loadCompilerProject({
+			root: this.config.projectRoot,
+			target,
+			options: this.config.tamaguiOptions ?? {},
+			hostVersions: compilerImplementationVersions,
+			missingProjectMessage: "Unable to load the Tamagui project for Metro compilation",
+			generation: (projectInfo, componentModules, normalizedOptions) => {
+				return (0, import_compiler_core.contentHash)(JSON.stringify({
+					cacheVersion: import_compilerCache.METRO_COMPILER_CACHE_VERSION,
+					compilerImplementationVersions,
+					componentModules,
+					configCss: projectInfo.tamaguiConfig?.getCSS?.() ?? "",
+					disablePartialExtraction: !!normalizedOptions.disablePartialExtraction,
+					experimentalNativeFastPath: target === "native" && normalizedOptions.experimental?.nativeFastPath === true,
+					target,
+					zeroRuntime: !!this.config.zero
+				}));
+			},
+			resolveComponents: async (moduleNames) => {
+				const componentModules = [];
+				for (const moduleName of moduleNames) {
+					try {
+						const resolution = this.#resolver.resolve(importer, {
+							specifier: moduleName,
+							isESMImport: true
+						}, options.platform);
+						if (!resolution) continue;
+						componentModules.push({
+							moduleName,
+							id: resolution.resolvedId
+						});
+					} catch (error) {
+						const diagnostic = (0, import_diagnostics.metroDiagnostic)("metro/resolve-failed", `Failed to resolve compiler component ${moduleName}: ${error instanceof Error ? error.message : String(error)}`, {
+							moduleId: importer,
+							dependency: moduleName
+						});
+						diagnostics.push(diagnostic);
+						this.#report(diagnostic);
+					}
+				}
+				return componentModules;
+			}
+		});
+	}
+	async #compileRecord(rawPath, options, diagnostics) {
+		const path = await (0, import_promises.realpath)((0, import_node_path.resolve)(rawPath));
+		const source = await (0, import_promises.readFile)(path, "utf8");
+		const sourceHash = (0, import_compiler_core.contentHash)(source);
+		const id = (0, import_compiler_core.resolvedModuleId)(path);
+		const cache = this.#recordCache;
+		const identity = this.#recordCacheIdentity;
+		const key = cache && identity ? (0, import_compiler_core.contentHash)(`${identity}\0${sourceHash}`) : null;
+		if (cache && key) {
+			const cached = await cache.read(key, (value) => {
+				const entry = value;
+				return entry?.schemaVersion === METRO_RECORD_CACHE_VERSION && entry.sourceHash === sourceHash && Array.isArray(entry.imports) && Array.isArray(entry.requireSpecifiers) && Array.isArray(entry.diagnostics) ? entry : null;
+			});
+			if (cached) {
+				for (const diagnostic of cached.diagnostics) {
+					diagnostics.push(diagnostic);
+					this.#report(diagnostic);
+				}
+				return {
+					input: {
+						id,
+						source,
+						imports: cached.imports
+					},
+					sourceHash,
+					requireSpecifiers: cached.requireSpecifiers
+				};
+			}
+		}
+		const args = this.#babelArgs(path, source, options);
+		const compiled = await (0, import_babel.compileWithUserBabel)(this.config.originalBabelTransformerPath, args);
+		const imports = [];
+		const requireSpecifiers = [];
+		const recordDiagnostics = [];
+		for (const dependency of (0, import_metroResolver.moduleSpecifiersFromAst)(compiled.result.ast)) {
+			if (!dependency.isESMImport) requireSpecifiers.push(dependency.specifier);
+			try {
+				const resolution = this.#resolver.resolve(path, dependency, options.platform);
+				if (!resolution) continue;
+				imports.push({
+					specifier: resolution.specifier,
+					resolvedId: (0, import_compiler_core.resolvedModuleId)(resolution.resolvedId),
+					external: resolution.external
+				});
+			} catch (error) {
+				recordDiagnostics.push((0, import_diagnostics.metroDiagnostic)("metro/resolve-failed", `Failed to resolve ${dependency.specifier} from ${path}: ${error instanceof Error ? error.message : String(error)}`, {
+					moduleId: path,
+					dependency: dependency.specifier
+				}));
+			}
+		}
+		for (const diagnostic of recordDiagnostics) {
+			diagnostics.push(diagnostic);
+			this.#report(diagnostic);
+		}
+		if (cache && key) {
+			await cache.write(key, {
+				schemaVersion: METRO_RECORD_CACHE_VERSION,
+				sourceHash,
+				imports,
+				requireSpecifiers,
+				diagnostics: recordDiagnostics
+			});
+		}
+		return {
+			input: {
+				id,
+				source,
+				imports
+			},
+			sourceHash,
+			requireSpecifiers
+		};
+	}
+	#babelOptions(options) {
+		const transformer = this.config.transformer ?? {};
+		return {
+			...options.transform,
+			dev: options.dev,
+			hot: options.hot,
+			platform: options.platform,
+			projectRoot: this.config.projectRoot,
+			enableBabelRCLookup: transformer.enableBabelRCLookup ?? true,
+			enableBabelRuntime: transformer.enableBabelRuntime ?? true,
+			hermesParser: transformer.hermesParser ?? false,
+			publicPath: transformer.publicPath ?? "/assets"
+		};
+	}
+	#babelArgs(filename, src, options) {
+		return {
+			filename,
+			src,
+			plugins: [],
+			options: this.#babelOptions(options)
+		};
+	}
+	async #addDependency(id, options, diagnostics, visiting = /* @__PURE__ */ new Set()) {
+		if (this.#records.has(id) || visiting.has(id)) return;
+		visiting.add(id);
+		try {
+			const record = await this.#compileRecord(id, options, diagnostics);
+			for (const dependency of record.input.imports) {
+				if (!dependency.external && (0, import_metroResolver.isCompilerSourceFile)(dependency.resolvedId)) {
+					await this.#addDependency(dependency.resolvedId, options, diagnostics, visiting);
+				}
+			}
+			this.#records.set(id, record);
+			const invalidation = this.#graph?.updateModule(record.input);
+			for (const affected of invalidation?.invalidatedIds ?? [id]) {
+				this.#refreshEntry(affected);
+			}
+			if (this.config.watch !== false && this.#scanOptions && retainsLiveGraph(this.#scanOptions)) {
+				this.#watchModule(id);
+			}
+		} finally {
+			visiting.delete(id);
+		}
+	}
+	#refreshEntry(id) {
+		const graph = this.#graph;
+		const host = this.#host;
+		const record = this.#records.get(id);
+		if (!graph || !host || !record || !this.#scanOptions || !this.#projectGeneration) return;
+		const target = compilerTarget(this.#scanOptions.platform);
+		const plan = (0, import_compiler_core.lowerModule)({
+			module: (0, import_compiler_core.materializeModule)(graph, id),
+			source: record.input.source,
+			target,
+			host,
+			options: { projectGeneration: this.#projectGeneration }
+		});
+		const zeroPlan = this.#zeroPlanFor(id, record.input.source, plan);
+		this.#entries.set(id, this.#entryFor(id, record, zeroPlan ?? plan));
+	}
+	/**
+	* One plan becomes one cache entry the same way whether the plan was just
+	* lowered or read back off disk, so a restored build reports exactly the
+	* diagnostics a fresh one did.
+	*/
+	#entryFor(id, record, plan) {
+		return {
+			schemaVersion: import_compilerCache.METRO_COMPILER_CACHE_VERSION,
+			moduleId: id,
+			sourceHash: record.sourceHash,
+			plan,
+			diagnostics: plan.diagnostics.map(({ code, message, dependencyId, span, component }) => {
+				const { line, column } = import_static.default.offsetToLineColumn(record.input.source, span.start);
+				return (0, import_diagnostics.metroDiagnostic)(code.startsWith("linked/") ? "metro/resolve-failed" : "metro/transform-failed", message, {
+					moduleId: id,
+					dependency: dependencyId,
+					span,
+					line,
+					column,
+					component
+				});
+			})
+		};
+	}
+	/**
+	* Both per-file caches for this scan. A project with no content stamp gets
+	* neither: a stamp that cannot see a config change would serve styles built
+	* against the old config, so the answer is no cache rather than a partial one.
+	*
+	* Zero builds opt out of the plan cache because a zero plan is produced
+	* alongside side effects that do not travel in the plan - the CSS artifact,
+	* the bridge manifest, the violation list - so replaying one module's plan
+	* without them would emit an artifact missing its rules.
+	*/
+	#installCaches(options, project, projectSourcesHash) {
+		const platform = options.platform ?? "default";
+		const root = (0, import_compiler_core.defaultPlanCacheRoot)(this.config.projectRoot, platform);
+		this.#recordCache = new import_compiler_core.JsonFileCache((0, import_node_path.join)(root, "records"), METRO_RECORD_CACHE_VERSION);
+		this.#recordCacheIdentity = (0, import_compiler_core.contentHash)((0, import_compiler_core.stableStringify)({
+			schema: METRO_RECORD_CACHE_VERSION,
+			resolver: this.#resolver.version,
+			babel: (0, import_babel.userBabelCacheKey)(this.config.originalBabelTransformerPath),
+			projectSourcesHash,
+			platform,
+			transform: this.#babelOptions(options)
+		}));
+		const stamp = project.cacheStamp;
+		const usePlanCache = typeof stamp === "string" && stamp !== "" && !this.config.zero;
+		this.#planCache = usePlanCache ? new import_compiler_core.ModulePlanCache((0, import_node_path.join)(root, "plans")) : null;
+		this.#planCacheStamp = usePlanCache ? stamp : null;
+	}
+	/**
+	* Fills `#entries` from disk for every module whose whole compile input is
+	* unchanged, and returns the ids that still have to be compiled. This is the
+	* per-file property: one edited module leaves every other module's entry
+	* valid, where the plan manifest would have discarded all of them.
+	*/
+	async #restorePlans(options) {
+		this.#planKeys.clear();
+		const cache = this.#planCache;
+		const stamp = this.#planCacheStamp;
+		if (!cache || !stamp) return [...this.#records.keys()].sort(compareCodeUnits);
+		const target = compilerTarget(options.platform);
+		const identity = {
+			stamp,
+			target,
+			structuralPassHash: `${target}-noop-v1`
+		};
+		const nodes = /* @__PURE__ */ new Map();
+		const lookup = (id) => {
+			let node = nodes.get(id);
+			if (node === void 0) {
+				const record = this.#records.get(id);
+				node = record ? (0, import_compiler_core.moduleClosureNode)(record.input) : null;
+				nodes.set(id, node);
+			}
+			return node;
+		};
+		const memo = /* @__PURE__ */ new Map();
+		const unplanned = [];
+		for (const id of [...this.#records.keys()].sort(compareCodeUnits)) {
+			const record = this.#records.get(id);
+			const digest = (0, import_compiler_core.moduleClosureDigest)(id, lookup, memo);
+			const key = digest && (0, import_compiler_core.planCacheKey)(identity, id, digest);
+			const entry = key && digest ? await cache.read(key, id, digest) : null;
+			if (entry) {
+				this.#entries.set(id, this.#entryFor(id, record, entry.plan));
+				continue;
+			}
+			if (key && digest) this.#planKeys.set(id, {
+				key,
+				digest
+			});
+			unplanned.push(id);
+		}
+		return unplanned;
+	}
+	async #storePlans(ids) {
+		const cache = this.#planCache;
+		if (!cache) return;
+		const pending = ids.flatMap((id) => {
+			const entry = this.#entries.get(id);
+			const key = this.#planKeys.get(id);
+			return entry && key ? [{
+				id,
+				entry,
+				key
+			}] : [];
+		});
+		for (let index = 0; index < pending.length; index += 32) {
+			await Promise.all(pending.slice(index, index + 32).map(({ id, entry, key }) => cache.write(key.key, {
+				schemaVersion: import_compiler_core.PLAN_CACHE_SCHEMA_VERSION,
+				moduleId: id,
+				closureDigest: key.digest,
+				plan: entry.plan
+			})));
+		}
+	}
+	/** Modules reachable from the bundle's entry, over the frontend's own graph. */
+	#reachableFrom(roots) {
+		const reached = /* @__PURE__ */ new Set();
+		const queue = [...roots];
+		while (queue.length) {
+			const id = queue.pop();
+			if (reached.has(id)) continue;
+			reached.add(id);
+			for (const dependency of this.#records.get(id)?.input.imports ?? []) {
+				if (!dependency.external) queue.push(dependency.resolvedId);
+			}
+		}
+		return reached;
+	}
+	/**
+	* The zero transform for one module, returning a plan whose edits also carry
+	* the static Theme lowering, the island bridge, and reference erasure.
+	*/
+	#zeroPlanFor(id, source, plan) {
+		const zero = this.config.zero;
+		const config = this.#tamaguiConfig;
+		if (!zero || !config) return null;
+		if (zero.islandBuild) {
+			zero.artifact.setIslandModuleCSS(zero.islandBuild, id, plan.css);
+			return null;
+		}
+		if (this.#zeroEntryGraph && !this.#zeroEntryGraph.has(id)) return null;
+		const relativePath = (0, import_node_path.relative)(this.config.projectRoot, id);
+		if (relativePath === "" || relativePath.startsWith("..") || relativePath.split(/[\\/]/).includes("node_modules")) {
+			return null;
+		}
+		const result = import_static.default.transformZeroModule({
+			mode: zero.isEnforcing ? "enforce" : "report",
+			id,
+			root: this.config.projectRoot,
+			source,
+			plan,
+			config,
+			isTamaguiSpecifier: (specifier) => specifier === "tamagui" || specifier.startsWith("@tamagui/"),
+			resolveIslandLoader: (specifier) => {
+				const islandId = zero.loaderIds.get((0, import_zeroRuntime.zeroModuleKey)((0, import_node_path.resolve)(id, "..", specifier)));
+				return islandId ? { islandId } : null;
+			},
+			resolveIslandModule: (specifier) => zero.islandModuleIds.get((0, import_zeroRuntime.zeroModuleKey)((0, import_node_path.resolve)(id, "..", specifier))) ?? null
+		});
+		zero.transformed.add(id);
+		if (result.erased.exports.length) {
+			zero.erasedExports.set(id, result.erased.exports);
+		}
+		for (const violation of result.violations) {
+			const { line, column } = import_static.default.offsetToLineColumn(source, violation.span.start);
+			zero.violations.push({
+				file: relativePath,
+				line,
+				column,
+				rule: violation.rule,
+				code: violation.code,
+				component: violation.component,
+				message: violation.message
+			});
+		}
+		if (result.violations.length || !zero.isEnforcing) return null;
+		import_static.default.mergeIslandBridges(zero.bridges, result.bridges);
+		for (const [identifier, rules] of result.bridgeCSS) {
+			zero.artifact.setBridgeRules(identifier, rules);
+		}
+		zero.artifact.setZeroModuleCSS(id, plan.css);
+		return {
+			...plan,
+			edits: [...plan.edits, ...result.edits]
+		};
+	}
+	async #publish(platform) {
+		const cache = new import_compilerCache.MetroCompilerCache(this.cacheRootFor(platform));
+		const generation = await cache.publish(platform, [...this.#entries.values()], this.#scanOptionsHash ?? "");
+		const zero = this.config.zero;
+		if (zero && !zero.islandBuild) {
+			await cache.publishZeroCSS({
+				schemaVersion: import_compilerCache.METRO_COMPILER_CACHE_VERSION,
+				generation,
+				configCSS: zero.configCSS,
+				zeroModuleCSS: Object.fromEntries(zero.artifact.zeroModuleEntries()),
+				bridgeCSS: Object.fromEntries(zero.artifact.bridgeEntries()),
+				bridges: Object.fromEntries(zero.bridges)
+			});
+		}
+		this.#publishedGeneration = generation;
+		return generation;
+	}
+	/**
+	* Restores the zero build's CSS side effects from the sidecar published with
+	* this plan generation. Returns false when there is nothing trustworthy to
+	* restore, which sends the caller to a full scan.
+	*/
+	async #rehydrateZeroCSS(cache, generation) {
+		const zero = this.config.zero;
+		if (!zero || zero.islandBuild) return true;
+		const sidecar = await cache.readZeroCSS(generation);
+		if (!sidecar) return false;
+		zero.artifact.clearGraphs();
+		zero.bridges.clear();
+		zero.violations.length = 0;
+		zero.configCSS = sidecar.configCSS;
+		for (const [moduleId, css] of Object.entries(sidecar.zeroModuleCSS)) {
+			zero.artifact.setZeroModuleCSS(moduleId, css);
+		}
+		for (const [bridgeId, css] of Object.entries(sidecar.bridgeCSS)) {
+			zero.artifact.setBridgeRules(bridgeId, css);
+		}
+		for (const [islandId, bridges] of Object.entries(sidecar.bridges)) {
+			zero.bridges.set(islandId, bridges);
+		}
+		zero.plansRestoredFromCache = true;
+		return true;
+	}
+	#installWatchers() {
+		for (const id of this.#records.keys()) this.#watchModule(id);
+	}
+	#watchModule(id) {
+		if (this.#watchers.has(id)) return;
+		try {
+			const watcher = (0, import_node_fs.watch)(id, { persistent: false }, () => {
+				void this.updateFile(id);
+			});
+			watcher.unref();
+			this.#watchers.set(id, watcher);
+		} catch {}
+	}
+	#report(diagnostic) {
+		this.config.reportDiagnostic?.(diagnostic);
+	}
+};
+function describeMetroCompilerRoot(projectRoot, moduleId) {
+	const path = (0, import_node_path.relative)(projectRoot, moduleId);
+	return path.startsWith("..") ? (0, import_node_path.basename)(moduleId) : path;
+}