bleam 0.0.6 → 0.0.7

package/dist/cli.cjs

@@ -28,6 +28,7 @@ const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__
 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 starterAppName = "Bleam Basic";
 function artifactPlatform() {
 	return `macos-${process.arch}`;
 }
@@ -85,16 +86,52 @@ function printUsage() {
 	console.log(`Usage: bleam <command>
 
 Commands:
-  new [dir] [--run]         Create a new Bleam project
-  dev [dir] [--port <port>] [--run]
+  new <dir> [--template <name>]
+                            Create and run a Bleam project
+  dev [dir] [--port <port>] [--no-run] [--clean]
                             Start a Bleam dev server
-  build [dir] [--output <dir>]
-                            Build App Store-ready native archives
+  build [dir] [--output <dir>] [--clean]
+                            Export standalone native archives
+  install [dir] [--output <dir>] [--clean]
+                            Build and install a standalone macOS app
+  publish ota [dir] [--service-url <url>]
+                            Publish an OTA update to the local update service
+  publish platform [dir] [--service-url <url>]
+                            Build and publish a platform update locally
   doctor [dir]              Check the local Bleam environment
+  typecheck [dir]           Typecheck project files
   check [dir] [--write]     Format, lint, and organize imports
   format [dir] [--check]    Format project files
   lint [dir]                Lint project files`);
 }
