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

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

@@ -0,0 +1,140 @@
+import type { MenuAction } from "@legendapp/spark-desktop-app/src/contracts/menu";
+export type { MenuAction } from "@legendapp/spark-desktop-app/src/contracts/menu";
+export type WindowId = string;
+export type DisplayId = string;
+export interface Size { width: number; height: number }
+/** Pointer position in logical units relative to the containing display's top-left corner. */
+export interface CursorPoint { displayId: DisplayId; x: number; y: number }
+/** Outer frame in logical units from the identified display's top-left corner. */
+export interface WindowBounds extends Size { displayId: DisplayId; x: number; y: number }
+export interface DisplayInfo {
+  id: DisplayId;
+  persistentId: string | null;
+  name: string;
+  primary: boolean;
+  size: Size;
+  workArea: { x: number; y: number; width: number; height: number };
+  scaleFactor: number;
+}
+export type WindowKind =
+  | { kind?: "window"; parentId?: WindowId; modal?: false }
+  | { kind: "window"; parentId: WindowId; modal: true }
+  | { kind: "overlay"; parentId?: WindowId; modal?: never };
+export interface WindowAppearanceOptions {
+  title?: string;
+  appearance?: "system" | "light" | "dark";
+  titleBarStyle?: "default" | "overlay" | "hidden" | "borderless";
+  backgroundColor?: string;
+  transparent?: boolean;
+  hasShadow?: boolean;
+  alwaysOnTop?: boolean;
+  resizable?: boolean;
+  closable?: boolean;
+  minimizable?: boolean;
+  /** Null clears this constraint back to the supported 100–20000 logical-unit range. */
+  minSize?: Size | null;
+  maxSize?: Size | null;
+}
+export type WindowOpenOptions = WindowKind & WindowAppearanceOptions & {
+  id: WindowId;
+  component: string;
+  props?: Record<string, unknown>;
+  size?: Size;
+  position?: { displayId: DisplayId; x: number; y: number };
+  show?: boolean;
+  restoreBounds?: boolean;
+  macos?: MacOSWindowOptions;
+};
+export interface WindowUpdateOptions extends WindowAppearanceOptions { macos?: MacOSWindowUpdateOptions }
+export interface WindowInfo {
+  id: WindowId;
+  kind: "window" | "overlay";
+  title: string;
+  parentId: WindowId | null;
+  modal: boolean;
+  visible: boolean;
+  focused: boolean;
+  minimized: boolean;
+  maximized: boolean;
+  fullscreen: boolean;
+  bounds: WindowBounds;
+}
+export type CloseResult = { closed: true } | { closed: false; reason: "vetoed" };
+export interface ShowWindowOptions { focus?: boolean }
+export interface CenterWindowOptions { displayId?: DisplayId }
+export interface WindowEventMap {
+  focusChanged: { windowId: WindowId; focused: boolean };
+  boundsChanged: { windowId: WindowId; bounds: WindowBounds };
+  visibilityChanged: { windowId: WindowId; visible: boolean };
+  fullscreenChanged: { windowId: WindowId; fullscreen: boolean };
+  closed: { windowId: WindowId };
+}
+export interface MacOSTitleBarControl {
+  id: string;
+  label?: string;
+  placement?: "left" | "right";
+  disabled?: boolean;
+  selected?: boolean;
+  symbol?: string;
+  tooltip?: string;
+}
+export interface MacOSTitleBarOptions {
+  contentLayout?: "contentLayoutGuide" | "fullSize";
+  transparent?: boolean;
+  titleVisibility?: "visible" | "hidden";
+  separator?: "automatic" | "none" | "line" | "shadow";
+  material?: "none" | "glass" | "titlebar" | "headerView" | "hudWindow" | "sidebar" | "windowBackground";
+  blendingMode?: "behindWindow" | "withinWindow";
+  materialState?: "active" | "inactive" | "followsWindowActiveState";
+  trafficLights?: boolean;
+  controls?: readonly MacOSTitleBarControl[];
+}
+export interface MacOSToolbarSegment { value: string; label: string; symbol?: string }
+interface ToolbarEntry { id: string; label?: string; placement?: "leading" | "trailing" }
+type ToolbarMenuEntry = { id: string; label: string; disabled?: boolean; hidden?: boolean; icon?: { type: "symbol"; name: string } };
+type ToolbarMenuItem =
+  | { type: "separator" }
+  | (ToolbarMenuEntry & { type: "action" })
+  | (ToolbarMenuEntry & { type: "checkbox"; checked: boolean })
+  | (ToolbarMenuEntry & { type: "slider"; min: number; max: number; value: number; suffix?: string });
+export type MacOSToolbarItem =
+  | (ToolbarEntry & { type: "button"; disabled?: boolean; bordered?: boolean; symbol?: string; tooltip?: string; monospacedDigits?: boolean; width?: number })
+  | (ToolbarEntry & { type: "menu"; disabled?: boolean; bordered?: boolean; symbol?: string; tooltip?: string; width?: number; items: readonly ToolbarMenuItem[] })
+  | (ToolbarEntry & { type: "label"; text: string; width?: number })
+  | (ToolbarEntry & { type: "search"; disabled?: boolean; collapses?: boolean; placeholder?: string; value?: string; width?: number })
+  | (ToolbarEntry & { type: "segmented"; segments: readonly MacOSToolbarSegment[]; value: string | null });
+export interface MacOSToolbarOptions {
+  visible?: boolean;
+  style?: "automatic" | "expanded" | "preference" | "unified" | "unifiedCompact";
+  items?: readonly MacOSToolbarItem[];
+}
+export interface MacOSStartupSplitViewOptions {
+  sidebarWidth: number;
+  sidebarMinWidth: number;
+  contentMinWidth: number;
+  sidebarCollapsed?: boolean;
+  appearance: "light" | "dark";
+  backgroundColor: string;
+  sidebarBackgroundColor: string;
+  contentTitlebarHeight?: number;
+}
+export interface MacOSWindowOptions {
+  panelStyle?: "utility" | "documentModal" | "nonactivating";
+  representedUri?: string | null;
+  level?: "normal" | "floating" | "modalPanel" | "mainMenu" | "status" | "screenSaver";
+  titleBar?: MacOSTitleBarOptions;
+  toolbar?: MacOSToolbarOptions;
+  startupSplitView?: MacOSStartupSplitViewOptions | null;
+  restoreOnLaunch?: boolean;
+}
+/** Panel class and startup shell are fixed when the native window is created. */
+export type MacOSWindowUpdateOptions = Omit<MacOSWindowOptions, "panelStyle">;
+export type MacOSWindowEvent =
+  | { type: "titleBarAction"; windowId: string; controlId: string }
+  | { type: "toolbarAction"; windowId: string; itemId: string }
+  | { type: "toolbarSelectionChanged"; windowId: string; itemId: string; value: string }
+  | { type: "toolbarSearchChanged" | "toolbarSearchSubmitted"; windowId: string; itemId: string; value: string; shiftKey: boolean }
+  | { type: "toolbarMenuAction"; windowId: string; itemId: string; action: MenuAction };
+export interface MacOSWindowBoundsOptions { durationMs?: number }
+export interface SetWindowBoundsOptions { macos?: MacOSWindowBoundsOptions }
+export interface MacOSWindowBlurOptions { radius: number; durationMs?: number }

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

