stim 0.0.0 → 1.1.0

package/dist/server-bare-BYHqEeyw.mjs

@@ -0,0 +1,352 @@
+import { p as readWorkspaceState } from "./state-IYEY-zi8.mjs";
+import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
+import { S as projectMetroSharedCache } from "./settings-BSwrY4FZ.mjs";
+import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-CDDZHtPl.mjs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region shim/bundle-response.cjs
+var require_bundle_response = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { randomUUID } = __require("node:crypto");
+	function bundleResponseMiddleware(write) {
+		return (req, res, next) => {
+			let url;
+			try {
+				url = new URL(req.url, "http://localhost");
+			} catch {
+				return next();
+			}
+			const platform = url.searchParams.get("platform");
+			if (req.method !== "GET" || !/\.bundle\/*$/.test(url.pathname) || !["ios", "android"].includes(platform)) return next();
+			const requestId = randomUUID();
+			const emit = (event, statusCode) => {
+				try {
+					write({
+						ts: Date.now(),
+						src: "metro",
+						level: event === "bundle_response_failed" ? "error" : "debug",
+						event,
+						platform,
+						requestId,
+						statusCode,
+						msg: `${platform} bundle response ${event.slice(16)}`
+					});
+				} catch {}
+			};
+			emit("bundle_response_started");
+			let ended = false;
+			const finish = (complete) => {
+				if (ended) return;
+				ended = true;
+				const success = complete && (res.statusCode === 200 || res.statusCode === 304);
+				emit(success ? "bundle_response_finished" : "bundle_response_failed", res.statusCode);
+			};
+			res.once("finish", () => finish(true));
+			res.once("close", () => finish(false));
+			return next();
+		};
+	}
+	module.exports = { bundleResponseMiddleware };
+}));
+//#endregion
+//#region shim/metro-cache-generation.cjs
+var require_metro_cache_generation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { createHash } = __require("node:crypto");
+	const { mkdirSync } = __require("node:fs");
+	const { join: join$1 } = __require("node:path");
+	function applyMetroCacheGeneration(config, generation, directory) {
+		if (!generation) return config;
+		const fileMapCacheDirectory = join$1(directory, generation);
+		mkdirSync(fileMapCacheDirectory, { recursive: true });
+		return {
+			...config,
+			cacheVersion: createHash("sha256").update(JSON.stringify([config.cacheVersion ?? "1.0", generation])).digest("hex"),
+			fileMapCacheDirectory
+		};
+	}
+	module.exports = { applyMetroCacheGeneration };
+}));
+//#endregion
+//#region src/supervisor/server-bare.ts
+var import_bundle_response = require_bundle_response();
+var import_metro_cache_generation = require_metro_cache_generation();
+const BARE_PACKAGES = [
+	"metro",
+	"@react-native/dev-middleware",
+	"@react-native-community/cli-server-api"
+];
+const REQUIRED_EXPORTS = {
+	metro: ["loadConfig", "runServer"],
+	"@react-native/dev-middleware": ["createDevMiddleware"],
+	"@react-native-community/cli-server-api": ["createDevServerMiddleware"]
+};
+function projectRequire(root) {
+	return createRequire(join(root, "package.json"));
+}
+function normalizeModule(mod, names) {
+	if (!mod || typeof mod !== "object") return mod;
+	const has = (obj) => obj && names.every((n) => typeof obj[n] === "function");
+	if (has(mod)) return mod;
+	if (has(mod.default)) return mod.default;
+	return mod;
+}
+function checkBareApi(modules) {
+	const problems = [];
+	for (const name of BARE_PACKAGES) {
+		const mod = modules?.[name];
+		if (!mod) {
+			problems.push(`${name} loaded but exported nothing`);
+			continue;
+		}
+		for (const fn of REQUIRED_EXPORTS[name] ?? []) if (typeof mod[fn] !== "function") problems.push(`${name} does not export ${fn}()`);
+	}
+	return problems;
+}
+function resolveBareDeps(root, { requireFrom = projectRequire } = {}) {
+	const localRequire = requireFrom(root);
+	const modules = {};
+	const missing = [];
+	for (const name of BARE_PACKAGES) {
+		let resolved;
+		try {
+			resolved = localRequire.resolve(name);
+		} catch {
+			missing.push(name);
+			continue;
+		}
+		try {
+			modules[name] = normalizeModule(localRequire(resolved), REQUIRED_EXPORTS[name] ?? []);
+		} catch (err) {
+			throw supervisorError("STIM_BARE_LOAD", `${name} is installed in ${root} but failed to load: ${err?.message || err}`, `Check that ${name} matches this project's React Native version, then reinstall node_modules.`);
+		}
+	}
+	if (missing.length > 0) throw supervisorError("STIM_BARE_DEPS", `Cannot host a bare React Native dev server for ${root}: ${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} not resolvable from the project.`, "Run `npm install` in the project. If this is an Expo project that was detected as bare, check that `expo` is in its dependencies and that it has an Expo config.");
+	const problems = checkBareApi(modules);
+	if (problems.length > 0) throw supervisorError("STIM_BARE_API", `The dev server packages in ${root} are not the API Stim expects: ${problems.join("; ")}.`, "Upgrade or reinstall the project's React Native toolchain so metro, @react-native/dev-middleware and @react-native-community/cli-server-api match.");
+	return {
+		metro: modules["metro"],
+		devMiddleware: modules["@react-native/dev-middleware"],
+		serverApi: modules["@react-native-community/cli-server-api"]
+	};
+}
+function loadNdjsonReporter(root, { requireFrom = createRequire } = {}) {
+	for (const from of [import.meta.url, join(root, "package.json")]) try {
+		const factory = requireFrom(from)("@stim-cli/metro").ndjsonReporter;
+		if (typeof factory === "function") return factory;
+	} catch {}
+	return null;
+}
+function loadFileStore(root, { requireFrom = projectRequire } = {}) {
+	try {
+		const Store = requireFrom(root)("metro-cache").FileStore;
+		return typeof Store === "function" ? Store : null;
+	} catch {
+		return null;
+	}
+}
+function installSharedCacheStore({ root, config, writer, enabled, FileStore }) {
+	if (!enabled) {
+		writer?.write({
+			src: "metro",
+			level: "debug",
+			event: "cache_store_skipped",
+			msg: "the shared Metro transform store is off in configuration"
+		});
+		return false;
+	}
+	if (!FileStore) {
+		writer?.write({
+			src: "metro",
+			level: "warn",
+			event: "cache_store_skipped",
+			msg: `metro-cache is not resolvable from ${root}, so this dev server runs on whatever transform cache the project configured`
+		});
+		return false;
+	}
+	const storeRoot = metroStoreRoot(root);
+	const result = appendCacheStore(config, {
+		storeRoot,
+		FileStore
+	});
+	registerMetroStore(storeRoot);
+	if (!result.added) {
+		writer?.write({
+			src: "metro",
+			level: "debug",
+			event: "cache_store_present",
+			msg: `the shared Metro transform store at ${storeRoot} was already configured (${result.reason})`
+		});
+		return true;
+	}
+	writer?.write({
+		src: "metro",
+		level: "debug",
+		event: "cache_store_added",
+		msg: `appended the shared Metro transform store at ${storeRoot} to this project's cacheStores`
+	});
+	return true;
+}
+const ASYNC_REQUIRE_MODULE = "metro-runtime/src/modules/asyncRequire";
+function normalizeMetroTransformerPaths(config, root) {
+	const current = config?.transformer?.asyncRequireModulePath;
+	if (typeof current !== "string" || !isAbsolute(current)) return false;
+	if (relative(root, current).split(sep).join("/") !== `node_modules/${ASYNC_REQUIRE_MODULE}.js`) return false;
+	config.transformer.asyncRequireModulePath = ASYNC_REQUIRE_MODULE;
+	return true;
+}
+function ensureNativePlatform(config) {
+	const platforms = config?.resolver?.platforms;
+	if (!Array.isArray(platforms) || platforms.includes("native")) return false;
+	config.resolver.platforms = [...platforms, "native"];
+	return true;
+}
+function reporterLogger(reporter) {
+	const at = (level) => (...data) => {
+		try {
+			reporter.update({
+				type: "unstable_server_log",
+				level,
+				data
+			});
+		} catch {}
+	};
+	return {
+		info: at("info"),
+		warn: at("warn"),
+		error: at("error")
+	};
+}
+function symbolicationReporterMiddleware(reporter) {
+	return (req, res, next) => {
+		if (typeof req?.url !== "string" || req.url.split("?", 1)[0] !== "/symbolicate") {
+			next();
+			return;
+		}
+		const end = res.end;
+		res.end = function(chunk, ...args) {
+			try {
+				const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : null;
+				const body = text ? JSON.parse(text) : null;
+				if (body !== null && typeof body === "object" && !Array.isArray(body)) reporter.update({
+					type: "client_symbolication",
+					codeFrame: body.codeFrame,
+					stack: body.stack
+				});
+			} catch {}
+			return end.call(this, chunk, ...args);
+		};
+		next();
+	};
+}
+function closeHttpServer(httpServer, timeoutMs) {
+	return new Promise((resolve) => {
+		let done = false;
+		const finish = () => {
+			if (!done) {
+				done = true;
+				resolve();
+			}
+		};
+		const timer = setTimeout(finish, timeoutMs);
+		if (typeof timer.unref === "function") timer.unref();
+		try {
+			httpServer.closeAllConnections?.();
+			httpServer.close(() => {
+				clearTimeout(timer);
+				finish();
+			});
+		} catch {
+			clearTimeout(timer);
+			finish();
+		}
+	});
+}
+async function startBareServer({ root, port, logsDir, writer = null, deps = null, reporterFactory = void 0, cacheStore = void 0, fileStore = void 0, closeTimeoutMs = 5e3 }) {
+	const { metro, devMiddleware, serverApi } = deps || resolveBareDeps(root);
+	const makeReporter = reporterFactory === void 0 ? loadNdjsonReporter(root) : reporterFactory;
+	const config = (0, import_metro_cache_generation.applyMetroCacheGeneration)(await metro.loadConfig({
+		cwd: root,
+		port
+	}), readWorkspaceState(root)?.metroCacheGeneration, join(dirname(logsDir), "metro-file-map"));
+	if (installSharedCacheStore({
+		root,
+		config,
+		writer,
+		enabled: cacheStore === void 0 ? projectMetroSharedCache(root) : cacheStore,
+		FileStore: fileStore === void 0 ? loadFileStore(root) : fileStore
+	}) && normalizeMetroTransformerPaths(config, root)) writer?.write({
+		src: "metro",
+		level: "debug",
+		event: "config_adjusted",
+		msg: "normalized the project-local asyncRequireModulePath for cross-worktree transform keys"
+	});
+	if (ensureNativePlatform(config)) writer?.write({
+		src: "metro",
+		level: "debug",
+		event: "config_adjusted",
+		msg: "added 'native' to resolver.platforms, as the React Native CLI does"
+	});
+	let reporter;
+	if (makeReporter) {
+		reporter = makeReporter({ dir: logsDir });
+		config.reporter = reporter;
+	} else {
+		writer?.write({
+			src: "metro",
+			level: "warn",
+			event: "reporter_missing",
+			msg: "@stim-cli/metro is not installed in this project or beside Stim, so bundler and client logs will not be captured. Install it as a devDependency to get them."
+		});
+		reporter = { update() {} };
+	}
+	const hostname = "localhost";
+	const devServerUrl = `http://${hostname}:${port}`;
+	const { middleware: communityMiddleware, websocketEndpoints: communityWebsocketEndpoints } = serverApi.createDevServerMiddleware({
+		host: hostname,
+		port,
+		watchFolders: config.watchFolders
+	});
+	const { middleware, websocketEndpoints } = devMiddleware.createDevMiddleware({
+		serverBaseUrl: devServerUrl,
+		logger: reporterLogger(reporter)
+	});
+	const httpServer = await metro.runServer(config, {
+		unstable_extraMiddleware: [
+			(0, import_bundle_response.bundleResponseMiddleware)((record) => writer?.write(record)),
+			symbolicationReporterMiddleware(reporter),
+			communityMiddleware,
+			middleware
+		],
+		websocketEndpoints: {
+			...communityWebsocketEndpoints,
+			...websocketEndpoints
+		}
+	});
+	let exited = false;
+	const listeners = [];
+	httpServer.on?.("close", () => {
+		if (exited) return;
+		exited = true;
+		for (const cb of listeners) cb({
+			code: 0,
+			reason: "the Metro http server closed"
+		});
+	});
+	return {
+		mode: "bare-inproc",
+		serverPid: null,
+		httpServer,
+		onExit(cb) {
+			listeners.push(cb);
+		},
+		async close() {
+			exited = true;
+			await closeHttpServer(httpServer, closeTimeoutMs);
+		}
+	};
+}
+//#endregion
+export { startBareServer };

package/dist/server-expo-BEMr_m6p.mjs

@@ -0,0 +1,312 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { r as createNdjsonWriter } from "./ndjson-DcAtEx_K.mjs";
+import { p as readWorkspaceState } from "./state-IYEY-zi8.mjs";
+import { l as resolvePackageJson } from "./project-COj6nzzh.mjs";
+import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
+import { n as stripAnsi, t as createLineReader } from "./process-output-C7IlIzd7.mjs";
+import { S as projectMetroSharedCache } from "./settings-BSwrY4FZ.mjs";
+import { a as metroStoreRoot, i as metroStoreConfirmedRoot, n as expoMetroConfigPath, o as registerMetroStore, r as expoMetroStoreEnv } from "./metro-store-CDDZHtPl.mjs";
+import { accessSync, constants, existsSync, readFileSync } from "node:fs";
+import { dirname, join, parse } from "node:path";
+//#region src/supervisor/server-expo.ts
+function delay(ms) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(resolve, ms);
+		if (typeof timer.unref === "function") timer.unref();
+	});
+}
+function expoBinPath(root) {
+	const fromPackage = expoBinFromPackage(resolvePackageJson(root, "expo"));
+	if (fromPackage) return fromPackage;
+	return findBinUpward(root, "expo");
+}
+function expoSdkMajor(root) {
+	const packageJsonPath = resolvePackageJson(root, "expo");
+	if (!packageJsonPath) return null;
+	try {
+		const version = JSON.parse(readFileSync(packageJsonPath, "utf-8"))?.version;
+		if (typeof version !== "string") return null;
+		const match = /^(\d+)/.exec(version);
+		return match ? Number(match[1]) : null;
+	} catch {
+		return null;
+	}
+}
+function expoBinFromPackage(packageJsonPath, binName = "expo") {
+	if (!packageJsonPath) return null;
+	let pkg;
+	try {
+		pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+	} catch {
+		return null;
+	}
+	const bin = pkg?.bin;
+	const rel = typeof bin === "string" ? bin : bin && typeof bin === "object" ? bin[binName] : null;
+	if (typeof rel !== "string" || rel.trim() === "") return null;
+	const file = join(dirname(packageJsonPath), rel);
+	return isExecutableFile(file) ? file : null;
+}
+function findBinUpward(startDir, name, { exists = existsSync } = {}) {
+	let dir = startDir;
+	const stop = parse(startDir).root;
+	while (true) {
+		const candidate = join(dir, "node_modules", ".bin", name);
+		if (exists(candidate)) return candidate;
+		if (dir === stop) return null;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+function isExecutableFile(file) {
+	try {
+		accessSync(file, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function expoBinRefusal(root, what = "start an Expo dev server for") {
+	return {
+		message: `Cannot ${what} ${root}: the \`expo\` package is not resolvable from it (require.resolve("expo/package.json") failed, and no node_modules/.bin/expo exists in it or in any parent).`,
+		remedy: "Install the project's dependencies (in a monorepo, from the workspace root), or check that this package really depends on `expo`."
+	};
+}
+const CROSS = "✖";
+const CROSS_MARK = "❌";
+const WARNING_SIGN = "⚠";
+const UNHANDLED_NAVIGATE = /The action '(?:NAVIGATE|NAVIGATE_DEPRECATED)' with payload .*was not handled by any navigator/;
+const DEV_CLIENT_ROUTE = "expo-development-client";
+function isDevClientNavigationNotice(line) {
+	const text = String(line);
+	return text.includes(DEV_CLIENT_ROUTE) && UNHANDLED_NAVIGATE.test(text);
+}
+function inferLevel(line) {
+	const text = String(line).trimStart();
+	if (!text) return "info";
+	if (isDevClientNavigationNotice(text)) return "info";
+	const first = text[0];
+	if (first === CROSS || first === CROSS_MARK) return "error";
+	if (first === WARNING_SIGN) return "warn";
+	const lead = /^([A-Za-z]+)/.exec(text)?.[1]?.toLowerCase() ?? "";
+	if (lead === "error" || lead === "fatal") return "error";
+	if (lead === "warn" || lead === "warning") return "warn";
+	if (/\bBundling failed\b/.test(text)) return "error";
+	if (/^Unable to resolve\b/.test(text)) return "error";
+	if (/^Failed to (load|resolve|compile|build)\b/.test(text)) return "error";
+	if (/^[A-Z][A-Za-z]*Error:/.test(text)) return "error";
+	return "info";
+}
+function isBundleMarker(line) {
+	const text = String(line);
+	return /\bBundled\b/.test(text) || /\bBundling failed\b/.test(text);
+}
+function cleanLine(line) {
+	const parts = stripAnsi(line).split("\r");
+	return (parts[parts.length - 1] ?? "").trimEnd();
+}
+function recordFromLine(line, { stream = "stdout" } = {}) {
+	const msg = cleanLine(line);
+	if (!msg.trim()) return null;
+	if (stream === "stderr" && msg.startsWith("stim-bundle-response: ")) try {
+		const record = JSON.parse(msg.slice(22));
+		if (record.src === "metro" && [
+			"bundle_response_started",
+			"bundle_response_finished",
+			"bundle_response_failed"
+		].includes(record.event) && ["ios", "android"].includes(record.platform) && typeof record.requestId === "string" && Number.isFinite(record.ts)) return record;
+	} catch {}
+	const confirmed = metroStoreConfirmedRoot(msg);
+	if (confirmed) return {
+		src: "metro",
+		level: "debug",
+		event: "cache_store_added",
+		msg: `sharing Metro transforms through ${confirmed} (the dev server process confirmed the store is in the config Metro loaded)`
+	};
+	const record = {
+		src: "metro",
+		level: inferLevel(msg),
+		msg,
+		raw: true,
+		event: stream === "stderr" ? "expo_stderr" : "expo_stdout"
+	};
+	if (isBundleMarker(msg)) record.marker = true;
+	return record;
+}
+function expoProxyEnv(env) {
+	if (env.EXPO_PACKAGER_PROXY_URL) return {};
+	const publicUrl = env.STIM_METRO_PUBLIC_URL?.trim();
+	return publicUrl ? { EXPO_PACKAGER_PROXY_URL: publicUrl.replace(/\/+$/, "") } : {};
+}
+const WAITING_ON_RE = /^Waiting on (\S+)/;
+const URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+const HTTP_SCHEME_RE = /^https?:\/\//i;
+function parseExpoWaitingOnUrl(line) {
+	const match = WAITING_ON_RE.exec(String(line ?? ""));
+	if (!match) return null;
+	const url = match[1];
+	if (HTTP_SCHEME_RE.test(url)) return url;
+	return URL_SCHEME_RE.test(url) ? url.replace(/^[^:]+:/, "https:") : url;
+}
+function resolveMetroStoreInjection(root, { log, env }) {
+	const sharedCache = projectMetroSharedCache(root);
+	if (!sharedCache) log.write({
+		src: "metro",
+		level: "debug",
+		event: "cache_store_skipped",
+		msg: "the shared Metro transform store is off in configuration"
+	});
+	const sdkMajor = expoSdkMajor(root);
+	if (sdkMajor === null || sdkMajor < 54) {
+		log.write({
+			src: "metro",
+			level: "debug",
+			event: "cache_store_skipped",
+			msg: sdkMajor === null ? "could not determine this project's Expo SDK, so Stim left its Metro cache unchanged" : `Expo SDK ${sdkMajor} predates the config override added in SDK 54, so it runs with its normal Metro cache`
+		});
+		return null;
+	}
+	const adapterPath = expoMetroConfigPath();
+	if (!adapterPath) {
+		log.write({
+			src: "metro",
+			level: "warn",
+			event: "cache_store_skipped",
+			msg: "Stim's Expo Metro config adapter is missing from this install, so the dev server runs on whatever transform cache the project configured"
+		});
+		return null;
+	}
+	const storeRoot = sharedCache ? metroStoreRoot(root) : "";
+	const additions = expoMetroStoreEnv({
+		root,
+		storeRoot,
+		adapterPath,
+		existingOverride: env.EXPO_OVERRIDE_METRO_CONFIG
+	});
+	if (!sharedCache) return additions;
+	registerMetroStore(storeRoot);
+	log.write({
+		src: "metro",
+		level: "debug",
+		event: "cache_store_requested",
+		msg: `asked this project's Expo dev server to share Metro transforms through ${storeRoot} (EXPO_OVERRIDE_METRO_CONFIG, no metro.config.js change); the config adapter in that process reports the outcome`
+	});
+	return additions;
+}
+async function startExpoServer({ root, port, logsDir, writer = null, spawnFn = null, killTimeoutMs = 5e3, tunnel = false, onTunnelUrl = null }) {
+	const bin = expoBinPath(root);
+	if (!bin) {
+		const refusal = expoBinRefusal(root);
+		throw supervisorError("STIM_EXPO_BIN", refusal.message, refusal.remedy);
+	}
+	const log = writer || createNdjsonWriter(join(logsDir, "metro.ndjson"));
+	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
+	const args = tunnel ? [
+		"start",
+		"--port",
+		String(port),
+		"--tunnel"
+	] : [
+		"start",
+		"--port",
+		String(port)
+	];
+	const storeEnv = resolveMetroStoreInjection(root, {
+		log,
+		env: process.env
+	});
+	const generation = readWorkspaceState(root)?.metroCacheGeneration;
+	if (generation && !storeEnv) throw supervisorError("STIM_BAD_ARG", "The saved Metro cache reset requires the Expo config adapter.", "Use Expo SDK 54 or newer and repair the Stim installation before starting this app.");
+	const child = spawn(bin, args, {
+		cwd: root,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: false,
+		env: {
+			...process.env,
+			FORCE_COLOR: "0",
+			...expoProxyEnv(process.env),
+			...storeEnv,
+			STIM_METRO_CACHE_GENERATION: generation ?? "",
+			STIM_METRO_FILE_MAP: join(dirname(logsDir), "metro-file-map"),
+			...tunnel ? { EXPO_UNSTABLE_TUNNEL_V2: "1" } : {}
+		}
+	});
+	let lastMsg = null;
+	let lastAt = 0;
+	let tunnelUrlSeen = false;
+	const emit = (stream) => (chunk) => {
+		const record = recordFromLine(chunk, { stream });
+		if (!record) return;
+		const now = Date.now();
+		if (record.msg === lastMsg && now - lastAt < 1e3) return;
+		lastMsg = typeof record.msg === "string" ? record.msg : null;
+		lastAt = now;
+		log.write(record);
+		if (tunnel && !tunnelUrlSeen && onTunnelUrl && typeof record.msg === "string") {
+			const url = parseExpoWaitingOnUrl(record.msg);
+			if (url) {
+				tunnelUrlSeen = true;
+				onTunnelUrl(url);
+			}
+		}
+	};
+	const outReader = createLineReader(emit("stdout"));
+	const errReader = createLineReader(emit("stderr"));
+	child.stdout?.setEncoding?.("utf-8");
+	child.stderr?.setEncoding?.("utf-8");
+	child.stdout?.on("data", (chunk) => outReader.push(chunk));
+	child.stderr?.on("data", (chunk) => errReader.push(chunk));
+	let exited = false;
+	let exitInfo = null;
+	const listeners = [];
+	child.on("exit", (code, signal) => {
+		exited = true;
+		exitInfo = {
+			code,
+			signal
+		};
+		outReader.flush();
+		errReader.flush();
+		for (const cb of listeners) cb(exitInfo);
+	});
+	child.on("error", (err) => {
+		if (exited) return;
+		exited = true;
+		exitInfo = {
+			code: null,
+			signal: null,
+			error: err
+		};
+		for (const cb of listeners) cb(exitInfo);
+	});
+	return {
+		mode: "expo-child",
+		serverPid: child.pid ?? null,
+		child,
+		onExit(cb) {
+			if (exited) {
+				cb(exitInfo);
+				return;
+			}
+			listeners.push(cb);
+		},
+		async close() {
+			if (exited || !child.pid) return;
+			const dead = new Promise((resolve) => {
+				child.once("exit", () => resolve());
+			});
+			if (!child.kill("SIGTERM")) return;
+			await Promise.race([dead, delay(killTimeoutMs)]);
+			if (!exited) {
+				child.kill("SIGKILL");
+				await Promise.race([dead, delay(killTimeoutMs)]);
+			}
+		}
+	};
+}
+//#endregion
+export { expoProxyEnv as a, inferLevel as c, parseExpoWaitingOnUrl as d, recordFromLine as f, expoBinRefusal as i, isBundleMarker as l, expoBinFromPackage as n, expoSdkMajor as o, startExpoServer as p, expoBinPath as r, findBinUpward as s, cleanLine as t, isDevClientNavigationNotice as u };

package/dist/server-expo-rb0k-0w7.mjs

@@ -0,0 +1,2 @@
+import { p as startExpoServer } from "./server-expo-BEMr_m6p.mjs";
+export { startExpoServer };