@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-auth-session/src/types.ts

@@ -0,0 +1,38 @@
+export type AuthSessionResult = { type: "success"; url: string } | { type: "cancel" | "dismiss" | "timeout" };
+export type AuthSessionOptions = { redirectUri?: string; timeoutMs?: number; signal?: AbortSignal };
+export interface AuthSession {
+  readonly redirectUri: string;
+  readonly state: string;
+  open(authorizationUrl: string): Promise<AuthSessionResult>;
+  dismiss(): Promise<void>;
+}
+export function timeout(options: AuthSessionOptions) {
+  const value = options.timeoutMs ?? 120_000;
+  if (!Number.isInteger(value) || value < 1 || value > 600_000) throw new TypeError("Auth timeout must be 1–600000 milliseconds");
+  return value;
+}
+export function callbackMatches(value: string, redirectUri: string, state: string) {
+  try {
+    const url = new URL(value), expected = new URL(redirectUri);
+    if (url.protocol !== expected.protocol || url.hostname !== expected.hostname || url.port !== expected.port || url.pathname !== expected.pathname || url.username || url.password) return false;
+    const states = [...url.searchParams.getAll("state"), ...new URLSearchParams(url.hash.slice(1)).getAll("state")];
+    return states.length === 1 && states[0] === state;
+  } catch { return false; }
+}
+export function authorize(value: string, state: string, redirectUri: string) {
+  const url = new URL(value);
+  if ((url.protocol !== "https:" && !(url.protocol === "http:" && url.hostname === "127.0.0.1")) || url.username || url.password) throw new TypeError("Authorization requires HTTPS (or a local loopback test server)");
+  const states = url.searchParams.getAll("state");
+  if (states.length !== 1 || states[0] !== state) throw new TypeError("Authorization URL must use this session's state");
+  const redirects = url.searchParams.getAll("redirect_uri");
+  if (redirects.length > 1 || (redirects.length === 1 && redirects[0] !== redirectUri)) throw new TypeError("Authorization redirect_uri must match the prepared session");
+}
+export function validateRedirect(uri: string) {
+  const url = new URL(uri);
+  if (url.username || url.password || url.search || url.hash || ["javascript:", "data:", "file:", "about:"].includes(url.protocol)) throw new TypeError("Invalid authentication redirect URI");
+  return url;
+}
+export function validateCount(count: number) { if (!Number.isInteger(count) || count < 1 || count > 1024) throw new TypeError("Random byte count must be 1–1024"); }
+export function validateDigest(algorithm: string, value: string) {
+  if (algorithm !== "SHA-256" || typeof value !== "string" || value.length > 262144) throw new TypeError("Expected SHA-256 and at most 262144 characters");
+}

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

