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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LegendApp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -6,7 +6,7 @@ Legend Spark adds native desktop APIs and a managed development workflow to Reac
 
 ## Try the experimental release
 
-You need Node 24.19.0 or newer. The npm package supplies the public API and `spark` command; the matching macOS Apple Silicon Runner downloads automatically on first launch.
+Requires Node 24.19.0 or newer. The single `@legendapp/spark` npm package contains the CLI and private implementation modules; no separate Spark module installs are needed. Bun is optional.
 
 ```sh
 npx @legendapp/spark@next create MyApp
@@ -14,8 +14,14 @@ cd MyApp
 npm run macos
 ```
 
-The development command downloads and caches a compatible Runner automatically. JavaScript edits use Fast Refresh; native changes require rebuilding.
+The published CLI uses matching GitHub release assets for patched native dependencies and automatically downloads the macOS ARM64 Spark Runner on first desktop launch. JavaScript edits use Fast Refresh. Native changes require a compatible runtime rebuild and native build tools.
 
-macOS on Apple Silicon is the primary experimental target. Windows development implementations still need native acceptance; Windows production builds are not supported. Mobile and web use Expo workflows with selected shared adapters.
+Source/local archives without embedded release metadata require a registered local SDK; see the repository setup guide.
 
-[Documentation](https://legend.so/spark) · [Source and current setup guide](https://github.com/LegendApp/legend-spark) · [Known Windows limitations](https://github.com/LegendApp/legend-spark/blob/main/docs/windows-issues.md)
+macOS 14+ on Apple Silicon is the primary experimental target. Windows development implementations still need native acceptance; Windows production builds and a downloadable Windows Runner are not supplied by this prerelease workflow. Mobile and web use Expo workflows with selected shared adapters.
+
+[Documentation](https://legend.so/spark) · [Source and setup guide](https://github.com/LegendApp/legend-spark) · [Known Windows limitations](https://github.com/LegendApp/legend-spark/blob/main/docs/windows-issues.md)
+
+[Desktop application capabilities](https://github.com/LegendApp/legend-spark/blob/main/docs/desktop-capabilities.md)
+cover managed windows, document helpers, routed commands, native controls,
+settings windows, and the shared desktop integrations.

package/ai-codex.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-codex";

package/ai.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-ai";

package/app-documents.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-documents/src/index.tsx";

package/camera.ts

@@ -0,0 +1,13 @@
+export {
+  Camera, VisionCamera, getCameraDevice, getAllCameraDevices, getDefaultCameraDevice,
+  addOnCameraDevicesChangedListener, useCamera, useCameraDevice, useCameraDevices,
+  useCameraPermission, useMicrophonePermission, usePhotoOutput, useVideoOutput,
+} from "react-native-vision-camera";
+export type {
+  CameraDevice, CameraRef, CameraViewProps, CameraProps, CameraSession,
+  CameraSessionConfig, CameraSessionConfiguration, CameraController, CameraFactory,
+  CameraPhotoOutput, CameraVideoOutput, PhotoOutputOptions, VideoOutputOptions,
+  Photo, Recorder, PermissionStatus, PermissionState, Constraint,
+} from "react-native-vision-camera";
+export { NitroImage } from "react-native-nitro-image";
+export type { Image } from "react-native-nitro-image";

package/config-plugin.d.cts

@@ -0,0 +1,2 @@
+import plugin = require("./vendor/node_modules/@legendapp/spark-desktop-config/app.plugin.cjs");
+export = plugin;

package/contracts.ts

@@ -0,0 +1,2 @@
+export { SparkError } from "./vendor/node_modules/@legendapp/spark-desktop-app/src/contracts";
+export type { SparkErrorCode, Availability, Subscription, AsyncRegistration } from "./vendor/node_modules/@legendapp/spark-desktop-app/src/contracts";

package/diagnostics.ts

@@ -0,0 +1 @@
+export { getStartupTiming, type StartupTiming } from "./vendor/node_modules/@legendapp/spark-desktop-windows/src/diagnostics";

package/expo-config.d.cts

@@ -0,0 +1 @@
+export { withSparkExpo } from "./vendor/node_modules/@legendapp/spark-desktop-config/expo.cjs";

package/metro.cjs

@@ -1 +1,4 @@
-module.exports = require("./vendor/node_modules/@legendapp/spark-cli/dist/metro.cjs");
+const { withDesktop } = require("./vendor/node_modules/@legendapp/spark-cli/dist/metro.cjs");
+const { getDefaultConfig, withSparkMetro } = require("./vendor/node_modules/@legendapp/spark-cli/dist/expo-metro.cjs");
+const { metroConfig } = require("./vendor/node_modules/@legendapp/spark-cli/dist/universal.cjs");
+module.exports = { withDesktop, metroConfig, getDefaultConfig, withSparkMetro };

package/metro.d.cts

@@ -0,0 +1,12 @@
+import type { getDefaultConfig as expoDefaults } from "expo/metro-config";
+export interface DesktopMetroOptions { runtimes?: boolean; watch?: boolean }
+export type MetroConfiguration = ReturnType<typeof expoDefaults>;
+/** Spark-owned project: chooses target defaults and installs desktop/runtime integration. */
+export function metroConfig(root: string): MetroConfiguration;
+/** Existing Expo project: obtain defaults before applying application customizations. */
+export const getDefaultConfig: typeof expoDefaults;
+/** Complete an existing Expo project's composition after application customizations. */
+export function withSparkMetro<T extends Partial<MetroConfiguration>>(config: T): T;
+export function withSparkMetro<T extends Partial<MetroConfiguration>>(config: Promise<T>): Promise<T>;
+/** Advanced integration of an already configured desktop Metro instance. */
+export function withDesktop<T extends Partial<MetroConfiguration>>(config: T, options?: DesktopMetroOptions): T;

package/native.cjs

@@ -1 +1,3 @@
-module.exports = require("./vendor/node_modules/@legendapp/spark-cli/dist/expo-native.cjs");
+const { nativeConfig } = require("./vendor/node_modules/@legendapp/spark-cli/dist/universal.cjs");
+const { withSparkNative } = require("./vendor/node_modules/@legendapp/spark-cli/dist/expo-native.cjs");
+module.exports = { nativeConfig, withSparkNative };

package/native.d.cts

@@ -0,0 +1,6 @@
+import type { UserConfig } from "@react-native-community/cli-types";
+export type NativeConfiguration = Pick<Partial<UserConfig>, "platforms" | "dependencies">;
+/** Spark-owned project: generate native discovery configuration. */
+export function nativeConfig(root: string): NativeConfiguration;
+/** Existing Expo project: compose with its React Native CLI configuration. */
+export function withSparkNative<T extends Partial<UserConfig>>(config: T, root: string): T & NativeConfiguration;

package/package.json

@@ -1,7 +1,24 @@
 {
   "name": "@legendapp/spark",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LegendApp/legend-spark.git",
+    "directory": "packages/desktop"
+  },
+  "homepage": "https://github.com/LegendApp/legend-spark#readme",
+  "bugs": {
+    "url": "https://github.com/LegendApp/legend-spark/issues"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "desktop",
+    "macos",
+    "windows",
+    "native"
+  ],
   "exports": {
     "./dialogs": "./dialogs.ts",
     "./menus": "./menus.ts",
@@ -20,7 +37,6 @@
     "./updates": "./updates.ts",
     "./processes": "./processes.ts",
     "./system": "./system.ts",
-    "./message-dialog": "./message-dialog.ts",
     "./global-shortcuts": "./global-shortcuts.ts",
     "./drag-drop": "./drag-drop.ts",
     "./webview": "./webview.ts",
@@ -33,38 +49,60 @@
     "./config-plugin": "./config-plugin.cjs",
     "./expo-config": "./expo-config.cjs",
     "./metro": "./metro.cjs",
-    "./expo-metro": "./expo-metro.cjs",
-    "./universal": "./universal.cjs",
     "./runtime-entry": "./runtime-entry.cjs",
     "./metro-gate": "./metro-gate.cjs",
     "./init-template": "./init-template.cjs",
     "./native": "./native.cjs",
     "./cli": "./bin/spark.cjs",
-    "./schema.json": "./schema.json"
+    "./schema.json": "./schema.json",
+    "./ui/split-view": "./ui-split-view.ts",
+    "./ui/sidebar": "./ui-sidebar.ts",
+    "./app/documents": "./app-documents.ts",
+    "./shortcuts/commands": "./shortcuts-commands.ts",
+    "./shortcuts/keyboard": "./shortcuts-keyboard.ts",
+    "./ui/glass": "./ui-glass.ts",
+    "./ui/swipe": "./ui-swipe.ts",
+    "./ui/symbol": "./ui-symbol.ts",
+    "./ui/search": "./ui-search.ts",
+    "./settings/window": "./settings-window.ts",
+    "./settings/observable": "./settings-observable.ts",
+    "./ui/classnames": "./ui-classnames.ts",
+    "./contracts": "./contracts.ts",
+    "./windows/macos": "./windows-macos.ts",
+    "./diagnostics": "./diagnostics.ts",
+    "./ai": "./ai.ts",
+    "./ai/codex": "./ai-codex.ts",
+    "./camera": "./camera.ts"
   },
   "files": [
     "*.ts",
     "*.cjs",
     "schema.json",
     "bin",
-    "*.d.cts"
+    "*.d.cts",
+    "patches"
   ],
   "dependencies": {
     "base64-js": "1.5.1",
-    "ws": "8.18.3",
-    "expo-desktop": "1.0.0-beta.6",
-    "npm": "11.11.0",
+    "ws": "8.21.0",
+    "expo-desktop": "1.0.0",
+    "npm": "11.21.0",
     "typescript": "5.9.3",
     "cross-spawn": "7.0.6",
-    "expo-desktop-config-plugins": "1.2.0-beta.1",
+    "react-native-nitro-modules": "0.37.0",
+    "@legendapp/state": "^3.0.0-beta.42",
+    "expo-desktop-config-plugins": "1.2.0",
     "@expo/config-plugins": "54.0.5",
+    "@expo/config-types": "54.0.10",
+    "diff": "8.0.2",
     "@react-native-runtimes/core": "0.1.0-alpha.2",
-    "react-native-nitro-modules": "0.35.7",
-    "expo": "54.0.37",
-    "react": "19.1.4",
-    "react-native": "0.81.6",
-    "react-dom": "19.1.4",
+    "@react-native-community/cli-types": "20.1.3",
+    "react-native-vision-camera": "5.2.3",
+    "react-native-nitro-image": "0.15.2",
+    "react-native-enriched-markdown": "1.0.2",
     "@op-engineering/op-sqlite": "18.2.1",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^3.4.0",
     "react-native-webview": "16.0.0"
   },
   "description": "Legend Spark — native applications with React Native and Expo",
@@ -85,6 +123,7 @@
     "react-dom": "19.1.4",
     "expo-linking": "~8.0.12",
     "expo-secure-store": "~15.0.8",
+    "@legendapp/list": ">=3.3.0",
     "@expo/ui": "0.2.0-beta.9",
     "uniwind": "^1.6.3",
     "react-native-windows": "0.81.35"
@@ -125,12 +164,49 @@
     "access": "public",
     "tag": "next"
   },
+  "scripts": {
+    "postinstall": "node postinstall.cjs"
+  },
   "spark": {
+    "nativePatchRequirements": {
+      "schema": 1,
+      "frameworkVersion": "0.0.1-next.4",
+      "packages": {
+        "@react-native-runtimes/core": {
+          "version": "0.1.0-alpha.2",
+          "patchHash": "985164a87eb04010a8d849f5b0ca22a76548dc3f73a64a6183683ca90932ec2c",
+          "upstreamRevision": "58710c25c6e505dcc1292ee54d855408a6f7a42d"
+        },
+        "react-native-nitro-modules": {
+          "version": "0.37.0",
+          "patchHash": "bd582f6bd686bd9058a2eae193854e86a1f66d0d8334fbcafd2b0cab16dadaa4",
+          "upstreamIntegrity": "sha512-ULS2CBZcdwGw5d4Y35EV/tbCOsNsQOnQ9LC9CehMhDNm5c90lwF/LxRamzKuFpjI547G7teTQgD0peqYSGnP9g=="
+        },
+        "@op-engineering/op-sqlite": {
+          "version": "18.2.1",
+          "patchHash": "d535dcd20aa0f5bcf8860086eb6484c73b1e84d8a586ea9fe74dca76085955a0",
+          "upstreamIntegrity": "sha512-atVOtXyFzO0e454eVS27AMwRs515URCKrkvLLG+mGKcyiF5UPfC53oukpNp2UmVzlLebyTEXNkTYs6n0dVGd0g=="
+        },
+        "react-native-webview": {
+          "version": "16.0.0",
+          "patchHash": "43cfd2d36780e085223bc7497719c7c64ec1bea1da82362e751f9937a0349e1a",
+          "upstreamIntegrity": "sha512-KIg5Yhy04lQfHdXC1JQPM+0kftMfPnH6AqDH7v6YskQ9kzfUacooofOFRmbaZHASq/0WY87Fx0peiFETFjOcCg=="
+        },
+        "expo-audio": {
+          "version": "1.1.1",
+          "patchHash": "e9348063295113222c6d03e5bf8cac2c3a7a0b283e40166c257fad60b423dd14",
+          "upstreamIntegrity": "sha512-CPCpJ+0AEHdzWROc0f00Zh6e+irLSl2ALos/LPvxEeIcJw1APfBa4DuHPkL4CQCWsVe7EnUjFpdwpqsEUWcP0g=="
+        }
+      }
+    },
     "bundledModules": [
+      "@legendapp/spark-ai",
       "@legendapp/spark-audio",
       "@legendapp/spark-auth-session",
       "@legendapp/spark-cli",
       "@legendapp/spark-clipboard",
+      "@legendapp/spark-codex",
+      "@legendapp/spark-commands",
       "@legendapp/spark-desktop-config",
       "@legendapp/spark-context-menu",
       "@legendapp/spark-desktop-app",
@@ -138,6 +214,7 @@
       "@legendapp/spark-desktop-links",
       "@legendapp/spark-desktop-shortcuts",
       "@legendapp/spark-desktop-windows",
+      "@legendapp/spark-documents",
       "@legendapp/spark-drag-drop",
       "@legendapp/spark-file-dialog",
       "@legendapp/spark-file-system",
@@ -148,6 +225,7 @@
       "@legendapp/spark-processes",
       "@legendapp/spark-secure-storage",
       "@legendapp/spark-settings",
+      "@legendapp/spark-settings-ui",
       "@legendapp/spark-sqlite",
       "@legendapp/spark-system",
       "@legendapp/spark-tray",

package/patches/camera/react-native-nitro-image.patch

@@ -0,0 +1,320 @@
+diff --git a/NitroImage.podspec b/NitroImage.podspec
+index 4b8f577..6aa9982 100644
+--- a/NitroImage.podspec
++++ b/NitroImage.podspec
+@@ -10,14 +10,18 @@ Pod::Spec.new do |s|
+   s.license      = package["license"]
+   s.authors      = package["author"]
+ 
+-  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
++  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0, :osx => "14.0" }
++  s.osx.prefix_header_contents = "#include <CoreGraphics/CoreGraphics.h>"
+   s.source       = { :git => "https://github.com/mrousavy/nitro.git", :tag => "#{s.version}" }
+ 
++  s.ios.source_files = "ios/**/*.{swift,m,mm}"
++  s.visionos.source_files = "ios/**/*.{swift,m,mm}"
++  s.osx.source_files = "macos/**/*.swift"
+   s.source_files = [
+     # Implementation (Swift)
+-    "ios/**/*.{swift}",
++    
+     # Autolinking/Registration (Objective-C++)
+-    "ios/**/*.{m,mm}",
++    
+     # Implementation (C++ objects)
+     "cpp/**/*.{hpp,cpp}",
+   ]
+diff --git a/macos/MacImage.swift b/macos/MacImage.swift
+new file mode 100644
+index 0000000..3c5623e
+--- /dev/null
++++ b/macos/MacImage.swift
+@@ -0,0 +1,183 @@
++import AppKit
++import CoreGraphics
++import CoreImage
++import ImageIO
++import UniformTypeIdentifiers
++import NitroModules
++
++public protocol NativeImage { var cgImage: CGImage { get } }
++
++private func bitmap(_ width: Double, _ height: Double) throws -> CGContext {
++  guard width.isFinite, height.isFinite, width > 0, height > 0, width <= 32768, height <= 32768,
++        let context = CGContext(data: nil, width: Int(width.rounded(.up)), height: Int(height.rounded(.up)), bitsPerComponent: 8, bytesPerRow: Int(width.rounded(.up)) * 4, space: CGColorSpace(name: CGColorSpace.sRGB)!, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else {
++    throw RuntimeError.error(withMessage: "Invalid image dimensions")
++  }
++  return context
++}
++
++public final class HybridCGImage: HybridImageSpec, NativeImage {
++  public let cgImage: CGImage
++  public init(cgImage: CGImage) { self.cgImage = cgImage; super.init() }
++  public var width: Double { Double(cgImage.width) }
++  public var height: Double { Double(cgImage.height) }
++  public var memorySize: Int { cgImage.bytesPerRow * cgImage.height }
++  private func render(_ width: Double, _ height: Double, draw: (CGContext) -> Void) throws -> any HybridImageSpec {
++    let context = try bitmap(width, height); draw(context)
++    guard let image = context.makeImage() else { throw RuntimeError.error(withMessage: "Failed to render image") }
++    return HybridCGImage(cgImage: image)
++  }
++  public func toRawPixelData(allowGpu: Bool?) throws -> RawPixelData {
++    let context = try bitmap(width, height)
++    context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
++    guard let pointer = context.data else { throw RuntimeError.error(withMessage: "Missing pixel data") }
++    let data = Data(bytes: pointer, count: context.bytesPerRow * context.height)
++    return RawPixelData(buffer: try ArrayBuffer.copy(data: data), width: width, height: height, pixelFormat: .rgba)
++  }
++  public func toRawPixelDataAsync(allowGpu: Bool?) throws -> Promise<RawPixelData> { Promise.async { try self.toRawPixelData(allowGpu: allowGpu) } }
++  public func toEncodedImageData(format: ImageFormat, quality: Double?) throws -> EncodedImageData {
++    let type: CFString
++    switch format { case .jpg: type = UTType.jpeg.identifier as CFString; case .png: type = UTType.png.identifier as CFString; case .heic: type = UTType.heic.identifier as CFString }
++    let data = NSMutableData()
++    guard let destination = CGImageDestinationCreateWithData(data, type, 1, nil) else { throw RuntimeError.error(withMessage: "Image encoder is unavailable") }
++    CGImageDestinationAddImage(destination, cgImage, [kCGImageDestinationLossyCompressionQuality: max(0, min(100, quality ?? 100)) / 100] as CFDictionary)
++    guard CGImageDestinationFinalize(destination) else { throw RuntimeError.error(withMessage: "Image encoding failed") }
++    return EncodedImageData(buffer: try ArrayBuffer.copy(data: data as Data), width: width, height: height, imageFormat: format)
++  }
++  public func toEncodedImageDataAsync(format: ImageFormat, quality: Double?) throws -> Promise<EncodedImageData> { Promise.async { try self.toEncodedImageData(format: format, quality: quality) } }
++  public func resize(width: Double, height: Double) throws -> any HybridImageSpec {
++    try render(width, height) { $0.interpolationQuality = .high; $0.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height)) }
++  }
++  public func resizeAsync(width: Double, height: Double) throws -> Promise<any HybridImageSpec> { Promise.async { try self.resize(width: width, height: height) } }
++  public func rotate(degrees: Double, allowFastFlagRotation: Bool?) throws -> any HybridImageSpec {
++    guard degrees.isFinite else { throw RuntimeError.error(withMessage: "Invalid rotation") }
++    let radians = degrees * .pi / 180
++    let bounds = CGRect(x: 0, y: 0, width: width, height: height).applying(CGAffineTransform(rotationAngle: radians))
++    return try render(abs(bounds.width), abs(bounds.height)) { context in
++      context.translateBy(x: abs(bounds.width) / 2, y: abs(bounds.height) / 2); context.rotate(by: -radians)
++      context.draw(cgImage, in: CGRect(x: -width / 2, y: -height / 2, width: width, height: height))
++    }
++  }
++  public func rotateAsync(degrees: Double, allowFastFlagRotation: Bool?) throws -> Promise<any HybridImageSpec> { Promise.async { try self.rotate(degrees: degrees, allowFastFlagRotation: allowFastFlagRotation) } }
++  public func crop(startX: Double, startY: Double, endX: Double, endY: Double) throws -> any HybridImageSpec {
++    guard startX >= 0, startY >= 0, endX <= width, endY <= height, endX > startX, endY > startY,
++          let image = cgImage.cropping(to: CGRect(x: startX, y: startY, width: endX - startX, height: endY - startY)) else { throw RuntimeError.error(withMessage: "Invalid crop rectangle") }
++    return HybridCGImage(cgImage: image)
++  }
++  public func cropAsync(startX: Double, startY: Double, endX: Double, endY: Double) throws -> Promise<any HybridImageSpec> { Promise.async { try self.crop(startX: startX, startY: startY, endX: endX, endY: endY) } }
++  public func mirrorHorizontally() throws -> any HybridImageSpec { try render(width, height) { $0.translateBy(x: width, y: 0); $0.scaleBy(x: -1, y: 1); $0.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height)) } }
++  public func mirrorHorizontallyAsync() throws -> Promise<any HybridImageSpec> { Promise.async { try self.mirrorHorizontally() } }
++  public func saveToFileAsync(path: String, format: ImageFormat, quality: Double?) throws -> Promise<Void> {
++    Promise.async {
++      let url = path.hasPrefix("file://") ? URL(string: path)! : URL(fileURLWithPath: path)
++      try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
++      let encoded = try self.toEncodedImageData(format: format, quality: quality)
++      try encoded.buffer.toData(copyIfNeeded: false).write(to: url, options: .atomic)
++    }
++  }
++  public func saveToTemporaryFileAsync(format: ImageFormat, quality: Double?) throws -> Promise<String> {
++    Promise.async {
++      let path = FileManager.default.temporaryDirectory.appendingPathComponent("\(UUID()).\(format.stringValue)").path
++      let encoded = try self.toEncodedImageData(format: format, quality: quality)
++      try encoded.buffer.toData(copyIfNeeded: false).write(to: URL(fileURLWithPath: path), options: .atomic)
++      return path
++    }
++  }
++  public func toThumbHash() throws -> ArrayBuffer { throw RuntimeError.error(withMessage: "ThumbHash is not implemented in the macOS prototype") }
++  public func toThumbHashAsync() throws -> Promise<ArrayBuffer> { Promise.async { try self.toThumbHash() } }
++  public func renderInto(image: any HybridImageSpec, x: Double, y: Double, width: Double, height: Double) throws -> any HybridImageSpec {
++    guard let target = image as? NativeImage else { throw RuntimeError.error(withMessage: "Expected a native macOS image") }
++    return try render(image.width, image.height) { context in
++      context.draw(target.cgImage, in: CGRect(x: 0, y: 0, width: image.width, height: image.height))
++      context.draw(cgImage, in: CGRect(x: x, y: image.height - y - height, width: width, height: height))
++    }
++  }
++  public func renderIntoAsync(image: any HybridImageSpec, x: Double, y: Double, width: Double, height: Double) throws -> Promise<any HybridImageSpec> { Promise.async { try self.renderInto(image: image, x: x, y: y, width: width, height: height) } }
++}
++
++final class HybridImageFactory: HybridImageFactorySpec {
++  func createBlankImage(width: Double, height: Double, enableAlpha: Bool, fill: Color?) throws -> any HybridImageSpec {
++    let context = try bitmap(width, height)
++    context.setFillColor(red: fill?.r ?? 0, green: fill?.g ?? 0, blue: fill?.b ?? 0, alpha: enableAlpha ? (fill?.a ?? 0) : 1)
++    context.fill(CGRect(x: 0, y: 0, width: width, height: height))
++    return HybridCGImage(cgImage: context.makeImage()!)
++  }
++  func createBlankImageAsync(width: Double, height: Double, enableAlpha: Bool, fill: Color?) throws -> Promise<any HybridImageSpec> { Promise.async { try self.createBlankImage(width: width, height: height, enableAlpha: enableAlpha, fill: fill) } }
++  func loadFromFile(filePath: String) throws -> any HybridImageSpec {
++    let url = filePath.hasPrefix("file://") ? URL(string: filePath)! : URL(fileURLWithPath: filePath)
++    return try decode(Data(contentsOf: url))
++  }
++  private func decode(_ data: Data) throws -> any HybridImageSpec {
++    guard let source = CGImageSourceCreateWithData(data as CFData, nil), let image = CGImageSourceCreateImageAtIndex(source, 0, nil) else { throw RuntimeError.error(withMessage: "Failed to decode image") }
++    let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any]
++    let orientation = (properties?[kCGImagePropertyOrientation] as? NSNumber)?.int32Value ?? 1
++    let oriented = CIImage(cgImage: image).oriented(forExifOrientation: orientation)
++    guard let result = CIContext().createCGImage(oriented, from: oriented.extent) else { throw RuntimeError.error(withMessage: "Failed to orient image") }
++    return HybridCGImage(cgImage: result)
++  }
++  func loadFromFileAsync(filePath: String) throws -> Promise<any HybridImageSpec> { Promise.async { try self.loadFromFile(filePath: filePath) } }
++  func loadFromResources(name: String) throws -> any HybridImageSpec {
++    guard let url = Bundle.main.url(forResource: name, withExtension: nil) else { throw RuntimeError.error(withMessage: "Image resource not found: \(name)") }
++    return try loadFromFile(filePath: url.path)
++  }
++  func loadFromResourcesAsync(name: String) throws -> Promise<any HybridImageSpec> { Promise.async { try self.loadFromResources(name: name) } }
++  func loadFromSymbol(symbolName: String) throws -> any HybridImageSpec {
++    guard let image = NSImage(systemSymbolName: symbolName, accessibilityDescription: nil), let cgImage = image.cgImage(forProposedRect: nil, context: nil, hints: nil) else { throw RuntimeError.error(withMessage: "Symbol not found: \(symbolName)") }
++    return HybridCGImage(cgImage: cgImage)
++  }
++  func loadFromRawPixelData(data: RawPixelData, allowGpu: Bool?) throws -> any HybridImageSpec {
++    guard data.pixelFormat == .rgba, data.width > 0, data.height > 0, data.width <= 32768, data.height <= 32768, data.width.rounded() == data.width, data.height.rounded() == data.height else { throw RuntimeError.error(withMessage: "The macOS prototype accepts RGBA pixel data with integer dimensions") }
++    let bytes = data.buffer.toData(copyIfNeeded: true)
++    guard bytes.count == Int(data.width) * Int(data.height) * 4,
++          let provider = CGDataProvider(data: bytes as CFData),
++          let image = CGImage(width: Int(data.width), height: Int(data.height), bitsPerComponent: 8, bitsPerPixel: 32, bytesPerRow: Int(data.width) * 4, space: CGColorSpace(name: CGColorSpace.sRGB)!, bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue), provider: provider, decode: nil, shouldInterpolate: true, intent: .defaultIntent) else { throw RuntimeError.error(withMessage: "Invalid raw pixel buffer") }
++    return HybridCGImage(cgImage: image)
++  }
++  func loadFromRawPixelDataAsync(data: RawPixelData, allowGpu: Bool?) throws -> Promise<any HybridImageSpec> { Promise.async { try self.loadFromRawPixelData(data: data, allowGpu: allowGpu) } }
++  func loadFromEncodedImageData(data: EncodedImageData) throws -> any HybridImageSpec { try decode(data.buffer.toData(copyIfNeeded: true)) }
++  func loadFromEncodedImageDataAsync(data: EncodedImageData) throws -> Promise<any HybridImageSpec> { Promise.async { try self.loadFromEncodedImageData(data: data) } }
++  func loadFromThumbHash(thumbhash: ArrayBuffer) throws -> any HybridImageSpec { throw RuntimeError.error(withMessage: "ThumbHash is not implemented in the macOS prototype") }
++  func loadFromThumbHashAsync(thumbhash: ArrayBuffer) throws -> Promise<any HybridImageSpec> { Promise.async { try self.loadFromThumbHash(thumbhash: thumbhash) } }
++}
++
++final class HybridImageUtils: HybridImageUtilsSpec {
++  var supportsHeicLoading: Bool { (CGImageSourceCopyTypeIdentifiers() as! [String]).contains(UTType.heic.identifier) }
++  var supportsHeicWriting: Bool { (CGImageDestinationCopyTypeIdentifiers() as! [String]).contains(UTType.heic.identifier) }
++  func thumbHashToBase64String(thumbhash: ArrayBuffer) throws -> String { thumbhash.toData(copyIfNeeded: false).base64EncodedString() }
++  func thumbhashFromBase64String(thumbhashBase64: String) throws -> ArrayBuffer {
++    guard let data = Data(base64Encoded: thumbhashBase64) else { throw RuntimeError.error(withMessage: "Invalid base64") }
++    return try ArrayBuffer.copy(data: data)
++  }
++}
++
++final class HybridImageLoader: HybridImageLoaderSpec {
++  let load: () throws -> any HybridImageSpec
++  init(load: @escaping () throws -> any HybridImageSpec) { self.load = load; super.init() }
++  func loadImage() throws -> Promise<any HybridImageSpec> { Promise.async { try self.load() } }
++  func requestImage(forView: any HybridNitroImageViewSpec) throws { DispatchQueue.main.async { (forView as? HybridImageView)?.load(self) } }
++  func dropImage(forView: any HybridNitroImageViewSpec) throws { DispatchQueue.main.async { (forView as? HybridImageView)?.clear() } }
++}
++final class HybridImageLoaderFactory: HybridImageLoaderFactorySpec {
++  let factory = HybridImageFactory()
++  func createFileImageLoader(filePath: String) throws -> any HybridImageLoaderSpec { HybridImageLoader { try self.factory.loadFromFile(filePath: filePath) } }
++  func createResourceImageLoader(name: String) throws -> any HybridImageLoaderSpec { HybridImageLoader { try self.factory.loadFromResources(name: name) } }
++  func createSymbolImageLoader(symbolName: String) throws -> any HybridImageLoaderSpec { HybridImageLoader { try self.factory.loadFromSymbol(symbolName: symbolName) } }
++  func createRawPixelDataImageLoader(data: RawPixelData) throws -> any HybridImageLoaderSpec { HybridImageLoader { try self.factory.loadFromRawPixelData(data: data, allowGpu: false) } }
++  func createEncodedImageDataImageLoader(data: EncodedImageData) throws -> any HybridImageLoaderSpec { HybridImageLoader { try self.factory.loadFromEncodedImageData(data: data) } }
++}
++final class HybridImageView: HybridNitroImageViewSpec {
++  let view = NSView()
++  private var generation = 0
++  var resizeMode: ResizeMode? { didSet { view.layer?.contentsGravity = resizeMode == .contain ? .resizeAspect : resizeMode == .stretch ? .resize : resizeMode == .center ? .center : .resizeAspectFill } }
++  var recyclingKey: String? { didSet { if recyclingKey != oldValue { clear() } } }
++  var image: Variant__any_HybridImageSpec___any_HybridImageLoaderSpec_? { didSet {
++    clear()
++    switch image { case .first(let image): view.layer?.contents = (image as? NativeImage)?.cgImage; case .second(let loader): load(loader); case nil: break }
++  } }
++  override init() { super.init(); view.wantsLayer = true; view.layer?.masksToBounds = true; view.layer?.contentsGravity = .resizeAspectFill }
++  func clear() { generation += 1; view.layer?.contents = nil }
++  func load(_ loader: any HybridImageLoaderSpec) {
++    generation += 1; let token = generation
++    do { try loader.loadImage().then { [weak self] image in DispatchQueue.main.async { guard let self, self.generation == token else { return }; self.view.layer?.contents = (image as? NativeImage)?.cgImage } }.catch { [weak self] _ in DispatchQueue.main.async { guard let self, self.generation == token else { return }; self.clear() } } } catch { clear() }
++  }
++  func onDropView() { clear() }
++}
+diff --git a/nitrogen/generated/ios/NitroImage+autolinking.rb b/nitrogen/generated/ios/NitroImage+autolinking.rb
+index 06be8b7..2114874 100644
+--- a/nitrogen/generated/ios/NitroImage+autolinking.rb
++++ b/nitrogen/generated/ios/NitroImage+autolinking.rb
+@@ -54,6 +54,8 @@ def add_nitrogen_files(spec)
+     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+     # Enables C++ <-> Swift interop (by default it's only ObjC)
+     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
++    # Nitro's Fabric-only templates must not enter its Swift umbrella.
++    "HEADER_SEARCH_PATHS" => "$(inherited) $(PODS_ROOT)/Headers/Private",
+     # Enables stricter modular headers
+     "DEFINES_MODULE" => "YES",
+     # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+diff --git a/nitrogen/generated/ios/c++/views/HybridNitroImageViewComponent.mm b/nitrogen/generated/ios/c++/views/HybridNitroImageViewComponent.mm
+index 34ef3c1..b45a8b2 100644
+--- a/nitrogen/generated/ios/c++/views/HybridNitroImageViewComponent.mm
++++ b/nitrogen/generated/ios/c++/views/HybridNitroImageViewComponent.mm
+@@ -12,7 +12,12 @@
+ #import <React/RCTComponentViewFactory.h>
+ #import <React/UIView+ComponentViewProtocol.h>
+ #import <NitroModules/NitroDefines.hpp>
++#import <TargetConditionals.h>
++#if TARGET_OS_OSX
++#import <AppKit/AppKit.h>
++#else
+ #import <UIKit/UIKit.h>
++#endif
+ 
+ #import "HybridNitroImageViewSpecSwift.hpp"
+ #import "NitroImage-Swift-Cxx-Umbrella.hpp"
+@@ -65,12 +70,21 @@ - (void) updateView {
+ 
+   // 2. Get UIView*
+   void* viewUnsafe = swiftPart.getView();
++  #if TARGET_OS_OSX
++  NSView* view = (__bridge_transfer NSView*) viewUnsafe;
++#else
+   UIView* view = (__bridge_transfer UIView*) viewUnsafe;
++#endif
+ 
+   // 3. Update RCTViewComponentView's [contentView]
+   [self setContentView:view];
+ }
+ 
++// RN < 0.82 does not call invalidate for views which opt out of recycling.
++- (void) dealloc {
++  if (_hybridView != nullptr) [self notifyOnDropView];
++}
++
+ - (void) notifyOnDropView {
+   // A recycled component can later be invalidated. Notify only once per mount.
+   if (_didDropView) {
+diff --git a/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.cpp b/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.cpp
+index a65f0aa..1de5350 100644
+--- a/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.cpp
++++ b/nitrogen/generated/shared/c++/views/HybridNitroImageViewComponent.cpp
+@@ -7,6 +7,9 @@
+ 
+ #include "HybridNitroImageViewComponent.hpp"
+ 
++#if defined(__APPLE__)
++#include <TargetConditionals.h>
++#endif
+ #include <NitroModules/NitroHash.hpp>
+ #include <NitroModules/ReactProp.hpp>
+ 
+@@ -19,7 +22,11 @@ namespace margelo::nitro::image::views {
+   HybridNitroImageViewProps::HybridNitroImageViewProps(const react::PropsParserContext& context,
+                                                        const HybridNitroImageViewProps& sourceProps,
+                                                        const react::RawProps& rawProps):
+-    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
++    react::ViewProps(context, sourceProps, rawProps
++    #if !TARGET_OS_OSX
++          , filterObjectKeys
++    #endif
++        ),
+     image(nitro::ReactProp<std::optional<std::variant<std::shared_ptr<HybridImageSpec>, std::shared_ptr<HybridImageLoaderSpec>>>>::fromRawValue("NitroImageView", "image", rawProps, sourceProps.image)),
+     resizeMode(nitro::ReactProp<std::optional<ResizeMode>>::fromRawValue("NitroImageView", "resizeMode", rawProps, sourceProps.resizeMode)),
+     recyclingKey(nitro::ReactProp<std::optional<std::string>>::fromRawValue("NitroImageView", "recyclingKey", rawProps, sourceProps.recyclingKey)),
+diff --git a/package.json b/package.json
+index f22fe12..94be214 100644
+--- a/package.json
++++ b/package.json
+@@ -28,7 +28,8 @@
+     "app.plugin.js",
+     "nitro.json",
+     "*.podspec",
+-    "README.md"
++    "README.md",
++    "macos/**/*.swift"
+   ],
+   "scripts": {
+     "build": "rm -rf tsconfig.tsbuildinfo && rm -rf lib && bun typecheck && bob build",
+diff --git a/react-native.config.js b/react-native.config.js
+index 3fdf8ea..9c4bc69 100644
+--- a/react-native.config.js
++++ b/react-native.config.js
+@@ -7,6 +7,7 @@ module.exports = {
+        * @type {import('@react-native-community/cli-types').IOSDependencyParams}
+        */
+       ios: {},
++      macos: { podspecPath: __dirname + "/NitroImage.podspec" },
+       /**
+        * @type {import('@react-native-community/cli-types').AndroidDependencyParams}
+        */