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

package/vendor/node_modules/@legendapp/spark-cli/templates/music-lite/assets.desktop.ts

@@ -1,7 +1,7 @@
 import { openFileDialog } from "@legendapp/spark/dialogs";
 import type { Track } from "./model";
 export async function importTracks(): Promise<Track[]> {
-  const paths = await openFileDialog({ allowedFileTypes: ["mp3", "m4a", "wav", "aac", "flac", "ogg"], allowsMultipleSelection: true });
-  return (paths ?? []).map(uri => ({ id: uri, uri, name: uri.split(/[\\/]/).pop()! }));
+  const paths = await openFileDialog({ filters: [{ extensions: ["mp3", "m4a", "wav", "aac", "flac", "ogg"] }], multiple: true });
+  return (paths.canceled ? [] : paths.paths).map(uri => ({ id: uri, uri, name: uri.split(/[\\/]/).pop()! }));
 }
 export const resolveTrack = async (track: Track) => ({ uri: track.uri, release() {} });

package/vendor/node_modules/@legendapp/spark-cli/templates/notes-lite/Activation.desktop.tsx

@@ -1,5 +1,5 @@
-import { readTextFile } from "@legendapp/spark/dialogs";
+import { readText } from "@legendapp/spark/files";
 import { OpenFiles } from "./shared/OpenFiles";
 import { notes } from "./store";
-const open = async (path: string) => { await notes.load(); if (!notes.getSnapshot().ready) throw new Error("Notes storage is unavailable"); const text = await readTextFile(path); notes.create(text); };
+const open = async (path: string) => { await notes.load(); if (!notes.getSnapshot().ready) throw new Error("Notes storage is unavailable"); const text = await readText(path); notes.create(text); };
 export function Activation({ windowId, onError }: { windowId: string; onError(message: string): void }) { return <OpenFiles windowId={windowId} onFile={open} onError={onError} />; }

package/vendor/node_modules/@legendapp/spark-cli/templates/notes-lite/Desktop.desktop.ts

@@ -1,25 +1,47 @@
-import { getDisplays, listWindows, openWindow, setWindowFrame, showWindow, onWindowEvent } from "@legendapp/spark/windows";
+import { addWindowListener, getDisplays, listWindows, openWindow, setWindowBounds, showWindow } from "@legendapp/spark/windows";
+import type { AsyncRegistration } from "@legendapp/spark/contracts";
 import { notes } from "./store";
 import { WindowSession } from "./window-session";
 export const desktop = true;
 const session = new WindowSession(notes, {
-  list: listWindows,
-  workAreas: async () => (await getDisplays()).map(display => display.workArea),
+  list: async () => (await listWindows()).map(window => ({ id: window.id, frame: window.bounds })),
+  workAreas: async () => (await getDisplays()).sort((a, b) => Number(b.primary) - Number(a.primary)).map(display => ({ ...display.workArea, displayId: display.id })),
   show: showWindow,
-  frame: setWindowFrame,
-  open: window => openWindow({ id: window.id, title: window.id === "settings" ? "Notes Settings" : "Notes", width: window.frame.width, height: window.frame.height, props: window.id === "settings" ? { settings: true } : { noteId: window.noteId } }),
+  frame: setWindowBounds,
+  open: window => openWindow({ id: window.id, component: "main", title: window.id === "settings" ? "Notes Settings" : "Notes", size: { width: window.frame.width, height: window.frame.height }, position: { displayId: window.frame.displayId, x: window.frame.x, y: window.frame.y }, props: { windowId: window.id, windowProps: window.id === "settings" ? { settings: true } : { noteId: window.noteId } } }),
 });
