@legendapp/spark 0.0.1-next.2 → 0.0.1-next.3

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

@@ -1,10 +1,10 @@
 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";
+import { listNotaryProfiles } from "./notary-profiles.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] }));
@@ -32,38 +32,84 @@ export async function credentials(root, reset = false, execute = run) {
     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 identity = process.env.SPARK_DEVELOPER_ID_APPLICATION ?? config.identity ?? (process.stdin.isTTY ? undefined : saved.hash);
+    const teamId = process.env.SPARK_TEAM_ID ?? config.teamId ?? (process.stdin.isTTY ? undefined : 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.");
+    const defaultChoice = Math.max(0, matches.findIndex(item => item.hash === saved.hash)) + 1;
+    let selected = matches[defaultChoice - 1];
+    if (process.stdin.isTTY) {
+        console.log("Available Developer ID signing certificates:");
         console.log(matches.map((item, index) => `${index + 1}. ${item.name} [${item.hash}]`).join("\n"));
-        const choice = Number(await ask("Signing identity: "));
+        const choice = Number(await ask(`Signing certificate [${defaultChoice}]: `) || String(defaultChoice));
         if (!Number.isInteger(choice) || choice < 1 || choice > matches.length)
             throw new Error("Invalid signing identity selection.");
         selected = matches[choice - 1];
     }
+    else if (matches.length > 1) {
+        throw new Error("Multiple signing identities are available. Set SPARK_DEVELOPER_ID_APPLICATION or run spark credentials interactively.");
+    }
     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.");
+    let suggestedProfile = keychainProfile || `spark-${selected.teamId}`;
+    let result;
+    let validated = false;
+    let needsSelection = Boolean(process.stdin.isTTY);
+    while (!validated) {
+        if (needsSelection || !keychainProfile) {
+            if (!process.stdin.isTTY)
+                throw new Error("Notarization is not configured. Set SPARK_NOTARY_KEYCHAIN_PROFILE or run spark credentials interactively.");
+            const profiles = await listNotaryProfiles(root, keychain, execute);
+            const manualChoice = profiles.length + 1;
+            const createChoice = profiles.length + 2;
+            const rememberedChoice = profiles.indexOf(keychainProfile);
+            const defaultProfileChoice = rememberedChoice >= 0 ? rememberedChoice + 1 : profiles.length ? 1 : manualChoice;
+            console.log(`Available saved notarization Keychain profiles${keychain ? ` in ${keychain}` : ""}:`);
+            console.log(profiles.length ? profiles.map((profile, index) => `${index + 1}. ${profile}`).join("\n") : "No saved notarization profiles found.");
+            console.log(`${manualChoice}. Enter an existing profile name\n${createChoice}. Create a notarization Keychain profile`);
+            const choice = Number(await ask(`Notarization profile [${defaultProfileChoice}]: `) || String(defaultProfileChoice));
+            if (Number.isInteger(choice) && choice >= 1 && choice <= profiles.length) {
+                keychainProfile = profiles[choice - 1];
+            }
+            else if (choice === manualChoice) {
+                keychainProfile = await ask("Existing notarization Keychain profile: ");
+                if (!keychainProfile)
+                    throw new Error("Enter an existing profile name or select the create option.");
+            }
+            else if (choice === createChoice) {
+                keychainProfile = await ask(`New notarization Keychain profile [${suggestedProfile}]: `) || suggestedProfile;
+                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.");
+            }
+            else {
+                throw new Error("Invalid notarization setup selection.");
+            }
+            needsSelection = false;
+        }
+        result = { ...selected, keychainProfile, ...(keychain ? { keychain } : {}) };
+        // Validate the Keychain profile before native compilation or signing.
+        try {
+            await execute(root, ["xcrun", "notarytool", "history", ...notaryAuth(result), "--output-format", "json"], { capture: true });
+            validated = true;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("No Keychain password item found for profile:")) {
+                const message = `Notarization Keychain profile ${JSON.stringify(keychainProfile)} was not found${keychain ? ` in ${JSON.stringify(keychain)}` : ""}. A signing certificate name does not create a notarization profile.`;
+                if (!process.stdin.isTTY)
+                    throw new Error(`${message} Run spark credentials interactively to select an existing profile or explicitly create one.`, { cause: error });
+                console.error(message);
+                suggestedProfile = keychainProfile;
+                keychainProfile = undefined;
+                needsSelection = true;
+            }
+            else {
+                throw error;
+            }
         }
     }
-    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

@@ -17,7 +17,16 @@ export function devArguments(args) {
                 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)) {
+        else if (key === "--app-arg") {
+            const value = inline.length ? inline.join("=") : args[++i];
+            if (value === undefined)
+                throw new Error("--app-arg needs a value");
+            (spark.appArgs ??= []).push(value);
+        }
+        else if (["--prebuilt-binary", "--go-binary"].includes(key)) {
+            throw new Error(`Unknown Spark option: ${key}; use --runner-binary`);
+        }
+        else if (["--project", "--platform", "--runner-binary"].includes(key)) {
             const value = inline.length ? inline.join("=") : args[++i];
             if (!value || value.startsWith("-"))
                 throw new Error(`${key} needs a value`);
@@ -44,7 +53,7 @@ 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");
+        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  --app-arg <value>        Pass a desktop launch argument (repeatable)\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;
@@ -58,7 +67,7 @@ export async function devCommand(args) {
     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"));
+        await dev(root, options.prebuiltBinary, expo, !!options.noOpen || initial !== desktop || (desktop === "windows" ? process.platform !== "win32" : process.platform !== "darwin"), options.appArgs);
     }
     else {
         if (options.prebuiltBinary)

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

@@ -2,7 +2,7 @@ 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 { architecture, projectPlatform } from "./platform.js";
 import { nodeCommand } from "./windows.js";
 import { readAppConfig } from "./project.js";
 import { existsSync, rmSync, watch } from "node:fs";
@@ -13,14 +13,16 @@ 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 { assertNativePatchPreflight } from "./native-patch-preflight.js";
 import { prepareConfig, dependencyStamp, goConfigurationIssues, incompatible, nativePackages, readJson, projectEnvironment, runtimeFor, stateFile, writeJson, } from "./project.js";
 export async function launch(root, app, port, options = {}) {
+    assertNativePatchPreflight(root);
     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" });
+        return spawnProcess([path.join(app, "MyApp.exe"), ...(options.args ?? [])], { 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",
@@ -34,7 +36,7 @@ export async function launch(root, app, port, options = {}) {
     // 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}`] : [])], {
+    return spawnProcess([executable, ...(port ? ["-RCT_jsLocation", `127.0.0.1:${port}`] : []), ...(options.args ?? [])], {
         cwd: root,
         env: {
             ...process.env,
@@ -49,7 +51,8 @@ export async function launch(root, app, port, options = {}) {
         stderr: "inherit",
     });
 }
-export async function dev(root, goApp, expoArgs = [], noOpen = false) {
+export async function dev(root, goApp, expoArgs = [], noOpen = false, appArgs = []) {
+    assertNativePatchPreflight(root);
     const platform = projectPlatform(root);
     preparePatch(root);
     let port;
@@ -201,7 +204,7 @@ export async function dev(root, goApp, expoArgs = [], noOpen = false) {
             }
             issues.push(...goConfigurationIssues(readAppConfig(root)));
         }
-        const view = sessionStatus(target, !!current, issues, appProcess?.exitCode === null, !!installedRelease()?.runners[`${platform}-${platform === "macos" ? "arm64" : process.arch}`]);
+        const view = sessionStatus(target, !!current, issues, appProcess?.exitCode === null, !!installedRelease()?.runners[`${platform}-${architecture(platform)}`]);
         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.
@@ -256,7 +259,7 @@ export async function dev(root, goApp, expoArgs = [], noOpen = false) {
                 appProcess.kill();
                 await appProcess.exited;
             }
-            appProcess = await launch(root, current.app, port, bundleOptions);
+            appProcess = await launch(root, current.app, port, { ...bundleOptions, args: appArgs });
             if (closing) {
                 appProcess.kill();
                 return;
@@ -278,7 +281,7 @@ export async function dev(root, goApp, expoArgs = [], noOpen = false) {
                     await appProcess.exited;
                 }
                 await open();
-                writeJson(settingsFile, { target, goApp });
+                writeJson(settingsFile, { ...(existsSync(settingsFile) ? readJson(settingsFile) : {}), target, goApp });
             }
             else if (name === "build") {
                 if ((await check()) || !canBuild)
@@ -294,7 +297,7 @@ export async function dev(root, goApp, expoArgs = [], noOpen = false) {
                 target = "dev";
                 restartPending = true;
                 await open();
-                writeJson(settingsFile, { target, goApp });
+                writeJson(settingsFile, { ...(existsSync(settingsFile) ? readJson(settingsFile) : {}), target, goApp });
             }
             else if (name === "open")
                 await open();
@@ -401,7 +404,7 @@ export async function dev(root, goApp, expoArgs = [], noOpen = false) {
     finally {
         busy = false;
     }
-    writeJson(settingsFile, { target, goApp });
+    writeJson(settingsFile, { ...(existsSync(settingsFile) ? readJson(settingsFile) : {}), target, goApp });
     await finished;
     process.off("SIGINT", close);
     process.off("SIGTERM", close);

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

@@ -18,7 +18,7 @@ export async function configureExample(root, example) {
     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";
+        pkg.dependencies["expo-audio"] = pkg.dependencies["expo-audio"] ?? pkg.overrides?.["expo-audio"] ?? pkg.resolutions?.["expo-audio"] ?? pkg.pnpm?.overrides?.["expo-audio"] ?? "1.1.1";
     if (example === "diff-lite")
         pkg.dependencies["diff"] = "8.0.2";
     writeJson(path.join(root, "package.json"), pkg);

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

@@ -15,8 +15,10 @@ const patches = [
     '    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 });`],
+    '    await (0, _profile.profile)(devServerManager.startAsync.bind(devServerManager))(startOptions);',
+    // Dependency validation can wait on the network after Metro is listening.
+    // Report actual server readiness before those optional startup checks.
+    `    await (0, _profile.profile)(devServerManager.startAsync.bind(devServerManager))(startOptions);\n    require(${extension}).ready(devServerManager.getNativeDevServerPort(), { dev: options.dev, minify: options.minify, https: options.https });`],
 ];
 
 function preparePatch(root) {

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

@@ -19,7 +19,7 @@ exports.withSparkMetro = 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');
+  if (!upstream) throw new Error('Compose Metro with getDefaultConfig from @legendapp/spark/metro');
   const customResolve = config.resolver?.resolveRequest;
   if (customResolve && customResolve !== upstream.resolveRequest) {
     const desktopResolve = upstream.resolveRequest;

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

@@ -2,7 +2,7 @@ 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. */
+/** Check the actual Node/Expo pair before handing work to Expo Desktop. */
 export async function checkExpoDesktopNode(root) {
     const requireApp = createRequire(path.join(root, "package.json"));
     const requireDesktop = createRequire(requireApp.resolve("expo-desktop/package.json"));
@@ -10,12 +10,12 @@ export async function checkExpoDesktopNode(root) {
     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
+    // Use the static named imports used by Expo Desktop. 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()}`);
+        throw new Error(`Expo Desktop 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/index.js

@@ -4,7 +4,7 @@ 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 { cliArguments } from "./cli-arguments.js";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { prepareConfig, readConfig, isExpoProject } from "@legendapp/spark-desktop-config/config.cjs";
 import { nodeCommand, prepareWindows } from "./windows.js";
@@ -24,33 +24,7 @@ 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.");
+    const { positionals, values } = cliArguments(argv);
     if (values.platform)
         process.env.SPARK_PLATFORM = values.platform;
     const platform = (values.platform ?? hostPlatform());
@@ -58,25 +32,25 @@ async function main() {
     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) && (values.device || values.port))
+            throw new Error("--device and --port are mobile build options; use spark dev for desktop launch options.");
         if (["ios", "android", "web"].includes(selected)) {
+            if (values.force)
+                throw new Error("--force is a desktop build option.");
             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))
+            if (values.runner || 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)] : [])];
@@ -125,7 +99,7 @@ Overrides: --project <directory>, --port <number>, dev --runner-binary <runtime
             case "create": {
                 if (!positionals[1])
                     throw new Error("Usage: spark create MyApp");
-                if (!values.universal && !["macos", "windows"].includes(platform))
+                if (!(values.universal || values.example) && !["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;
@@ -169,8 +143,6 @@ Overrides: --project <directory>, --port <number>, dev --runner-binary <runtime
                             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)
@@ -216,8 +188,8 @@ Overrides: --project <directory>, --port <number>, dev --runner-binary <runtime
                 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.");
+                if (process.platform !== "darwin")
+                    throw new Error("macOS packaging requires macOS.");
                 const result = await packageApp(project(), { force: !!values.force, submissionId: values["submission-id"] });
                 if (result.pending)
                     process.exitCode = 2;

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

@@ -35,7 +35,7 @@ export function readRuntime(app) {
     try {
         const windows = existsSync(path.join(app, "spark-runtime.json"));
         const runtime = readJson(path.join(app, windows ? "spark-runtime.json" : "Contents/Resources/spark-runtime.json"));
-        if (runtime.schema !== 1 || runtime.framework !== VERSION || !["macos", "windows"].includes(runtime.platform) || !(runtime.platform === "windows" ? ["arm64", "x64"] : ["arm64"]).includes(runtime.arch) || !runtime.modules || typeof runtime.modules !== "object" || typeof runtime.fingerprint !== "string")
+        if (runtime.schema !== 1 || runtime.framework !== VERSION || !["macos", "windows"].includes(runtime.platform) || !["arm64", "x64"].includes(runtime.arch) || !runtime.modules || typeof runtime.modules !== "object" || typeof runtime.fingerprint !== "string")
             return undefined;
         if (!existsSync(path.join(app, windows ? "MyApp.exe" : "Contents/MacOS")) || windows !== (runtime.platform === "windows"))
             return undefined;

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

@@ -16,6 +16,11 @@ function runtimePlan(root, env = process.env) {
     .map(e => e.name).concat(["src"]) };
 }
 function withDesktop(config, options = {}) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new Error("Expected desktop Metro options");
+  for (const [key, value] of Object.entries(options)) {
+    if (!["runtimes", "watch"].includes(key)) throw new Error(`Unknown desktop Metro option: ${key}`);
+    if (value !== undefined && typeof value !== "boolean") throw new Error(`${key} must be boolean`);
+  }
   // Expo 54 sets the react-native export condition only for iOS/Android.
   // Desktop must also select native package exports (e.g. Uniwind's runtime).
   const conditions = { ...config.resolver?.unstable_conditionsByPlatform };
@@ -24,10 +29,26 @@ function withDesktop(config, options = {}) {
   }
   config = { ...config, resolver: { ...config.resolver, unstable_conditionsByPlatform: conditions } };
   const root = path.resolve(config.projectRoot || process.cwd());
-  // Prebuilt hosts request /index.bundle and /.threaded-runtime/entry.bundle.
-  // Keep those URLs relative to the app inside a monorepo; Expo still discovers
-  // workspace watch folders and package dependencies.
-  config = { ...config, server: { ...config.server, unstable_serverRoot: root } };
+  // Keep the configured workspace root so lazy imports outside the app have
+  // valid URLs. Only the prebuilt host's fixed entry URLs are app-relative.
+  const serverRoot = path.resolve(config.server?.unstable_serverRoot || root);
+  const entryPrefix = path.relative(serverRoot, root).split(path.sep).map(encodeURIComponent).join("/");
+  if (entryPrefix && (entryPrefix === ".." || entryPrefix.startsWith("../"))) {
+    throw new Error("Metro's server root must contain the Spark project");
+  }
+  const rewrite = config.server?.rewriteRequestUrl;
+  config = { ...config, server: { ...config.server, unstable_serverRoot: serverRoot,
+    rewriteRequestUrl(value) {
+      const url = new URL(value, "http://localhost");
+      const platform = url.searchParams.get("platform");
+      if (entryPrefix && (!platform || ["macos", "windows"].includes(platform)) &&
+          /^\/(index|\.threaded-runtime\/entry)\.(bundle|map|delta)$/.test(url.pathname)) {
+        url.pathname = `/${entryPrefix}${url.pathname}`;
+        value = value.startsWith("/") ? `${url.pathname}${url.search}${url.hash}` : url.href;
+      }
+      return rewrite ? rewrite(value) : value;
+    },
+  } };
   let core;
   try { core = require.resolve("@react-native-runtimes/core/metro", { paths: [root] }); } catch {}
   if (!core || options.runtimes === false) {
@@ -40,7 +61,7 @@ function withDesktop(config, options = {}) {
   const plan = runtimePlan(root);
   const generatedEntry = path.join(root, ".threaded-runtime/entry.js");
   if (plan.enabled) {
-    config = withThreadedRuntime(config, { ...options, roots: plan.roots, watch: plan.production ? false : options.watch });
+    config = withThreadedRuntime(config, { roots: plan.roots, watch: plan.production ? false : options.watch });
     // Production roots come from Metro's resolved graph, including worker files
     // shipped by dependencies. Do not register unrelated index.<name>.ts files.
     if (plan.production) generateThreadedRuntimeEntry({ projectRoot: root, generatedEntry, roots: plan.roots, runtimeEntries: [] });

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

@@ -0,0 +1,26 @@
+import { existsSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { run } from "./commands.js";
+import { createRequire } from "node:module";
+const { identity } = createRequire(import.meta.url)("@legendapp/spark-desktop-config/identity.cjs");
+/** Restore app-owned values after Expo Desktop's template string replacement. */
+export async function restoreNativeMetadata(root, config, execute = run) {
+    const overrides = { ...config.macos?.infoPlist, ...identity(config) };
+    const nativeRoot = path.join(root, "macos");
+    const matches = [];
+    for (const entry of readdirSync(nativeRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const file = path.join(nativeRoot, entry.name, "Info.plist");
+        if (!existsSync(file))
+            continue;
+        const info = JSON.parse(await execute(root, ["plutil", "-convert", "json", "-o", "-", file], { capture: true }));
+        if ("SparkProjectIdentifier" in info)
+            matches.push({ file, info });
+    }
+    if (matches.length !== 1)
+        throw new Error(`Expected one generated Spark Info.plist, found ${matches.length}`);
+    const { file, info } = matches[0];
+    writeFileSync(file, JSON.stringify({ ...info, ...overrides }));
+    await execute(root, ["plutil", "-convert", "xml1", file], { capture: true });
+}

package/vendor/node_modules/@legendapp/spark-cli/dist/native-patch-preflight.js

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { findFramework } from "./local.js";
+import { installedPackages, readJson, VERSION } from "./project.js";
+const required = ["@react-native-runtimes/core", "react-native-nitro-modules", "@op-engineering/op-sqlite", "react-native-webview"];
+const optional = ["expo-audio"];
+export function validatePackedNativePatches(packages, requirements, frameworkVersion = VERSION) {
+    if (!requirements || requirements.schema !== 1 || requirements.frameworkVersion !== frameworkVersion || !requirements.packages || typeof requirements.packages !== "object")
+        return [`The installed @legendapp/spark SDK does not include native patch provenance for ${frameworkVersion}. Run spark add desktop to install the matching SDK packages, then retry.`];
+    const installed = new Map(packages.map(pkg => [pkg.name, pkg.json]));
+    const errors = [];
+    for (const name of required)
+        if (!installed.has(name))
+            errors.push(`${name} is missing; reinstall the dependencies from this Spark SDK.`);
+    for (const name of [...required, ...optional]) {
+        const actual = installed.get(name);
+        if (!actual)
+            continue;
+        const expected = requirements.packages[name];
+        const spark = actual.spark;
+        if (!expected || typeof expected.version !== "string" || !/^[a-f0-9]{64}$/.test(expected.patchHash) ||
+            (!expected.upstreamIntegrity && !expected.upstreamRevision) || actual.version !== expected.version || spark?.sdk !== true || spark.patchHash !== expected.patchHash ||
+            spark.upstreamIntegrity !== expected.upstreamIntegrity || spark.upstreamRevision !== expected.upstreamRevision) {
+            errors.push(`${name}@${actual.version} is not the matching patched Spark SDK package.`);
+        }
+    }
+    return errors;
+}
+export function validateWorkspaceNativePatches(root, packages) {
+    const framework = findFramework(root);
+    if (!framework)
+        return ["The Spark SDK is missing native patch provenance. Run spark add desktop to install matching SDK packages, then retry."];
+    const frameworkPackage = readJson(path.join(framework, "package.json"));
+    const map = frameworkPackage.sparkWorkspacePatches;
+    if (!map)
+        return ["The Spark workspace has no install-time patch inventory. Run npm run postinstall in the framework checkout, then retry."];
+    const pins = readJson(path.join(framework, "patches/workspace/upstream.json"));
+    const installed = new Map(packages.map(pkg => [pkg.name, pkg]));
+    const errors = [];
+    for (const name of [...required, ...optional]) {
+        const pkg = installed.get(name);
+        if (!pkg) {
+            if (required.includes(name))
+                errors.push(`${name} is missing; reinstall the dependencies from this Spark workspace.`);
+            continue;
+        }
+        const entry = Object.entries(map).find(([key]) => key.slice(0, key.lastIndexOf("@")) === name);
+        const pin = pins[name];
+        if (!entry || !pin || !entry[0].endsWith(`@${pin.version}`) || pkg.json.version !== pin.version) {
+            errors.push(`${name}@${pkg.json.version} does not match the Spark workspace patch inventory.`);
+            continue;
+        }
+        const patchFile = path.resolve(framework, entry[1]);
+        if (!patchFile.startsWith(framework + path.sep) || !existsSync(patchFile)) {
+            errors.push(`${name} has no readable Spark workspace patch. Run npm run postinstall in the framework checkout.`);
+            continue;
+        }
+        const patchHash = createHash("sha256").update(readFileSync(patchFile)).digest("hex");
+        const receipt = pkg.json.spark?.workspacePatch;
+        const expectedRevision = pin.revision;
+        if (!receipt || receipt.schema !== 1 || receipt.version !== pin.version || receipt.patchHash !== patchHash ||
+            receipt.upstreamIntegrity !== pin.integrity || (expectedRevision && receipt.upstreamRevision !== expectedRevision)) {
+            errors.push(`${name}@${pkg.json.version} has no matching applied workspace patch stamp. Run npm run postinstall in the framework checkout, then retry.`);
+        }
+    }
+    return errors;
+}
+export function assertNativePatchPreflight(root) {
+    const packages = installedPackages(root);
+    const framework = findFramework(root);
+    let errors;
+    const spark = packages.find(pkg => pkg.name === "@legendapp/spark");
+    const requirements = spark?.json.spark?.nativePatchRequirements;
+    if (requirements)
+        errors = validatePackedNativePatches(packages, requirements);
+    else if (framework)
+        errors = validateWorkspaceNativePatches(root, packages);
+    else {
+        errors = validatePackedNativePatches(packages, requirements);
+    }
+    if (errors.length)
+        throw new Error(`Native preparation stopped before changing project files:\n${errors.map(error => `- ${error}`).join("\n")}`);
+}