@tamagui/cli 2.7.7 → 3.0.0-beta.1097.1

package/dist/build.cjs

@@ -5,36 +5,29 @@ 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
-  });
+	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;
+	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(
-// If the importer is in node compatibility mode or this is not an ESM
-// file that has been converted to a CommonJS file using a Babel-
-// compatible transform (i.e. "__esModule" has not been set), then set
-// "default" to the CommonJS "module.exports" for node compatibility.
-isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-  value: mod,
-  enumerable: true
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var build_exports = {};
 __export(build_exports, {
-  build: () => build,
-  insertCssImport: () => insertCssImport
+	build: () => build,
+	insertCssImport: () => insertCssImport
 });
 module.exports = __toCommonJS(build_exports);
 var import_static = require("@tamagui/static");
@@ -45,270 +38,424 @@ var import_node_path = require("node:path");
 var import_node_os = require("node:os");
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
+var import_node_module = require("node:module");
+var import_typescript = require("typescript");
+const import_meta = {};
+const cliVersion = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url)("@tamagui/cli/package.json").version;
 function insertCssImport(jsContent, cssImport) {
-  const directiveMatch = jsContent.match(/^(['"])use (client|server)\1;?\n?/);
-  if (directiveMatch) {
-    const directive = directiveMatch[0];
-    return `${directive}${cssImport}
+	const directiveMatch = jsContent.match(/^(['"])use (client|server)\1;?\n?/);
+	if (directiveMatch) {
+		const directive = directiveMatch[0];
+		return `${directive}${cssImport}
 ${jsContent.slice(directive.length)}`;
-  }
-  return `${cssImport}
+	}
+	return `${cssImport}
 ${jsContent}`;
 }
-const build = async options => {
-  const sourceDir = options.dir ?? ".";
-  const outputDir = options.output;
-  const outputAround = options.outputAround || false;
-  const promises = [];
-  const isDryRun = options.dryRun || false;
-  if (isDryRun) console.info("[dry-run] no files will be written\n");
-  if (outputDir) await (0, import_fs_extra.mkdir)(outputDir, {
-    recursive: true
-  });
-  const loadedOptions = (0, import_static.loadTamaguiBuildConfigSync)(options.tamaguiOptions);
-  if (loadedOptions.disable) console.warn(`[tamagui] Note: "disable" option in tamagui.build.ts is being ignored for CLI build command`);
-  const buildOptions = {
-    ...loadedOptions,
-    disable: false,
-    disableExtraction: false
-  };
-  const targets = options.target === "both" || !options.target ? ["web", "native"] : [options.target];
-  const webTamaguiOptions = {
-    ...buildOptions,
-    platform: "web"
-  };
-  await (0, import_static.loadTamagui)(webTamaguiOptions);
-  const allFiles = [];
-  const watchPattern = sourceDir.match(/\.(tsx|jsx)$/) ? sourceDir : `${sourceDir}/**/*.{tsx,jsx}`;
-  await new Promise(res => {
-    const watcher = import_chokidar.default.watch(watchPattern, {
-      ignoreInitial: false
-    });
-    watcher.on("add", relativePath => {
-      const sourcePath = (0, import_node_path.resolve)(process.cwd(), relativePath);
-      if (options.exclude && import_micromatch.default.contains(relativePath, options.exclude)) return;
-      if (options.include && !import_micromatch.default.contains(relativePath, options.include)) return;
-      allFiles.push(sourcePath);
-    }).on("ready", () => {
-      watcher.close().then(() => res());
-    });
-  });
-  const fileToTargets = /* @__PURE__ */new Map();
-  for (const sourcePath of allFiles) {
-    const platformMatch = sourcePath.match(/\.(web|native|ios|android)\.(tsx|jsx)$/);
-    let filePlatforms = [];
-    if (platformMatch) {
-      const platform = platformMatch[1];
-      if (platform === "web") filePlatforms = ["web"];else if (platform === "native" || platform === "ios" || platform === "android") filePlatforms = ["native"];
-    } else {
-      const basePath = sourcePath.replace(/\.(tsx|jsx)$/, "");
-      const hasNative = allFiles.some(f => f === `${basePath}.native.tsx` || f === `${basePath}.native.jsx` || f === `${basePath}.ios.tsx` || f === `${basePath}.ios.jsx` || f === `${basePath}.android.tsx` || f === `${basePath}.android.jsx`);
-      const hasWeb = allFiles.some(f => f === `${basePath}.web.tsx` || f === `${basePath}.web.jsx`);
-      filePlatforms = targets.filter(target => {
-        if (target === "native" && hasNative) return false;
-        if (target === "web" && hasWeb) return false;
-        return true;
-      });
-      if (hasWeb && hasNative) filePlatforms = [];
-    }
-    if (filePlatforms.length > 0) fileToTargets.set(sourcePath, filePlatforms);
-  }
-  const stats = {
-    filesProcessed: 0,
-    optimized: 0,
-    flattened: 0,
-    styled: 0,
-    found: 0
-  };
-  const trackedFiles = [];
-  const restoreDir = options.runCommand ? (0, import_node_path.join)((0, import_node_os.tmpdir)(), `tamagui-restore-${process.pid}`) : null;
-  if (restoreDir) await (0, import_fs_extra.mkdir)(restoreDir, {
-    recursive: true
-  });
-  const trackFile = async filePath => {
-    if (!restoreDir) return;
-    const hash = (0, import_node_crypto.createHash)("md5").update(filePath).digest("hex");
-    const backupPath = (0, import_node_path.join)(restoreDir, hash);
-    await (0, import_fs_extra.copyFile)(filePath, backupPath);
-    trackedFiles.push({
-      path: filePath,
-      hardlinkPath: backupPath,
-      mtimeAfterWrite: 0
-    });
-  };
-  const recordMtime = async filePath => {
-    if (!restoreDir) return;
-    const tracked = trackedFiles.find(t => t.path === filePath);
-    if (tracked) tracked.mtimeAfterWrite = (await (0, import_fs_extra.stat)(filePath)).mtimeMs;
-  };
-  for (const [sourcePath, filePlatforms] of fileToTargets) promises.push((async () => {
-    if (options.debug) process.env.NODE_ENV ||= "development";
-    const originalSource = await (0, import_fs_extra.readFile)(sourcePath, "utf-8");
-    if (isDryRun) console.info(`
-${sourcePath} [${filePlatforms.join(", ")}]`);
-    if (filePlatforms.includes("web")) {
-      process.env.TAMAGUI_TARGET = "web";
-      const extractor = (0, import_static.createExtractor)({
-        platform: "web"
-      });
-      const out = await (0, import_static.extractToClassNames)({
-        extractor,
-        source: originalSource,
-        sourcePath,
-        options: {
-          ...buildOptions,
-          platform: "web"
-        },
-        shouldPrintDebug: options.debug || false
-      });
-      if (out) {
-        stats.filesProcessed++;
-        stats.optimized += out.stats.optimized;
-        stats.flattened += out.stats.flattened;
-        stats.styled += out.stats.styled;
-        stats.found += out.stats.found;
-        if (isDryRun) {
-          const jsContent = typeof out.js === "string" ? out.js : out.js.toString("utf-8");
-          if (out.styles) console.info(`
+const build = async (options) => {
+	const sourceDir = options.dir ?? ".";
+	const outputDir = options.output;
+	const outputAround = options.outputAround || false;
+	const promises = [];
+	const isDryRun = options.dryRun || false;
+	const trackedFiles = [];
+	const trackedPaths = /* @__PURE__ */ new Set();
+	const restoreDir = options.runCommand ? (0, import_node_path.join)((0, import_node_os.tmpdir)(), `tamagui-restore-${process.pid}`) : null;
+	if (restoreDir) await (0, import_fs_extra.mkdir)(restoreDir, { recursive: true });
+	let didRestore = false;
+	const restoreTrackedFiles = async (force = false) => {
+		if (didRestore) return;
+		await restoreFiles(trackedFiles, restoreDir, force);
+		didRestore = true;
+	};
+	try {
+		const trackFile = async (filePath) => {
+			if (!restoreDir || trackedPaths.has(filePath)) return;
+			trackedPaths.add(filePath);
+			if (!await (0, import_fs_extra.stat)(filePath).catch(() => null)) {
+				trackedFiles.push({
+					path: filePath,
+					hardlinkPath: "",
+					mtimeAfterWrite: 0
+				});
+				return;
+			}
+			const hash = (0, import_node_crypto.createHash)("md5").update(filePath).digest("hex");
+			const backupPath = (0, import_node_path.join)(restoreDir, hash);
+			await (0, import_fs_extra.copyFile)(filePath, backupPath);
+			trackedFiles.push({
+				path: filePath,
+				hardlinkPath: backupPath,
+				mtimeAfterWrite: 0
+			});
+		};
+		const recordMtime = async (filePath) => {
+			if (!restoreDir) return;
+			const tracked = trackedFiles.find((item) => item.path === filePath);
+			if (tracked) tracked.mtimeAfterWrite = (await (0, import_fs_extra.stat)(filePath)).mtimeMs;
+		};
+		if (isDryRun) console.info("[dry-run] no files will be written\n");
+		if (outputDir) await (0, import_fs_extra.mkdir)(outputDir, { recursive: true });
+		const loadedOptions = (0, import_static.loadTamaguiBuildConfigSync)(options.tamaguiOptions);
+		if (loadedOptions.disable) console.warn(`[tamagui] Note: "disable" option in tamagui.build.ts is being ignored for CLI build command`);
+		const buildOptions = {
+			...loadedOptions,
+			disable: false,
+			disableExtraction: false
+		};
+		const targets = options.target === "both" || !options.target ? ["web", "native"] : [options.target];
+		const root = process.cwd();
+		const outputCSSPath = buildOptions.outputCSS ? (0, import_node_path.resolve)(root, buildOptions.outputCSS) : null;
+		if (outputCSSPath) await trackFile(outputCSSPath);
+		const require2 = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+		const configPath = (0, import_typescript.findConfigFile)(root, import_typescript.sys.fileExists, "tsconfig.json") || (0, import_typescript.findConfigFile)(root, import_typescript.sys.fileExists, "jsconfig.json");
+		const compilerOptions = configPath ? (0, import_typescript.parseJsonConfigFileContent)((() => {
+			const loaded = (0, import_typescript.readConfigFile)(configPath, import_typescript.sys.readFile);
+			if (loaded.error) throw new Error(String(loaded.error.messageText));
+			return loaded.config;
+		})(), import_typescript.sys, (0, import_node_path.dirname)(configPath)).options : {};
+		const resolveCompilerId = (specifier, importer) => {
+			const resolved = (0, import_typescript.nodeModuleNameResolver)(specifier, importer, compilerOptions, import_typescript.sys).resolvedModule?.resolvedFileName;
+			if (resolved && !resolved.endsWith(".d.ts")) return resolved;
+			try {
+				return require2.resolve(specifier, { paths: [(0, import_node_path.dirname)(importer), root] });
+			} catch {
+				return null;
+			}
+		};
+		const compilerFrontends = /* @__PURE__ */ new Map();
+		const compilerProjects = /* @__PURE__ */ new Map();
+		for (const target of targets) {
+			const targetOptions = {
+				...buildOptions,
+				platform: target
+			};
+			const projectInfo = await (0, import_static.loadTamagui)(targetOptions);
+			if (!projectInfo) throw new Error(`Unable to load Tamagui for the ${target} build`);
+			const componentModules = [.../* @__PURE__ */ new Set(["@tamagui/core", ...targetOptions.components ?? []])].map((moduleName) => {
+				const id = resolveCompilerId(moduleName, (0, import_node_path.join)(root, "__tamagui_cli__.tsx"));
+				if (!id) throw new Error(`Unable to resolve compiler component ${moduleName}`);
+				return {
+					moduleName,
+					id
+				};
+			});
+			compilerProjects.set(target, {
+				projectInfo,
+				componentModules,
+				generation: (0, import_node_crypto.createHash)("sha256").update(target).update("\0").update(buildOptions.config ?? "tamagui.config.ts").update("\0").update(JSON.stringify(targetOptions.components ?? [])).update("\0").update(String(!!targetOptions.disablePartialExtraction)).update("\0").update(String(target === "native" && !!targetOptions.experimental?.nativeFastPath)).digest("hex"),
+				disablePartialExtraction: targetOptions.disablePartialExtraction,
+				experimentalNativeFastPath: target === "native" && targetOptions.experimental?.nativeFastPath === true,
+				cacheStamp: (0, import_static.compilerProjectStamp)({
+					stampSources: projectInfo.stampSources ?? [],
+					hostVersions: [`@tamagui/cli@${cliVersion}`],
+					target,
+					componentModules,
+					disablePartialExtraction: !!targetOptions.disablePartialExtraction,
+					experimentalNativeFastPath: target === "native" && targetOptions.experimental?.nativeFastPath === true,
+					zeroRuntime: false,
+					development: process.env.NODE_ENV === "development"
+				})
+			});
+			compilerFrontends.set(target, new import_static.CompilerFrontend());
+		}
+		if (outputCSSPath) await recordMtime(outputCSSPath);
+		const compileTarget = async (target, sourcePath, source) => {
+			const compiler = compilerFrontends.get(target);
+			const project = compilerProjects.get(target);
+			return compiler.compile({
+				id: sourcePath,
+				source,
+				root,
+				target,
+				project,
+				resolve: async (specifier, importer) => {
+					const id = resolveCompilerId(specifier, importer);
+					return id ? {
+						id,
+						external: id.includes("/node_modules/")
+					} : null;
+				},
+				load: async (id) => {
+					try {
+						return await (0, import_fs_extra.readFile)(id.split(/[?#]/, 1)[0], "utf8");
+					} catch {
+						return null;
+					}
+				}
+			});
+		};
+		const allFiles = [];
+		const watchPattern = sourceDir.match(/\.(tsx|jsx)$/) ? sourceDir : `${sourceDir}/**/*.{tsx,jsx}`;
+		const sourceRoot = sourceDir.match(/\.(tsx|jsx)$/) ? (0, import_node_path.dirname)((0, import_node_path.resolve)(sourceDir)) : (0, import_node_path.resolve)(sourceDir);
+		await new Promise((res) => {
+			const watcher = import_chokidar.default.watch(watchPattern, { ignoreInitial: false });
+			watcher.on("add", (relativePath) => {
+				const sourcePath = (0, import_node_path.resolve)(process.cwd(), relativePath);
+				if (options.exclude && import_micromatch.default.contains(relativePath, options.exclude)) return;
+				if (options.include && !import_micromatch.default.contains(relativePath, options.include)) return;
+				allFiles.push(sourcePath);
+			}).on("ready", () => {
+				watcher.close().then(() => res());
+			});
+		});
+		allFiles.sort();
+		const fileToTargets = /* @__PURE__ */ new Map();
+		for (const sourcePath of allFiles) {
+			const platformMatch = sourcePath.match(/\.(web|native|ios|android)\.(tsx|jsx)$/);
+			let filePlatforms = [];
+			if (platformMatch) {
+				const platform = platformMatch[1];
+				if (platform === "web") filePlatforms = ["web"];
+				else if (platform === "native" || platform === "ios" || platform === "android") filePlatforms = ["native"];
+			} else {
+				const basePath = sourcePath.replace(/\.(tsx|jsx)$/, "");
+				const hasNative = allFiles.some((f) => f === `${basePath}.native.tsx` || f === `${basePath}.native.jsx` || f === `${basePath}.ios.tsx` || f === `${basePath}.ios.jsx` || f === `${basePath}.android.tsx` || f === `${basePath}.android.jsx`);
+				const hasWeb = allFiles.some((f) => f === `${basePath}.web.tsx` || f === `${basePath}.web.jsx`);
+				filePlatforms = targets.filter((target) => {
+					if (target === "native" && hasNative) return false;
+					if (target === "web" && hasWeb) return false;
+					return true;
+				});
+				if (hasWeb && hasNative) filePlatforms = [];
+			}
+			if (filePlatforms.length > 0) fileToTargets.set(sourcePath, filePlatforms);
+		}
+		const stats = {
+			filesProcessed: 0,
+			optimized: 0,
+			flattened: 0,
+			styled: 0,
+			found: 0,
+			bailed: 0
+		};
+		const countedFiles = /* @__PURE__ */ new Set();
+		const addStats = (sourcePath, fileStats) => {
+			if (!countedFiles.has(sourcePath)) {
+				countedFiles.add(sourcePath);
+				stats.filesProcessed++;
+			}
+			stats.optimized += fileStats.lowered - fileStats.flattened;
+			stats.flattened += fileStats.flattened;
+			stats.styled += fileStats.styled;
+			stats.found += fileStats.found;
+			stats.bailed += fileStats.bailed;
+		};
+		if (options.debug) process.env.NODE_ENV ||= "development";
+		const sources = /* @__PURE__ */ new Map();
+		await Promise.all([...fileToTargets.keys()].map(async (sourcePath) => {
+			sources.set(sourcePath, await (0, import_fs_extra.readFile)(sourcePath, "utf-8"));
+		}));
+		const buildWebFile = async (sourcePath, originalSource) => {
+			if (isDryRun) console.info(`
+${sourcePath} [web]`);
+			const out = await compileTarget("web", sourcePath, originalSource);
+			if (out.output.changed || out.plan.stats.found > 0) {
+				addStats(sourcePath, out.plan.stats);
+				if (isDryRun) {
+					if (out.plan.css) console.info(`
 css:
-${out.styles}`);
-          console.info(`
+${out.plan.css}`);
+					console.info(`
 js:
-${jsContent}`);
-        } else {
-          const relPath = outputDir ? (0, import_node_path.relative)((0, import_node_path.resolve)(sourceDir), sourcePath) : (0, import_node_path.basename)(sourcePath);
-          const cssName = "_" + (0, import_node_path.basename)(sourcePath, (0, import_node_path.extname)(sourcePath));
-          const outputBase = outputDir ? (0, import_node_path.join)(outputDir, (0, import_node_path.dirname)(relPath)) : (0, import_node_path.dirname)(sourcePath);
-          if (outputDir) await (0, import_fs_extra.mkdir)(outputBase, {
-            recursive: true
-          });
-          const stylePath = (0, import_node_path.join)(outputBase, cssName + ".css");
-          const cssImport = `import "./${cssName}.css"`;
-          const code = insertCssImport(typeof out.js === "string" ? out.js : out.js.toString("utf-8"), cssImport);
-          const webOutputPath = outputDir ? (0, import_node_path.join)(outputDir, relPath) : sourcePath;
-          if (!outputDir) await trackFile(sourcePath);
-          await (0, import_fs_extra.writeFile)(webOutputPath, code, "utf-8");
-          if (!outputDir) await recordMtime(sourcePath);
-          await (0, import_fs_extra.writeFile)(stylePath, out.styles, "utf-8");
-          if (!outputDir) trackedFiles.push({
-            path: stylePath,
-            hardlinkPath: "",
-            mtimeAfterWrite: (await (0, import_fs_extra.stat)(stylePath)).mtimeMs
-          });
-        }
-      } else if (isDryRun) console.info(`  web: no output`);
-    }
-    if (filePlatforms.includes("native")) {
-      process.env.TAMAGUI_TARGET = "native";
-      const nativeTamaguiOptions = {
-        ...buildOptions,
-        platform: "native"
-      };
-      const nativeOut = (0, import_static.extractToNative)(sourcePath, originalSource, nativeTamaguiOptions);
-      if (isDryRun) {
-        if (nativeOut.code) console.info(`
+${out.output.code}`);
+				} else {
+					const relPath = outputDir ? (0, import_node_path.relative)(sourceRoot, sourcePath) : (0, import_node_path.basename)(sourcePath);
+					const cssName = "_" + (0, import_node_path.basename)(sourcePath, (0, import_node_path.extname)(sourcePath));
+					const outputBase = outputDir ? (0, import_node_path.join)(outputDir, (0, import_node_path.dirname)(relPath)) : (0, import_node_path.dirname)(sourcePath);
+					if (outputDir) await (0, import_fs_extra.mkdir)(outputBase, { recursive: true });
+					const stylePath = (0, import_node_path.join)(outputBase, cssName + ".css");
+					const cssImport = `import "./${cssName}.css"`;
+					const code = out.plan.css ? insertCssImport(out.output.code, cssImport) : out.output.code;
+					const webOutputPath = outputDir ? (0, import_node_path.join)(outputDir, relPath) : sourcePath;
+					if (!outputDir) await trackFile(sourcePath);
+					await (0, import_fs_extra.writeFile)(webOutputPath, code, "utf-8");
+					if (!outputDir) await recordMtime(sourcePath);
+					if (out.plan.css) await (0, import_fs_extra.writeFile)(stylePath, out.plan.css, "utf-8");
+					if (!outputDir && out.plan.css) trackedFiles.push({
+						path: stylePath,
+						hardlinkPath: "",
+						mtimeAfterWrite: (await (0, import_fs_extra.stat)(stylePath)).mtimeMs
+					});
+				}
+			} else if (isDryRun) console.info(`  web: no output`);
+		};
+		const buildNativeFile = async (sourcePath, filePlatforms, originalSource) => {
+			if (isDryRun) console.info(`
+${sourcePath} [native]`);
+			const nativeOut = await compileTarget("native", sourcePath, originalSource);
+			if (nativeOut.output.changed || nativeOut.plan.stats.found > 0) addStats(sourcePath, nativeOut.plan.stats);
+			if (isDryRun) if (nativeOut.output.code) console.info(`
 native:
-${nativeOut.code}`);else console.info(`  native: no output`);
-      } else {
-        let nativeOutputPath = sourcePath;
-        const needsNativeSuffix = !/\.(web|native|ios|android)\.(tsx|jsx)$/.test(sourcePath) && (filePlatforms.length > 1 || outputAround);
-        if (outputAround) {
-          nativeOutputPath = sourcePath.replace(/\.(tsx|jsx)$/, ".native.$1");
-          if (await (0, import_fs_extra.stat)(nativeOutputPath).catch(() => null)) throw new Error(`--output-around: ${nativeOutputPath} already exists. Remove it first or use --output instead.`);
-        } else if (outputDir) {
-          const relPath = (0, import_node_path.relative)((0, import_node_path.resolve)(sourceDir), sourcePath);
-          const outputRelPath = needsNativeSuffix ? relPath.replace(/\.(tsx|jsx)$/, ".native.$1") : relPath;
-          nativeOutputPath = (0, import_node_path.join)(outputDir, outputRelPath);
-          await (0, import_fs_extra.mkdir)((0, import_node_path.dirname)(nativeOutputPath), {
-            recursive: true
-          });
-        } else if (needsNativeSuffix) nativeOutputPath = sourcePath.replace(/\.(tsx|jsx)$/, ".native.$1");
-        if (nativeOut.code) {
-          if (nativeOut.code.includes("__ReactNativeStyleSheet") || nativeOut.code.includes("_withStableStyle")) {
-            stats.filesProcessed++;
-            const wrapperMatches = nativeOut.code.match(/_withStableStyle/g);
-            if (wrapperMatches) stats.flattened += wrapperMatches.length;
-          }
-          if (!outputDir && !outputAround && (nativeOutputPath === sourcePath || filePlatforms.length === 1)) await trackFile(nativeOutputPath);
-          await (0, import_fs_extra.writeFile)(nativeOutputPath, nativeOut.code, "utf-8");
-          if (!outputDir && !outputAround) await recordMtime(nativeOutputPath);
-          if (!outputDir && !outputAround && nativeOutputPath !== sourcePath && filePlatforms.length > 1) trackedFiles.push({
-            path: nativeOutputPath,
-            hardlinkPath: "",
-            mtimeAfterWrite: (await (0, import_fs_extra.stat)(nativeOutputPath)).mtimeMs
-          });
-          if (outputAround) console.info(`  \u2192 ${nativeOutputPath}`);
-        }
-      }
-    }
-  })());
-  await Promise.all(promises);
-  if (isDryRun) console.info(`
-${stats.filesProcessed} files | ${stats.found} found | ${stats.optimized} optimized | ${stats.flattened} flattened | ${stats.styled} styled
+${nativeOut.output.code}`);
+			else console.info(`  native: no output`);
+			else {
+				let nativeOutputPath = sourcePath;
+				const needsNativeSuffix = !/\.(web|native|ios|android)\.(tsx|jsx)$/.test(sourcePath) && (filePlatforms.length > 1 || outputAround);
+				if (outputAround) {
+					nativeOutputPath = sourcePath.replace(/\.(tsx|jsx)$/, ".native.$1");
+					if (await (0, import_fs_extra.stat)(nativeOutputPath).catch(() => null)) throw new Error(`--output-around: ${nativeOutputPath} already exists. Remove it first or use --output instead.`);
+				} else if (outputDir) {
+					const relPath = (0, import_node_path.relative)(sourceRoot, sourcePath);
+					const outputRelPath = needsNativeSuffix ? relPath.replace(/\.(tsx|jsx)$/, ".native.$1") : relPath;
+					nativeOutputPath = (0, import_node_path.join)(outputDir, outputRelPath);
+					await (0, import_fs_extra.mkdir)((0, import_node_path.dirname)(nativeOutputPath), { recursive: true });
+				} else if (needsNativeSuffix) nativeOutputPath = sourcePath.replace(/\.(tsx|jsx)$/, ".native.$1");
+				if (nativeOut.output.code) {
+					if (nativeOut.output.changed) {
+						stats.filesProcessed++;
+						stats.flattened += nativeOut.plan.stats.flattened;
+					}
+					if (!outputDir && !outputAround && (nativeOutputPath === sourcePath || filePlatforms.length === 1)) await trackFile(nativeOutputPath);
+					await (0, import_fs_extra.writeFile)(nativeOutputPath, nativeOut.output.code, "utf-8");
+					if (!outputDir && !outputAround) await recordMtime(nativeOutputPath);
+					if (!outputDir && !outputAround && nativeOutputPath !== sourcePath && filePlatforms.length > 1) trackedFiles.push({
+						path: nativeOutputPath,
+						hardlinkPath: "",
+						mtimeAfterWrite: (await (0, import_fs_extra.stat)(nativeOutputPath)).mtimeMs
+					});
+					if (outputAround) console.info(`  \u2192 ${nativeOutputPath}`);
+				}
+			}
+		};
+		for (const target of targets) {
+			process.env.TAMAGUI_TARGET = target;
+			const targetPromises = [...fileToTargets].filter(([, filePlatforms]) => filePlatforms.includes(target)).map(([sourcePath, filePlatforms]) => target === "web" ? buildWebFile(sourcePath, sources.get(sourcePath)) : buildNativeFile(sourcePath, filePlatforms, sources.get(sourcePath)));
+			promises.push(...targetPromises);
+			await Promise.all(targetPromises);
+		}
+		if (isDryRun) console.info(`
+${stats.filesProcessed} files | ${stats.found} found | ${stats.optimized} optimized | ${stats.flattened} flattened | ${stats.styled} styled | ${stats.bailed} bailed
 `);
-  if (options.expectOptimizations !== void 0) {
-    const totalOptimizations = stats.optimized + stats.flattened;
-    if (totalOptimizations < options.expectOptimizations) {
-      console.error(`
+		if (options.expectOptimizations !== void 0) {
+			const totalOptimizations = stats.optimized + stats.flattened;
+			if (totalOptimizations < options.expectOptimizations) {
+				console.error(`
 Expected at least ${options.expectOptimizations} optimizations but only got ${totalOptimizations}`);
-      console.error(`Stats: ${JSON.stringify(stats, null, 2)}`);
-      process.exit(1);
-    }
-    console.info(`
+				console.error(`Stats: ${JSON.stringify(stats, null, 2)}`);
+				await restoreTrackedFiles(true);
+				throw new Error(`Expected at least ${options.expectOptimizations} optimizations but only got ${totalOptimizations}`);
+			}
+			console.info(`
 \u2713 Met optimization target: ${totalOptimizations} >= ${options.expectOptimizations}`);
-  }
-  if (options.runCommand && options.runCommand.length > 0) {
-    const command = options.runCommand.join(" ");
-    console.info(`
-Running: ${command}
-`);
-    try {
-      (0, import_node_child_process.execSync)(command, {
-        stdio: "inherit"
-      });
-    } catch (err) {
-      console.error(`
+		}
+		if (options.runCommand && options.runCommand.length > 0) {
+			let commandFailed = true;
+			try {
+				await runCommand(options.runCommand, () => restoreTrackedFiles(true));
+				commandFailed = false;
+			} catch (err) {
+				console.error(`
 Command failed with exit code ${err.status || 1}`);
-      process.exitCode = err.status || 1;
-    } finally {
-      await restoreFiles(trackedFiles, restoreDir);
-    }
-  }
-  return {
-    stats,
-    trackedFiles
-  };
+				throw err;
+			} finally {
+				await restoreTrackedFiles(commandFailed);
+			}
+		}
+		return {
+			stats,
+			trackedFiles
+		};
+	} catch (error) {
+		await Promise.allSettled(promises);
+		await restoreTrackedFiles(true);
+		throw error;
+	}
 };
-async function restoreFiles(trackedFiles, restoreDir) {
-  if (!restoreDir || trackedFiles.length === 0) return;
-  console.info(`
+async function runCommand(command, restore) {
+	await new Promise((resolveCommand, rejectCommand) => {
+		const child = (0, import_node_child_process.spawn)(command[0], command.slice(1), { stdio: "inherit" });
+		let settled = false;
+		let listenersRestored = false;
+		const interruptListeners = process.listeners("SIGINT");
+		const terminateListeners = process.listeners("SIGTERM");
+		process.removeAllListeners("SIGINT");
+		process.removeAllListeners("SIGTERM");
+		const cleanup = () => {
+			process.off("SIGINT", onInterrupt);
+			process.off("SIGTERM", onTerminate);
+			if (listenersRestored) return;
+			listenersRestored = true;
+			for (const listener of interruptListeners) process.on("SIGINT", listener);
+			for (const listener of terminateListeners) process.on("SIGTERM", listener);
+		};
+		const finishSignal = (signal) => {
+			if (settled) return;
+			settled = true;
+			(async () => {
+				const childExited = child.exitCode === null && child.signalCode === null ? new Promise((resolveExit) => child.once("exit", () => resolveExit())) : Promise.resolve();
+				child.kill(signal);
+				await childExited;
+				try {
+					await restore();
+				} finally {
+					cleanup();
+					process.exit(signal === "SIGINT" ? 130 : 143);
+				}
+			})();
+		};
+		const onInterrupt = () => finishSignal("SIGINT");
+		const onTerminate = () => finishSignal("SIGTERM");
+		process.once("SIGINT", onInterrupt);
+		process.once("SIGTERM", onTerminate);
+		console.info(`
+Running: ${command.join(" ")}
+`);
+		child.once("error", (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			rejectCommand(error);
+		});
+		child.once("exit", (code, signal) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			if (code === 0) {
+				resolveCommand();
+				return;
+			}
+			const error = /* @__PURE__ */ new Error(signal ? `Command terminated by ${signal}` : `Command exited with code ${code}`);
+			error.status = code ?? 1;
+			rejectCommand(error);
+		});
+	});
+}
+async function restoreFiles(trackedFiles, restoreDir, force = false) {
+	if (!restoreDir) return;
+	if (trackedFiles.length === 0) {
+		await (0, import_fs_extra.rm)(restoreDir, {
+			recursive: true,
+			force: true
+		});
+		return;
+	}
+	console.info(`
 Restoring ${trackedFiles.length} files...`);
-  let restored = 0;
-  let skipped = 0;
-  let deleted = 0;
-  for (const tracked of trackedFiles) try {
-    const currentStat = await (0, import_fs_extra.stat)(tracked.path).catch(() => null);
-    if (currentStat && currentStat.mtimeMs !== tracked.mtimeAfterWrite) {
-      console.warn(`  Skipping ${tracked.path} - modified during build`);
-      skipped++;
-      continue;
-    }
-    if (tracked.hardlinkPath === "") {
-      await (0, import_fs_extra.rm)(tracked.path, {
-        force: true
-      });
-      deleted++;
-    } else {
-      await (0, import_fs_extra.copyFile)(tracked.hardlinkPath, tracked.path);
-      restored++;
-    }
-  } catch (err) {
-    console.warn(`  Failed to restore ${tracked.path}: ${err.message}`);
-    skipped++;
-  }
-  await (0, import_fs_extra.rm)(restoreDir, {
-    recursive: true,
-    force: true
-  });
-  console.info(`  Restored: ${restored}, Deleted: ${deleted}, Skipped: ${skipped}`);
-}
+	let restored = 0;
+	let skipped = 0;
+	let deleted = 0;
+	for (const tracked of trackedFiles) try {
+		const currentStat = await (0, import_fs_extra.stat)(tracked.path).catch(() => null);
+		if (!force && currentStat && currentStat.mtimeMs !== tracked.mtimeAfterWrite) {
+			console.warn(`  Skipping ${tracked.path} - modified during build`);
+			skipped++;
+			continue;
+		}
+		if (tracked.hardlinkPath === "") {
+			await (0, import_fs_extra.rm)(tracked.path, { force: true });
+			deleted++;
+		} else {
+			await (0, import_fs_extra.copyFile)(tracked.hardlinkPath, tracked.path);
+			restored++;
+		}
+	} catch (err) {
+		console.warn(`  Failed to restore ${tracked.path}: ${err.message}`);
+		skipped++;
+	}
+	await (0, import_fs_extra.rm)(restoreDir, {
+		recursive: true,
+		force: true
+	});
+	console.info(`  Restored: ${restored}, Deleted: ${deleted}, Skipped: ${skipped}`);
+}