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

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

@@ -15,8 +15,10 @@ const patches = [
     '    const onPressAsync = async (key)=>{',
     `    const onPressAsync = async (key)=>{\n        try {\n            if (await require(${extension}).handleKey(key)) return;\n        } catch (error) {\n            _log.exception(error);\n            return;\n        }`],
   ['startAsync.js', '0e062078e63ad6264b1393d403ad56d65a38c6430d30fdac50cd656486cd418b',
-    '    mcpServer == null ? void 0 : mcpServer.start();',
-    `    mcpServer == null ? void 0 : mcpServer.start();\n    require(${extension}).ready(devServerManager.getNativeDevServerPort(), { dev: options.dev, minify: options.minify, https: options.https });`],
+    '    await (0, _profile.profile)(devServerManager.startAsync.bind(devServerManager))(startOptions);',
+    // Dependency validation can wait on the network after Metro is listening.
+    // Report actual server readiness before those optional startup checks.
+    `    await (0, _profile.profile)(devServerManager.startAsync.bind(devServerManager))(startOptions);\n    require(${extension}).ready(devServerManager.getNativeDevServerPort(), { dev: options.dev, minify: options.minify, https: options.https });`],
 ];
 
 function preparePatch(root) {

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

@@ -19,7 +19,7 @@ exports.withSparkMetro = config => {
   if (config && typeof config.then === 'function') return config.then(exports.withSparkMetro);
   if (!config || typeof config !== 'object') throw new Error('Spark needs an object or promise from metro.config');
   const upstream = defaults.get(path.resolve(config.projectRoot || process.cwd()));
-  if (!upstream) throw new Error('Compose Metro with getDefaultConfig from @legendapp/spark-cli/src/expo-metro.cjs');
+  if (!upstream) throw new Error('Compose Metro with getDefaultConfig from @legendapp/spark/metro');
   const customResolve = config.resolver?.resolveRequest;
   if (customResolve && customResolve !== upstream.resolveRequest) {
     const desktopResolve = upstream.resolveRequest;

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

@@ -1,5 +1,9 @@
 exports.withSparkNative = (original, root) => {
-  if (!['macos', 'windows'].includes(process.env.SPARK_PLATFORM)) return original;
+  if (!['macos', 'windows'].includes(process.env.SPARK_PLATFORM)) {
+    const patched = require('@legendapp/spark-desktop-config/native-patches.cjs').prepareNativePatches(root);
+    if (!Object.keys(patched).length) return original;
+    return { ...original, dependencies: { ...patched, ...original.dependencies } };
+  }
   const generated = require('./universal.cjs').nativeConfig(root);
   const dependencies = { ...original.dependencies };
   for (const [name, config] of Object.entries(generated.dependencies ?? {})) {

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

@@ -2,7 +2,7 @@ import { spawnProcess, which } from "./process.js";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-/** Check the actual Node/Expo pair before handing work to Expo Desktop beta. */
+/** Check the actual Node/Expo pair before handing work to Expo Desktop. */
 export async function checkExpoDesktopNode(root) {
     const requireApp = createRequire(path.join(root, "package.json"));
     const requireDesktop = createRequire(requireApp.resolve("expo-desktop/package.json"));
@@ -10,12 +10,12 @@ export async function checkExpoDesktopNode(root) {
     const node = which("node");
     if (!node)
         throw new Error("Missing node. Install Node 24.19.0 (the version in .nvmrc), then retry.");
-    // Use the same static named imports as beta.5. Older Node releases cannot
+    // Use the static named imports used by Expo Desktop. Older Node releases cannot
     // discover these exports in Expo's Babel-generated CommonJS modules.
     const child = spawnProcess([node, "--input-type=module", "-e",
         `import { AndroidConfig, IOSConfig } from ${JSON.stringify(configPlugins)}; if (!AndroidConfig || !IOSConfig) throw new Error('Missing Expo config exports');`,
     ], { cwd: root, stdout: "ignore", stderr: "pipe" });
     const [stderr, code] = await Promise.all([new Response(child.stderr).text(), child.exited]);
     if (code !== 0)
-        throw new Error(`Expo Desktop beta could not load its config plugins using ${node}. Use Node 24.19.0 (nvm install && nvm use from the framework checkout), then retry. Node 24.12.0 cannot import these CommonJS named exports.\n${stderr.trim()}`);
+        throw new Error(`Expo Desktop could not load its config plugins using ${node}. Use Node 24.19.0 (nvm install && nvm use from the framework checkout), then retry. Node 24.12.0 cannot import these CommonJS named exports.\n${stderr.trim()}`);
 }

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

@@ -2,8 +2,8 @@ import { copyFileSync, lstatSync, mkdirSync, realpathSync, chmodSync, readdirSyn
 import path from "node:path";
 import { createRequire } from "node:module";
 import { architecture } from "./platform.js";
-const { validateHelpers } = createRequire(import.meta.url)("@legendapp/spark-desktop-config/helpers.cjs");
 export function resolveHelpers(root, helpers = {}, platform = "macos", arch = architecture(platform)) {
+    const { validateHelpers } = createRequire(import.meta.url)("@legendapp/spark-desktop-config/helpers.cjs");
     validateHelpers(helpers);
     const base = realpathSync(root);
     function inspect(file) {

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

@@ -1,13 +1,13 @@
-import { spawnProcess } from "./process.js";
+import { nodeCommand, spawnProcess } from "./process.js";
 import { examples } from "./examples.js";
 import { prepareGoProfile } from "./go-profile.js";
 import { exportSDK, importSDK } from "./sdk-transfer.js";
 import { hostPlatform } from "./platform.js";
 import path from "node:path";
-import { parseArgs } from "node:util";
+import { cliArguments } from "./cli-arguments.js";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { prepareConfig, readConfig, isExpoProject } from "@legendapp/spark-desktop-config/config.cjs";
-import { nodeCommand, prepareWindows } from "./windows.js";
+import { prepareWindows } from "./windows.js";
 import { create, refreshLocalPackages } from "./create.js";
 import { addDesktop } from "./add-desktop.js";
 import { buildMode } from "./build-mode.js";
@@ -20,37 +20,13 @@ import { doctor, run } from "./commands.js";
 import { findFramework, findProject, sparkHome, creationManifest, packageManifest, registerRuntime } from "./local.js";
 import { readJson, stateFile, VERSION, writeJson } from "./project.js";
 import { devCommand } from "./dev-command.js";
+import { printDependencyPins, upgradeDependencyPins } from "./dependency-pins.js";
+import { reportError } from "./errors.js";
 async function main() {
     const argv = process.argv.slice(2);
     if (argv[0] === "dev")
         return devCommand(argv.slice(1));
-    const { positionals, values } = parseArgs({
-        args: argv,
-        allowPositionals: true,
-        options: {
-            example: { type: "string" },
-            "package-manager": { type: "string" },
-            runtime: { type: "string", multiple: true },
-            universal: { type: "boolean" },
-            device: { type: "string" },
-            project: { type: "string" },
-            platform: { type: "string" },
-            packages: { type: "string" },
-            port: { type: "string" },
-            runner: { type: "boolean" },
-            prebuilt: { type: "boolean" },
-            go: { type: "boolean" }, // Legacy desktop build alias; dev --go belongs to Expo.
-            dev: { type: "boolean" },
-            release: { type: "boolean" },
-            preview: { type: "boolean" },
-            force: { type: "boolean" },
-            "no-open": { type: "boolean" },
-            "submission-id": { type: "string" },
-            help: { type: "boolean", short: "h" },
-        },
-    });
-    if (values.platform && !["macos", "windows", "ios", "android", "web"].includes(values.platform))
-        throw new Error("Platform must be macos, windows, ios, android, or web.");
+    const { positionals, values } = cliArguments(argv);
     if (values.platform)
         process.env.SPARK_PLATFORM = values.platform;
     const platform = (values.platform ?? hostPlatform());
@@ -58,25 +34,25 @@ async function main() {
     const start = path.resolve(projectOption ?? process.cwd());
     const project = () => findProject(start);
     const port = values.port === undefined ? undefined : Number(values.port);
-    if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
-        throw new Error("Port must be an integer between 1 and 65535.");
     const command = positionals[0];
     if (!values.help && !values.platform && !(command === "open" && positionals[1]) && ["build", "prebuild", "analyze", "package", "open", "updates", "credentials"].includes(command ?? "") && isExpoProject(project())) {
         process.env.SPARK_PLATFORM = readConfig(project()).expo.platforms[0];
     }
     if (values.example && (command !== "create" || !examples.includes(values.example)))
         throw new Error(`Use create --example ${examples.join(" | ")}`);
-    if (values.universal && command !== "create")
-        throw new Error("--universal is a create option.");
     if (!values.help && ["build", "prebuild"].includes(command ?? "")) {
         const root = project();
         const selected = readConfig(root).expo.platforms[0];
+        if (!["ios", "android", "web"].includes(selected) && (values.device || values.port))
+            throw new Error("--device and --port are mobile build options; use spark dev for desktop launch options.");
         if (["ios", "android", "web"].includes(selected)) {
+            if (values.force)
+                throw new Error("--force is a desktop build option.");
             if (command === "build" && selected === "web")
                 throw new Error("Use expo export --platform web for web production output.");
             if (command === "prebuild" && selected === "web")
                 throw new Error("Web has no native project to prebuild.");
-            if (values.runner || values.prebuilt || values.go || values.release || values.preview || (command === "build" && !values.dev))
+            if (values.runner || values.release || values.preview || (command === "build" && !values.dev))
                 throw new Error("Mobile builds use --dev in this slice; Expo owns mobile distribution workflows.");
             prepareConfig(root);
             const args = command === "prebuild" ? ["prebuild", "--platform", selected, "--no-install"] : [`run:${selected}`, ...(values.device ? ["--device", values.device] : []), ...(port ? ["--port", String(port)] : [])];
@@ -104,6 +80,8 @@ async function main() {
   spark build         Build a standalone desktop app
   spark prebuild      Generate a Windows/mobile native project
   spark package       Sign and notarize a distribution archive
+  spark doctor        Check app dependency pins and native tooling (exits 1 on issues)
+  spark upgrade       Align app dependency pins with Spark (--dry-run previews changes)
 
 Inside an app: npm run dev, npm run build, npm run package (or pnpm, yarn, bun)
 
@@ -125,8 +103,6 @@ Overrides: --project <directory>, --port <number>, dev --runner-binary <runtime
             case "create": {
                 if (!positionals[1])
                     throw new Error("Usage: spark create MyApp");
-                if (!values.universal && !["macos", "windows"].includes(platform))
-                    throw new Error("Use create --universal for mobile/web targets");
                 await create(path.resolve(positionals[1]), creationManifest(values.packages), platform, !!values.universal || !!values.example, values.example, values["package-manager"]);
                 break;
             }
@@ -169,8 +145,6 @@ Overrides: --project <directory>, --port <number>, dev --runner-binary <runtime
                             process.exitCode = 2;
                         break;
                     }
-                    case "build-go": // Legacy alias; persisted runtime metadata still uses "go".
-                    case "build-prebuilt": // Legacy command alias.
                     case "build-runner": {
                         let root;
                         if (projectOption)
@@ -201,10 +175,44 @@ Overrides: --project <directory>, --port <number>, dev --runner-binary <runtime
                     throw new Error("For macOS, spark build --dev generates and builds the native project.");
                 await prepareWindows(project(), "dev");
                 break;
-            case "doctor":
-                await doctor(start);
+            case "doctor": {
+                let root;
+                let pinIssues = false;
+                try {
+                    root = project();
+                }
+                catch {
+                    console.log("No Spark app found; skipping dependency pin check.");
+                }
+                if (root) {
+                    try {
+                        const issues = upgradeDependencyPins(root, true);
+                        printDependencyPins(issues);
+                        if (issues.length) {
+                            process.exitCode = 1;
+                            pinIssues = true;
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Dependency pin check failed: ${error instanceof Error ? error.message : String(error)}`);
+                        process.exitCode = 1;
+                        pinIssues = true;
+                    }
+                }
+                await doctor(root ?? start);
                 console.log("Native toolchain available.");
+                if (pinIssues)
+                    console.log("Dependency pin issues found; run spark upgrade.");
+                break;
+            }
+            case "upgrade": {
+                const issues = upgradeDependencyPins(project(), !!values["dry-run"]);
+                console.log(values["dry-run"] ? "Dependency pin changes (dry run):" : "Dependency pin changes:");
+                printDependencyPins(issues);
+                if (issues.length)
+                    console.log(values["dry-run"] ? "No files changed. Run spark upgrade, then run your package manager's install command (npm/pnpm/yarn/bun install)." : "Updated package.json. Run your package manager's install command (npm/pnpm/yarn/bun install).");
                 break;
+            }
             case "updates": {
                 if (positionals[1] !== "init" || !positionals[2])
                     throw new Error("Usage: spark updates init https://example.com/updates/appcast.xml");
@@ -216,8 +224,8 @@ Overrides: --project <directory>, --port <number>, dev --runner-binary <runtime
                 console.log("Signing credentials configured. Run spark package to prepare a distribution archive.");
                 break;
             case "package": {
-                if (process.platform !== "darwin" || process.arch !== "arm64")
-                    throw new Error("Packaging currently supports Apple Silicon macOS only.");
+                if (process.platform !== "darwin")
+                    throw new Error("macOS packaging requires macOS.");
                 const result = await packageApp(project(), { force: !!values.force, submissionId: values["submission-id"] });
                 if (result.pending)
                     process.exitCode = 2;
@@ -258,6 +266,6 @@ try {
     await main();
 }
 catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
+    reportError(process.cwd(), error, "Spark");
     process.exitCode = 1;
 }

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

@@ -0,0 +1,16 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import path from "node:path";
+export function readJson(file) {
+    return JSON.parse(readFileSync(file, "utf8"));
+}
+export function writeJson(file, value) {
+    const content = JSON.stringify(value, null, 2) + "\n";
+    // Metro watches JSON too: rewriting unchanged session state on every runtime
+    // check causes empty Fast Refresh updates even when app code has not changed.
+    if (existsSync(file) && readFileSync(file, "utf8") === content)
+        return;
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    writeFileSync(temporary, content);
+    renameSync(temporary, file);
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync } from "node:fs";
+import path from "node:path";
+import { stateFile } from "./project.js";
+export async function preserveMacOSPods(root, prepare) {
+    const native = path.join(root, "macos");
+    const cache = stateFile(root, "prebuild-cache/macos");
+    const entries = ["Pods", "Podfile.lock"];
+    function restore() {
+        for (const entry of entries) {
+            const saved = path.join(cache, entry);
+            const destination = path.join(native, entry);
+            if (!existsSync(saved))
+                continue;
+            if (existsSync(destination))
+                throw new Error(`Cannot restore CocoaPods cache: both ${saved} and ${destination} exist.`);
+            mkdirSync(native, { recursive: true });
+            renameSync(saved, destination);
+        }
+        rmSync(cache, { recursive: true, force: true });
+    }
+    // A terminated prebuild may leave the only copy of Pods in the cache.
+    restore();
+    try {
+        for (const entry of entries) {
+            const source = path.join(native, entry);
+            if (!existsSync(source))
+                continue;
+            mkdirSync(cache, { recursive: true });
+            renameSync(source, path.join(cache, entry));
+        }
+        await prepare();
+    }
+    finally {
+        restore();
+    }
+}
+export function preparationChanges(previous, current) {
+    if (!previous?.inputs)
+        return ["native preparation provenance missing"];
+    const reasons = [];
+    if (JSON.stringify(previous.inputs.config) !== JSON.stringify(current.inputs?.config)) {
+        const updatesChanged = JSON.stringify(previous.inputs.config.expo?.extra?.spark?.updates) !== JSON.stringify(current.inputs?.config.expo?.extra?.spark?.updates);
+        reasons.push(updatesChanged ? "native configuration changed (updater settings)" : "native configuration changed");
+    }
+    if (previous.inputs.plugin !== current.inputs?.plugin)
+        reasons.push("native host/config plugin changed");
+    const before = new Map(previous.inputs.packages.map(([name, root, contents]) => [name, { root, contents }]));
+    for (const [name, root, contents] of current.inputs?.packages ?? []) {
+        const prior = before.get(name);
+        if (!prior)
+            reasons.push(`${name} added`);
+        else {
+            if (prior.root !== root)
+                reasons.push(`${name} location changed`);
+            if (prior.contents !== contents)
+                reasons.push(`${name} preparation sources changed`);
+        }
+        before.delete(name);
+    }
+    for (const name of before.keys())
+        reasons.push(`${name} removed`);
+    return reasons.length ? reasons : previous.fingerprint !== current.fingerprint ? ["native preparation inputs changed"] : [];
+}
+export function missingNativeFrameworks(root) {
+    const pods = path.join(root, "macos/Pods");
+    const support = path.join(pods, "Target Support Files");
+    if (!existsSync(support))
+        return [support];
+    const missing = new Set();
+    for (const target of readdirSync(support)) {
+        const script = path.join(support, target, `${target}-xcframeworks.sh`);
+        if (!existsSync(script))
+            continue;
+        // CocoaPods lists only the frameworks and slices selected for this target.
+        for (const match of readFileSync(script, "utf8").matchAll(/^install_xcframework "([^"]+)" "[^"]+" "[^"]+" (.+)$/gm)) {
+            const framework = match[1].replaceAll("${PODS_ROOT}", pods).replaceAll("$(PODS_ROOT)", pods);
+            if (framework.includes("$"))
+                throw new Error(`Cannot resolve native framework input: ${framework}`);
+            if (!existsSync(path.join(framework, "Info.plist")))
+                missing.add(path.normalize(framework));
+            for (const slice of match[2].matchAll(/"([^"]+)"/g)) {
+                if (!existsSync(path.join(framework, slice[1])))
+                    missing.add(path.join(framework, slice[1]));
+            }
+        }
+    }
+    return [...missing];
+}

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

@@ -0,0 +1,75 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { run } from "./commands.js";
+import { stateFile } from "./project.js";
+// Security returns attributes only. Never request or print credential data.
+const discovery = String.raw `
+import Foundation
+import Security
+import LocalAuthentication
+
+struct KeychainError: Error { let status: OSStatus }
+func check(_ status: OSStatus) throws {
+    if status != errSecSuccess { throw KeychainError(status: status) }
+}
+func profiles(_ query: [CFString: Any]) throws -> [String] {
+    var result: CFTypeRef?
+    let status = SecItemCopyMatching(query as CFDictionary, &result)
+    var names: [String] = []
+    if status != errSecItemNotFound {
+        try check(status)
+        let prefix = "com.apple.gke.notary.tool.saved-creds."
+        for item in result as? [[String: Any]] ?? [] {
+            if let account = item[kSecAttrAccount as String] as? String, account.hasPrefix(prefix) {
+                let name = String(account.dropFirst(prefix.count))
+                if !name.isEmpty { names.append(name) }
+            }
+        }
+    }
+    return names
+}
+
+do {
+    let context = LAContext()
+    context.interactionNotAllowed = true
+    var query: [CFString: Any] = [
+        kSecClass: kSecClassGenericPassword,
+        kSecAttrLabel: "com.apple.gke.notary.tool",
+        kSecMatchLimit: kSecMatchLimitAll,
+        kSecReturnAttributes: true,
+        kSecReturnData: false,
+        kSecUseAuthenticationContext: context
+    ]
+    if CommandLine.arguments.count > 1 {
+        var keychain: SecKeychain?
+        try check(SecKeychainOpen(CommandLine.arguments[1], &keychain))
+        if let keychain { query[kSecMatchSearchList] = [keychain] }
+    }
+    var names = try profiles(query)
+    if CommandLine.arguments.count == 1 {
+        query[kSecUseDataProtectionKeychain] = true
+        query[kSecAttrSynchronizable] = kSecAttrSynchronizableAny
+        names += try profiles(query)
+    }
+    let data = try JSONSerialization.data(withJSONObject: Array(Set(names)).sorted())
+    print(String(decoding: data, as: UTF8.self))
+} catch {
+    let message: String
+    if let error = error as? KeychainError {
+        message = SecCopyErrorMessageString(error.status, nil) as String? ?? "OSStatus \(error.status)"
+    } else { message = String(describing: error) }
+    FileHandle.standardError.write(Data("Cannot list notarization Keychain profiles: \(message)\n".utf8))
+    exit(1)
+}
+`;
+export async function listNotaryProfiles(root, keychain, execute = run) {
+    const file = stateFile(root, "notary-profiles.swift");
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, discovery);
+    const output = await execute(root, ["xcrun", "swift", "-suppress-warnings", file, ...(keychain ? [keychain] : [])], { capture: true });
+    const profiles = JSON.parse(output);
+    if (!Array.isArray(profiles) || !profiles.every(profile => typeof profile === "string" && profile.length > 0)) {
+        throw new Error("Invalid notarization profile discovery result.");
+    }
+    return [...new Set(profiles)].sort();
+}

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

@@ -69,16 +69,18 @@ async function packageUnlocked(root, options, deps) {
     if (config.extra?.spark?.updates && !result.runtime.modules["@legendapp/spark-updates"])
         throw new Error("Updates are configured but the module was pruned. Import @legendapp/spark/updates from the app entry.");
     const entitlements = distributionEntitlements(appEntitlements(root, result.runtime.modules));
+    if (!config.macos?.bundleIdentifier || !config.version)
+        throw new Error("Packaging requires macos.bundleIdentifier and version");
     const byPath = config.extra?.spark?.signing?.macos?.entitlementsByPath ?? {};
     const info = JSON.parse(await execute(root, ["plutil", "-convert", "json", "-o", "-", path.join(result.app, "Contents/Info.plist")], { capture: true }));
-    const expected = { runner: options.runner, bundleId: config.macos.bundleIdentifier, version: config.version, buildVersion: info.CFBundleVersion, entitlements, byPath };
+    const expected = { arch: result.runtime.arch, runner: options.runner, bundleId: config.macos.bundleIdentifier, version: config.version, buildVersion: info.CFBundleVersion, entitlements, byPath };
     if (!expected.bundleId || !expected.version || !expected.buildVersion)
         throw new Error("Bundle identifier and release version metadata must be configured before packaging.");
     const inputHash = artifactHash(result.app);
     const key = digest(JSON.stringify({ recipe: 1, inputHash, identity: identity.hash, entitlements, byPath }));
     const folder = stateFile(root, `packaging/${key}`);
     const app = path.join(folder, path.basename(result.app));
-    const safeName = `${config.slug ?? config.name}-${config.version}-arm64`.replace(/[^A-Za-z0-9._-]/g, "-");
+    const safeName = `${config.slug ?? config.name}-${config.version}-${result.runtime.arch}`.replace(/[^A-Za-z0-9._-]/g, "-");
     const upload = path.join(folder, `${safeName}-${key.slice(0, 16)}-notary.zip`);
     const statePath = path.join(folder, "state.json");
     mkdirSync(folder, { recursive: true });