@legendapp/spark 0.0.1-next.2

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

@@ -0,0 +1,43 @@
+import { packageManager, managerCommand } from "./package-manager.js";
+import { cpSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { readJson, writeJson } from "./project.js";
+import { run } from "./commands.js";
+export const examples = ["document-editor", "notes-lite", "music-lite", "diff-lite"];
+export async function configureExample(root, example) {
+    const pkg = readJson(path.join(root, "package.json"));
+    const suffixes = ["desktop-app", "desktop-windows", "desktop-shortcuts", "native-menu", "file-dialog", "message-dialog"];
+    if (example === "music-lite")
+        suffixes.push("audio");
+    if (example === "diff-lite")
+        suffixes.push("processes");
+    const desktop = suffixes.map(name => name === "desktop" ? "@legendapp/spark" : `@legendapp/spark-${name}`);
+    if (!pkg.dependencies["@legendapp/spark"])
+        throw new Error("SDK example requires @legendapp/spark");
+    Object.assign(pkg.dependencies, { "expo-document-picker": "14.0.8", "expo-file-system": "19.0.24", "expo-sharing": "14.0.8" });
+    if (example !== "document-editor")
+        pkg.dependencies["@react-native-async-storage/async-storage"] = "2.2.0";
+    if (example === "music-lite")
+        pkg.dependencies["expo-audio"] = "1.1.1";
+    if (example === "diff-lite")
+        pkg.dependencies["diff"] = "8.0.2";
+    writeJson(path.join(root, "package.json"), pkg);
+    const config = readJson(path.join(root, "desktop.config.json"));
+    for (const platform of ["ios", "android", "macos", "windows"]) {
+        const options = config.expoByPlatform[platform] ??= {};
+        const excluded = options.autolinking?.exclude ?? [];
+        const extra = ["macos", "windows"].includes(platform) ? ["expo-document-picker", "expo-sharing", "expo-file-system", "expo-audio"] : desktop;
+        if (platform === "windows")
+            extra.push(...desktop.filter(name => !["@legendapp/spark-file-dialog", "@legendapp/spark-audio", "@legendapp/spark-desktop-app", "@legendapp/spark-desktop-windows", "@legendapp/spark-desktop-shortcuts", "@legendapp/spark-native-menu"].includes(name)));
+        options.autolinking = { ...options.autolinking, exclude: [...new Set([...excluded, ...extra])] };
+        if (example === "music-lite" && ["ios", "android"].includes(platform))
+            options.plugins = [...(options.plugins ?? []), ["expo-audio", { microphonePermission: false, enableBackgroundPlayback: true, recordAudioAndroid: false }]];
+    }
+    writeJson(path.join(root, "desktop.config.json"), config);
+    cpSync(path.resolve(import.meta.dirname, "../templates", example), root, { recursive: true });
+    if (example !== "document-editor") {
+        cpSync(path.resolve(import.meta.dirname, "../templates/example-shared"), path.join(root, "shared"), { recursive: true });
+        writeFileSync(path.join(root, "shared/identity.ts"), `export const projectId = ${JSON.stringify(config.projectId)};\n`);
+    }
+    await run(root, managerCommand(packageManager(root), ["install"]));
+}

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

@@ -0,0 +1,19 @@
+import { accessSync, constants, statSync } from "node:fs";
+import path from "node:path";
+export function which(command, env = process.env) {
+    const extensions = process.platform === "win32" ? ["", ...(env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";")] : [""];
+    const directories = command.includes(path.sep) || path.isAbsolute(command) ? [""] : (env.PATH ?? "").split(path.delimiter);
+    for (const directory of directories) {
+        for (const extension of extensions) {
+            const file = path.resolve(directory, command + extension);
+            try {
+                if (statSync(file).isFile()) {
+                    accessSync(file, constants.X_OK);
+                    return file;
+                }
+            }
+            catch { }
+        }
+    }
+    return undefined;
+}

package/vendor/node_modules/@legendapp/spark-cli/dist/expo-dev-extension.cjs

@@ -0,0 +1,51 @@
+let state = { target: 'go', canBuild: false };
+let sequence = 0;
+const pending = new Map();
+
+function commands(platform = process.env.SPARK_PLATFORM, host = process.platform, current = state) {
+  const name = platform === 'macos' ? 'macOS' : platform === 'windows' ? 'Windows' : undefined;
+  if (!name) return [];
+  const disabled = platform === 'macos' ? host !== 'darwin' : host !== 'win32';
+  return [
+    { key: 'd', msg: `open ${name} (${current.target === 'go' ? 'Spark Runner' : 'development build'})`, disabled },
+    { key: 'g', msg: `switch desktop to ${current.target === 'go' ? 'development build' : 'Spark Runner'}`, disabled },
+    { key: 'b', msg: `build and open ${name} development build`, disabled: disabled || !current.canBuild },
+  ];
+}
+
+async function handleKey(key) {
+  if (!commands().some(command => command.key === key)) return false;
+  if (commands().find(command => command.key === key).disabled) return true;
+  const id = ++sequence;
+  await new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    process.send({ type: 'spark:action', id, action: { d: 'open', g: 'switch', b: 'build' }[key] }, error => {
+      if (error) { pending.delete(id); reject(error); }
+    });
+  });
+  return true;
+}
+
+function integrateCommands(ui) {
+  const desktop = commands();
+  return ui.flatMap(item => {
+    const keys = item?.key === 's' ? ['g'] : item?.key === 'w' ? ['d', 'b'] : [];
+    return [item, ...desktop.filter(command => keys.includes(command.key))];
+  });
+}
+
+if (process.send) {
+  process.on('message', message => {
+    if (message?.type === 'spark:state') state = message.state;
+    if (message?.type === 'spark:result') {
+      const request = pending.get(message.id);
+      pending.delete(message.id);
+      if (message.error) request?.reject(new Error(message.error));
+      else request?.resolve();
+    }
+  });
+  // The supervisor owns the native app; do not leave Expo alive if it disappears.
+  process.on('disconnect', () => process.exit());
+}
+
+module.exports = { commands, integrateCommands, handleKey, ready: (port, options) => process.send({ type: 'spark:ready', port, options }) };

