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

package/vendor/node_modules/@legendapp/spark-desktop-app/src/contracts/index.ts

@@ -0,0 +1,56 @@
+/** Contracts shared by Spark-owned APIs. This module never loads native code. */
+export type SparkErrorCode =
+  | "E_INVALID_ARGUMENT" | "E_INVALID_DATA" | "E_UNAVAILABLE" | "E_UNSUPPORTED_PLATFORM"
+  | "E_UNSUPPORTED_OPTION" | "E_MODULE_UNAVAILABLE" | "E_PERMISSION_DENIED"
+  | "E_NOT_FOUND" | "E_NOT_EMPTY" | "E_ALREADY_EXISTS" | "E_BUSY" | "E_CLOSED"
+  | "E_ABORTED" | "E_TIMEOUT" | "E_NATIVE";
+
+export class SparkError extends Error {
+  readonly code: SparkErrorCode;
+  constructor(code: SparkErrorCode, message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "SparkError";
+    this.code = code;
+  }
+}
+
+export type Availability =
+  | { available: true }
+  | { available: false; reason: "unsupported-platform" | "missing-module" | "host-restriction" };
+export interface Subscription { remove(): void }
+export interface AsyncRegistration { remove(): Promise<void> }
+
+/** Stop callbacks immediately; join concurrent cleanup, and permit retry on failure. */
+export function asyncRegistration(stop: () => void, cleanup: () => Promise<void>): AsyncRegistration {
+  let stopped = false;
+  let pending: Promise<void> | undefined;
+  return { remove() {
+    if (!stopped) { stopped = true; stop(); }
+    return pending ??= Promise.resolve().then(cleanup).catch(error => {
+      pending = undefined;
+      throw error;
+    });
+  } };
+}
+
+export function parseNativeResult<T>(json: string, validate: (value: unknown) => value is T): T {
+  let value: unknown;
+  try { value = JSON.parse(json); }
+  catch (cause) { throw new SparkError("E_INVALID_DATA", "Native response is not valid JSON", { cause }); }
+  if (!validate(value)) throw new SparkError("E_INVALID_DATA", "Native response does not match its contract");
+  return value;
+}
+
+/** Normalize errors added by Spark's native adapters, preserving the original failure. */
+export function nativeError(cause: unknown): SparkError {
+  if (cause instanceof SparkError) return cause;
+  const original = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
+  const aliases: Record<string, SparkErrorCode> = { E_PERMISSION: "E_PERMISSION_DENIED", E_EXISTS: "E_ALREADY_EXISTS" };
+  const known: readonly string[] = ["E_INVALID_ARGUMENT", "E_INVALID_DATA", "E_UNAVAILABLE", "E_UNSUPPORTED_PLATFORM", "E_UNSUPPORTED_OPTION", "E_MODULE_UNAVAILABLE", "E_PERMISSION_DENIED", "E_NOT_FOUND", "E_NOT_EMPTY", "E_ALREADY_EXISTS", "E_BUSY", "E_CLOSED", "E_ABORTED", "E_TIMEOUT", "E_NATIVE"];
+  const code = aliases[original] ?? (known.includes(original) ? original as SparkErrorCode : "E_NATIVE");
+  return new SparkError(code, cause instanceof Error ? cause.message : "Native operation failed", { cause });
+}
+export function invokeNative<T>(operation: () => T | Promise<T>): Promise<T> {
+  try { return Promise.resolve(operation()).catch(cause => { throw nativeError(cause); }); }
+  catch (cause) { return Promise.reject(nativeError(cause)); }
+}

package/vendor/node_modules/@legendapp/spark-desktop-app/src/contracts/menu.ts

