bleam 0.0.4 → 0.0.6

package/dist/cli.cjs

@@ -16,27 +16,98 @@ let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_url = require("node:url");
 node_url = require_chunk.__toESM(node_url);
+let ws = require("ws");
+ws = require_chunk.__toESM(ws);
+let yocto_spinner = require("yocto-spinner");
+yocto_spinner = require_chunk.__toESM(yocto_spinner);
+let yoctocolors = require("yoctocolors");
+yoctocolors = require_chunk.__toESM(yoctocolors);
 
 //#region src/cli.ts
 const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
 const packageRoot = node_path.default.dirname((0, node_url.fileURLToPath)(new URL("../package.json", require("url").pathToFileURL(__filename).href)));
 const packageJson = require$1("../package.json");
 const runtimeVersion = packageJson.version;
-const runtimePlatform = `macos-${process.arch}`;
+function artifactPlatform() {
+	return `macos-${process.arch}`;
+}
+function prettyPath(value) {
+	const home = node_os.default.homedir();
+	return value === home || value.startsWith(`${home}${node_path.default.sep}`) ? `~${value.slice(home.length)}` : value;
+}
+function commandSucceeds(command, args) {
+	const result = (0, node_child_process.spawnSync)(command, args, { stdio: "ignore" });
+	return !result.error && result.status === 0;
+}
+function commandText(command, args) {
+	return [command, ...args].join(" ");
+}
+function doctorHint(projectRoot) {
+	return projectRoot ? `Run ${(0, yoctocolors.bold)(`bleam doctor ${projectRoot}`)} for diagnostics.` : `Run ${(0, yoctocolors.bold)("bleam doctor")} for diagnostics.`;
+}
+function appConfigBuildExample() {
+	return [
+		"Example:",
+		"import { appConfig } from 'bleam'",
+		"",
+		"export default appConfig({",
+		"  name: 'My App',",
+		"  bundleIdentifier: 'com.example.myapp',",
+		"  teamId: 'ABCDE12345',",
+		"})"
+	].join("\n");
+}
+function missingBuildFieldError(field) {
+	return /* @__PURE__ */ new Error(`app.config.ts must define ${field} for bleam build.\n\n${appConfigBuildExample()}`);
+}
+function heading(text) {
+	return (0, yoctocolors.bold)(text);
+}
+function muted(text) {
+	return (0, yoctocolors.dim)(text);
+}
+function statusLabel(status) {
+	if (status === "pass") return (0, yoctocolors.green)("[ok]");
+	if (status === "warn") return (0, yoctocolors.yellow)("[warn]");
+	return (0, yoctocolors.red)("[fail]");
+}
+function startSpinner(text) {
+	if (!process.stderr.isTTY) {
+		console.log(text);
+		return;
+	}
+	return (0, yocto_spinner.default)({
+		text,
+		handleSignals: false
+	}).start();
+}
 function printUsage() {
 	console.log(`Usage: bleam <command>
 
 Commands:
   new [dir] [--run]         Create a new Bleam project
-  dev [dir] [--port <port>] Start a Bleam dev server`);
+  dev [dir] [--port <port>] [--run]
+                            Start a Bleam dev server
+  build [dir] [--output <dir>]
+                            Build App Store-ready native archives
+  doctor [dir]              Check the local Bleam environment
+  check [dir] [--write]     Format, lint, and organize imports
+  format [dir] [--check]    Format project files
+  lint [dir]                Lint project files`);
 }
 function invocationRoot() {
-	return node_path.default.isAbsolute(process.env.PWD ?? "") ? process.env.PWD : process.cwd();
+	const pwd = process.env.PWD;
+	return pwd && node_path.default.isAbsolute(pwd) ? pwd : process.cwd();
+}
+function canonicalPath(value) {
+	const resolved = node_path.default.resolve(value);
+	return (0, node_fs.existsSync)(resolved) ? node_fs.realpathSync.native(resolved) : resolved;
 }
 function parseDevOptions(argv) {
 	const root = invocationRoot();
 	let projectRoot = root;
 	let port = 8081;
+	let run = false;
 	let hasProjectRootArg = false;
 	for (let index = 0; index < argv.length; index += 1) {
 		const arg = argv[index];
@@ -49,6 +120,10 @@ function parseDevOptions(argv) {
 			port = Number(arg.slice(7));
 			continue;
 		}
+		if (arg === "--run") {
+			run = true;
+			continue;
+		}
 		if (arg === "--help" || arg === "-h") {
 			printUsage();
 			process.exit(0);
@@ -60,8 +135,9 @@ function parseDevOptions(argv) {
 	if (!Number.isInteger(port) || port <= 0) throw new Error(`Invalid port: ${port}`);
 	if (!hasProjectRootArg && !isBleamProjectRoot(projectRoot)) projectRoot = discoverBleamProjectRoot(projectRoot) ?? projectRoot;
 	return {
-		projectRoot: node_path.default.resolve(projectRoot),
-		port
+		projectRoot: canonicalPath(projectRoot),
+		port,
+		run
 	};
 }
 function parseNewOptions(argv) {
@@ -81,12 +157,139 @@ function parseNewOptions(argv) {
 		projectRoot = node_path.default.resolve(root, arg);
 	}
 	return {
-		projectRoot,
+		projectRoot: canonicalPath(projectRoot),
 		run
 	};
 }
+function parseBuildOptions(argv) {
+	const root = invocationRoot();
+	let projectRoot = root;
+	let hasProjectRootArg = false;
+	let output;
+	let configuration = "Release";
+	let exportOptionsPlist;
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--output" || arg === "-o") {
+			output = argv[++index];
+			continue;
+		}
+		if (arg.startsWith("--output=")) {
+			output = arg.slice(9);
+			continue;
+		}
+		if (arg === "--configuration") {
+			const value = argv[++index];
+			if (!value) throw new Error("Missing --configuration value");
+			configuration = value;
+			continue;
+		}
+		if (arg.startsWith("--configuration=")) {
+			configuration = arg.slice(16);
+			continue;
+		}
+		if (arg === "--export-options-plist") {
+			exportOptionsPlist = argv[++index];
+			continue;
+		}
+		if (arg.startsWith("--export-options-plist=")) {
+			exportOptionsPlist = arg.slice(23);
+			continue;
+		}
+		if (arg === "--help" || arg === "-h") {
+			printUsage();
+			process.exit(0);
+		}
+		if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+		projectRoot = node_path.default.resolve(root, arg);
+		hasProjectRootArg = true;
+	}
+	if (!hasProjectRootArg && !isBleamProjectRoot(projectRoot)) projectRoot = discoverBleamProjectRoot(projectRoot) ?? projectRoot;
+	const resolvedProjectRoot = canonicalPath(projectRoot);
+	return {
+		projectRoot: resolvedProjectRoot,
+		output: node_path.default.resolve(resolvedProjectRoot, output ?? "dist"),
+		configuration,
+		exportOptionsPlist: exportOptionsPlist ? node_path.default.resolve(root, exportOptionsPlist) : void 0
+	};
+}
+function parseProjectToolOptions(argv) {
+	const root = invocationRoot();
+	let projectRoot = root;
+	let hasProjectRootArg = false;
+	let write = false;
+	let formatCheck = false;
+	for (const arg of argv) {
+		if (arg === "--write") {
+			write = true;
+			continue;
+		}
+		if (arg === "--check") {
+			formatCheck = true;
+			continue;
+		}
+		if (arg === "--help" || arg === "-h") {
+			printUsage();
+			process.exit(0);
+		}
+		if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+		projectRoot = node_path.default.resolve(root, arg);
+		hasProjectRootArg = true;
+	}
+	if (!hasProjectRootArg && !isBleamProjectRoot(projectRoot)) projectRoot = discoverBleamProjectRoot(projectRoot) ?? projectRoot;
+	return {
+		projectRoot: canonicalPath(projectRoot),
+		write,
+		formatCheck
+	};
+}
+function parseDoctorOptions(argv) {
+	const root = invocationRoot();
+	let projectRoot = root;
+	let hasProjectRootArg = false;
+	for (const arg of argv) {
+		if (arg === "--help" || arg === "-h") {
+			printUsage();
+			process.exit(0);
+		}
+		if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+		projectRoot = node_path.default.resolve(root, arg);
+		hasProjectRootArg = true;
+	}
+	if (!hasProjectRootArg && !isBleamProjectRoot(projectRoot)) projectRoot = discoverBleamProjectRoot(projectRoot) ?? projectRoot;
+	return { projectRoot: canonicalPath(projectRoot) };
+}
+function parseInternalMetroOptions(argv) {
+	let workspaceRoot;
+	let port = 8081;
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--workspace-root") {
+			workspaceRoot = node_path.default.resolve(invocationRoot(), argv[++index] ?? "");
+			continue;
+		}
+		if (arg === "--port") {
+			port = Number(argv[++index]);
+			continue;
+		}
+		if (arg.startsWith("--port=")) {
+			port = Number(arg.slice(7));
+			continue;
+		}
+		throw new Error(`Unknown internal option: ${arg}`);
+	}
+	if (!workspaceRoot) throw new Error("Missing --workspace-root");
+	if (!Number.isInteger(port) || port <= 0) throw new Error(`Invalid port: ${port}`);
+	return {
+		workspaceRoot,
+		port
+	};
+}
 function isBleamProjectRoot(projectRoot) {
-	return (0, node_fs.existsSync)(node_path.default.join(projectRoot, "app.config.ts")) && (0, node_fs.existsSync)(node_path.default.join(projectRoot, "app.tsx"));
+	return (0, node_fs.existsSync)(node_path.default.join(projectRoot, "app.config.ts")) && (0, node_fs.existsSync)(node_path.default.join(projectRoot, "app", "index.tsx"));
+}
+function resolvedDependencyRoot() {
+	return node_path.default.dirname(node_path.default.dirname(require$1.resolve("react-native/package.json")));
 }
 function discoverBleamProjectRoot(searchRoot) {
 	const ignoredNames = new Set([
@@ -119,6 +322,23 @@ function assertStringField(value, field) {
 	if (typeof value !== "string" || value.trim() === "") throw new Error(`app.config.ts must define ${field}`);
 	return value;
 }
+function isHexColor(value) {
+	return typeof value === "string" && /^#[\da-f]{6}$/i.test(value);
+}
+function normalizeAppearance(value) {
+	const input = value && typeof value === "object" ? value : {};
+	const window = input.window && typeof input.window === "object" ? input.window : {};
+	const appearance = {};
+	if (window.backgroundColor !== void 0) {
+		if (!isHexColor(window.backgroundColor)) throw new Error("app.config.ts appearance.window.backgroundColor must be a #rrggbb color");
+		appearance.window = { backgroundColor: window.backgroundColor };
+	}
+	if (input.userInterfaceStyle !== void 0) {
+		if (input.userInterfaceStyle !== "automatic" && input.userInterfaceStyle !== "light" && input.userInterfaceStyle !== "dark") throw new Error("app.config.ts appearance.userInterfaceStyle must be automatic, light, or dark");
+		appearance.userInterfaceStyle = input.userInterfaceStyle;
+	}
+	return appearance;
+}
 function loadAppConfig(projectRoot) {
 	const configPath = node_path.default.join(projectRoot, "app.config.ts");
 	const loader = `
@@ -138,7 +358,7 @@ function loadAppConfig(projectRoot) {
 			...process.env,
 			NODE_PATH: [
 				node_path.default.join(projectRoot, "node_modules"),
-				node_path.default.join(packageRoot, "node_modules"),
+				resolvedDependencyRoot(),
 				process.env.NODE_PATH
 			].filter(Boolean).join(node_path.default.delimiter)
 		}
@@ -148,14 +368,21 @@ function loadAppConfig(projectRoot) {
 	return {
 		name: assertStringField(value.name, "name"),
 		version: typeof value.version === "string" ? value.version : void 0,
+		buildNumber: typeof value.buildNumber === "string" ? value.buildNumber : void 0,
 		bundleIdentifier: typeof value.bundleIdentifier === "string" ? value.bundleIdentifier : void 0,
-		teamId: typeof value.teamId === "string" ? value.teamId : void 0
+		teamId: typeof value.teamId === "string" ? value.teamId : void 0,
+		appearance: normalizeAppearance(value.appearance)
 	};
 }
 function assertBleamConfigFiles(projectRoot) {
 	if ((0, node_fs.existsSync)(node_path.default.join(projectRoot, "app.json"))) throw new Error("Bleam projects use app.config.ts; app.json is not supported.");
 	if (!(0, node_fs.existsSync)(node_path.default.join(projectRoot, "app.config.ts"))) throw new Error("Missing app.config.ts. Bleam projects must define app.config.ts.");
-	if (!(0, node_fs.existsSync)(node_path.default.join(projectRoot, "app.tsx"))) throw new Error("Missing app.tsx. Bleam projects must define app.tsx.");
+	if (!(0, node_fs.existsSync)(node_path.default.join(projectRoot, "app", "index.tsx"))) throw new Error("Missing app/index.tsx. Bleam projects must define app/index.tsx.");
+}
+function ensureProjectTsconfig(projectRoot) {
+	const tsconfigPath = node_path.default.join(projectRoot, "tsconfig.json");
+	if ((0, node_fs.existsSync)(tsconfigPath)) return;
+	(0, node_fs.writeFileSync)(tsconfigPath, `${JSON.stringify({ extends: "./.bleam/dev/tsconfig.json" }, null, 2)}\n`);
 }
 function readProjectConfig(options) {
 	assertBleamConfigFiles(options.projectRoot);
@@ -163,8 +390,10 @@ function readProjectConfig(options) {
 	return {
 		name: config.name,
 		version: config.version,
+		buildNumber: config.buildNumber ?? "1",
 		bundleIdentifier: config.bundleIdentifier,
 		teamId: config.teamId,
+		appearance: config.appearance ?? normalizeAppearance(void 0),
 		runtimeVersion,
 		sdkVersion: runtimeVersion
 	};
@@ -177,27 +406,51 @@ function nameFromDirectory(projectRoot) {
 	if (!name) return "Bleam App";
 	return name.replace(/\b\w/g, (letter) => letter.toUpperCase());
 }
+function singleQuotedString(value) {
+	return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\r/g, "\\r").replace(/\n/g, "\\n")}'`;
+}
 function createNewProject(options) {
 	const templateRoot = node_path.default.join(packageRoot, "templates", "basic");
 	if (!(0, node_fs.existsSync)(templateRoot)) throw new Error(`Missing basic template: ${templateRoot}`);
 	if ((0, node_fs.existsSync)(options.projectRoot) && (0, node_fs.readdirSync)(options.projectRoot).length > 0) throw new Error(`Directory is not empty: ${options.projectRoot}`);
 	(0, node_fs.mkdirSync)(options.projectRoot, { recursive: true });
 	(0, node_fs.cpSync)(templateRoot, options.projectRoot, { recursive: true });
-	(0, node_fs.writeFileSync)(node_path.default.join(options.projectRoot, "app.config.ts"), `export default {\n  name: ${JSON.stringify(nameFromDirectory(options.projectRoot))},\n}\n`);
+	const name = nameFromDirectory(options.projectRoot);
+	(0, node_fs.writeFileSync)(node_path.default.join(options.projectRoot, "app.config.ts"), `import { appConfig } from 'bleam'\n\nexport default appConfig({\n  name: ${singleQuotedString(name)},\n})\n`);
+	(0, node_fs.writeFileSync)(node_path.default.join(options.projectRoot, ".gitignore"), `.bleam\nbiome.json\n.DS_Store\n`);
+	createDevWorkspace(options.projectRoot, {
+		name,
+		buildNumber: "1",
+		appearance: normalizeAppearance(void 0),
+		runtimeVersion,
+		sdkVersion: runtimeVersion
+	});
 	console.log(`Created Bleam project at ${options.projectRoot}`);
 }
 function createDevWorkspace(projectRoot, config) {
 	const workspaceRoot = node_path.default.join(projectRoot, ".bleam", "dev");
 	(0, node_fs.mkdirSync)(workspaceRoot, { recursive: true });
 	const workspaceNodeModules = node_path.default.join(workspaceRoot, "node_modules");
-	if (!(0, node_fs.existsSync)(workspaceNodeModules)) (0, node_fs.symlinkSync)(node_path.default.join(packageRoot, "node_modules"), workspaceNodeModules);
+	const dependencyRoot = resolvedDependencyRoot();
+	(0, node_fs.rmSync)(workspaceNodeModules, {
+		recursive: true,
+		force: true
+	});
+	(0, node_fs.symlinkSync)(dependencyRoot, workspaceNodeModules);
+	ensureProjectTsconfig(projectRoot);
 	(0, node_fs.writeFileSync)(node_path.default.join(workspaceRoot, "app.config.js"), `module.exports = ${JSON.stringify({ expo: {
 		name: config.name,
 		slug: slugFromName(config.name),
 		version: config.version ?? "0.0.0",
 		orientation: "default",
 		platforms: ["ios"],
-		newArchEnabled: true
+		newArchEnabled: true,
+		extra: { bleam: {
+			appearance: config.appearance,
+			buildNumber: config.buildNumber,
+			runtimeVersion: config.runtimeVersion,
+			sdkVersion: config.sdkVersion
+		} }
 	} }, null, 2)}\n`);
 	(0, node_fs.writeFileSync)(node_path.default.join(workspaceRoot, "index.js"), `import { registerApp } from 'bleam/app'\nimport App from ${JSON.stringify(node_path.default.join(projectRoot, "app"))}\n\nregisterApp(App)\n`);
 	(0, node_fs.writeFileSync)(node_path.default.join(workspaceRoot, "metro.config.js"), `const { getDefaultConfig } = require(${JSON.stringify(node_path.default.join(packageRoot, "metro-config.cjs"))})\n\nmodule.exports = getDefaultConfig(__dirname)\n`);
@@ -208,6 +461,7 @@ function createDevWorkspace(projectRoot, config) {
 		main: "index.js",
 		dependencies: {
 			"@types/react": packageJson.dependencies?.["@types/react"],
+			"@biomejs/biome": packageJson.dependencies?.["@biomejs/biome"],
 			expo: packageJson.dependencies?.expo,
 			react: packageJson.dependencies?.react,
 			"react-native": packageJson.dependencies?.["react-native"],
@@ -217,10 +471,49 @@ function createDevWorkspace(projectRoot, config) {
 	}, null, 2)}\n`);
 	(0, node_fs.writeFileSync)(node_path.default.join(workspaceRoot, "tsconfig.json"), `${JSON.stringify({
 		extends: "bleam/tsconfig",
-		include: [node_path.default.relative(workspaceRoot, node_path.default.join(projectRoot, "app.tsx")), node_path.default.relative(workspaceRoot, node_path.default.join(projectRoot, "app.config.ts"))]
+		compilerOptions: { paths: {
+			bleam: ["./node_modules/bleam/dist/index"],
+			"bleam/*": ["./node_modules/bleam/dist/*"],
+			expo: ["./node_modules/expo"],
+			"expo/*": ["./node_modules/expo/*"],
+			react: ["./node_modules/@types/react"],
+			"react/jsx-runtime": ["./node_modules/@types/react/jsx-runtime"],
+			"react/jsx-dev-runtime": ["./node_modules/@types/react/jsx-dev-runtime"],
+			"react-native": ["./node_modules/react-native"],
+			"react-native/*": ["./node_modules/react-native/*"]
+		} },
+		include: [node_path.default.relative(workspaceRoot, node_path.default.join(projectRoot, "app")), node_path.default.relative(workspaceRoot, node_path.default.join(projectRoot, "app.config.ts"))]
 	}, null, 2)}\n`);
 	return workspaceRoot;
 }
+function writeBiomeConfig(configPath) {
+	(0, node_fs.writeFileSync)(configPath, `${JSON.stringify({
+		$schema: "https://biomejs.dev/schemas/2.5.2/schema.json",
+		files: { includes: [
+			"app/**/*",
+			"app.config.ts",
+			"tsconfig.json"
+		] },
+		formatter: {
+			enabled: true,
+			indentStyle: "space",
+			indentWidth: 2,
+			lineWidth: 80
+		},
+		javascript: { formatter: {
+			quoteStyle: "single",
+			semicolons: "asNeeded",
+			trailingCommas: "all"
+		} },
+		linter: {
+			enabled: true,
+			rules: {
+				preset: "recommended",
+				suspicious: { noExplicitAny: "off" }
+			}
+		}
+	}, null, 2)}\n`);
+}
 function writeProjectRuntimeConfig(projectRoot, config, origin) {
 	const projectConfigPath = node_path.default.join(projectRoot, ".bleam", "project.json");
 	(0, node_fs.mkdirSync)(node_path.default.dirname(projectConfigPath), { recursive: true });
@@ -229,28 +522,220 @@ function writeProjectRuntimeConfig(projectRoot, config, origin) {
 		version: config.version,
 		bundleIdentifier: config.bundleIdentifier,
 		teamId: config.teamId,
+		appearance: config.appearance,
 		devServer: origin,
 		runtimeVersion: config.runtimeVersion,
 		sdkVersion: config.sdkVersion
 	}, null, 2)}\n`);
 	return projectConfigPath;
 }