package/vendor/node_modules/@legendapp/spark-cli/dist/expo-dev-patch.cjs

@@ -0,0 +1,38 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { createRequire } = require('node:module');
+const { createHash } = require('node:crypto');
+
+const VERSION = '54.0.27';
+const extension = JSON.stringify(path.join(__dirname, 'expo-dev-extension.cjs'));
+// Process-local patches: installed Expo files remain untouched. Verify the exact
+// upstream inputs before starting, so an Expo upgrade cannot silently lose keys.
+const patches = [
+  ['interface/commandsTable.js', 'eeb1700b0ae26613bf6dedab556479a4c15d3a3c94c63ecbb5db21c4899e1645',
+    'function logCommandsTable(ui) {',
+    `function logCommandsTable(ui) {\n    ui = require(${extension}).integrateCommands(ui);`],
+  ['interface/startInterface.js', 'c8e55431b18a37e1ab2be22f068c980e9cc41ffc105ea7478e34fc11b91a22bd',
+    '    const onPressAsync = async (key)=>{',
+    `    const onPressAsync = async (key)=>{\n        try {\n            if (await require(${extension}).handleKey(key)) return;\n        } catch (error) {\n            _log.exception(error);\n            return;\n        }`],
+  ['startAsync.js', '0e062078e63ad6264b1393d403ad56d65a38c6430d30fdac50cd656486cd418b',
+    '    mcpServer == null ? void 0 : mcpServer.start();',
+    `    mcpServer == null ? void 0 : mcpServer.start();\n    require(${extension}).ready(devServerManager.getNativeDevServerPort(), { dev: options.dev, minify: options.minify, https: options.https });`],
+];
+
+function preparePatch(root) {
+  const appRequire = createRequire(path.join(root, 'package.json'));
+  const expoRequire = createRequire(appRequire.resolve('expo/package.json'));
+  const manifest = expoRequire.resolve('@expo/cli/package.json');
+  const version = JSON.parse(fs.readFileSync(manifest, 'utf8')).version;
+  if (version !== VERSION) throw new Error(`spark desktop keys require @expo/cli ${VERSION}; found ${version}. Restore the supported version or update the spark Expo patch.`);
+  return new Map(patches.map(([relative, hash, before, after]) => {
+    const file = fs.realpathSync(path.join(path.dirname(manifest), 'build/src/start', relative));
+    const source = fs.readFileSync(file, 'utf8');
+    if (createHash('sha256').update(source).digest('hex') !== hash || source.split(before).length !== 2) {
+      throw new Error(`Unsupported Expo CLI source: ${relative}. Update the spark Expo patch before starting desktop development.`);
+    }
+    return [file, source.replace(before, after)];
+  }));
+}
+
+module.exports = { VERSION, preparePatch };

