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

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

@@ -23,12 +23,26 @@ export function windowsArchitecture(host = process.platform, machineArch = machi
     }
     return "x64";
 }
-export const architecture = (platform) => platform === "windows" ? windowsArchitecture() : "arm64";
+export function macOSArchitecture(machineArch = machine(), env = process.env) {
+    const explicit = env.SPARK_MACOS_ARCH?.toLowerCase();
+    if (explicit !== undefined) {
+        if (explicit === "arm64" || explicit === "x64")
+            return explicit;
+        throw new Error("SPARK_MACOS_ARCH must be arm64 or x64.");
+    }
+    if (machineArch === "arm64" || machineArch === "aarch64")
+        return "arm64";
+    if (["x64", "x86_64"].includes(machineArch))
+        return "x64";
+    throw new Error(`Unsupported macOS architecture: ${machineArch}.`);
+}
+export const macOSXcodeArchitecture = (arch) => arch === "x64" ? "x86_64" : "arm64";
+export const architecture = (platform) => platform === "windows" ? windowsArchitecture() : macOSArchitecture();
 export function projectPlatform(root) {
     if (!["app.json", "desktop.config.json"].some(name => existsSync(path.join(root, name))))
         return "macos";
     const platforms = readConfig(root).expo?.platforms ?? ["macos"];
-    if (platforms.length !== 1 || !["macos", "windows"].includes(platforms[0]))
+    if (platforms.length !== 1 || (platforms[0] !== "macos" && platforms[0] !== "windows"))
         throw new Error("Select a desktop target with --platform macos or --platform windows.");
     return platforms[0];
 }

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

@@ -1,3 +1,4 @@
+import { readJson } from "./json.js";
 import path from "node:path";
 import { spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
@@ -55,3 +56,9 @@ export function spawnProcess(argv, options = {}) {
     return result;
 }
 export { which } from "./executable.js";
+// Windows .cmd shims are shell programs; run the package's actual JS entry.
+export function nodeCommand(root, name, bin, args = []) {
+    const req = createRequire(path.join(root, "package.json"));
+    const file = req.resolve(`${name}/package.json`), pkg = readJson(file);
+    return ["node", path.resolve(path.dirname(file), typeof pkg.bin === "string" ? pkg.bin : pkg.bin[bin]), ...args];
+}

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

@@ -1,3 +1,5 @@
+import { nativeWindowOptions } from "@legendapp/spark-window-options";
+import { prepareNativePatches } from "@legendapp/spark-desktop-config/native-patches.cjs";
 import { macOSReleaseSettings } from "./macos-release.js";
 import { projectPlatform, architecture } from "./platform.js";
 import { resolveHelpers } from "./helpers.js";
@@ -5,23 +7,11 @@ import { readConfig as readAppConfig, prepareConfig, writeUpdates, statePath, is
 export { readAppConfig, prepareConfig, writeUpdates, statePath, isUniversal };
 import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync, renameSync, } from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync, } from "node:fs";
 import path from "node:path";
-export const VERSION = "0.0.1-next.2";
-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);
-}
+import { readJson, writeJson } from "./json.js";
+export { readJson, writeJson };
+export const VERSION = "0.0.1-next.4";
 export function digest(value) {
     return createHash("sha256").update(value).digest("hex");
 }
