craft-native 0.0.76 → 0.0.78

package/dist/ios/templates/CraftApp.swift

@@ -2222,41 +2222,33 @@ struct CraftWebView: UIViewRepresentable {
                     _progressCallbacks: [],
                     _statusCallbacks: [],
 
+                    // OTA is not implemented natively. These five used to post
+                    // to actions the switch below does not handle, and register
+                    // a resolve/reject pair that nothing would ever call — they
+                    // also bypassed _createCallback, which is what owns the 30s
+                    // timeout, so the promises hung forever rather than
+                    // rejecting. An immediate rejection is the honest answer:
+                    // an app can catch it, where it could never catch a hang.
+                    _unavailable: function(name) {
+                        return Promise.reject(new Error(
+                            'craft.ota.' + name + ' is not implemented on this platform'
+                        ));
+                    },
                     configure: function(options) {
                         this._config = options;
-                        window.webkit.messageHandlers.craft.postMessage({action: 'otaConfigure', config: options});
+                        console.warn('[craft] ota.configure stored locally; OTA is not implemented natively');
                     },
                     checkForUpdate: function() {
-                        var self = window.craft;
-                        var id = 'cb_' + (++self._callbackId);
-                        window.webkit.messageHandlers.craft.postMessage({action: 'otaCheckForUpdate', callbackId: id});
-                        return new Promise(function(resolve, reject) {
-                            self._callbacks[id] = {resolve: resolve, reject: reject};
-                        });
+                        return window.craft.ota._unavailable('checkForUpdate');
                     },
                     downloadUpdate: function(options) {
-                        var self = window.craft;
-                        var id = 'cb_' + (++self._callbackId);
-                        window.webkit.messageHandlers.craft.postMessage({action: 'otaDownloadUpdate', options: options || {}, callbackId: id});
-                        return new Promise(function(resolve, reject) {
-                            self._callbacks[id] = {resolve: resolve, reject: reject};
-                        });
+                        return window.craft.ota._unavailable('downloadUpdate');
                     },
                     applyUpdate: function() {
-                        var self = window.craft;
-                        var id = 'cb_' + (++self._callbackId);
-                        window.webkit.messageHandlers.craft.postMessage({action: 'otaApplyUpdate', callbackId: id});
-                        return new Promise(function(resolve, reject) {
-                            self._callbacks[id] = {resolve: resolve, reject: reject};
-                        });
+                        return window.craft.ota._unavailable('applyUpdate');
                     },
                     rollback: function() {
-                        var self = window.craft;
-                        var id = 'cb_' + (++self._callbackId);
-                        window.webkit.messageHandlers.craft.postMessage({action: 'otaRollback', callbackId: id});
-                        return new Promise(function(resolve, reject) {
-                            self._callbacks[id] = {resolve: resolve, reject: reject};
-                        });
+                        return window.craft.ota._unavailable('rollback');
                     },
                     getCurrentBundle: function() {
                         // This returns synchronously from stored data

package/dist/package.d.ts

@@ -74,6 +74,20 @@ export interface PackageConfig {
          * the helper lands next to `process.execPath`.
          */
         additionalExecutables?: string[];
+        /**
+         * URL schemes the app registers as a handler for — `['myapp']` makes
+         * `myapp://…` open it.
+         *
+         * Emitted as `CFBundleURLTypes`. Without this key macOS never dispatches
+         * a URL to the app at all, so Craft's receive path (the `kAEGetURL`
+         * AppleEvent handler behind `craft.deepLink`) can be fully working and
+         * still never hear anything.
+         *
+         * Schemes are matched case-insensitively by LaunchServices and are
+         * global to the machine: pick something specific to the app, not `app`
+         * or `open`.
+         */
+        urlSchemes?: string[];
     };
     /** Windows-specific options */
     windows?: {
@@ -138,7 +152,18 @@ export interface MacOSBundleMetadata {
     minimumSystemVersion?: string;
     /** Sets `LSUIElement` — no Dock icon, no app switcher entry */
     menuBarOnly?: boolean;
+    /** URL schemes the app handles, emitted as `CFBundleURLTypes` */
+    urlSchemes?: string[];
 }
+/**
+ * `CFBundleURLTypes` for the schemes an app handles, or `null` if it handles
+ * none.
+ *
+ * All the schemes go in one URL type. They are alternatives for reaching the
+ * same app, not different kinds of document, so splitting them across several
+ * dicts would only invent distinctions LaunchServices does not care about.
+ */
+export declare function urlTypesEntry(bundleId: string, schemes: readonly string[]): string | null;
 /**
  * Render `Contents/Info.plist` for a macOS app bundle.
  *
@@ -178,6 +203,50 @@ export declare function dmgCreateArguments(opts: {
     volumeName: string;
 }, contentBytes: number): string[];
 export declare function shouldRetryHdiutil(error: string, attempt: number, maxAttempts?: number): boolean;
+/**
+ * Helper: Create PKG from app bundle
+ *
+ * Two flavours share this entry point:
+ * - a plain `pkgbuild` installer for direct distribution, and
+ * - a signed `productbuild` submission package for the Mac App Store, which is
+ *   the only form App Store Connect accepts.
+ */
+/**
+ * The component property list `pkgbuild` is given for the app bundle.
+ *
+ * Written out rather than left to `pkgbuild`'s inference, because its default
+ * for a bundle is `BundleIsRelocatable = true`, which puts this in the package:
+ *
+ *     <relocate><bundle id="dev.example.app"/></relocate>
+ *
+ * That directive tells `installer` the payload path is only a suggestion: it
+ * looks the bundle identifier up on the target volume and, if the system has a
+ * copy of that bundle registered anywhere, writes the payload over *that* copy
+ * instead — and exits 0. The user sees "The install was successful" and finds
+ * nothing at /Applications.
+ *
+ * It is intermittent by nature, since it turns on whether the system has
+ * indexed some other copy yet, which is exactly how it behaved: the native
+ * lifecycle workflow's macOS legs failed only on slow runs, on both
+ * architectures, with `installer` reporting success and the app absent.
+ *
+ * `BundleIsVersionChecked` is off for a related reason — with it on, installing
+ * an *older* version over a newer one is skipped, which silently turns a
+ * rollback into a no-op.
+ *
+ * The `pkg-info` attribute `relocatable="false"` that appears either way is not
+ * this setting and does not govern it; only the `<relocate>` element does.
+ */
+export declare function pkgbuildComponentPlist(rootRelativeBundlePath: string): string;
+/** Build the `pkgbuild` argument list for a non-App-Store package. */
+export declare function pkgbuildArguments(opts: {
+    root: string;
+    componentPlistPath: string;
+    identifier: string;
+    version: string;
+    outputPath: string;
+    installerIdentity?: string;
+}): string[];
 export declare function windowsArchitecture(architecture: string): 'x86' | 'x64' | 'arm64';
 export declare function renderWixSource(opts: Pick<MSIOptions, 'name' | 'version' | 'manufacturer' | 'architecture'>, sourceName: string): string;
 export declare function windowsExecutableName(name: string): string;

package/dist/types.d.ts

@@ -55,6 +55,55 @@ export interface WindowOptions {
      * Window title
      */
     title?: string;
+    /**
+     * Build the window without ever putting it on screen (macOS).
+     *
+     * The page loads and runs JavaScript exactly as it would visibly, and it
+     * remains capturable — a snapshot taken after script has mutated the DOM
+     * reflects the mutation.
+     *
+     * **It does not animate.** An unshown window does not drive the compositor,
+     * so `requestAnimationFrame` stops after one frame and page timers fall to
+     * roughly 1Hz. Anything that advances itself — CSS or canvas animation, a
+     * charting library redrawing on rAF, "wait until the spinner stops" — sees
+     * the first frame forever. Drive the page with explicit calls and take
+     * readiness from load completion, not from a polling loop inside the page.
+     *
+     * Contradicts `menubarOnly`, which has no window to hide; passing both is an
+     * error rather than a silent no-op.
+     */
+    headless?: boolean;
+    /**
+     * Keep the process running after the last window closes (macOS).
+     *
+     * Craft decides this from the shape of the app when it is not set: an app
+     * with a tray icon or in menubar-only mode stays running, because outliving
+     * its window is what those are for; an ordinary windowed app quits.
+     *
+     * Set it to `true` for a windowed app that should stay resident and be
+     * brought back by clicking the Dock icon, or `false` for a tray app that
+     * should genuinely go away when its window closes.
+     *
+     * Before this existed the answer was AppKit's default, `false`, for every
+     * app: closing the last window left a process with no window and no way to
+     * get one back.
+     */
+    keepRunning?: boolean;
+    /**
+     * Remember this window's size and position across launches, under this name
+     * (macOS).
+     *
+     * `width`/`height`/`x`/`y` become **first-launch defaults**: they are what
+     * the window opens at until there is a saved frame to restore, and the saved
+     * frame wins from then on. Without this the window forgets its geometry
+     * every launch, and an app that wants the standard behaviour has to wire
+     * `onResize`/`onMove` to its own storage and reimplement what AppKit does in
+     * one call.
+     *
+     * The name is the key AppKit stores under, so it must be stable across
+     * launches and distinct per window.
+     */
+    frameAutosave?: string;
     /**
      * Window width in pixels
      * @default 800
@@ -454,6 +503,19 @@ export interface AppConfig {
      * Window options
      */
     window?: WindowOptions;
+    /**
+     * The name macOS shows for the app: the App menu title, and the
+     * "About X" / "Hide X" / "Quit X" items.
+     *
+     * Without it those read the executable's name, so every app launched
+     * through the shared `craft` binary calls itself "craft" in the menu bar.
+     * A packaged `.app` gets this from `CFBundleName` instead; this is what
+     * gives a dev-mode app its identity back without a packaging step.
+     *
+     * Not the name `ps` and Activity Monitor show — that comes from the
+     * executable and cannot be changed from inside the process.
+     */
+    appName?: string;
     /**
      * Path to Craft binary (auto-detected if not provided)
      */
@@ -627,11 +689,46 @@ export interface AppInfo {
 /**
  * Notification options
  */
+/**
+ * A button on a notification banner.
+ *
+ * macOS shows two directly on a banner and puts any others behind an
+ * "Options" disclosure, so craft accepts at most four — past that they are
+ * a menu the user has to go looking for rather than a choice they can see.
+ *
+ * Two spellings are accepted. `{ id, label }` is the one to use. `{ action,
+ * title }` is what this type has said since before anything implemented it,
+ * and it keeps working rather than being deleted out from under whoever wrote
+ * against it — the field was published, it just never did anything.
+ */
+export type NotificationAction = {
+    /** Comes back as `actionId` in `craft.notifications.onAction`. */
+    id: string;
+    /** The text on the button. */
+    label: string;
+} | {
+    /** @deprecated Use `id`. */
+    action: string;
+    /** @deprecated Use `label`. */
+    title: string;
+};
 export interface NotificationOptions {
     /**
      * Notification title (required)
      */
     title: string;
+    /**
+     * Buttons on the banner.
+     *
+     * Pressing one brings the app forward and fires
+     * `craft.notifications.onAction` with `{ notificationId, actionId }` —
+     * which is what lets a prompt be answered without switching to the app
+     * first.
+     *
+     * Two buttons cannot share an `id`: the response names the button by id,
+     * and for an Approve/Deny prompt that name is the entire answer.
+     */
+    actions?: NotificationAction[];
     /**
      * Notification body text
      */
@@ -648,13 +745,6 @@ export interface NotificationOptions {
      * - Or any system sound name
      */
     sound?: string;
-    /**
-     * Action buttons (platform dependent)
-     */
-    actions?: Array<{
-        action: string;
-        title: string;
-    }>;
     /**
      * Notification tag (for grouping/replacing)
      */
@@ -870,7 +960,83 @@ export interface CraftMobileAPI {
  * defines the CraftBridge interface with additional mobile-only features
  * such as AR, ML, deep links, OTA updates, widgets, and auth persistence.
  */
+/**
+ * Where the platform drew this window's window buttons — the macOS traffic
+ * lights, and their equivalents elsewhere.
+ *
+ * The buttons are the window server's on every desktop window Craft opens that
+ * is not frameless: real, correctly styled, wired to the keyboard and to
+ * accessibility. A page must never draw replicas beside them, and this is what
+ * makes that unnecessary — it says where they are, so a layout can leave room
+ * instead of inventing its own.
+ *
+ * Every number is measured from the live window and re-sent when it changes: a
+ * resize, a fullscreen transition, a new document. Listen for the
+ * `craft:windowcontrols` event on `window` for layout that CSS cannot express;
+ * everything else is better served by the four CSS variables, which the host
+ * sets before the document is parsed.
+ *
+ * The same facts reach CSS as `--craft-window-controls-width` / `-height` /
+ * `-inset-x` / `-inset-y` / `-replicas`, and the document as
+ * `<html data-craft-window-controls="...">`.
+ */
+export interface CraftWindowControls {
+    /**
+     * `titlebar` — real buttons, in a titlebar above the page. Nothing to do.
+     * `overlay` — real buttons, over the page's own top-left corner. Leave room.
+     * `custom` — a frameless window: no buttons, and the page's own are the only
+     *   ones there can be.
+     * `none` — no window chrome in this environment at all (iOS, Android).
+     */
+    style: 'titlebar' | 'overlay' | 'custom' | 'none';
+    /** The platform drew real buttons for this window. */
+    native: boolean;
+    /**
+     * ...and they are on screen right now. False in fullscreen, where macOS
+     * takes them into an auto-hiding titlebar — which is why a layout should
+     * reserve `reserveWidth` rather than a remembered constant.
+     */
+    visible: boolean;
+    /**
+     * The block's true position, in CSS px from the top-left of the web
+     * viewport. Negative where the buttons are not over the page at all: above
+     * it in a plain titlebar window, to its left in a window whose web content
+     * starts after a native sidebar.
+     */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /**
+     * The room to leave inside the page — the block's far edge, or zero when it
+     * does not reach into the page. `--craft-window-controls-width` / `-height`.
+     */
+    reserveWidth: number;
+    reserveHeight: number;
+    /**
+     * Where the block starts inside the page, zero unless it overlaps.
+     * `--craft-window-controls-inset-x` / `-inset-y`.
+     */
+    insetX: number;
+    insetY: number;
+    /**
+     * The `display` a replica should take: `'none'` wherever real buttons exist
+     * and wherever there is no window to control, and `null` in a frameless
+     * window, where the page's own controls are the real ones. Published as
+     * `--craft-window-controls-replicas`, which is *removed* rather than set when
+     * this is null, so the page's own fallback applies.
+     */
+    replicas: 'none' | null;
+}
 export interface CraftBridgeAPI {
+    /**
+     * Where the platform drew this window's close/minimise/zoom buttons.
+     *
+     * Present in every Craft window, so a UI that has to lay out around them can
+     * ask instead of guessing — and so a UI shared with the browser can tell the
+     * two apart. See `CraftWindowControls`.
+     */
+    windowControls?: CraftWindowControls;
     /**
      * Trackpad gesture phases (desktop only).
      *
@@ -923,6 +1089,259 @@ export interface CraftBridgeAPI {
      * Screen-sharing and screen-recording detection (macOS)
      */
     screenSharing?: CraftScreenSharingAPI;
+    /**
+     * System-wide hotkeys (macOS).
+     *
+     * Absent in effect on Linux and Windows: the calls exist, and every
+     * registration is refused, because Craft has no implementation there and a
+     * shortcut that can never fire is worse than one that was never accepted.
+     */
+    shortcuts?: CraftGlobalShortcutsAPI;
+    /**
+     * A small scalar preference store (macOS: CFPreferences).
+     */
+    prefs?: CraftPreferencesAPI;
+    /**
+     * The Cmd+, convention: where the App menu's Settings… item arrives.
+     */
+    settings?: CraftSettingsAPI;
+    /**
+     * What the native side actually serves.
+     *
+     * Always present: it is how you find out whether anything else here is.
+     */
+    capabilities?: () => Promise<CraftCapabilities>;
+    /** The last capabilities answer, or null if nothing has asked yet. */
+    capabilitiesSync?: () => CraftCapabilities | null;
+    /**
+     * Whether one surface is known to work — `craft.supports('tray.destroy')`.
+     *
+     * Fails **open**: returns true before capabilities have been fetched, and
+     * true for a namespace craft has not audited. A feature-detection mechanism
+     * that breaks working code when it cannot see itself would be worse than the
+     * gaps it describes.
+     */
+    supports?: (path: string) => boolean;
+}
+/**
+ * How much craft is willing to claim about a namespace.
+ *
+ * - `declared` — audited: the action list below is complete and enforced by a
+ *   conformance test against the dispatch chain.
+ * - `undeclared` — routed, but not audited. Craft claims nothing either way;
+ *   treat it as "try it and handle failure", not as "missing".
+ * - `unavailable` — reachable and known not to work. `reason` says why.
+ * - `unrouted` — implemented natively but absent from the dispatcher, so no
+ *   message can reach it.
+ */
+export type CapabilityNamespaceStatus = 'declared' | 'undeclared' | 'unavailable' | 'unrouted';
+export interface CapabilityAction {
+    status: 'live' | 'unavailable';
+    /** Whether native sends a reply the caller is waiting on. */
+    reply: 'none' | 'result';
+    /** Present when the action is unavailable. */
+    reason?: string;
+}
+export interface CapabilityNamespace {
+    status: CapabilityNamespaceStatus;
+    reason?: string;
+    /** Present only for `declared` namespaces. */
+    actions?: Record<string, CapabilityAction>;
+}
+/**
+ * What the native binary behind this page actually serves.
+ *
+ * The injected bridge script is one blob, the same in every build, so the
+ * presence of `window.craft.x` has never been evidence that anything is behind
+ * it. This is the evidence.
+ */
+export interface CraftCapabilities {
+    namespaces: Record<string, CapabilityNamespace>;
+    /**
+     * Every `craft:*` event channel, and what craft can say about it.
+     *
+     * `'live'` means something in this build took out a permit to emit on it.
+     * `'unknown'` means craft cannot prove it either way — subscribe and see, and
+     * do **not** disable a feature over it.
+     *
+     * There is deliberately no `'dead'`. Craft cannot establish absence: the
+     * `craft:window:*` names are composed in JavaScript from
+     * `__craftDeliverWindowEvent('focus')`, so no source scan finds the literal
+     * even though the emitter is right there.
+     */
+    channels: Record<string, 'live' | 'unknown'>;
+}
+/**
+ * The only value types `craft.prefs` stores.
+ *
+ * Anything else is refused in the page, before it can reach native. That is
+ * deliberate rather than a limitation dodged: the preferences API raises an
+ * Objective-C exception for a value that is not a property-list type, and Zig
+ * cannot catch one — so refusing containers here is what makes that crash
+ * unreachable. Serialise structure yourself:
+ * `prefs.set(k, JSON.stringify(v))`.
+ */
+export type PreferenceValue = string | number | boolean;
+export interface CraftPreferencesInfo {
+    /**
+     * The preferences domain in use — the bundle identifier inside a packaged
+     * `.app`, the executable's name otherwise.
+     */
+    domain: string;
+    /** The key prefix craft namespaces its own preferences under. */
+    prefix: string;
+    /** How many keys the app currently has stored. */
+    count: number;
+    /** A copy-pasteable command that prints the domain. */
+    readCommand: string;
+}
+/**
+ * A small preference store over the platform's own mechanism, so `defaults
+ * read` and a native settings pane both see what the app wrote.
+ *
+ * macOS only. Values are stored as native property-list types under a reserved
+ * key prefix, so clearing craft's preferences cannot disturb the AppKit and
+ * WebKit keys that share the same domain.
+ */
+export interface CraftPreferencesAPI {
+    /**
+     * Read a preference.
+     *
+     * `fallback` is returned when the key is absent — and also when what is
+     * stored is of a different type from the fallback, which is how a value left
+     * behind by an older build of the app degrades to the default rather than to
+     * a surprise. Call `get(key)` with no fallback to read whatever is stored.
+     *
+     * Rejects with `code: 'PREFS_FOREIGN_VALUE'` if something outside craft
+     * wrote a value craft cannot represent, rather than coercing it away.
+     */
+    get: <T extends PreferenceValue>(key: string, fallback?: T) => Promise<T | undefined>;
+    /**
+     * Write a preference. Resolves once the value is on disk, not merely once
+     * the message was posted.
+     *
+     * Rejects with `code: 'PREFS_UNSUPPORTED_VALUE'` for anything that is not a
+     * string, number or boolean; `'PREFS_NON_FINITE'` for NaN or Infinity;
+     * `'PREFS_VALUE_TOO_LARGE'` past 8 KiB; `'PREFS_BAD_KEY'` for a key outside
+     * `/^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/`.
+     */
+    set: (key: string, value: PreferenceValue) => Promise<void>;
+    /** Remove a preference. Resolves to whether it was there to begin with. */
+    delete: (key: string) => Promise<boolean>;
+    /**
+     * Remove every preference this app has set, and nothing else. Resolves to
+     * how many were removed.
+     */
+    clear: () => Promise<number>;
+    /** Every key this app has set, sorted. */
+    keys: () => Promise<string[]>;
+    /**
+     * Which domain the preferences are actually landing in.
+     *
+     * Worth having: an unbundled dev-mode binary writes to a domain named after
+     * the executable while a packaged `.app` writes to its bundle identifier, so
+     * preferences set during development can appear to vanish once the app is
+     * packaged.
+     */
+    info: () => Promise<CraftPreferencesInfo>;
+}
+/**
+ * The Cmd+, convention.
+ *
+ * craft's default App menu ships a `Settings…` item, and this is where its
+ * click arrives. An app that replaces the whole menu bar with
+ * `craft.menu.set()` loses the default item, and can declare
+ * `{ id: 'settings', role: 'settings', label: 'Settings…', shortcut: 'cmd+,' }`
+ * to get it back — the same handler answers either way.
+ */
+export interface CraftSettingsAPI {
+    /** Subscribe to Settings being opened. Returns an unsubscribe function. */
+    onOpen: (handler: (event: {
+        source: string;
+    }) => void) => () => void;
+    /**
+     * Open settings from the app's own UI — a gear button, say — so it lands in
+     * the same handler as Cmd+, rather than needing a second code path. Purely
+     * page-local; nothing crosses the bridge.
+     */
+    open: (source?: string) => Promise<void>;
+}
+/** A global hotkey, as `craft.shortcuts.list()` reports it. */
+export interface GlobalShortcut {
+    /** The id the app registered it under. */
+    id: string;
+    /**
+     * Craft's canonical spelling of the combination — `Cmd+Delete`, whatever
+     * the app originally wrote — so it can be passed straight back to
+     * `register()`.
+     */
+    accelerator: string;
+    /** The key alone, canonically named. */
+    key: string;
+    /** False while `disable()` has the key released back to the system. */
+    enabled: boolean;
+}
+/** Why a registration was refused. */
+export interface GlobalShortcutError {
+    /** The id from the payload that failed, or `''` if it had none. */
+    id: string;
+    /** Craft's error code, e.g. `NATIVE_CALL_FAILED`, `INVALID_PARAMETER`. */
+    code: string;
+    message: string;
+}
+/**
+ * System-wide hotkeys: they fire whether or not the app is frontmost.
+ *
+ * Accelerators are `+`-separated and case-insensitive — `'Cmd+Shift+H'`. The
+ * last component is the key, everything before it a modifier (`Cmd`/`Command`/
+ * `Meta`, `Ctrl`/`Control`, `Alt`/`Option`, `Shift`, or `CmdOrCtrl` for the
+ * platform's own). Keys are named by position on the keyboard, not by the
+ * character they produce, so a binding survives a layout change.
+ *
+ * At least one of Command, Control or Option is required, except on the
+ * function keys: a bare global hotkey on `H` would mean no application on the
+ * system ever saw the user type an h again.
+ */
+export interface CraftGlobalShortcutsAPI {
+    /**
+     * Reserve a combination system-wide. Registering an `id` twice replaces the
+     * first binding.
+     *
+     * The promise resolves once the message is posted, **not** once the key is
+     * reserved — so a combination that belongs to another app or to the system
+     * resolves here and reports on {@link CraftGlobalShortcutsAPI.onError}.
+     */
+    register: (id: string, accelerator: string) => Promise<void>;
+    /** Give the key back to the system and forget the shortcut. */
+    unregister: (id: string) => Promise<void>;
+    /** The same, for every shortcut this app holds. */
+    unregisterAll: () => Promise<void>;
+    /**
+     * Stop firing *and release the key*, so other apps can use it again. The
+     * shortcut stays listed. Holding a reservation while dropping the event
+     * would make the combination dead in every other app for as long as Craft
+     * ran.
+     */
+    disable: (id: string) => Promise<void>;
+    /**
+     * Take the key back. Can fail if something else claimed it while it was
+     * released, which reports on {@link CraftGlobalShortcutsAPI.onError}.
+     */
+    enable: (id: string) => Promise<void>;
+    /** Whether the id is known — enabled or not. */
+    isRegistered: (id: string) => Promise<boolean>;
+    list: () => Promise<GlobalShortcut[]>;
+    /** Every press of a registered, enabled shortcut. Returns an unsubscribe. */
+    on: (handler: (event: {
+        id: string;
+        accelerator: string;
+    }) => void) => () => void;
+    /**
+     * Where every fire-and-forget call reports its failure — `register`,
+     * `enable`, `disable`, `unregister`. (`isRegistered` and `list` are
+     * requests and reject their own promise instead.) Returns an unsubscribe.
+     */
+    onError: (handler: (error: GlobalShortcutError) => void) => () => void;
 }
 /**
  * Focus / Do Not Disturb authorization state, mirroring

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.76",
+  "version": "0.0.78",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",