@@ -0,0 +1,114 @@
+import { SparkError } from "./index";
+import { nativePath } from "./path";
+import { parseAccelerator, type Accelerator } from "./accelerator";
+export type MenuIcon = { type: "symbol"; name: string } | { type: "image"; path: string };
+export type MenuRole = "new" | "open" | "save" | "saveAs" | "clearRecentDocuments" | "about" | "settings" | "services" | "hide" | "hideOthers" | "showAll" | "quit" | "undo" | "redo" | "cut" | "copy" | "paste" | "selectAll" | "minimize" | "zoom" | "close" | "toggleFullscreen";
+export type MenuLocation = "app" | "file" | "edit" | "view" | "window" | "help";
+export type MenuTarget = { id: string } | { role: MenuRole } | { menu: MenuLocation };
+export type MenuPlacement = { before: MenuTarget; after?: never } | { after: MenuTarget; before?: never };
+interface MenuEntry { target?: MenuTarget; placement?: MenuPlacement; id: string; label: string; disabled?: boolean; hidden?: boolean; icon?: MenuIcon }
+export type MenuItem =
+  | { type: "separator" }
+  | (MenuEntry & { type: "action"; shortcut?: string })
+  | (MenuEntry & { type: "checkbox"; checked: boolean; shortcut?: string })
+  | (MenuEntry & { type: "submenu"; items: readonly MenuItem[] })
+  | (Omit<MenuEntry, "label"> & { type: "role"; role: MenuRole; label?: string; shortcut?: string })
+  | (MenuEntry & { type: "slider"; min: number; max: number; value: number; suffix?: string });
+export type MenuAction = { type: "action"; itemId: string } | { type: "valueChanged"; itemId: string; value: number };
+/** Internal recursive subset helper for feature surfaces that support fewer menu item arms. */
+export type MenuItemTree<Leaf extends Exclude<MenuItem, { type: "submenu" }>> = Leaf | (Omit<Extract<MenuItem, { type: "submenu" }>, "items"> & { items: readonly MenuItemTree<Leaf>[] });
+/** Internal transport shape; never reexported from feature entry points. */
+export interface MenuWireItem {
+  id?: string; title?: string; target?: MenuTarget; placement?: MenuPlacement; _sparkOwner?: string; _sparkIdentity?: string; enabled?: boolean; hidden?: boolean; checked?: boolean; separator?: boolean;
+  shortcut?: Accelerator; items?: MenuWireItem[]; role?: MenuRole;
+  systemImageName?: string; imagePath?: string; slider?: { min: number; max: number; value: number; suffix?: string };
+}
+export interface MenuSupport { types: readonly MenuItem["type"][]; shortcuts?: boolean; icons?: readonly MenuIcon["type"][]; targeting?: boolean }
+const roles: readonly string[] = ["new", "open", "save", "saveAs", "clearRecentDocuments", "about", "settings", "services", "hide", "hideOthers", "showAll", "quit", "undo", "redo", "cut", "copy", "paste", "selectAll", "minimize", "zoom", "close", "toggleFullscreen"];
+function keys(value: object, allowed: readonly string[]) {
+  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported menu property: ${key}`);
+}
+/** Validate and snapshot the complete tree before a native side effect. */
+export function menuItems(input: readonly MenuItem[], support: MenuSupport, platform: "macos" | "windows"): MenuWireItem[] {
+  const ids = new Set<string>();
+  const active = new Set<object>();
+  function visit(items: readonly MenuItem[], depth: number): MenuWireItem[] {
+    if (!Array.isArray(items) || depth > 5 || active.has(items)) throw new SparkError("E_INVALID_ARGUMENT", "Menus must be acyclic arrays with at most five levels");
+    active.add(items);
+    try {
+      return items.flatMap(item => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) throw new SparkError("E_INVALID_ARGUMENT", "Expected a menu item");
+        if (!support.types.includes(item.type)) throw new SparkError("E_UNSUPPORTED_OPTION", `This surface does not support menu item type: ${item.type}`);
+        if (item.type === "separator") { keys(item, ["type"]); return [{ separator: true }]; }
+        if (typeof item.id !== "string" || !item.id.length || item.id.length > 200 || item.id.includes("\0") || ids.has(item.id)) throw new SparkError("E_INVALID_ARGUMENT", "Menu item ids must be nonempty and unique");
+        ids.add(item.id);
+        const common = ["type", "id", "label", "disabled", "hidden", "icon", "target", "placement"];
+        keys(item, [...common, ...(item.type === "submenu" ? ["items"] : item.type === "slider" ? ["min", "max", "value", "suffix"] : item.type === "role" ? ["role", "shortcut"] : item.type === "checkbox" ? ["checked", "shortcut"] : ["shortcut"])]);
+        if ((item.type !== "role" || item.label !== undefined) && (typeof item.label !== "string" || !item.label.trim())) throw new SparkError("E_INVALID_ARGUMENT", "Menu items need a label");
+        if ([item.disabled, item.hidden].some(value => value !== undefined && typeof value !== "boolean")) throw new SparkError("E_INVALID_ARGUMENT", "Menu flags must be boolean");
+        const result: MenuWireItem = { id: item.id, title: item.label, enabled: !item.disabled };
+        if (item.target !== undefined || item.placement !== undefined) {
+          if (!support.targeting) throw new SparkError("E_UNSUPPORTED_OPTION", "This menu surface does not support targeting or placement");
+          if (item.target !== undefined) result.target = menuTarget(item.target);
+          if (item.placement !== undefined) {
+            if (!item.placement || typeof item.placement !== "object" || Array.isArray(item.placement)) throw new SparkError("E_INVALID_ARGUMENT", "Expected menu placement");
+            keys(item.placement, ["before", "after"]);
+            if ((item.placement.before !== undefined) === (item.placement.after !== undefined)) throw new SparkError("E_INVALID_ARGUMENT", "Placement requires exactly one of before or after");
+            result.placement = item.placement.before !== undefined ? { before: menuTarget(item.placement.before) } : { after: menuTarget(item.placement.after!) };
+          }
+        }
+        if (item.type === "checkbox") {
+          if (typeof item.checked !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Checkbox menus require checked state");
+          result.checked = item.checked;
+        }
+        if (item.type === "submenu") result.items = visit(item.items, depth + 1);
+        if (item.type === "role") {
+          if (!roles.includes(item.role)) throw new SparkError("E_INVALID_ARGUMENT", "Unknown menu role");
+          result.role = item.role;
+        }
+        if (item.type === "slider") {
+          if (![item.min, item.max, item.value].every(value => typeof value === "number" && Number.isFinite(value)) || item.min >= item.max || item.value < item.min || item.value > item.max || (item.suffix !== undefined && typeof item.suffix !== "string")) throw new SparkError("E_INVALID_ARGUMENT", "Invalid menu slider range/value");
+          result.slider = { min: item.min, max: item.max, value: item.value, suffix: item.suffix };
+        }
+        if ("shortcut" in item && item.shortcut !== undefined) {
+          if (!support.shortcuts) throw new SparkError("E_UNSUPPORTED_OPTION", "This menu surface does not support shortcuts");
+          result.shortcut = parseAccelerator(item.shortcut, platform);
+        }
+        if (item.icon !== undefined) {
+          if (!item.icon || !support.icons?.includes(item.icon.type)) throw new SparkError("E_UNSUPPORTED_OPTION", "This menu surface does not support this icon type");
+          if (item.icon.type === "symbol") {
+            keys(item.icon, ["type", "name"]);
+            if (typeof item.icon.name !== "string" || !item.icon.name.trim()) throw new SparkError("E_INVALID_ARGUMENT", "Expected a symbol name");
+            result.systemImageName = item.icon.name;
+          } else {
+            keys(item.icon, ["type", "path"]);
+            if (typeof item.icon.path !== "string" || !item.icon.path.length || item.icon.path.includes("\0")) throw new SparkError("E_INVALID_ARGUMENT", "Expected an image path");
+            result.imagePath = nativePath(item.icon.path, platform);
+          }
+        }
+        if (item.hidden && item.target) result.hidden = true;
+        return item.hidden && !item.target ? [] : [result];
+      });
+    } finally { active.delete(items); }
+  }
+  return visit(input, 1);
+}
+export function selectableMenuIds(items: readonly MenuWireItem[]): Set<string> {
+  const ids = new Set<string>();
+  function visit(items: readonly MenuWireItem[]) {
+    for (const item of items) {
+      if (!item.enabled || item.hidden) continue;
+      if (item.items) visit(item.items);
+      else if (item.id && !item.separator && !item.role && !item.slider) ids.add(item.id);
+    }
+  }
+  visit(items); return ids;
+}
+
+function menuTarget(value: MenuTarget): MenuTarget {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== 1) throw new SparkError("E_INVALID_ARGUMENT", "Expected one semantic menu target");
+  if ("id" in value && typeof value.id === "string" && value.id.length && value.id.length <= 200 && !value.id.includes("\0")) return { id: value.id };
+  if ("role" in value && roles.includes(value.role)) return { role: value.role };
+  if ("menu" in value && ["app", "file", "edit", "view", "window", "help"].includes(value.menu)) return { menu: value.menu };
+  throw new SparkError("E_INVALID_ARGUMENT", "Invalid semantic menu target");
+}

package/vendor/node_modules/@legendapp/spark-desktop-app/src/contracts/native-buffer.ts

@@ -0,0 +1,22 @@
+import { SparkError } from "../contracts";
+export type BinaryCall = (method: string, args: string, buffer?: ArrayBuffer, offset?: number, length?: number) => Promise<unknown>;
+type Module = { binaryCall?: BinaryCall; installBinary?: () => string | null | undefined };
+/** Native snapshots the specified view synchronously before enqueueing I/O. */
+export function callBinary(module: object, name: string, method: string, args: object, bytes?: Uint8Array): Promise<unknown> {
+  const native = module as Module;
+  let call = native.binaryCall;
+  if (!call) {
+    const globals = globalThis as unknown as Record<string, unknown>;
+    if (!globals[name]) {
+      const error = native.installBinary?.();
+      if (typeof error === "string") throw new SparkError("E_MODULE_UNAVAILABLE", error);
+    }
+    call = globals[name] as BinaryCall | undefined;
+  }
+  if (typeof call !== "function") throw new SparkError("E_MODULE_UNAVAILABLE", "Native binary transport is unavailable");
+  return call(method, JSON.stringify(args), bytes?.buffer as ArrayBuffer | undefined, bytes?.byteOffset, bytes?.byteLength);
+}
+export function nativeBytes(value: unknown, maximum = Number.MAX_SAFE_INTEGER): Uint8Array {
+  if (!(value instanceof ArrayBuffer) || value.byteLength > maximum) throw new SparkError("E_INVALID_DATA", "Invalid native byte buffer");
+  return new Uint8Array(value);
+}

package/vendor/node_modules/@legendapp/spark-desktop-app/src/contracts/path.ts

@@ -0,0 +1,24 @@
+import { SparkError } from "./index";
+/** Drive-qualified and UNC paths are absolute on Windows; C:foo and \foo are not. */
+export function absolutePath(path: string, platform: string) {
+  if (typeof path !== "string") throw new SparkError("E_INVALID_ARGUMENT", "Expected an absolute path or file URL");
+  const windows = /^(?:[a-z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+)/i.test(path);
+  if (path.includes("\0") ||
+      !(path.startsWith("file://") || (platform === "windows" ? windows : path.startsWith("/")))) {
+    throw new SparkError("E_INVALID_ARGUMENT", "Expected an absolute path or file URL");
+  }
+  return path;
+}
+
+/** Decode local file URLs once, preserving native absolute paths. */
+export function nativePath(path: string, platform: string): string {
+  absolutePath(path, platform);
+  if (!path.startsWith("file://")) return path;
+  try {
+    const url = new URL(path);
+    if ((url.hostname && url.hostname !== "localhost") || url.search || url.hash || url.username || url.password || url.port) throw new Error("Expected a local file URL without a query or fragment");
+    let decoded = decodeURIComponent(url.pathname);
+    if (platform === "windows") decoded = decoded.replace(/^\/(?=[a-z]:)/i, "").replaceAll("/", "\\");
+    return absolutePath(decoded, platform);
+  } catch (cause) { throw new SparkError("E_INVALID_ARGUMENT", "Expected a native absolute path or local file URL", { cause }); }
+}

package/vendor/node_modules/@legendapp/spark-desktop-app/src/events.ts

@@ -0,0 +1,75 @@
+import { NativeEventEmitter, TurboModuleRegistry } from "react-native";
+import type { Spec } from "./NativeDesktopApp";
+import { SparkError, type Subscription } from "./contracts";
+/** Internal bridge transport. Feature modules validate their own event payloads. */
+export type DesktopEvent = { type: string; id?: string; url?: string; windowId?: string; bytes?: ArrayBuffer; [key: string]: unknown };
+export interface DesktopEventFilter { types: readonly string[]; target?: { field: string; value: string } }
+type Entry = { active: boolean; listener: (event: DesktopEvent) => void };
+type Bucket = { count: number; listeners: Entry[]; targets: Map<string, Map<string, Entry[]>> };
+type Hub = { count: number; buckets: Map<string, Bucket>; subscription: Subscription };
+const hubs = new WeakMap<Spec, Hub>();
+function deliver(listeners: readonly Entry[], event: DesktopEvent) {
+  // Arrays are replaced on registration, so dispatch needs no per-event snapshot.
+  // One throwing subscriber must not starve the rest of the bucket or escape into the native emitter.
+  for (const entry of listeners) {
+    if (!entry.active) continue;
+    try { entry.listener(event); }
+    catch (cause) { console.error(new SparkError("E_NATIVE", "Desktop event listener failed", { cause })); }
+  }
+}
+function route(bucket: Bucket | undefined, event: DesktopEvent) {
+  if (!bucket) return;
+  deliver(bucket.listeners, event);
+  for (const [field, targets] of bucket.targets) {
+    const value = event[field];
+    const listeners = typeof value === "string" ? targets.get(value) : undefined;
+    if (listeners) deliver(listeners, event);
+  }
+}
+function dispatch(hub: Hub, event: DesktopEvent) {
+  route(hub.buckets.get(event.type), event);
+  if (event.type !== "*") route(hub.buckets.get("*"), event);
+}
+/** Route once by native event type/resource instead of waking every feature listener. */
+export function onDesktopEvent(listener: (event: DesktopEvent) => void, filter?: DesktopEventFilter): Subscription {
+  const native = TurboModuleRegistry.get<Spec>("NativeDesktopApp");
+  if (!native) throw new SparkError("E_MODULE_UNAVAILABLE", "Desktop event module is unavailable");
+  let hub = hubs.get(native);
+  if (!hub) {
+    const created: Hub = { count: 0, buckets: new Map(), subscription: undefined! };
+    created.subscription = new NativeEventEmitter(native).addListener("desktop", (event: unknown) => {
+      if (event && typeof event === "object" && typeof (event as DesktopEvent).type === "string") dispatch(created, event as DesktopEvent);
+    });
+    hubs.set(native, created); hub = created;
+  }
+  const owner = hub, entry: Entry = { active: true, listener };
+  const types = filter ? [...new Set(filter.types)] : ["*"];
+  const target = filter?.target ? { ...filter.target } : undefined;
+  owner.count++;
+  for (const type of types) {
+    const bucket = owner.buckets.get(type) ?? { count: 0, listeners: [], targets: new Map() };
+    owner.buckets.set(type, bucket); bucket.count++;
+    if (!target) bucket.listeners = [...bucket.listeners, entry];
+    else {
+      const values = bucket.targets.get(target.field) ?? new Map<string, Entry[]>();
+      bucket.targets.set(target.field, values);
+      values.set(target.value, [...(values.get(target.value) ?? []), entry]);
+    }
+  }
+  return { remove() {
+    if (!entry.active) return;
+    entry.active = false;
+    for (const type of types) {
+      const bucket = owner.buckets.get(type)!;
+      if (!target) bucket.listeners = bucket.listeners.filter(value => value !== entry);
+      else {
+        const values = bucket.targets.get(target.field)!;
+        const remaining = values.get(target.value)!.filter(value => value !== entry);
+        if (remaining.length) values.set(target.value, remaining); else values.delete(target.value);
+        if (!values.size) bucket.targets.delete(target.field);
+      }
+      if (--bucket.count === 0) owner.buckets.delete(type);
+    }
+    if (--owner.count === 0) { owner.subscription.remove(); hubs.delete(native); }
+  } };
+}

package/vendor/node_modules/@legendapp/spark-desktop-app/src/index.ts

@@ -1 +1,3 @@
 export * from "./api";
+
+export { finishWindowRestoration } from "./restoration";

package/vendor/node_modules/@legendapp/spark-desktop-app/src/index.windows.ts

@@ -1 +1,3 @@
 export * from "./api";
+
+export { finishWindowRestoration } from "./restoration";

package/vendor/node_modules/@legendapp/spark-desktop-app/src/open-requests.ts

@@ -0,0 +1,43 @@
+import { Platform } from "react-native";
+import { SparkError, type Subscription } from "./contracts";
+import { nativePath } from "./contracts/path";
+import { onDesktopEvent } from "./events";
+import { callAppNative } from "./transport";
+export type OpenRequest = { type: "file"; id: string; path: string } | { type: "url"; id: string; url: string };
+function request(value: unknown): OpenRequest {
+  if (!value || typeof value !== "object") throw new SparkError("E_INVALID_DATA", "Invalid native open request");
+  const event = value as { type?: unknown; id?: unknown; url?: unknown };
+  if (typeof event.id !== "string" || !event.id || typeof event.url !== "string" || !/^[a-z][a-z0-9+.-]*:/i.test(event.url) || event.url.includes("\0")) throw new SparkError("E_INVALID_DATA", "Invalid native open request");
+  if (event.type === "openURL") return { type: "url", id: event.id, url: event.url };
+  if (event.type === "openFile" && event.url.startsWith("file://")) {
+    try { return { type: "file", id: event.id, path: nativePath(event.url, Platform.OS) }; }
+    catch (cause) { throw new SparkError("E_INVALID_DATA", "Invalid file-open URL", { cause }); }
+  }
+  throw new SparkError("E_INVALID_DATA", "Invalid native open request type");
+}
+/** Each subscription replays retained launch requests, deduplicating concurrent live delivery. */
+export async function subscribeToOpenRequests(listener: (event: OpenRequest) => void): Promise<Subscription> {
+  if (typeof listener !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected open-request listener");
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") throw new SparkError("E_UNSUPPORTED_PLATFORM", "Desktop open requests require a desktop host");
+  const seen = new Set<string>(); let removed = false, replaying = true;
+  function prune() { while (seen.size > 200) seen.delete(seen.values().next().value!); }
+  function deliver(event: OpenRequest) {
+    if (removed || seen.has(event.id)) return;
+    seen.add(event.id); if (!replaying) prune();
+    // A listener that throws must not abort the launch-queue replay for the rest of the batch.
+    try { listener(event); } catch (cause) { console.error(new SparkError("E_NATIVE", "Open request listener failed", { cause })); }
+  }
+  const subscription = onDesktopEvent(event => {
+    if (event.type !== "openURL" && event.type !== "openFile") return;
+    let value: OpenRequest;
+    try { value = request(event); } catch { return; }
+    deliver(value);
+  }, { types: ["openURL", "openFile"] });
+  try {
+    const values = await callAppNative("pendingURLs", (value): value is unknown[] => Array.isArray(value));
+    const requests = values.map(request);
+    for (const event of requests) deliver(event);
+    replaying = false; prune();
+  } catch (error) { removed = true; subscription.remove(); throw error; }
+  return { remove() { if (!removed) { removed = true; subscription.remove(); } } };
+}

package/vendor/node_modules/@legendapp/spark-desktop-app/src/restoration.ts

@@ -0,0 +1,11 @@
+import { Platform, TurboModuleRegistry, type TurboModule } from "react-native";
+interface RestorationNative extends TurboModule { finishWindowRestoration(): Promise<string> }
+import { SparkError, invokeNative, parseNativeResult } from "./contracts";
+/** Call after application restoration to discard startup shells no document adopted. */
+export async function finishWindowRestoration(): Promise<void> {
+  if (Platform.OS !== "macos") throw new SparkError("E_UNSUPPORTED_PLATFORM", "Native window-shell restoration requires macOS");
+  const native = TurboModuleRegistry.get<RestorationNative>("NativeWindowManager");
+  if (!native) throw new SparkError("E_MODULE_UNAVAILABLE", "Native window restoration is unavailable");
+  const result = parseNativeResult(await invokeNative(() => native.finishWindowRestoration()), (value): value is { success: boolean } => !!value && typeof value === "object" && typeof (value as any).success === "boolean");
+  if (!result.success) throw new SparkError("E_NATIVE", "Could not finish native window restoration");
+}

package/vendor/node_modules/@legendapp/spark-desktop-app/src/transport.ts

@@ -0,0 +1,10 @@
+import { Platform, TurboModuleRegistry } from "react-native";
+import type { Spec } from "./NativeDesktopApp";
+import { SparkError, invokeNative, parseNativeResult } from "./contracts";
+/** Internal native transport; each feature supplies its own response validator. */
+export async function callAppNative<T>(method: string, validate: (value: unknown) => value is T, args: object = {}): Promise<T> {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") throw new SparkError("E_UNSUPPORTED_PLATFORM", "Desktop application APIs require a desktop host");
+  const native = TurboModuleRegistry.get<Spec>("NativeDesktopApp");
+  if (!native) throw new SparkError("E_MODULE_UNAVAILABLE", "Desktop application module is unavailable");
+  return parseNativeResult(await invokeNative(() => native.call(method, JSON.stringify(args))), validate);
+}

package/vendor/node_modules/@legendapp/spark-desktop-config/app.plugin.cjs

@@ -9,6 +9,7 @@ const {
 } = require("expo-desktop-config-plugins");
 const { identity } = require("./identity.cjs");
 const { resolveEntitlements } = require("./entitlements.cjs");
+const { version: sparkVersion } = require("@legendapp/spark/package.json");
 
 module.exports = function withSparkDesktop(config) {
   if (config.platforms?.length === 1 && config.platforms[0] === "windows") return require("./windows.plugin.cjs")(config);
@@ -27,10 +28,7 @@ module.exports = function withSparkDesktop(config) {
   });
   config = withAppDelegate(config, (mod) => {
     // Own this adapter; application customizations belong in configuration/plugins.
-    mod.modResults.contents = fs.readFileSync(
-      require.resolve("@legendapp/spark-desktop-host/AppDelegate.mm"),
-      "utf8",
-    );
+    mod.modResults.contents = fs.readFileSync(require.resolve("@legendapp/spark-desktop-host/AppDelegate.mm"), "utf8");
     return mod;
   });
   config = withInfoPlist(config, (mod) => {
@@ -38,11 +36,12 @@ module.exports = function withSparkDesktop(config) {
     for (const key of ["SUFeedURL", "SUPublicEDKey", "SUEnableAutomaticChecks", "SUAutomaticallyUpdate", "SUAllowsAutomaticUpdates", "SUEnableSystemProfiling", "SURequireSignedFeed", "SUVerifyUpdateBeforeExtraction"])
       if (!(key in generated)) delete mod.modResults[key];
     Object.assign(mod.modResults, generated);
-    mod.modResults.SparkFrameworkVersion = "0.1.0-prototype.0";
+    mod.modResults.SparkFrameworkVersion = sparkVersion;
     mod.modResults.NSAppTransportSecurity = { NSAllowsLocalNetworking: true };
     return mod;
   });
   return withPodfile(config, (mod) => {
+    require("./autolinking.cjs").installAutolinkingPatch(mod.modRequest.projectRoot);
     require("./fabric-lifecycle.cjs").installSurfaceLifecyclePatch(mod.modRequest.projectRoot);
     require("./keyboard-events.cjs").installKeyboardEventsPatch(mod.modRequest.projectRoot);
     // The beta template passes the resolved package to use_react_native!, but
@@ -51,6 +50,12 @@ module.exports = function withSparkDesktop(config) {
       "react_native_post_install(installer)",
       'react_native_post_install(installer, "#{config[:reactNativePath]}-macos")',
     );
+    // Bun/pnpm may resolve RN and RN macOS into different physical directories.
+    // Appending "-macos" to RN's resolved path is only valid for flat installs.
+    const macOSPath = JSON.stringify(path.relative(path.join(mod.modRequest.projectRoot, "macos"), path.dirname(require.resolve("react-native-macos/package.json", {
+      paths: [mod.modRequest.projectRoot],
+    })))).replace(/#\{/g, "\\#{");
+    mod.modResults.contents = mod.modResults.contents.replaceAll('"#{config[:reactNativePath]}-macos"', macOSPath);
     const selectionFile = statePath(mod.modRequest.projectRoot, "native-selection.json", "macos");
     const included = fs.existsSync(selectionFile) ? JSON.parse(fs.readFileSync(selectionFile, "utf8")).included : [];
     const updatePackage = included.find(pkg => pkg.name === "@legendapp/spark-updates");

package/vendor/node_modules/@legendapp/spark-desktop-config/app.plugin.d.cts

@@ -0,0 +1,3 @@
+import type { ConfigPlugin } from "@expo/config-plugins";
+declare const withSparkDesktop: ConfigPlugin;
+export = withSparkDesktop;

package/vendor/node_modules/@legendapp/spark-desktop-config/autolinking.cjs

@@ -0,0 +1,35 @@
+// Expo 54's file scanner ignores Bun file: dependencies' symlinked podspecs.
+const fs = require("node:fs");
+const path = require("node:path");
+const before = `        return (await fs_1.default.promises.readdir(targetPath, { withFileTypes: true }))
+            .filter((entry) => entry.isFile() && filter(entry.name))`;
+const after = `        const entries = await fs_1.default.promises.readdir(targetPath, { withFileTypes: true });
+        const files = await Promise.all(entries.map(async (entry) => {
+            if (!filter(entry.name)) return null;
+            if (entry.isFile()) return entry;
+            if (!entry.isSymbolicLink()) return null;
+            const stat = await fs_1.default.promises.stat(path_1.default.join(targetPath, entry.name)).catch(() => null);
+            return stat?.isFile() ? entry : null;
+        }));
+        return files
+            .filter((entry) => entry !== null)`;
+function patchAutolinkingSource(source) {
+  if (source.includes(after) && !source.includes(before)) return source;
+  if (source.split(before).length !== 2 || source.includes(after))
+    throw new Error("Expo autolinking source changed; review the symlink compatibility patch before building.");
+  return source.replace(before, after);
+}
+function installAutolinkingPatch(root) {
+  const manifest = require.resolve("expo-modules-autolinking/package.json", { paths: [root] });
+  const version = JSON.parse(fs.readFileSync(manifest, "utf8")).version;
+  if (version !== "3.0.27") throw new Error(`spark's autolinking patch requires expo-modules-autolinking@3.0.27; found ${version}.`);
+  const file = path.join(path.dirname(manifest), "build/utils.js");
+  const source = fs.readFileSync(file, "utf8");
+  const patched = patchAutolinkingSource(source);
+  if (source !== patched) {
+    const temporary = `${file}.spark-${process.pid}.tmp`;
+    fs.writeFileSync(temporary, patched);
+    fs.renameSync(temporary, file); // Do not modify package-cache hardlinks.
+  }
+}
+module.exports = { patchAutolinkingSource, installAutolinkingPatch };