+function parsePublishOtaOptions(argv) {
+	const root = invocationRoot();
+	let projectRoot = root;
+	let hasProjectRootArg = false;
+	let serviceUrl = process.env.BLEAM_UPDATE_SERVICE_URL ?? "http://127.0.0.1:8787";
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--service-url") {
+			serviceUrl = argv[++index] ?? "";
+			continue;
+		}
+		if (arg.startsWith("--service-url=")) {
+			serviceUrl = arg.slice(14);
+			continue;
+		}
+		if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+		if (hasProjectRootArg) throw new Error("Only one project directory may be specified");
+		projectRoot = node_path.default.resolve(root, arg);
+		hasProjectRootArg = true;
+	}
+	const url = new URL(serviceUrl);
+	if (url.protocol !== "http:" || !["127.0.0.1", "localhost"].includes(url.hostname)) throw new Error("Local publishing requires an http://localhost service URL");
+	if (!hasProjectRootArg && !isBleamProjectRoot(projectRoot)) projectRoot = discoverBleamProjectRoot(projectRoot) ?? projectRoot;
+	return {
+		projectRoot: canonicalPath(projectRoot),
+		serviceUrl: url.origin
+	};
+}
 function invocationRoot() {
 	const pwd = process.env.PWD;
 	return pwd && node_path.default.isAbsolute(pwd) ? pwd : process.cwd();
@@ -107,7 +144,8 @@ function parseDevOptions(argv) {
 	const root = invocationRoot();
 	let projectRoot = root;
 	let port = 8081;
-	let run = false;
+	let run = true;
+	let clean = false;
 	let hasProjectRootArg = false;
 	for (let index = 0; index < argv.length; index += 1) {
 		const arg = argv[index];
@@ -124,6 +162,14 @@ function parseDevOptions(argv) {
 			run = true;
 			continue;
 		}
+		if (arg === "--no-run") {
+			run = false;
+			continue;
+		}
+		if (arg === "--clean" || arg === "-c") {
+			clean = true;
+			continue;
+		}
 		if (arg === "--help" || arg === "-h") {
 			printUsage();
 			process.exit(0);
@@ -137,36 +183,55 @@ function parseDevOptions(argv) {
 	return {
 		projectRoot: canonicalPath(projectRoot),
 		port,
-		run
+		run,
+		clean
 	};
 }
 function parseNewOptions(argv) {
 	const root = invocationRoot();
-	let projectRoot = root;
-	let run = false;
-	for (const arg of argv) {
-		if (arg === "--run") {
-			run = true;
-			continue;
-		}
+	let projectRoot;
+	let template = "basic";
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
 		if (arg === "--help" || arg === "-h") {
 			printUsage();
 			process.exit(0);
 		}
+		if (arg === "--template") {
+			template = projectTemplate(argv[++index] ?? "");
+			continue;
+		}
+		if (arg.startsWith("--template=")) {
+			template = projectTemplate(arg.slice(11));
+			continue;
+		}
 		if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+		if (projectRoot) throw new Error("Only one project directory may be specified");
 		projectRoot = node_path.default.resolve(root, arg);
 	}
+	if (!projectRoot) throw new Error("Usage: bleam new <dir>");
 	return {
 		projectRoot: canonicalPath(projectRoot),
-		run
+		template
 	};
 }
+const projectTemplates = [
+	"basic",
+	"state",
+	"foundation-models",
+	"image-generation"
+];
+function projectTemplate(value) {
+	if (projectTemplates.includes(value)) return value;
+	throw new Error(`Unknown template: ${value}. Expected ${projectTemplates.join(", ")}`);
+}
 function parseBuildOptions(argv) {
 	const root = invocationRoot();
 	let projectRoot = root;
 	let hasProjectRootArg = false;
 	let output;
 	let configuration = "Release";
+	let clean = false;
 	let exportOptionsPlist;
 	for (let index = 0; index < argv.length; index += 1) {
 		const arg = argv[index];
@@ -188,6 +253,10 @@ function parseBuildOptions(argv) {
 			configuration = arg.slice(16);
 			continue;
 		}
+		if (arg === "--clean") {
+			clean = true;
+			continue;
+		}
 		if (arg === "--export-options-plist") {
 			exportOptionsPlist = argv[++index];
 			continue;
@@ -210,6 +279,7 @@ function parseBuildOptions(argv) {
 		projectRoot: resolvedProjectRoot,
 		output: node_path.default.resolve(resolvedProjectRoot, output ?? "dist"),
 		configuration,
+		clean,
 		exportOptionsPlist: exportOptionsPlist ? node_path.default.resolve(root, exportOptionsPlist) : void 0
 	};
 }
@@ -262,6 +332,7 @@ function parseDoctorOptions(argv) {
 function parseInternalMetroOptions(argv) {
 	let workspaceRoot;
 	let port = 8081;
+	let resetCache = false;
 	for (let index = 0; index < argv.length; index += 1) {
 		const arg = argv[index];
 		if (arg === "--workspace-root") {
@@ -276,13 +347,18 @@ function parseInternalMetroOptions(argv) {
 			port = Number(arg.slice(7));
 			continue;
 		}
+		if (arg === "--reset-cache") {
+			resetCache = true;
+			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
+		port,
+		resetCache
 	};
 }
 function isBleamProjectRoot(projectRoot) {
@@ -322,6 +398,11 @@ function assertStringField(value, field) {
 	if (typeof value !== "string" || value.trim() === "") throw new Error(`app.config.ts must define ${field}`);
 	return value;
 }
+function normalizeAppGroups(value, bundleIdentifier) {
+	const configured = Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+	if (configured.length > 0) return configured;
+	return bundleIdentifier ? [`group.${bundleIdentifier}`] : [];
+}
 function isHexColor(value) {
 	return typeof value === "string" && /^#[\da-f]{6}$/i.test(value);
 }
@@ -365,11 +446,13 @@ function loadAppConfig(projectRoot) {
 	});
 	if (result.status !== 0) throw new Error(result.stderr.trim() || "Failed to load app.config.ts");
 	const value = JSON.parse(result.stdout);
+	const bundleIdentifier = typeof value.bundleIdentifier === "string" ? value.bundleIdentifier : void 0;
 	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,
+		bundleIdentifier,
+		appGroups: normalizeAppGroups(value.appGroups, bundleIdentifier),
 		teamId: typeof value.teamId === "string" ? value.teamId : void 0,
 		appearance: normalizeAppearance(value.appearance)
 	};
@@ -392,6 +475,7 @@ function readProjectConfig(options) {
 		version: config.version,
 		buildNumber: config.buildNumber ?? "1",
 		bundleIdentifier: config.bundleIdentifier,
+		appGroups: config.appGroups ?? [],
 		teamId: config.teamId,
 		appearance: config.appearance ?? normalizeAppearance(void 0),
 		runtimeVersion,
@@ -409,22 +493,40 @@ function nameFromDirectory(projectRoot) {
 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 });
+function updateStarterAppName(projectRoot, name) {
+	const appPath = node_path.default.join(projectRoot, "app", "index.tsx");
+	const source = (0, node_fs.readFileSync)(appPath, "utf8");
+	const placeholder = `const appName = ${singleQuotedString(starterAppName)}`;
+	if (!source.includes(placeholder)) throw new Error(`Missing starter app name placeholder: ${appPath}`);
+	(0, node_fs.writeFileSync)(appPath, source.replace(placeholder, `const appName = ${singleQuotedString(name)}`));
+}
+function createProject(options) {
+	const template = options.template ?? "basic";
+	const templateRoot = node_path.default.join(packageRoot, "templates", template);
+	if (!(0, node_fs.existsSync)(templateRoot)) throw new Error(`Missing ${template} template: ${templateRoot}`);
+	if ((0, node_fs.existsSync)(options.projectRoot)) throw new Error(`Destination already exists: ${options.projectRoot}`);
 	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
-	});
+	(0, node_fs.mkdirSync)(options.projectRoot, { recursive: true });
+	try {
+		(0, node_fs.cpSync)(templateRoot, options.projectRoot, { recursive: true });
+		updateStarterAppName(options.projectRoot, name);
+		(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",
+			appGroups: [],
+			appearance: normalizeAppearance(void 0),
+			runtimeVersion,
+			sdkVersion: runtimeVersion
+		});
+	} catch (error) {
+		(0, node_fs.rmSync)(options.projectRoot, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
 	console.log(`Created Bleam project at ${options.projectRoot}`);
 }
 function createDevWorkspace(projectRoot, config) {
@@ -438,7 +540,7 @@ function createDevWorkspace(projectRoot, config) {
 	});
 	(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: {
+	const expoConfig = {
 		name: config.name,
 		slug: slugFromName(config.name),
 		version: config.version ?? "0.0.0",
@@ -451,7 +553,10 @@ function createDevWorkspace(projectRoot, config) {
 			runtimeVersion: config.runtimeVersion,
 			sdkVersion: config.sdkVersion
 		} }
-	} }, null, 2)}\n`);
+	};
+	if ((0, node_fs.existsSync)(node_path.default.join(projectRoot, "icon.png"))) expoConfig.icon = "../../icon.png";
+	if ((0, node_fs.existsSync)(node_path.default.join(projectRoot, "splash.png"))) expoConfig.plugins = [["expo-splash-screen", { image: "../../splash.png" }]];
+	(0, node_fs.writeFileSync)(node_path.default.join(workspaceRoot, "app.config.js"), `module.exports = ${JSON.stringify({ expo: expoConfig }, 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`);
 	(0, node_fs.writeFileSync)(node_path.default.join(workspaceRoot, "package.json"), `${JSON.stringify({
@@ -463,6 +568,7 @@ function createDevWorkspace(projectRoot, config) {
 			"@types/react": packageJson.dependencies?.["@types/react"],
 			"@biomejs/biome": packageJson.dependencies?.["@biomejs/biome"],
 			expo: packageJson.dependencies?.expo,
+			"expo-splash-screen": packageJson.dependencies?.["expo-splash-screen"],
 			react: packageJson.dependencies?.react,
 			"react-native": packageJson.dependencies?.["react-native"],
 			typescript: packageJson.dependencies?.typescript
@@ -547,6 +653,24 @@ function replacePlistString(plist, key, value) {
 	if (!pattern.test(plist)) return plist;
 	return plist.replace(pattern, `$1${plistString(value)}$3`);
 }
+function plistStringArray(values) {
+	return values.map((value) => `\t\t<string>${plistString(value)}</string>`).join("\n");
+}
+function replaceOrInsertPlistString(plist, key, value) {
+	const replaced = replacePlistString(plist, key, value);
+	if (replaced !== plist) return replaced;
+	const closingDictionary = plist.lastIndexOf("</dict>");
+	if (closingDictionary < 0) return plist;
+	return `${plist.slice(0, closingDictionary)}\t<key>${key}</key>\n\t<string>${plistString(value)}</string>\n${plist.slice(closingDictionary)}`;
+}
+function replaceOrInsertPlistStringArray(plist, key, values) {
+	const pattern = /* @__PURE__ */ new RegExp(`(<key>${key}</key>\\s*<array>)([\\s\\S]*?)(</array>)`);
+	const replacement = `$1\n${plistStringArray(values)}\n\t$3`;
+	if (pattern.test(plist)) return plist.replace(pattern, replacement);
+	const closingDictionary = plist.lastIndexOf("</dict>");
+	if (closingDictionary < 0) return plist;
+	return `${plist.slice(0, closingDictionary)}\t<key>${key}</key>\n\t<array>\n${plistStringArray(values)}\n\t</array>\n${plist.slice(closingDictionary)}`;
+}
 function writeGeneratedAppJson(nativeRoot, config) {
 	(0, node_fs.writeFileSync)(node_path.default.join(nativeRoot, "app.json"), `${JSON.stringify({ expo: {
 		name: config.name,
@@ -563,40 +687,60 @@ function writeGeneratedAppJson(nativeRoot, config) {
 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 generationInfoPlistPath = node_path.default.join(nativeRoot, "ios", "GenerationService", "Info.plist");
+	const platformInfoPlistPath = node_path.default.join(nativeRoot, "ios", "PlatformHelper", "Info.plist");
+	const appEntitlementsPath = node_path.default.join(nativeRoot, "ios", "Bleam", "bleam.entitlements");
+	const generationEntitlementsPath = node_path.default.join(nativeRoot, "ios", "GenerationService", "GenerationService.entitlements");
 	const productName = xcodeSettingValue(config.name);
 	const bundleIdentifier = xcodeSettingValue(config.bundleIdentifier ?? "");
+	const generationBundleIdentifier = xcodeSettingValue(`${config.bundleIdentifier}.GenerationService`);
+	const platformBundleIdentifier = xcodeSettingValue(`${config.bundleIdentifier}.PlatformHelper`);
 	const teamId = xcodeSettingValue(config.teamId ?? "");
 	const version = xcodeSettingValue(config.version ?? "1.0.0");
 	const buildNumber = xcodeSettingValue(config.buildNumber);
+	const primaryAppGroup = config.appGroups[0];
 	let project = (0, node_fs.readFileSync)(projectPath, "utf8");
-	project = project.replace(/PRODUCT_BUNDLE_IDENTIFIER = [^;]+;/g, () => {
-		return `PRODUCT_BUNDLE_IDENTIFIER = ${bundleIdentifier};`;
+	project = project.replace(/PRODUCT_BUNDLE_IDENTIFIER = ([^;]+);/g, (_, current) => {
+		return `PRODUCT_BUNDLE_IDENTIFIER = ${current.endsWith(".GenerationService") ? generationBundleIdentifier : current.endsWith(".PlatformHelper") ? platformBundleIdentifier : 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, () => {
+	}).replace(/PRODUCT_NAME = bleam;/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 = replaceOrInsertPlistString(infoPlist, "BleamRuntimeVersion", config.runtimeVersion);
+	infoPlist = replaceOrInsertPlistString(infoPlist, "BleamTeamIdentifier", config.teamId ?? "");
+	const updateServiceUrl = process.env.BLEAM_UPDATE_SERVICE_URL;
+	if (updateServiceUrl) infoPlist = replaceOrInsertPlistString(infoPlist, "BleamUpdateServiceURL", updateServiceUrl);
 	infoPlist = replacePlistString(infoPlist, "CFBundleVersion", config.buildNumber);
+	if (primaryAppGroup) infoPlist = replaceOrInsertPlistString(infoPlist, "AppGroupIdentifier", primaryAppGroup);
 	(0, node_fs.writeFileSync)(infoPlistPath, infoPlist);
+	if (primaryAppGroup) {
+		let generationInfoPlist = (0, node_fs.readFileSync)(generationInfoPlistPath, "utf8");
+		generationInfoPlist = replaceOrInsertPlistString(generationInfoPlist, "AppGroupIdentifier", primaryAppGroup);
+		(0, node_fs.writeFileSync)(generationInfoPlistPath, generationInfoPlist);
+		(0, node_fs.writeFileSync)(platformInfoPlistPath, replaceOrInsertPlistString((0, node_fs.readFileSync)(platformInfoPlistPath, "utf8"), "BleamPlatformVersion", config.runtimeVersion));
+		for (const entitlementsPath of [appEntitlementsPath, generationEntitlementsPath]) (0, node_fs.writeFileSync)(entitlementsPath, replaceOrInsertPlistStringArray((0, node_fs.readFileSync)(entitlementsPath, "utf8"), "com.apple.security.application-groups", config.appGroups));
+	}
 }
 function createBuildNativeWorkspace(options, config) {
 	const nativeRoot = node_path.default.join(options.projectRoot, ".bleam", "build", "native");
 	const templateRoot = nativeRuntimeTemplateRoot();
-	(0, node_fs.rmSync)(nativeRoot, {
+	if (options.clean) (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,
+		verbatimSymlinks: 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");
@@ -636,32 +780,66 @@ function runInheritedCommand(command, args, cwd) {
 	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) {
+	const iosRoot = node_path.default.join(nativeRoot, "ios");
+	const expectedStamp = podInstallInputStamp(iosRoot);
+	if (hasCurrentPodInstall(iosRoot, expectedStamp)) {
+		console.log("Using cached native dependencies");
+		return;
+	}
 	console.log("Installing native dependencies...");
-	runInheritedCommand("pod", ["install"], node_path.default.join(nativeRoot, "ios"));
+	runInheritedCommand("pod", ["install"], iosRoot);
+	(0, node_fs.writeFileSync)(podInstallStampPath(iosRoot), `${expectedStamp}\n`);
+}
+function podInstallInputStamp(iosRoot) {
+	const inputHash = (0, node_crypto.createHash)("sha256");
+	for (const relative of [
+		"Podfile",
+		"Podfile.lock",
+		"../package.json"
+	]) {
+		const input = node_path.default.resolve(iosRoot, relative);
+		if ((0, node_fs.existsSync)(input)) inputHash.update((0, node_fs.readFileSync)(input));
+	}
+	return inputHash.digest("hex");
 }
-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", [
+function podInstallStampPath(iosRoot) {
+	return node_path.default.join(iosRoot, ".bleam-pods-input");
+}
+function hasCurrentPodInstall(iosRoot, expectedStamp) {
+	const stampPath = podInstallStampPath(iosRoot);
+	return (0, node_fs.existsSync)(node_path.default.join(iosRoot, "Bleam.xcworkspace")) && (0, node_fs.existsSync)(node_path.default.join(iosRoot, "Pods", "Manifest.lock")) && (0, node_fs.existsSync)(stampPath) && (0, node_fs.readFileSync)(stampPath, "utf8").trim() === expectedStamp;
+}
+function nativeArchiveArgs(options) {
+	return [
 		"-allowProvisioningUpdates",
 		"-workspace",
 		node_path.default.join(options.nativeRoot, "ios", "Bleam.xcworkspace"),
 		"-scheme",
-		"bleam",
+		"Bleam",
 		"-configuration",
 		options.configuration,
 		"-destination",
 		"platform=macOS,arch=arm64,variant=Mac Catalyst",
 		"-archivePath",
-		archivePath,
+		options.archivePath,
+		"ARCHS=arm64",
 		"archive"
-	], options.nativeRoot);
+	];
+}
+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", nativeArchiveArgs({
+		nativeRoot: options.nativeRoot,
+		archivePath,
+		configuration: options.configuration
+	}), options.nativeRoot);
 	return archivePath;
 }
 function exportNativeArchive(options) {
@@ -704,6 +882,177 @@ async function buildNativeArchives(options) {
 		});
 		console.log(`Exported ${exportPath}`);
 	}
+	return archivePath;
+}
+async function installNativeApp(options) {
+	const destination = installArchivedApp(await buildNativeArchives(options));
+	console.log(`Installed ${destination}`);
+}
+function installArchivedApp(archivePath, applications = node_path.default.join(node_os.default.homedir(), "Applications")) {
+	const products = node_path.default.join(archivePath, "Products", "Applications");
+	const appName = (0, node_fs.readdirSync)(products).find((name) => name.endsWith(".app"));
+	if (!appName) throw new Error(`Archive does not contain a macOS app: ${archivePath}`);
+	const source = node_path.default.join(products, appName);
+	const destination = applications === node_path.default.join(node_os.default.homedir(), "Applications") ? installedAppPath(appName) : node_path.default.join(applications, appName);
+	(0, node_fs.mkdirSync)(applications, { recursive: true });
+	(0, node_fs.rmSync)(destination, {
+		recursive: true,
+		force: true
+	});
+	(0, node_child_process.execFileSync)("ditto", [source, destination], { stdio: "inherit" });
+	return destination;
+}
+function installedAppPath(appName) {
+	if (node_path.default.basename(appName) !== appName || !appName.endsWith(".app")) throw new Error(`Invalid macOS app name: ${appName}`);
+	return node_path.default.join(node_os.default.homedir(), "Applications", appName);
+}
+async function publishOta(options) {
+	const config = readProjectConfig(options);
+	if (!config.bundleIdentifier) throw missingBuildFieldError("bundleIdentifier");
+	if (!config.teamId) throw missingBuildFieldError("teamId");
+	const workspaceRoot = createBuildNativeWorkspace({
+		projectRoot: options.projectRoot,
+		output: node_path.default.join(options.projectRoot, "dist"),
+		configuration: "Release",
+		clean: false
+	}, config);
+	const outputRoot = node_path.default.join(options.projectRoot, ".bleam", "publish", "ota");
+	const bundleRoot = node_path.default.join(outputRoot, "bundle");
+	const bundlePath = node_path.default.join(bundleRoot, "bundle.js");
+	const archivePath = node_path.default.join(outputRoot, "ota.zip");
+	(0, node_fs.rmSync)(outputRoot, {
+		recursive: true,
+		force: true
+	});
+	(0, node_fs.mkdirSync)(bundleRoot, { recursive: true });
+	console.log(`Bundling OTA update for runtime ${runtimeVersion}...`);
+	runInheritedCommand(process.execPath, [
+		require$1.resolve("@expo/cli"),
+		"export:embed",
+		"--entry-file",
+		node_path.default.join(workspaceRoot, "index.ts"),
+		"--platform",
+		"ios",
+		"--dev",
+		"false",
+		"--bundle-output",
+		bundlePath,
+		"--assets-dest",
+		node_path.default.join(bundleRoot, "assets"),
+		"--minify",
+		"true"
+	], workspaceRoot);
+	runInheritedCommand("ditto", [
+		"-c",
+		"-k",
+		"--keepParent",
+		bundleRoot,
+		archivePath
+	], outputRoot);
+	const sizeBytes = (0, node_fs.readFileSync)(archivePath).byteLength;
+	const digest = sha256(archivePath);
+	const releaseId = `ota_${Date.now().toString(36)}_${digest.slice(0, 12)}`;
+	const release = {
+		schemaVersion: 1,
+		kind: "ota",
+		bundleIdentifier: config.bundleIdentifier,
+		teamIdentifier: config.teamId,
+		channel: "stable",
+		releaseId,
+		bundleVersion: `${config.version ?? "1.0.0"}+${config.buildNumber}`,
+		runtimeVersion,
+		artifact: {
+			format: "bleam-ota-zip-v1",
+			downloadId: releaseId,
+			sizeBytes,
+			sha256: digest
+		},
+		publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const response = await fetch(`${options.serviceUrl}/v1/local/releases/ota`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			release,
+			artifactBase64: (0, node_fs.readFileSync)(archivePath).toString("base64")
+		})
+	});
+	if (!response.ok) throw new Error(`Local OTA publication failed: ${response.status} ${await response.text()}`);
+	console.log(`Published OTA update ${releaseId}`);
+	console.log(`${options.serviceUrl}/v1/apps/${encodeURIComponent(config.bundleIdentifier)}/ota/${runtimeVersion}`);
+}
+async function publishPlatform(options) {
+	const config = readProjectConfig(options);
+	if (!config.bundleIdentifier) throw missingBuildFieldError("bundleIdentifier");
+	if (!config.teamId) throw missingBuildFieldError("teamId");
+	const archivePath = await buildNativeArchives({
+		projectRoot: options.projectRoot,
+		output: node_path.default.join(options.projectRoot, "dist"),
+		configuration: "Release",
+		clean: false
+	});
+	const products = node_path.default.join(archivePath, "Products", "Applications");
+	const appName = (0, node_fs.readdirSync)(products).find((name) => name.endsWith(".app"));
+	if (!appName) throw new Error(`Archive does not contain a macOS app: ${archivePath}`);
+	const outputRoot = node_path.default.join(options.projectRoot, ".bleam", "publish", "platform");
+	const stagingRoot = node_path.default.join(outputRoot, "app");
+	const artifactPath = node_path.default.join(outputRoot, "platform.zip");
+	(0, node_fs.rmSync)(outputRoot, {
+		recursive: true,
+		force: true
+	});
+	(0, node_fs.mkdirSync)(stagingRoot, { recursive: true });
+	(0, node_child_process.execFileSync)("ditto", [node_path.default.join(products, appName), node_path.default.join(stagingRoot, appName)]);
+	runInheritedCommand("zip", [
+		"-q",
+		"-r",
+		"-y",
+		artifactPath,
+		"app"
+	], outputRoot);
+	const sizeBytes = (0, node_fs.readFileSync)(artifactPath).byteLength;
+	const digest = sha256(artifactPath);
+	const releaseId = `platform_${Date.now().toString(36)}_${digest.slice(0, 12)}`;
+	const release = platformRelease(config, releaseId, sizeBytes, digest);
+	const response = await fetch(`${options.serviceUrl}/v1/local/releases/platform`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			release,
+			artifactBase64: (0, node_fs.readFileSync)(artifactPath).toString("base64")
+		})
+	});
+	if (!response.ok) throw new Error(`Local platform publication failed: ${response.status} ${await response.text()}`);
+	console.log(`Published platform update ${releaseId}`);
+	console.log(`${options.serviceUrl}/v1/apps/${encodeURIComponent(config.bundleIdentifier)}/platform/macos-arm64`);
+}
+function platformRelease(config, releaseId, sizeBytes, digest) {
+	if (!config.bundleIdentifier) throw missingBuildFieldError("bundleIdentifier");
+	if (!config.teamId) throw missingBuildFieldError("teamId");
+	return {
+		schemaVersion: 1,
+		kind: "platform",
+		bundleIdentifier: config.bundleIdentifier,
+		teamIdentifier: config.teamId,
+		channel: "stable",
+		releaseId,
+		appVersion: config.version ?? "1.0.0",
+		buildNumber: config.buildNumber,
+		bleamPlatformVersion: runtimeVersion,
+		target: {
+			os: "macos",
+			architecture: "arm64",
+			installLocation: "user-applications",
+			minimumMacOSVersion: "14.0"
+		},
+		artifact: {
+			format: "bleam-macos-app-zip-v1",
+			downloadId: releaseId,
+			sizeBytes,
+			sha256: digest
+		},
+		publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
 }
 function runtimeCacheRoot() {
 	return node_path.default.join(node_os.default.homedir(), "Library", "Caches", "bleam", "runtimes", runtimeVersion, artifactPlatform());
@@ -754,16 +1103,22 @@ async function downloadRuntimeArtifact() {
 	const runtimePlatform = artifactPlatform();
 	const cacheRoot = runtimeCacheRoot();
 	const cachedAppPath = node_path.default.join(cacheRoot, "Bleam.app");
-	if ((0, node_fs.existsSync)(cachedAppPath)) return {
-		appPath: cachedAppPath,
-		version: runtimeVersion,
-		platform: runtimePlatform
-	};
+	if ((0, node_fs.existsSync)(cachedAppPath)) {
+		console.log(`Using cached Bleam runtime at ${prettyPath(cachedAppPath)}`);
+		return {
+			appPath: cachedAppPath,
+			version: runtimeVersion,
+			platform: runtimePlatform
+		};
+	}
 	(0, node_fs.mkdirSync)(cacheRoot, { recursive: true });
 	const archiveUrl = runtimeArchiveUrl();
 	const archivePath = node_path.default.join(cacheRoot, runtimeArchiveName());
 	const extractRoot = node_path.default.join(cacheRoot, "extract");
+	console.log(`Downloading Bleam runtime ${runtimeVersion} for ${runtimePlatform}`);
+	console.log(`Runtime archive: ${archiveUrl}`);
 	await downloadFile(archiveUrl, archivePath);
+	console.log("Verifying Bleam runtime archive");
 	const expectedSha256 = await downloadExpectedSha256(archiveUrl);
 	if (expectedSha256 && sha256(archivePath) !== expectedSha256) {
 		(0, node_fs.rmSync)(archivePath, { force: true });
@@ -774,6 +1129,7 @@ async function downloadRuntimeArtifact() {
 		force: true
 	});
 	(0, node_fs.mkdirSync)(extractRoot, { recursive: true });
+	console.log("Extracting Bleam runtime archive");
 	(0, node_child_process.execFileSync)("ditto", [
 		"-x",
 		"-k",
@@ -786,11 +1142,15 @@ async function downloadRuntimeArtifact() {
 		recursive: true,
 		force: true
 	});
-	(0, node_fs.cpSync)(extractedAppPath, cachedAppPath, { recursive: true });
+	(0, node_fs.cpSync)(extractedAppPath, cachedAppPath, {
+		recursive: true,
+		verbatimSymlinks: true
+	});
 	(0, node_fs.rmSync)(extractRoot, {
 		recursive: true,
 		force: true
 	});
+	console.log(`Cached Bleam runtime at ${prettyPath(cachedAppPath)}`);
 	return {
 		appPath: cachedAppPath,
 		version: runtimeVersion,
@@ -799,10 +1159,12 @@ async function downloadRuntimeArtifact() {
 }
 async function resolveRuntimeArtifact() {
 	const runtimePlatform = artifactPlatform();
+	console.log(`Resolving Bleam runtime ${runtimeVersion} for ${runtimePlatform}`);
 	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 points to a missing app bundle: ${appPath}\nUnset BLEAM_RUNTIME_APP or point it to a valid Bleam.app.\n${doctorHint()}`);
+		console.log(`Using BLEAM_RUNTIME_APP runtime at ${prettyPath(appPath)}`);
 		return {
 			appPath,
 			version: runtimeVersion,
@@ -810,11 +1172,14 @@ async function resolveRuntimeArtifact() {
 		};
 	}
 	const localAppPath = localDevelopmentRuntimeAppPath();
-	if ((0, node_fs.existsSync)(localAppPath)) return {
-		appPath: localAppPath,
-		version: runtimeVersion,
-		platform: runtimePlatform
-	};
+	if ((0, node_fs.existsSync)(localAppPath)) {
+		console.log(`Using local development runtime at ${prettyPath(localAppPath)}`);
+		return {
+			appPath: localAppPath,
+			version: runtimeVersion,
+			platform: runtimePlatform
+		};
+	}
 	try {
 		return await downloadRuntimeArtifact();
 	} catch (error) {
@@ -823,14 +1188,31 @@ async function resolveRuntimeArtifact() {
 }
 function copyRuntimeClient(projectRoot, runtime) {
 	const clientAppPath = node_path.default.join(projectRoot, ".bleam", "client", "Bleam.app");
+	console.log(`Preparing Bleam app at ${prettyPath(clientAppPath)}`);
 	(0, node_fs.rmSync)(clientAppPath, {
 		recursive: true,
 		force: true
 	});
 	(0, node_fs.mkdirSync)(node_path.default.dirname(clientAppPath), { recursive: true });
-	(0, node_fs.cpSync)(runtime.appPath, clientAppPath, { recursive: true });
+	(0, node_fs.cpSync)(runtime.appPath, clientAppPath, {
+		recursive: true,
+		verbatimSymlinks: true
+	});
 	return clientAppPath;
 }
+function cleanDevArtifacts(projectRoot) {
+	const bleamRoot = node_path.default.join(projectRoot, ".bleam");
+	const targets = [
+		"client",
+		"dev",
+		"project.json"
+	].map((name) => node_path.default.join(bleamRoot, name));
+	console.log("Cleaning Bleam dev artifacts");
+	for (const target of targets) (0, node_fs.rmSync)(target, {
+		recursive: true,
+		force: true
+	});
+}
 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;
@@ -932,6 +1314,15 @@ function runDoctor(options) {
 function formatDuration(ms) {
 	return `${(ms / 1e3).toFixed(1)}s`;
 }
+async function bundleErrorPreview(response) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (!contentType.includes("json") && !contentType.includes("text")) return "";
+	try {
+		return (await response.text()).trim().slice(0, 1e3);
+	} catch {
+		return "";
+	}
+}
 async function waitForDevBundle(bundleUrl, timeoutMs = 6e4) {
 	const startedAt = Date.now();
 	const requestTimeoutMs = 3e4;
@@ -943,14 +1334,17 @@ async function waitForDevBundle(bundleUrl, timeoutMs = 6e4) {
 				cache: "no-store",
 				signal: AbortSignal.timeout(requestTimeoutMs)
 			});
-			await response.body?.cancel();
 			if (response.ok) {
+				await response.body?.cancel();
 				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...`);
+			const preview = await bundleErrorPreview(response);
+			const detail = preview ? `\n${preview}` : "";
+			const message = `Bundle request returned ${response.status}, retrying...${detail}`;
+			if (spinner) spinner.text = message;
+			else console.log(message);
 		} catch (error) {
 			if (error instanceof Error && error.name === "TimeoutError") {
 				const message = `Bundle request timed out after ${formatDuration(Date.now() - requestStartedAt)}, retrying...`;
@@ -986,7 +1380,11 @@ function openRuntimeClient(appPath, projectConfigPath, manifest) {
 		if (code && code !== 0) console.error(`Failed to open Bleam runtime at ${appPath}`);
 	});
 }
+function quitRuntimeClient() {
+	(0, node_child_process.spawnSync)("osascript", ["-e", "tell application id \"dev.bleam.app\" to quit"], { stdio: "ignore" });
+}
 async function launchRuntimeClient(appPath, projectConfigPath, manifest) {
+	quitRuntimeClient();
 	openRuntimeClient(appPath, projectConfigPath, manifest);
 }
 function focusRuntimeClient() {
@@ -999,6 +1397,49 @@ function sendJson(res, status, value) {
 	});
 	res.end(JSON.stringify(value));
 }
+function readRequestBody(req, limit = 1e6) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > limit) {
+				reject(/* @__PURE__ */ new Error("Request body too large"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+function isLogLevel(value) {
+	return value === "debug" || value === "info" || value === "warn" || value === "error";
+}
+function isLogSource(value) {
+	return value === "cli" || value === "metro" || value === "runtime" || value === "js" || value === "native" || value === "xpc";
+}
+function normalizeDevLogEvent(value) {
+	const input = value && typeof value === "object" ? value : {};
+	const message = typeof input.message === "string" ? input.message : input.message === void 0 ? "" : JSON.stringify(input.message);
+	return {
+		type: "log",
+		id: typeof input.id === "string" && input.id ? input.id : (0, node_crypto.randomUUID)(),
+		time: typeof input.time === "string" && input.time ? input.time : (/* @__PURE__ */ new Date()).toISOString(),
+		source: isLogSource(input.source) ? input.source : "runtime",
+		level: isLogLevel(input.level) ? input.level : "info",
+		category: typeof input.category === "string" && input.category ? input.category : void 0,
+		message,
+		details: input.details,
+		jobId: typeof input.jobId === "string" && input.jobId ? input.jobId : void 0
+	};
+}
+function formatDevLogEvent(event) {
+	const category = event.category ? `:${event.category}` : "";
+	const job = event.jobId ? ` ${event.jobId.slice(0, 8)}` : "";
+	return `[${event.source}${category}:${event.level}${job}] ${event.message}`;
+}
 async function requestRuntimeReload(origin) {
 	const response = await fetch(`${origin}/bleam/reload`, {
 		method: "POST",
@@ -1017,6 +1458,13 @@ function biomeBinPath() {
 	if (!bin) throw new Error("Could not resolve @biomejs/biome binary");
 	return node_path.default.join(biomePackageRoot, bin);
 }
+function typescriptBinPath() {
+	const typescriptPackageJsonPath = require$1.resolve("typescript/package.json");
+	const typescriptPackageRoot = node_path.default.dirname(typescriptPackageJsonPath);
+	const bin = require$1("typescript/package.json").bin?.tsc;
+	if (!bin) throw new Error("Could not resolve TypeScript compiler binary");
+	return node_path.default.join(typescriptPackageRoot, bin);
+}
 function ensureProjectToolWorkspace(options) {
 	const config = readProjectConfig({ projectRoot: options.projectRoot });
 	return createDevWorkspace(options.projectRoot, config);
@@ -1044,6 +1492,20 @@ function runBiomeCommand(command, options) {
 	if (result.error) throw result.error;
 	process.exit(result.status ?? 1);
 }
+function runTypecheckCommand(options) {
+	assertBleamConfigFiles(options.projectRoot);
+	ensureProjectToolWorkspace(options);
+	const result = (0, node_child_process.spawnSync)(typescriptBinPath(), [
+		"--noEmit",
+		"-p",
+		node_path.default.join(options.projectRoot, "tsconfig.json")
+	], {
+		cwd: options.projectRoot,
+		stdio: "inherit"
+	});
+	if (result.error) throw result.error;
+	process.exit(result.status ?? 1);
+}
 function setupInteractiveControls(options) {
 	if (!process.stdin.isTTY) return () => {};
 	const wasRaw = process.stdin.isRaw;
@@ -1065,21 +1527,26 @@ function setupInteractiveControls(options) {
 			if (key === "o") {
 				(async () => {
 					try {
-						if (!focusRuntimeClient()) {
-							console.log("Opening Bleam app...");
-							await launchRuntimeClient(options.clientAppPath, options.projectConfigPath, options.manifest);
+						if (focusRuntimeClient()) {
+							console.log("Focused Bleam app");
+							return;
 						}
+						console.log(`Opening Bleam app at ${prettyPath(options.clientAppPath)}`);
+						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));
-			});
+			if (key === "r") {
+				console.log("Requesting app reload");
+				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);
@@ -1090,12 +1557,18 @@ function setupInteractiveControls(options) {
 }
 async function startInternalMetroServer(options) {
 	process.env.BLEAM_DEV_PLATFORM ??= "macos";
+	const projectRoot = process.env.BLEAM_PROJECT_ROOT ?? options.workspaceRoot;
+	const logPath = node_path.default.join(projectRoot, ".bleam", "dev", "logs", "dev.log");
+	const recentLogs = [];
+	const logClients = /* @__PURE__ */ new Set();
+	const maxRecentLogs = 1e3;
 	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
+		port: options.port,
+		resetCache: options.resetCache
 	});
 	const { middleware, end, attachHmrServer } = await metro.createConnectMiddleware(config, {
 		watch: true,
@@ -1103,6 +1576,16 @@ async function startInternalMetroServer(options) {
 	});
 	const messageClients = /* @__PURE__ */ new Set();
 	const messageServer = new ws.WebSocketServer({ noServer: true });
+	const logServer = new ws.WebSocketServer({ noServer: true });
+	const recordLog = (event) => {
+		recentLogs.push(event);
+		if (recentLogs.length > maxRecentLogs) recentLogs.splice(0, recentLogs.length - maxRecentLogs);
+		(0, node_fs.mkdirSync)(node_path.default.dirname(logPath), { recursive: true });
+		(0, node_fs.appendFileSync)(logPath, `${JSON.stringify(event)}\n`, "utf8");
+		const payload = JSON.stringify(event);
+		for (const client of logClients) if (client.readyState === ws.WebSocket.OPEN) client.send(payload);
+		console.log(formatDevLogEvent(event));
+	};
 	const broadcastReload = () => {
 		const message = JSON.stringify({
 			version: 2,
@@ -1120,6 +1603,11 @@ async function startInternalMetroServer(options) {
 		messageClients.add(client);
 		client.on("close", () => messageClients.delete(client));
 	});
+	logServer.on("connection", (client) => {
+		logClients.add(client);
+		for (const event of recentLogs) client.send(JSON.stringify(event));
+		client.on("close", () => logClients.delete(client));
+	});
 	const server = node_http.default.createServer((req, res) => {
 		if (req.url?.split("?")[0] === "/status") {
 			res.writeHead(200, {
@@ -1142,6 +1630,29 @@ async function startInternalMetroServer(options) {
 			});
 			return;
 		}
+		if (req.url?.split("?")[0] === "/bleam/logs") {
+			if (req.method === "GET") {
+				sendJson(res, 200, { logs: recentLogs });
+				return;
+			}
+			if (req.method !== "POST") {
+				res.writeHead(405, { Allow: "GET, POST" });
+				res.end();
+				return;
+			}
+			readRequestBody(req).then((body) => {
+				const parsed = body ? JSON.parse(body) : {};
+				const events = Array.isArray(parsed) ? parsed : [parsed];
+				for (const value of events) recordLog(normalizeDevLogEvent(value));
+				sendJson(res, 200, { ok: true });
+			}).catch((error) => {
+				sendJson(res, 400, {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			});
+			return;
+		}
 		middleware(req, res, (error) => {
 			if (res.headersSent) return;
 			if (error) {
@@ -1171,6 +1682,12 @@ async function startInternalMetroServer(options) {
 			});
 			return;
 		}
+		if (req.url?.split("?")[0] === "/bleam/logs/stream") {
+			logServer.handleUpgrade(req, socket, head, (client) => {
+				logServer.emit("connection", client, req);
+			});
+			return;
+		}
 		for (const listener of metroUpgradeListeners) listener.call(server, req, socket, head);
 	});
 	await new Promise((resolve, reject) => {
@@ -1184,7 +1701,9 @@ async function startInternalMetroServer(options) {
 	const close = () => {
 		setTimeout(() => process.exit(0), 1e3).unref();
 		messageServer.close();
+		logServer.close();
 		for (const client of messageClients) client.terminate();
+		for (const client of logClients) client.terminate();
 		server.close(() => {
 			end();
 			process.exit(0);
@@ -1195,8 +1714,10 @@ async function startInternalMetroServer(options) {
 }
 async function startDevServer(options) {
 	const config = readProjectConfig(options);
+	if (options.clean) cleanDevArtifacts(options.projectRoot);
 	const runtime = await resolveRuntimeArtifact();
 	const clientAppPath = copyRuntimeClient(options.projectRoot, runtime);
+	console.log("Preparing Bleam dev workspace");
 	const workspaceRoot = createDevWorkspace(options.projectRoot, config);
 	const origin = `http://localhost:${options.port}`;
 	const projectConfigPath = writeProjectRuntimeConfig(options.projectRoot, config, origin);
@@ -1206,7 +1727,8 @@ async function startDevServer(options) {
 		"--workspace-root",
 		workspaceRoot,
 		"--port",
-		String(options.port)
+		String(options.port),
+		...options.clean ? ["--reset-cache"] : []
 	], {
 		stdio: "inherit",
 		env: {
@@ -1230,24 +1752,32 @@ async function startDevServer(options) {
 		}
 	});
 	let cleanupInteractiveControls = () => {};
+	let didLaunchRuntimeClient = false;
+	let didCleanupDevSession = false;
 	let stopping = false;
+	const cleanupDevSession = () => {
+		if (didCleanupDevSession) return;
+		didCleanupDevSession = true;
+		cleanupInteractiveControls();
+		if (didLaunchRuntimeClient) quitRuntimeClient();
+	};
 	const stop = (signal) => {
 		if (stopping) return;
 		stopping = true;
-		cleanupInteractiveControls();
+		cleanupDevSession();
 		child.kill(signal);
 		setTimeout(() => process.exit(0), 2e3).unref();
 	};
 	process.on("SIGINT", () => stop("SIGINT"));
 	process.on("SIGTERM", () => stop("SIGTERM"));
 	child.on("error", (error) => {
-		cleanupInteractiveControls();
+		cleanupDevSession();
 		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();
+		cleanupDevSession();
 		process.exit(code ?? 0);
 	});
 	try {
@@ -1261,8 +1791,9 @@ async function startDevServer(options) {
 		});
 		if (options.run && process.env.BLEAM_NO_OPEN !== "1") try {
 			await waitForDevBundle(manifest.bundleUrl);
-			console.log("Opening Bleam app...");
+			console.log(`Opening Bleam app at ${prettyPath(clientAppPath)}`);
 			await launchRuntimeClient(clientAppPath, projectConfigPath, manifest);
+			didLaunchRuntimeClient = true;
 		} catch (error) {
 			console.error(`Initial app launch failed: ${error instanceof Error ? error.message : String(error)}`);
 			console.error(doctorHint(options.projectRoot));
@@ -1270,7 +1801,7 @@ async function startDevServer(options) {
 			console.error("Bleam dev server is still running.");
 		}
 	} catch (error) {
-		cleanupInteractiveControls();
+		cleanupDevSession();
 		child.kill("SIGTERM");
 		throw error;
 	}
@@ -1283,11 +1814,12 @@ async function main(argv = process.argv.slice(2)) {
 	}
 	if (command === "new") {
 		const options = parseNewOptions(args);
-		createNewProject(options);
-		if (options.run) await startDevServer({
+		createProject(options);
+		await startDevServer({
 			projectRoot: options.projectRoot,
 			port: 8081,
-			run: true
+			run: true,
+			clean: false
 		});
 		return;
 	}
@@ -1295,14 +1827,34 @@ async function main(argv = process.argv.slice(2)) {
 		await startDevServer(parseDevOptions(args));
 		return;
 	}
+	if (command === "install") {
+		await installNativeApp(parseBuildOptions(args));
+		return;
+	}
 	if (command === "build") {
 		await buildNativeArchives(parseBuildOptions(args));
 		return;
 	}
+	if (command === "publish") {
+		const [kind, ...publishArgs] = args;
+		if (kind === "ota") {
+			await publishOta(parsePublishOtaOptions(publishArgs));
+			return;
+		}
+		if (kind === "platform") {
+			await publishPlatform(parsePublishOtaOptions(publishArgs));
+			return;
+		}
+		throw new Error("Usage: bleam publish <ota|platform> [dir] [--service-url <url>]");
+	}
 	if (command === "doctor") {
 		runDoctor(parseDoctorOptions(args));
 		return;
 	}
+	if (command === "typecheck") {
+		runTypecheckCommand(parseProjectToolOptions(args));
+		return;
+	}
 	if (command === "check") {
 		runBiomeCommand("check", parseProjectToolOptions(args));
 		return;
@@ -1321,9 +1873,24 @@ async function main(argv = process.argv.slice(2)) {
 	}
 	throw new Error(`Unknown command: ${command}`);
 }
-main().catch((error) => {
+if (process.env.VITEST !== "true") main().catch((error) => {
 	console.error(error instanceof Error ? error.message : String(error));
 	process.exit(1);
 });
+const __test = {
+	createProject,
+	createBuildNativeWorkspace,
+	hasCurrentPodInstall,
+	installedAppPath,
+	installArchivedApp,
+	nativeArchiveArgs,
+	parseBuildOptions,
+	parseNewOptions,
+	parsePublishOtaOptions,
+	platformRelease,
+	podInstallInputStamp,
+	replaceOrInsertPlistString
+};
 
-//#endregion
+//#endregion
+exports.__test = __test;