package/vendor/node_modules/@legendapp/spark-cli/dist/expo-dev-preload.cjs

@@ -0,0 +1,19 @@
+const Module = require('node:module');
+const { preparePatch } = require('./expo-dev-patch.cjs');
+
+// Node forks inherit --require, including Metro transform workers. Only the
+// top-level Expo process may attach to the Spark supervisor's IPC channel.
+if (!process.env.SPARK_EXPO_PRELOADED) {
+  process.env.SPARK_EXPO_PRELOADED = '1';
+  if (!process.send) throw new Error('Start the Spark Expo integration through spark dev.');
+  const patches = preparePatch(process.cwd());
+  const load = Module._extensions['.js'];
+  Module._extensions['.js'] = function(module, filename) {
+    const source = patches.get(filename);
+    if (source === undefined) return load(module, filename);
+    patches.delete(filename);
+    if (!patches.size) Module._extensions['.js'] = load;
+    module._compile(source, filename);
+  };
+  require('./expo-dev-extension.cjs');
+}

package/vendor/node_modules/@legendapp/spark-cli/dist/expo-metro.cjs

@@ -0,0 +1,41 @@
+const { createRequire } = require('node:module');
+const path = require('node:path');
+const defaults = new Map();
+const desktopSession = () => process.env.SPARK_DEV_SESSION === '1' || ['macos', 'windows'].includes(process.env.SPARK_PLATFORM);
+
+// A drop-in getDefaultConfig import: let upstream supply each target's defaults
+// before the application's existing Metro customizations are applied.
+exports.getDefaultConfig = (root, ...options) => {
+  const requireApp = createRequire(path.join(root, 'package.json'));
+  const config = desktopSession()
+    ? requireApp('expo-desktop-metro-config').makeMetroConfig(root, ...options)
+    : requireApp('expo/metro-config').getDefaultConfig(root, ...options);
+  defaults.set(path.resolve(root), { resolveRequest: config.resolver.resolveRequest, rewriteRequestUrl: config.server?.rewriteRequestUrl });
+  return config;
+};
+
+exports.withSparkMetro = config => {
+  if (!desktopSession()) return config;
+  if (config && typeof config.then === 'function') return config.then(exports.withSparkMetro);
+  if (!config || typeof config !== 'object') throw new Error('Spark needs an object or promise from metro.config');
+  const upstream = defaults.get(path.resolve(config.projectRoot || process.cwd()));
+  if (!upstream) throw new Error('Compose Metro with getDefaultConfig from @legendapp/spark-cli/src/expo-metro.cjs');
+  const customResolve = config.resolver?.resolveRequest;
+  if (customResolve && customResolve !== upstream.resolveRequest) {
+    const desktopResolve = upstream.resolveRequest;
+    config = { ...config, resolver: { ...config.resolver, resolveRequest(context, name, platform) {
+      return customResolve({ ...context, resolveRequest(nextContext, nextName, nextPlatform) {
+        return desktopResolve({ ...nextContext, resolveRequest: context.resolveRequest }, nextName, nextPlatform);
+      } }, name, platform);
+    } } };
+  }
+  const rewrite = config.server?.rewriteRequestUrl;
+  const result = require('./metro.cjs').withDesktop(config, { runtimes: false });
+  return { ...result, server: { ...result.server, rewriteRequestUrl(url) {
+    // Existing desktop hosts request index. Expo resolves the application's
+    // actual package.json main, including its default AppEntry, without a shim.
+    const entry = url.replace(/\/index(?:\.windows)?\.bundle\?/, '/.expo/.virtual-metro-entry.bundle?');
+    const rewritten = rewrite ? rewrite(entry) : entry;
+    return upstream.rewriteRequestUrl ? upstream.rewriteRequestUrl(rewritten) : rewritten;
+  } } };
+};