package/vendor/node_modules/@legendapp/spark-desktop-config/config.cjs

@@ -1,3 +1,4 @@
+const { validateOwned, validatePlatforms } = require("./validation.cjs");
 const fs = require("node:fs");
 const path = require("node:path");
 const { createHash } = require("node:crypto");
@@ -20,6 +21,7 @@ function statePath(root, name, target = process.env.SPARK_PLATFORM) {
   return path.join(root, ".spark", "platforms", target, name);
 }
 function selectTarget(platforms, target) {
+  validatePlatforms(platforms);
   const selected = target ?? (platforms.includes(process.platform === "win32" ? "windows" : "macos") ? (process.platform === "win32" ? "windows" : "macos") : platforms[0]);
   if (!platforms.includes(selected)) throw new Error(`Platform ${selected} is not supported by this project`);
   return selected;
@@ -46,7 +48,11 @@ function readConfig(root, target = process.env.SPARK_PLATFORM) {
       if (previous === undefined) delete process.env.SPARK_PLATFORM; else process.env.SPARK_PLATFORM = previous;
     }
   }
-  if (!fs.existsSync(file)) return JSON.parse(fs.readFileSync(path.join(root, "app.json"), "utf8"));
+  if (!fs.existsSync(file)) {
+    const value = JSON.parse(fs.readFileSync(path.join(root, "app.json"), "utf8"));
+    if (!value?.expo || typeof value.expo !== "object" || Array.isArray(value.expo)) throw new Error("app.json needs an expo configuration object");
+    return { ...value, expo: { ...value.expo, platforms: validatePlatforms(value.expo.platforms ?? ["macos"]) } };
+  }
   const result = toExpo(JSON.parse(fs.readFileSync(file, "utf8")), target);
   return result;
 }