@@ -38,13 +28,13 @@ export function entryFile(root) {
 }
 export function installedPackages(root) {
     const found = new Map();
-    const queue = [
-        { root, json: readJson(path.join(root, "package.json")), app: true },
-    ];
+    const manifest = readJson(path.join(root, "package.json"));
+    const appRequire = createRequire(path.join(root, "package.json"));
+    const queue = [{ root, json: manifest, app: true }];
     const visited = new Set();
     while (queue.length) {
         const current = queue.shift();
-        const req = createRequire(path.join(current.root, current.json.spark?.bundledModuleRoot ?? ".", "package.json"));
+        const contextualRequire = createRequire(path.join(current.root, current.json.spark?.bundledModuleRoot ?? ".", "package.json"));
         const bundled = current.json.spark?.bundledModules ?? current.json.bundledDependencies ?? current.json.bundleDependencies;
         const names = Object.keys({
             ...Object.fromEntries((Array.isArray(bundled) ? bundled : []).map(name => [name, true])),
@@ -57,6 +47,9 @@ export function installedPackages(root) {
                 .filter(([name]) => !current.json.peerDependenciesMeta?.[name]?.optional)),
         }).sort();
         for (const name of names) {
+            // Linked workspace packages resolve peers from their original checkout.
+            // Explicit app overrides must select the app's installed native copy.
+            const req = Object.hasOwn(manifest.overrides ?? {}, name) ? appRequire : contextualRequire;
             let file;
             try {
                 file = req.resolve(`${name}/package.json`);
@@ -64,11 +57,19 @@ export function installedPackages(root) {
             catch {
                 // Packages with exports hiding package.json still have an owning directory.
                 try {
-                    let dir = path.dirname(req.resolve(name));
-                    while ((!existsSync(path.join(dir, "package.json")) || typeof readJson(path.join(dir, "package.json")).name !== "string") &&
-                        dir !== path.dirname(dir))
-                        dir = path.dirname(dir);
-                    file = path.join(dir, "package.json");
+                    // Subpath-only packages (e.g. @legendapp/list/react-native) may
+                    // expose neither package.json nor a root entry. Inspect Node's
+                    // package search locations without requiring a public root export.
+                    const manifest = req.resolve.paths(name)?.map(base => path.join(base, name, "package.json"))
+                        .find(candidate => existsSync(candidate));
+                    if (manifest)
+                        file = manifest;
+                    else {
+                        let dir = path.dirname(req.resolve(name));
+                        while ((!existsSync(path.join(dir, "package.json")) || typeof readJson(path.join(dir, "package.json")).name !== "string") && dir !== path.dirname(dir))
+                            dir = path.dirname(dir);
+                        file = path.join(dir, "package.json");
+                    }
                 }
                 catch {
                     if (current.app &&
@@ -122,16 +123,31 @@ export function hashFiles(root, entries, windows = false) {
         visit(entry);
     return hash.digest("hex");
 }
-export function nativePackages(root) {
+export function nativePackages(root, { applyExcludes = true } = {}) {
+    prepareNativePatches(root);
     const installed = installedPackages(root);
     if (projectPlatform(root) === "windows")
         return windowsNativePackages(root, installed);
+    const excluded = ["app.json", "desktop.config.json"].some(file => existsSync(path.join(root, file)))
+        ? readAppConfig(root).expo?.autolinking?.exclude ?? [] : [];
+    if (!applyExcludes) {
+        const appRequire = createRequire(path.join(root, "package.json"));
+        for (const name of excluded) {
+            if (installed.some(pkg => pkg.name === name))
+                continue;
+            const file = appRequire.resolve.paths(name)?.map(base => path.join(base, name, "package.json")).find(file => existsSync(file));
+            if (!file)
+                continue;
+            const json = readJson(file);
+            installed.push({ name: json.name, root: realpathSync(path.dirname(file)), json });
+        }
+        installed.sort((a, b) => a.name.localeCompare(b.name));
+    }
     // Host/CNG code can change the native ABI without adding a TurboModule.
     // Fold it into the mandatory app module's compatibility signature for Go.
     const adapters = installed.filter(pkg => ["@legendapp/spark-desktop-host", "@legendapp/spark-desktop-config"].includes(pkg.name))
         .map(pkg => hashFiles(pkg.root, ["package.json", "AppDelegate.mm", ...readdirSync(pkg.root).filter(name => name.endsWith(".cjs"))])).join(":");
-    const excluded = isUniversal(root) ? readAppConfig(root).expo?.autolinking?.exclude ?? [] : [];
-    return installed.filter(pkg => !excluded.includes(pkg.name))
+    return installed.filter(pkg => !applyExcludes || !excluded.includes(pkg.name))
         .filter((pkg) => pkg.json.codegenConfig ||
         pkg.json.spark?.nativeModules ||
         readdirSync(pkg.root).some((name) => name.endsWith(".podspec") || name === "expo-module.config.json"))
@@ -168,12 +184,12 @@ export function dependencyStamp(root) {
         "react-native.config.js",
     ]);
 }
-export function selection(packages, used, include = []) {
+export function selection(packages, used, include = [], excluded = []) {
     const selected = new Set([
         ...packages.filter((p) => !p.sdk).map((p) => p.name),
         ...used,
         ...include,
-    ]);
+    ].filter(name => !excluded.includes(name)));
     const reasons = {};
     for (const pkg of packages)
         if (selected.has(pkg.name))
@@ -196,6 +212,8 @@ export function selection(packages, used, include = []) {
             for (const name of nativeDeps) {
                 if (!packages.some((p) => p.name === name))
                     throw new Error(`${pkg.name} requires missing native package ${name}`);
+                if (excluded.includes(name))
+                    continue;
                 if (!selected.has(name)) {
                     selected.add(name);
                     reasons[name] = `native dependency of ${pkg.name}`;
@@ -218,6 +236,43 @@ export function hostSourceSignature(root) {
         .filter(pkg => ["@legendapp/spark-desktop-host", "@legendapp/spark-desktop-config"].includes(pkg.name))
         .map(pkg => [pkg.name, hashFiles(pkg.root, ["package.json", "AppDelegate.mm", "windows", ...readdirSync(pkg.root).filter(file => file.endsWith(".cjs"))])])));
 }
+export function nativePreparationInputs(root, packages) {
+    return {
+        config: readAppConfig(root),
+        packages: packages.map((p) => [
+            p.name,
+            // CocoaPods records physical source paths, even for identical packages.
+            p.root,
+            hashFiles(p.root, [
+                "package.json",
+                p.json.codegenConfig?.jsSrcsDir ?? "src",
+                ...readdirSync(p.root).filter((name) => name.endsWith(".podspec")),
+            ]),
+        ]),
+        plugin: hostSourceSignature(root),
+    };
+}
+export function nativePreparationFingerprint(root, packages) {
+    return digest(JSON.stringify(nativePreparationInputs(root, packages)));
+}
+export function nativeProjectFingerprint(inputs, packages) {
+    return digest(JSON.stringify({
+        config: inputs.config,
+        plugin: inputs.plugin,
+        packages: packages.map(p => [p.name, p.root, hashFiles(p.root, ["package.json"])]),
+    }));
+}
+export function localSigningIdentity(root, mode) {
+    if (mode !== "dev")
+        return "-";
+    const file = stateFile(root, "settings.json");
+    const identity = existsSync(file) ? readJson(file).macOSDevelopmentIdentity : undefined;
+    if (identity === undefined)
+        return "-";
+    if (typeof identity !== "string" || !identity.trim() || identity.startsWith("-"))
+        throw new Error("macOSDevelopmentIdentity must name a signing certificate or its SHA-1 fingerprint");
+    return identity;
+}
 export function runtimeFor(root, packages, mode) {
     const platform = projectPlatform(root);
     const modules = Object.fromEntries(packages.map((p) => [p.name, p.signature]));
@@ -240,7 +295,10 @@ export function runtimeFor(root, packages, mode) {
         mode,
         modules,
         fingerprint: digest(JSON.stringify({
-            ...(platform === "windows" ? { arch: architecture(platform) } : {}),
+            arch: architecture(platform),
+            // Rebuild cached hosts generated before canonical plist restoration.
+            ...(platform === "macos" ? { nativeMetadataVersion: 1 } : {}),
+            ...(platform === "macos" && mode === "dev" ? { developmentIdentity: localSigningIdentity(root, mode) } : {}),
             ...(platform === "macos" && mode === "release" ? { releaseSettings: macOSReleaseSettings } : {}),
             modules,
             pins,
@@ -297,7 +355,7 @@ export function projectEnvironment(root) {
     if (typeof projectId !== "string" || !projectId.length || projectId.length > 200)
         throw new Error("Set extra.spark.projectId to a stable project identifier before launching the Spark Runner.");
     return {
-        SPARK_WINDOW_CONFIG: JSON.stringify(config.extra?.spark?.window ?? {}),
+        SPARK_WINDOW_CONFIG: JSON.stringify(nativeWindowOptions(config.extra?.spark?.window ?? {})),
         SPARK_PROJECT_ID: projectId,
         SPARK_PROJECT_NAME: typeof config.name === "string" ? config.name : path.basename(root),
         SPARK_PROJECT_VERSION: typeof config.version === "string" ? config.version : "0.0.0",

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

@@ -1,18 +1,22 @@
-import { existsSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from "node:fs";
 import path from "node:path";
-import { readJson, VERSION } from "./project.js";
+import { readJson } from "./json.js";
 import { localArchive } from "./package-manager.js";
+const VERSION = readJson(path.resolve(import.meta.dirname, "../package.json")).version;
 export const releaseBase = (version) => `https://github.com/LegendApp/legend-spark/releases/download/v${version}`;
 export function validateRelease(value) {
     if (value?.schema !== 1 || value.version !== VERSION || !/^[a-f0-9]{40}$/.test(value.revision) || !value.packages || !value.runners)
         throw new Error("Invalid or incompatible Spark release manifest");
+    if (Object.keys(value.packages).some(name => !/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/.test(name)))
+        throw new Error("Invalid Spark package name");
     for (const asset of [...Object.values(value.packages), ...Object.values(value.runners)]) {
         const url = new URL(asset.url);
         if (url.href !== asset.url || !/^[A-Za-z0-9._-]+$/.test(url.pathname.split("/").at(-1) ?? "") || !asset.url.startsWith(releaseBase(VERSION) + "/") || url.search || url.hash || !/^[a-f0-9]{64}$/.test(asset.sha256) || !Number.isSafeInteger(asset.size) || asset.size <= 0)
             throw new Error("Invalid Spark release asset");
     }
     for (const [target, asset] of Object.entries(value.runners)) {
-        if (target !== "macos-arm64" || path.basename(asset.app) !== asset.app || !asset.app.endsWith(".app") || !/^[A-Z0-9]{10}$/.test(asset.teamId) || !/^[a-f0-9]+$/.test(asset.fingerprint))
+        if (!["macos-arm64", "macos-x64"].includes(target) || path.basename(asset.app) !== asset.app || !asset.app.endsWith(".app") || !/^[A-Z0-9]{10}$/.test(asset.teamId) || !/^[a-f0-9]+$/.test(asset.fingerprint))
             throw new Error("Invalid Runner release target");
     }
     return value;
@@ -21,7 +25,7 @@ export function installedRelease() {
     const file = path.join(import.meta.dirname, "release.json");
     return existsSync(file) ? validateRelease(readJson(file)) : undefined;
 }
-/** Registry versions and immutable HTTPS archives survive project moves and clones. */
+/** Local SDK archives keep their manifest-relative paths; release archives become portable project-relative files. */
 export function packageSources(manifest, release = installedRelease()) {
     let sources;
     if (manifest) {
@@ -36,7 +40,84 @@ export function packageSources(manifest, release = installedRelease()) {
         if (!release)
             throw new Error("This SDK has no published release metadata. Pack or register a local SDK first.");
         validateRelease(release);
-        sources = { ...Object.fromEntries(Object.entries(release.packages).map(([name, asset]) => [name, asset.url])), "@legendapp/spark": VERSION };
+        sources = { ...Object.fromEntries(Object.entries(release.packages).map(([name, asset]) => [name, `file:./spark-packages/${packageArchiveName(name, asset)}`])), "@legendapp/spark": VERSION };
     }
     return sources;
 }
+function packageArchiveName(name, asset) {
+    return `${name.replace(/^@/, "").replaceAll("/", "-")}-${asset.sha256}.tgz`;
+}
+/** Download and verify release bytes before installing; relative vendored files survive moves and ordinary clones. */
+export async function materializeReleasePackages(release, projectRoot, fetcher = fetch) {
+    validateRelease(release);
+    const directory = path.join(projectRoot, "spark-packages");
+    mkdirSync(directory, { recursive: true });
+    const pending = Object.entries(release.packages).map(([name, asset]) => ({ name, asset, file: path.join(directory, packageArchiveName(name, asset)) }));
+    for (const { name, asset, file } of pending) {
+        if (!existsSync(file))
+            continue;
+        const bytes = readFileSync(file);
+        if (bytes.length !== asset.size || createHash("sha256").update(bytes).digest("hex") !== asset.sha256)
+            throw new Error(`Existing verified Spark package archive is corrupt: ${name}`);
+    }
+    for (const { name, asset, file } of pending) {
+        if (existsSync(file))
+            continue;
+        const response = await fetcher(asset.url, { signal: AbortSignal.timeout(120_000) });
+        if (!response.ok)
+            throw new Error(`Download Spark package ${name}: HTTP ${response.status}`);
+        const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+        const fd = openSync(temporary, "wx");
+        const hash = createHash("sha256");
+        let size = 0;
+        let open = true;
+        try {
+            if (!response.body)
+                throw new Error(`Download Spark package ${name}: response has no body`);
+            const reader = response.body.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    size += value.byteLength;
+                    if (size > asset.size) {
+                        await reader.cancel();
+                        throw new Error(`Spark package archive exceeds its declared size: ${name}`);
+                    }
+                    hash.update(value);
+                    let offset = 0;
+                    while (offset < value.byteLength)
+                        offset += writeSync(fd, value, offset, value.byteLength - offset);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            if (size !== asset.size || hash.digest("hex") !== asset.sha256)
+                throw new Error(`Spark package archive checksum or size mismatch: ${name}`);
+            closeSync(fd);
+            open = false;
+            renameSync(temporary, file);
+        }
+        catch (error) {
+            if (open)
+                closeSync(fd);
+            rmSync(temporary, { force: true });
+            throw error;
+        }
+    }
+}
+/** Recheck vendored bytes immediately before a package manager can run lifecycle scripts. */
+export function verifyMaterializedReleasePackages(release, projectRoot) {
+    validateRelease(release);
+    const directory = path.join(projectRoot, "spark-packages");
+    for (const [name, asset] of Object.entries(release.packages)) {
+        const file = path.join(directory, packageArchiveName(name, asset));
+        if (!existsSync(file))
+            throw new Error(`Verified Spark package archive is missing: ${name}`);
+        const bytes = readFileSync(file);
+        if (bytes.length !== asset.size || createHash("sha256").update(bytes).digest("hex") !== asset.sha256)
+            throw new Error(`Verified Spark package archive changed before installation: ${name}`);
+    }
+}

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

@@ -1,37 +1,42 @@
 {
   "schema": 1,
-  "version": "0.0.1-next.2",
-  "revision": "6359fee375c5b0549b43f339d4e856db4bcb7c98",
+  "version": "0.0.1-next.4",
+  "revision": "23bfaba5d57e9eda98422f1187fd65037ac11d01",
   "packages": {
     "@react-native-runtimes/core": {
-      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.2/runtimes-31ac67156c18.tgz",
-      "size": 53885,
-      "sha256": "a8e532d0a1e8d7c23953e94612d58f0e660a685e58645075c5180304c8462515"
+      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.4/runtimes-985164a87eb0.tgz",
+      "size": 53886,
+      "sha256": "138644fcfaf60b172c9f206c66c6d160515dd8803c70264687d0f503294c9c0b"
     },
     "react-native-nitro-modules": {
-      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.2/react-native-nitro-modules-0.35.7-7c494d2176d7.tgz",
-      "size": 138548,
-      "sha256": "7c494d2176d7f144ee5d518fd8c03b24f29c22bba520b7cebd71ba7d60cb56d3"
+      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.4/react-native-nitro-modules-0.37.0-56a36548e4e3.tgz",
+      "size": 145386,
+      "sha256": "56a36548e4e3236d3805dc75774a1c293034318d2825580c0b86d4079cce80ae"
     },
     "@op-engineering/op-sqlite": {
-      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.2/op-engineering-op-sqlite-18.2.1-ebd60a4eb0d4.tgz",
-      "size": 115455003,
-      "sha256": "ebd60a4eb0d4a0a2d48c7ca455cf3668879ff64a258bed108c2393d53679cf3c"
+      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.4/op-engineering-op-sqlite-18.2.1-809aacdae6a3.tgz",
+      "size": 112508531,
+      "sha256": "809aacdae6a375f1524022533800253ee89beb931cdb5ab02781acecfa53aeac"
     },
     "react-native-webview": {
-      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.2/react-native-webview-16.0.0-33882a035641.tgz",
-      "size": 116112,
-      "sha256": "33882a03564141b8b5c56cc7e99e0d425f3a53b59db966d9412bb85ef6f0abf3"
+      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.4/react-native-webview-16.0.0-bc2c08eb8de7.tgz",
+      "size": 116287,
+      "sha256": "bc2c08eb8de7b979d90a641ce63b3241c034f836c76c77b794716473b3b43216"
+    },
+    "expo-audio": {
+      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.4/expo-audio-1.1.1-c4ae56565c36.tgz",
+      "size": 381084,
+      "sha256": "c4ae56565c365086e134ab9edd15ce981a2149bda07d9e9553e151def5fe7fec"
     }
   },
   "runners": {
     "macos-arm64": {
-      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.2/spark-runner-macos-arm64.zip",
-      "size": 12455131,
-      "sha256": "77635060c84c536d67af10496e21a65fb57f279a7f165d362f1ca81829c95e69",
+      "url": "https://github.com/LegendApp/legend-spark/releases/download/v0.0.1-next.4/spark-runner-macos-arm64.zip",
+      "size": 17395353,
+      "sha256": "6334c66020c8ddd0ff3f6c154b8fb97e01ceb952a26254765b816bd6055dabb1",
       "app": "SparkRunner.app",
       "teamId": "56DD97VT22",
-      "fingerprint": "fef5859c9685b017d0132277f593c732512dec23b2c57bc6c53ce695e821406d"
+      "fingerprint": "64932dc5718a49253e5f76a9ae26c3553059893b1e0c6dcff7b05f86c2c787e2"
     }
   }
 }

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

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, ftruncateSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
 import { open } from "node:fs/promises";
 import path from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
@@ -9,6 +10,142 @@ import { architecture } from "./platform.js";
 import { VERSION } from "./project.js";
 import { installedRelease } from "./release.js";
 const defaults = { fetch: globalThis.fetch, run };
+function readLegacyPid(lock) {
+    try {
+        const content = readFileSync(lock, "utf8").trim();
+        if (/^\d+$/.test(content))
+            return Number(content);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return undefined;
+}
+/** The kernel releases this advisory lock if the installer exits, including on a crash. */
+export async function acquireRunnerLock(lock, waitMs = 600_000) {
+    const deadline = Date.now() + waitMs;
+    let child;
+    let exited;
+    while (true) {
+        if (Date.now() >= deadline)
+            throw new Error("Another process is installing Runner. Retry desktop launch when it finishes.");
+        const existingPid = readLegacyPid(lock);
+        if (existingPid) {
+            try {
+                process.kill(existingPid, 0);
+                if (Date.now() >= deadline)
+                    throw new Error("Another process is installing Runner. Retry desktop launch when it finishes.");
+                await sleep(Math.min(1000, deadline - Date.now()));
+                continue;
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    throw error;
+            }
+        }
+        const existed = existsSync(lock);
+        const observed = existed ? lstatSync(lock) : undefined;
+        const remaining = Math.max(1, deadline - Date.now());
+        child = spawn("/usr/bin/lockf", ["-k", "-t", String(Math.max(1, Math.ceil(remaining / 1000))), lock, process.execPath, "-e", "process.stdout.write('locked\\n'); process.stdin.resume()"], { detached: true, stdio: ["pipe", "pipe", "pipe"] });
+        let stderr = "";
+        child.stderr.setEncoding("utf8").on("data", chunk => { stderr += chunk; });
+        exited = new Promise(resolve => child.once("close", (code, signal) => resolve({ code, signal })));
+        try {
+            await new Promise((resolve, reject) => {
+                let output = "";
+                child.stdout.setEncoding("utf8").on("data", chunk => {
+                    output += chunk;
+                    if (output.includes("locked\n"))
+                        resolve();
+                });
+                child.once("error", reject);
+                void exited.then(({ code }) => reject(new Error(`Could not acquire Runner install lock${stderr ? `: ${stderr.trim()}` : ` (lockf exited ${code})`}`)));
+            });
+        }
+        catch (error) {
+            try {
+                process.kill(-child.pid, "SIGTERM");
+            }
+            catch { }
+            await exited;
+            throw error;
+        }
+        const stopKeeper = async () => { child.stdin.end(); await exited; };
+        let fd;
+        try {
+            const acquired = lstatSync(lock);
+            if (observed && (acquired.dev !== observed.dev || acquired.ino !== observed.ino)) {
+                await stopKeeper();
+                continue;
+            }
+            const content = readFileSync(lock, "utf8").trim();
+            const legacyPid = readLegacyPid(lock);
+            if (legacyPid) {
+                let legacyLive = false;
+                try {
+                    process.kill(legacyPid, 0);
+                    legacyLive = true;
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        throw error;
+                }
+                if (legacyLive) {
+                    await stopKeeper();
+                    if (Date.now() >= deadline)
+                        throw new Error("Another process is installing Runner. Retry desktop launch when it finishes.");
+                    await sleep(Math.min(1000, deadline - Date.now()));
+                    continue;
+                }
+            }
+            else if (!content && existed) {
+                const age = Date.now() - statSync(lock).mtimeMs;
+                if (age < 30_000) {
+                    await stopKeeper();
+                    if (Date.now() >= deadline)
+                        throw new Error("Another process is installing Runner. Retry desktop launch when it finishes.");
+                    await sleep(Math.min(1000, deadline - Date.now()));
+                    continue;
+                }
+            }
+            fd = openSync(lock, "r+");
+            ftruncateSync(fd, 0);
+            writeFileSync(fd, `v2:${process.pid}`);
+            closeSync(fd);
+            fd = undefined;
+            break;
+        }
+        catch (error) {
+            if (fd !== undefined) {
+                try {
+                    closeSync(fd);
+                }
+                catch { }
+            }
+            await stopKeeper();
+            throw error;
+        }
+    }
+    let released = false;
+    let releasePromise;
+    let unexpectedExit;
+    void exited.then(result => { if (!released)
+        unexpectedExit = result; });
+    const release = () => releasePromise ??= (async () => {
+        released = true;
+        child.stdin.end();
+        const result = await exited;
+        if (result.code !== 0)
+            throw new Error(`Runner install lock process exited unexpectedly (${result.signal ?? result.code}).`);
+    })();
+    return Object.assign(release, {
+        assertAlive() {
+            if (unexpectedExit)
+                throw new Error(`Runner install lock process exited unexpectedly (${unexpectedExit.signal ?? unexpectedExit.code}).`);
+        },
+    });
+}
 export async function downloadAsset(asset, file, request = globalThis.fetch) {
     for (let attempt = 0; attempt < 3; attempt++) {
         let handle;
@@ -50,7 +187,7 @@ export async function downloadAsset(asset, file, request = globalThis.fetch) {
 }
 async function verify(app, asset, deps) {
     const runtime = readRuntime(app);
-    if (!runtime || runtime.mode !== "go" || runtime.platform !== "macos" || runtime.arch !== "arm64" || runtime.fingerprint !== asset.fingerprint)
+    if (!runtime || runtime.mode !== "go" || runtime.platform !== "macos" || runtime.arch !== architecture("macos") || runtime.fingerprint !== asset.fingerprint)
         throw new Error("Downloaded Runner has incompatible runtime metadata");
     await deps.run(path.dirname(app), ["codesign", "--verify", "--deep", "--strict", app], { capture: true });
     const signature = await deps.run(path.dirname(app), ["codesign", "-dvvv", app], { capture: true });
@@ -65,32 +202,7 @@ export async function installRunner(asset, cache = sparkHome(), deps = defaults)
     const app = path.join(destination, asset.app);
     mkdirSync(parent, { recursive: true });
     const lock = `${destination}.lock`;
-    let owned = false;
-    for (let attempt = 0; !owned && attempt < 600; attempt++) {
-        try {
-            const fd = openSync(lock, "wx");
-            writeFileSync(fd, String(process.pid));
-            closeSync(fd);
-            owned = true;
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            const pid = Number(readFileSync(lock, "utf8"));
-            if (Number.isInteger(pid) && pid > 0) {
-                try {
-                    process.kill(pid, 0);
-                }
-                catch (probe) {
-                    if (probe.code === "ESRCH")
-                        rmSync(lock, { force: true });
-                }
-            }
-            await sleep(1000);
-        }
-    }
-    if (!owned)
-        throw new Error("Another process is installing Runner. Retry desktop launch when it finishes.");
+    const releaseLock = await acquireRunnerLock(lock);
     let staging;
     try {
         if (existsSync(app)) {
@@ -110,8 +222,10 @@ export async function installRunner(asset, cache = sparkHome(), deps = defaults)
             // Only publisher-pinned bytes reach the platform extractor.
             await deps.run(staging, ["ditto", "-x", "-k", archive, unpacked], { capture: true });
             await verify(path.join(unpacked, asset.app), asset, deps);
+            releaseLock.assertAlive();
             renameSync(unpacked, destination);
         }
+        releaseLock.assertAlive();
         registerRuntime(app);
         console.log("Spark Runner installed and verified.");
         return app;
@@ -119,7 +233,7 @@ export async function installRunner(asset, cache = sparkHome(), deps = defaults)
     finally {
         if (staging)
             rmSync(staging, { recursive: true, force: true });
-        rmSync(lock, { force: true });
+        await releaseLock();
     }
 }
 export async function acquireRunner(platform) {
@@ -130,8 +244,8 @@ export async function acquireRunner(platform) {
         const asset = release.runners[target];
         if (!asset)
             throw new Error(`This Spark release has no Runner for ${target}. Use a custom development build.`);
-        if (process.platform !== "darwin" || process.arch !== "arm64")
-            throw new Error("This release's Runner requires Apple Silicon macOS and arm64 Node.");
+        if (process.platform !== "darwin")
+            throw new Error("This release's macOS Runner requires macOS.");
         app = await installRunner(asset);
     }
     return app;