@@ -0,0 +1,162 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { menuItems } from "@legendapp/spark-desktop-app/src/contracts/menu";
+import type { Size, WindowBounds, WindowOpenOptions, WindowUpdateOptions, MacOSWindowOptions } from "./types";
+
+type ObjectValue = Record<string, unknown>;
+export function object<T>(value: T, name: string): asserts value is T & ObjectValue {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new SparkError("E_INVALID_ARGUMENT", `${name} must be an object`);
+}
+export 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 window option: ${key}`);
+}
+export function windowId(value: unknown): asserts value is string {
+  if (typeof value !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(value)) throw new SparkError("E_INVALID_ARGUMENT", "Window IDs require 1–100 letters, numbers, underscores or hyphens");
+}
+export function text(value: unknown, name: string, empty = true): asserts value is string {
+  if (typeof value !== "string" || value.includes("\0") || (!empty && !value.length)) throw new SparkError("E_INVALID_ARGUMENT", `Invalid ${name}`);
+}
+export function number(value: unknown, name: string, min: number, max: number): asserts value is number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) throw new SparkError("E_INVALID_ARGUMENT", `${name} must be between ${min} and ${max}`);
+}
+function enumValue(value: unknown, allowed: readonly string[], name: string) {
+  if (value !== undefined && !allowed.includes(value as string)) throw new SparkError("E_INVALID_ARGUMENT", `Invalid ${name}`);
+}
+function flags(value: ObjectValue, names: readonly string[]) {
+  for (const key of names) if (value[key] !== undefined && typeof value[key] !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", `${key} must be boolean`);
+}
+export function size(value: unknown): asserts value is Size {
+  object(value, "size"); keys(value, ["width", "height"]);
+  number(value.width, "width", 100, 20000); number(value.height, "height", 100, 20000);
+}
+function position(value: unknown) {
+  object(value, "position"); keys(value, ["displayId", "x", "y"]);
+  text(value.displayId, "display ID", false); number(value.x, "x", -10000000, 10000000); number(value.y, "y", -10000000, 10000000);
+}
+export function bounds(value: unknown): asserts value is WindowBounds {
+  object(value, "bounds"); keys(value, ["displayId", "x", "y", "width", "height"]);
+  position({ displayId: value.displayId, x: value.x, y: value.y }); size({ width: value.width, height: value.height });
+}
+function color(value: unknown) {
+  if (typeof value !== "string" || !/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(value)) throw new SparkError("E_INVALID_ARGUMENT", "Window colors must be #RRGGBB or #RRGGBBAA");
+}
+/** Snapshot JSON props before a queued native call; no silent coercion or omission. */
+export function jsonSnapshot(value: unknown, active = new Set<object>()): unknown {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (!value || typeof value !== "object" || active.has(value)) throw new SparkError("E_INVALID_ARGUMENT", "Window props must be finite, acyclic JSON");
+  active.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getOwnPropertySymbols(value).length || Object.keys(value).length !== value.length || Array.from({ length: value.length }, (_, index) => index).some(index => !Object.hasOwn(value, index))) throw new SparkError("E_INVALID_ARGUMENT", "Window props cannot contain sparse arrays");
+      return value.map(entry => jsonSnapshot(entry, active));
+    }
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new SparkError("E_INVALID_ARGUMENT", "Window props require plain JSON objects");
+    if (Object.getOwnPropertySymbols(value).length) throw new SparkError("E_INVALID_ARGUMENT", "Window props cannot contain symbol properties");
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, jsonSnapshot(entry, active)]));
+  } finally { active.delete(value); }
+}
+const common = ["title", "appearance", "titleBarStyle", "backgroundColor", "transparent", "hasShadow", "alwaysOnTop", "resizable", "closable", "minimizable", "minSize", "maxSize", "macos"];
+export function validateOptions(options: WindowOpenOptions | WindowUpdateOptions, platform: string, opening: boolean): void {
+  object(options, "window options"); keys(options, [...common, ...(opening ? ["id", "component", "props", "size", "position", "show", "restoreBounds", "kind", "parentId", "modal"] : [])]);
+  flags(options, ["transparent", "hasShadow", "alwaysOnTop", "resizable", "closable", "minimizable", "show", "restoreBounds", "modal"]);
+  if (options.title !== undefined) text(options.title, "title");
+  enumValue(options.appearance, ["system", "light", "dark"], "appearance");
+  enumValue(options.titleBarStyle, ["default", "overlay", "hidden", "borderless"], "titleBarStyle");
+  if (platform === "windows" && options.titleBarStyle === "overlay") throw new SparkError("E_UNSUPPORTED_OPTION", "Windows does not support overlay title bars");
+  if (options.backgroundColor !== undefined) color(options.backgroundColor);
+  for (const value of [options.minSize, options.maxSize]) if (value !== undefined && value !== null) size(value);
+  const min = options.minSize ?? { width: 100, height: 100 }, max = options.maxSize ?? { width: 20000, height: 20000 };
+  if (min.width > max.width || min.height > max.height) throw new SparkError("E_INVALID_ARGUMENT", "Minimum window size exceeds maximum");
+  if (options.macos !== undefined) {
+    if (platform !== "macos") throw new SparkError("E_UNSUPPORTED_OPTION", "macos window options require macOS");
+    validateMacOS(options.macos);
+    if (!opening && "panelStyle" in options.macos) throw new SparkError("E_UNSUPPORTED_OPTION", "panelStyle is fixed when opening a window");
+    if (options.alwaysOnTop !== undefined && options.macos.level !== undefined) throw new SparkError("E_INVALID_ARGUMENT", "Choose alwaysOnTop or a macOS window level");
+  }
+  if (opening) {
+    const value = options as WindowOpenOptions;
+    windowId(value.id); if (value.id === "main") throw new SparkError("E_INVALID_ARGUMENT", "The main window is created by the host");
+    text(value.component, "registered component", false);
+    enumValue(value.kind, ["window", "overlay"], "window kind");
+    if (value.parentId !== undefined) windowId(value.parentId);
+    if (value.parentId === value.id || (value.modal && (!value.parentId || String(value.kind) === "overlay"))) throw new SparkError("E_INVALID_ARGUMENT", "Modal windows require a distinct parent and cannot be overlays");
+    if (value.size !== undefined) {
+      size(value.size);
+      if (value.size.width < min.width || value.size.height < min.height || value.size.width > max.width || value.size.height > max.height) throw new SparkError("E_INVALID_ARGUMENT", "Window size is outside its constraints");
+    }
+    if (value.position !== undefined) position(value.position);
+    if (value.props !== undefined) { object(value.props, "props"); jsonSnapshot(value.props); }
+  }
+}
+function entries(value: unknown, name: string): ObjectValue[] {
+  if (!Array.isArray(value)) throw new SparkError("E_INVALID_ARGUMENT", `${name} must be an array`);
+  const ids = new Set<string>();
+  for (const item of value) {
+    object(item, name); text(item.id, `${name} ID`, false);
+    if (ids.has(item.id)) throw new SparkError("E_INVALID_ARGUMENT", `${name} IDs must be unique`);
+    ids.add(item.id);
+  }
+  return value;
+}
+export function validateMacOS(value: MacOSWindowOptions) {
+  object(value, "macos"); keys(value, ["panelStyle", "representedUri", "level", "titleBar", "toolbar", "startupSplitView", "restoreOnLaunch"]);
+  enumValue(value.panelStyle, ["utility", "documentModal", "nonactivating"], "panelStyle");
+  enumValue(value.level, ["normal", "floating", "modalPanel", "mainMenu", "status", "screenSaver"], "level");
+  flags(value, ["restoreOnLaunch"]);
+  if (value.representedUri !== undefined && value.representedUri !== null) {
+    text(value.representedUri, "represented URI", false);
+    try { new URL(value.representedUri); } catch { throw new SparkError("E_INVALID_ARGUMENT", "representedUri must be an absolute URI"); }
+  }
+  if (value.titleBar !== undefined) {
+    const title = value.titleBar; object(title, "titleBar");
+    keys(title, ["contentLayout", "transparent", "titleVisibility", "separator", "material", "blendingMode", "materialState", "trafficLights", "controls"]);
+    flags(title, ["transparent", "trafficLights"]);
+    enumValue(title.contentLayout, ["contentLayoutGuide", "fullSize"], "contentLayout");
+    enumValue(title.titleVisibility, ["visible", "hidden"], "titleVisibility");
+    enumValue(title.separator, ["automatic", "none", "line", "shadow"], "separator");
+    enumValue(title.material, ["none", "glass", "titlebar", "headerView", "hudWindow", "sidebar", "windowBackground"], "material");
+    enumValue(title.blendingMode, ["behindWindow", "withinWindow"], "blendingMode");
+    enumValue(title.materialState, ["active", "inactive", "followsWindowActiveState"], "materialState");
+    if (title.controls !== undefined) for (const control of entries(title.controls, "titlebar control")) {
+      keys(control, ["id", "label", "placement", "disabled", "selected", "symbol", "tooltip"]); flags(control, ["disabled", "selected"]);
+      enumValue(control.placement, ["left", "right"], "control placement");
+      for (const field of ["label", "symbol", "tooltip"]) if (control[field] !== undefined) text(control[field], field);
+    }
+  }
+  if (value.toolbar !== undefined) {
+    object(value.toolbar, "toolbar"); keys(value.toolbar, ["visible", "style", "items"]); flags(value.toolbar, ["visible"]);
+    enumValue(value.toolbar.style, ["automatic", "expanded", "preference", "unified", "unifiedCompact"], "toolbar style");
+    if (value.toolbar.items !== undefined) for (const item of entries(value.toolbar.items, "toolbar item")) {
+      const fields: Record<string, string[]> = { button: ["disabled", "bordered", "symbol", "tooltip", "monospacedDigits", "width"], menu: ["disabled", "bordered", "symbol", "tooltip", "width", "items"], label: ["text", "width"], search: ["disabled", "collapses", "placeholder", "value", "width"], segmented: ["segments", "value"] };
+      if (typeof item.type !== "string" || !Object.hasOwn(fields, item.type)) throw new SparkError("E_INVALID_ARGUMENT", "Unknown toolbar item type");
+      keys(item, ["id", "label", "placement", "type", ...fields[item.type]]);
+      flags(item, ["disabled", "bordered", "monospacedDigits", "collapses"]);
+      enumValue(item.placement, ["leading", "trailing"], "toolbar placement");
+      for (const field of ["label", "symbol", "tooltip", "text", "placeholder"]) if (item[field] !== undefined) text(item[field], field);
+      if (item.width !== undefined) number(item.width, "toolbar width", 1, 20000);
+      if (item.type === "label") text(item.text, "toolbar text");
+      if (item.type === "search" && item.value !== undefined) text(item.value, "search value");
+      if (item.type === "menu") menuItems(item.items as never, { types: ["action", "checkbox", "separator", "slider"], icons: ["symbol"] }, "macos");
+      if (item.type === "segmented") {
+        if (!Array.isArray(item.segments) || !item.segments.length) throw new SparkError("E_INVALID_ARGUMENT", "Toolbar segments must be nonempty");
+        const values = new Set<string>();
+        for (const segment of item.segments) {
+          object(segment, "segment"); keys(segment, ["value", "label", "symbol"]); text(segment.value, "segment value"); text(segment.label, "segment label", false);
+          if (segment.symbol !== undefined) text(segment.symbol, "segment symbol", false);
+          if (values.has(segment.value)) throw new SparkError("E_INVALID_ARGUMENT", "Segment values must be unique"); values.add(segment.value);
+        }
+        if (item.value !== null && !values.has(item.value as string)) throw new SparkError("E_INVALID_ARGUMENT", "Unknown toolbar segment value");
+      }
+    }
+  }
+  if (value.startupSplitView !== undefined && value.startupSplitView !== null) {
+    const split = value.startupSplitView; object(split, "startupSplitView");
+    keys(split, ["sidebarWidth", "sidebarMinWidth", "contentMinWidth", "sidebarCollapsed", "appearance", "backgroundColor", "sidebarBackgroundColor", "contentTitlebarHeight"]);
+    for (const field of ["sidebarWidth", "sidebarMinWidth", "contentMinWidth"] as const) number(split[field], field, 0, 20000);
+    if (split.sidebarWidth < split.sidebarMinWidth && !split.sidebarCollapsed) throw new SparkError("E_INVALID_ARGUMENT", "Sidebar width is below its minimum");
+    if (split.contentTitlebarHeight !== undefined) number(split.contentTitlebarHeight, "contentTitlebarHeight", 0, 20000);
+    flags(split, ["sidebarCollapsed"]);
+    if (!["light", "dark"].includes(split.appearance)) throw new SparkError("E_INVALID_ARGUMENT", "Startup split view requires light or dark appearance");
+    color(split.backgroundColor); color(split.sidebarBackgroundColor);
+  }
+}

package/vendor/node_modules/@legendapp/spark-desktop-windows/src/window-manager/NativeWindowManager.ts

@@ -0,0 +1,28 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  getConstantsJson(): string;
+  getReactNativeStartupTimingJson(): string;
+  getDisplays(): Promise<string>;
+  openWindow(optionsJson: string): Promise<string>;
+  finishWindowRestoration(): Promise<string>;
+  closeWindow(identifier: string): Promise<string>;
+  closeFrontmostWindow(): Promise<string>;
+  hideMainWindow(): Promise<string>;
+  showWindow(identifier: string): Promise<string>;
+  showMainWindow(): Promise<string>;
+  setMainWindowOptions(optionsJson: string): Promise<string>;
+  setWindowOptions(identifier: string, optionsJson: string): Promise<string>;
+  getMainWindowFrame(): Promise<string>;
+  setMainWindowFrame(frameJson: string): Promise<string>;
+  setWindowBlur(identifier: string, radius: number, durationMs: number): Promise<string>;
+  setWindowTitle(identifier: string, title: string): Promise<string>;
+  setWindowToolbarItemText(identifier: string, itemId: string, text: string): Promise<string>;
+  setPreventDisplaySleep(enabled: boolean): Promise<string>;
+  focusToolbarSearchItem(identifier: string, itemId: string, value: string | null): Promise<string>;
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.get<Spec>("NativeWindowManager");

package/vendor/node_modules/@legendapp/spark-desktop-windows/src/windows/WindowProvider.tsx

@@ -0,0 +1,20 @@
+import type { ComponentType, ReactNode } from "react";
+import { createContext, useContext } from "react";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { windowId } from "../validation";
+const WindowContext = createContext<string | null>(null);
+export function useWindowId(): string {
+  const id = useContext(WindowContext);
+  if (id === null) throw new SparkError("E_UNAVAILABLE", "useWindowId requires a WindowProvider for this React root");
+  return id;
+}
+export interface WindowProviderProps { children: ReactNode; id: string }
+export function WindowProvider({ children, id }: WindowProviderProps) {
+  windowId(id); return <WindowContext.Provider value={id}>{children}</WindowContext.Provider>;
+}
+export function withWindowProvider<P extends object>(Component: ComponentType<P>, id: string): ComponentType<P> {
+  windowId(id);
+  const Wrapped = (props: P) => <WindowProvider id={id}><Component {...props} /></WindowProvider>;
+  Wrapped.displayName = `Window(${id})`;
+  return Wrapped;
+}

package/vendor/node_modules/@legendapp/spark-desktop-windows/src/windows/createWindowsNavigator.tsx

@@ -0,0 +1,78 @@
+import type { ComponentType } from "react";
+import { lazy, Suspense } from "react";
+import { AppRegistry } from "react-native";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { openWindow, closeWindow, showWindow } from "../api";
+import type { CloseResult, WindowInfo, WindowOpenOptions } from "../types";
+import { keys, object, validateOptions, windowId } from "../validation";
+import { Platform } from "react-native";
+import type { NavigatorWindowOptions, WindowsConfig, WindowComponentProps } from "./types";
+import { withWindowProvider } from "./WindowProvider";
+export type NavigatorOpenOptions<P> = { props: P; options?: NavigatorWindowOptions };
+type OpenArguments<P> = {} extends P ? [options?: { props?: P; options?: NavigatorWindowOptions }] : [options: NavigatorOpenOptions<P>];
+export interface WindowsNavigator<T extends WindowsConfig> {
+  open<K extends keyof T>(name: K, ...args: OpenArguments<WindowComponentProps<T[K]>>): Promise<WindowInfo>;
+  close(name: keyof T): Promise<CloseResult>;
+  show(name: keyof T): Promise<void>;
+  getId(name: keyof T): string;
+  prefetch(name: keyof T): Promise<void>;
+}
+const registrations = new Set<string>();
+function component(value: unknown): value is ComponentType<any> {
+  return typeof value === "function" || (!!value && typeof value === "object" && [Symbol.for("react.memo"), Symbol.for("react.forward_ref"), Symbol.for("react.lazy")].includes((value as any).$$typeof));
+}
+export function createWindowsNavigator<T extends WindowsConfig>(config: T): WindowsNavigator<T> {
+  object(config, "navigator configuration");
+  const ids = new Set<string>();
+  for (const entry of Object.values(config)) {
+    object(entry, "window registration"); keys(entry, ["id", "component", "loadComponent", "options"]); windowId(entry.id);
+    if (entry.id === "main" || ids.has(entry.id) || registrations.has(entry.id)) throw new SparkError("E_ALREADY_EXISTS", "Window ID is already registered or reserved");
+    ids.add(entry.id);
+    if ((entry.component !== undefined) === (entry.loadComponent !== undefined) || (entry.component !== undefined && !component(entry.component)) || (entry.loadComponent !== undefined && typeof entry.loadComponent !== "function")) throw new SparkError("E_INVALID_ARGUMENT", "Register exactly one component or loadComponent");
+    if (entry.options) {
+      object(entry.options, "registration options");
+      for (const key of ["id", "component", "props"]) if (key in entry.options) throw new SparkError("E_INVALID_ARGUMENT", "Navigator identity and props cannot be overridden in options");
+      validateOptions({ ...entry.options, id: entry.id, component: "registration" } as WindowOpenOptions, Platform.OS, true);
+    }
+  }
+  const registry = new Map<keyof T, { id: string; moduleName: string; options: NavigatorWindowOptions; load(): Promise<void> }>();
+  for (const name of Object.keys(config) as (keyof T)[]) {
+    const entry = config[name], id = entry.id, moduleName = `spark.window.${id}`;
+    let resolved: ComponentType<any> | undefined = entry.component ? withWindowProvider(entry.component, id) : undefined;
+    let pending: Promise<void> | undefined;
+    const load = async () => {
+      if (resolved) return;
+      if (!pending) pending = Promise.resolve().then(() => entry.loadComponent!()).then(value => {
+        const result = value && typeof value === "object" && "default" in value ? value.default : value;
+        if (!component(result)) throw new SparkError("E_INVALID_DATA", "Window loader did not return a React component");
+        resolved = withWindowProvider(result, id);
+      }).catch(cause => { pending = undefined; throw cause; });
+      await pending;
+    };
+    // Native surfaces restart on reload before the app can call open or prefetch.
+    const LoadedWindow = lazy(async () => { await load(); return { default: resolved! }; });
+    const RestartedWindow = (props: any) => <Suspense fallback={null}><LoadedWindow {...props} /></Suspense>;
+    AppRegistry.registerComponent(moduleName, () => resolved ?? RestartedWindow);
+    registrations.add(id);
+    registry.set(name, { id, moduleName, options: JSON.parse(JSON.stringify(entry.options ?? {})), load });
+  }
+  const get = (name: keyof T) => {
+    const value = registry.get(name); if (!value) throw new SparkError("E_NOT_FOUND", `Unknown window: ${String(name)}`); return value;
+  };
+  return {
+    async open(name, ...args) {
+      const registration = get(name), request = args[0] ?? {};
+      object(request, "open request"); keys(request, ["props", "options"]);
+      if (request.options) { object(request.options, "open options"); for (const key of ["id", "component", "props"]) if (key in request.options) throw new SparkError("E_INVALID_ARGUMENT", "Navigator identity and props cannot be overridden in options"); }
+      const options = { ...registration.options, ...request.options, id: registration.id, component: registration.moduleName, props: request.props } as WindowOpenOptions;
+      validateOptions(options, Platform.OS, true);
+      const snapshot = JSON.parse(JSON.stringify(options));
+      // Always load before native creation. Failed loaders remain retryable and leave no native shell.
+      await registration.load(); return openWindow(snapshot);
+    },
+    async close(name) { return closeWindow(get(name).id); },
+    async show(name) { await showWindow(get(name).id); },
+    getId(name) { return get(name).id; },
+    async prefetch(name) { await get(name).load(); },
+  };
+}

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

@@ -0,0 +1,6 @@
+export { createWindowsNavigator, type WindowsNavigator, type NavigatorOpenOptions } from "./createWindowsNavigator";
+export type { WindowConfigEntry, WindowsConfig, WindowComponentLoader, NavigatorWindowOptions, WindowComponentProps } from "./types";
+export { useWindowFocusEffect, type WindowHookOptions } from "./useWindowFocusEffect";
+export { usePrimaryWindowLifecycle, type UsePrimaryWindowLifecycleOptions } from "./usePrimaryWindowLifecycle";
+export { useWindowId, WindowProvider, withWindowProvider, type WindowProviderProps } from "./WindowProvider";
+export { createPrimaryWindowLifecycle, type PrimaryWindowLifecycleOptions } from "./primaryWindowLifecycle";

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

@@ -0,0 +1,34 @@
+import { addAppListener } from "@legendapp/spark-desktop-app";
+import { SparkError, nativeError, type Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+
+export interface PrimaryWindowLifecycleOptions {
+  windowId: string;
+  onInitialOpen: () => void | Promise<void>;
+  onReopenRequested?: () => void | Promise<void>;
+  onWindowClosed?: () => void;
+  onError: (error: SparkError) => void;
+}
+
+/** Owns application events for one logical window, including reopened instances. */
+export function createPrimaryWindowLifecycle(options: PrimaryWindowLifecycleOptions): Subscription {
+  const { windowId, onInitialOpen, onReopenRequested, onWindowClosed, onError } = options;
+  if (typeof windowId !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(windowId)) {
+    throw new SparkError("E_INVALID_ARGUMENT", "Expected a window ID");
+  }
+  let active = true;
+  const run = (action: (() => void | Promise<void>) | undefined) => {
+    if (active && action) void Promise.resolve().then(() => { if (active) return action(); })
+      .catch(cause => onError(nativeError(cause)));
+  };
+  const reopened = addAppListener("reopen", event => { if (!event.hasVisibleWindows) run(onReopenRequested); });
+  let closed: Subscription;
+  try {
+    closed = addAppListener("windowClosed", event => {
+      if (active && event.windowId === windowId && onWindowClosed) {
+        try { onWindowClosed(); } catch (cause) { onError(nativeError(cause)); }
+      }
+    });
+  } catch (error) { active = false; reopened.remove(); throw error; }
+  run(onInitialOpen);
+  return { remove() { active = false; reopened.remove(); closed.remove(); } };
+}

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

@@ -0,0 +1,11 @@
+import type { ComponentType } from "react";
+import type { WindowOpenOptions } from "../types";
+export type WindowComponentLoader<P = Record<string, never>> = () => ComponentType<P> | { default: ComponentType<P> } | Promise<ComponentType<P> | { default: ComponentType<P> }>;
+type WithoutIdentity<T> = T extends unknown ? Omit<T, "id" | "component" | "props"> : never;
+export type NavigatorWindowOptions = WithoutIdentity<WindowOpenOptions>;
+export type WindowConfigEntry<P = any> = { id: string; options?: NavigatorWindowOptions } & (
+  | { component: ComponentType<P>; loadComponent?: never }
+  | { component?: never; loadComponent: WindowComponentLoader<P> }
+);
+export type WindowsConfig = Record<string, WindowConfigEntry>;
+export type WindowComponentProps<T> = T extends { component: ComponentType<infer P> } ? P : T extends { loadComponent: WindowComponentLoader<infer P> } ? P : never;

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

@@ -0,0 +1,18 @@
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { createPrimaryWindowLifecycle, type PrimaryWindowLifecycleOptions } from "./primaryWindowLifecycle";
+export type UsePrimaryWindowLifecycleOptions = PrimaryWindowLifecycleOptions;
+
+export function usePrimaryWindowLifecycle(options: UsePrimaryWindowLifecycleOptions): void {
+  const latest = useRef(options);
+  useLayoutEffect(() => { latest.current = options; });
+  useEffect(() => {
+    const registration = createPrimaryWindowLifecycle({
+      windowId: options.windowId,
+      onInitialOpen: () => latest.current.onInitialOpen(),
+      onReopenRequested: () => latest.current.onReopenRequested?.(),
+      onWindowClosed: () => latest.current.onWindowClosed?.(),
+      onError: error => latest.current.onError(error),
+    });
+    return () => registration.remove();
+  }, [options.windowId]);
+}

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

@@ -0,0 +1,17 @@
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { nativeError, type AsyncRegistration, type SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { addWindowListener } from "../api";
+import { useWindowId } from "./WindowProvider";
+export interface WindowHookOptions { onError?: (error: SparkError) => void }
+export function useWindowFocusEffect(callback: () => void, options: WindowHookOptions = {}) {
+  const id = useWindowId(), latest = useRef({ callback, onError: options.onError });
+  useLayoutEffect(() => { latest.current = { callback, onError: options.onError }; }, [callback, options.onError]);
+  useEffect(() => {
+    let disposed = false, registration: AsyncRegistration | undefined;
+    const report = (cause: unknown) => { if (latest.current.onError) latest.current.onError(nativeError(cause)); else console.error(cause); };
+    void addWindowListener(id, "focusChanged", event => { if (!disposed && event.focused) latest.current.callback(); }, { onError: report }).then(value => {
+      if (disposed) void value.remove().catch(report); else registration = value;
+    }).catch(report);
+    return () => { disposed = true; void registration?.remove().catch(report); };
+  }, [id]);
+}

package/vendor/node_modules/@legendapp/spark-documents/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@legendapp/spark-documents",
+  "version": "0.0.1-next.4",
+  "private": true,
+  "license": "MIT",
+  "main": "src/index.tsx",
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "@legendapp/spark-file-dialog": "0.0.1-next.4",
+    "@legendapp/spark-file-system": "0.0.1-next.4",
+    "@legendapp/spark-native-menu": "0.0.1-next.4",
+    "@legendapp/spark-desktop-app": "0.0.1-next.4",
+    "@legendapp/spark-desktop-windows": "0.0.1-next.4",
+    "@legendapp/spark-desktop-links": "0.0.1-next.4"
+  },
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  }
+}