package/vendor/node_modules/@legendapp/spark-cli/dist/expo-native.cjs

@@ -0,0 +1,10 @@
+exports.withSparkNative = (original, root) => {
+  if (!['macos', 'windows'].includes(process.env.SPARK_PLATFORM)) return original;
+  const generated = require('./universal.cjs').nativeConfig(root);
+  const dependencies = { ...original.dependencies };
+  for (const [name, config] of Object.entries(generated.dependencies ?? {})) {
+    dependencies[name] = { ...dependencies[name], ...config,
+      platforms: { ...dependencies[name]?.platforms, ...config.platforms } };
+  }
+  return { ...original, platforms: { ...generated.platforms, ...original.platforms }, dependencies };
+};

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

@@ -0,0 +1,21 @@
+import { spawnProcess, which } from "./process.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+/** Check the actual Node/Expo pair before handing work to Expo Desktop beta. */
+export async function checkExpoDesktopNode(root) {
+    const requireApp = createRequire(path.join(root, "package.json"));
+    const requireDesktop = createRequire(requireApp.resolve("expo-desktop/package.json"));
+    const configPlugins = pathToFileURL(requireDesktop.resolve("@expo/config-plugins")).href;
+    const node = which("node");
+    if (!node)
+        throw new Error("Missing node. Install Node 24.19.0 (the version in .nvmrc), then retry.");
+    // Use the same static named imports as beta.5. Older Node releases cannot
+    // discover these exports in Expo's Babel-generated CommonJS modules.
+    const child = spawnProcess([node, "--input-type=module", "-e",
+        `import { AndroidConfig, IOSConfig } from ${JSON.stringify(configPlugins)}; if (!AndroidConfig || !IOSConfig) throw new Error('Missing Expo config exports');`,
+    ], { cwd: root, stdout: "ignore", stderr: "pipe" });
+    const [stderr, code] = await Promise.all([new Response(child.stderr).text(), child.exited]);
+    if (code !== 0)
+        throw new Error(`Expo Desktop beta could not load its config plugins using ${node}. Use Node 24.19.0 (nvm install && nvm use from the framework checkout), then retry. Node 24.12.0 cannot import these CommonJS named exports.\n${stderr.trim()}`);
+}

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

@@ -0,0 +1,20 @@
+import { packageManager, managerCommand, localArchive } from "./package-manager.js";
+import path from "node:path";
+import { readJson, writeJson } from "./project.js";
+import { run } from "./commands.js";
+/** Modules shipped in the maintained client, in addition to its platform starter. */
+export async function prepareGoProfile(root, manifest, platform, selectedManager) {
+    const manager = packageManager(root, selectedManager);
+    const pkg = readJson(path.join(root, "package.json"));
+    const archives = readJson(manifest);
+    if (!archives["@legendapp/spark"])
+        throw new Error("Spark Runner profile requires @legendapp/spark");
+    pkg.dependencies["@legendapp/spark"] = localArchive(path.resolve(path.dirname(manifest), archives["@legendapp/spark"]));
+    pkg.dependencies["@react-native-async-storage/async-storage"] = "2.2.0";
+    // Expo's mobile development client brings this native utility into universal
+    // consumers' conservative graph. It builds on macOS and must be present in Go.
+    if (platform === "macos")
+        pkg.dependencies["expo-json-utils"] = "0.15.0";
+    writeJson(path.join(root, "package.json"), pkg);
+    await run(root, managerCommand(manager, ["install"]));
+}

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