@@ -0,0 +1,164 @@
+import { packageSources } 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";
+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) {
+    if (source.includes(integrationMarker))
+        return source;
+    const parsed = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+    const exported = parsed.statements.find(ts.isExportAssignment);
+    const wrap = (expression) => `require(${JSON.stringify(module)}).${fn}(${expression}${root ? ", __dirname" : ""})`;
+    if (exported && !exported.isExportEquals) {
+        const expression = exported.expression;
+        return source.slice(0, expression.getStart(parsed)) + wrap(expression.getText(parsed)) + source.slice(expression.end) + `\n${integrationMarker}\n`;
+    }
+    let commonJS = false;
+    function visit(node) {
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && node.left.getText(parsed) === "module.exports")
+            commonJS = true;
+        ts.forEachChild(node, visit);
+    }
+    visit(parsed);
+    if (!commonJS)
+        throw new Error(`Cannot safely compose ${file}: use module.exports or an export default expression. No files were changed.`);
+    return `${source}\n${integrationMarker}\nmodule.exports = ${wrap("module.exports")};\n`;
+}
+export function composeMetro(source, file) {
+    if (source.includes(integrationMarker))
+        return source;
+    const parsed = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+    const replacements = [];
+    function visit(node) {
+        if (ts.isStringLiteral(node) && ["expo/metro-config", "@expo/metro-config"].includes(node.text))
+            replacements.push({ start: node.getStart(parsed), end: node.end });
+        ts.forEachChild(node, visit);
+    }
+    visit(parsed);
+    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);
+}
+export async function addDesktop(root, manifestFile) {
+    const pkgFile = path.join(root, "package.json");
+    if (!existsSync(pkgFile))
+        throw new Error("Run add desktop in an installed Expo app, or pass --project.");
+    const pkg = readJson(pkgFile);
+    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 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.
+    for (const [name, version] of Object.entries({ expo: "54.0.37", "react-native": "0.81.6", react: "19.1.4" })) {
+        let actual;
+        try {
+            actual = installed(name);
+        }
+        catch {
+            throw new Error(`Install the app's dependencies first; ${name} is missing.`);
+        }
+        if (actual !== version)
+            throw new Error(`The tested Expo Desktop beta needs ${name}@${version}; this app has ${actual}. Align the app's baseline separately, then retry. No files were changed.`);
+    }
+    const desktopFile = path.join(root, "desktop.config.json");
+    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.");
+        await run(root, managerCommand(manager, ["install"]));
+        console.log("Desktop integration already exists; dependencies installed. Existing configuration preserved.");
+        return;
+    }
+    for (const file of ["macos", "windows"])
+        if (existsSync(path.join(root, file)))
+            throw new Error(`Existing ${file} project needs explicit host composition before adopting spark. No files were changed.`);
+    const expoRequire = createRequire(req.resolve("expo/package.json"));
+    const { getConfig } = expoRequire("@expo/config");
+    const base = getConfig(root, { skipPlugins: true }).exp;
+    if (base.newArchEnabled === false)
+        throw new Error("spark's desktop host requires the New Architecture. Align that setting before adding desktop.");
+    const files = new Map();
+    const configNames = ["app.config.ts", "app.config.js"].filter(file => existsSync(path.join(root, file)));
+    if (configNames.length > 1)
+        throw new Error("Keep one dynamic Expo configuration file before adding desktop.");
+    const configFile = configNames[0] ?? "app.config.js";
+    const configSource = configNames.length ? readFileSync(path.join(root, configFile), "utf8") : "module.exports = ({ config }) => config;\n";
+    files.set(configFile, composeExport(configSource, configFile, "@legendapp/spark/expo-config", "withSparkExpo"));
+    for (const file of ["metro.config.ts", "metro.config.mjs", "metro.config.cjs", "react-native.config.ts", "react-native.config.cjs"]) {
+        if (existsSync(path.join(root, file)))
+            throw new Error(`Compose ${file} explicitly; automatic integration currently supports metro.config.js and react-native.config.js. No files were changed.`);
+    }
+    const metro = "metro.config.js";
+    files.set(metro, composeMetro(existsSync(path.join(root, metro)) ? readFileSync(path.join(root, metro), "utf8") : 'const { getDefaultConfig } = require("expo/metro-config");\nmodule.exports = getDefaultConfig(__dirname);\n', metro));
+    const native = "react-native.config.js";
+    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 local = ["@legendapp/spark"];
+    const dependencies = {};
+    for (const name of local) {
+        if (!archives[name])
+            throw new Error(`SDK is missing ${name}; run spark sdk pack first.`);
+        dependencies[name] = archives[name];
+    }
+    for (const [name, version] of Object.entries(defaults.dependencies)) {
+        if (name.startsWith("expo-desktop") || ["react-native-macos", "react-native-windows", "@react-native-community/cli"].includes(name))
+            dependencies[name] = version;
+    }
+    pkg.dependencies ??= {};
+    for (const [name, version] of Object.entries(dependencies)) {
+        const previous = pkg.dependencies[name] ?? pkg.devDependencies?.[name];
+        if (previous && previous !== version)
+            throw new Error(`Existing ${name} dependency conflicts with the tested desktop version. Resolve it explicitly before retrying. No files were changed.`);
+        if (!previous)
+            pkg.dependencies[name] = version;
+    }
+    // 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" };
+    for (const name of vendor) {
+        if (archives[name]) {
+            overrides[name] = archives[name];
+        }
+    }
+    const overrideField = manager === "yarn" ? "resolutions" : "overrides";
+    const owner = manager === "pnpm" ? (pkg.pnpm ??= {}) : pkg;
+    for (const [name, version] of Object.entries(overrides))
+        if (owner[overrideField]?.[name] && owner[overrideField][name] !== version)
+            throw new Error(`Existing ${name} override conflicts with the local SDK. No files were changed.`);
+    owner[overrideField] = { ...owner[overrideField], ...overrides };
+    pkg.scripts ??= {};
+    for (const platform of ["macos", "windows"]) {
+        const name = pkg.scripts[platform] ? `spark:${platform}` : platform;
+        const command = `spark dev --platform ${platform}`;
+        if (pkg.scripts[name] && pkg.scripts[name] !== command)
+            throw new Error(`Script ${name} already exists; resolve the script conflict before adding desktop.`);
+        pkg.scripts[name] = command;
+    }
+    files.set("package.json", JSON.stringify(pkg, null, 2) + "\n");
+    const config = readJson(path.join(template, "desktop.config.json"));
+    const { name, version, expo, ...desktop } = config;
+    const projectId = crypto.randomUUID();
+    desktop.extends = "expo";
+    desktop.projectId = projectId;
+    desktop.platforms = [...new Set([...(base.platforms ?? ["ios", "android", "web"]), "macos", "windows"])];
+    desktop.macos = { bundleIdentifier: base.macos?.bundleIdentifier ?? base.ios?.bundleIdentifier ?? `app.spark.id${projectId.replaceAll("-", "")}` };
+    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`);
+    // All conflicts are checked before the first write. The integration is kept
+    // reviewable/retryable if the package manager fails; never regenerate mobile.
+    for (const [file, content] of files)
+        writeFileSync(path.join(root, file), content);
+    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

@@ -0,0 +1,7 @@
+export function buildMode(values) {
+    const prebuilt = values.runner || values.prebuilt || values.go;
+    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.");
+    }
+    return prebuilt ? "go" : values.dev ? "dev" : values.preview ? "preview" : "release";
+}

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

@@ -0,0 +1,278 @@
+import { macOSReleaseSettings } from "./macos-release.js";
+import { projectPlatform } from "./platform.js";
+import { isUniversal, isExpoProject } from "@legendapp/spark-desktop-config/config.cjs";
+import { buildWindows } from "./windows.js";
+import { copyHelpers } from "./helpers.js";
+import { readAppConfig } from "./project.js";
+import { cpSync, existsSync, mkdirSync, readFileSync, realpathSync, readdirSync, rmSync, writeFileSync, openSync, closeSync, } from "node:fs";
+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)) {
+    if (projectPlatform(root) === "windows")
+        throw new Error("Windows production analysis is not implemented; use spark build --dev.");
+    prepareConfig(root);
+    const dir = stateFile(root, "analysis");
+    mkdirSync(dir, { recursive: true });
+    const exportBundle = async (env) => run(root, [
+        binary(root, "expo"),
+        "export:embed",
+        "--platform",
+        "macos",
+        "--entry-file",
+        entryFile(root),
+        "--bundle-output",
+        path.join(dir, "app.js"),
+        "--sourcemap-output",
+        path.join(dir, "app.map"),
+        "--dev",
+        "false",
+        "--minify",
+        "false",
+        "--max-workers",
+        "2",
+    ], { env: { CI: "1", ...env }, capture: true });
+    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");
+    const roots = discovery.sources.filter(source => !source.includes("\0")).map(source => {
+        const absolute = path.resolve(root, source);
+        // Expo emits URL-like /node_modules and /App.tsx paths as well as absolute paths.
+        return existsSync(absolute) ? absolute : path.resolve(root, source.replace(/^\//, ""));
+    }).filter(source => existsSync(source)).map(source => realpathSync(source));
+    const enabled = !!runtimeCore && discovery.sources.some(source => (source.startsWith(runtimeCore.root + "/") || source.includes("/node_modules/@react-native-runtimes/core/")) && !source.endsWith("secondary-runtime-polyfill.js"));
+    if (enabled && !discovery.sources.some(source => ["/@legendapp/spark-cli/src/runtime-entry.cjs", "/@legendapp/spark-cli/dist/runtime-entry.cjs"].some(entry => source.endsWith(entry)))) {
+        throw new Error("Runtimes requires withDesktop in metro.config.js and the worker-aware index.ts. See docs/runtimes.md migration instructions.");
+    }
+    const runtimeSources = path.join(dir, "runtime-sources.json");
+    writeJson(runtimeSources, { enabled, roots: roots.filter(source => /\.[jt]sx?$/.test(source) && !source.endsWith(".d.ts") &&
+            !source.includes("/node_modules/@react-native-runtimes/core/") &&
+            (!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 used = new Set();
+    for (const source of map.sources) {
+        for (const pkg of packages) {
+            // Metro's source map can contain absolute paths or project-relative node_modules paths.
+            if (source.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 ?? []);
+    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,
+    });
+    return result;
+}
+export async function build(root, mode, force = false) {
+    const lock = stateFile(root, "build.lock");
+    mkdirSync(path.dirname(lock), { recursive: true });
+    try {
+        const fd = openSync(lock, "wx");
+        writeFileSync(fd, String(process.pid));
+        closeSync(fd);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        const pid = Number(readFileSync(lock, "utf8"));
+        if (!Number.isInteger(pid) || pid <= 0)
+            throw new Error(`Invalid build lock: ${lock}. Check for an active build before removing it.`);
+        try {
+            process.kill(pid, 0);
+        }
+        catch (signalError) {
+            if (signalError.code === "ESRCH") {
+                rmSync(lock);
+                return build(root, mode, force);
+            }
+        }
+        throw new Error(`Another build owns this project (PID ${pid}). Wait for it to finish.`);
+    }
+    try {
+        const result = await buildUnlocked(root, mode, force);
+        if (mode === "go") {
+            registerRuntime(result.app);
+            console.log("Spark Runner registered. Apps will discover it automatically.");
+        }
+        return result;
+    }
+    finally {
+        rmSync(lock, { force: true });
+    }
+}
+async function buildUnlocked(root, mode, force) {
+    if (projectPlatform(root) === "windows")
+        return buildWindows(root, mode, force);
+    prepareConfig(root);
+    if (mode === "go") {
+        const issues = goConfigurationIssues(readAppConfig(root));
+        if (issues.length)
+            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: [] };
+    validateBuildModules(mode, chosen.included);
+    const runtime = runtimeFor(root, chosen.included, mode);
+    const productionHash = productionGraph
+        ? hashFiles(root, [path.relative(root, stateFile(root, "analysis/app.js"))])
+        : undefined;
+    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;
+        }
+    }
+    writeJson(stateFile(root, "native-selection.json"), {
+        excluded: chosen.excluded.map((p) => p.name),
+        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) &&
+        !readFileSync(rnConfig, "utf8").startsWith(marker) &&
+        !(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`);
+    const pkg = readJson(path.join(root, "package.json"));
+    if (!isUniversal(root)) {
+        pkg.expo ??= {};
+        pkg.expo.autolinking ??= {};
+        pkg.expo.autolinking.exclude = chosen.excluded.map((p) => p.name);
+        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 preparedFile = stateFile(root, "native-preparation.json");
+    const needsPreparation = force ||
+        !existsSync(preparedFile) ||
+        readJson(preparedFile).fingerprint !== preparation ||
+        !existsSync(path.join(root, "macos/Pods/Manifest.lock"));
+    if (needsPreparation) {
+        const manifest = readFileSync(path.join(root, "package.json"), "utf8");
+        try {
+            await run(root, [
+                binary(root, "expo-desktop"),
+                "prebuild",
+                "--platform",
+                "macos",
+                "--template",
+                "expo-desktop-template-bare-minimum@54.81.1-beta.6",
+                "--no-install",
+                ...(force ? ["--clean"] : []),
+            ], { env: { CI: "1" }, capture: true });
+            // beta.5 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);
+        }
+        // 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,
+        });
+        await run(root, ["pod", "install"], {
+            cwd: path.join(root, "macos"),
+            env: { RCT_NEW_ARCH_ENABLED: "1" },
+            capture: true,
+        });
+        writeJson(preparedFile, { fingerprint: preparation });
+    }
+    const nativeRoot = path.join(root, "macos");
+    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.
+    await run(root, [
+        "xcodebuild",
+        "-workspace",
+        path.join(nativeRoot, workspace),
+        "-scheme",
+        `${name}-macOS`,
+        "-configuration",
+        configuration,
+        "-destination",
+        "platform=macOS,arch=arm64",
+        "-derivedDataPath",
+        derived,
+        "ARCHS=arm64",
+        "ONLY_ACTIVE_ARCH=YES",
+        "CODE_SIGNING_ALLOWED=NO",
+        ...(mode === "release" ? macOSReleaseSettings : []),
+        "-jobs",
+        "8",
+        "build",
+    ], {
+        env: { RCT_NEW_ARCH_ENABLED: "1", ENTRY_FILE: entryFile(root), ...(productionGraph ? { SPARK_RUNTIME_SOURCES: stateFile(root, "analysis/runtime-sources.json") } : {}) },
+        capture: true,
+    });
+    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 });
+    mkdirSync(path.dirname(destination), { recursive: true });
+    cpSync(path.join(products, product), destination, { recursive: true, verbatimSymlinks: true });
+    if (mode === "release" &&
+        !existsSync(path.join(destination, "Contents/Resources/main.jsbundle")))
+        throw new Error("Standalone build is missing its JavaScript bundle.");
+    const result = {
+        app: destination,
+        runtime: runtimeFor(root, chosen.included, mode),
+    };
+    if (mode === "go" && process.env.SPARK_RELEASE_REVISION) {
+        if (!/^[a-f0-9]{40}$/.test(process.env.SPARK_RELEASE_REVISION))
+            throw new Error("Invalid release source revision");
+        result.runtime.sourceRevision = process.env.SPARK_RELEASE_REVISION;
+    }
+    if (productionHash)
+        result.runtime.fingerprint = digest(result.runtime.fingerprint + productionHash);
+    // prebuild can update package/config fields; cache the actual post-generation inputs.
+    writeJson(path.join(destination, "Contents/Resources/spark-runtime.json"), result.runtime);
+    copyHelpers(root, destination, readAppConfig(root).expo?.extra?.spark?.helpers);
+    if (mode === "release") {
+        // Hermes is prebuilt, so Xcode's app/Pod compiler settings cannot strip it.
+        const hermes = path.join(destination, "Contents/Frameworks/hermes.framework/Versions/Current/hermes");
+        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 });
+    writeJson(resultFile, result);
+    console.log(`Built ${destination}`);
+    return result;
+}

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