@@ -85,7 +91,8 @@ function toExpo(value, target) {
   for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new Error(`Unknown desktop configuration field: ${key}`);
   for (const key of ["name", "projectId", "version"]) if (typeof value[key] !== "string" || !value[key].trim()) throw new Error(`Desktop config needs ${key}`);
   const platforms = value.platforms ?? ["macos"];
-  if (!Array.isArray(platforms) || !platforms.length || new Set(platforms).size !== platforms.length || platforms.some(p => !["macos", "windows", "ios", "android", "web"].includes(p))) throw new Error("platforms must list unique supported targets: macos, windows, ios, android, web");
+  validatePlatforms(platforms);
+  validateOwned(value);
   const selected = selectTarget(platforms, target);
   if (platforms.includes("macos") && (!value.macos || typeof value.macos.bundleIdentifier !== "string" || !/^[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+$/.test(value.macos.bundleIdentifier))) throw new Error("macos.bundleIdentifier must be a reverse-DNS identifier");
   validateWindow(value.window ?? {});
@@ -110,7 +117,12 @@ function toExpo(value, target) {
     windows: backend.windows ?? { namespace: "DesktopApp", displayName: value.name, packageGuid: guid, projectGuid: guid },
     plugins: [...(["macos", "windows"].includes(selected) ? ["@legendapp/spark/config-plugin"] : []), ...(backend.plugins ?? []).filter(p => (Array.isArray(p) ? p[0] : p) !== "@legendapp/spark-desktop-config" && (Array.isArray(p) ? p[0] : p) !== "@legendapp/spark/config-plugin")],
   };
-  identity(config);
+  const nativeIdentity = identity(config);
+  // Materialize the framework-owned associations before Expo's base mods run.
+  // This also avoids the desktop backend's broken array-valued scheme coercion.
+  if (selected === "macos" && nativeIdentity.CFBundleURLTypes) {
+    config.macos.infoPlist.CFBundleURLTypes = nativeIdentity.CFBundleURLTypes;
+  }
   return { expo: config };
 }
 function merge(base, override) {
@@ -146,6 +158,7 @@ function prepareConfig(root) {
   return result;
 }
 function writeUpdates(root, updates) {
+  require("./updates.cjs").updateConfiguration({ extra: { spark: { updates } } });
   const file = path.join(root, filename);
   if (fs.existsSync(file)) {
     const value = JSON.parse(fs.readFileSync(file, "utf8")); value.updates = updates;

package/vendor/node_modules/@legendapp/spark-desktop-config/config.d.cts

@@ -1,13 +1,93 @@
-export function readConfig(root: string, target?: string): any;
-export function prepareConfig(root: string): any;
-export function toExpo(value: unknown, target?: string): any;
-export function writeUpdates(root: string, updates: unknown): void;
-
+import type { ExpoConfig } from "@expo/config-types";
+import type { WindowConfiguration } from "@legendapp/spark-window-options";
+export type { WindowConfiguration } from "@legendapp/spark-window-options";
+export type SparkPlatform = "macos" | "windows" | "ios" | "android" | "web";
+export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+export interface UpdateConfiguration { feedURL: string; publicKey: string }
+export interface DocumentType { name: string; contentTypes: string[]; role?: "Editor" | "Viewer" }
+export type HelperTarget = "macos-arm64" | "macos-x64" | "windows-arm64" | "windows-x64";
+export type HelperConfiguration = string | Partial<Record<HelperTarget, { directory: string; executable: string }>>;
+export interface MacOSConfiguration {
+  bundleIdentifier: string;
+  buildNumber?: string;
+  infoPlist?: Record<string, JsonValue>;
+  entitlements?: Record<string, JsonValue>;
+  lifecycle?: MacOSLifecycle;
+}
+export interface SigningConfiguration {
+  macos?: { identity?: string; teamId?: string; entitlementsByPath?: Record<string, Record<string, JsonValue>> };
+}
+/** Spark-owned settings carried inside Expo's extra.spark. */
+export interface SparkSettings {
+  projectId: string;
+  window?: WindowConfiguration;
+  documentTypes?: DocumentType[];
+  menuBarOnly?: boolean;
+  updates?: UpdateConfiguration;
+  include?: string[];
+  signing?: SigningConfiguration;
+  helpers?: Record<string, HelperConfiguration>;
+  supportedPlatforms?: SparkPlatform[];
+}
+/** Expo retains ownership of its configuration; Spark only adds desktop fields. */
+export type ExpoOverrides = Partial<Omit<ExpoConfig, "platforms" | "extra">> & {
+  platforms?: SparkPlatform[];
+  extra?: Record<string, unknown>;
+  macos?: MacOSConfiguration;
+  windows?: { namespace?: string; displayName?: string; packageGuid?: string; projectGuid?: string; [key: string]: unknown };
+  autolinking?: { exclude?: string[]; [key: string]: unknown };
+};
+export interface SparkApplicationConfig extends Omit<SparkSettings, "supportedPlatforms"> {
+  $schema?: string;
+  name: string;
+  version: string;
+  extends?: never;
+  platforms?: SparkPlatform[];
+  macos?: MacOSConfiguration;
+  scheme?: string | string[];
+  expo?: ExpoOverrides;
+  expoByPlatform?: Partial<Record<SparkPlatform, ExpoOverrides>>;
+}
+export type SparkExpoProjectConfig = Omit<SparkApplicationConfig, "extends" | "name" | "version" | "platforms"> & {
+  extends: "expo";
+  name?: string;
+  version?: string;
+  platforms: SparkPlatform[];
+};
+export type SparkConfig = SparkApplicationConfig | SparkExpoProjectConfig;
+export type ResolvedExpoConfig = Omit<ExpoOverrides, "platforms" | "extra"> & {
+  platforms: SparkPlatform[];
+  extra?: Record<string, unknown> & { spark?: SparkSettings };
+};
+export interface ResolvedConfig { expo: ResolvedExpoConfig }
+export type GeneratedExpoConfig = ResolvedExpoConfig & { name: string; slug: string; version: string; extra: Record<string, unknown> & { spark: SparkSettings } };
+export function readConfig(root: string, target?: string): ResolvedConfig;
+export function prepareConfig(root: string): ResolvedConfig;
+/** Accepts untrusted JSON; validates Spark-owned settings before returning Expo configuration. */
+export function toExpo(value: unknown, target?: string): { expo: GeneratedExpoConfig };
+export function writeUpdates(root: string, updates: UpdateConfiguration): void;
 export function isUniversal(root: string): boolean;
 export function isExpoProject(root: string): boolean;
 export function statePath(root: string, name: string, target?: string): string;
-export function selectTarget(platforms: string[], target?: string): string;
-export function expoConfig(root: string): any;
+export function selectTarget(platforms: readonly string[], target?: string): SparkPlatform;
+export function expoConfig(root: string): ResolvedExpoConfig;
+export function supportedPlatforms(root: string): SparkPlatform[];
+export function developmentConfig(value: unknown, target?: string): GeneratedExpoConfig;
+export function applySelection(root: string, expo: ResolvedExpoConfig): ResolvedExpoConfig;
 
-export function supportedPlatforms(root: string): string[];
-export function developmentConfig(value: any, target?: string): any;
+/** macOS native startup policy. Omitted fields keep Spark's normal host behavior. */
+export type MacOSLifecycle = {
+  appearance?: "system" | "light" | "dark";
+  /** Linked NSObject classes conforming to SparkStartupPlugin. No automatic discovery. */
+  plugins?: string[];
+  mainWindow?: {
+    hidden?: boolean;
+    glass?: boolean;
+    autosaveName?: string;
+    backgroundColors?: { light: string; dark: string };
+    closeBehavior?: "close" | "hide" | "request";
+    reopenBehavior?: "default" | "manual" | "visibleWindows";
+    toolbarStyle?: "unified" | "expanded";
+    titlebarSeparatorStyle?: "automatic" | "none" | "line" | "shadow";
+  };
+};

package/vendor/node_modules/@legendapp/spark-desktop-config/expo.d.cts

@@ -0,0 +1,3 @@
+import type { ExpoOverrides } from "./config.cjs";
+/** Compose Spark's desktop overlay without replacing Expo's configuration model. */
+export function withSparkExpo<Context>(original: ExpoOverrides | ((context: Context) => ExpoOverrides), root: string): (context: Context) => ExpoOverrides;