+function nativeRuntimeTemplateRoot() {
+	return node_path.default.resolve(packageRoot, "..", "..", "app", "bleam");
+}
+function safeArtifactName(name) {
+	return name.trim().replace(/[/:\\]/g, "-").replace(/\s+/g, " ") || "App";
+}
+function xcodeSettingValue(value) {
+	if (/^[A-Za-z0-9_.$-]+$/.test(value)) return value;
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function plistString(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function replacePlistString(plist, key, value) {
+	const pattern = /* @__PURE__ */ new RegExp(`(<key>${key}</key>\\s*<string>)([^<]*)(</string>)`);
+	if (!pattern.test(plist)) return plist;
+	return plist.replace(pattern, `$1${plistString(value)}$3`);
+}
+function writeGeneratedAppJson(nativeRoot, config) {
+	(0, node_fs.writeFileSync)(node_path.default.join(nativeRoot, "app.json"), `${JSON.stringify({ expo: {
+		name: config.name,
+		slug: slugFromName(config.name),
+		version: config.version ?? "1.0.0",
+		platforms: ["ios"],
+		ios: {
+			appleTeamId: config.teamId,
+			buildNumber: config.buildNumber,
+			bundleIdentifier: config.bundleIdentifier
+		}
+	} }, null, 2)}\n`);
+}
+function patchNativeProject(nativeRoot, config) {
+	const projectPath = node_path.default.join(nativeRoot, "ios", "Bleam.xcodeproj", "project.pbxproj");
+	const infoPlistPath = node_path.default.join(nativeRoot, "ios", "Bleam", "Info.plist");
+	const productName = xcodeSettingValue(config.name);
+	const bundleIdentifier = xcodeSettingValue(config.bundleIdentifier ?? "");
+	const teamId = xcodeSettingValue(config.teamId ?? "");
+	const version = xcodeSettingValue(config.version ?? "1.0.0");
+	const buildNumber = xcodeSettingValue(config.buildNumber);
+	let project = (0, node_fs.readFileSync)(projectPath, "utf8");
+	project = project.replace(/PRODUCT_BUNDLE_IDENTIFIER = [^;]+;/g, () => {
+		return `PRODUCT_BUNDLE_IDENTIFIER = ${bundleIdentifier};`;
+	}).replace(/DEVELOPMENT_TEAM = [^;]+;/g, () => {
+		return `DEVELOPMENT_TEAM = ${teamId};`;
+	}).replace(/MARKETING_VERSION = [^;]+;/g, () => {
+		return `MARKETING_VERSION = ${version};`;
+	}).replace(/CURRENT_PROJECT_VERSION = [^;]+;/g, () => {
+		return `CURRENT_PROJECT_VERSION = ${buildNumber};`;
+	}).replace(/PRODUCT_NAME = [^;]+;/g, () => {
+		return `PRODUCT_NAME = ${productName};`;
+	});
+	(0, node_fs.writeFileSync)(projectPath, project);
+	let infoPlist = (0, node_fs.readFileSync)(infoPlistPath, "utf8");
+	infoPlist = replacePlistString(infoPlist, "CFBundleDisplayName", config.name);
+	infoPlist = replacePlistString(infoPlist, "CFBundleShortVersionString", config.version ?? "1.0.0");
+	infoPlist = replacePlistString(infoPlist, "CFBundleVersion", config.buildNumber);
+	(0, node_fs.writeFileSync)(infoPlistPath, infoPlist);
+}
+function createBuildNativeWorkspace(options, config) {
+	const nativeRoot = node_path.default.join(options.projectRoot, ".bleam", "build", "native");
+	const templateRoot = nativeRuntimeTemplateRoot();
+	(0, node_fs.rmSync)(nativeRoot, {
+		recursive: true,
+		force: true
+	});
+	(0, node_fs.mkdirSync)(node_path.default.dirname(nativeRoot), { recursive: true });
+	(0, node_fs.cpSync)(templateRoot, nativeRoot, {
+		recursive: true,
+		filter(source) {
+			return !node_path.default.relative(templateRoot, source).split(node_path.default.sep).some((part) => {
+				return part === "build" || part === "dist" || part === "node_modules" || part === ".expo" || part === "Pods" || part === ".xcode.env.local" || part === ".DS_Store" || part.endsWith(".xcworkspace");
+			});
+		}
+	});
+	const nodeModules = node_path.default.join(nativeRoot, "node_modules");
+	(0, node_fs.rmSync)(nodeModules, {
+		recursive: true,
+		force: true
+	});
+	(0, node_fs.symlinkSync)(resolvedDependencyRoot(), nodeModules);
+	writeGeneratedAppJson(nativeRoot, config);
+	(0, node_fs.writeFileSync)(node_path.default.join(nativeRoot, "index.ts"), `import { registerApp } from 'bleam/app'\nimport App from ${JSON.stringify(node_path.default.join(options.projectRoot, "app"))}\n\nregisterApp(App)\n`);
+	(0, node_fs.writeFileSync)(node_path.default.join(nativeRoot, "metro.config.js"), `const { getDefaultConfig } = require(${JSON.stringify(node_path.default.join(packageRoot, "metro-config.cjs"))})\n\nmodule.exports = getDefaultConfig(__dirname)\n`);
+	(0, node_fs.writeFileSync)(node_path.default.join(nativeRoot, "ios", ".xcode.env"), `export NODE_BINARY=$(command -v node)\nexport BLEAM_PROJECT_ROOT=${singleQuotedString(options.projectRoot)}\nexport BLEAM_DEV_PLATFORM=macos\n`);
+	patchNativeProject(nativeRoot, config);
+	return nativeRoot;
+}
+function preflightBuild(options, config) {
+	if (process.platform !== "darwin") throw new Error(`bleam build requires macOS and Xcode. Current platform: ${process.platform}.\n${doctorHint(options.projectRoot)}`);
+	if (!config.bundleIdentifier) throw missingBuildFieldError("bundleIdentifier");
+	if (!config.teamId) throw missingBuildFieldError("teamId");
+	const templateRoot = nativeRuntimeTemplateRoot();
+	if (!(0, node_fs.existsSync)(templateRoot)) throw new Error(`Missing native runtime template: ${templateRoot}\n${doctorHint(options.projectRoot)}`);
+	if (!commandSucceeds("pod", ["--version"])) throw new Error(`CocoaPods is required for bleam build, but ${(0, yoctocolors.bold)("pod")} is unavailable.\nInstall CocoaPods, then run bleam build again.\n${doctorHint(options.projectRoot)}`);
+	if (!commandSucceeds("xcodebuild", ["-version"])) throw new Error(`Xcode command line tools are required for bleam build, but ${(0, yoctocolors.bold)("xcodebuild")} is unavailable.\nInstall Xcode or run ${(0, yoctocolors.bold)("xcode-select --install")}, then run bleam build again.\n${doctorHint(options.projectRoot)}`);
+}
+function runInheritedCommand(command, args, cwd) {
+	const text = commandText(command, args);
+	const result = (0, node_child_process.spawnSync)(command, args, {
+		cwd,
+		stdio: "inherit",
+		env: process.env
+	});
+	if (result.error) throw new Error(`${text} could not start in ${cwd}: ${result.error.message}\n${doctorHint()}`);
+	if (result.status !== 0) throw new Error(`${text} failed in ${cwd} with exit code ${result.status ?? "unknown"}.\nNative command output above may contain the underlying Xcode/CocoaPods error.\n${doctorHint()}`);
+}
+function installPods(nativeRoot) {
+	console.log("Installing native dependencies...");
+	runInheritedCommand("pod", ["install"], node_path.default.join(nativeRoot, "ios"));
+}
+function archiveNativeApp(options) {
+	const platformOutput = node_path.default.join(options.outputRoot, "macos");
+	const archivePath = node_path.default.join(platformOutput, `${safeArtifactName(options.config.name)}.xcarchive`);
+	(0, node_fs.mkdirSync)(platformOutput, { recursive: true });
+	(0, node_fs.rmSync)(archivePath, {
+		recursive: true,
+		force: true
+	});
+	console.log(`Archiving ${options.config.name} for macOS...`);
+	runInheritedCommand("xcodebuild", [
+		"-allowProvisioningUpdates",
+		"-workspace",
+		node_path.default.join(options.nativeRoot, "ios", "Bleam.xcworkspace"),
+		"-scheme",
+		"bleam",
+		"-configuration",
+		options.configuration,
+		"-destination",
+		"platform=macOS,arch=arm64,variant=Mac Catalyst",
+		"-archivePath",
+		archivePath,
+		"archive"
+	], options.nativeRoot);
+	return archivePath;
+}
+function exportNativeArchive(options) {
+	const exportPath = node_path.default.join(options.outputRoot, "macos", "export");
+	(0, node_fs.rmSync)(exportPath, {
+		recursive: true,
+		force: true
+	});
+	(0, node_fs.mkdirSync)(exportPath, { recursive: true });
+	console.log("Exporting macOS archive...");
+	runInheritedCommand("xcodebuild", [
+		"-allowProvisioningUpdates",
+		"-exportArchive",
+		"-archivePath",
+		options.archivePath,
+		"-exportPath",
+		exportPath,
+		"-exportOptionsPlist",
+		options.exportOptionsPlist
+	], node_path.default.dirname(options.archivePath));
+	return exportPath;
+}
+async function buildNativeArchives(options) {
+	const config = readProjectConfig(options);
+	preflightBuild(options, config);
+	const nativeRoot = createBuildNativeWorkspace(options, config);
+	installPods(nativeRoot);
+	const archivePath = archiveNativeApp({
+		nativeRoot,
+		outputRoot: options.output,
+		configuration: options.configuration,
+		config
+	});
+	console.log(`Created ${archivePath}`);
+	if (options.exportOptionsPlist) {
+		const exportPath = exportNativeArchive({
+			archivePath,
+			outputRoot: options.output,
+			exportOptionsPlist: options.exportOptionsPlist
+		});
+		console.log(`Exported ${exportPath}`);
+	}
+}
 function runtimeCacheRoot() {
-	return node_path.default.join(node_os.default.homedir(), "Library", "Caches", "bleam", "runtimes", runtimeVersion, runtimePlatform);
+	return node_path.default.join(node_os.default.homedir(), "Library", "Caches", "bleam", "runtimes", runtimeVersion, artifactPlatform());
 }
 function localDevelopmentRuntimeAppPath() {
-	return node_path.default.resolve(packageRoot, "..", "..", "app", "bleam", "build", "Build", "Products", "Debug-maccatalyst", "Bleam.app");
+	const productsRoot = node_path.default.resolve(packageRoot, "..", "..", "app", "bleam", "build", "Build", "Products", "Debug-maccatalyst");
+	for (const appName of ["Bleam.app", "bleam.app"]) {
+		const appPath = node_path.default.join(productsRoot, appName);
+		if ((0, node_fs.existsSync)(appPath)) return appPath;
+	}
+	return node_path.default.join(productsRoot, "Bleam.app");
 }
 function runtimeReleaseBaseUrl() {
 	return process.env.BLEAM_RUNTIME_RELEASE_BASE_URL ?? "https://github.com/bajedev/bleam-app/releases/download";
 }
 function runtimeArchiveName() {
-	return `bleam-runtime-v${runtimeVersion}-${runtimePlatform}.zip`;
+	return `bleam-runtime-v${runtimeVersion}-${artifactPlatform()}.zip`;
 }
 function runtimeArchiveUrl() {
 	const tag = encodeURIComponent(`bleam@${runtimeVersion}`);
 	return `${runtimeReleaseBaseUrl()}/${tag}/${runtimeArchiveName()}`;
 }
+function runtimeResolutionDetails() {
+	return [
+		`Runtime version: ${runtimeVersion}`,
+		`Runtime platform: ${artifactPlatform()}`,
+		`Runtime cache: ${runtimeCacheRoot()}`,
+		`Release URL: ${runtimeArchiveUrl()}`,
+		`Override with BLEAM_RUNTIME_APP=/path/to/Bleam.app for local testing.`,
+		doctorHint()
+	].join("\n");
+}
 function sha256(filePath) {
 	return (0, node_crypto.createHash)("sha256").update((0, node_fs.readFileSync)(filePath)).digest("hex");
 }
@@ -265,7 +750,8 @@ async function downloadExpectedSha256(url) {
 	return (await response.text()).trim().split(/\s+/)[0];
 }
 async function downloadRuntimeArtifact() {
-	if (process.platform !== "darwin") throw new Error("Bleam runtime artifacts are currently only available on macOS.");
+	if (process.platform !== "darwin") throw new Error("Bleam runtime artifacts are currently only available from macOS hosts.");
+	const runtimePlatform = artifactPlatform();
 	const cacheRoot = runtimeCacheRoot();
 	const cachedAppPath = node_path.default.join(cacheRoot, "Bleam.app");
 	if ((0, node_fs.existsSync)(cachedAppPath)) return {
@@ -312,10 +798,11 @@ async function downloadRuntimeArtifact() {
 	};
 }
 async function resolveRuntimeArtifact() {
+	const runtimePlatform = artifactPlatform();
 	const overrideAppPath = process.env.BLEAM_RUNTIME_APP;
 	if (overrideAppPath) {
 		const appPath = node_path.default.resolve(overrideAppPath);
-		if (!(0, node_fs.existsSync)(appPath)) throw new Error(`BLEAM_RUNTIME_APP does not exist: ${appPath}`);
+		if (!(0, node_fs.existsSync)(appPath)) throw new Error(`BLEAM_RUNTIME_APP points to a missing app bundle: ${appPath}\nUnset BLEAM_RUNTIME_APP or point it to a valid Bleam.app.\n${doctorHint()}`);
 		return {
 			appPath,
 			version: runtimeVersion,
@@ -328,7 +815,11 @@ async function resolveRuntimeArtifact() {
 		version: runtimeVersion,
 		platform: runtimePlatform
 	};
-	return downloadRuntimeArtifact();
+	try {
+		return await downloadRuntimeArtifact();
+	} catch (error) {
+		throw new Error(`Failed to resolve the Bleam runtime.\n${runtimeResolutionDetails()}\n\nCause: ${error instanceof Error ? error.message : String(error)}`);
+	}
 }
 function copyRuntimeClient(projectRoot, runtime) {
 	const clientAppPath = node_path.default.join(projectRoot, ".bleam", "client", "Bleam.app");
@@ -340,39 +831,6 @@ function copyRuntimeClient(projectRoot, runtime) {
 	(0, node_fs.cpSync)(runtime.appPath, clientAppPath, { recursive: true });
 	return clientAppPath;
 }
-function waitForDevServer(port, timeoutMs = 12e4) {
-	return new Promise((resolve, reject) => {
-		const startedAt = Date.now();
-		const poll = () => {
-			const req = node_http.default.get(`http://localhost:${port}/status`, (res) => {
-				let data = "";
-				res.on("data", (chunk) => {
-					data += chunk.toString();
-				});
-				res.on("end", () => {
-					if (data.includes("packager-status:running")) {
-						resolve();
-						return;
-					}
-					retry();
-				});
-			});
-			req.on("error", retry);
-			req.setTimeout(2e3, () => {
-				req.destroy();
-				retry();
-			});
-		};
-		const retry = () => {
-			if (Date.now() - startedAt > timeoutMs) {
-				reject(/* @__PURE__ */ new Error(`Bleam dev server did not start within ${timeoutMs / 1e3}s`));
-				return;
-			}
-			setTimeout(poll, 500);
-		};
-		poll();
-	});
-}
 function isBleamManifest(value) {
 	const manifest = value && typeof value === "object" ? value : {};
 	return typeof manifest.name === "string" && typeof manifest.bundleUrl === "string" && manifest.platform === "macos" && manifest.dev === true;
@@ -380,18 +838,138 @@ function isBleamManifest(value) {
 async function readDevManifest(origin, timeoutMs = 3e4) {
 	const manifestUrl = `${origin}/bleam/manifest.json`;
 	const startedAt = Date.now();
+	const spinner = startSpinner("Waiting for Bleam dev server...");
 	while (Date.now() - startedAt <= timeoutMs) {
 		try {
 			const response = await fetch(manifestUrl, { cache: "no-store" });
 			const value = await response.json();
-			if (response.ok && isBleamManifest(value)) return value;
+			if (response.ok && isBleamManifest(value)) {
+				spinner?.success("Bleam dev server is ready");
+				return value;
+			}
 		} catch {}
 		await new Promise((resolve) => setTimeout(resolve, 500));
 	}
+	spinner?.error("Bleam dev server did not become available");
 	throw new Error(`Bleam manifest did not become available: ${manifestUrl}`);
 }
+function pushDoctorCheck(checks, status, label, detail) {
+	checks.push({
+		status,
+		label,
+		detail
+	});
+}
+function printDoctorSection(title, checks) {
+	if (checks.length === 0) return;
+	console.log(`\n${heading(title)}`);
+	for (const check of checks) {
+		const detail = check.detail ? muted(`: ${check.detail}`) : "";
+		console.log(`  ${statusLabel(check.status)} ${check.label}${detail}`);
+	}
+}
+function runDoctor(options) {
+	const projectChecks = [];
+	const runtimeChecks = [];
+	const environmentChecks = [];
+	const appConfigPath = node_path.default.join(options.projectRoot, "app.config.ts");
+	const appEntryPath = node_path.default.join(options.projectRoot, "app", "index.tsx");
+	if ((0, node_fs.existsSync)(appConfigPath)) pushDoctorCheck(projectChecks, "pass", "app.config.ts found");
+	else pushDoctorCheck(projectChecks, "fail", "app.config.ts missing");
+	if ((0, node_fs.existsSync)(appEntryPath)) pushDoctorCheck(projectChecks, "pass", "app/index.tsx found");
+	else pushDoctorCheck(projectChecks, "fail", "app/index.tsx missing");
+	try {
+		const config = readProjectConfig(options);
+		pushDoctorCheck(projectChecks, "pass", "config loaded");
+		pushDoctorCheck(projectChecks, "pass", "name", config.name);
+		if (config.bundleIdentifier) pushDoctorCheck(projectChecks, "pass", "bundleIdentifier", config.bundleIdentifier);
+		else pushDoctorCheck(projectChecks, "warn", "bundleIdentifier not configured", "required for bleam build");
+		if (config.teamId) pushDoctorCheck(projectChecks, "pass", "teamId", config.teamId);
+		else pushDoctorCheck(projectChecks, "warn", "teamId not configured", "required for bleam build");
+	} catch (error) {
+		pushDoctorCheck(projectChecks, "fail", "config failed to load", error instanceof Error ? error.message : String(error));
+	}
+	const cacheRoot = runtimeCacheRoot();
+	const cachedAppPath = node_path.default.join(cacheRoot, "Bleam.app");
+	const localAppPath = localDevelopmentRuntimeAppPath();
+	pushDoctorCheck(runtimeChecks, "pass", "version", runtimeVersion);
+	pushDoctorCheck(runtimeChecks, "pass", "platform", artifactPlatform());
+	pushDoctorCheck(runtimeChecks, "pass", "cache", prettyPath(cacheRoot));
+	if ((0, node_fs.existsSync)(cachedAppPath)) pushDoctorCheck(runtimeChecks, "pass", "cached runtime found");
+	else pushDoctorCheck(runtimeChecks, "warn", "runtime not cached yet", "bleam dev can download it on demand");
+	if ((0, node_fs.existsSync)(localAppPath)) pushDoctorCheck(runtimeChecks, "pass", "local development runtime found", prettyPath(localAppPath));
+	else pushDoctorCheck(runtimeChecks, "warn", "local development runtime not found", prettyPath(localAppPath));
+	const overrideAppPath = process.env.BLEAM_RUNTIME_APP;
+	if (overrideAppPath) {
+		const appPath = node_path.default.resolve(overrideAppPath);
+		pushDoctorCheck(runtimeChecks, (0, node_fs.existsSync)(appPath) ? "pass" : "fail", "BLEAM_RUNTIME_APP", prettyPath(appPath));
+	}
+	pushDoctorCheck(runtimeChecks, "pass", "release artifact URL", runtimeArchiveUrl());
+	pushDoctorCheck(environmentChecks, process.platform === "darwin" ? "pass" : "fail", "macOS host", process.platform);
+	pushDoctorCheck(environmentChecks, "pass", "node", prettyPath(process.execPath));
+	const hasXcodebuild = commandSucceeds("xcodebuild", ["-version"]);
+	pushDoctorCheck(environmentChecks, hasXcodebuild ? "pass" : "warn", "xcodebuild", hasXcodebuild ? "available" : "unavailable");
+	const hasPod = commandSucceeds("pod", ["--version"]);
+	pushDoctorCheck(environmentChecks, hasPod ? "pass" : "warn", "pod", hasPod ? "available" : "unavailable");
+	const allChecks = [
+		...projectChecks,
+		...runtimeChecks,
+		...environmentChecks
+	];
+	const counts = {
+		pass: allChecks.filter((check) => check.status === "pass").length,
+		warn: allChecks.filter((check) => check.status === "warn").length,
+		fail: allChecks.filter((check) => check.status === "fail").length
+	};
+	console.log(heading("Bleam Doctor"));
+	printDoctorSection("Project", projectChecks);
+	printDoctorSection("Runtime", runtimeChecks);
+	printDoctorSection("Environment", environmentChecks);
+	console.log(`\n${heading("Summary")}`);
+	console.log(`  ${(0, yoctocolors.green)(`${counts.pass} passed`)}, ${(0, yoctocolors.yellow)(`${counts.warn} warnings`)}, ${counts.fail > 0 ? (0, yoctocolors.red)(`${counts.fail} failed`) : (0, yoctocolors.green)("0 failed")}`);
+	if (counts.fail > 0) process.exit(1);
+}
+function formatDuration(ms) {
+	return `${(ms / 1e3).toFixed(1)}s`;
+}
+async function waitForDevBundle(bundleUrl, timeoutMs = 6e4) {
+	const startedAt = Date.now();
+	const requestTimeoutMs = 3e4;
+	const spinner = startSpinner("Bundling app...");
+	while (Date.now() - startedAt <= timeoutMs) {
+		const requestStartedAt = Date.now();
+		try {
+			const response = await fetch(bundleUrl, {
+				cache: "no-store",
+				signal: AbortSignal.timeout(requestTimeoutMs)
+			});
+			await response.body?.cancel();
+			if (response.ok) {
+				spinner?.success(`Bundled app in ${formatDuration(Date.now() - startedAt)}`);
+				if (!spinner) console.log(`Bundled app in ${formatDuration(Date.now() - startedAt)}`);
+				return;
+			}
+			if (spinner) spinner.text = `Bundle request returned ${response.status}, retrying...`;
+			else console.log(`Bundle request returned ${response.status}, retrying...`);
+		} catch (error) {
+			if (error instanceof Error && error.name === "TimeoutError") {
+				const message = `Bundle request timed out after ${formatDuration(Date.now() - requestStartedAt)}, retrying...`;
+				if (spinner) spinner.text = message;
+				else console.log(message);
+			} else {
+				const message = `Bundle request failed: ${error instanceof Error ? error.message : String(error)}`;
+				if (spinner) spinner.text = `${message}, retrying...`;
+				else console.log(message);
+			}
+		}
+		await new Promise((resolve) => setTimeout(resolve, 500));
+	}
+	spinner?.error("Bundle did not complete");
+	throw new Error(`Bleam bundle did not complete within ${formatDuration(timeoutMs)}.\nBundle URL: ${bundleUrl}\n${doctorHint()}`);
+}
 function openRuntimeClient(appPath, projectConfigPath, manifest) {
-	(0, node_child_process.spawn)("open", [
+	const child = (0, node_child_process.spawn)("open", [
+		"-n",
 		appPath,
 		"--args",
 		"--bleam-project-config",
@@ -400,10 +978,220 @@ function openRuntimeClient(appPath, projectConfigPath, manifest) {
 		manifest.bundleUrl,
 		"--bleam-title",
 		manifest.name
-	], {
-		detached: true,
-		stdio: "ignore"
-	}).unref();
+	], { stdio: "ignore" });
+	child.on("error", (error) => {
+		console.error(`Failed to open Bleam runtime at ${appPath}: ${error.message}`);
+	});
+	child.on("exit", (code) => {
+		if (code && code !== 0) console.error(`Failed to open Bleam runtime at ${appPath}`);
+	});
+}
+async function launchRuntimeClient(appPath, projectConfigPath, manifest) {
+	openRuntimeClient(appPath, projectConfigPath, manifest);
+}
+function focusRuntimeClient() {
+	return (0, node_child_process.spawnSync)("osascript", ["-e", "tell application id \"dev.bleam.app\" to activate"], { stdio: "ignore" }).status === 0;
+}
+function sendJson(res, status, value) {
+	res.writeHead(status, {
+		"Cache-Control": "no-store",
+		"Content-Type": "application/json; charset=utf-8"
+	});
+	res.end(JSON.stringify(value));
+}
+async function requestRuntimeReload(origin) {
+	const response = await fetch(`${origin}/bleam/reload`, {
+		method: "POST",
+		cache: "no-store"
+	});
+	const value = await response.json();
+	if (!response.ok) throw new Error(`Reload request failed: ${response.status}`);
+	const reload = value;
+	return typeof reload.clients === "number" ? reload.clients : 0;
+}
+function biomeBinPath() {
+	const biomePackageJsonPath = require$1.resolve("@biomejs/biome/package.json");
+	const biomePackageRoot = node_path.default.dirname(biomePackageJsonPath);
+	const biomePackage = require$1("@biomejs/biome/package.json");
+	const bin = typeof biomePackage.bin === "string" ? biomePackage.bin : biomePackage.bin?.biome;
+	if (!bin) throw new Error("Could not resolve @biomejs/biome binary");
+	return node_path.default.join(biomePackageRoot, bin);
+}
+function ensureProjectToolWorkspace(options) {
+	const config = readProjectConfig({ projectRoot: options.projectRoot });
+	return createDevWorkspace(options.projectRoot, config);
+}
+function runBiomeCommand(command, options) {
+	assertBleamConfigFiles(options.projectRoot);
+	ensureProjectToolWorkspace(options);
+	const configPath = node_path.default.join(options.projectRoot, "biome.json");
+	const existingConfig = (0, node_fs.existsSync)(configPath) ? (0, node_fs.readFileSync)(configPath, "utf8") : void 0;
+	const args = [
+		command,
+		"--config-path",
+		"biome.json"
+	];
+	if (command === "check" && options.write) args.push("--write");
+	if (command === "format" && !options.formatCheck) args.push("--write");
+	args.push("app", "app.config.ts", "tsconfig.json");
+	writeBiomeConfig(configPath);
+	const result = (0, node_child_process.spawnSync)(biomeBinPath(), args, {
+		cwd: options.projectRoot,
+		stdio: "inherit"
+	});
+	if (existingConfig === void 0) (0, node_fs.rmSync)(configPath, { force: true });
+	else (0, node_fs.writeFileSync)(configPath, existingConfig);
+	if (result.error) throw result.error;
+	process.exit(result.status ?? 1);
+}
+function setupInteractiveControls(options) {
+	if (!process.stdin.isTTY) return () => {};
+	const wasRaw = process.stdin.isRaw;
+	let closed = false;
+	const cleanup = () => {
+		if (closed) return;
+		closed = true;
+		process.stdin.off("data", onData);
+		process.stdin.setRawMode(wasRaw);
+	};
+	const onData = (data) => {
+		for (const byte of data) {
+			if (byte === 3) {
+				cleanup();
+				options.stop();
+				return;
+			}
+			const key = String.fromCharCode(byte).toLowerCase();
+			if (key === "o") {
+				(async () => {
+					try {
+						if (!focusRuntimeClient()) {
+							console.log("Opening Bleam app...");
+							await launchRuntimeClient(options.clientAppPath, options.projectConfigPath, options.manifest);
+						}
+					} catch (error) {
+						console.error(error instanceof Error ? error.message : String(error));
+					}
+				})();
+				continue;
+			}
+			if (key === "r") requestRuntimeReload(options.origin).then((clients) => {
+				console.log(`Reloaded app (${clients} client${clients === 1 ? "" : "s"})`);
+			}).catch((error) => {
+				console.error(error instanceof Error ? error.message : String(error));
+			});
+		}
+	};
+	process.stdin.setRawMode(true);
+	process.stdin.resume();
+	process.stdin.on("data", onData);
+	console.log("Press o to open, r to reload, Ctrl+C to stop.");
+	return cleanup;
+}
+async function startInternalMetroServer(options) {
+	process.env.BLEAM_DEV_PLATFORM ??= "macos";
+	const metro = require$1("@expo/metro/metro");
+	const { loadConfig } = require$1("@expo/metro/metro-config");
+	const config = await loadConfig({
+		config: node_path.default.join(options.workspaceRoot, "metro.config.js"),
+		cwd: options.workspaceRoot,
+		port: options.port
+	});
+	const { middleware, end, attachHmrServer } = await metro.createConnectMiddleware(config, {
+		watch: true,
+		waitForBundler: true
+	});
+	const messageClients = /* @__PURE__ */ new Set();
+	const messageServer = new ws.WebSocketServer({ noServer: true });
+	const broadcastReload = () => {
+		const message = JSON.stringify({
+			version: 2,
+			method: "reload",
+			params: {}
+		});
+		let clients = 0;
+		for (const client of messageClients) if (client.readyState === ws.WebSocket.OPEN) {
+			client.send(message);
+			clients += 1;
+		}
+		return clients;
+	};
+	messageServer.on("connection", (client) => {
+		messageClients.add(client);
+		client.on("close", () => messageClients.delete(client));
+	});
+	const server = node_http.default.createServer((req, res) => {
+		if (req.url?.split("?")[0] === "/status") {
+			res.writeHead(200, {
+				"Cache-Control": "no-store",
+				"Content-Type": "text/plain; charset=utf-8",
+				"X-React-Native-Project-Root": encodeURI(config.projectRoot)
+			});
+			res.end("packager-status:running");
+			return;
+		}
+		if (req.url?.split("?")[0] === "/bleam/reload") {
+			if (req.method !== "POST") {
+				res.writeHead(405, { Allow: "POST" });
+				res.end();
+				return;
+			}
+			sendJson(res, 200, {
+				ok: true,
+				clients: broadcastReload()
+			});
+			return;
+		}
+		middleware(req, res, (error) => {
+			if (res.headersSent) return;
+			if (error) {
+				console.error(error.message);
+				res.writeHead(500, {
+					"Cache-Control": "no-store",
+					"Content-Type": "text/plain; charset=utf-8"
+				});
+				res.end(error.message);
+				return;
+			}
+			res.writeHead(404, {
+				"Cache-Control": "no-store",
+				"Content-Type": "text/plain; charset=utf-8"
+			});
+			res.end("Not found");
+		});
+	});
+	server.timeout = 0;
+	attachHmrServer(server);
+	const metroUpgradeListeners = server.listeners("upgrade");
+	server.removeAllListeners("upgrade");
+	server.on("upgrade", (req, socket, head) => {
+		if (req.url?.split("?")[0] === "/message") {
+			messageServer.handleUpgrade(req, socket, head, (client) => {
+				messageServer.emit("connection", client, req);
+			});
+			return;
+		}
+		for (const listener of metroUpgradeListeners) listener.call(server, req, socket, head);
+	});
+	await new Promise((resolve, reject) => {
+		server.on("error", reject);
+		server.listen(options.port, "localhost", () => resolve());
+	});
+	server.on("error", (error) => {
+		console.error(error instanceof Error ? error.message : String(error));
+	});
+	console.log(`Bleam dev server running at http://localhost:${options.port}`);
+	const close = () => {
+		setTimeout(() => process.exit(0), 1e3).unref();
+		messageServer.close();
+		for (const client of messageClients) client.terminate();
+		server.close(() => {
+			end();
+			process.exit(0);
+		});
+	};
+	process.on("SIGINT", close);
+	process.on("SIGTERM", close);
 }
 async function startDevServer(options) {
 	const config = readProjectConfig(options);
@@ -413,10 +1201,10 @@ async function startDevServer(options) {
 	const origin = `http://localhost:${options.port}`;
 	const projectConfigPath = writeProjectRuntimeConfig(options.projectRoot, config, origin);
 	const child = (0, node_child_process.spawn)(process.execPath, [
-		require$1.resolve("expo/bin/cli"),
-		"start",
+		(0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href),
+		"internal:metro",
+		"--workspace-root",
 		workspaceRoot,
-		"--localhost",
 		"--port",
 		String(options.port)
 	], {
@@ -428,11 +1216,12 @@ async function startDevServer(options) {
 			BLEAM_DEV_NAME: config.name,
 			BLEAM_DEV_ORIGIN: origin,
 			BLEAM_DEV_PORT: String(options.port),
+			BLEAM_DEV_PLATFORM: "macos",
 			BLEAM_DEV_RUNTIME_VERSION: config.runtimeVersion,
 			BLEAM_DEV_SDK_VERSION: config.sdkVersion,
 			NODE_PATH: [
 				node_path.default.join(options.projectRoot, "node_modules"),
-				node_path.default.join(packageRoot, "node_modules"),
+				resolvedDependencyRoot(),
 				node_path.default.dirname(node_path.default.dirname(require$1.resolve("expo/package.json"))),
 				node_path.default.dirname(node_path.default.dirname(require$1.resolve("react/package.json"))),
 				node_path.default.dirname(node_path.default.dirname(require$1.resolve("react-native/package.json"))),
@@ -440,15 +1229,51 @@ async function startDevServer(options) {
 			].filter(Boolean).join(node_path.default.delimiter)
 		}
 	});
+	let cleanupInteractiveControls = () => {};
+	let stopping = false;
 	const stop = (signal) => {
+		if (stopping) return;
+		stopping = true;
+		cleanupInteractiveControls();
 		child.kill(signal);
+		setTimeout(() => process.exit(0), 2e3).unref();
 	};
 	process.on("SIGINT", () => stop("SIGINT"));
 	process.on("SIGTERM", () => stop("SIGTERM"));
-	child.on("exit", (code) => process.exit(code ?? 0));
-	await waitForDevServer(options.port);
-	const manifest = await readDevManifest(origin);
-	if (process.env.BLEAM_NO_OPEN !== "1") openRuntimeClient(clientAppPath, projectConfigPath, manifest);
+	child.on("error", (error) => {
+		cleanupInteractiveControls();
+		console.error(`Bleam dev server process failed: ${error instanceof Error ? error.message : String(error)}`);
+		console.error(doctorHint(options.projectRoot));
+		process.exit(1);
+	});
+	child.on("exit", (code) => {
+		cleanupInteractiveControls();
+		process.exit(code ?? 0);
+	});
+	try {
+		const manifest = await readDevManifest(origin);
+		cleanupInteractiveControls = setupInteractiveControls({
+			origin,
+			clientAppPath,
+			projectConfigPath,
+			manifest,
+			stop: () => stop("SIGINT")
+		});
+		if (options.run && process.env.BLEAM_NO_OPEN !== "1") try {
+			await waitForDevBundle(manifest.bundleUrl);
+			console.log("Opening Bleam app...");
+			await launchRuntimeClient(clientAppPath, projectConfigPath, manifest);
+		} catch (error) {
+			console.error(`Initial app launch failed: ${error instanceof Error ? error.message : String(error)}`);
+			console.error(doctorHint(options.projectRoot));
+			console.error("Check BLEAM_RUNTIME_APP if you are using a runtime override.");
+			console.error("Bleam dev server is still running.");
+		}
+	} catch (error) {
+		cleanupInteractiveControls();
+		child.kill("SIGTERM");
+		throw error;
+	}
 }
 async function main(argv = process.argv.slice(2)) {
 	const [command, ...args] = argv;
@@ -461,7 +1286,8 @@ async function main(argv = process.argv.slice(2)) {
 		createNewProject(options);
 		if (options.run) await startDevServer({
 			projectRoot: options.projectRoot,
-			port: 8081
+			port: 8081,
+			run: true
 		});
 		return;
 	}
@@ -469,6 +1295,30 @@ async function main(argv = process.argv.slice(2)) {
 		await startDevServer(parseDevOptions(args));
 		return;
 	}
+	if (command === "build") {
+		await buildNativeArchives(parseBuildOptions(args));
+		return;
+	}
+	if (command === "doctor") {
+		runDoctor(parseDoctorOptions(args));
+		return;
+	}
+	if (command === "check") {
+		runBiomeCommand("check", parseProjectToolOptions(args));
+		return;
+	}
+	if (command === "format") {
+		runBiomeCommand("format", parseProjectToolOptions(args));
+		return;
+	}
+	if (command === "lint") {
+		runBiomeCommand("lint", parseProjectToolOptions(args));
+		return;
+	}
+	if (command === "internal:metro") {
+		await startInternalMetroServer(parseInternalMetroOptions(args));
+		return;
+	}
 	throw new Error(`Unknown command: ${command}`);
 }
 main().catch((error) => {