@vantail/api 0.1.0

package/dist/app.d.ts

@@ -0,0 +1,87 @@
+export interface AppInfo {
+    name: string;
+    version: string;
+    identifier: string;
+    isDev: boolean;
+}
+/** Identity and lifecycle of the running application. */
+export type ProgressState = "none" | "normal" | "indeterminate" | "paused" | "error";
+export interface ProgressOptions {
+    /** 0 to 100. Leave it out to change only the state. */
+    value?: number;
+    state?: ProgressState;
+}
+export declare const app: {
+    name: () => Promise<string>;
+    version: () => Promise<string>;
+    identifier: () => Promise<string>;
+    info: () => Promise<AppInfo>;
+    /** Whether the app is running under `vantail dev`. */
+    isDev: () => Promise<boolean>;
+    /**
+     * The same facts as {@link app.info}, without awaiting.
+     *
+     * The runtime injects them before any application code runs, so this is
+     * safe to read during module evaluation. Returns `undefined` in a browser.
+     */
+    infoSync: () => AppInfo | undefined;
+    /**
+     * Send an application-defined event to another window, or to all of them.
+     *
+     * This is how two windows talk to each other: there is no shared memory
+     * between webviews, so a message goes out through the runtime and comes
+     * back in on the other side.
+     *
+     * ```ts
+     * // in the main window
+     * await app.emit("document-saved", { path }, { to: "preview" });
+     *
+     * // in the preview window
+     * app.listen<{ path: string }>("document-saved", ({ path }) => reload(path));
+     * ```
+     */
+    emit: (event: string, payload?: unknown, options?: {
+        to?: string;
+    }) => Promise<null>;
+    /**
+     * Listen for events sent with {@link app.emit}. Returns an unsubscribe
+     * function. The second argument tells you which window sent it.
+     */
+    listen: <T = unknown>(event: string, handler: (payload: T, meta: {
+        from: string;
+    }) => void) => (() => void);
+    /**
+     * Somebody started the application again while it was already running.
+     *
+     * Only fires when `singleInstance` is on, which is where the second launch
+     * hands over its arguments and exits instead of opening a second copy. The
+     * runtime has already brought the existing window to the front by the time
+     * this arrives.
+     */
+    onSecondInstance: (handler: (launch: {
+        args: string[];
+        cwd: string;
+    }) => void) => () => void;
+    /** Close the application. Does not resolve - the process is going away. */
+    /**
+     * The badge on the application's icon - an unread count, usually.
+     * `null` clears it.
+     *
+     * macOS shows any text. Linux shows a number, so a label that is not one is
+     * refused there. Windows has no text badge and answers `UNSUPPORTED`.
+     */
+    setBadge: (label: string | number | null) => Promise<null>;
+    /**
+     * The progress bar drawn across the application's icon or taskbar button.
+     *
+     * ```ts
+     * await app.setProgress({ value: 40, state: "normal" });
+     * await app.setProgress({ state: "none" });   // done
+     * ```
+     */
+    setProgress: (options: ProgressOptions) => Promise<null>;
+    quit: () => Promise<null>;
+    /** Relaunch the application with the same arguments. */
+    restart: () => Promise<null>;
+};
+//# sourceMappingURL=app.d.ts.map

package/dist/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,yDAAyD;AACzD,MAAM,MAAM,aAAa,GACvB,MAAM,GAAG,QAAQ,GAAG,eAAe,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,eAAe;IAC9B,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED,eAAO,MAAM,GAAG;IACd,IAAI;IACJ,OAAO;IACP,UAAU;IACV,IAAI;IAEJ,sDAAsD;IACtD,KAAK;IAEL;;;;;OAKG;IACH,QAAQ,QAAM,OAAO,GAAG,SAAS;IAOjC;;;;;;;;;;;;;;OAcG;IACH,IAAI,UAAU,MAAM,YAAY,OAAO,YAAW;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE;IAGjE;;;OAGG;IACH,MAAM,GAAG,CAAC,GAAG,OAAO,SACX,MAAM,WACJ,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,KACpD,CAAC,MAAM,IAAI,CAAC;IAOf;;;;;;;OAOG;IACH,gBAAgB,YACL,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI;IAG5D,2EAA2E;IAC3E;;;;;;OAMG;IACH,QAAQ,UAAU,MAAM,GAAG,MAAM,GAAG,IAAI;IAKxC;;;;;;;OAOG;IACH,WAAW,YAAY,eAAe;IAGtC,IAAI;IAEJ,wDAAwD;IACxD,OAAO;CACR,CAAC"}

