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

package/dist/esm/frontend.mjs

@@ -0,0 +1,855 @@
+import { existsSync, watch } from "node:fs";
+import { readFile, readdir, realpath } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import ignore from "ignore";
+import { JsonFileCache, ModulePlanCache, PLAN_CACHE_SCHEMA_VERSION, ProjectGraph, contentHash, createExternalClosureLookup, defaultPlanCacheRoot, isTamaguiSpecifier, lowerModule, materializeModule, moduleClosureDigest, moduleClosureNode, planCacheKey, resolvedModuleId, stableStringify, yukuFactory } from "@tamagui/compiler-core";
+import Static, { ComponentDiscovery, createComponentRegistry, createTamaguiCompilerHost } from "@tamagui/static";
+import { compileWithUserBabel, userBabelCacheKey } from "./babel.mjs";
+import { zeroModuleKey } from "./zeroRuntime.mjs";
+import { METRO_COMPILER_CACHE_VERSION, MetroCompilerCache, defaultMetroCompilerCacheRoot } from "./compilerCache.mjs";
+import { metroDiagnostic } from "./diagnostics.mjs";
+import { createMetroCompilerResolver, isCompilerSourceFile, moduleSpecifiersFromAst } from "./metroResolver.mjs";
+
+const METRO_RECORD_CACHE_VERSION = 2;
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+const requireFromFrontend = 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 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 (!existsSync(join(ancestor, ".git"))) {
+		const parent = dirname(ancestor);
+		if (parent === ancestor) break;
+		inherited.unshift(parent);
+		ancestor = parent;
+	}
+	const rootScopes = [];
+	for (const dir of inherited) {
+		const source = await readFile(join(dir, ".gitignore"), "utf8").catch(() => null);
+		if (source) rootScopes.push({
+			dir,
+			matcher: ignore().add(source)
+		});
+	}
+	const found = [];
+	const stack = [{
+		dir: root,
+		scopes: rootScopes
+	}];
+	while (stack.length) {
+		const { dir, scopes } = stack.pop();
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		let active = scopes;
+		if (entries.some((entry) => entry.isFile() && entry.name === ".gitignore")) {
+			const source = await readFile(join(dir, ".gitignore"), "utf8").catch(() => null);
+			if (source) active = [...scopes, {
+				dir,
+				matcher: ignore().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() && 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 = join(dir, entry.name);
+			let ignored = false;
+			for (const scope of active) {
+				const relativePath = relative(scope.dir, path);
+				if (!relativePath || relativePath.startsWith("..")) continue;
+				const candidate = relativePath.split(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 ?? defaultMetroCompilerCacheRoot(config.projectRoot);
+		this.#resolver = createMetroCompilerResolver(config);
+	}
+	config;
+	#cacheBaseRoot;
+	#entries = /* @__PURE__ */ new Map();
+	#records = /* @__PURE__ */ new Map();
+	#watchers = /* @__PURE__ */ new Map();
+	#resolver;
+	#graph = null;
+	#host = null;
+	#registry = null;
+	#discovery = new ComponentDiscovery();
+	#externalClosure = createExternalClosureLookup();
+	#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 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) => realpath(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 = 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 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 || !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 = 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 ProjectGraph(yukuFactory, { modules: [...this.#records.values()].map(({ input }) => input) });
+			const componentModules = compilerProject.componentModules.map(({ moduleName, id }) => ({
+				moduleName,
+				resolvedId: id
+			}));
+			this.#discovery.clear();
+			this.#registry = createComponentRegistry(compilerProject.projectInfo.components, componentModules);
+			this.#host = createTamaguiCompilerHost({
+				target: compilerTarget(options.platform),
+				tamaguiConfig: compilerProject.projectInfo.tamaguiConfig,
+				components: compilerProject.projectInfo.components,
+				componentModules,
+				registry: this.#registry,
+				disablePartialExtraction: compilerProject.disablePartialExtraction,
+				experimentalNativeFastPath: compilerProject.experimentalNativeFastPath,
+				zeroRuntime: compilerProject.zeroRuntime
+			});
+			if (zero) {
+				if (zero.isEnforcing) {
+					Static.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(resolvedModuleId));
+			}
+			for (const id of unplanned) await this.#refreshEntry(id);
+			await this.#storePlans(unplanned);
+		}
+		if (zero) {
+			Static.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(Static.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 = 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 realpath(resolve(this.config.projectRoot, firstEntry)) : this.config.projectRoot;
+		const compilerProject = await this.#loadCompilerProject(options, importer, diagnostics);
+		const cache = new MetroCompilerCache(this.cacheRootFor(options.platform));
+		const validation = await cache.validate();
+		const projectSources = await walkProjectSources(this.config.projectRoot);
+		const optionsHash = scanOptionsHash(options, compilerProject.generation, 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 = resolvedModuleId(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) await this.#refreshEntry(affected);
+					}
+					const generation2 = await this.#publish(options.platform);
+					result = {
+						changed: invalidation2.changed,
+						affectedIds: invalidation2.invalidatedIds,
+						generation: generation2
+					};
+					return result;
+				}
+				const diagnostic = 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 || !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) await 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 contentHash(await 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.#registry = 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 Static.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 contentHash(JSON.stringify({
+					cacheVersion: 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 = 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 realpath(resolve(rawPath));
+		const source = await readFile(path, "utf8");
+		const sourceHash = contentHash(source);
+		const id = resolvedModuleId(path);
+		const cache = this.#recordCache;
+		const identity = this.#recordCacheIdentity;
+		const key = cache && identity ? contentHash(`${identity}\0${sourceHash}`) : null;
+		if (cache && key) {
+			const cached = await cache.read(key, (value) => {
+				const entry = value;
+				return entry?.schemaVersion === 2 && 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 compileWithUserBabel(this.config.originalBabelTransformerPath, args);
+		const imports = [];
+		const requireSpecifiers = [];
+		const recordDiagnostics = [];
+		for (const dependency of 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: resolvedModuleId(resolution.resolvedId),
+					external: resolution.external
+				});
+			} catch (error) {
+				recordDiagnostics.push(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: 2,
+				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 && 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]) {
+				await this.#refreshEntry(affected);
+			}
+			if (this.config.watch !== false && this.#scanOptions && retainsLiveGraph(this.#scanOptions)) {
+				this.#watchModule(id);
+			}
+		} finally {
+			visiting.delete(id);
+		}
+	}
+	async #refreshEntry(id) {
+		const graph = this.#graph;
+		const host = this.#host;
+		const registry = this.#registry;
+		const record = this.#records.get(id);
+		if (!graph || !host || !registry || !record || !this.#scanOptions || !this.#projectGeneration) {
+			return;
+		}
+		const target = compilerTarget(this.#scanOptions.platform);
+		const materialized = materializeModule(graph, id);
+		await this.#discovery.prepare(materialized, registry, ({ id: moduleId }) => Static.evaluateComponentModule({
+			...this.config.tamaguiOptions,
+			platform: target
+		}, moduleId));
+		const plan = lowerModule({
+			module: materialized,
+			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: METRO_COMPILER_CACHE_VERSION,
+			moduleId: id,
+			sourceHash: record.sourceHash,
+			plan,
+			diagnostics: plan.diagnostics.map(({ code, message, dependencyId, span, component }) => {
+				const { line, column } = Static.offsetToLineColumn(record.input.source, span.start);
+				return 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 = defaultPlanCacheRoot(this.config.projectRoot, platform);
+		this.#recordCache = new JsonFileCache(join(root, "records"), 2);
+		this.#recordCacheIdentity = contentHash(stableStringify({
+			schema: 2,
+			resolver: this.#resolver.version,
+			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 ModulePlanCache(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 ? moduleClosureNode(record.input, { includeExternal: true }) : this.#externalClosure(id);
+				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 = moduleClosureDigest(id, lookup, memo);
+			const key = digest && 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: 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 = relative(this.config.projectRoot, id);
+		if (relativePath === "" || relativePath.startsWith("..") || relativePath.split(/[\\/]/).includes("node_modules")) {
+			return null;
+		}
+		const result = Static.transformZeroModule({
+			mode: zero.isEnforcing ? "enforce" : "report",
+			id,
+			root: this.config.projectRoot,
+			source,
+			plan,
+			config,
+			isTamaguiSpecifier,
+			resolveIslandLoader: (specifier) => {
+				const islandId = zero.loaderIds.get(zeroModuleKey(resolve(id, "..", specifier)));
+				return islandId ? { islandId } : null;
+			},
+			resolveIslandModule: (specifier) => zero.islandModuleIds.get(zeroModuleKey(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 } = Static.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;
+		Static.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 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: 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 = 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 = relative(projectRoot, moduleId);
+	return path.startsWith("..") ? basename(moduleId) : path;
+}
+
+export { METRO_RECORD_CACHE_VERSION, MetroCompilerFrontend, describeMetroCompilerRoot };
+//# sourceMappingURL=frontend.mjs.map