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

package/postinstall.cjs

@@ -0,0 +1 @@
+require("./vendor/node_modules/@legendapp/spark-desktop-config/native-patches.cjs").prepareNativePatches(__dirname);

package/ui-swipe.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-ui/src/swipe-actions/index.tsx";

package/vendor/node_modules/@legendapp/spark-ai/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@legendapp/spark-ai",
-  "version": "0.0.1-next.3",
+  "version": "0.0.1-next.4",
   "private": true,
   "main": "src/index.ts",
   "react-native": "src/index.ts",
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.3",
-    "@legendapp/spark-processes": "0.0.1-next.3"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4",
+    "@legendapp/spark-processes": "0.0.1-next.4"
   },
   "peerDependencies": {
     "react": "19.1.4",

package/vendor/node_modules/@legendapp/spark-audio/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-audio",
-  "version": "0.0.1-next.3",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index",
   "react-native": "src/index",
@@ -47,6 +47,6 @@
   },
   "private": true,
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.3"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4"
   }
 }

package/vendor/node_modules/@legendapp/spark-auth-session/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-auth-session",
-  "version": "0.0.1-next.3",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index",
   "react-native": "src/index",
@@ -8,9 +8,9 @@
     "src"
   ],
   "dependencies": {
-    "@legendapp/spark-desktop-links": "0.0.1-next.3",
+    "@legendapp/spark-desktop-links": "0.0.1-next.4",
     "base64-js": "1.5.1",
-    "@legendapp/spark-desktop-app": "0.0.1-next.3"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4"
   },
   "peerDependencies": {
     "react-native": "0.81.6",

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

@@ -12,10 +12,11 @@ import path from "node:path";
 import { registerRuntime } from "./local.js";
 import { binary, doctor, run } from "./commands.js";
 import { prepareConfig, entryFile, digest, hashFiles, nativePreparationInputs, nativeProjectFingerprint, localSigningIdentity, nativePackages, readJson, runtimeFor, selection, stateFile, writeJson, validateBuildModules, goConfigurationIssues, } from "./project.js";
-export async function analyze(root, packages = nativePackages(root)) {
+export async function analyze(root) {
     assertNativePatchPreflight(root);
     if (projectPlatform(root) === "windows")
         throw new Error("Windows production analysis is not implemented; use spark build --dev.");
+    const packages = nativePackages(root, { applyExcludes: false });
     prepareConfig(root);
     const dir = stateFile(root, "analysis");
     mkdirSync(dir, { recursive: true });
@@ -57,24 +58,70 @@ export async function analyze(root, packages = nativePackages(root)) {
             (!source.includes("/node_modules/") || /["']@react-native-runtimes\/core["']/.test(readFileSync(source, "utf8")))) });
     await exportBundle({ SPARK_RUNTIME_SOURCES: runtimeSources });
     const map = readJson(path.join(dir, "app.map"));
+    const sourceFile = (source) => source.includes("\0") ? undefined
+        : [path.resolve(root, source), path.resolve(root, source.replace(/^\//, ""))].find(file => existsSync(file));
     const used = new Set();
     for (const source of map.sources) {
+        const file = sourceFile(source);
+        const resolved = file ? realpathSync(file) : source;
         for (const pkg of packages) {
             // Metro's source map can contain absolute paths or project-relative node_modules paths.
             if (source.startsWith(pkg.root + "/") ||
+                resolved.startsWith(pkg.root + "/") ||
                 source.includes(`/node_modules/${pkg.name}/`) ||
                 source.startsWith(`node_modules/${pkg.name}/`))
                 used.add(pkg.name);
         }
     }
     const config = readAppConfig(root);
-    const result = selection(packages, used, config.expo?.extra?.spark?.include ?? []);
+    const explicitExcluded = config.expo?.autolinking?.exclude ?? [];
+    const include = config.expo?.extra?.spark?.include ?? [];
+    const result = selection(packages, used, include, explicitExcluded);
+    const violations = packages.filter(pkg => explicitExcluded.includes(pkg.name)).flatMap(pkg => {
+        const reasons = [];
+        if (used.has(pkg.name))
+            reasons.push("used by the production bundle");
+        if (include.includes(pkg.name))
+            reasons.push("explicit native include");
+        for (const included of result.included) {
+            if (included.requires.includes(pkg.name))
+                reasons.push(`required by included ${included.name} (spark.requires)`);
+            if (Object.hasOwn(included.json.dependencies ?? {}, pkg.name) && !Object.hasOwn(included.json.optionalDependencies ?? {}, pkg.name))
+                reasons.push(`required by included ${included.name} (dependencies)`);
+            if (Object.hasOwn(included.json.peerDependencies ?? {}, pkg.name) && !included.json.peerDependenciesMeta?.[pkg.name]?.optional)
+                reasons.push(`required by included ${included.name} (peerDependencies)`);
+        }
+        if (!reasons.length)
+            return [];
+        const names = [pkg.name];
+        if (pkg.name.startsWith("@legendapp/spark-"))
+            names.push(`@legendapp/spark/${pkg.name.slice("@legendapp/spark-".length).replace(/^desktop-/, "")}`);
+        const importedFrom = map.sources.find(source => {
+            if (source.includes("/node_modules/") || source.startsWith("node_modules/"))
+                return false;
+            const file = sourceFile(source);
+            return file !== undefined && names.some(name => readFileSync(file, "utf8").includes(name));
+        });
+        return [{ name: pkg.name, reasons, ...(importedFrom ? { importedFrom } : {}) }];
+    });
     writeJson(stateFile(root, "selection-report.json"), {
         included: result.included.map((p) => p.name),
         excluded: result.excluded.map((p) => p.name),
         reasons: result.reasons,
         sources: map.sources,
+        nativeCheck: { violations },
     });
+    if (violations.length)
+        throw new Error([
+            `Release native-module check failed: ${violations.length} excluded native package${violations.length === 1 ? " is" : "s are"} required.`,
+            ...violations.flatMap(violation => [
+                `  ${violation.name}`,
+                ...violation.reasons.map(reason => `    ${reason}${reason === "used by the production bundle" && violation.importedFrom ? ` (e.g. ${violation.importedFrom})` : ""}`),
+                "    excluded by desktop.config.json expo.autolinking.exclude",
+            ]),
+            "Fix: stop excluding it, or remove the import. In legend-apps, add the package (or its @legendapp/spark/<subpath>) to apps/<app>/app.manifest.ts nativeModules.macos.",
+            "Details: .spark/selection-report.json (nativeCheck)",
+        ].join("\n"));
     return result;
 }
 export async function build(root, mode, force = false) {
@@ -125,11 +172,10 @@ async function buildUnlocked(root, mode, force) {
             throw new Error(`Build the Spark Runner from a generic SDK starter: ${issues.join("; ")}`);
     }
     await doctor(root);
-    const all = nativePackages(root);
     const productionGraph = mode === "release" || mode === "preview";
     const chosen = productionGraph
-        ? await analyze(root, all)
-        : { included: all, excluded: [] };
+        ? await analyze(root)
+        : { included: nativePackages(root), excluded: [] };
     validateBuildModules(mode, chosen.included);
     const runtime = runtimeFor(root, chosen.included, mode);
     const productionHash = productionGraph
@@ -148,9 +194,9 @@ async function buildUnlocked(root, mode, force) {
     });
     const rnConfig = path.join(root, "react-native.config.js");
     const marker = "// Generated by spark; extend with configuration plugins.";
-    if (existsSync(rnConfig) &&
+    if (!isUniversal(root) && (existsSync(rnConfig) &&
         !readFileSync(rnConfig, "utf8").startsWith(marker) &&
-        !(isExpoProject(root) && readFileSync(rnConfig, "utf8").includes("// spark: existing Expo project")))
+        !(isExpoProject(root) && readFileSync(rnConfig, "utf8").includes("// spark: existing Expo project"))))
         throw new Error("Existing react-native.config.js is not spark-managed. Compose the native selection explicitly before building.");
     if (!isUniversal(root))
         writeFileSync(rnConfig, `${marker}\nconst selection = require('./.spark/native-selection.json');\nmodule.exports = { dependencies: Object.fromEntries([\n...selection.included.map(p => [p.name, { root: p.root }]),\n...selection.excluded.map(name => [name, { platforms: { ios: null, macos: null, android: null } }])\n]) };\n`);
@@ -175,6 +221,7 @@ async function buildUnlocked(root, mode, force) {
     if (!force && existing) {
         if (existing.runtime.fingerprint === runtime.fingerprint &&
             existing.preparation?.fingerprint === preparation.fingerprint &&
+            existing.product === path.basename(existing.app) &&
             existsSync(existing.app)) {
             console.log(`Reusing ${existing.app}`);
             return existing;
@@ -184,6 +231,7 @@ async function buildUnlocked(root, mode, force) {
         ...preparationChanges(existing.preparation, preparation),
         ...(existing.runtime.fingerprint !== runtime.fingerprint ? ["runtime inputs changed"] : []),
         ...(!existsSync(existing.app) ? ["cached app missing"] : []),
+        ...(existing.product !== path.basename(existing.app) ? ["cached app product is unverified"] : []),
     ];
     console.log(`Building ${mode} runtime: ${reasons.join("; ")}.`);
     const nativeConfig = readAppConfig(root).expo;
@@ -273,11 +321,12 @@ async function buildUnlocked(root, mode, force) {
         label: `Building ${mode === "go" ? "Spark Runner" : mode} runtime (${configuration}, ${runtime.arch})`,
     });
     const products = path.join(derived, "Build", "Products", configuration);
-    const product = readdirSync(products).find((name) => name.endsWith(".app"));
-    if (!product)
-        throw new Error("Build completed without an app product.");
+    // The scheme's product, not the first .app: a renamed app leaves its old bundle in DerivedData.
+    const product = `${name}.app`;
+    if (!existsSync(path.join(products, product)))
+        throw new Error(`Build completed without ${product}.`);
     const destination = stateFile(root, `products/macos-${runtime.arch}/${mode}/${product}`);
-    rmSync(destination, { recursive: true, force: true });
+    rmSync(path.dirname(destination), { recursive: true, force: true });
     mkdirSync(path.dirname(destination), { recursive: true });
     cpSync(path.join(products, product), destination, { recursive: true, verbatimSymlinks: true });
     if (mode === "release" &&
@@ -285,6 +334,8 @@ async function buildUnlocked(root, mode, force) {
         throw new Error("Standalone build is missing its JavaScript bundle.");
     const result = {
         app: destination,
+        // Older receipts may record a stale bundle selected from DerivedData.
+        product,
         runtime: runtimeFor(root, chosen.included, mode),
         preparation,
     };

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

@@ -6,7 +6,7 @@ const options = {
     device: { type: "string" }, project: { type: "string" }, platform: { type: "string" },
     packages: { type: "string" }, port: { type: "string" }, runner: { type: "boolean" },
     dev: { type: "boolean" }, release: { type: "boolean" }, preview: { type: "boolean" },
-    force: { type: "boolean" }, "submission-id": { type: "string" }, help: { type: "boolean", short: "h" },
+    force: { type: "boolean" }, "dry-run": { type: "boolean" }, "submission-id": { type: "string" }, help: { type: "boolean", short: "h" },
 };
 const commands = {
     create: { flags: ["example", "package-manager", "universal", "platform", "packages"], arguments: [1, 1] },
@@ -20,6 +20,7 @@ const commands = {
     build: { flags: ["project", "platform", "device", "port", "runner", "dev", "release", "preview", "force"], arguments: [0, 0] },
     prebuild: { flags: ["project", "platform"], arguments: [0, 0] },
     doctor: { flags: ["project"], arguments: [0, 0] },
+    upgrade: { flags: ["project", "dry-run"], arguments: [0, 0] },
     "updates init": { flags: ["project", "platform"], arguments: [1, 1] },
     credentials: { flags: ["project", "platform"], arguments: [0, 0] },
     package: { flags: ["project", "platform", "force", "submission-id"], arguments: [0, 0] },

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

@@ -3,7 +3,8 @@ import { checkExpoDesktopNode } from "./expo-node.js";
 import { appendFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
-import { stateFile } from "./project.js";
+import { statePath as stateFile } from "@legendapp/spark-desktop-config/config.cjs";
+import { CommandError } from "./errors.js";
 const running = new Map();
 const secretFlags = new Set(["--password", "--apple-id-password", "--token", "--secret", "--api-key", "-P"]);
 export function commandRedactor(argv, secrets = []) {
@@ -74,7 +75,7 @@ export async function run(root, argv, options = {}) {
             process.stdout.write(redact(output));
     }
     if (code)
-        throw new Error(`${argv.map(redact).join(" ")} exited ${code}. See ${log}\n${redact(output).slice(-1800)}`);
+        throw new CommandError(argv.map(redact), code, redact(output), log);
     if (options.label)
         console.log(`${options.label} finished (${((Date.now() - started) / 1000).toFixed(1)}s).`);
     return output;

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

@@ -1,15 +1,15 @@
+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");
@@ -37,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";

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

@@ -5,6 +5,7 @@ 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,6 +28,17 @@ 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) : {};
@@ -41,9 +53,7 @@ export async function credentials(root, reset = false, execute = run) {
     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 certificate [${defaultChoice}]: `) || String(defaultChoice));
-        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) {
@@ -66,14 +76,14 @@ export async function credentials(root, reset = false, execute = run) {
             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));
+            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)
-                    throw new Error("Enter an existing profile name or select the create option.");
+                    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;
@@ -84,29 +94,34 @@ export async function credentials(root, reset = false, execute = run) {
                 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;
+            needsSelection = !keychainProfile;
         }
-        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;
+        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;
             }
-            else {
-                throw error;
+            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;
+                }
             }
         }
     }

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 = {};

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

@@ -3,7 +3,7 @@ import { acquireRunner } from "./runner-install.js";
 import { spawnProcess } from "./process.js";
 import { windowsMetroPort, stopWindowsMetro } from "./windows-metro.js";
 import { architecture, projectPlatform } from "./platform.js";
-import { nodeCommand } from "./windows.js";
+import { nodeCommand } from "./process.js";
 import { readAppConfig } from "./project.js";
 import { existsSync, rmSync, watch } from "node:fs";
 import path from "node:path";