bleam 0.0.1 → 0.0.4

package/dist/app.cjs

@@ -0,0 +1,11 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+let expo = require("expo");
+expo = require_chunk.__toESM(expo);
+
+//#region src/app.ts
+function registerApp(component) {
+	(0, expo.registerRootComponent)(component);
+}
+
+//#endregion
+exports.registerApp = registerApp;

package/dist/app.d.cts

@@ -0,0 +1,7 @@
+import { ComponentType } from "react";
+
+//#region src/app.d.ts
+declare function registerApp(component: ComponentType): void;
+//#endregion
+export { registerApp };
+//# sourceMappingURL=app.d.cts.map

package/dist/app.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.cts","names":[],"sources":["../src/app.ts"],"sourcesContent":[],"mappings":";;;iBAGgB,WAAA,YAAuB"}

package/dist/app.d.ts

@@ -0,0 +1,7 @@
+import { ComponentType } from "react";
+
+//#region src/app.d.ts
+declare function registerApp(component: ComponentType): void;
+//#endregion
+export { registerApp };
+//# sourceMappingURL=app.d.ts.map

package/dist/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","names":[],"sources":["../src/app.ts"],"sourcesContent":[],"mappings":";;;iBAGgB,WAAA,YAAuB"}

package/dist/app.js

@@ -0,0 +1,10 @@
+import { registerRootComponent } from "expo";
+
+//#region src/app.ts
+function registerApp(component) {
+	registerRootComponent(component);
+}
+
+//#endregion
+export { registerApp };
+//# sourceMappingURL=app.js.map

package/dist/app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.js","names":[],"sources":["../src/app.ts"],"sourcesContent":["import { registerRootComponent } from 'expo'\nimport type { ComponentType } from 'react'\n\nexport function registerApp(component: ComponentType) {\n  registerRootComponent(component)\n}\n"],"mappings":";;;AAGA,SAAgB,YAAY,WAA0B;AACpD,uBAAsB,UAAU"}

package/dist/bundler.d.cts

@@ -0,0 +1,28 @@
+//#region src/bundler.d.ts
+interface DevServerOptions {
+  projectRoot: string;
+  port?: number;
+}
+interface DevServerHandle {
+  url: string;
+  close(): Promise<void>;
+}
+interface BundleOptions {
+  projectRoot: string;
+  entry: string;
+  platform: 'macos';
+  dev: boolean;
+}
+interface BundleResult {
+  entry: string;
+  assets: string[];
+}
+interface DevServer {
+  start(options: DevServerOptions): Promise<DevServerHandle>;
+}
+interface Bundler {
+  bundle(options: BundleOptions): Promise<BundleResult>;
+}
+//#endregion
+export { BundleOptions, BundleResult, Bundler, DevServer, DevServerHandle, DevServerOptions };
+//# sourceMappingURL=bundler.d.cts.map

package/dist/bundler.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundler.d.cts","names":[],"sources":["../src/bundler.ts"],"sourcesContent":[],"mappings":";UAAiB,gBAAA;EAAA,WAAA,EAAA,MAAgB;EAKhB,IAAA,CAAA,EAAA,MAAA;AAKjB;AAOiB,UAZA,eAAA,CAYY;EAKZ,GAAA,EAAA,MAAA;EACA,KAAA,EAAA,EAhBN,OAgBM,CAAA,IAAA,CAAA;;AAAmB,UAbnB,aAAA,CAamB;EAAO,WAAA,EAAA,MAAA;EAG1B,KAAA,EAAA,MAAO;EACN,QAAA,EAAA,OAAA;EAAwB,GAAA,EAAA,OAAA;;AAAD,UAVxB,YAAA,CAUwB;;;;UALxB,SAAA;iBACA,mBAAmB,QAAQ;;UAG3B,OAAA;kBACC,gBAAgB,QAAQ"}

package/dist/bundler.d.ts

@@ -0,0 +1,28 @@
+//#region src/bundler.d.ts
+interface DevServerOptions {
+  projectRoot: string;
+  port?: number;
+}
+interface DevServerHandle {
+  url: string;
+  close(): Promise<void>;
+}
+interface BundleOptions {
+  projectRoot: string;
+  entry: string;
+  platform: 'macos';
+  dev: boolean;
+}
+interface BundleResult {
+  entry: string;
+  assets: string[];
+}
+interface DevServer {
+  start(options: DevServerOptions): Promise<DevServerHandle>;
+}
+interface Bundler {
+  bundle(options: BundleOptions): Promise<BundleResult>;
+}
+//#endregion
+export { BundleOptions, BundleResult, Bundler, DevServer, DevServerHandle, DevServerOptions };
+//# sourceMappingURL=bundler.d.ts.map

