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

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

@@ -1,22 +1,28 @@
-import { packageSources } from "./release.js";
+import { creationManifest } from "./local.js";
+import { installedRelease, materializeReleasePackages, packageSources, verifyMaterializedReleasePackages } from "./release.js";
 import { packageManager, managerCommand, applyOverrides, localArchive } from "./package-manager.js";
 import { packArchive } from "./pack-archive.js";
-import { spawnProcess } from "./process.js";
+import { nodeCommand, 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 { readJson, writeJson } from "./json.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 defaults = readJson(path.join(template, "package.json"));
+    const pins = { ...defaults.overrides, ...Object.fromEntries(Object.entries(defaults.dependencies)
+            .filter(([name]) => name.startsWith("expo-desktop"))) };
+    for (const [name, version] of Object.entries(pins)) {
+        if (pkg.dependencies?.[name])
+            pkg.dependencies[name] = version;
+    }
     const manager = packageManager(root, selectedManager);
     const overrides = { ...pins };
     for (const [name, file] of Object.entries(readJson(manifest))) {
@@ -31,6 +37,9 @@ export async function refreshLocalPackages(root, manifest, selectedManager) {
     upgradeManagedEntry(root);
 }
 export async function create(root, archiveManifest, platform = hostPlatform(), universal = false, example, selectedManager) {
+    if (!(universal || example) && !["macos", "windows"].includes(platform))
+        throw new Error("Use create --universal for mobile/web targets");
+    archiveManifest ??= creationManifest();
     const manager = packageManager(process.cwd(), selectedManager);
     await checkExpoDesktopNode(path.resolve(import.meta.dirname, ".."));
     const variant = universal || example ? "universal" : platform === "macos" ? "blank-typescript" : "windows";
@@ -42,9 +51,12 @@ export async function create(root, archiveManifest, platform = hostPlatform(), u
     try {
         cpSync(source, temporary, { recursive: true });
         const pkg = readJson(path.join(temporary, "package.json"));
-        const archives = packageSources(archiveManifest);
+        const release = archiveManifest ? undefined : installedRelease();
+        const archives = packageSources(archiveManifest, release);
         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.");
+        if (release)
+            await materializeReleasePackages(release, temporary);
         const overrides = {};
         for (const [name, file] of Object.entries(archives)) {
             overrides[name] = file;
@@ -58,10 +70,12 @@ export async function create(root, archiveManifest, platform = hostPlatform(), u
         if (manager === "pnpm")
             writeFileSync(path.join(temporary, ".npmrc"), "node-linker=hoisted\n");
         await packArchive(temporary, templateFile);
+        if (release)
+            verifyMaterializedReleasePackages(release, temporary);
         // 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.
+        // Expo Desktop 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.
@@ -75,11 +89,26 @@ export async function create(root, archiveManifest, platform = hostPlatform(), u
     finally {
         rmSync(temporary, { recursive: true, force: true });
     }
+    if (!archiveManifest) {
+        const release = installedRelease();
+        if (release)
+            verifyMaterializedReleasePackages(release, root);
+        const ignoreFile = path.join(root, ".gitignore");
+        const ignore = existsSync(ignoreFile) ? readFileSync(ignoreFile, "utf8") : "";
+        if (!ignore.includes("!/spark-packages/**"))
+            writeFileSync(ignoreFile, `${ignore}${ignore.endsWith("\n") || !ignore ? "" : "\n"}\n# Spark verified release package inputs\n!/spark-packages/\n!/spark-packages/**\n`);
+    }
     // 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)
+    if (example) {
+        if (!archiveManifest) {
+            const release = installedRelease();
+            if (release)
+                verifyMaterializedReleasePackages(release, root);
+        }
         await configureExample(root, example);
+    }
     console.log(`Created ${root}.\n\n  cd ${JSON.stringify(root)}\n  ${manager} run ${platform}`);
 }
 export function upgradeManagedEntry(root) {

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

@@ -1,10 +1,11 @@
 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";
+import { isNetworkError } from "./errors.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] }));
@@ -27,43 +28,103 @@ async function ask(question) {
         input.close();
     }
 }
+async function choose(question, defaultChoice, count) {
+    let choice;
+    while (choice === undefined) {
+        const answer = Number(await ask(`${question} [${defaultChoice}]: `) || String(defaultChoice));
+        if (Number.isInteger(answer) && answer >= 1 && answer <= count)
+            choice = answer;
+        else
+            console.error(`Choose a number from 1 to ${count}.`);
+    }
+    return choice;
+}
 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 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: "));
-        if (!Number.isInteger(choice) || choice < 1 || choice > matches.length)
-            throw new Error("Invalid signing identity selection.");
+        const choice = await choose("Signing certificate", defaultChoice, matches.length);
         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 = await choose("Notarization profile", defaultProfileChoice, createChoice);
+            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)
+                    console.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.");
+            }
+            needsSelection = !keychainProfile;
+        }
+        if (keychainProfile) {
+            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 if (process.stdin.isTTY && isNetworkError(error)) {
+                    console.error("Could not reach Apple’s notarization service. Check your internet connection or VPN.");
+                    const retry = await ask("Retry validation with the same profile? [Y/n]: ");
+                    if (retry && !/^y(?:es)?$/i.test(retry))
+                        throw error;
+                }
+                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/dependency-pins.js

@@ -0,0 +1,132 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import { supportedPlatforms } from "@legendapp/spark-desktop-config/config.cjs";
+const packages = ["react", "react-native", "react-native-macos", "expo"];
+// create/refreshLocalPackages use this starter's tested compatibility matrix too.
+const defaults = JSON.parse(readFileSync(new URL("../templates/blank-typescript/package.json", import.meta.url), "utf8"));
+export const expectedDependencyPins = Object.fromEntries(packages.map(name => [name, defaults.dependencies[name]]));
+export function dependencyPinIssues(pkg, platforms) {
+    const required = packages.filter(name => name !== "react-native-macos" || platforms.includes("macos"));
+    const issues = [];
+    function check(name, value, where) {
+        // npm and pnpm permit an override to reference a direct dependency's spec.
+        const resolved = ["overrides", "pnpm"].includes(where[0]) && typeof value === "string" && value.startsWith("$")
+            ? pkg.dependencies?.[value.slice(1)] ?? pkg.devDependencies?.[value.slice(1)] : value;
+        if (typeof resolved === "string" && /^(catalog|workspace):/.test(resolved)) {
+            console.log(`Skipping dependency pin check for ${where.join(" → ")}: ${resolved} is managed by the catalog or workspace.`);
+            return;
+        }
+        if (resolved !== expectedDependencyPins[name])
+            issues.push({ package: name, found: typeof value === "string" ? value : JSON.stringify(value), expected: expectedDependencyPins[name], where });
+    }
+    for (const name of required) {
+        let present = false;
+        for (const section of ["dependencies", "devDependencies"]) {
+            if (Object.hasOwn(pkg[section] ?? {}, name)) {
+                present = true;
+                check(name, pkg[section][name], [section, name]);
+            }
+        }
+        if (!present)
+            issues.push({ package: name, found: "(missing)", expected: expectedDependencyPins[name], where: ["dependencies", name], missing: true });
+    }
+    function overrides(entries, where, parent) {
+        for (const [selector, value] of Object.entries(entries ?? {})) {
+            // Yarn paths/globs, version-qualified npm selectors and pnpm parent>child selectors.
+            // Comparators after @, whitespace or || belong to the version range.
+            const child = selector.split(/(?<![@\s|])>(?=[@a-zA-Z])/).at(-1);
+            const segments = child.split("/");
+            const name = selector === "." ? parent : segments.at(-2)?.startsWith("@") ? undefined : required.find(name => new RegExp(`^${name}(?:@[^/]*)?$`).test(segments.at(-1)));
+            const location = [...where, selector];
+            if (value && typeof value === "object" && !Array.isArray(value))
+                overrides(value, location, name);
+            else if (name)
+                check(name, value, location);
+        }
+    }
+    overrides(pkg.overrides, ["overrides"]);
+    overrides(pkg.resolutions, ["resolutions"]);
+    overrides(pkg.pnpm?.overrides, ["pnpm", "overrides"]);
+    return issues;
+}
+export function printDependencyPins(issues) {
+    if (!issues.length) {
+        console.log("Dependency pins match Spark's expected versions.");
+        return;
+    }
+    const rows = [["Package", "Found", "Expected", "Where"], ...issues.map(issue => [issue.package, issue.found, issue.expected, issue.where.join(" → ")])];
+    const widths = rows[0].map((_, column) => Math.max(...rows.map(row => row[column].length)));
+    for (const row of rows)
+        console.log(row.map((value, column) => value.padEnd(widths[column])).join("  ").trimEnd());
+}
+/** Edit only mismatched values and insert missing pins, preserving existing formatting. */
+export function upgradeDependencyPins(root, dryRun = false) {
+    const file = path.join(root, "package.json");
+    let source = readFileSync(file, "utf8");
+    const pkg = JSON.parse(source);
+    const parsed = ts.parseJsonText(file, source);
+    const object = parsed.statements[0].expression;
+    function property(object, key) {
+        return object.properties.find(p => ts.isPropertyAssignment(p) && ts.isStringLiteral(p.name) && p.name.text === key);
+    }
+    function rejectDuplicates(node, where, nested = true) {
+        if (!node || !ts.isObjectLiteralExpression(node))
+            return;
+        const keys = new Set();
+        for (const entry of node.properties) {
+            if (!ts.isPropertyAssignment(entry) || !ts.isStringLiteral(entry.name))
+                continue;
+            const key = entry.name.text;
+            if (keys.has(key))
+                throw new Error(`package.json has duplicate key ${JSON.stringify(key)} in ${where.join(" → ") || "root"}. No files were changed.`);
+            keys.add(key);
+            if (nested)
+                rejectDuplicates(entry.initializer, [...where, key]);
+        }
+    }
+    rejectDuplicates(object, [], false);
+    for (const section of ["dependencies", "devDependencies", "overrides", "resolutions"])
+        rejectDuplicates(property(object, section)?.initializer, [section]);
+    const pnpm = property(object, "pnpm")?.initializer;
+    rejectDuplicates(pnpm, ["pnpm"], false);
+    if (pnpm && ts.isObjectLiteralExpression(pnpm))
+        rejectDuplicates(property(pnpm, "overrides")?.initializer, ["pnpm", "overrides"]);
+    const issues = dependencyPinIssues(pkg, supportedPlatforms(root));
+    if (!issues.length || dryRun)
+        return issues;
+    const edits = [];
+    const missing = issues.filter(issue => issue.missing);
+    if (missing.length) {
+        if ("dependencies" in pkg && (!pkg.dependencies || typeof pkg.dependencies !== "object" || Array.isArray(pkg.dependencies)))
+            throw new Error("package.json dependencies must be an object. No files were changed.");
+        const indent = source.match(/^[\t ]+(?=")/m)?.[0] ?? "  ";
+        const newline = source.includes("\r\n") ? "\r\n" : "\n";
+        const dependencies = property(object, "dependencies")?.initializer;
+        const target = dependencies ?? object;
+        const entries = dependencies ? missing.map(issue => `${JSON.stringify(issue.package)}: ${JSON.stringify(issue.expected)}`)
+            : [`"dependencies": ${JSON.stringify(Object.fromEntries(missing.map(issue => [issue.package, issue.expected])), null, indent)}`];
+        const last = target.properties.at(-1);
+        const baseIndent = source.slice(0, target.getStart(parsed)).match(/(?:^|\n)([\t ]*)[^\n]*$/)[1];
+        const multiline = !last || source.slice(target.getStart(parsed), target.end).includes("\n");
+        const separator = multiline ? newline + baseIndent + indent : " ";
+        const text = entries.map(entry => entry.replaceAll("\n", newline + baseIndent + indent)).join("," + separator);
+        edits.push(last ? { start: last.end, end: last.end, text: "," + separator + text }
+            : { start: target.getStart(parsed) + 1, end: target.end - 1, text: separator + text + newline + baseIndent });
+    }
+    for (const issue of issues) {
+        if (issue.missing)
+            continue;
+        // Fixing the referenced direct dependency also fixes npm/pnpm's $ref override.
+        if (["overrides", "pnpm"].includes(issue.where[0]) && issue.found.startsWith("$") && issues.some(direct => ["dependencies", "devDependencies"].includes(direct.where[0]) && direct.package === issue.found.slice(1) && direct.expected === issue.expected))
+            continue;
+        let node = object;
+        for (const key of issue.where)
+            node = property(node, key).initializer;
+        edits.push({ start: node.getStart(parsed), end: node.end, text: JSON.stringify(issue.expected) });
+    }
+    for (const edit of edits.sort((a, b) => b.start - a.start))
+        source = source.slice(0, edit.start) + edit.text + source.slice(edit.end);
+    writeFileSync(file, source);
+    return issues;
+}

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

@@ -4,7 +4,7 @@ import { prepareConfig, selectTarget, supportedPlatforms } from "@legendapp/spar
 import { dev } from "./dev.js";
 import { findProject } from "./local.js";
 import { hostPlatform } from "./platform.js";
-import { nodeCommand } from "./windows.js";
+import { nodeCommand } from "./process.js";
 // Consume only spark options. Expo validates its flags, aliases and values.
 export function devArguments(args) {
     const spark = {};
@@ -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,8 +2,8 @@ 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 { architecture, projectPlatform } from "./platform.js";
+import { nodeCommand } from "./process.js";
 import { readAppConfig } from "./project.js";
 import { existsSync, rmSync, watch } from "node:fs";
 import path from "node:path";
@@ -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/errors.js

@@ -0,0 +1,100 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+// Command failures retain diagnostics without making callers parse their message.
+export class CommandError extends Error {
+    argv;
+    code;
+    output;
+    log;
+    constructor(argv, code, output, log) {
+        super(`${argv.join(" ")} exited ${code}${log ? `. See ${log}` : ""}${output ? `\n${output.slice(-1800)}` : ""}`);
+        this.argv = argv;
+        this.code = code;
+        this.output = output;
+        this.log = log;
+        this.name = "CommandError";
+    }
+}
+export function isNetworkError(error) {
+    const message = error instanceof CommandError ? error.output : error instanceof Error ? error.message : String(error);
+    return /NSURLErrorDomain Code=-(?:1001|1005|1009)|internet connection appears to be offline|\b(?:ENOTFOUND|EAI_AGAIN|ETIMEDOUT|ECONNRESET|ENETUNREACH)\b|could not resolve host|failed to connect|network is unreachable/i.test(message);
+}
+export function errorPresentation(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const command = error instanceof CommandError ? error.argv.join(" ") : "";
+    const details = error instanceof CommandError ? error.output : message;
+    let summary = message.split("\n")[0] || "An unexpected error occurred.";
+    let next;
+    if (isNetworkError(error)) {
+        summary = command.includes("notarytool") ? "Could not reach Apple’s notarization service." : "Could not reach the remote service.";
+        next = "Check your internet connection or VPN, then retry the same command.";
+    }
+    else if ((/\b(?:E401|ENEEDAUTH)\b|401 Unauthorized/i.test(details) && /npm/.test(command || message)) || command === "npm whoami") {
+        summary = "npm authentication failed.";
+        next = "Run npm login, then retry the same release command.";
+    }
+    else if (command === "gh auth status" || /gh auth login/.test(details)) {
+        summary = "GitHub authentication failed.";
+        next = "Run gh auth login, then retry the same command.";
+    }
+    else if (/No Keychain password item found for profile:/.test(details)) {
+        summary = "The selected notarization Keychain profile was not found.";
+        next = "Run spark credentials to select an existing profile or explicitly create one.";
+    }
+    else if (/notarytool/.test(command) && /\b401\b|invalid credentials|authentication/i.test(details)) {
+        summary = "Apple rejected the notarization credentials.";
+        next = "Run spark credentials to select or explicitly create a valid Keychain profile.";
+    }
+    else if (error instanceof CommandError) {
+        const checks = { "bun run test": "Tests failed.", "bun run typecheck": "Type checking failed.", "bun install --frozen-lockfile": "Dependency installation failed." };
+        summary = checks[command] ?? `${command} failed (exit ${error.code}).`;
+        next = "Review the diagnostic log or output above, fix the problem, then retry the same command.";
+    }
+    return { summary, next };
+}
+function diagnostics(error, seen = new Set()) {
+    let result = String(error);
+    if (error instanceof Error && !seen.has(error)) {
+        seen.add(error);
+        result = error.stack ?? error.message;
+        if (error instanceof CommandError && error.output)
+            result += `\n\nCommand output:\n${error.output}`;
+        if (error.cause)
+            result += `\n\nCaused by:\n${diagnostics(error.cause, seen)}`;
+    }
+    return result;
+}
+export function reportError(root, error, label = "Release") {
+    const { summary, next } = errorPresentation(error);
+    console.error(`\n${label} stopped: ${summary}`);
+    if (next)
+        console.error(`Next: ${next}`);
+    let log;
+    try {
+        const folder = path.join(root, ".spark/logs");
+        mkdirSync(folder, { recursive: true });
+        const destination = path.join(folder, `${Date.now()}-${crypto.randomUUID()}-error.log`);
+        writeFileSync(destination, diagnostics(error));
+        log = destination;
+    }
+    catch {
+        // Reporting must still work when the original failure was a full disk.
+        if (error instanceof CommandError)
+            log = error.log;
+    }
+    if (log)
+        console.error(`Details: ${log}`);
+    else
+        console.error("Could not save diagnostics. Set SPARK_DEBUG=1 to print them.");
+    if (process.env.SPARK_DEBUG === "1")
+        console.error(diagnostics(error));
+}
+export async function releaseCommand(root, action) {
+    try {
+        await action();
+    }
+    catch (error) {
+        reportError(root, error);
+        process.exitCode = 1;
+    }
+}

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

@@ -1,7 +1,7 @@
 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 { readJson, writeJson } from "./json.js";
 import { run } from "./commands.js";
 export const examples = ["document-editor", "notes-lite", "music-lite", "diff-lite"];
 export async function configureExample(root, example) {
@@ -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);