-export const openNote = (noteId: string) => session.openNote(noteId);
-export const openSettings = () => session.openSettings();
+const watchers = new Set<(message: string) => void>();
+const registrations = new Map<string, AsyncRegistration[]>();
+let generation = 0, timer: ReturnType<typeof setTimeout> | undefined;
+function report(error: unknown) { for (const watcher of watchers) watcher(String(error)); }
+function changed() { clearTimeout(timer); timer = setTimeout(() => { void session.capture().catch(report); }, 150); }
+let pending: Promise<void> = Promise.resolve();
+function observeWindows() {
+  const epoch = generation;
+  const task = pending.then(async () => {
+    if (!watchers.size || epoch !== generation) return;
+    for (const window of await listWindows()) {
+      if (!session.known(window.id) || registrations.has(window.id)) continue;
+      const owned: AsyncRegistration[] = [];
+      try {
+        owned.push(await addWindowListener(window.id, "boundsChanged", changed));
+        owned.push(await addWindowListener(window.id, "closed", () => { registrations.delete(window.id); for (const value of owned) void value.remove().catch(report); changed(); }));
+        if (watchers.size && epoch === generation) registrations.set(window.id, owned);
+        else for (const value of owned) await value.remove();
+      } catch (error) { for (const value of owned) await value.remove(); throw error; }
+    }
+  });
+  pending = task.catch(() => {}); return task;
+}
+export async function openNote(noteId: string) { await session.openNote(noteId); await observeWindows(); }
+export async function openSettings() { await session.openSettings(); await observeWindows(); }
 export const showNotebook = () => showWindow("main");
-export const restoreSession = session.restore;
+export async function restoreSession() { await session.restore(); await observeWindows(); }
 export const flushSession = session.quit;
 export function watchSession(onError: (message: string) => void) {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const subscription = onWindowEvent(event => {
-    if (!session.known(event.windowId) || !["move", "resize", "closed"].includes(event.type)) return;
-    clearTimeout(timer);
-    timer = setTimeout(() => { void session.restore().then(session.capture).catch(error => onError(String(error))); }, 150);
-  });
-  return { remove() { clearTimeout(timer); subscription.remove(); } };
+  watchers.add(onError); void observeWindows().catch(report);
+  return { remove() {
+    watchers.delete(onError);
+    if (!watchers.size) { generation++; clearTimeout(timer); for (const owned of registrations.values()) for (const value of owned) void value.remove().catch(console.error); registrations.clear(); }
+  } };
 }

package/vendor/node_modules/@legendapp/spark-cli/templates/notes-lite/session.ts

@@ -1,16 +1,15 @@
 export type Theme = "system" | "light" | "dark";
-export type Frame = { x: number; y: number; width: number; height: number };
+export type Frame = { displayId: string; x: number; y: number; width: number; height: number };
 export type SavedWindow = { id: string; noteId?: string; frame: Frame };
 export function decodeWindows(value: unknown): SavedWindow[] {
   if (value === undefined) return [];
-  if (!Array.isArray(value) || !value.every(item => item && typeof item.id === "string" && /^(main|settings|note-[a-zA-Z0-9_-]+)$/.test(item.id) && (item.noteId === undefined || typeof item.noteId === "string") && item.frame && ["x", "y", "width", "height"].every(key => Number.isFinite(item.frame[key])) && item.frame.width >= 100 && item.frame.height >= 100 && item.frame.width <= 20000 && item.frame.height <= 20000) || new Set(value.map(item => item.id)).size !== value.length) throw new Error("Unsupported window session");
+  if (!Array.isArray(value) || !value.every(item => item && typeof item.id === "string" && /^(main|settings|note-[a-zA-Z0-9_-]+)$/.test(item.id) && (item.noteId === undefined || typeof item.noteId === "string") && item.frame && typeof item.frame.displayId === "string" && item.frame.displayId.length > 0 && ["x", "y", "width", "height"].every(key => Number.isFinite(item.frame[key])) && item.frame.width >= 100 && item.frame.height >= 100 && item.frame.width <= 20000 && item.frame.height <= 20000) || new Set(value.map(item => item.id)).size !== value.length) throw new Error("Unsupported window session");
   return value;
 }
-/** Both platforms return frames/work areas in their own matching coordinate system. */
+/** Saved bounds and work areas use the same display-relative logical units. */
 export function fitFrame(frame: Frame, workAreas: Frame[]): Frame {
   if (!workAreas.length) return frame;
-  const overlap = (area: Frame) => Math.max(0, Math.min(frame.x + frame.width, area.x + area.width) - Math.max(frame.x, area.x)) * Math.max(0, Math.min(frame.y + frame.height, area.y + area.height) - Math.max(frame.y, area.y));
-  const area = workAreas.reduce((best, current) => overlap(current) > overlap(best) ? current : best);
+  const area = workAreas.find(area => area.displayId === frame.displayId) ?? workAreas[0];
   const width = Math.min(frame.width, area.width), height = Math.min(frame.height, area.height);
-  return { x: Math.max(area.x, Math.min(frame.x, area.x + area.width - width)), y: Math.max(area.y, Math.min(frame.y, area.y + area.height - height)), width, height };
+  return { displayId: area.displayId, x: Math.max(area.x, Math.min(frame.x, area.x + area.width - width)), y: Math.max(area.y, Math.min(frame.y, area.y + area.height - height)), width, height };
 }