@@ -0,0 +1,107 @@
+import { spawnProcess, which } from "./process.js";
+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";
+const running = new Map();
+const secretFlags = new Set(["--password", "--apple-id-password", "--token", "--secret", "--api-key", "-P"]);
+export function commandRedactor(argv, secrets = []) {
+    const values = [...secrets];
+    for (let i = 0; i < argv.length; i++) {
+        const [flag, ...inline] = argv[i].split("=");
+        if (secretFlags.has(flag))
+            values.push(inline.length ? inline.join("=") : argv[i + 1] ?? "");
+    }
+    const unique = [...new Set(values.filter(Boolean))].sort((a, b) => b.length - a.length);
+    return { sensitive: unique.length > 0, redact: (value) => unique.reduce((text, secret) => text.replaceAll(secret, "[REDACTED]"), value) };
+}
+export function cancelCommands(root) {
+    for (const child of running.get(root) ?? [])
+        child.kill();
+}
+export async function run(root, argv, options = {}) {
+    const { sensitive, redact } = commandRedactor(argv, options.sensitiveValues);
+    mkdirSync(stateFile(root, "logs"), { recursive: true });
+    appendFileSync(stateFile(root, "commands.jsonl"), JSON.stringify({
+        time: new Date().toISOString(),
+        argv: argv.map(redact),
+        cwd: options.cwd ?? root,
+    }) + "\n");
+    const child = spawnProcess(argv, {
+        cwd: options.cwd ?? root,
+        env: { ...process.env, ...options.env },
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    if (!running.has(root))
+        running.set(root, new Set());
+    running.get(root).add(child);
+    let output = "";
+    const log = stateFile(root, `logs/${Date.now()}-${crypto.randomUUID()}-${path.basename(argv[0])}.log`);
+    async function consume(stream, target) {
+        const decoder = new TextDecoder();
+        for await (const chunk of stream) {
+            const value = decoder.decode(chunk, { stream: true });
+            output += value;
+            if (!sensitive) {
+                appendFileSync(log, value);
+                if (!options.capture)
+                    target.write(value);
+            }
+        }
+    }
+    let code;
+    try {
+        [, , code] = await Promise.all([
+            consume(child.stdout, process.stdout),
+            consume(child.stderr, process.stderr),
+            child.exited,
+        ]);
+    }
+    finally {
+        running.get(root).delete(child);
+        if (!running.get(root).size)
+            running.delete(root);
+    }
+    // Buffer sensitive commands so secrets split across output chunks cannot leak.
+    if (sensitive) {
+        appendFileSync(log, redact(output));
+        if (!options.capture)
+            process.stdout.write(redact(output));
+    }
+    if (code)
+        throw new Error(`${argv.map(redact).join(" ")} exited ${code}. See ${log}\n${redact(output).slice(-1800)}`);
+    return output;
+}
+export function binary(root, name) {
+    const require = createRequire(path.join(root, "package.json"));
+    const manifest = require.resolve(`${name}/package.json`);
+    const pkg = require(manifest);
+    const entry = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.[name];
+    if (!entry)
+        throw new Error(`${name} does not expose its CLI entry point`);
+    return path.resolve(path.dirname(manifest), entry);
+}
+export async function doctor(root) {
+    if (process.platform === "win32") {
+        for (const tool of ["node", "pwsh.exe", "dotnet.exe"])
+            if (!which(tool))
+                throw new Error(`Missing ${tool}; see docs/windows-slice.md.`);
+        await checkExpoDesktopNode(root);
+        const require = createRequire(path.join(root, "package.json"));
+        const windows = path.dirname(require.resolve("react-native-windows/package.json"));
+        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.");
+    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.`);
+    await checkExpoDesktopNode(root);
+    await run(root, ["xcodebuild", "-version"], { capture: true });
+    await run(root, ["xcrun", "--sdk", "macosx", "--show-sdk-path"], {
+        capture: true,
+    });
+}