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

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,8 +11,9 @@ 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";
+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)) {
+    assertNativePatchPreflight(root);
     if (projectPlatform(root) === "windows")
         throw new Error("Windows production analysis is not implemented; use spark build --dev.");
     prepareConfig(root);
@@ -21,7 +25,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 +38,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");
@@ -72,6 +78,7 @@ export async function analyze(root, packages = nativePackages(root)) {
     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 {
@@ -131,16 +138,12 @@ 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");
@@ -155,66 +158,97 @@ 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 &&
+            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"] : []),
+    ];
+    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 +258,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,13 +270,13 @@ 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}`);
+    const destination = stateFile(root, `products/macos-${runtime.arch}/${mode}/${product}`);
     rmSync(destination, { recursive: true, force: true });
     mkdirSync(path.dirname(destination), { recursive: true });
     cpSync(path.join(products, product), destination, { recursive: true, verbatimSymlinks: true });
@@ -252,6 +286,7 @@ async function buildUnlocked(root, mode, force) {
     const result = {
         app: destination,
         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 +304,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,60 @@
+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" }, "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] },
+    "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

@@ -39,6 +39,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) {
@@ -72,6 +75,8 @@ export async function run(root, argv, options = {}) {
     }
     if (code)
         throw new Error(`${argv.map(redact).join(" ")} exited ${code}. See ${log}\n${redact(output).slice(-1800)}`);
+    if (options.label)
+        console.log(`${options.label} finished (${((Date.now() - started) / 1000).toFixed(1)}s).`);
     return output;
 }
 export function binary(root, name) {
@@ -94,8 +99,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.`);

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

@@ -1,4 +1,4 @@
-import { packageSources } from "./release.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";
@@ -16,7 +16,13 @@ const template = path.resolve(import.meta.dirname, "../templates/blank-typescrip
 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))) {
@@ -42,9 +48,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 +67,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 +86,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) {