package/dist/app.js

@@ -0,0 +1,79 @@
+import { bridgeInfo, invoke, listen } from "./transport.js";
+export const app = {
+    name: () => invoke("app.name"),
+    version: () => invoke("app.version"),
+    identifier: () => invoke("app.identifier"),
+    info: () => invoke("app.info"),
+    /** Whether the app is running under `vantail dev`. */
+    isDev: () => invoke("app.isDev"),
+    /**
+     * The same facts as {@link app.info}, without awaiting.
+     *
+     * The runtime injects them before any application code runs, so this is
+     * safe to read during module evaluation. Returns `undefined` in a browser.
+     */
+    infoSync: () => {
+        const info = bridgeInfo();
+        if (!info)
+            return undefined;
+        const { name, version, identifier, isDev } = info;
+        return { name, version, identifier, isDev };
+    },
+    /**
+     * Send an application-defined event to another window, or to all of them.
+     *
+     * This is how two windows talk to each other: there is no shared memory
+     * between webviews, so a message goes out through the runtime and comes
+     * back in on the other side.
+     *
+     * ```ts
+     * // in the main window
+     * await app.emit("document-saved", { path }, { to: "preview" });
+     *
+     * // in the preview window
+     * app.listen<{ path: string }>("document-saved", ({ path }) => reload(path));
+     * ```
+     */
+    emit: (event, payload, options = {}) => invoke("app.emit", { event, payload: payload ?? null, ...options }),
+    /**
+     * Listen for events sent with {@link app.emit}. Returns an unsubscribe
+     * function. The second argument tells you which window sent it.
+     */
+    listen: (event, handler) => 
+    // User events travel under a `user:` prefix so an application can name
+    // its events anything without colliding with `window.resized` and friends.
+    listen(`user:${event}`, (message) => handler(message.payload, { from: message.from })),
+    /**
+     * Somebody started the application again while it was already running.
+     *
+     * Only fires when `singleInstance` is on, which is where the second launch
+     * hands over its arguments and exits instead of opening a second copy. The
+     * runtime has already brought the existing window to the front by the time
+     * this arrives.
+     */
+    onSecondInstance: (handler) => listen("app.secondInstance", handler),
+    /** Close the application. Does not resolve - the process is going away. */
+    /**
+     * The badge on the application's icon - an unread count, usually.
+     * `null` clears it.
+     *
+     * macOS shows any text. Linux shows a number, so a label that is not one is
+     * refused there. Windows has no text badge and answers `UNSUPPORTED`.
+     */
+    setBadge: (label) => invoke("app.setBadge", {
+        label: label === null ? null : String(label),
+    }),
+    /**
+     * The progress bar drawn across the application's icon or taskbar button.
+     *
+     * ```ts
+     * await app.setProgress({ value: 40, state: "normal" });
+     * await app.setProgress({ state: "none" });   // done
+     * ```
+     */
+    setProgress: (options) => invoke("app.setProgress", options),
+    quit: () => invoke("app.quit"),
+    /** Relaunch the application with the same arguments. */
+    restart: () => invoke("app.restart"),
+};
+//# sourceMappingURL=app.js.map

