@reset-framework/sdk 0.2.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reset-framework/sdk",
-  "version": "0.2.1",
+  "version": "1.0.2",
   "type": "module",
   "description": "Browser-side SDK for Reset Framework applications.",
   "license": "MIT",
@@ -10,7 +10,11 @@
   "sideEffects": false,
   "types": "./src/index.d.ts",
   "exports": {
-    ".": "./src/index.js",
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/client.js

@@ -5,6 +5,7 @@ import {
   invokeRaw,
   isResetRuntimeAvailable
 } from "./transport.js"
+import { createEventApi } from "./events.js"
 import { ResetProtocolError } from "./errors.js"
 
 function isObjectLike(value) {
@@ -48,6 +49,19 @@ function requireBooleanField(record, field, command) {
   return value
 }
 
+function requireNumberField(record, field, command) {
+  const value = record[field]
+
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new ResetProtocolError(
+      `Reset runtime returned an invalid '${field}' field for '${command}'.`,
+      { command }
+    )
+  }
+
+  return value
+}
+
 function normalizeAppInfo(payload, command) {
   const record = requireObject(payload, command)
 
@@ -72,6 +86,17 @@ function normalizeRuntimeInfo(payload, command) {
   })
 }
 
+function normalizeCapabilities(payload, command) {
+  const record = requireObject(payload, command)
+  const commands = Array.isArray(record.commands) ? record.commands : []
+  const permissions = Array.isArray(record.permissions) ? record.permissions : []
+
+  return Object.freeze({
+    commands: Object.freeze(commands.map((entry) => Object.freeze({ ...entry }))),
+    permissions: Object.freeze([...permissions])
+  })
+}
+
 function createCommandApi(transport) {
   return Object.freeze({
     invoke(command, payload = {}) {
@@ -103,6 +128,18 @@ function createAppApi(transport) {
     },
     async getInfo() {
       return normalizeAppInfo(await transport.invoke("app.getInfo"), "app.getInfo")
+    },
+    show() {
+      return transport.invoke("app.show")
+    },
+    hide() {
+      return transport.invoke("app.hide")
+    },
+    quit() {
+      return transport.invoke("app.quit")
+    },
+    relaunch() {
+      return transport.invoke("app.relaunch")
     }
   })
 }
@@ -133,6 +170,395 @@ function createRuntimeApi(transport) {
     },
     async getInfo() {
       return normalizeRuntimeInfo(await transport.invoke("runtime.getInfo"), "runtime.getInfo")
+    },
+    async getCapabilities() {
+      return normalizeCapabilities(
+        await transport.invoke("runtime.getCapabilities"),
+        "runtime.getCapabilities"
+      )
+    }
+  })
+}
+
+function createWindowApi(transport) {
+  return Object.freeze({
+    getCurrent() {
+      return transport.invoke("window.getCurrent")
+    },
+    getInfo() {
+      return transport.invoke("window.getInfo")
+    },
+    list() {
+      return transport.invoke("window.list")
+    },
+    show() {
+      return transport.invoke("window.show")
+    },
+    hide() {
+      return transport.invoke("window.hide")
+    },
+    focus() {
+      return transport.invoke("window.focus")
+    },
+    close() {
+      return transport.invoke("window.close")
+    },
+    minimize() {
+      return transport.invoke("window.minimize")
+    },
+    maximize() {
+      return transport.invoke("window.maximize")
+    },
+    center() {
+      return transport.invoke("window.center")
+    },
+    setTitle(title) {
+      return transport.invoke("window.setTitle", { title })
+    },
+    setSize(width, height) {
+      return transport.invoke("window.setSize", { width, height })
+    },
+    setResizable(resizable) {
+      return transport.invoke("window.setResizable", { resizable })
+    }
+  })
+}
+
+function createDialogApi(transport) {
+  return Object.freeze({
+    openFile(options = {}) {
+      return transport.invoke("dialog.openFile", options)
+    },
+    saveFile(options = {}) {
+      return transport.invoke("dialog.saveFile", options)
+    },
+    message(title, message) {
+      return transport.invoke("dialog.message", { title, message })
+    },
+    confirm(title, message) {
+      return transport.invoke("dialog.confirm", { title, message })
+    }
+  })
+}
+
+function createFsApi(transport) {
+  return Object.freeze({
+    async readTextFile(path) {
+      const payload = requireObject(await transport.invoke("fs.readTextFile", { path }), "fs.readTextFile")
+      return requireStringField(payload, "text", "fs.readTextFile")
+    },
+    writeTextFile(path, text, options = {}) {
+      return transport.invoke("fs.writeTextFile", {
+        path,
+        text,
+        ...options
+      })
+    },
+    async exists(path) {
+      const payload = requireObject(await transport.invoke("fs.exists", { path }), "fs.exists")
+      return requireBooleanField(payload, "exists", "fs.exists")
+    },
+    mkdir(path, options = {}) {
+      return transport.invoke("fs.mkdir", {
+        path,
+        ...options
+      })
+    },
+    remove(path, options = {}) {
+      return transport.invoke("fs.remove", {
+        path,
+        ...options
+      })
+    },
+    rename(from, to) {
+      return transport.invoke("fs.rename", { from, to })
+    },
+    async readDir(path) {
+      const payload = requireObject(await transport.invoke("fs.readDir", { path }), "fs.readDir")
+      return Array.isArray(payload.entries) ? payload.entries : []
+    }
+  })
+}
+
+function createPathApi(transport) {
+  return Object.freeze({
+    async join(...segments) {
+      const payload = requireObject(await transport.invoke("path.join", { segments }), "path.join")
+      return requireStringField(payload, "path", "path.join")
+    },
+    async basename(path) {
+      const payload = requireObject(await transport.invoke("path.basename", { path }), "path.basename")
+      return requireStringField(payload, "name", "path.basename")
+    },
+    async dirname(path) {
+      const payload = requireObject(await transport.invoke("path.dirname", { path }), "path.dirname")
+      return requireStringField(payload, "path", "path.dirname")
+    },
+    async resolve(path, base) {
+      const payload = requireObject(await transport.invoke("path.resolve", { path, base }), "path.resolve")
+      return requireStringField(payload, "path", "path.resolve")
+    },
+    async getHomeDir() {
+      const payload = requireObject(await transport.invoke("path.getHomeDir"), "path.getHomeDir")
+      return requireStringField(payload, "path", "path.getHomeDir")
+    },
+    async getTempDir() {
+      const payload = requireObject(await transport.invoke("path.getTempDir"), "path.getTempDir")
+      return requireStringField(payload, "path", "path.getTempDir")
+    },
+    async getAppDataDir() {
+      const payload = requireObject(await transport.invoke("path.getAppDataDir"), "path.getAppDataDir")
+      return requireStringField(payload, "path", "path.getAppDataDir")
+    },
+    async getAppConfigDir() {
+      const payload = requireObject(await transport.invoke("path.getAppConfigDir"), "path.getAppConfigDir")
+      return requireStringField(payload, "path", "path.getAppConfigDir")
+    },
+    async getCacheDir() {
+      const payload = requireObject(await transport.invoke("path.getCacheDir"), "path.getCacheDir")
+      return requireStringField(payload, "path", "path.getCacheDir")
+    },
+    getInfo() {
+      return transport.invoke("path.getInfo")
+    }
+  })
+}
+
+function createShellApi(transport) {
+  return Object.freeze({
+    openExternal(url) {
+      return transport.invoke("shell.openExternal", { url })
+    },
+    openPath(path) {
+      return transport.invoke("shell.openPath", { path })
+    },
+    showItemInFolder(path) {
+      return transport.invoke("shell.showItemInFolder", { path })
+    }
+  })
+}
+
+function createClipboardApi(transport) {
+  return Object.freeze({
+    async readText() {
+      const payload = requireObject(await transport.invoke("clipboard.readText"), "clipboard.readText")
+      return requireStringField(payload, "text", "clipboard.readText")
+    },
+    writeText(text) {
+      return transport.invoke("clipboard.writeText", { text })
+    }
+  })
+}
+
+function createNotificationApi(transport) {
+  return Object.freeze({
+    async isSupported() {
+      const payload = requireObject(
+        await transport.invoke("notification.isSupported"),
+        "notification.isSupported"
+      )
+      return requireBooleanField(payload, "supported", "notification.isSupported")
+    },
+    requestPermission() {
+      return transport.invoke("notification.requestPermission")
+    },
+    show(options) {
+      return transport.invoke("notification.show", options)
+    }
+  })
+}
+
+function createScreenApi(transport) {
+  return Object.freeze({
+    getCursorPosition() {
+      return transport.invoke("screen.getCursorPosition")
+    },
+    getPrimaryDisplay() {
+      return transport.invoke("screen.getPrimaryDisplay")
+    },
+    async getDisplays() {
+      const payload = requireObject(await transport.invoke("screen.getDisplays"), "screen.getDisplays")
+      return Array.isArray(payload.displays) ? payload.displays : []
+    }
+  })
+}
+
+function createStorageApi(transport) {
+  return Object.freeze({
+    async get(key) {
+      const payload = requireObject(await transport.invoke("storage.get", { key }), "storage.get")
+      return payload.value
+    },
+    set(key, value) {
+      return transport.invoke("storage.set", { key, value })
+    },
+    remove(key) {
+      return transport.invoke("storage.remove", { key })
+    },
+    clear() {
+      return transport.invoke("storage.clear")
+    },
+    async getAll() {
+      const payload = requireObject(await transport.invoke("storage.getAll"), "storage.getAll")
+      return requireObject(payload.entries ?? {}, "storage.getAll")
+    }
+  })
+}
+
+function createWebViewApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("webview.getInfo")
+    },
+    reload() {
+      return transport.invoke("webview.reload")
+    },
+    goBack() {
+      return transport.invoke("webview.goBack")
+    },
+    goForward() {
+      return transport.invoke("webview.goForward")
+    },
+    navigate(options) {
+      return transport.invoke("webview.navigate", options)
+    },
+    setZoomFactor(factor) {
+      return transport.invoke("webview.setZoomFactor", { factor })
+    }
+  })
+}
+
+function createCryptoApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("crypto.getInfo")
+    },
+    randomBytes(size, options = {}) {
+      return transport.invoke("crypto.randomBytes", {
+        size,
+        encoding: options.encoding
+      })
+    },
+    async randomUuid() {
+      const payload = requireObject(await transport.invoke("crypto.randomUuid"), "crypto.randomUuid")
+      return requireStringField(payload, "uuid", "crypto.randomUuid")
+    }
+  })
+}
+
+function createProcessApi(transport) {
+  return Object.freeze({
+    async getPid() {
+      const payload = requireObject(await transport.invoke("process.getPid"), "process.getPid")
+      return requireNumberField(payload, "pid", "process.getPid")
+    },
+    async getCwd() {
+      const payload = requireObject(await transport.invoke("process.getCwd"), "process.getCwd")
+      return requireStringField(payload, "path", "process.getCwd")
+    },
+    getInfo() {
+      return transport.invoke("process.getInfo")
+    }
+  })
+}
+
+function createPowerApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("power.getInfo")
+    }
+  })
+}
+
+function createMenuApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("menu.getInfo")
+    },
+    setApplicationMenu(items) {
+      return transport.invoke("menu.setApplicationMenu", { items })
+    },
+    clearApplicationMenu() {
+      return transport.invoke("menu.clearApplicationMenu")
+    }
+  })
+}
+
+function createTrayApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("tray.getInfo")
+    },
+    create(options = {}) {
+      return transport.invoke("tray.create", options)
+    },
+    setTitle(title) {
+      return transport.invoke("tray.setTitle", { title })
+    },
+    setTooltip(tooltip) {
+      return transport.invoke("tray.setTooltip", { tooltip })
+    },
+    setMenu(items) {
+      return transport.invoke("tray.setMenu", { items })
+    },
+    destroy() {
+      return transport.invoke("tray.destroy")
+    }
+  })
+}
+
+function createShortcutApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("shortcut.getInfo")
+    },
+    register(accelerator) {
+      return transport.invoke("shortcut.register", { accelerator })
+    },
+    unregister(accelerator) {
+      return transport.invoke("shortcut.unregister", { accelerator })
+    },
+    unregisterAll() {
+      return transport.invoke("shortcut.unregisterAll")
+    }
+  })
+}
+
+function createProtocolApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("protocol.getInfo")
+    },
+    register(options = {}) {
+      return transport.invoke("protocol.register", options)
+    },
+    unregister(options = {}) {
+      return transport.invoke("protocol.unregister", options)
+    }
+  })
+}
+
+function createUpdaterApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("updater.getInfo")
+    },
+    check(options = {}) {
+      return transport.invoke("updater.check", options)
+    },
+    download(options = {}) {
+      return transport.invoke("updater.download", options)
+    },
+    install(options = {}) {
+      return transport.invoke("updater.install", options)
+    }
+  })
+}
+
+function createNetApi(transport) {
+  return Object.freeze({
+    request(options) {
+      return transport.invoke("net.request", options)
     }
   })
 }