package/vendor/node_modules/@legendapp/spark-cli/templates/notes-lite/window-session.ts

@@ -20,13 +20,13 @@ export class WindowSession {
     const id = `note-${noteId}`;
     this.noteIds.set(id, noteId);
     if ((await this.host.list()).some(window => window.id === id)) await this.host.show(id);
-    else await this.host.open({ id, noteId, frame: { x: 0, y: 0, width: 700, height: 600 } });
+    else await this.host.open({ id, noteId, frame: fitFrame({ displayId: "", x: 0, y: 0, width: 700, height: 600 }, await this.host.workAreas()) });
     await this.capture();
   }
   async openSettings() {
     await this.restore();
     if ((await this.host.list()).some(window => window.id === "settings")) await this.host.show("settings");
-    else await this.host.open({ id: "settings", frame: { x: 0, y: 0, width: 460, height: 360 } });
+    else await this.host.open({ id: "settings", frame: fitFrame({ displayId: "", x: 0, y: 0, width: 460, height: 360 }, await this.host.workAreas()) });
     await this.capture();
   }
   capture = () => {
@@ -46,8 +46,9 @@ export class WindowSession {
     for (const window of saved) {
       if (window.id !== "main" && window.id !== "settings" && !this.notes.getSnapshot().notes.some(note => note.id === window.noteId && !note.deleted)) continue;
       if (window.noteId) this.noteIds.set(window.id, window.noteId);
-      if (window.id !== "main" && !(await this.host.list()).some(item => item.id === window.id)) await this.host.open(window);
-      await this.host.frame(window.id, fitFrame(window.frame, areas));
+      const frame = fitFrame(window.frame, areas);
+      if (window.id !== "main" && !(await this.host.list()).some(item => item.id === window.id)) await this.host.open({ ...window, frame });
+      await this.host.frame(window.id, frame);
     }
     await this.capture();
   })();

package/vendor/node_modules/@legendapp/spark-cli/templates/universal/desktop.config.json

