@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-cli/dist/create.js

@@ -0,0 +1,99 @@
+import { packageSources } from "./release.js";
+import { packageManager, managerCommand, applyOverrides, localArchive } from "./package-manager.js";
+import { packArchive } from "./pack-archive.js";
+import { spawnProcess } from "./process.js";
+import { checkExpoDesktopNode } from "./expo-node.js";
+import { configureExample } from "./examples.js";
+import { hostPlatform } from "./platform.js";
+import { nodeCommand } from "./windows.js";
+import { cpSync, existsSync, readFileSync, writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { readJson, writeJson } from "./project.js";
+import { run } from "./commands.js";
+// Resolve relative to the installed CLI so packed consumers use the same starter.
+const template = path.resolve(import.meta.dirname, "../templates/blank-typescript");
+export async function refreshLocalPackages(root, manifest, selectedManager) {
+    const pkg = readJson(path.join(root, "package.json"));
+    // The template owns the tested compatibility matrix, not module inclusion.
+    const pins = readJson(path.join(template, "package.json")).overrides;
+    const manager = packageManager(root, selectedManager);
+    const overrides = { ...pins };
+    for (const [name, file] of Object.entries(readJson(manifest))) {
+        const archive = localArchive(path.resolve(path.dirname(manifest), file));
+        overrides[name] = archive;
+        if (pkg.dependencies?.[name])
+            pkg.dependencies[name] = archive;
+    }
+    applyOverrides(pkg, overrides, manager);
+    writeJson(path.join(root, "package.json"), pkg);
+    await run(root, managerCommand(manager, ["install"]));
+    upgradeManagedEntry(root);
+}
+export async function create(root, archiveManifest, platform = hostPlatform(), universal = false, example, selectedManager) {
+    const manager = packageManager(process.cwd(), selectedManager);
+    await checkExpoDesktopNode(path.resolve(import.meta.dirname, ".."));
+    const variant = universal || example ? "universal" : platform === "macos" ? "blank-typescript" : "windows";
+    const source = path.resolve(import.meta.dirname, "../templates", variant);
+    const temporary = mkdtempSync(path.join(os.tmpdir(), "spark-create-"));
+    const templateFile = path.join(temporary, "template.tgz");
+    // Resolve archives on the recipient machine, immediately before Expo extracts
+    // and installs the template. No producer-machine paths enter the SDK bundle.
+    try {
+        cpSync(source, temporary, { recursive: true });
+        const pkg = readJson(path.join(temporary, "package.json"));
+        const archives = packageSources(archiveManifest);
+        if (pkg.dependencies["@react-native-runtimes/core"] && !archives["@react-native-runtimes/core"])
+            throw new Error("This SDK lacks the patched Runtimes archive. Repack or install the complete SDK.");
+        const overrides = {};
+        for (const [name, file] of Object.entries(archives)) {
+            overrides[name] = file;
+            if (pkg.dependencies[name])
+                pkg.dependencies[name] = file;
+        }
+        applyOverrides(pkg, overrides, manager);
+        writeJson(path.join(temporary, "package.json"), pkg);
+        if (manager === "yarn")
+            writeFileSync(path.join(temporary, ".yarnrc.yml"), "nodeLinker: node-modules\n");
+        if (manager === "pnpm")
+            writeFileSync(path.join(temporary, ".npmrc"), "node-linker=hoisted\n");
+        await packArchive(temporary, templateFile);
+        // The upstream CLI owns validation, extraction, app IDs, install, and Git setup.
+        // The templates' postinstall initializes spark configuration once.
+        const name = path.basename(root);
+        // beta.5 misreads npm 12's record-shaped pack metadata for a local tarball.
+        // Use the compatible npm executable for upstream extraction; the chosen manager installs.
+        const npmBin = path.join(import.meta.dirname, "npm-bin");
+        // Expo needs file: to distinguish Windows drive paths from npm package names.
+        const child = spawnProcess(nodeCommand(path.resolve(import.meta.dirname, ".."), "expo-desktop", "expo-desktop", [
+            "create-app", root, "--template", `file:${templateFile}`, "--yes", "--no-agents-md",
+            "--display-name", name, "--rdns", `so.legend.spark.prototype.${name.toLowerCase()}`,
+        ]), { cwd: process.cwd(), env: { ...process.env, PATH: `${npmBin}${path.delimiter}${process.env.PATH ?? ""}`, npm_config_user_agent: `${manager}/spark`, CI: "1", ...(manager === "yarn" ? { YARN_ENABLE_IMMUTABLE_INSTALLS: "false" } : {}) }, stdout: "inherit", stderr: "inherit" });
+        if (await child.exited)
+            throw new Error("Expo Desktop could not create the app. See its output above.");
+    }
+    finally {
+        rmSync(temporary, { recursive: true, force: true });
+    }
+    // Upstream can report success after an install failure. Require a usable CLI.
+    if (!existsSync(path.join(root, "node_modules/@legendapp/spark/package.json")))
+        throw new Error(`Dependency installation failed. Run ${manager} install in ${root} and retry.`);
+    if (example)
+        await configureExample(root, example);
+    console.log(`Created ${root}.\n\n  cd ${JSON.stringify(root)}\n  ${manager} run ${platform}`);
+}
+export function upgradeManagedEntry(root) {
+    const oldMetro = `const { makeMetroConfig } = require("expo-desktop-metro-config");
+const { gate } = require("@legendapp/spark-cli/src/metro-gate.cjs");
+const config = makeMetroConfig(__dirname);
+config.server = { ...config.server, enhanceMiddleware: (middleware) => gate(__dirname, middleware) };
+module.exports = config;
+`;
+    const oldEntry = 'import { registerRootComponent } from "expo";\nimport App from "./App";\nregisterRootComponent(App);\n';
+    const metro = path.join(root, "metro.config.js"), entry = path.join(root, "index.ts");
+    // Upgrade only the exact generated pair; customized entries remain user-owned.
+    if (existsSync(metro) && existsSync(entry) && readFileSync(metro, "utf8") === oldMetro && readFileSync(entry, "utf8") === oldEntry) {
+        for (const file of ["metro.config.js", "index.ts"])
+            cpSync(path.join(template, file), path.join(root, file));
+    }
+}

package/vendor/node_modules/@legendapp/spark-cli/dist/credentials.js

@@ -0,0 +1,69 @@
+import { spawnProcess } from "./process.js";
+import { readAppConfig } from "./project.js";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { run } from "./commands.js";
+import { readJson, stateFile, writeJson } from "./project.js";
+export function parseIdentities(output) {
+    return [...output.matchAll(/\b([A-Fa-f0-9]{40})\s+"(Developer ID Application: [^"\n]+ \(([A-Z0-9]{10})\))"/g)]
+        .map((match) => ({ hash: match[1].toUpperCase(), name: match[2], teamId: match[3] }));
+}
+export function chooseIdentity(identities, identity, teamId) {
+    const matches = identities.filter((item) => (!identity || item.hash === identity.toUpperCase() || item.name === identity) && (!teamId || item.teamId === teamId));
+    if (!matches.length)
+        throw new Error("No matching Developer ID Application identity with a private key is available. Install it through Xcode or Keychain Access, then run spark credentials.");
+    return matches;
+}
+export function notaryAuth(credentials) {
+    return ["--keychain-profile", credentials.keychainProfile, ...(credentials.keychain ? ["--keychain", credentials.keychain] : [])];
+}
+async function ask(question) {
+    const input = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await input.question(question)).trim();
+    }
+    finally {
+        input.close();
+    }
+}
+export async function credentials(root, reset = false, execute = run) {
+    const file = stateFile(root, "signing.json");
+    const saved = !reset && existsSync(file) ? readJson(file) : {};
+    const config = readAppConfig(root).expo?.extra?.spark?.signing?.macos ?? {};
+    const keychain = process.env.SPARK_SIGNING_KEYCHAIN ?? saved.keychain;
+    const identity = process.env.SPARK_DEVELOPER_ID_APPLICATION ?? config.identity ?? saved.hash;
+    const teamId = process.env.SPARK_TEAM_ID ?? config.teamId ?? saved.teamId;
+    const discovered = parseIdentities(await execute(root, ["security", "find-identity", "-v", "-p", "codesigning", ...(keychain ? [keychain] : [])], { capture: true }));
+    const matches = chooseIdentity(discovered, identity, teamId);
+    let selected = matches[0];
+    if (matches.length > 1) {
+        if (!process.stdin.isTTY)
+            throw new Error("Multiple signing identities are available. Set SPARK_DEVELOPER_ID_APPLICATION or run spark credentials interactively.");
+        console.log(matches.map((item, index) => `${index + 1}. ${item.name} [${item.hash}]`).join("\n"));
+        const choice = Number(await ask("Signing identity: "));
+        if (!Number.isInteger(choice) || choice < 1 || choice > matches.length)
+            throw new Error("Invalid signing identity selection.");
+        selected = matches[choice - 1];
+    }
+    let keychainProfile = process.env.SPARK_NOTARY_KEYCHAIN_PROFILE ?? saved.keychainProfile;
+    if (!keychainProfile) {
+        if (!process.stdin.isTTY)
+            throw new Error("Notarization is not configured. Set SPARK_NOTARY_KEYCHAIN_PROFILE or run spark credentials interactively.");
+        keychainProfile = await ask("Existing notarization Keychain profile (Enter to create one): ");
+        if (!keychainProfile) {
+            keychainProfile = `spark-${selected.teamId}`;
+            console.log(`Apple’s tool will store and validate notarization credentials in Keychain as ${keychainProfile}. Secret input is handled by notarytool and is not recorded by spark.`);
+            const child = spawnProcess(["xcrun", "notarytool", "store-credentials", keychainProfile, ...(keychain ? ["--keychain", keychain] : [])], {
+                stdin: "inherit", stdout: "inherit", stderr: "inherit",
+            });
+            if (await child.exited)
+                throw new Error("Notarization credential setup failed. Run spark credentials to retry.");
+        }
+    }
+    const result = { ...selected, keychainProfile, ...(keychain ? { keychain } : {}) };
+    // Validate the Keychain profile before native compilation or signing.
+    await execute(root, ["xcrun", "notarytool", "history", ...notaryAuth(result), "--output-format", "json"], { capture: true });
+    writeJson(file, result);
+    return result;
+}