package/dist/app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.js","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAmB5D,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,IAAI,EAAE,GAAG,EAAE,CAAC,MAAM,CAAS,UAAU,CAAC;IACtC,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAS,aAAa,CAAC;IAC5C,UAAU,EAAE,GAAG,EAAE,CAAC,MAAM,CAAS,gBAAgB,CAAC;IAClD,IAAI,EAAE,GAAG,EAAE,CAAC,MAAM,CAAU,UAAU,CAAC;IAEvC,sDAAsD;IACtD,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAU,WAAW,CAAC;IAEzC;;;;;OAKG;IACH,QAAQ,EAAE,GAAwB,EAAE;QAClC,MAAM,IAAI,GAAG,UAAU,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI;YAAE,OAAO,SAAS,CAAC;QAC5B,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;QAClD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,EAAE,CAAC,KAAa,EAAE,OAAiB,EAAE,OAAO,GAAoB,EAAE,EAAE,EAAE,CACxE,MAAM,CAAO,UAAU,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC;IAE3E;;;OAGG;IACH,MAAM,EAAE,CACN,KAAa,EACb,OAAqD,EACvC,EAAE;IAChB,uEAAuE;IACvE,2EAA2E;IAC3E,MAAM,CAA+B,QAAQ,KAAK,EAAE,EAAE,CAAC,OAAO,EAAE,EAAE,CAChE,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CACjD;IAEH;;;;;;;OAOG;IACH,gBAAgB,EAAE,CAChB,OAA0D,EAC1D,EAAE,CAAC,MAAM,CAAkC,oBAAoB,EAAE,OAAO,CAAC;IAE3E,2EAA2E;IAC3E;;;;;;OAMG;IACH,QAAQ,EAAE,CAAC,KAA6B,EAAE,EAAE,CAC1C,MAAM,CAAO,cAAc,EAAE;QAC3B,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;KAC7C,CAAC;IAEJ;;;;;;;OAOG;IACH,WAAW,EAAE,CAAC,OAAwB,EAAE,EAAE,CACxC,MAAM,CAAO,iBAAiB,EAAE,OAAO,CAAC;IAE1C,IAAI,EAAE,GAAG,EAAE,CAAC,MAAM,CAAO,UAAU,CAAC;IAEpC,wDAAwD;IACxD,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAO,aAAa,CAAC;CAC3C,CAAC"}

package/dist/autostart.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Starting when the user logs in.
+ *
+ * Each platform keeps its own register of these - a launch agent on macOS, a
+ * `Run` value on Windows, a desktop entry on Linux - and all three name a
+ * path, so this only works on a packaged application. Calling it from
+ * `vantail dev` throws `UNSUPPORTED` rather than registering a path that will
+ * not exist tomorrow.
+ *
+ * ```ts
+ * if (!(await autostart.isEnabled())) await autostart.enable();
+ * ```
+ */
+export declare const autostart: {
+    /** Start this application at login. */
+    enable(): Promise<void>;
+    /** Stop starting it. Doing this twice is not an error. */
+    disable(): Promise<void>;
+    isEnabled(): Promise<boolean>;
+};
+//# sourceMappingURL=autostart.d.ts.map

package/dist/autostart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autostart.d.ts","sourceRoot":"","sources":["../src/autostart.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS;IACpB,uCAAuC;IACvC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,0DAA0D;IAC1D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;CAG9B,CAAC"}

package/dist/autostart.js

@@ -0,0 +1,28 @@
+import { invoke } from "./transport.js";
+/**
+ * Starting when the user logs in.
+ *
+ * Each platform keeps its own register of these - a launch agent on macOS, a
+ * `Run` value on Windows, a desktop entry on Linux - and all three name a
+ * path, so this only works on a packaged application. Calling it from
+ * `vantail dev` throws `UNSUPPORTED` rather than registering a path that will
+ * not exist tomorrow.
+ *
+ * ```ts
+ * if (!(await autostart.isEnabled())) await autostart.enable();
+ * ```
+ */
+export const autostart = {
+    /** Start this application at login. */
+    enable() {
+        return invoke("autostart.enable");
+    },
+    /** Stop starting it. Doing this twice is not an error. */
+    disable() {
+        return invoke("autostart.disable");
+    },
+    isEnabled() {
+        return invoke("autostart.isEnabled");
+    },
+};
+//# sourceMappingURL=autostart.js.map

package/dist/autostart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autostart.js","sourceRoot":"","sources":["../src/autostart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,uCAAuC;IACvC,MAAM;QACJ,OAAO,MAAM,CAAO,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,0DAA0D;IAC1D,OAAO;QACL,OAAO,MAAM,CAAO,mBAAmB,CAAC,CAAC;IAC3C,CAAC;IAED,SAAS;QACP,OAAO,MAAM,CAAU,qBAAqB,CAAC,CAAC;IAChD,CAAC;CACF,CAAC"}

package/dist/binary.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Binary data on the wire.
+ *
+ * The IPC channel carries JSON, so bytes travel as base64. That costs a third
+ * again in size and has to be built in memory on both sides, which is why the
+ * runtime caps binary calls at 64 MB rather than pretending this is a stream.
+ */
+/** Bytes accepted by `filesystem.writeBinary`. */
+export type BinaryInput = Uint8Array | ArrayBuffer | ArrayBufferView;
+export declare function toBytes(input: BinaryInput): Uint8Array;
+export declare function encode(input: BinaryInput): string;
+export declare function decode(base64: string): Uint8Array;
+//# sourceMappingURL=binary.d.ts.map