@@ -0,0 +1,79 @@
+import { copyFileSync, lstatSync, mkdirSync, realpathSync, chmodSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { architecture } from "./platform.js";
+const { validateHelpers } = createRequire(import.meta.url)("@legendapp/spark-desktop-config/helpers.cjs");
+export function resolveHelpers(root, helpers = {}, platform = "macos", arch = architecture(platform)) {
+    validateHelpers(helpers);
+    const base = realpathSync(root);
+    function inspect(file) {
+        // Reject symlinks at every level, including parent directories. Bundles are
+        // relocatable plain directories; links and special files aren't portable.
+        const relative = path.relative(base, file);
+        let current = base;
+        for (const part of relative.split(path.sep)) {
+            current = path.join(current, part);
+            if (lstatSync(current).isSymbolicLink())
+                throw new Error(`Helper contains a symlink: ${current}`);
+        }
+        return lstatSync(file);
+    }
+    return Object.entries(helpers).map(([name, value]) => {
+        const bundle = typeof value === "string" ? undefined : value[`${platform}-${arch}`];
+        if (typeof value !== "string" && !bundle)
+            throw new Error(`Helper ${name} has no ${platform}-${arch} bundle`);
+        const directory = bundle ? path.join(base, bundle.directory) : undefined;
+        const file = bundle ? path.join(directory, bundle.executable) : path.join(base, value);
+        if (!inspect(file).isFile())
+            throw new Error(`Helper must be a regular file: ${name}`);
+        const files = [];
+        const directories = [];
+        const modes = [];
+        function visit(entry) {
+            const stat = inspect(entry);
+            if (stat.isDirectory()) {
+                directories.push(path.relative(directory, entry));
+                for (const child of readdirSync(entry).sort())
+                    visit(path.join(entry, child));
+            }
+            else if (stat.isFile()) {
+                files.push(path.relative(base, entry));
+                modes.push([path.relative(base, entry), stat.mode & 0o777]);
+            }
+            else
+                throw new Error(`Helper contains a special file: ${entry}`);
+        }
+        visit(directory ?? file);
+        if (bundle && readdirSync(directory).some(name => name.toLowerCase() === ".spark-entry"))
+            throw new Error(".spark-entry is reserved for helper metadata");
+        return { name, file, relative: path.relative(base, file), directory, files, directories, modes, executable: bundle?.executable };
+    });
+}
+export function copyHelpers(root, app, helpers = {}, platform = "macos", arch = architecture(platform)) {
+    const bundles = resolveHelpers(root, helpers, platform, arch);
+    const destination = path.join(app, platform === "windows" ? "Helpers" : "Contents/Helpers");
+    // This directory is framework-owned. Removed helpers must not survive rebuilds.
+    rmSync(destination, { recursive: true, force: true });
+    if (!bundles.length)
+        return;
+    mkdirSync(destination, { recursive: true });
+    for (const helper of bundles) {
+        if (!helper.directory) {
+            const file = path.join(destination, helper.name + (platform === "windows" ? ".exe" : ""));
+            copyFileSync(helper.file, file);
+            chmodSync(file, 0o755);
+            continue;
+        }
+        const directory = path.join(destination, `${helper.name}.helper`);
+        for (const relative of helper.directories)
+            mkdirSync(path.join(directory, relative), { recursive: true });
+        for (const relative of helper.files) {
+            const source = path.join(realpathSync(root), relative);
+            const target = path.join(directory, path.relative(helper.directory, source));
+            mkdirSync(path.dirname(target), { recursive: true });
+            copyFileSync(source, target);
+        }
+        chmodSync(path.join(directory, helper.executable), 0o755);
+        writeFileSync(path.join(directory, ".spark-entry"), helper.executable, "utf8");
+    }
+}

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

@@ -0,0 +1,263 @@
+import { spawnProcess } from "./process.js";
+import { examples } from "./examples.js";
+import { prepareGoProfile } from "./go-profile.js";
+import { exportSDK, importSDK } from "./sdk-transfer.js";
+import { hostPlatform } from "./platform.js";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { prepareConfig, readConfig, isExpoProject } from "@legendapp/spark-desktop-config/config.cjs";
+import { nodeCommand, prepareWindows } from "./windows.js";
+import { create, refreshLocalPackages } from "./create.js";
+import { addDesktop } from "./add-desktop.js";
+import { buildMode } from "./build-mode.js";
+import { initializeUpdates } from "./updates.js";
+import { packageApp } from "./package.js";
+import { credentials } from "./credentials.js";
+import { build, analyze } from "./build.js";
+import { launch } from "./dev.js";
+import { doctor, run } from "./commands.js";
+import { findFramework, findProject, sparkHome, creationManifest, packageManifest, registerRuntime } from "./local.js";
+import { readJson, stateFile, VERSION, writeJson } from "./project.js";
+import { devCommand } from "./dev-command.js";
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv[0] === "dev")
+        return devCommand(argv.slice(1));
+    const { positionals, values } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            example: { type: "string" },
+            "package-manager": { type: "string" },
+            runtime: { type: "string", multiple: true },
+            universal: { type: "boolean" },
+            device: { type: "string" },
+            project: { type: "string" },
+            platform: { type: "string" },
+            packages: { type: "string" },
+            port: { type: "string" },
+            runner: { type: "boolean" },
+            prebuilt: { type: "boolean" },
+            go: { type: "boolean" }, // Legacy desktop build alias; dev --go belongs to Expo.
+            dev: { type: "boolean" },
+            release: { type: "boolean" },
+            preview: { type: "boolean" },
+            force: { type: "boolean" },
+            "no-open": { type: "boolean" },
+            "submission-id": { type: "string" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    if (values.platform && !["macos", "windows", "ios", "android", "web"].includes(values.platform))
+        throw new Error("Platform must be macos, windows, ios, android, or web.");
+    if (values.platform)
+        process.env.SPARK_PLATFORM = values.platform;
+    const platform = (values.platform ?? hostPlatform());
+    const projectOption = values.project;
+    const start = path.resolve(projectOption ?? process.cwd());
+    const project = () => findProject(start);
+    const port = values.port === undefined ? undefined : Number(values.port);
+    if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
+        throw new Error("Port must be an integer between 1 and 65535.");
+    const command = positionals[0];
+    if (!values.help && !values.platform && !(command === "open" && positionals[1]) && ["build", "prebuild", "analyze", "package", "open", "updates", "credentials"].includes(command ?? "") && isExpoProject(project())) {
+        process.env.SPARK_PLATFORM = readConfig(project()).expo.platforms[0];
+    }
+    if (values.example && (command !== "create" || !examples.includes(values.example)))
+        throw new Error(`Use create --example ${examples.join(" | ")}`);
+    if (values.universal && command !== "create")
+        throw new Error("--universal is a create option.");
+    if (!values.help && ["build", "prebuild"].includes(command ?? "")) {
+        const root = project();
+        const selected = readConfig(root).expo.platforms[0];
+        if (["ios", "android", "web"].includes(selected)) {
+            if (command === "build" && selected === "web")
+                throw new Error("Use expo export --platform web for web production output.");
+            if (command === "prebuild" && selected === "web")
+                throw new Error("Web has no native project to prebuild.");
+            if (values.runner || values.prebuilt || values.go || values.release || values.preview || (command === "build" && !values.dev))
+                throw new Error("Mobile builds use --dev in this slice; Expo owns mobile distribution workflows.");
+            prepareConfig(root);
+            const args = command === "prebuild" ? ["prebuild", "--platform", selected, "--no-install"] : [`run:${selected}`, ...(values.device ? ["--device", values.device] : []), ...(port ? ["--port", String(port)] : [])];
+            const manifest = readFileSync(path.join(root, "package.json"), "utf8");
+            try {
+                const child = spawnProcess(nodeCommand(root, "expo", "expo", args), { cwd: root, env: process.env, stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+                process.exitCode = await child.exited;
+            }
+            finally {
+                writeFileSync(path.join(root, "package.json"), manifest);
+            }
+            process.exit(process.exitCode);
+        }
+    }
+    if (values.help || !command) {
+        console.log(`Legend Spark
+
+  spark create MyApp  Create an app (--universal for shared Settings; --platform selects a target)
+  spark create MyEditor --example document-editor  Shared document editor
+  spark create MyNotes --example notes-lite        Local notes
+  spark create MyMusic --example music-lite        Audio queue
+  spark create MyDiff --example diff-lite          Text comparison
+  spark add desktop  Add desktop to an existing Expo app without replacing its entry point
+  spark dev           Develop with Fast Refresh
+  spark build         Build a standalone desktop app
+  spark prebuild      Generate a Windows/mobile native project
+  spark package       Sign and notarize a distribution archive
+
+Inside an app: npm run dev, npm run build, npm run package (or pnpm, yarn, bun)
+
+Advanced: updates init <feedURL>, credentials, doctor, analyze, open [app], build --dev, build --preview
+Windows: dev and build --dev; production builds are not yet supported.
+SDK transfer: sdk export <directory> [--runtime <Spark Runner directory>], sdk import <directory>
+SDK maintainers: sdk pack, sdk package-runner, sdk build-runner [--platform windows], sdk register <runtime directory>
+Targets: dev/build/prebuild --platform macos|windows|ios|android|web
+Overrides: --project <directory>, --port <number>, dev --runner-binary <runtime path>, create --packages <manifest>, create / sdk build-runner --package-manager npm|pnpm|yarn|bun`);
+    }
+    else
+        switch (command) {
+            case "add": {
+                if (positionals[1] !== "desktop")
+                    throw new Error("Usage: spark add desktop [--project <Expo app>]");
+                await addDesktop(start, creationManifest(values.packages));
+                break;
+            }
+            case "create": {
+                if (!positionals[1])
+                    throw new Error("Usage: spark create MyApp");
+                if (!values.universal && !["macos", "windows"].includes(platform))
+                    throw new Error("Use create --universal for mobile/web targets");
+                await create(path.resolve(positionals[1]), creationManifest(values.packages), platform, !!values.universal || !!values.example, values.example, values["package-manager"]);
+                break;
+            }
+            case "sdk": {
+                if (!["macos", "windows"].includes(platform))
+                    throw new Error("SDK commands require a desktop target");
+                switch (positionals[1]) {
+                    case "export": {
+                        if (!positionals[2])
+                            throw new Error("Usage: spark sdk export <directory> [--runtime <Spark Runner directory>]");
+                        console.log(`Exported SDK to ${exportSDK(packageManifest(values.packages), positionals[2], values.runtime)}. Transfer the directory and run node install.mjs there.`);
+                        break;
+                    }
+                    case "import": {
+                        if (!positionals[2])
+                            throw new Error("Usage: spark sdk import <SDK directory>");
+                        console.log(`Registered SDK from ${importSDK(positionals[2])}`);
+                        break;
+                    }
+                    case "pack": {
+                        const framework = findFramework(start) ?? findFramework();
+                        if (!framework)
+                            throw new Error("Run spark sdk pack inside the framework checkout.");
+                        await run(framework, [process.execPath, path.join(framework, "scripts/pack.ts"), ...(platform === "windows" ? ["--platform=windows"] : [])]);
+                        break;
+                    }
+                    case "register": {
+                        if (!positionals[2])
+                            throw new Error("Usage: spark sdk register <runtime directory>");
+                        const result = registerRuntime(positionals[2]);
+                        console.log(`Registered Spark Runner for SDK ${result.runtime.framework}. Apps will discover it automatically.`);
+                        break;
+                    }
+                    case "package-runner": {
+                        if (platform !== "macos")
+                            throw new Error("Signed Runner distribution currently supports macOS only.");
+                        const root = projectOption ? project() : path.join(sparkHome(), "sdk-builds", VERSION, "SparkRunner");
+                        const result = await packageApp(root, { runner: true, force: !!values.force, submissionId: values["submission-id"] });
+                        if (result.pending)
+                            process.exitCode = 2;
+                        break;
+                    }
+                    case "build-go": // Legacy alias; persisted runtime metadata still uses "go".
+                    case "build-prebuilt": // Legacy command alias.
+                    case "build-runner": {
+                        let root;
+                        if (projectOption)
+                            root = project();
+                        else {
+                            root = path.join(sparkHome(), "sdk-builds", VERSION, ...(platform === "windows" ? ["windows"] : []), "SparkRunner");
+                            const manifest = packageManifest(values.packages);
+                            const manager = values["package-manager"];
+                            if (!existsSync(path.join(root, "package.json")))
+                                await create(root, manifest, platform, false, undefined, manager);
+                            else
+                                await refreshLocalPackages(root, manifest, manager);
+                            await prepareGoProfile(root, manifest, platform, manager);
+                            const configFile = path.join(root, "desktop.config.json");
+                            const config = readJson(configFile);
+                            config.version = VERSION.split("-")[0];
+                            writeJson(configFile, config);
+                        }
+                        await build(root, "go", !!values.force);
+                        break;
+                    }
+                    default: throw new Error("SDK commands: spark sdk pack, spark sdk build-runner, spark sdk register <runtime directory>");
+                }
+                break;
+            }
+            case "prebuild":
+                if (readConfig(project()).expo.platforms[0] !== "windows")
+                    throw new Error("For macOS, spark build --dev generates and builds the native project.");
+                await prepareWindows(project(), "dev");
+                break;
+            case "doctor":
+                await doctor(start);
+                console.log("Native toolchain available.");
+                break;
+            case "updates": {
+                if (positionals[1] !== "init" || !positionals[2])
+                    throw new Error("Usage: spark updates init https://example.com/updates/appcast.xml");
+                await initializeUpdates(project(), positionals[2]);
+                break;
+            }
+            case "credentials":
+                await credentials(project(), true);
+                console.log("Signing credentials configured. Run spark package to prepare a distribution archive.");
+                break;
+            case "package": {
+                if (process.platform !== "darwin" || process.arch !== "arm64")
+                    throw new Error("Packaging currently supports Apple Silicon macOS only.");
+                const result = await packageApp(project(), { force: !!values.force, submissionId: values["submission-id"] });
+                if (result.pending)
+                    process.exitCode = 2;
+                break;
+            }
+            case "build": {
+                const mode = buildMode(values);
+                const root = project();
+                await build(root, mode, !!values.force);
+                if (mode === "dev") {
+                    const settings = stateFile(root, "settings.json");
+                    writeJson(settings, { ...(existsSync(settings) ? readJson(settings) : {}), target: "dev" });
+                }
+                break;
+            }
+            case "analyze": {
+                const result = await analyze(project());
+                console.log(JSON.stringify({ included: result.included.map((p) => p.name), excluded: result.excluded.map((p) => p.name) }, null, 2));
+                break;
+            }
+            case "open": {
+                // No path opens the project's last standalone build. In-session `o` opens the development runtime.
+                const root = positionals[1] ? start : project();
+                const record = stateFile(root, "release-build.json");
+                if (!positionals[1] && !existsSync(record))
+                    throw new Error("No standalone app has been built. Run npm run build first.");
+                const product = positionals[1] ? path.resolve(positionals[1]) : readJson(record).app;
+                if (!existsSync(product))
+                    throw new Error("The app binary is missing. Rebuild it with npm run build.");
+                const app = await launch(root, product, port);
+                await app.exited;
+                break;
+            }
+            default: throw new Error(`Unknown command: ${command}. Run spark --help.`);
+        }
+}
+try {
+    await main();
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}

package/vendor/node_modules/@legendapp/spark-cli/dist/init-template.cjs

@@ -0,0 +1,25 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { prepareConfig, toExpo } = require('@legendapp/spark-desktop-config/config.cjs');
+
+// Expo Desktop assigns the application names and native IDs. Initialize only
+// spark-owned configuration, once, after its template dependencies are installed.
+function initializeTemplate(root) {
+  const file = path.join(root, 'desktop.config.json');
+  if (!fs.existsSync(file)) return;
+  const config = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (config.projectId) return;
+  const { expo } = JSON.parse(fs.readFileSync(path.join(root, 'app.json'), 'utf8'));
+  if (!expo?.windows?.projectGuid || !expo.name || !expo.macos?.bundleIdentifier) {
+    throw new Error('Create this template with expo-desktop create-app so its application identity is initialized.');
+  }
+  config.name = expo.name;
+  config.projectId = expo.windows.projectGuid;
+  config.expo = { ...expo, ...config.expo };
+  if (config.macos) config.macos = { ...expo.macos, ...config.macos, bundleIdentifier: expo.macos.bundleIdentifier };
+  toExpo(config);
+  fs.writeFileSync(file, JSON.stringify(config, null, 2) + '\n');
+  prepareConfig(root);
+}
+module.exports = { initializeTemplate };
+if (require.main === module) initializeTemplate(process.cwd());