@@ -3,9 +3,11 @@
   "name": "HelloWorld",
   "version": "0.0.1",
   "window": {
-    "width": 1000,
-    "height": 700,
-    "restoreFrame": true
+    "size": {
+      "width": 1000,
+      "height": 700
+    },
+    "restoreBounds": true
   },
   "macos": {
     "bundleIdentifier": "so.legend.spark.prototype.helloworld"

package/vendor/node_modules/@legendapp/spark-cli/templates/universal/metro.config.js

@@ -1,5 +1,5 @@
 const { withUniwindConfig } = require("uniwind/metro");
-const { metroConfig } = require("@legendapp/spark/universal");
+const { metroConfig } = require("@legendapp/spark/metro");
 
 module.exports = withUniwindConfig(metroConfig(__dirname), {
   cssEntryFile: "./global.css",

package/vendor/node_modules/@legendapp/spark-cli/templates/universal/package.json

@@ -18,11 +18,11 @@
   },
   "dependencies": {
     "expo": "54.0.37",
-    "expo-desktop": "1.0.0-beta.6",
-    "expo-desktop-prebuild-config": "1.1.0-beta.1",
-    "expo-desktop-config-plugins": "1.2.0-beta.1",
-    "expo-desktop-metro-config": "54.81.0-beta.3",
-    "expo-desktop-template-bare-minimum": "54.81.1-beta.6",
+    "expo-desktop": "1.0.0",
+    "expo-desktop-prebuild-config": "1.1.0",
+    "expo-desktop-config-plugins": "1.2.0",
+    "expo-desktop-metro-config": "54.81.0",
+    "expo-desktop-template-bare-minimum": "54.81.1",
     "react": "19.1.4",
     "react-native": "0.81.6",
     "react-native-macos": "0.81.7",
@@ -30,8 +30,8 @@
     "typescript": "5.9.3",
     "@types/react": "19.1.10",
     "react-native-windows": "0.81.35",
-    "expo-desktop-modules-core": "54.0.14-beta.0",
-    "expo-desktop-stubs": "54.0.14-beta.0",
+    "expo-desktop-modules-core": "54.0.14",
+    "expo-desktop-stubs": "54.0.14",
     "@expo/ui": "0.2.0-beta.9",
     "expo-dev-client": "6.0.21",
     "expo-clipboard": "8.0.8",
@@ -41,11 +41,11 @@
     "react-native-web": "0.21.0",
     "uniwind": "1.6.3",
     "tailwindcss": "4.2.4",
-    "@legendapp/spark": "0.0.1-next.2"
+    "@legendapp/spark": "0.0.1-next.4"
   },
   "overrides": {
     "@expo/cli": "54.0.27",
-    "react-native-nitro-modules": "0.35.7",
+    "react-native-nitro-modules": "0.37.0",
     "react-native-webview": "16.0.0",
     "@op-engineering/op-sqlite": "18.2.1",
     "expo-asset": "12.0.13",
@@ -54,10 +54,12 @@
     "expo-font": "14.0.12",
     "expo-keep-awake": "15.0.8",
     "expo-modules-core": "3.0.30",
-    "expo-desktop-modules-core": "54.0.14-beta.0",
-    "expo-desktop-stubs": "54.0.14-beta.0",
+    "expo-desktop-modules-core": "54.0.14",
+    "expo-desktop-stubs": "54.0.14",
     "react": "19.1.4",
-    "react-native": "0.81.6"
+    "react-native": "0.81.6",
+    "react-native-macos": "0.81.7",
+    "react-native-windows": "0.81.35"
   },
   "expo": {
     "install": {

package/vendor/node_modules/@legendapp/spark-cli/templates/universal/react-native.config.js

@@ -1,2 +1,2 @@
 // Generated by spark; extend with configuration plugins.
-module.exports = require("@legendapp/spark/universal").nativeConfig(__dirname);
+module.exports = require("@legendapp/spark/native").nativeConfig(__dirname);

package/vendor/node_modules/@legendapp/spark-cli/templates/windows/package.json

@@ -14,24 +14,24 @@
   },
   "dependencies": {
     "expo": "54.0.37",
-    "expo-desktop": "1.0.0-beta.6",
-    "expo-desktop-prebuild-config": "1.1.0-beta.1",
-    "expo-desktop-config-plugins": "1.2.0-beta.1",
-    "expo-desktop-metro-config": "54.81.0-beta.3",
-    "expo-desktop-template-bare-minimum": "54.81.1-beta.6",
+    "expo-desktop": "1.0.0",
+    "expo-desktop-prebuild-config": "1.1.0",
+    "expo-desktop-config-plugins": "1.2.0",
+    "expo-desktop-metro-config": "54.81.0",
+    "expo-desktop-template-bare-minimum": "54.81.1",
     "react": "19.1.4",
     "react-native": "0.81.6",
     "@react-native-community/cli": "20.1.3",
     "typescript": "5.9.3",
     "@types/react": "19.1.10",
     "react-native-windows": "0.81.35",
-    "expo-desktop-modules-core": "54.0.14-beta.0",
-    "expo-desktop-stubs": "54.0.14-beta.0",
-    "@legendapp/spark": "0.0.1-next.2"
+    "expo-desktop-modules-core": "54.0.14",
+    "expo-desktop-stubs": "54.0.14",
+    "@legendapp/spark": "0.0.1-next.4"
   },
   "overrides": {
     "@expo/cli": "54.0.27",
-    "react-native-nitro-modules": "0.35.7",
+    "react-native-nitro-modules": "0.37.0",
     "react-native-webview": "16.0.0",
     "@op-engineering/op-sqlite": "18.2.1",
     "expo-asset": "12.0.13",
@@ -40,10 +40,12 @@
     "expo-font": "14.0.12",
     "expo-keep-awake": "15.0.8",
     "expo-modules-core": "3.0.30",
-    "expo-desktop-modules-core": "54.0.14-beta.0",
-    "expo-desktop-stubs": "54.0.14-beta.0",
+    "expo-desktop-modules-core": "54.0.14",
+    "expo-desktop-stubs": "54.0.14",
     "react": "19.1.4",
-    "react-native": "0.81.6"
+    "react-native": "0.81.6",
+    "react-native-macos": "0.81.7",
+    "react-native-windows": "0.81.35"
   },
   "expo": {
     "install": {

package/vendor/node_modules/@legendapp/spark-cli/templates/windows/react-native.config.js

@@ -1,2 +1,2 @@
 // Generated by spark; extend with configuration plugins.
-module.exports = require("@legendapp/spark/universal").nativeConfig(__dirname);
+module.exports = require("@legendapp/spark/native").nativeConfig(__dirname);

package/vendor/node_modules/@legendapp/spark-clipboard/macos/RNDesktopClipboard.mm

@@ -1,11 +1,13 @@
 #import "RNDesktopClipboard.h"
+#import <RNDesktopApp/SparkBinaryJSI.h>
 #import <RNDesktopApp/SparkDesktop.h>
 @implementation RNDesktopClipboard
 RCT_EXPORT_MODULE(NativeDesktopClipboard)
-- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { [self perform:method args:SparkArgs(json) binary:NO resolve:resolve reject:reject]; }
+- (void)binaryCall:(NSString *)method args:(NSString *)json bytes:(NSData *)bytes resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { NSMutableDictionary *args = [SparkArgs(json) mutableCopy]; if (bytes) args[@"imagePNG"] = bytes; [self perform:method args:args binary:YES resolve:resolve reject:reject]; }
+- (void)perform:(NSString *)method args:(NSDictionary *)args binary:(BOOL)binary resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   dispatch_async(dispatch_get_main_queue(), ^{
     NSPasteboard *board = NSPasteboard.generalPasteboard;
-    NSDictionary *args = SparkArgs(json);
     if ([method isEqual:@"hasString"]) {
       resolve(SparkJSON(@([board availableTypeFromArray:@[NSPasteboardTypeString, NSPasteboardTypeHTML, NSPasteboardTypeRTF]] != nil))); return;
     }
@@ -24,8 +26,7 @@ RCT_EXPORT_MODULE(NativeDesktopClipboard)
           if (rich) [item setString:rich.string forType:NSPasteboardTypeString];
         }
         [board clearContents];
-        if (![board writeObjects:@[item]]) { reject(@"E_CLIPBOARD", @"Could not write clipboard", nil); return; }
-        resolve(@"null"); return;
+        resolve(SparkJSON(@([board writeObjects:@[item]]))); return;
       }
       NSString *text = [board stringForType:html ? NSPasteboardTypeHTML : NSPasteboardTypeString];
       if (!text) {
@@ -50,10 +51,10 @@ RCT_EXPORT_MODULE(NativeDesktopClipboard)
       for (NSString *key in types) { NSString *value = [board stringForType:types[key]]; if (value) content[key] = value; }
       NSData *image = [board dataForType:NSPasteboardTypePNG];
       if (!image) { NSData *tiff = [board dataForType:NSPasteboardTypeTIFF]; if (tiff) image = [[NSBitmapImageRep imageRepWithData:tiff] representationUsingType:NSBitmapImageFileTypePNG properties:@{}]; }
-      if (image) content[@"imagePNG"] = [image base64EncodedStringWithOptions:0];
+      if (image) content[@"imagePNG"] = image;
       NSArray *urls = [board readObjectsForClasses:@[NSURL.class] options:@{ NSPasteboardURLReadingFileURLsOnlyKey: @YES }];
       if (urls.count) content[@"files"] = [urls valueForKey:@"path"];
-      resolve(SparkJSON(content)); return;
+      resolve(binary ? content : SparkJSON(content)); return;
     }
     if ([method isEqual:@"write"]) {
       NSMutableArray *objects = [NSMutableArray new];
@@ -62,7 +63,7 @@ RCT_EXPORT_MODULE(NativeDesktopClipboard)
         NSPasteboardItem *item = [NSPasteboardItem new];
         for (NSString *key in types) if (args[key]) [item setString:args[key] forType:types[key]];
         if (args[@"imagePNG"]) {
-          NSData *image = [[NSData alloc] initWithBase64EncodedString:args[@"imagePNG"] options:0];
+          NSData *image = args[@"imagePNG"];
           if (!image || ![NSBitmapImageRep imageRepWithData:image]) { SparkInvalid(reject, @"Invalid clipboard image"); return; }
           [item setData:image forType:NSPasteboardTypePNG];
         }
@@ -71,17 +72,10 @@ RCT_EXPORT_MODULE(NativeDesktopClipboard)
       [board clearContents]; if (objects.count && ![board writeObjects:objects]) { reject(@"E_CLIPBOARD", @"Could not write clipboard", nil); return; }
       resolve(@"null"); return;
     }
-    if ([method isEqual:@"readText"]) resolve(SparkJSON([board stringForType:NSPasteboardTypeString] ?: @""));
-    else if ([method isEqual:@"hasText"]) resolve(SparkJSON(@([board availableTypeFromArray:@[NSPasteboardTypeString]] != nil)));
-    else if ([method isEqual:@"writeText"]) {
-      if (![args[@"text"] isKindOfClass:NSString.class]) { SparkInvalid(reject, @"Expected clipboard text"); return; }
-      [board clearContents];
-      if (![board setString:args[@"text"] forType:NSPasteboardTypeString]) { reject(@"E_CLIPBOARD", @"Could not write clipboard", nil); return; }
-      resolve(@"null");
-    } else SparkInvalid(reject, @"Unknown clipboard operation");
+    SparkInvalid(reject, @"Unknown clipboard operation");
   });
 }
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
-  return std::make_shared<facebook::react::NativeDesktopClipboardSpecJSI>(params);
+  return std::make_shared<spark::binary::Module<facebook::react::NativeDesktopClipboardSpecJSI>>(params);
 }
 @end

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

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-clipboard",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index",
   "react-native": "src/index",
@@ -41,7 +41,7 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4"
   },
   "peerDependenciesMeta": {
     "expo-clipboard": {

package/vendor/node_modules/@legendapp/spark-clipboard/src/NativeDesktopClipboard.ts

@@ -3,4 +3,4 @@ import { TurboModuleRegistry } from "react-native";
 export interface Spec extends TurboModule {
   call(method: string, args: string): Promise<string>;
 }
-export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopClipboard");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopClipboard");

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

@@ -1,39 +1,63 @@
 import { Platform } from "react-native";
+import { callBinary, nativeBytes } from "@legendapp/spark-desktop-app/src/contracts/native-buffer";
+import { SparkError, parseNativeResult, invokeNative, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+import { nativePath } from "@legendapp/spark-desktop-app/src/contracts/path";
 import Native from "./NativeDesktopClipboard";
-async function call<T = void>(method: string, args: object = {}): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))) as T; }
-export const readClipboardText = () => call<string>("readText");
-export const writeClipboardText = (text: string) => call("writeText", { text });
-export const hasClipboardText = () => call<boolean>("hasText");
-
-export type ClipboardContent = { text?: string; html?: string; rtf?: string; imagePNG?: string; files?: string[] };
-/** imagePNG contains base64-encoded PNG bytes. */
-export async function readClipboard(): Promise<ClipboardContent> { return JSON.parse(await Native.call("read", "{}")); }
-export async function getClipboardFormats(): Promise<string[]> { return JSON.parse(await Native.call("formats", "{}")); }
-export async function clearClipboard() { await Native.call("clear", "{}"); }
-export async function writeClipboard(content: ClipboardContent) {
-  for (const key of Object.keys(content)) if (!["text", "html", "rtf", "imagePNG", "files"].includes(key)) throw new Error(`Unknown clipboard format: ${key}`);
-  if (content.files && (Object.keys(content).length !== 1 || content.files.some(file => Platform.OS === "windows" ? !/^(?:[a-z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+)/i.test(file) : !file.startsWith("/")))) throw new Error("Files must be absolute paths and written separately from other formats");
-  for (const key of ["text", "html", "rtf", "imagePNG"] as const) if (content[key] !== undefined && typeof content[key] !== "string") throw new Error(`Invalid clipboard ${key}`);
-  await Native.call("write", JSON.stringify(content));
-}
-
-import { StringFormat } from "./formats";
+import { stringOptions } from "./options";
+import type { ClipboardContent, ClipboardWriteContent, GetStringOptions, SetStringOptions } from "./types";
 export { StringFormat } from "./formats";
-export type GetStringOptions = { preferredFormat?: StringFormat };
-export type SetStringOptions = { inputFormat?: StringFormat };
-function stringOptions(options: object, key: string) {
-  if (!options || Object.keys(options).some(name => name !== key)) throw new Error("Unsupported clipboard option");
-  const format = (options as Record<string, unknown>)[key] ?? StringFormat.PLAIN_TEXT;
-  if (format !== StringFormat.PLAIN_TEXT && format !== StringFormat.HTML) throw new Error("Invalid clipboard string format");
-  return format;
+export type { ClipboardContent, ClipboardWriteContent, ClipboardImage, GetStringOptions, SetStringOptions } from "./types";
+export function getRichClipboardAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+function native() {
+  const availability = getRichClipboardAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Desktop clipboard module is unavailable");
+  return Native!;
+}
+async function call<T>(method: string, args: object, validate: (value: unknown) => value is T): Promise<T> {
+  return parseNativeResult(await invokeNative(() => native().call(method, JSON.stringify(args))), validate);
 }
-/** Expo-compatible text/HTML subset. Rich desktop formats remain available above. */
+const isVoid = (value: unknown): value is null => value === null;
+const isBoolean = (value: unknown): value is boolean => typeof value === "boolean";
+/** Expo-compatible text/HTML subset. */
 export async function getStringAsync(options: GetStringOptions = {}): Promise<string> {
-  return call("getString", { format: stringOptions(options, "preferredFormat") });
+  return call("getString", { format: stringOptions(options, "preferredFormat") }, (value): value is string => typeof value === "string");
 }
 export async function setStringAsync(text: string, options: SetStringOptions = {}): Promise<boolean> {
-  if (typeof text !== "string") throw new TypeError("Clipboard text must be a string");
-  await call("setString", { text, format: stringOptions(options, "inputFormat") });
-  return true;
+  if (typeof text !== "string") throw new SparkError("E_INVALID_ARGUMENT", "Clipboard text must be a string");
+  return call("setString", { text, format: stringOptions(options, "inputFormat") }, isBoolean);
+}
+export async function hasStringAsync(): Promise<boolean> { return call("hasString", {}, (value): value is boolean => typeof value === "boolean"); }
+export async function readClipboard(): Promise<ClipboardContent> {
+  const raw = await invokeNative(() => callBinary(native(), "__sparkClipboardBinary", "read", {})) as Record<string, unknown>;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new SparkError("E_INVALID_DATA", "Invalid clipboard content");
+  const result: ClipboardContent = {};
+  for (const key of ["text", "html", "rtf"] as const) {
+    if (raw[key] !== undefined && typeof raw[key] !== "string") throw new SparkError("E_INVALID_DATA", `Invalid clipboard ${key}`);
+    if (typeof raw[key] === "string") result[key] = raw[key];
+  }
+  if (raw.files !== undefined) {
+    if (!Array.isArray(raw.files) || raw.files.some(value => typeof value !== "string")) throw new SparkError("E_INVALID_DATA", "Invalid clipboard files");
+    try { result.files = raw.files.map(value => nativePath(value, Platform.OS)); }
+    catch (cause) { throw new SparkError("E_INVALID_DATA", "Invalid clipboard file paths", { cause }); }
+  }
+  if (raw.imagePNG !== undefined) {
+    result.image = { format: "png", bytes: nativeBytes(raw.imagePNG) };
+  }
+  return result;
+}
+export async function getClipboardFormats(): Promise<string[]> { return call("formats", {}, (value): value is string[] => Array.isArray(value) && value.every(format => typeof format === "string")); }
+export async function clearClipboard(): Promise<void> { await call("clear", {}, isVoid); }
+export async function writeClipboard(content: ClipboardWriteContent): Promise<void> {
+  if (!content || typeof content !== "object" || Array.isArray(content)) throw new SparkError("E_INVALID_ARGUMENT", "Expected clipboard content");
+  for (const key of Object.keys(content)) if (!["text", "html", "rtf", "image", "files"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown clipboard format: ${key}`);
+  for (const key of ["text", "html", "rtf"] as const) if (content[key] !== undefined && typeof content[key] !== "string") throw new SparkError("E_INVALID_ARGUMENT", `Invalid clipboard ${key}`);
+  if (content.files !== undefined && (!Array.isArray(content.files) || Object.entries(content).some(([key, value]) => key !== "files" && value !== undefined))) throw new SparkError("E_INVALID_ARGUMENT", "Files must be written separately from other formats");
+  const files = content.files?.map(path => nativePath(path, Platform.OS));
+  const { image, ...rest } = content;
+  if (image !== undefined && (!image || image.format !== "png" || !(image.bytes instanceof Uint8Array))) throw new SparkError("E_INVALID_ARGUMENT", "Expected PNG image bytes");
+  const response = await invokeNative(() => callBinary(native(), "__sparkClipboardBinary", "write", { ...rest, files }, image?.bytes));
+  if (response !== null) throw new SparkError("E_INVALID_DATA", "Invalid native clipboard response");
 }
-export const hasStringAsync = (): Promise<boolean> => call("hasString");

package/vendor/node_modules/@legendapp/spark-clipboard/src/expo.ts

@@ -1,12 +1,22 @@
 import * as Clipboard from "expo-clipboard";
-export { getStringAsync, setStringAsync, hasStringAsync, StringFormat } from "expo-clipboard";
-export type { GetStringOptions, SetStringOptions } from "expo-clipboard";
-export type { ClipboardContent } from "./index";
-export const readClipboardText = Clipboard.getStringAsync;
-export async function writeClipboardText(text: string): Promise<void> { await Clipboard.setStringAsync(text); }
-export const hasClipboardText = Clipboard.hasStringAsync;
-const unavailable = async (..._args: unknown[]): Promise<never> => { throw Object.assign(new Error("Rich desktop clipboard operations are unavailable on this platform"), { code: "E_UNAVAILABLE" }); };
-export const readClipboard = unavailable;
-export const getClipboardFormats = unavailable;
-export const clearClipboard = unavailable;
-export const writeClipboard = unavailable;
+import { SparkError, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+import { StringFormat } from "./formats";
+import { stringOptions } from "./options";
+import type { ClipboardContent, ClipboardWriteContent, GetStringOptions, SetStringOptions } from "./types";
+export { StringFormat } from "./formats";
+export type { ClipboardContent, ClipboardWriteContent, ClipboardImage, GetStringOptions, SetStringOptions } from "./types";
+export async function getStringAsync(options: GetStringOptions = {}): Promise<string> {
+  const format = stringOptions(options, "preferredFormat");
+  return Clipboard.getStringAsync({ preferredFormat: format === StringFormat.HTML ? Clipboard.StringFormat.HTML : Clipboard.StringFormat.PLAIN_TEXT });
+}
+export async function setStringAsync(text: string, options: SetStringOptions = {}): Promise<boolean> {
+  const format = stringOptions(options, "inputFormat");
+  return Clipboard.setStringAsync(text, { inputFormat: format === StringFormat.HTML ? Clipboard.StringFormat.HTML : Clipboard.StringFormat.PLAIN_TEXT });
+}
+export const hasStringAsync = Clipboard.hasStringAsync;
+export function getRichClipboardAvailability(): Availability { return { available: false, reason: "unsupported-platform" }; }
+function unavailable(): never { throw new SparkError("E_UNSUPPORTED_PLATFORM", "Rich clipboard operations require a desktop host"); }
+export async function readClipboard(): Promise<ClipboardContent> { return unavailable(); }
+export async function getClipboardFormats(): Promise<string[]> { return unavailable(); }
+export async function clearClipboard(): Promise<void> { return unavailable(); }
+export async function writeClipboard(_content: ClipboardWriteContent): Promise<void> { return unavailable(); }

package/vendor/node_modules/@legendapp/spark-clipboard/src/options.ts

@@ -0,0 +1,8 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { StringFormat } from "./formats";
+export function stringOptions(options: object, key: string): StringFormat {
+  if (!options || typeof options !== "object" || Object.keys(options).some(name => name !== key)) throw new SparkError("E_UNSUPPORTED_OPTION", "Unsupported clipboard option");
+  const format = (options as Record<string, unknown>)[key] ?? StringFormat.PLAIN_TEXT;
+  if (format !== StringFormat.PLAIN_TEXT && format !== StringFormat.HTML) throw new SparkError("E_INVALID_ARGUMENT", "Invalid clipboard string format");
+  return format;
+}

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

@@ -0,0 +1,10 @@
+import type { StringFormat } from "./formats";
+export type GetStringOptions = { preferredFormat?: StringFormat };
+export type SetStringOptions = { inputFormat?: StringFormat };
+export interface ClipboardImage { format: "png"; bytes: Uint8Array }
+/** Reading preserves all OS representations, which can coexist. */
+export interface ClipboardContent { text?: string; html?: string; rtf?: string; image?: ClipboardImage; files?: readonly string[] }
+/** File lists must be written separately from text/image representations. */
+export type ClipboardWriteContent =
+  | { files: readonly string[]; text?: never; html?: never; rtf?: never; image?: never }
+  | { files?: never; text?: string; html?: string; rtf?: string; image?: ClipboardImage };