package/dist/binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,eAAe,CAAC;AAErE,wBAAgB,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,CAItD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAejD;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAYjD"}

package/dist/binary.js

@@ -0,0 +1,41 @@
+/**
+ * Binary data on the wire.
+ *
+ * The IPC channel carries JSON, so bytes travel as base64. That costs a third
+ * again in size and has to be built in memory on both sides, which is why the
+ * runtime caps binary calls at 64 MB rather than pretending this is a stream.
+ */
+export function toBytes(input) {
+    if (input instanceof Uint8Array)
+        return input;
+    if (input instanceof ArrayBuffer)
+        return new Uint8Array(input);
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+}
+export function encode(input) {
+    const bytes = toBytes(input);
+    // Newer engines have this and it is markedly faster on large buffers.
+    const fast = bytes.toBase64;
+    if (typeof fast === "function")
+        return fast.call(bytes);
+    // btoa takes a string of code units, and a spread of a large array blows
+    // the argument limit - hence the chunking.
+    let binary = "";
+    const CHUNK = 0x8000;
+    for (let index = 0; index < bytes.length; index += CHUNK) {
+        binary += String.fromCharCode(...bytes.subarray(index, index + CHUNK));
+    }
+    return btoa(binary);
+}
+export function decode(base64) {
+    const fast = Uint8Array.fromBase64;
+    if (typeof fast === "function")
+        return fast(base64);
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+//# sourceMappingURL=binary.js.map

package/dist/binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.js","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,MAAM,UAAU,OAAO,CAAC,KAAkB;IACxC,IAAI,KAAK,YAAY,UAAU;QAAE,OAAO,KAAK,CAAC;IAC9C,IAAI,KAAK,YAAY,WAAW;QAAE,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IAC/D,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;AAC1E,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,KAAkB;IACvC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAE7B,sEAAsE;IACtE,MAAM,IAAI,GAAI,KAAqC,CAAC,QAAQ,CAAC;IAC7D,IAAI,OAAO,IAAI,KAAK,UAAU;QAAE,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAExD,yEAAyE;IACzE,2CAA2C;IAC3C,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,MAAM,KAAK,GAAG,MAAM,CAAC;IACrB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,KAAK,EAAE,CAAC;QACzD,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,MAAc;IACnC,MAAM,IAAI,GACR,UACD,CAAC,UAAU,CAAC;IACb,IAAI,OAAO,IAAI,KAAK,UAAU;QAAE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC;IAEpD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACtD,KAAK,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/clipboard.d.ts

@@ -0,0 +1,36 @@
+import { type BinaryInput } from "./binary.js";
+export interface ClipboardImage {
+    width: number;
+    height: number;
+    /** The image as PNG bytes. */
+    data: Uint8Array;
+}
+/** The system clipboard. */
+export declare const clipboard: {
+    /** Resolves to an empty string when the clipboard holds no text. */
+    readText: () => Promise<string>;
+    writeText: (text: string) => Promise<null>;
+    hasText: () => Promise<boolean>;
+    clear: () => Promise<null>;
+    /**
+     * The clipboard's image as PNG bytes, or `null` when it holds no image.
+     *
+     * ```ts
+     * const image = await clipboard.readImage();
+     * if (image) {
+     *   const url = URL.createObjectURL(new Blob([image.data], { type: "image/png" }));
+     *   document.querySelector("img").src = url;
+     * }
+     * ```
+     */
+    readImage(): Promise<ClipboardImage | null>;
+    /**
+     * Put a PNG on the clipboard.
+     *
+     * The clipboard itself holds raw pixels, so this is converted on the way -
+     * an image without an alpha channel is fine.
+     */
+    writeImage: (png: BinaryInput) => Promise<null>;
+    hasImage: () => Promise<boolean>;
+};
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../src/clipboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/D,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,4BAA4B;AAC5B,eAAO,MAAM,SAAS;IACpB,oEAAoE;IACpE,QAAQ;IACR,SAAS,SAAS,MAAM;IACxB,OAAO;IACP,KAAK;IAEL;;;;;;;;;;OAUG;IACG,SAAS,IAAI,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAUjD;;;;;OAKG;IACH,UAAU,QAAQ,WAAW;IAG7B,QAAQ;CACT,CAAC"}

package/dist/clipboard.js

@@ -0,0 +1,34 @@
+import { decode, encode } from "./binary.js";
+import { invoke } from "./transport.js";
+/** The system clipboard. */
+export const clipboard = {
+    /** Resolves to an empty string when the clipboard holds no text. */
+    readText: () => invoke("clipboard.readText"),
+    writeText: (text) => invoke("clipboard.writeText", { text }),
+    hasText: () => invoke("clipboard.hasText"),
+    clear: () => invoke("clipboard.clear"),
+    /**
+     * The clipboard's image as PNG bytes, or `null` when it holds no image.
+     *
+     * ```ts
+     * const image = await clipboard.readImage();
+     * if (image) {
+     *   const url = URL.createObjectURL(new Blob([image.data], { type: "image/png" }));
+     *   document.querySelector("img").src = url;
+     * }
+     * ```
+     */
+    async readImage() {
+        const result = await invoke("clipboard.readImage");
+        return result && { ...result, data: decode(result.data) };
+    },
+    /**
+     * Put a PNG on the clipboard.
+     *
+     * The clipboard itself holds raw pixels, so this is converted on the way -
+     * an image without an alpha channel is fine.
+     */
+    writeImage: (png) => invoke("clipboard.writeImage", { data: encode(png) }),
+    hasImage: () => invoke("clipboard.hasImage"),
+};
+//# sourceMappingURL=clipboard.js.map

package/dist/clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.js","sourceRoot":"","sources":["../src/clipboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAoB,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AASxC,4BAA4B;AAC5B,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,oEAAoE;IACpE,QAAQ,EAAE,GAAG,EAAE,CAAC,MAAM,CAAS,oBAAoB,CAAC;IACpD,SAAS,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,MAAM,CAAO,qBAAqB,EAAE,EAAE,IAAI,EAAE,CAAC;IAC1E,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAU,mBAAmB,CAAC;IACnD,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAO,iBAAiB,CAAC;IAE5C;;;;;;;;;;OAUG;IACH,KAAK,CAAC,SAAS;QACb,MAAM,MAAM,GAAG,MAAM,MAAM,CAIjB,qBAAqB,CAAC,CAAC;QAEjC,OAAO,MAAM,IAAI,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;IAC5D,CAAC;IAED;;;;;OAKG;IACH,UAAU,EAAE,CAAC,GAAgB,EAAE,EAAE,CAC/B,MAAM,CAAO,sBAAsB,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;IAE7D,QAAQ,EAAE,GAAG,EAAE,CAAC,MAAM,CAAU,oBAAoB,CAAC;CACtD,CAAC"}

package/dist/deeplink.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Links to your application, from anywhere on the machine.
+ *
+ * Register a scheme in `vantail.config.ts` and `myapp://...` reaches you -
+ * which is how a desktop application finishes an OAuth sign-in, since the
+ * browser needs somewhere to send the user back to.
+ *
+ * ```ts
+ * deepLink.onOpen((url) => {
+ *   const code = new URL(url).searchParams.get("code");
+ *   if (code) void exchangeForToken(code);
+ * });
+ * ```
+ *
+ * **Treat the URL as input from a stranger.** Any web page or program on the
+ * machine can open one. The runtime guarantees only that the scheme is one of
+ * yours; everything after that is unverified, so check the state parameter of
+ * an OAuth callback rather than trusting it arrived.
+ *
+ * A link that launched the application arrives before any page exists. It is
+ * held for you, and delivered as soon as you register a handler - so there is
+ * no window in which the link that started the app can be missed.
+ */
+export declare const deepLink: {
+    /**
+     * Handle links, including any that arrived before this ran.
+     *
+     * Returns an unsubscribe function.
+     */
+    onOpen: (handler: (url: string) => void) => (() => void);
+    /** The schemes this application registered. */
+    protocols: () => Promise<string[]>;
+};
+/** Only used by tests, to undo the module-level cache. */
+export declare function resetDeepLinkState(): void;
+//# sourceMappingURL=deeplink.d.ts.map

package/dist/deeplink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deeplink.d.ts","sourceRoot":"","sources":["../src/deeplink.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;OAIG;IACH,MAAM,YAAY,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC;IAqBtD,+CAA+C;IAC/C,SAAS;CACV,CAAC;AAUF,0DAA0D;AAC1D,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/deeplink.js

@@ -0,0 +1,61 @@
+import { invoke, listen } from "./transport.js";
+/**
+ * Links to your application, from anywhere on the machine.
+ *
+ * Register a scheme in `vantail.config.ts` and `myapp://...` reaches you -
+ * which is how a desktop application finishes an OAuth sign-in, since the
+ * browser needs somewhere to send the user back to.
+ *
+ * ```ts
+ * deepLink.onOpen((url) => {
+ *   const code = new URL(url).searchParams.get("code");
+ *   if (code) void exchangeForToken(code);
+ * });
+ * ```
+ *
+ * **Treat the URL as input from a stranger.** Any web page or program on the
+ * machine can open one. The runtime guarantees only that the scheme is one of
+ * yours; everything after that is unverified, so check the state parameter of
+ * an OAuth callback rather than trusting it arrived.
+ *
+ * A link that launched the application arrives before any page exists. It is
+ * held for you, and delivered as soon as you register a handler - so there is
+ * no window in which the link that started the app can be missed.
+ */
+export const deepLink = {
+    /**
+     * Handle links, including any that arrived before this ran.
+     *
+     * Returns an unsubscribe function.
+     */
+    onOpen: (handler) => {
+        // Registered before subscribing: subscribing releases whatever the
+        // runtime was holding, and a handler added afterwards would miss exactly
+        // the link it was written for.
+        const stop = listen("deeplink.open", ({ url }) => handler(url));
+        if (arrived === undefined) {
+            // First subscriber: ask the runtime for what it held, and remember it
+            // so a handler registered later in this session still sees it.
+            arrived = invoke("deeplink.subscribe");
+        }
+        void arrived.then((urls) => {
+            for (const url of urls)
+                handler(url);
+        });
+        return stop;
+    },
+    /** The schemes this application registered. */
+    protocols: () => invoke("deeplink.protocols"),
+};
+/**
+ * Links the application was started with.
+ *
+ * Cached so that every handler sees them, not only whichever one happened to
+ * register first.
+ */
+let arrived;
+/** Only used by tests, to undo the module-level cache. */
+export function resetDeepLinkState() {
+    arrived = undefined;
+}
+//# sourceMappingURL=deeplink.js.map

package/dist/deeplink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deeplink.js","sourceRoot":"","sources":["../src/deeplink.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB;;;;OAIG;IACH,MAAM,EAAE,CAAC,OAA8B,EAAgB,EAAE;QACvD,mEAAmE;QACnE,yEAAyE;QACzE,+BAA+B;QAC/B,MAAM,IAAI,GAAG,MAAM,CAAkB,eAAe,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAChE,OAAO,CAAC,GAAG,CAAC,CACb,CAAC;QAEF,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,sEAAsE;YACtE,+DAA+D;YAC/D,OAAO,GAAG,MAAM,CAAW,oBAAoB,CAAC,CAAC;QACnD,CAAC;QAED,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YACzB,KAAK,MAAM,GAAG,IAAI,IAAI;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC;IACd,CAAC;IAED,+CAA+C;IAC/C,SAAS,EAAE,GAAG,EAAE,CAAC,MAAM,CAAW,oBAAoB,CAAC;CACxD,CAAC;AAEF;;;;;GAKG;AACH,IAAI,OAAsC,CAAC;AAE3C,0DAA0D;AAC1D,MAAM,UAAU,kBAAkB;IAChC,OAAO,GAAG,SAAS,CAAC;AACtB,CAAC"}

package/dist/dialog.d.ts

@@ -0,0 +1,48 @@
+export interface FileFilter {
+    /** Shown in the dialog's file-type dropdown, e.g. "Markdown". */
+    name: string;
+    /** Extensions without the dot, e.g. `["md", "markdown"]`. */
+    extensions: string[];
+}
+export interface OpenOptions {
+    title?: string;
+    /** A file or directory to open the dialog at. */
+    defaultPath?: string;
+    filters?: FileFilter[];
+}
+export interface SaveOptions {
+    title?: string;
+    defaultPath?: string;
+    /** Pre-filled file name. */
+    defaultName?: string;
+    filters?: FileFilter[];
+}
+export interface MessageOptions {
+    title?: string;
+    kind?: "info" | "warning" | "error";
+}
+export interface ConfirmOptions extends MessageOptions {
+    okLabel?: string;
+    cancelLabel?: string;
+}
+/**
+ * Native dialogs.
+ *
+ * A path the user picks here is also *granted* to `filesystem` for the rest
+ * of the session - the user's choice is the authorisation. That is what makes
+ * a tight `permissions.filesystem` scope practical.
+ *
+ * Every picker resolves to `null` when the user cancels.
+ */
+export declare const dialog: {
+    openFile: (options?: OpenOptions) => Promise<string | null>;
+    openFiles: (options?: OpenOptions) => Promise<string[]>;
+    openDirectory: (options?: OpenOptions) => Promise<string | null>;
+    openDirectories: (options?: OpenOptions) => Promise<string[]>;
+    saveFile: (options?: SaveOptions) => Promise<string | null>;
+    /** An informational dialog with a single dismiss button. */
+    message: (message: string, options?: MessageOptions) => Promise<null>;
+    /** Resolves `true` when the user accepts. */
+    confirm: (message: string, options?: ConfirmOptions) => Promise<boolean>;
+};
+//# sourceMappingURL=dialog.d.ts.map

package/dist/dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog.d.ts","sourceRoot":"","sources":["../src/dialog.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4BAA4B;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,cAAe,SAAQ,cAAc;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;IACjB,QAAQ,aAAY,WAAW;IAG/B,SAAS,aAAY,WAAW;IAGhC,aAAa,aAAY,WAAW;IAMpC,eAAe,aAAY,WAAW;IAGtC,QAAQ,aAAY,WAAW;IAG/B,4DAA4D;IAC5D,OAAO,YAAY,MAAM,YAAW,cAAc;IAGlD,6CAA6C;IAC7C,OAAO,YAAY,MAAM,YAAW,cAAc;CAEnD,CAAC"}

package/dist/dialog.js

@@ -0,0 +1,25 @@
+import { invoke } from "./transport.js";
+/**
+ * Native dialogs.
+ *
+ * A path the user picks here is also *granted* to `filesystem` for the rest
+ * of the session - the user's choice is the authorisation. That is what makes
+ * a tight `permissions.filesystem` scope practical.
+ *
+ * Every picker resolves to `null` when the user cancels.
+ */
+export const dialog = {
+    openFile: (options = {}) => invoke("dialog.openFile", { ...options, multiple: false }),
+    openFiles: (options = {}) => invoke("dialog.openFile", { ...options, multiple: true }),
+    openDirectory: (options = {}) => invoke("dialog.openDirectory", {
+        ...options,
+        multiple: false,
+    }),
+    openDirectories: (options = {}) => invoke("dialog.openDirectory", { ...options, multiple: true }),
+    saveFile: (options = {}) => invoke("dialog.saveFile", { ...options, multiple: false }),
+    /** An informational dialog with a single dismiss button. */
+    message: (message, options = {}) => invoke("dialog.message", { ...options, message }),
+    /** Resolves `true` when the user accepts. */
+    confirm: (message, options = {}) => invoke("dialog.confirm", { ...options, message }),
+};
+//# sourceMappingURL=dialog.js.map

package/dist/dialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog.js","sourceRoot":"","sources":["../src/dialog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAkCxC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,QAAQ,EAAE,CAAC,OAAO,GAAgB,EAAE,EAAE,EAAE,CACtC,MAAM,CAAgB,iBAAiB,EAAE,EAAE,GAAG,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAE3E,SAAS,EAAE,CAAC,OAAO,GAAgB,EAAE,EAAE,EAAE,CACvC,MAAM,CAAW,iBAAiB,EAAE,EAAE,GAAG,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAErE,aAAa,EAAE,CAAC,OAAO,GAAgB,EAAE,EAAE,EAAE,CAC3C,MAAM,CAAgB,sBAAsB,EAAE;QAC5C,GAAG,OAAO;QACV,QAAQ,EAAE,KAAK;KAChB,CAAC;IAEJ,eAAe,EAAE,CAAC,OAAO,GAAgB,EAAE,EAAE,EAAE,CAC7C,MAAM,CAAW,sBAAsB,EAAE,EAAE,GAAG,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAE1E,QAAQ,EAAE,CAAC,OAAO,GAAgB,EAAE,EAAE,EAAE,CACtC,MAAM,CAAgB,iBAAiB,EAAE,EAAE,GAAG,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAE3E,4DAA4D;IAC5D,OAAO,EAAE,CAAC,OAAe,EAAE,OAAO,GAAmB,EAAE,EAAE,EAAE,CACzD,MAAM,CAAO,gBAAgB,EAAE,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC;IAEzD,6CAA6C;IAC7C,OAAO,EAAE,CAAC,OAAe,EAAE,OAAO,GAAmB,EAAE,EAAE,EAAE,CACzD,MAAM,CAAU,gBAAgB,EAAE,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC;CAC7D,CAAC"}

package/dist/drop.d.ts

@@ -0,0 +1,37 @@
+export interface DropEvent {
+    /** Absolute paths of what was dropped. */
+    paths: string[];
+    /** Where, relative to the window's top-left corner. */
+    position: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Files dragged onto the window.
+ *
+ * HTML5 drag events give a page the *contents* of a dropped file but never its
+ * path, so a dropped file cannot be handed to {@link filesystem}. These events
+ * carry the paths, and a dropped path becomes readable for the rest of the
+ * session - dropping a file is the user choosing it, exactly as a dialog is.
+ * (`filesystem.grantFromDrop`, on by default, controls that.)
+ *
+ * Needs `permissions.dragDrop`. **Turning it on changes what the page sees:**
+ * the runtime handles the drop, so HTML5 `drop` events stop firing for files
+ * and these arrive instead. With the permission off, nothing changes.
+ *
+ * ```ts
+ * fileDrop.onDrop(async ({ paths }) => {
+ *   for (const path of paths) console.log(await filesystem.readText(path));
+ * });
+ * ```
+ */
+export declare const fileDrop: {
+    /** A drag arrived over the window, carrying these paths. */
+    onEnter: (handler: (event: DropEvent) => void) => () => void;
+    /** They were let go. */
+    onDrop: (handler: (event: DropEvent) => void) => () => void;
+    /** The drag left the window, or was cancelled. */
+    onLeave: (handler: () => void) => () => void;
+};
+//# sourceMappingURL=drop.d.ts.map

package/dist/drop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../src/drop.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,SAAS;IACxB,0CAA0C;IAC1C,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,uDAAuD;IACvD,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ;IACnB,4DAA4D;IAC5D,OAAO,YAAY,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI;IAG7C,wBAAwB;IACxB,MAAM,YAAY,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI;IAG5C,kDAAkD;IAClD,OAAO,YAAY,MAAM,IAAI;CAE9B,CAAC"}

package/dist/drop.js

@@ -0,0 +1,29 @@
+import { listen } from "./transport.js";
+/**
+ * Files dragged onto the window.
+ *
+ * HTML5 drag events give a page the *contents* of a dropped file but never its
+ * path, so a dropped file cannot be handed to {@link filesystem}. These events
+ * carry the paths, and a dropped path becomes readable for the rest of the
+ * session - dropping a file is the user choosing it, exactly as a dialog is.
+ * (`filesystem.grantFromDrop`, on by default, controls that.)
+ *
+ * Needs `permissions.dragDrop`. **Turning it on changes what the page sees:**
+ * the runtime handles the drop, so HTML5 `drop` events stop firing for files
+ * and these arrive instead. With the permission off, nothing changes.
+ *
+ * ```ts
+ * fileDrop.onDrop(async ({ paths }) => {
+ *   for (const path of paths) console.log(await filesystem.readText(path));
+ * });
+ * ```
+ */
+export const fileDrop = {
+    /** A drag arrived over the window, carrying these paths. */
+    onEnter: (handler) => listen("drop.entered", handler),
+    /** They were let go. */
+    onDrop: (handler) => listen("drop.dropped", handler),
+    /** The drag left the window, or was cancelled. */
+    onLeave: (handler) => listen("drop.left", handler),
+};
+//# sourceMappingURL=drop.js.map

package/dist/drop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop.js","sourceRoot":"","sources":["../src/drop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AASxC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,4DAA4D;IAC5D,OAAO,EAAE,CAAC,OAAmC,EAAE,EAAE,CAC/C,MAAM,CAAY,cAAc,EAAE,OAAO,CAAC;IAE5C,wBAAwB;IACxB,MAAM,EAAE,CAAC,OAAmC,EAAE,EAAE,CAC9C,MAAM,CAAY,cAAc,EAAE,OAAO,CAAC;IAE5C,kDAAkD;IAClD,OAAO,EAAE,CAAC,OAAmB,EAAE,EAAE,CAC/B,MAAM,CAAwB,WAAW,EAAE,OAAO,CAAC;CACtD,CAAC"}