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

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

@@ -1,11 +1,11 @@
-import { packageSources } from "./release.js";
+import { installedRelease, materializeReleasePackages, packageSources, verifyMaterializedReleasePackages } from "./release.js";
 import { packageManager, managerCommand, localArchive } from "./package-manager.js";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
 import ts from "typescript";
 import { run } from "./commands.js";
-import { readJson } from "./project.js";
+import { readJson, writeJson } from "./project.js";
 export const integrationMarker = "// spark: existing Expo project";
 /** Wrap an existing export without reprinting or moving the application's code. */
 export function composeExport(source, file, module, fn, root = true) {
@@ -43,8 +43,8 @@ export function composeMetro(source, file) {
     if (!replacements.length)
         throw new Error(`Cannot safely compose ${file}: use Expo's getDefaultConfig before adding desktop support. No files were changed.`);
     for (const { start, end } of replacements.sort((a, b) => b.start - a.start))
-        source = source.slice(0, start) + '"@legendapp/spark/expo-metro"' + source.slice(end);
-    return composeExport(source, file, "@legendapp/spark/expo-metro", "withSparkMetro", false);
+        source = source.slice(0, start) + '"@legendapp/spark/metro"' + source.slice(end);
+    return composeExport(source, file, "@legendapp/spark/metro", "withSparkMetro", false);
 }
 export async function addDesktop(root, manifestFile) {
     const pkgFile = path.join(root, "package.json");
@@ -54,6 +54,7 @@ export async function addDesktop(root, manifestFile) {
     if (pkg.type === "module")
         throw new Error("ES module package configurations need explicit composition; automatic add desktop currently supports Expo's CommonJS project layout. No files were changed.");
     const manager = packageManager(root);
+    const release = manifestFile ? undefined : installedRelease();
     const req = createRequire(pkgFile);
     const installed = (name) => readJson(req.resolve(`${name}/package.json`)).version;
     // Never upgrade the mobile baseline as a side effect of adding desktop.
@@ -72,6 +73,43 @@ export async function addDesktop(root, manifestFile) {
     if (existsSync(desktopFile)) {
         if (readJson(desktopFile).extends !== "expo")
             throw new Error("This app already uses spark-owned configuration; add desktop is for existing Expo projects.");
+        if (release) {
+            const sources = packageSources(undefined, release);
+            const replacement = new Map(Object.entries(release.packages).map(([name, asset]) => [asset.url, sources[name]]));
+            const portableSources = new Set(replacement.values());
+            let changed = false, needsVerify = false;
+            function secureDependencies(value) {
+                if (typeof value === "string") {
+                    const portable = replacement.get(value);
+                    if (portable) {
+                        changed = true;
+                        needsVerify = true;
+                        return portable;
+                    }
+                    if (portableSources.has(value))
+                        needsVerify = true;
+                    return value;
+                }
+                if (Array.isArray(value))
+                    return value.map(secureDependencies);
+                if (value && typeof value === "object")
+                    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, secureDependencies(item)]));
+                return value;
+            }
+            for (const field of ["dependencies", "devDependencies", "optionalDependencies", "overrides", "resolutions", "pnpm"])
+                if (pkg[field])
+                    pkg[field] = secureDependencies(pkg[field]);
+            if (needsVerify) {
+                await materializeReleasePackages(release, root);
+                verifyMaterializedReleasePackages(release, root);
+                if (changed)
+                    writeJson(pkgFile, pkg);
+                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`);
+            }
+        }
         await run(root, managerCommand(manager, ["install"]));
         console.log("Desktop integration already exists; dependencies installed. Existing configuration preserved.");
         return;
@@ -101,7 +139,7 @@ export async function addDesktop(root, manifestFile) {
     files.set(native, composeExport(existsSync(path.join(root, native)) ? readFileSync(path.join(root, native), "utf8") : "module.exports = {};\n", native, "@legendapp/spark/native", "withSparkNative"));
     const template = path.resolve(import.meta.dirname, "../templates/universal");
     const defaults = readJson(path.join(template, "package.json"));
-    const archives = packageSources(manifestFile);
+    const archives = packageSources(manifestFile, release);
     const local = ["@legendapp/spark"];
     const dependencies = {};
     for (const name of local) {
@@ -123,7 +161,8 @@ export async function addDesktop(root, manifestFile) {
     }
     // Resolve local transitive SDK packages without replacing any mobile pins.
     const vendor = ["@react-native-runtimes/core", "react-native-nitro-modules", "@op-engineering/op-sqlite", "react-native-webview"];
-    const overrides = { ...Object.fromEntries(local.map(name => [name, dependencies[name]])), "@expo/cli": "54.0.27" };
+    const overrides = { ...Object.fromEntries(local.map(name => [name, dependencies[name]])), "@expo/cli": "54.0.27",
+        "react-native-macos": defaults.overrides["react-native-macos"], "react-native-windows": defaults.overrides["react-native-windows"] };
     for (const name of vendor) {
         if (archives[name]) {
             overrides[name] = archives[name];
@@ -154,11 +193,15 @@ export async function addDesktop(root, manifestFile) {
     files.set("desktop.config.json", JSON.stringify(desktop, null, 2) + "\n");
     const ignoreFile = path.join(root, ".gitignore");
     const ignore = existsSync(ignoreFile) ? readFileSync(ignoreFile, "utf8") : "";
-    files.set(".gitignore", `${ignore}${ignore.endsWith("\n") || !ignore ? "" : "\n"}\n# spark generated desktop state\n/.spark/\n/macos/\n/windows/\n`);
+    files.set(".gitignore", `${ignore}${ignore.endsWith("\n") || !ignore ? "" : "\n"}\n# spark generated desktop state\n/.spark/\n/macos/\n/windows/\n${release ? "\n# Spark verified release package inputs\n!/spark-packages/\n!/spark-packages/**\n" : ""}`);
     // All conflicts are checked before the first write. The integration is kept
     // reviewable/retryable if the package manager fails; never regenerate mobile.
+    if (release)
+        await materializeReleasePackages(release, root);
     for (const [file, content] of files)
         writeFileSync(path.join(root, file), content);
+    if (release)
+        verifyMaterializedReleasePackages(release, root);
     await run(root, managerCommand(manager, ["install"]));
     console.log(`Added desktop support to ${root}. Existing entry point and mobile/web scripts are unchanged.\nRun spark build --dev --platform macos, then spark dev --platform macos. Windows native builds run on Windows.`);
 }

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

@@ -1,5 +1,5 @@
 export function buildMode(values) {
-    const prebuilt = values.runner || values.prebuilt || values.go;
+    const prebuilt = values.runner;
     if ([prebuilt, values.dev, values.preview, values.release].filter(Boolean).length > 1) {
         throw new Error("Choose only one build mode: --dev, --preview, --release, or --runner.");
     }

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

@@ -1,5 +1,8 @@
+import { restoreNativeMetadata } from "./native-metadata.js";
+import { assertNativePatchPreflight } from "./native-patch-preflight.js";
+import { missingNativeFrameworks, preparationChanges, preserveMacOSPods } from "./native-preparation.js";
 import { macOSReleaseSettings } from "./macos-release.js";
-import { projectPlatform } from "./platform.js";
+import { macOSXcodeArchitecture, projectPlatform } from "./platform.js";
 import { isUniversal, isExpoProject } from "@legendapp/spark-desktop-config/config.cjs";
 import { buildWindows } from "./windows.js";
 import { copyHelpers } from "./helpers.js";
@@ -8,10 +11,12 @@ import { cpSync, existsSync, mkdirSync, readFileSync, realpathSync, readdirSync,
 import path from "node:path";
 import { registerRuntime } from "./local.js";
 import { binary, doctor, run } from "./commands.js";
-import { prepareConfig, entryFile, digest, hashFiles, hostSourceSignature, nativePackages, readJson, runtimeFor, selection, stateFile, writeJson, validateBuildModules, goConfigurationIssues, } from "./project.js";
-export async function analyze(root, packages = nativePackages(root)) {
+import { prepareConfig, entryFile, digest, hashFiles, nativePreparationInputs, nativeProjectFingerprint, localSigningIdentity, nativePackages, readJson, runtimeFor, selection, stateFile, writeJson, validateBuildModules, goConfigurationIssues, } from "./project.js";
+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 });
@@ -21,7 +26,9 @@ export async function analyze(root, packages = nativePackages(root)) {
         "--platform",
         "macos",
         "--entry-file",
-        entryFile(root),
+        // Metro resolves export entries from its server root, which can be the
+        // containing workspace rather than this app's project root.
+        path.resolve(root, entryFile(root)),
         "--bundle-output",
         path.join(dir, "app.js"),
         "--sourcemap-output",
@@ -32,7 +39,7 @@ export async function analyze(root, packages = nativePackages(root)) {
         "false",
         "--max-workers",
         "2",
-    ], { env: { CI: "1", ...env }, capture: true });
+    ], { env: { CI: "1", ...env }, label: "Analyzing production JavaScript" });
     await exportBundle({ SPARK_RUNTIME_DISCOVERY: "1" });
     const discovery = readJson(path.join(dir, "app.map"));
     const runtimeCore = packages.find(pkg => pkg.name === "@react-native-runtimes/core");
@@ -51,27 +58,74 @@ 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) {
+    assertNativePatchPreflight(root);
     const lock = stateFile(root, "build.lock");
     mkdirSync(path.dirname(lock), { recursive: true });
     try {
@@ -118,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
@@ -131,23 +184,19 @@ async function buildUnlocked(root, mode, force) {
     if (productionHash)
         runtime.fingerprint = digest(runtime.fingerprint + productionHash);
     const resultFile = stateFile(root, `${mode}-build.json`);
-    if (!force && existsSync(resultFile)) {
-        const existing = readJson(resultFile);
-        if (existing.runtime.fingerprint === runtime.fingerprint &&
-            existsSync(existing.app)) {
-            console.log(`Reusing ${existing.app}`);
-            return existing;
-        }
-    }
+    const excludedNames = [...new Set([
+            ...(readAppConfig(root).expo.autolinking?.exclude ?? []),
+            ...chosen.excluded.map((p) => p.name),
+        ])];
     writeJson(stateFile(root, "native-selection.json"), {
-        excluded: chosen.excluded.map((p) => p.name),
+        excluded: excludedNames,
         included: chosen.included.map((p) => ({ name: p.name, root: p.root })),
     });
     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`);
@@ -155,66 +204,99 @@ async function buildUnlocked(root, mode, force) {
     if (!isUniversal(root)) {
         pkg.expo ??= {};
         pkg.expo.autolinking ??= {};
-        pkg.expo.autolinking.exclude = chosen.excluded.map((p) => p.name);
+        pkg.expo.autolinking.exclude = excludedNames;
         writeJson(path.join(root, "package.json"), pkg);
     }
-    const preparation = digest(JSON.stringify({
-        config: readAppConfig(root),
-        packages: chosen.included.map((p) => [
-            p.name,
-            hashFiles(p.root, [
-                "package.json",
-                p.json.codegenConfig?.jsSrcsDir ?? "src",
-                ...readdirSync(p.root).filter((name) => name.endsWith(".podspec")),
-            ]),
-        ]),
-        plugin: hostSourceSignature(root),
-    }));
+    const inputs = nativePreparationInputs(root, chosen.included);
+    const preparation = { fingerprint: digest(JSON.stringify(inputs)), inputs, projectFingerprint: nativeProjectFingerprint(inputs, chosen.included) };
     const preparedFile = stateFile(root, "native-preparation.json");
-    const needsPreparation = force ||
-        !existsSync(preparedFile) ||
-        readJson(preparedFile).fingerprint !== preparation ||
+    const prepared = existsSync(preparedFile) ? readJson(preparedFile) : undefined;
+    const nativeRoot = path.join(root, "macos");
+    const hasNativeProject = existsSync(nativeRoot) && readdirSync(nativeRoot).some(name => name.endsWith(".xcodeproj") && existsSync(path.join(nativeRoot, name, "project.pbxproj")));
+    const needsProject = force || !hasNativeProject || prepared?.projectFingerprint !== preparation.projectFingerprint;
+    const needsPreparation = needsProject ||
+        prepared?.fingerprint !== preparation.fingerprint ||
         !existsSync(path.join(root, "macos/Pods/Manifest.lock"));
-    if (needsPreparation) {
+    const existing = existsSync(resultFile) ? readJson(resultFile) : undefined;
+    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;
+        }
+    }
+    const reasons = force ? ["forced build"] : !existing ? ["no cached app"] : [
+        ...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;
+    if (needsPreparation)
+        rmSync(preparedFile, { force: true });
+    if (needsProject) {
+        console.log(`Preparing native project (preserving CocoaPods cache): ${force ? "forced build" : !hasNativeProject ? "native project missing" : preparationChanges(prepared, preparation).join("; ") || "native project provenance missing"}.`);
         const manifest = readFileSync(path.join(root, "package.json"), "utf8");
+        const appJson = path.join(root, "app.json");
+        const originalAppJson = existsSync(appJson) ? readFileSync(appJson, "utf8") : undefined;
         try {
-            await run(root, [
+            await preserveMacOSPods(root, () => run(root, [
                 binary(root, "expo-desktop"),
                 "prebuild",
                 "--platform",
                 "macos",
                 "--template",
-                "expo-desktop-template-bare-minimum@54.81.1-beta.6",
+                "expo-desktop-template-bare-minimum@54.81.1",
                 "--no-install",
-                ...(force ? ["--clean"] : []),
-            ], { env: { CI: "1" }, capture: true });
-            // beta.5 copies all-platform template dependencies even for macOS. Preserve this
+                // Template renaming is not idempotent (HelloWorld becomes
+                // LegendHelloWorld, then LegendLegendHelloWorld). Native projects
+                // are generated output; recreate them only when project inputs change.
+                "--clean",
+            ], { env: { CI: "1" }, label: "Generating native project" }));
+            // Expo Desktop copies all-platform template dependencies even for macOS. Preserve this
             // platform's installed manifest instead of silently adding uninstalled Windows packages.
         }
         finally {
             writeFileSync(path.join(root, "package.json"), manifest);
+            // Upstream template replacement also rewrites app.json substrings.
+            if (originalAppJson !== undefined)
+                writeFileSync(appJson, originalAppJson);
         }
+    }
+    if (needsPreparation) {
         // ReactCodegen's source glob must not pick up bindings from a previously larger graph.
         rmSync(path.join(root, "macos/build/generated"), {
             recursive: true,
             force: true,
         });
+    }
+    const missing = missingNativeFrameworks(root);
+    if (needsPreparation || missing.length) {
+        if (needsPreparation && !needsProject)
+            console.log(`Updating CocoaPods dependencies: ${prepared?.fingerprint !== preparation.fingerprint ? preparationChanges(prepared, preparation).join("; ") : "CocoaPods state missing"}.`);
+        if (missing.length && !needsPreparation)
+            console.log(`Restoring missing native frameworks:\n${missing.join("\n")}`);
         await run(root, ["pod", "install"], {
             cwd: path.join(root, "macos"),
             env: { RCT_NEW_ARCH_ENABLED: "1" },
-            capture: true,
+            label: "Installing CocoaPods dependencies",
         });
-        writeJson(preparedFile, { fingerprint: preparation });
+        const remaining = missingNativeFrameworks(root);
+        if (remaining.length)
+            throw new Error(`Native frameworks are missing after pod install. Restore the package's native artifacts and retry:\n${remaining.join("\n")}`);
+        writeJson(preparedFile, preparation);
     }
-    const nativeRoot = path.join(root, "macos");
+    await restoreNativeMetadata(root, nativeConfig);
     const workspace = readdirSync(nativeRoot).find((name) => name.endsWith(".xcworkspace"));
     if (!workspace)
         throw new Error("Prebuild did not produce a macOS workspace.");
     const name = workspace.slice(0, -".xcworkspace".length);
     const configuration = mode === "release" ? "Release" : "Debug";
-    const derived = stateFile(root, "DerivedData");
-    console.log(`Building ${mode === "go" ? "Spark Runner" : mode} runtime (${configuration}, arm64)…`);
-    // Export once for analysis; native build performs the normal production bundle step.
+    const xcodeArch = macOSXcodeArchitecture(runtime.arch);
+    const derived = stateFile(root, `DerivedData/macos-${runtime.arch}`);
     await run(root, [
         "xcodebuild",
         "-workspace",
@@ -224,10 +306,10 @@ async function buildUnlocked(root, mode, force) {
         "-configuration",
         configuration,
         "-destination",
-        "platform=macOS,arch=arm64",
+        `platform=macOS,arch=${xcodeArch}`,
         "-derivedDataPath",
         derived,
-        "ARCHS=arm64",
+        `ARCHS=${xcodeArch}`,
         "ONLY_ACTIVE_ARCH=YES",
         "CODE_SIGNING_ALLOWED=NO",
         ...(mode === "release" ? macOSReleaseSettings : []),
@@ -236,14 +318,15 @@ async function buildUnlocked(root, mode, force) {
         "build",
     ], {
         env: { RCT_NEW_ARCH_ENABLED: "1", ENTRY_FILE: entryFile(root), ...(productionGraph ? { SPARK_RUNTIME_SOURCES: stateFile(root, "analysis/runtime-sources.json") } : {}) },
-        capture: true,
+        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.");
-    const destination = stateFile(root, `products/${mode}/${product}`);
-    rmSync(destination, { recursive: true, force: true });
+    // 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(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" &&
@@ -251,7 +334,10 @@ 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,
     };
     if (mode === "go" && process.env.SPARK_RELEASE_REVISION) {
         if (!/^[a-f0-9]{40}$/.test(process.env.SPARK_RELEASE_REVISION))
@@ -269,9 +355,9 @@ async function buildUnlocked(root, mode, force) {
         if (existsSync(hermes))
             await run(root, ["strip", "-S", "-x", hermes], { capture: true });
     }
-    // Local standalone outputs remain ad-hoc. `spark package` signs a separate
-    // staging copy with Developer ID for distribution.
-    await run(root, ["codesign", "--force", "--deep", "--sign", "-", destination], { capture: true });
+    // Development apps can opt into a local identity for same-team native plugins.
+    // Standalone outputs remain ad-hoc until `spark package` signs its staging copy.
+    await run(root, ["codesign", "--force", "--deep", "--sign", localSigningIdentity(root, mode), destination], { capture: true });
     writeJson(resultFile, result);
     console.log(`Built ${destination}`);
     return result;

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

@@ -0,0 +1,61 @@
+import { parseArgs } from "node:util";
+import { buildMode } from "./build-mode.js";
+const 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" },
+    dev: { type: "boolean" }, release: { type: "boolean" }, preview: { type: "boolean" },
+    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] },
+    "add desktop": { flags: ["project", "packages"], arguments: [0, 0] },
+    "sdk export": { flags: ["packages", "runtime"], arguments: [1, 1] },
+    "sdk import": { flags: [], arguments: [1, 1] },
+    "sdk register": { flags: [], arguments: [1, 1] },
+    "sdk pack": { flags: ["project", "platform"], arguments: [0, 0] },
+    "sdk package-runner": { flags: ["project", "platform", "force", "submission-id"], arguments: [0, 0] },
+    "sdk build-runner": { flags: ["project", "platform", "packages", "package-manager", "force"], arguments: [0, 0] },
+    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] },
+    analyze: { flags: ["project", "platform"], arguments: [0, 0] },
+    open: { flags: ["project", "platform", "port"], arguments: [0, 1] },
+};
+/** Validate the command grammar before resolving a project or performing side effects. */
+export function cliArguments(args) {
+    const parsed = parseArgs({ args, allowPositionals: true, options });
+    const { values, positionals } = parsed;
+    const grouped = ["sdk", "add", "updates"].includes(positionals[0]);
+    const command = positionals.slice(0, grouped ? 2 : 1).join(" ");
+    if (!command || (grouped && positionals.length === 1 && values.help)) {
+        if (Object.keys(values).some(key => key !== "help"))
+            throw new Error("Choose a command before specifying options. Run spark --help.");
+        return parsed;
+    }
+    const contract = commands[command];
+    if (!contract)
+        throw new Error(`Unknown command: ${command}. Run spark --help.`);
+    for (const key of Object.keys(values))
+        if (key !== "help" && !contract.flags.includes(key))
+            throw new Error(`--${key} is not an option for spark ${command}`);
+    const count = positionals.length - (grouped ? 2 : 1);
+    if ((!values.help && count < contract.arguments[0]) || count > contract.arguments[1])
+        throw new Error(`Invalid arguments for spark ${command}. Expected ${contract.arguments[0] === contract.arguments[1] ? contract.arguments[0] : "zero or one"} positional argument(s).`);
+    if (values.platform && !["macos", "windows", "ios", "android", "web"].includes(values.platform))
+        throw new Error("Platform must be macos, windows, ios, android, or web.");
+    if (values.port !== undefined && (!Number.isInteger(Number(values.port)) || Number(values.port) < 1 || Number(values.port) > 65535))
+        throw new Error("Port must be an integer between 1 and 65535.");
+    if (values["package-manager"] && !["npm", "pnpm", "yarn", "bun"].includes(values["package-manager"]))
+        throw new Error("Package manager must be npm, pnpm, yarn, or bun.");
+    if (command === "build")
+        buildMode(values);
+    if (command === "sdk build-runner" && values.project && (values.packages || values["package-manager"]))
+        throw new Error("--packages and --package-manager configure a generated Runner project; omit --project to use them.");
+    return parsed;
+}

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 = []) {
@@ -39,6 +40,9 @@ export async function run(root, argv, options = {}) {
     running.get(root).add(child);
     let output = "";
     const log = stateFile(root, `logs/${Date.now()}-${crypto.randomUUID()}-${path.basename(argv[0])}.log`);
+    const started = Date.now();
+    if (options.label)
+        console.log(`${options.label}…\nLog: ${log}`);
     async function consume(stream, target) {
         const decoder = new TextDecoder();
         for await (const chunk of stream) {
@@ -71,7 +75,9 @@ 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;
 }
 export function binary(root, name) {
@@ -94,8 +100,8 @@ export async function doctor(root) {
         await run(root, ["pwsh.exe", "-File", path.join(windows, "Scripts/rnw-dependencies.ps1")]);
         return;
     }
-    if (process.platform !== "darwin" || process.arch !== "arm64")
-        throw new Error("The prototype supports Apple Silicon macOS only.");
+    if (process.platform !== "darwin")
+        throw new Error("Native macOS builds require macOS.");
     for (const tool of ["node", "pod", "xcodebuild"])
         if (!which(tool))
             throw new Error(`Missing ${tool}. Install the macOS native prerequisites described in docs/development.md, then retry the build.`);