@@ -142,6 +568,26 @@ export function createResetClient(source) {
   const commands = createCommandApi(transport)
   const app = createAppApi(transport)
   const runtime = createRuntimeApi(transport)
+  const events = createEventApi(transport)
+  const window = createWindowApi(transport)
+  const dialog = createDialogApi(transport)
+  const fs = createFsApi(transport)
+  const path = createPathApi(transport)
+  const shell = createShellApi(transport)
+  const clipboard = createClipboardApi(transport)
+  const notification = createNotificationApi(transport)
+  const screen = createScreenApi(transport)
+  const storage = createStorageApi(transport)
+  const webview = createWebViewApi(transport)
+  const crypto = createCryptoApi(transport)
+  const process = createProcessApi(transport)
+  const power = createPowerApi(transport)
+  const menu = createMenuApi(transport)
+  const tray = createTrayApi(transport)
+  const shortcut = createShortcutApi(transport)
+  const protocol = createProtocolApi(transport)
+  const updater = createUpdaterApi(transport)
+  const net = createNetApi(transport)
 
   return Object.freeze({
     isAvailable() {
@@ -152,7 +598,27 @@ export function createResetClient(source) {
     },
     commands,
     app,
-    runtime
+    runtime,
+    events,
+    window,
+    dialog,
+    fs,
+    path,
+    shell,
+    clipboard,
+    notification,
+    screen,
+    storage,
+    webview,
+    crypto,
+    process,
+    power,
+    menu,
+    tray,
+    shortcut,
+    protocol,
+    updater,
+    net
   })
 }
 
@@ -168,3 +634,23 @@ export const reset = createResetClient()
 export const commands = reset.commands
 export const app = reset.app
 export const runtime = reset.runtime
+export const events = reset.events
+export const window = reset.window
+export const dialog = reset.dialog
+export const fs = reset.fs
+export const path = reset.path
+export const shell = reset.shell
+export const clipboard = reset.clipboard
+export const notification = reset.notification
+export const screen = reset.screen
+export const storage = reset.storage
+export const webview = reset.webview
+export const crypto = reset.crypto
+export const process = reset.process
+export const power = reset.power
+export const menu = reset.menu
+export const tray = reset.tray
+export const shortcut = reset.shortcut
+export const protocol = reset.protocol
+export const updater = reset.updater
+export const net = reset.net

package/src/errors.js

@@ -26,6 +26,8 @@ export class ResetInvocationError extends ResetRuntimeError {
   constructor(command, message, response, options = {}) {
     super(message, options)
     this.command = command
+    this.code = response?.code
+    this.details = response?.details
     this.response = response
   }
 }

package/src/events.js

@@ -0,0 +1,123 @@
+function getDefaultWindowTarget() {
+  if (typeof window === "undefined") {
+    return undefined
+  }
+
+  return window
+}
+
+function getState(target = getDefaultWindowTarget()) {
+  if (!target) {
+    return null
+  }
+
+  if (!target.__resetEventState) {
+    const listeners = new Map()
+
+    target.__resetEventState = {
+      listeners,
+      dispatch(envelope) {
+        const eventName = typeof envelope?.event === "string" ? envelope.event : ""
+        if (eventName === "") {
+          return
+        }
+
+        const handlers = listeners.get(eventName)
+        if (!handlers) {
+          return
+        }
+
+        for (const handler of [...handlers]) {
+          handler(envelope.payload)
+        }
+      }
+    }
+
+    Object.defineProperty(target, "__resetDispatchEvent", {
+      value: (envelope) => target.__resetEventState.dispatch(envelope),
+      configurable: false,
+      enumerable: false,
+      writable: false
+    })
+  }
+
+  return target.__resetEventState
+}
+
+export function listen(eventName, handler, target = getDefaultWindowTarget()) {
+  if (typeof eventName !== "string" || eventName.trim() === "") {
+    throw new TypeError("Reset event name must be a non-empty string.")
+  }
+
+  if (typeof handler !== "function") {
+    throw new TypeError("Reset event handler must be a function.")
+  }
+
+  const state = getState(target)
+  if (!state) {
+    return () => {}
+  }
+
+  const handlers = state.listeners.get(eventName) ?? new Set()
+  handlers.add(handler)
+  state.listeners.set(eventName, handlers)
+
+  return () => {
+    const current = state.listeners.get(eventName)
+    if (!current) {
+      return
+    }
+
+    current.delete(handler)
+    if (current.size === 0) {
+      state.listeners.delete(eventName)
+    }
+  }
+}
+
+export function once(eventName, handler, target = getDefaultWindowTarget()) {
+  let dispose = () => {}
+
+  dispose = listen(
+    eventName,
+    (payload) => {
+      dispose()
+      handler(payload)
+    },
+    target
+  )
+
+  return dispose
+}
+
+export function emitLocal(eventName, payload, target = getDefaultWindowTarget()) {
+  const state = getState(target)
+  if (!state) {
+    return
+  }
+
+  state.dispatch({
+    event: eventName,
+    payload
+  })
+}
+
+export function createEventApi(transport, target = getDefaultWindowTarget()) {
+  return Object.freeze({
+    listen(eventName, handler) {
+      return listen(eventName, handler, target)
+    },
+    once(eventName, handler) {
+      return once(eventName, handler, target)
+    },
+    emitLocal(eventName, payload) {
+      emitLocal(eventName, payload, target)
+    },
+    emit(eventName, payload = null) {
+      return transport.invoke("event.emit", {
+        event: eventName,
+        payload
+      })
+    }
+  })
+}

package/src/index.d.ts

@@ -6,6 +6,8 @@ export type ResetInvokeSuccess<T = unknown> = {
 export type ResetInvokeError = {
   ok: false;
   error: string;
+  code?: string;
+  details?: unknown;
 };
 
 export type ResetInvokeResponse<T = unknown> =
@@ -25,6 +27,11 @@ export interface ResetRuntime {
 
 export interface ResetRuntimeWindow {
   reset?: ResetRuntime;
+  __resetEventState?: {
+    listeners: Map<string, Set<(payload: unknown) => void>>;
+    dispatch(envelope: { event: string; payload: unknown }): void;
+  };
+  __resetDispatchEvent?: (envelope: { event: string; payload: unknown }) => void;
 }
 
 export interface ResetRuntimeSourceOptions {
@@ -66,6 +73,38 @@ export interface ResetAppInfo {
   windowTitle: string;
 }
 
+export interface ResetPoint {
+  x: number;
+  y: number;
+}
+
+export interface ResetSize {
+  width: number;
+  height: number;
+}
+
+export interface ResetRect extends ResetPoint, ResetSize {}
+
+export interface ResetWindowInfo {
+  id: string;
+  title: string;
+  frame: ResetRect;
+  position: ResetPoint;
+  size: ResetSize;
+  visible: boolean;
+  focused: boolean;
+  minimized: boolean;
+  maximized: boolean;
+  resizable: boolean;
+}
+
+export interface ResetDisplayInfo {
+  id: string;
+  frame: ResetRect;
+  visibleFrame: ResetRect;
+  scaleFactor: number;
+}
+
 export interface ResetRuntimeInfo {
   platform: ResetPlatform;
   arch: ResetArchitecture;
@@ -74,12 +113,26 @@ export interface ResetRuntimeInfo {
   debug: boolean;
 }
 
+export interface ResetCommandDescriptor {
+  command: string;
+  permission: string;
+}
+
+export interface ResetCapabilitiesInfo {
+  commands: ReadonlyArray<ResetCommandDescriptor>;
+  permissions: ReadonlyArray<string>;
+}
+
 export interface ResetAppApi {
   getId(): Promise<string>;
   getName(): Promise<string>;
   getSlug(): Promise<string>;
   getVersion(): Promise<string>;
   getInfo(): Promise<ResetAppInfo>;
+  show(): Promise<{ visible: boolean }>;
+  hide(): Promise<{ hidden: boolean }>;
+  quit(): Promise<{ quitting: boolean }>;
+  relaunch(): Promise<{ relaunching: boolean }>;
 }
 
 export interface ResetRuntimeApi {
@@ -88,6 +141,281 @@ export interface ResetRuntimeApi {
   getFrameworkVersion(): Promise<string>;
   getBridgeVersion(): Promise<string>;
   getInfo(): Promise<ResetRuntimeInfo>;
+  getCapabilities(): Promise<ResetCapabilitiesInfo>;
+}
+
+export interface ResetWindowApi {
+  getCurrent(): Promise<ResetWindowInfo>;
+  getInfo(): Promise<ResetWindowInfo>;
+  list(): Promise<{ windows: ResetWindowInfo[] }>;
+  show(): Promise<ResetWindowInfo>;
+  hide(): Promise<ResetWindowInfo>;
+  focus(): Promise<ResetWindowInfo>;
+  close(): Promise<{ closed: boolean }>;
+  minimize(): Promise<ResetWindowInfo>;
+  maximize(): Promise<ResetWindowInfo>;
+  center(): Promise<ResetWindowInfo>;
+  setTitle(title: string): Promise<ResetWindowInfo>;
+  setSize(width: number, height: number): Promise<ResetWindowInfo>;
+  setResizable(resizable: boolean): Promise<ResetWindowInfo>;
+}
+
+export interface ResetDialogOpenFileOptions {
+  title?: string;
+  multiple?: boolean;
+  directory?: boolean;
+}
+
+export interface ResetDialogSaveFileOptions {
+  title?: string;
+  defaultPath?: string;
+}
+
+export interface ResetDialogApi {
+  openFile(options?: ResetDialogOpenFileOptions): Promise<{
+    canceled: boolean;
+    paths: string[];
+  }>;
+  saveFile(options?: ResetDialogSaveFileOptions): Promise<{
+    canceled: boolean;
+    path?: string;
+  }>;
+  message(title: string, message: string): Promise<{ confirmed: boolean }>;
+  confirm(title: string, message: string): Promise<{ confirmed: boolean }>;
+}
+
+export interface ResetDirectoryEntry {
+  name: string;
+  path: string;
+  kind: "file" | "directory" | "symlink" | "other";
+}
+
+export interface ResetFsApi {
+  readTextFile(path: string): Promise<string>;
+  writeTextFile(
+    path: string,
+    text: string,
+    options?: { createDirectories?: boolean }
+  ): Promise<{ written: boolean }>;
+  exists(path: string): Promise<boolean>;
+  mkdir(
+    path: string,
+    options?: { recursive?: boolean }
+  ): Promise<{ created: boolean }>;
+  remove(
+    path: string,
+    options?: { recursive?: boolean }
+  ): Promise<{ removed: boolean; count: number }>;
+  rename(from: string, to: string): Promise<{ renamed: boolean }>;
+  readDir(path: string): Promise<ResetDirectoryEntry[]>;
+}
+
+export interface ResetPathInfo {
+  homeDir: string;
+  tempDir: string;
+  appDataDir: string;
+  appConfigDir: string;
+  cacheDir: string;
+}
+
+export interface ResetPathApi {
+  join(...segments: string[]): Promise<string>;
+  basename(path: string): Promise<string>;
+  dirname(path: string): Promise<string>;
+  resolve(path: string, base?: string): Promise<string>;
+  getHomeDir(): Promise<string>;
+  getTempDir(): Promise<string>;
+  getAppDataDir(): Promise<string>;
+  getAppConfigDir(): Promise<string>;
+  getCacheDir(): Promise<string>;
+  getInfo(): Promise<ResetPathInfo>;
+}
+
+export interface ResetShellApi {
+  openExternal(url: string): Promise<{ opened: boolean }>;
+  openPath(path: string): Promise<{ opened: boolean }>;
+  showItemInFolder(path: string): Promise<{ shown: boolean }>;
+}
+
+export interface ResetClipboardApi {
+  readText(): Promise<string>;
+  writeText(text: string): Promise<{ written: boolean }>;
+}
+
+export interface ResetNotificationApi {
+  isSupported(): Promise<boolean>;
+  requestPermission(): Promise<{
+    supported: boolean;
+    authorized: boolean;
+    status: string;
+  }>;
+  show(options: { title: string; body?: string }): Promise<{
+    shown: boolean;
+    authorized: boolean;
+    id?: string;
+  }>;
+}
+
+export interface ResetScreenApi {
+  getCursorPosition(): Promise<ResetPoint>;
+  getPrimaryDisplay(): Promise<ResetDisplayInfo | null>;
+  getDisplays(): Promise<ResetDisplayInfo[]>;
+}
+
+export interface ResetStorageApi {
+  get<T = unknown>(key: string): Promise<T | null>;
+  set(key: string, value: unknown): Promise<{ key: string; stored: boolean }>;
+  remove(key: string): Promise<{ key: string; removed: boolean }>;
+  clear(): Promise<{ cleared: boolean }>;
+  getAll(): Promise<Record<string, unknown>>;
+}
+
+export interface ResetWebViewInfo {
+  title: string;
+  url: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  loading: boolean;
+  estimatedProgress: number;
+}
+
+export interface ResetWebViewApi {
+  getInfo(): Promise<ResetWebViewInfo>;
+  reload(): Promise<ResetWebViewInfo>;
+  goBack(): Promise<ResetWebViewInfo>;
+  goForward(): Promise<ResetWebViewInfo>;
+  navigate(options: { url?: string; path?: string }): Promise<ResetWebViewInfo>;
+  setZoomFactor(factor: number): Promise<ResetWebViewInfo>;
+}
+
+export interface ResetCryptoApi {
+  getInfo(): Promise<{
+    supported: boolean;
+    encodings: string[];
+    maxRandomBytes: number;
+  }>;
+  randomBytes(
+    size: number,
+    options?: { encoding?: "hex" | "base64url" }
+  ): Promise<{
+    size: number;
+    encoding: "hex" | "base64url";
+    value: string;
+  }>;
+  randomUuid(): Promise<string>;
+}
+
+export interface ResetProcessInfo {
+  pid: number;
+  cwd: string;
+  platform: ResetPlatform;
+  arch: ResetArchitecture;
+  debug: boolean;
+}
+
+export interface ResetProcessApi {
+  getPid(): Promise<number>;
+  getCwd(): Promise<string>;
+  getInfo(): Promise<ResetProcessInfo>;
+}
+
+export interface ResetPowerInfo {
+  supported: boolean;
+  lowPowerMode: boolean;
+  thermalState: string;
+}
+
+export interface ResetPowerApi {
+  getInfo(): Promise<ResetPowerInfo>;
+}
+
+export interface ResetSupportInfo {
+  supported: boolean;
+  module: string;
+  platform: ResetPlatform | string;
+}
+
+export interface ResetMenuInfo extends ResetSupportInfo {
+  installed: boolean;
+  topLevelCount: number;
+}
+
+export interface ResetTrayInfo extends ResetSupportInfo {
+  created: boolean;
+  title: string;
+  tooltip: string;
+  hasMenu: boolean;
+}
+
+export interface ResetMenuItem {
+  id?: string;
+  label?: string;
+  enabled?: boolean;
+  checked?: boolean;
+  separator?: boolean;
+  submenu?: ResetMenuItem[];
+}
+
+export interface ResetMenuApi {
+  getInfo(): Promise<ResetMenuInfo>;
+  setApplicationMenu(items: ResetMenuItem[]): Promise<ResetMenuInfo>;
+  clearApplicationMenu(): Promise<ResetMenuInfo>;
+}
+
+export interface ResetTrayApi {
+  getInfo(): Promise<ResetTrayInfo>;
+  create(options?: {
+    title?: string;
+    tooltip?: string;
+    items?: ResetMenuItem[];
+  }): Promise<ResetTrayInfo>;
+  setTitle(title: string): Promise<ResetTrayInfo>;
+  setTooltip(tooltip: string): Promise<ResetTrayInfo>;
+  setMenu(items: ResetMenuItem[]): Promise<ResetTrayInfo>;
+  destroy(): Promise<{ destroyed: boolean }>;
+}
+
+export interface ResetShortcutApi {
+  getInfo(): Promise<ResetSupportInfo>;
+  register(accelerator: string): Promise<unknown>;
+  unregister(accelerator: string): Promise<unknown>;
+  unregisterAll(): Promise<unknown>;
+}
+
+export interface ResetProtocolApi {
+  getInfo(): Promise<ResetSupportInfo>;
+  register(options?: {
+    scheme?: string;
+  }): Promise<unknown>;
+  unregister(options?: {
+    scheme?: string;
+  }): Promise<unknown>;
+}
+
+export interface ResetUpdaterApi {
+  getInfo(): Promise<ResetSupportInfo>;
+  check(options?: Record<string, unknown>): Promise<unknown>;
+  download(options?: Record<string, unknown>): Promise<unknown>;
+  install(options?: Record<string, unknown>): Promise<unknown>;
+}
+
+export interface ResetNetResponse {
+  url: string;
+  status: number;
+  ok: boolean;
+  headers: Record<string, string>;
+  body: string;
+  bodyEncoding: "utf8" | "base64" | string;
+}
+
+export interface ResetNetApi {
+  request(options: {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+  }): Promise<ResetNetResponse>;
 }
 
 export interface ResetClient {
@@ -96,6 +424,42 @@ export interface ResetClient {
   commands: ResetCommandApi;
   app: ResetAppApi;
   runtime: ResetRuntimeApi;
+  events: ResetEventApi;
+  window: ResetWindowApi;
+  dialog: ResetDialogApi;
+  fs: ResetFsApi;
+  path: ResetPathApi;
+  shell: ResetShellApi;
+  clipboard: ResetClipboardApi;
+  notification: ResetNotificationApi;
+  screen: ResetScreenApi;
+  storage: ResetStorageApi;
+  webview: ResetWebViewApi;
+  crypto: ResetCryptoApi;
+  process: ResetProcessApi;
+  power: ResetPowerApi;
+  menu: ResetMenuApi;
+  tray: ResetTrayApi;
+  shortcut: ResetShortcutApi;
+  protocol: ResetProtocolApi;
+  updater: ResetUpdaterApi;
+  net: ResetNetApi;
+}
+
+export interface ResetEventApi {
+  listen<T = unknown>(
+    eventName: string,
+    handler: (payload: T) => void
+  ): () => void;
+  once<T = unknown>(
+    eventName: string,
+    handler: (payload: T) => void
+  ): () => void;
+  emitLocal<T = unknown>(eventName: string, payload: T): void;
+  emit<T = unknown>(eventName: string, payload?: T): Promise<{
+    delivered: boolean;
+    event: string;
+  }>;
 }
 
 declare global {
@@ -119,6 +483,8 @@ export class ResetProtocolError extends ResetRuntimeError {
 export class ResetInvocationError extends ResetRuntimeError {
   command: string;
   response: ResetInvokeError;
+  code?: string;
+  details?: unknown;
   constructor(
     command: string,
     message: string,
@@ -157,3 +523,23 @@ export const reset: ResetClient;
 export const commands: ResetCommandApi;
 export const app: ResetAppApi;
 export const runtime: ResetRuntimeApi;
+export const events: ResetEventApi;
+export const window: ResetWindowApi;
+export const dialog: ResetDialogApi;
+export const fs: ResetFsApi;
+export const path: ResetPathApi;
+export const shell: ResetShellApi;
+export const clipboard: ResetClipboardApi;
+export const notification: ResetNotificationApi;
+export const screen: ResetScreenApi;
+export const storage: ResetStorageApi;
+export const webview: ResetWebViewApi;
+export const crypto: ResetCryptoApi;
+export const process: ResetProcessApi;
+export const power: ResetPowerApi;
+export const menu: ResetMenuApi;
+export const tray: ResetTrayApi;
+export const shortcut: ResetShortcutApi;
+export const protocol: ResetProtocolApi;
+export const updater: ResetUpdaterApi;
+export const net: ResetNetApi;

package/src/index.js

@@ -1,14 +1,34 @@
 export {
   app,
+  clipboard,
   commands,
   createResetClient,
   createResetTransport,
+  crypto,
+  dialog,
+  events,
+  fs,
   getResetRuntime,
   invoke,
   invokeRaw,
   isResetRuntimeAvailable,
+  menu,
+  net,
+  notification,
+  path,
+  power,
+  process,
+  protocol,
   reset,
-  runtime
+  screen,
+  shell,
+  shortcut,
+  storage,
+  runtime,
+  tray,
+  updater,
+  webview,
+  window
 } from "./client.js"
 
 export {

package/src/transport.js

@@ -86,7 +86,23 @@ function normalizeResponse(command, response) {
   }
 
   if (response.ok === false) {
-    if (typeof response.error !== "string" || response.error.trim() === "") {
+    if (typeof response.error === "string" && response.error.trim() !== "") {
+      return Object.freeze({
+        ok: false,
+        error: response.error,
+        code: undefined,
+        details: undefined
+      })
+    }
+
+    if (!isObjectLike(response.error)) {
+      throw new ResetProtocolError(
+        `Reset runtime returned an invalid error response for '${command}'.`,
+        { command }
+      )
+    }
+
+    if (typeof response.error.message !== "string" || response.error.message.trim() === "") {
       throw new ResetProtocolError(
         `Reset runtime returned an invalid error response for '${command}'.`,
         { command }
@@ -95,7 +111,9 @@ function normalizeResponse(command, response) {
 
     return Object.freeze({
       ok: false,
-      error: response.error
+      error: response.error.message,
+      code: typeof response.error.code === "string" ? response.error.code : undefined,
+      details: response.error.details
     })
   }