package/dist/bundler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundler.d.ts","names":[],"sources":["../src/bundler.ts"],"sourcesContent":[],"mappings":";UAAiB,gBAAA;EAAA,WAAA,EAAA,MAAgB;EAKhB,IAAA,CAAA,EAAA,MAAA;AAKjB;AAOiB,UAZA,eAAA,CAYY;EAKZ,GAAA,EAAA,MAAA;EACA,KAAA,EAAA,EAhBN,OAgBM,CAAA,IAAA,CAAA;;AAAmB,UAbnB,aAAA,CAamB;EAAO,WAAA,EAAA,MAAA;EAG1B,KAAA,EAAA,MAAO;EACN,QAAA,EAAA,OAAA;EAAwB,GAAA,EAAA,OAAA;;AAAD,UAVxB,YAAA,CAUwB;;;;UALxB,SAAA;iBACA,mBAAmB,QAAQ;;UAG3B,OAAA;kBACC,gBAAgB,QAAQ"}

package/dist/bundler.js

@@ -0,0 +1 @@
+export {  };

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/cli.cjs

@@ -0,0 +1,479 @@
+#!/usr/bin/env node
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+let node_child_process = require("node:child_process");
+node_child_process = require_chunk.__toESM(node_child_process);
+let node_crypto = require("node:crypto");
+node_crypto = require_chunk.__toESM(node_crypto);
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_http = require("node:http");
+node_http = require_chunk.__toESM(node_http);
+let node_module = require("node:module");
+node_module = require_chunk.__toESM(node_module);
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os);
+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);
+
+//#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 printUsage() {
+	console.log(`Usage: bleam <command>
+
+Commands:
+  new [dir] [--run]         Create a new Bleam project
+  dev [dir] [--port <port>] Start a Bleam dev server`);
+}
+function invocationRoot() {
+	return node_path.default.isAbsolute(process.env.PWD ?? "") ? process.env.PWD : process.cwd();
+}
+function parseDevOptions(argv) {
+	const root = invocationRoot();
+	let projectRoot = root;
+	let port = 8081;
+	let hasProjectRootArg = false;
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--port" || arg === "-p") {
+			const value = argv[++index];
+			port = Number(value);
+			continue;
+		}
+		if (arg.startsWith("--port=")) {
+			port = Number(arg.slice(7));
+			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 (!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
+	};
+}
+function parseNewOptions(argv) {
+	const root = invocationRoot();
+	let projectRoot = root;
+	let run = false;
+	for (const arg of argv) {
+		if (arg === "--run") {
+			run = 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);
+	}
+	return {
+		projectRoot,
+		run
+	};
+}
+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"));
+}
+function discoverBleamProjectRoot(searchRoot) {
+	const ignoredNames = new Set([
+		".bleam",
+		".expo",
+		".git",
+		".yarn",
+		"build",
+		"dist",
+		"node_modules",
+		"templates"
+	]);
+	const matches = [];
+	function visit(directory) {
+		if (matches.length > 1) return;
+		if (isBleamProjectRoot(directory)) {
+			matches.push(directory);
+			return;
+		}
+		for (const entry of (0, node_fs.readdirSync)(directory, { withFileTypes: true })) {
+			if (!entry.isDirectory() || ignoredNames.has(entry.name)) continue;
+			visit(node_path.default.join(directory, entry.name));
+		}
+	}
+	visit(searchRoot);
+	if (matches.length > 1) throw new Error("Multiple Bleam projects found. Run bleam dev <dir>.");
+	return matches[0];
+}
+function assertStringField(value, field) {
+	if (typeof value !== "string" || value.trim() === "") throw new Error(`app.config.ts must define ${field}`);
+	return value;
+}
+function loadAppConfig(projectRoot) {
+	const configPath = node_path.default.join(projectRoot, "app.config.ts");
+	const loader = `
+    const mod = await import(${JSON.stringify((0, node_url.pathToFileURL)(configPath).href)});
+    const config = mod.default?.default ?? mod.default ?? mod;
+    process.stdout.write(JSON.stringify(config));
+  `;
+	const result = (0, node_child_process.spawnSync)(process.execPath, [
+		"--import",
+		require$1.resolve("tsx"),
+		"--eval",
+		loader
+	], {
+		cwd: projectRoot,
+		encoding: "utf8",
+		env: {
+			...process.env,
+			NODE_PATH: [
+				node_path.default.join(projectRoot, "node_modules"),
+				node_path.default.join(packageRoot, "node_modules"),
+				process.env.NODE_PATH
+			].filter(Boolean).join(node_path.default.delimiter)
+		}
+	});
+	if (result.status !== 0) throw new Error(result.stderr.trim() || "Failed to load app.config.ts");
+	const value = JSON.parse(result.stdout);
+	return {
+		name: assertStringField(value.name, "name"),
+		version: typeof value.version === "string" ? value.version : void 0,
+		bundleIdentifier: typeof value.bundleIdentifier === "string" ? value.bundleIdentifier : void 0,
+		teamId: typeof value.teamId === "string" ? value.teamId : void 0
+	};
+}
+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.");
+}
+function readProjectConfig(options) {
+	assertBleamConfigFiles(options.projectRoot);
+	const config = loadAppConfig(options.projectRoot);
+	return {
+		name: config.name,
+		version: config.version,
+		bundleIdentifier: config.bundleIdentifier,
+		teamId: config.teamId,
+		runtimeVersion,
+		sdkVersion: runtimeVersion
+	};
+}
+function slugFromName(name) {
+	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "bleam-app";
+}
+function nameFromDirectory(projectRoot) {
+	const name = node_path.default.basename(projectRoot).replace(/[-_]+/g, " ").trim();
+	if (!name) return "Bleam App";
+	return name.replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+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`);
+	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);
+	(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
+	} }, 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({
+		name: `${slugFromName(config.name)}-bleam-dev`,
+		version: config.version ?? "0.0.0",
+		private: true,
+		main: "index.js",
+		dependencies: {
+			"@types/react": packageJson.dependencies?.["@types/react"],
+			expo: packageJson.dependencies?.expo,
+			react: packageJson.dependencies?.react,
+			"react-native": packageJson.dependencies?.["react-native"],
+			typescript: packageJson.dependencies?.typescript
+		},
+		expo: { install: { exclude: ["typescript"] } }
+	}, 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"))]
+	}, null, 2)}\n`);
+	return workspaceRoot;
+}
+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 });
+	(0, node_fs.writeFileSync)(projectConfigPath, `${JSON.stringify({
+		name: config.name,
+		version: config.version,
+		bundleIdentifier: config.bundleIdentifier,
+		teamId: config.teamId,
+		devServer: origin,
+		runtimeVersion: config.runtimeVersion,
+		sdkVersion: config.sdkVersion
+	}, null, 2)}\n`);
+	return projectConfigPath;
+}
+function runtimeCacheRoot() {
+	return node_path.default.join(node_os.default.homedir(), "Library", "Caches", "bleam", "runtimes", runtimeVersion, runtimePlatform);
+}
+function localDevelopmentRuntimeAppPath() {
+	return node_path.default.resolve(packageRoot, "..", "..", "app", "bleam", "build", "Build", "Products", "Debug-maccatalyst", "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`;
+}
+function runtimeArchiveUrl() {
+	const tag = encodeURIComponent(`bleam@${runtimeVersion}`);
+	return `${runtimeReleaseBaseUrl()}/${tag}/${runtimeArchiveName()}`;
+}
+function sha256(filePath) {
+	return (0, node_crypto.createHash)("sha256").update((0, node_fs.readFileSync)(filePath)).digest("hex");
+}
+async function downloadFile(url, destination) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
+	(0, node_fs.writeFileSync)(destination, new Uint8Array(await response.arrayBuffer()));
+}
+async function downloadExpectedSha256(url) {
+	const response = await fetch(`${url}.sha256`);
+	if (!response.ok) return;
+	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.");
+	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
+	};
+	(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");
+	await downloadFile(archiveUrl, archivePath);
+	const expectedSha256 = await downloadExpectedSha256(archiveUrl);
+	if (expectedSha256 && sha256(archivePath) !== expectedSha256) {
+		(0, node_fs.rmSync)(archivePath, { force: true });
+		throw new Error(`Runtime artifact checksum mismatch: ${archiveUrl}`);
+	}
+	(0, node_fs.rmSync)(extractRoot, {
+		recursive: true,
+		force: true
+	});
+	(0, node_fs.mkdirSync)(extractRoot, { recursive: true });
+	(0, node_child_process.execFileSync)("ditto", [
+		"-x",
+		"-k",
+		archivePath,
+		extractRoot
+	], { stdio: "ignore" });
+	const extractedAppPath = node_path.default.join(extractRoot, "Bleam.app");
+	if (!(0, node_fs.existsSync)(extractedAppPath)) throw new Error(`Runtime archive did not contain Bleam.app: ${archiveUrl}`);
+	(0, node_fs.rmSync)(cachedAppPath, {
+		recursive: true,
+		force: true
+	});
+	(0, node_fs.cpSync)(extractedAppPath, cachedAppPath, { recursive: true });
+	(0, node_fs.rmSync)(extractRoot, {
+		recursive: true,
+		force: true
+	});
+	return {
+		appPath: cachedAppPath,
+		version: runtimeVersion,
+		platform: runtimePlatform
+	};
+}
+async function resolveRuntimeArtifact() {
+	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}`);
+		return {
+			appPath,
+			version: runtimeVersion,
+			platform: runtimePlatform
+		};
+	}
+	const localAppPath = localDevelopmentRuntimeAppPath();
+	if ((0, node_fs.existsSync)(localAppPath)) return {
+		appPath: localAppPath,
+		version: runtimeVersion,
+		platform: runtimePlatform
+	};
+	return downloadRuntimeArtifact();
+}
+function copyRuntimeClient(projectRoot, runtime) {
+	const clientAppPath = node_path.default.join(projectRoot, ".bleam", "client", "Bleam.app");
+	(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 });
+	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;
+}
+async function readDevManifest(origin, timeoutMs = 3e4) {
+	const manifestUrl = `${origin}/bleam/manifest.json`;
+	const startedAt = Date.now();
+	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;
+		} catch {}
+		await new Promise((resolve) => setTimeout(resolve, 500));
+	}
+	throw new Error(`Bleam manifest did not become available: ${manifestUrl}`);
+}
+function openRuntimeClient(appPath, projectConfigPath, manifest) {
+	(0, node_child_process.spawn)("open", [
+		appPath,
+		"--args",
+		"--bleam-project-config",
+		projectConfigPath,
+		"--bleam-bundle-url",
+		manifest.bundleUrl,
+		"--bleam-title",
+		manifest.name
+	], {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+}
+async function startDevServer(options) {
+	const config = readProjectConfig(options);
+	const runtime = await resolveRuntimeArtifact();
+	const clientAppPath = copyRuntimeClient(options.projectRoot, runtime);
+	const workspaceRoot = createDevWorkspace(options.projectRoot, config);
+	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",
+		workspaceRoot,
+		"--localhost",
+		"--port",
+		String(options.port)
+	], {
+		stdio: "inherit",
+		env: {
+			...process.env,
+			BLEAM_DEV: "1",
+			BLEAM_PROJECT_ROOT: options.projectRoot,
+			BLEAM_DEV_NAME: config.name,
+			BLEAM_DEV_ORIGIN: origin,
+			BLEAM_DEV_PORT: String(options.port),
+			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"),
+				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"))),
+				process.env.NODE_PATH
+			].filter(Boolean).join(node_path.default.delimiter)
+		}
+	});
+	const stop = (signal) => {
+		child.kill(signal);
+	};
+	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);
+}
+async function main(argv = process.argv.slice(2)) {
+	const [command, ...args] = argv;
+	if (!command || command === "--help" || command === "-h") {
+		printUsage();
+		return;
+	}
+	if (command === "new") {
+		const options = parseNewOptions(args);
+		createNewProject(options);
+		if (options.run) await startDevServer({
+			projectRoot: options.projectRoot,
+			port: 8081
+		});
+		return;
+	}
+	if (command === "dev") {
+		await startDevServer(parseDevOptions(args));
+		return;
+	}
+	throw new Error(`Unknown command: ${command}`);
+}
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+});
+
+//#endregion

package/dist/cli.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export { };