package/vendor/node_modules/@legendapp/spark-cli/dist/dev-command.js

@@ -0,0 +1,81 @@
+import { spawnProcess } from "./process.js";
+import path from "node:path";
+import { prepareConfig, selectTarget, supportedPlatforms } from "@legendapp/spark-desktop-config/config.cjs";
+import { dev } from "./dev.js";
+import { findProject } from "./local.js";
+import { hostPlatform } from "./platform.js";
+import { nodeCommand } from "./windows.js";
+// Consume only spark options. Expo validates its flags, aliases and values.
+export function devArguments(args) {
+    const spark = {};
+    const expo = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const [key, ...inline] = arg.split("=");
+        if (key === "--no-open") {
+            if (inline.length)
+                throw new Error("--no-open does not take a value");
+            spark.noOpen = true;
+        }
+        else if (["--project", "--platform", "--runner-binary", "--prebuilt-binary", "--go-binary"].includes(key)) {
+            const value = inline.length ? inline.join("=") : args[++i];
+            if (!value || value.startsWith("-"))
+                throw new Error(`${key} needs a value`);
+            if (key === "--project")
+                spark.project = value;
+            else if (key === "--platform")
+                spark.platform = value;
+            else
+                spark.prebuiltBinary = value;
+        }
+        else
+            expo.push(arg);
+    }
+    return { ...spark, expo };
+}
+export function devTargets(platforms, initial, host = hostPlatform()) {
+    if (initial && !platforms.includes(initial))
+        throw new Error(`Platform ${initial} is not supported by this project`);
+    const desktop = initial && ["macos", "windows"].includes(initial) ? initial
+        : platforms.includes(host) ? host : platforms.find(p => ["macos", "windows"].includes(p));
+    return { desktop, initial: selectTarget(platforms, initial) };
+}
+export async function devCommand(args) {
+    const options = devArguments(args);
+    const start = path.resolve(options.project ?? process.cwd());
+    if (options.expo.includes("--help") || options.expo.includes("-h")) {
+        console.log("spark dev options:\n  --project <directory>    Application directory\n  --platform <platform>    Initial launch target; all declared platforms stay available\n  --runner-binary <path>  Register and use a Spark Runner\n  --no-open                Wait for a launch key (explicit Expo launch flags still apply)\n\nAll other options belong to expo start:\n");
+        const child = spawnProcess(nodeCommand(start, "expo", "expo", ["start", "--help"]), { cwd: start, stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+        process.exitCode = await child.exited;
+        return;
+    }
+    const root = findProject(start);
+    const { desktop, initial } = devTargets(supportedPlatforms(root), options.platform ?? process.env.SPARK_PLATFORM);
+    // This selects only desktop build/signature state in the supervisor. Expo's
+    // child uses shared development config and chooses each JS graph per request.
+    process.env.SPARK_PLATFORM = desktop ?? initial;
+    const expo = [...options.expo];
+    if (!options.noOpen && ["ios", "android", "web"].includes(initial))
+        expo.push(`--${initial}`);
+    if (desktop) {
+        await dev(root, options.prebuiltBinary, expo, !!options.noOpen || initial !== desktop || (desktop === "windows" ? process.platform !== "win32" : process.platform !== "darwin"));
+    }
+    else {
+        if (options.prebuiltBinary)
+            throw new Error("--runner-binary needs a desktop platform in desktop.config.json");
+        prepareConfig(root);
+        const child = spawnProcess(nodeCommand(root, "expo", "expo", ["start", root, ...expo]), {
+            cwd: root, env: { ...process.env, SPARK_DEV_SESSION: "1" }, stdin: "inherit", stdout: "inherit", stderr: "inherit",
+        });
+        const stop = () => child.kill();
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+        try {
+            process.exitCode = await child.exited;
+        }
+        finally {
+            process.off("SIGINT", stop);
+            process.off("SIGTERM", stop);
+        }
+    }
+}

package/vendor/node_modules/@legendapp/spark-cli/dist/dev.js

@@ -0,0 +1,408 @@
+import { installedRelease } from "./release.js";
+import { acquireRunner } from "./runner-install.js";
+import { spawnProcess } from "./process.js";
+import { windowsMetroPort, stopWindowsMetro } from "./windows-metro.js";
+import { projectPlatform } from "./platform.js";
+import { nodeCommand } from "./windows.js";
+import { readAppConfig } from "./project.js";
+import { existsSync, rmSync, watch } from "node:fs";
+import path from "node:path";
+import { run, cancelCommands } from "./commands.js";
+import { build } from "./build.js";
+import { createRequire } from "node:module";
+const { preparePatch } = createRequire(import.meta.url)("./expo-dev-patch.cjs");
+import { findGo, readRuntime, registerRuntime } from "./local.js";
+import { sessionStatus } from "./session-status.js";
+import { prepareConfig, dependencyStamp, goConfigurationIssues, incompatible, nativePackages, readJson, projectEnvironment, runtimeFor, stateFile, writeJson, } from "./project.js";
+export async function launch(root, app, port, options = {}) {
+    if (readRuntime(app)?.platform === "windows") {
+        if (process.platform !== "win32")
+            throw new Error("Launch the Windows runtime on Windows.");
+        const nativePort = await windowsMetroPort(root, port ?? 8081, options);
+        writeJson(stateFile(root, "windows-connection.json"), { port: nativePort, dev: options.dev ?? true });
+        return spawnProcess([path.join(app, "MyApp.exe")], { cwd: app, env: { ...process.env, ...projectEnvironment(root), SPARK_METRO_PORT: String(nativePort), SPARK_SESSION_FILE: stateFile(root, "windows-connection.json") }, stdout: "inherit", stderr: "inherit" });
+    }
+    const info = await run(root, [
+        "/usr/libexec/PlistBuddy",
+        "-c",
+        "Print :CFBundleExecutable",
+        path.join(app, "Contents/Info.plist"),
+    ], { capture: true });
+    const executable = path.join(app, "Contents/MacOS", info.trim());
+    const runtimeFile = path.join(app, "Contents/Resources/spark-runtime.json");
+    const developmentJS = options.dev ?? (!existsSync(runtimeFile) || readJson(runtimeFile).mode !== "preview");
+    // Direct executable launch retains the exact product path and process ownership.
+    // RN's native packager websocket reads RCT_jsLocation independently of the
+    // JS bundle URL. The process argument domain avoids persistent preference edits.
+    return spawnProcess([executable, ...(port ? ["-RCT_jsLocation", `127.0.0.1:${port}`] : [])], {
+        cwd: root,
+        env: {
+            ...process.env,
+            ...projectEnvironment(root),
+            ...(port
+                ? {
+                    SPARK_BUNDLE_URL: `${options.https ? "https" : "http"}://127.0.0.1:${port}/index.bundle?platform=macos&dev=${developmentJS}&minify=${options.minify ?? false}`,
+                }
+                : {}),
+        },
+        stdout: "inherit",
+        stderr: "inherit",
+    });
+}
+export async function dev(root, goApp, expoArgs = [], noOpen = false) {
+    const platform = projectPlatform(root);
+    preparePatch(root);
+    let port;
+    let bundleOptions = {};
+    let target = "go";
+    const settingsFile = stateFile(root, "settings.json");
+    const settings = existsSync(settingsFile) ? readJson(settingsFile) : {};
+    const explicitGo = !!goApp;
+    goApp ??= settings.goApp;
+    if (goApp)
+        goApp = path.resolve(goApp);
+    if (explicitGo)
+        registerRuntime(goApp);
+    if (!explicitGo && settings.target === "dev")
+        target = "dev";
+    let current;
+    let appProcess;
+    let launchedRuntime;
+    let busy = false;
+    let status = "";
+    let canBuild = false;
+    let stamp = dependencyStamp(root);
+    let restartPending = false;
+    let reopenPending = false;
+    let closing = false;
+    let metro;
+    let finish;
+    const finished = new Promise((resolve) => {
+        finish = resolve;
+    });
+    async function startMetro() {
+        prepareConfig(root);
+        const previous = metro;
+        metro = undefined;
+        if (previous && previous.exitCode === null) {
+            previous.kill();
+            await previous.exited;
+        }
+        if (closing)
+            return;
+        let ready;
+        const started = new Promise(resolve => { ready = resolve; });
+        const [, expo, ...args] = nodeCommand(root, "expo", "expo", [
+            "start", root, ...(port ? ["--port", String(port)] : []), ...expoArgs,
+        ]);
+        // Expo owns stdin and the terminal. JSON IPC carries desktop actions only;
+        // reload, debugger, mobile/web actions, prompts and shutdown remain Expo's.
+        const child = spawnProcess([
+            "node", "--require", path.join(import.meta.dirname, "expo-dev-preload.cjs"), expo, ...args,
+        ], {
+            cwd: root, env: { ...process.env, SPARK_PLATFORM: platform, SPARK_DEV_SESSION: "1" },
+            stdin: "inherit", stdout: "inherit", stderr: "inherit", serialization: "json",
+            ipc(message, sender) {
+                if (message?.type === "spark:ready") {
+                    bundleOptions = message.options ?? {};
+                    ready(message.port);
+                }
+                if (message?.type === "spark:action") {
+                    void action(message.action).then(() => { if (sender.exitCode === null)
+                        sender.send({ type: "spark:result", id: message.id }); }, error => { if (sender.exitCode === null)
+                        sender.send({ type: "spark:result", id: message.id, error: String(error) }); });
+                }
+            },
+        });
+        metro = child;
+        child.send({ type: "spark:state", state: { target, canBuild } });
+        void child.exited.then(code => {
+            if (metro === child && !closing) {
+                process.exitCode = code;
+                close();
+            }
+        });
+        let timeout;
+        try {
+            const actualPort = await Promise.race([
+                started,
+                child.exited.then(code => { throw new Error(`Expo exited before starting (exit ${code}). See its output above.`); }),
+                new Promise((_, reject) => { timeout = setTimeout(() => reject(new Error("Expo did not become ready.")), platform === "windows" ? 180_000 : 60_000); }),
+            ]);
+            if (!Number.isInteger(actualPort) || actualPort < 1)
+                throw new Error("Expo did not provide its Metro port.");
+            port = actualPort;
+            await check();
+            restartPending = false;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async function check(report = false) {
+        if (closing)
+            return false;
+        try {
+            return await inspectRuntime(report);
+        }
+        catch (error) {
+            current = undefined;
+            canBuild = false;
+            if (appProcess?.exitCode === null) {
+                appProcess.kill();
+                await appProcess.exited;
+            }
+            if (closing)
+                return false;
+            const reason = String(error);
+            writeJson(stateFile(root, "session.json"), { compatible: false, reason, target, port, canBuild });
+            if (metro?.exitCode === null)
+                metro.send({ type: "spark:state", state: { target, canBuild } });
+            if (report || status !== reason) {
+                status = reason;
+                console.error(`\n› Desktop: ${reason}`);
+            }
+            return false;
+        }
+    }
+    async function inspectRuntime(report) {
+        const native = nativePackages(root);
+        current = undefined;
+        if (target === "go") {
+            if (explicitGo) {
+                const runtime = readRuntime(goApp);
+                if (runtime?.mode === "go")
+                    current = { app: goApp, runtime };
+            }
+            else {
+                current = findGo(native, goApp, platform);
+                if (current)
+                    goApp = current.app;
+            }
+        }
+        if (target === "dev" && existsSync(stateFile(root, "dev-build.json"))) {
+            const record = readJson(stateFile(root, "dev-build.json"));
+            const runtime = readRuntime(record.app);
+            if (runtime?.mode === "dev")
+                current = { app: record.app, runtime };
+        }
+        const issues = current ? incompatible(current.runtime, native, platform) : [];
+        if (current && target === "dev" &&
+            current.runtime.fingerprint !== runtimeFor(root, native, "dev").fingerprint)
+            issues.push("Native configuration or host changed.");
+        if (target === "go") {
+            for (let i = 0; i < issues.length; i++) {
+                const name = issues[i];
+                if (native.some((pkg) => pkg.name === name)) {
+                    issues[i] = current?.runtime.modules[name]
+                        ? `${name} has changed since this Spark Runner was built.`
+                        : `${name} isn’t included in the Spark Runner.`;
+                }
+            }
+            issues.push(...goConfigurationIssues(readAppConfig(root)));
+        }
+        const view = sessionStatus(target, !!current, issues, appProcess?.exitCode === null, !!installedRelease()?.runners[`${platform}-${platform === "macos" ? "arm64" : process.arch}`]);
+        if (view.compatible && current && appProcess?.exitCode === null &&
+            (launchedRuntime?.app !== current.app || launchedRuntime.fingerprint !== current.runtime.fingerprint)) {
+            // Discovery can find a different compatible binary after a native edit.
+            // Relaunch before allowing that new runtime selection to serve the app.
+            restartPending = true;
+            appProcess.kill();
+            await appProcess.exited;
+            appProcess = undefined;
+            reopenPending = true;
+        }
+        if (closing)
+            return false;
+        canBuild = view.canBuild;
+        const next = view.message;
+        writeJson(stateFile(root, "session.json"), {
+            compatible: view.compatible,
+            reason: next,
+            target,
+            port,
+            canBuild,
+        });
+        // An existing HMR websocket can push code without another bundle request.
+        // Stop only the process owned by this session when its native ABI is stale.
+        if (!view.compatible && appProcess && appProcess.exitCode === null) {
+            appProcess.kill();
+            await appProcess.exited;
+        }
+        if (metro?.exitCode === null)
+            metro.send({ type: "spark:state", state: { target, canBuild } });
+        if (report || next !== status) {
+            status = next;
+            console.log(`\n› Desktop: ${status}\n${view.compatible ? "" : view.actions + "\n"}`);
+        }
+        return view.compatible;
+    }
+    async function open() {
+        if (platform === "windows" ? process.platform !== "win32" : process.platform !== "darwin") {
+            throw new Error(`Open ${platform} on a matching desktop host. Mobile and web remain available.`);
+        }
+        const localRunner = target === "go" ? findGo(nativePackages(root), goApp, platform) : undefined;
+        if (target === "go" && !explicitGo && (!localRunner || incompatible(localRunner.runtime, nativePackages(root), platform).length > 0)) {
+            const downloaded = await acquireRunner(platform);
+            if (downloaded)
+                goApp = downloaded;
+        }
+        if ((await check(true)) && current) {
+            if (restartPending)
+                await startMetro();
+            if (closing)
+                return;
+            if (appProcess && appProcess.exitCode === null) {
+                appProcess.kill();
+                await appProcess.exited;
+            }
+            appProcess = await launch(root, current.app, port, bundleOptions);
+            if (closing) {
+                appProcess.kill();
+                return;
+            }
+            launchedRuntime = { app: current.app, fingerprint: current.runtime.fingerprint };
+            reopenPending = false;
+            await check();
+        }
+    }
+    async function action(name) {
+        if (busy || closing)
+            throw new Error("Desktop runtime is busy. Try again in a moment.");
+        busy = true;
+        try {
+            if (name === "switch") {
+                target = target === "dev" ? "go" : "dev";
+                if (appProcess?.exitCode === null) {
+                    appProcess.kill();
+                    await appProcess.exited;
+                }
+                await open();
+                writeJson(settingsFile, { target, goApp });
+            }
+            else if (name === "build") {
+                if ((await check()) || !canBuild)
+                    return;
+                writeJson(stateFile(root, "session.json"), { compatible: false, reason: "Preparing custom development build" });
+                if (appProcess?.exitCode === null) {
+                    appProcess.kill();
+                    await appProcess.exited;
+                }
+                await build(root, "dev");
+                if (closing)
+                    return;
+                target = "dev";
+                restartPending = true;
+                await open();
+                writeJson(settingsFile, { target, goApp });
+            }
+            else if (name === "open")
+                await open();
+        }
+        catch (error) {
+            if (!closing)
+                await check();
+            throw error;
+        }
+        finally {
+            busy = false;
+        }
+    }
+    function close() {
+        if (closing)
+            return;
+        closing = true;
+        clearInterval(timer);
+        clearTimeout(debounce);
+        watcher.close();
+        appProcess?.kill();
+        metro?.kill();
+        cancelCommands(root);
+        rmSync(stateFile(root, "session.json"), { force: true });
+        stopWindowsMetro(root);
+        rmSync(stateFile(root, "windows-connection.json"), { force: true });
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        void Promise.allSettled([metro?.exited, appProcess?.exited]).then(finish);
+    }
+    let debounce;
+    // Suspend bundle requests promptly while a package manager changes the graph.
+    const watcher = watch(root, (_event, filename) => {
+        if (!filename ||
+            ![
+                "package.json",
+                "bun.lock",
+                "package-lock.json",
+                "pnpm-lock.yaml",
+                "yarn.lock",
+                "app.json",
+                "desktop.config.json",
+                "metro.config.js",
+            ].includes(String(filename)) ||
+            closing)
+            return;
+        writeJson(stateFile(root, "session.json"), {
+            compatible: false,
+            reason: "Dependencies changed; checking runtime",
+        });
+        restartPending = true;
+        clearTimeout(debounce);
+        debounce = setTimeout(() => {
+            if (!busy)
+                void refresh();
+        }, 400);
+    });
+    async function refresh() {
+        if (busy || closing)
+            return;
+        busy = true;
+        try {
+            const next = dependencyStamp(root);
+            if (next !== stamp) {
+                restartPending = true;
+                stamp = next;
+            }
+            const compatible = await check();
+            if (restartPending) {
+                const wasOpen = appProcess?.exitCode === null || reopenPending;
+                await startMetro();
+                // A new Metro dependency map needs a fresh app connection, not the old HMR graph.
+                if (wasOpen && compatible)
+                    await open();
+            }
+        }
+        catch (error) {
+            writeJson(stateFile(root, "session.json"), {
+                compatible: false,
+                reason: String(error),
+            });
+            console.error(String(error));
+        }
+        finally {
+            busy = false;
+        }
+    }
+    const timer = setInterval(refresh, 2000);
+    process.on("SIGINT", close);
+    process.on("SIGTERM", close);
+    try {
+        busy = true;
+        await check();
+        await startMetro();
+        if (!noOpen)
+            await open().catch(error => console.error(String(error)));
+    }
+    catch (error) {
+        close();
+        process.off("SIGINT", close);
+        process.off("SIGTERM", close);
+        throw error;
+    }
+    finally {
+        busy = false;
+    }
+    writeJson(settingsFile, { target, goApp });
+    await finished;
+    process.off("SIGINT", close);
+    process.off("SIGTERM", close);
+}