@swipt/api 0.1.0-nightly.42 → 0.1.0-nightly.44

package/accessibility.d.ts

@@ -1,11 +1,35 @@
 import type { CallOptions, Point, Rect } from "./index";
 
-export type AccessibilityTrait = "button" | "link" | "image" | "playsSound" | "keyboardKey" | "staticText" | "summaryElement"
-  | "updatesFrequently" | "searchField" | "startsMediaSession" | "adjustable" | "allowsDirectInteraction"
-  | "causesPageTurn" | "tabBar" | "header" | "webContent" | "textEntry";
+export type AccessibilityTrait =
+  | "button"
+  | "link"
+  | "image"
+  | "playsSound"
+  | "keyboardKey"
+  | "staticText"
+  | "summaryElement"
+  | "updatesFrequently"
+  | "searchField"
+  | "startsMediaSession"
+  | "adjustable"
+  | "allowsDirectInteraction"
+  | "causesPageTurn"
+  | "tabBar"
+  | "header"
+  | "webContent"
+  | "textEntry";
 
-export type AccessibilityAction = "press" | "increment" | "decrement" | "escape" | "menu"
-  | "scrollUp" | "scrollDown" | "scrollLeft" | "scrollRight" | "scrollToVisible";
+export type AccessibilityAction =
+  | "press"
+  | "increment"
+  | "decrement"
+  | "escape"
+  | "menu"
+  | "scrollUp"
+  | "scrollDown"
+  | "scrollLeft"
+  | "scrollRight"
+  | "scrollToVisible";
 
 export interface AccessibilityElement {
   readonly role: string;
@@ -45,13 +69,38 @@ export interface AccessibilitySnapshot {
   findAll(selector: AccessibilitySelector): AccessibilityElement[];
 }
 
-type TextField = "role" | "class" | "label" | "value" | "identifier" | "placeholder" | "hint" | "url" | "app";
-type Flag = "disabled" | "focused" | "selected" | "expanded" | "secure" | "partial" | "offScreen" | "inert" | "remote";
+type TextField =
+  | "role"
+  | "class"
+  | "label"
+  | "value"
+  | "identifier"
+  | "placeholder"
+  | "hint"
+  | "url"
+  | "app";
+type Flag =
+  | "disabled"
+  | "focused"
+  | "selected"
+  | "expanded"
+  | "secure"
+  | "partial"
+  | "offScreen"
+  | "inert"
+  | "remote";
 
 export type AccessibilitySelector =
-  | ({ traits?: AccessibilityTrait[]; within?: AccessibilitySelector | AccessibilityElement; parent?: AccessibilitySelector | AccessibilityElement; has?: AccessibilitySelector | AccessibilityElement; not?: AccessibilitySelector | AccessibilityElement; index?: number }
-    & { [field in TextField]?: string | RegExp }
-    & { [field in Flag]?: boolean })
+  | ({
+      traits?: AccessibilityTrait[];
+      within?: AccessibilitySelector | AccessibilityElement;
+      parent?: AccessibilitySelector | AccessibilityElement;
+      has?: AccessibilitySelector | AccessibilityElement;
+      not?: AccessibilitySelector | AccessibilityElement;
+      index?: number;
+    } & { [field in TextField]?: string | RegExp } & {
+      [field in Flag]?: boolean;
+    })
   | ((element: AccessibilityElement) => boolean);
 
 export interface SnapshotOptions extends CallOptions {
@@ -67,13 +116,29 @@ export interface FindOptions extends CallOptions {
   readonly pollTimeoutMs?: number;
 }
 
-export declare function snapshot(options?: SnapshotOptions): Promise<AccessibilitySnapshot>;
-export declare function find(selector: AccessibilitySelector | readonly AccessibilitySelector[], options?: FindOptions): Promise<AccessibilityElement | null>;
+export declare function snapshot(
+  options?: SnapshotOptions,
+): Promise<AccessibilitySnapshot>;
+export declare function find(
+  selector: AccessibilitySelector | readonly AccessibilitySelector[],
+  options?: FindOptions,
+): Promise<AccessibilityElement | null>;
 export interface ElementOptions extends CallOptions {
   /** Omitted or 0 tries once; a positive number or Infinity keeps checking until a tap would reach the element, and fails at the limit. */
   readonly timeoutMs?: number;
 }
 
-export declare function tap(element: AccessibilityElement, options?: ElementOptions): Promise<void>;
-export declare function setText(element: AccessibilityElement, text: string, options?: ElementOptions): Promise<void>;
-export declare function perform(element: AccessibilityElement, action: AccessibilityAction | (string & {}), options?: CallOptions): Promise<void>;
+export declare function tap(
+  element: AccessibilityElement,
+  options?: ElementOptions,
+): Promise<void>;
+export declare function setText(
+  element: AccessibilityElement,
+  text: string,
+  options?: ElementOptions,
+): Promise<void>;
+export declare function perform(
+  element: AccessibilityElement,
+  action: AccessibilityAction | (string & {}),
+  options?: CallOptions,
+): Promise<void>;

package/accessibility.mjs

@@ -1,5 +1,7 @@
 const outside = () => {
-  throw new Error("@swipt/api/accessibility runs inside Swipt; build the swiplet with `swipt project build`");
+  throw new Error(
+    "@swipt/api/accessibility runs inside Swipt; build the swiplet with `swipt project build`",
+  );
 };
 
 export const snapshot = outside;

package/device.d.ts

@@ -37,13 +37,35 @@ export declare const locked: ObservableState<boolean>;
 export declare const displayState: ObservableState<DisplayState>;
 export declare function unlock(options?: CallOptions): Promise<void>;
 
-export declare function applicationEvents(options?: CallOptions): AsyncIterable<ApplicationStateEvent>;
-export declare function installedApplications(options?: CallOptions): Promise<InstalledApplication[]>;
-export declare function applicationIcon(bundleId: string, options?: CallOptions): Promise<FileHandle>;
-export declare function launchApplication(bundleId: string, options?: CallOptions & { url?: string; restart?: boolean }): Promise<void>;
+export declare function applicationEvents(
+  options?: CallOptions,
+): AsyncIterable<ApplicationStateEvent>;
+export declare function installedApplications(
+  options?: CallOptions,
+): Promise<InstalledApplication[]>;
+/** Answers a PNG file in cacheDirectory. */
+export declare function applicationIcon(
+  bundleId: string,
+  options?: CallOptions,
+): Promise<FileHandle>;
+export declare function launchApplication(
+  bundleId: string,
+  options?: CallOptions & { url?: string; restart?: boolean },
+): Promise<void>;
 
-export declare function pasteboard(options?: CallOptions): Promise<string | null>;
-export declare function setPasteboard(text: string | null, options?: CallOptions): Promise<void>;
+export declare function pasteboard(
+  options?: CallOptions,
+): Promise<string | null>;
+export declare function setPasteboard(
+  text: string | null,
+  options?: CallOptions,
+): Promise<void>;
 
-export declare function simulateLocation(latitude: number, longitude: number, options?: CallOptions): Promise<void>;
-export declare function clearSimulatedLocation(options?: CallOptions): Promise<void>;
+export declare function simulateLocation(
+  latitude: number,
+  longitude: number,
+  options?: CallOptions,
+): Promise<void>;
+export declare function clearSimulatedLocation(
+  options?: CallOptions,
+): Promise<void>;

package/device.mjs

@@ -1,5 +1,7 @@
 const outside = () => {
-  throw new Error("@swipt/api/device runs inside Swipt; build the swiplet with `swipt project build`");
+  throw new Error(
+    "@swipt/api/device runs inside Swipt; build the swiplet with `swipt project build`",
+  );
 };
 
 export const info = outside;

package/file-system.d.ts

@@ -1,4 +1,9 @@
 export declare const dataDirectory: DirectoryHandle;
+/**
+ * Holds the files Swipt keeps for the Swiplet by default: screen recordings and their exports, and application icons.
+ * The system may delete its contents when storage runs low; clearing the Swiplet's data or deleting the Swiplet removes it.
+ */
+export declare const cacheDirectory: DirectoryHandle;
 export declare const assets: DirectoryHandle;
 
 export interface FileStat {
@@ -23,7 +28,15 @@ export interface FileHandle {
   stat(): Promise<FileStat | null>;
   text(): Promise<string>;
   bytes(): Promise<Uint8Array>;
-  write(data: string | Uint8Array | Blob | ReadableStream<Uint8Array>): Promise<void>;
+  stream(): ReadableStream<Uint8Array>;
+  write(
+    data:
+      | string
+      | ArrayBuffer
+      | ArrayBufferView
+      | Blob
+      | ReadableStream<ArrayBuffer | ArrayBufferView>,
+  ): Promise<void>;
   copy(to: FileHandle): Promise<void>;
   move(to: FileHandle): Promise<void>;
   delete(): Promise<void>;

package/file-system.mjs

@@ -1,2 +1,3 @@
 export const dataDirectory = undefined;
+export const cacheDirectory = undefined;
 export const assets = undefined;

package/image.d.ts

@@ -1,7 +1,8 @@
 import type { CallOptions, Point, Quad, Rect } from "./index";
 import type { FileHandle } from "./file-system";
 
-export type Color = `#${string}` | readonly [red: number, green: number, blue: number];
+export type Color =
+  `#${string}` | readonly [red: number, green: number, blue: number];
 export type ImageFormat = "png" | "jpeg" | "heic";
 
 export interface TemplateMatch {
@@ -58,7 +59,8 @@ export interface RecognizedTextCandidate {
   boundingBox(start: number, end: number): RecognizedTextBox | null;
 }
 
-export interface RecognizedTextLine extends RecognizedTextCandidate, RecognizedTextBox {
+export interface RecognizedTextLine
+  extends RecognizedTextCandidate, RecognizedTextBox {
   readonly candidates: readonly RecognizedTextCandidate[];
 }
 
@@ -85,7 +87,10 @@ export interface RasterImage {
 
   crop(rect: Rect): RasterImage;
   resize(scale: number): RasterImage;
-  resize(size: { readonly width?: number; readonly height?: number }): RasterImage;
+  resize(size: {
+    readonly width?: number;
+    readonly height?: number;
+  }): RasterImage;
   rotate(degrees: number): RasterImage;
   grayscale(): RasterImage;
   threshold(level?: number | "otsu"): RasterImage;
@@ -95,20 +100,59 @@ export interface RasterImage {
   dilate(radius?: number): RasterImage;
   erode(radius?: number): RasterImage;
 
-  encode(format?: ImageFormat, options?: CallOptions & { readonly quality?: number }): Promise<Uint8Array>;
-  save(file: FileHandle | string, options?: CallOptions & { readonly format?: ImageFormat; readonly quality?: number }): Promise<FileHandle>;
-  pixel(point: Point, options?: CallOptions): Promise<[red: number, green: number, blue: number, alpha: number]>;
-  stats(options?: CallOptions & { readonly region?: Rect }): Promise<ImageStats>;
-
-  find(template: RasterImage, options?: TemplateMatchOptions): Promise<TemplateMatch | null>;
-  findAll(template: RasterImage, options?: TemplateMatchOptions & { readonly limit?: number; readonly overlap?: number }): Promise<TemplateMatch[]>;
-  matchColors(checks: readonly ColorCheck[], options?: CallOptions): Promise<boolean[]>;
-  components(options?: CallOptions & { readonly minimumPixels?: number }): Promise<ConnectedComponent[]>;
-  recognizeText(options?: TextRecognitionOptions): Promise<RecognizedTextLine[]>;
-  diff(other: RasterImage, options?: CallOptions & { readonly threshold?: number }): Promise<ImageDifference>;
+  encode(
+    format?: ImageFormat,
+    options?: CallOptions & { readonly quality?: number },
+  ): Promise<Uint8Array>;
+  save(
+    file: FileHandle | string,
+    options?: CallOptions & {
+      readonly format?: ImageFormat;
+      readonly quality?: number;
+    },
+  ): Promise<FileHandle>;
+  pixel(
+    point: Point,
+    options?: CallOptions,
+  ): Promise<[red: number, green: number, blue: number, alpha: number]>;
+  stats(
+    options?: CallOptions & { readonly region?: Rect },
+  ): Promise<ImageStats>;
+
+  find(
+    template: RasterImage,
+    options?: TemplateMatchOptions,
+  ): Promise<TemplateMatch | null>;
+  findAll(
+    template: RasterImage,
+    options?: TemplateMatchOptions & {
+      readonly limit?: number;
+      readonly overlap?: number;
+    },
+  ): Promise<TemplateMatch[]>;
+  matchColors(
+    checks: readonly ColorCheck[],
+    options?: CallOptions,
+  ): Promise<boolean[]>;
+  components(
+    options?: CallOptions & { readonly minimumPixels?: number },
+  ): Promise<ConnectedComponent[]>;
+  recognizeText(
+    options?: TextRecognitionOptions,
+  ): Promise<RecognizedTextLine[]>;
+  diff(
+    other: RasterImage,
+    options?: CallOptions & { readonly threshold?: number },
+  ): Promise<ImageDifference>;
   distance(other: RasterImage, options?: CallOptions): Promise<number>;
-  nearest(candidates: readonly RasterImage[], options?: CallOptions): Promise<{ readonly index: number; readonly distance: number }>;
+  nearest(
+    candidates: readonly RasterImage[],
+    options?: CallOptions,
+  ): Promise<{ readonly index: number; readonly distance: number }>;
   detectBarcodes(options?: CallOptions): Promise<DetectedBarcode[]>;
 }
 
-export declare function decode(data: Uint8Array | FileHandle | string, options?: CallOptions & { readonly scale?: number }): Promise<RasterImage>;
+export declare function decode(
+  data: Uint8Array | FileHandle | string,
+  options?: CallOptions & { readonly scale?: number },
+): Promise<RasterImage>;

package/image.mjs

@@ -1,5 +1,7 @@
 const outside = () => {
-  throw new Error("@swipt/api/image runs inside Swipt; build the swiplet with `swipt project build`");
+  throw new Error(
+    "@swipt/api/image runs inside Swipt; build the swiplet with `swipt project build`",
+  );
 };
 
 export const decode = outside;

package/index.d.ts

@@ -9,18 +9,30 @@ export interface ObservableState<T> {
 
 export type Point = [x: number, y: number];
 export type Rect = [x: number, y: number, width: number, height: number];
-export type Quad = [topLeft: Point, topRight: Point, bottomRight: Point, bottomLeft: Point];
+export type Quad = [
+  topLeft: Point,
+  topRight: Point,
+  bottomRight: Point,
+  bottomLeft: Point,
+];
 
-export type ErrorName = "AbortError" | "TimeoutError" | "NotFoundError" | "UnavailableError";
+export type ErrorName =
+  "AbortError" | "TimeoutError" | "NotFoundError" | "UnavailableError";
 
-export type JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };
+export type JSONValue =
+  string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };
 
-export type Jsonify<T> = T extends string | number | boolean | null ? T
-  : T extends undefined | symbol | ((...args: any[]) => unknown) ? never
-  : T extends { toJSON(): infer J } ? Jsonify<J>
-  : T extends readonly (infer U)[] ? Jsonify<U>[]
-  : T extends object ? { [K in keyof T]: Jsonify<Exclude<T[K], undefined>> }
-  : never;
+export type Jsonify<T> = T extends string | number | boolean | null
+  ? T
+  : T extends undefined | symbol | ((...args: any[]) => unknown)
+    ? never
+    : T extends { toJSON(): infer J }
+      ? Jsonify<J>
+      : T extends readonly (infer U)[]
+        ? Jsonify<U>[]
+        : T extends object
+          ? { [K in keyof T]: Jsonify<Exclude<T[K], undefined>> }
+          : never;
 
 declare global {
   function sleep(ms: number, options?: CallOptions): Promise<void>;

package/input.d.ts

@@ -4,18 +4,51 @@ export interface TapOptions extends CallOptions {
   readonly count?: number;
 }
 
-export type KeyboardKey = "return" | "backspace" | "forwardDelete" | "tab" | "escape" | "space" | "left" | "right" | "up" | "down"
-  | "home" | "end" | "pageUp" | "pageDown" | `f${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12}`;
+export type KeyboardKey =
+  | "return"
+  | "backspace"
+  | "forwardDelete"
+  | "tab"
+  | "escape"
+  | "space"
+  | "left"
+  | "right"
+  | "up"
+  | "down"
+  | "home"
+  | "end"
+  | "pageUp"
+  | "pageDown"
+  | `f${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12}`;
 export type KeyboardModifier = "cmd" | "shift" | "ctrl" | "alt";
-export type KeyCombination = KeyboardKey | `${KeyboardModifier}+${KeyboardKey}` | (string & {});
+export type KeyCombination =
+  KeyboardKey | `${KeyboardModifier}+${KeyboardKey}` | (string & {});
 export type TouchSample = [x: number, y: number, ms: number];
 
 export declare function tap(point: Point, options?: TapOptions): Promise<void>;
-export declare function swipe(from: Point, to: Point, options?: CallOptions & { durationMs?: number }): Promise<void>;
-export declare function drag(from: Point, to: Point, options?: CallOptions & { durationMs?: number; pressMs?: number }): Promise<void>;
-export declare function pinch(center: Point, scale: number, options?: CallOptions & { durationMs?: number }): Promise<void>;
-export declare function touch(fingers: readonly (readonly TouchSample[])[], options?: CallOptions): Promise<void>;
-export declare function pressKey(combination: KeyCombination, options?: CallOptions): Promise<void>;
+export declare function swipe(
+  from: Point,
+  to: Point,
+  options?: CallOptions & { durationMs?: number },
+): Promise<void>;
+export declare function drag(
+  from: Point,
+  to: Point,
+  options?: CallOptions & { durationMs?: number; pressMs?: number },
+): Promise<void>;
+export declare function pinch(
+  center: Point,
+  scale: number,
+  options?: CallOptions & { durationMs?: number },
+): Promise<void>;
+export declare function touch(
+  fingers: readonly (readonly TouchSample[])[],
+  options?: CallOptions,
+): Promise<void>;
+export declare function pressKey(
+  combination: KeyCombination,
+  options?: CallOptions,
+): Promise<void>;
 export declare function pressHome(options?: CallOptions): Promise<void>;
 export declare function openAppSwitcher(options?: CallOptions): Promise<void>;
 export declare function pressPower(options?: CallOptions): Promise<void>;

package/input.mjs

@@ -1,5 +1,7 @@
 const outside = () => {
-  throw new Error("@swipt/api/input runs inside Swipt; build the swiplet with `swipt project build`");
+  throw new Error(
+    "@swipt/api/input runs inside Swipt; build the swiplet with `swipt project build`",
+  );
 };
 
 export const tap = outside;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swipt/api",
-  "version": "0.1.0-nightly.42",
+  "version": "0.1.0-nightly.44",
   "license": "GPL-3.0-or-later",
   "repository": {
     "type": "git",

package/repl.d.ts

@@ -2,8 +2,10 @@ declare global {
   const accessibility: typeof import("@swipt/api/accessibility");
   const input: typeof import("@swipt/api/input");
   const device: typeof import("@swipt/api/device");
-  const screen: typeof import("@swipt/api/screen");
+  var screen: Screen;
+  interface Screen extends Readonly<typeof import("@swipt/api/screen")> {}
   const image: typeof import("@swipt/api/image");
+  const dataDirectory: import("@swipt/api/file-system").DirectoryHandle;
   const dialog: import("@swipt/api/swiplet").IntentDialog;
   const args: readonly string[];
 

package/screen.d.ts

@@ -18,11 +18,37 @@ export interface ScreenChange {
 }
 
 export type TimelineEvent =
-  | { readonly time: number; readonly type: "operation"; readonly name: string; readonly arguments?: readonly unknown[]; readonly durationMs?: number; readonly error?: string; readonly message?: string; readonly swiplet?: string }
-  | { readonly time: number; readonly type: "action"; readonly swiplet: string; readonly action: string; readonly caller: "app" | "shortcuts" | "api" }
+  | {
+      readonly time: number;
+      readonly type: "operation";
+      readonly name: string;
+      readonly arguments?: readonly unknown[];
+      readonly durationMs?: number;
+      readonly error?: string;
+      readonly message?: string;
+      readonly swiplet?: string;
+    }
+  | {
+      readonly time: number;
+      readonly type: "action";
+      readonly swiplet: string;
+      readonly action: string;
+      readonly caller: "app" | "shortcuts" | "api";
+    }
   | { readonly time: number; readonly type: "foreground"; readonly app: string }
-  | { readonly time: number; readonly type: "log"; readonly swiplet: string; readonly level: "error" | "warn" | "info" | "debug"; readonly message: string }
-  | { readonly time: number; readonly type: "feed"; readonly frames: number; readonly decodedMs: number };
+  | {
+      readonly time: number;
+      readonly type: "log";
+      readonly swiplet: string;
+      readonly level: "error" | "warn" | "info" | "debug";
+      readonly message: string;
+    }
+  | {
+      readonly time: number;
+      readonly type: "feed";
+      readonly frames: number;
+      readonly decodedMs: number;
+    };
 
 export interface ScreenRecording {
   readonly file: FileHandle;
@@ -35,19 +61,46 @@ export interface ScreenRecording {
   readonly events: readonly TimelineEvent[];
 
   frame(time: number): RasterImage;
-  frames(times: readonly number[] | { readonly everyMs: number; readonly from?: number; readonly to?: number }): RasterImage[];
-  grid(options?: CallOptions & { readonly times?: readonly number[]; readonly columns?: number; readonly width?: number }): Promise<RasterImage>;
-  diff(from: number, to: number, options?: CallOptions & { readonly threshold?: number }): Promise<ImageDifference>;
-  find(target: ScreenTarget | readonly ScreenTarget[], options?: Omit<ScreenFindOptions, "timeoutMs"> & { readonly from?: number; readonly to?: number }): Promise<(ScreenMatch & { readonly time: number }) | null>;
-  export(options?: CallOptions & {
-    readonly file?: FileHandle | string;
-    readonly from?: number;
-    readonly to?: number;
-    readonly region?: Rect;
-    readonly scale?: number;
-    readonly format?: "mov" | "mp4" | "gif";
-    readonly frameRate?: number;
-  }): Promise<FileHandle>;
+  frames(
+    times:
+      | readonly number[]
+      | {
+          readonly everyMs: number;
+          readonly from?: number;
+          readonly to?: number;
+        },
+  ): RasterImage[];
+  grid(
+    options?: CallOptions & {
+      readonly times?: readonly number[];
+      readonly columns?: number;
+      readonly width?: number;
+    },
+  ): Promise<RasterImage>;
+  diff(
+    from: number,
+    to: number,
+    options?: CallOptions & { readonly threshold?: number },
+  ): Promise<ImageDifference>;
+  find(
+    target: ScreenTarget | readonly ScreenTarget[],
+    options?: Omit<ScreenFindOptions, "timeoutMs"> & {
+      readonly from?: number;
+      readonly to?: number;
+    },
+  ): Promise<(ScreenMatch & { readonly time: number }) | null>;
+  export(
+    options?: CallOptions & {
+      /** Omitted, the export goes to a new file in cacheDirectory. */
+      readonly file?: FileHandle | string;
+      readonly from?: number;
+      readonly to?: number;
+      readonly region?: Rect;
+      readonly scale?: number;
+      readonly format?: "mov" | "mp4" | "gif";
+      readonly frameRate?: number;
+    },
+  ): Promise<FileHandle>;
 }
 
 export interface RecordingSession {
@@ -80,10 +133,28 @@ export interface ScreenMatch {
 }
 
 export declare function screenshot(options?: CallOptions): Promise<RasterImage>;
-export declare function find(target: ScreenTarget | readonly ScreenTarget[], options?: ScreenFindOptions): Promise<ScreenMatch | null>;
+export declare function find(
+  target: ScreenTarget | readonly ScreenTarget[],
+  options?: ScreenFindOptions,
+): Promise<ScreenMatch | null>;
 export declare const frames: ObservableState<RasterImage>;
-export declare function waitFor(predicate: (frame: RasterImage) => boolean | Promise<boolean>, options?: CallOptions & { readonly timeoutMs?: number }): Promise<RasterImage>;
-export declare function waitForChange(options?: WaitOptions & { readonly from?: RasterImage }): Promise<RasterImage>;
-export declare function waitForStable(options?: WaitOptions & { readonly durationMs?: number }): Promise<RasterImage>;
-export declare function record(options?: CallOptions & { readonly file?: FileHandle | string }): Promise<RecordingSession>;
-export declare function openRecording(file: FileHandle | string, options?: CallOptions): Promise<ScreenRecording>;
+export declare function waitFor(
+  predicate: (frame: RasterImage) => boolean | Promise<boolean>,
+  options?: CallOptions & { readonly timeoutMs?: number },
+): Promise<RasterImage>;
+export declare function waitForChange(
+  options?: WaitOptions & { readonly from?: RasterImage },
+): Promise<RasterImage>;
+export declare function waitForStable(
+  options?: WaitOptions & { readonly durationMs?: number },
+): Promise<RasterImage>;
+export declare function record(
+  options?: CallOptions & {
+    /** Omitted, the recording goes to a new file in cacheDirectory. */
+    readonly file?: FileHandle | string;
+  },
+): Promise<RecordingSession>;
+export declare function openRecording(
+  file: FileHandle | string,
+  options?: CallOptions,
+): Promise<ScreenRecording>;

package/screen.mjs

@@ -1,5 +1,7 @@
 const outside = () => {
-  throw new Error("@swipt/api/screen runs inside Swipt; build the swiplet with `swipt project build`");
+  throw new Error(
+    "@swipt/api/screen runs inside Swipt; build the swiplet with `swipt project build`",
+  );
 };
 
 export const screenshot = outside;

package/swiplet.d.ts

@@ -1,12 +1,46 @@
-import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+import type {
+  StandardJSONSchemaV1,
+  StandardSchemaV1,
+} from "@standard-schema/spec";
 
 import type { CallOptions, Jsonify } from "./index";
 
 export type IntentChoiceStyle = "default" | "destructive" | "cancel";
 
-export type ConfirmationActionName = "add" | "addData" | "book" | "buy" | "call" | "checkIn" | "continue" | "create" | "do" | "download"
-  | "filter" | "find" | "get" | "go" | "log" | "open" | "order" | "pay" | "play" | "playSound" | "post" | "request" | "run"
-  | "search" | "send" | "set" | "share" | "start" | "startNavigation" | "toggle" | "turnOff" | "turnOn" | "view";
+export type ConfirmationActionName =
+  | "add"
+  | "addData"
+  | "book"
+  | "buy"
+  | "call"
+  | "checkIn"
+  | "continue"
+  | "create"
+  | "do"
+  | "download"
+  | "filter"
+  | "find"
+  | "get"
+  | "go"
+  | "log"
+  | "open"
+  | "order"
+  | "pay"
+  | "play"
+  | "playSound"
+  | "post"
+  | "request"
+  | "run"
+  | "search"
+  | "send"
+  | "set"
+  | "share"
+  | "start"
+  | "startNavigation"
+  | "toggle"
+  | "turnOff"
+  | "turnOn"
+  | "view";
 
 export interface Person {
   readonly name: string;
@@ -20,23 +54,79 @@ export interface Placemark {
 }
 
 export interface IntentDialog {
-  requestChoice<T extends string | { title: string; style?: IntentChoiceStyle }>(choices: T[], prompt: string, options?: CallOptions): Promise<T>;
-  requestConfirmation(prompt: string, options?: CallOptions & { actionName?: ConfirmationActionName | { accept: string; deny: string; destructive?: boolean } }): Promise<void>;
-  requestValue(type: "text", prompt?: string, options?: CallOptions & { multiline?: boolean; literal?: boolean }): Promise<string>;
-  requestValue(type: "integer", prompt?: string, options?: CallOptions & { stepper?: boolean; min?: number; max?: number }): Promise<number>;
-  requestValue(type: "number", prompt?: string, options?: CallOptions & { min?: number; max?: number }): Promise<number>;
-  requestValue(type: "date" | "time" | "dateTime", prompt?: string, options?: CallOptions): Promise<Date>;
-  requestValue(type: "file", prompt?: string, options?: CallOptions): Promise<{ name: string; type: string; bytes: Uint8Array }>;
-  requestValue(type: "person", prompt?: string, options?: CallOptions): Promise<Person>;
-  requestValue(type: "placemark", prompt?: string, options?: CallOptions): Promise<Placemark>;
-  requestDisambiguation(values: string[], prompt: string, options?: CallOptions): Promise<string>;
-  requestValueConfirmation(value: string, prompt: string, options?: CallOptions): Promise<boolean>;
-  continueInForeground(prompt?: string, options?: CallOptions & { alwaysConfirm?: boolean }): Promise<void>;
+  requestChoice<
+    T extends string | { title: string; style?: IntentChoiceStyle },
+  >(
+    choices: T[],
+    prompt: string,
+    options?: CallOptions,
+  ): Promise<T>;
+  requestConfirmation(
+    prompt: string,
+    options?: CallOptions & {
+      actionName?:
+        | ConfirmationActionName
+        | { accept: string; deny: string; destructive?: boolean };
+    },
+  ): Promise<void>;
+  requestValue(
+    type: "text",
+    prompt?: string,
+    options?: CallOptions & { multiline?: boolean; literal?: boolean },
+  ): Promise<string>;
+  requestValue(
+    type: "integer",
+    prompt?: string,
+    options?: CallOptions & { stepper?: boolean; min?: number; max?: number },
+  ): Promise<number>;
+  requestValue(
+    type: "number",
+    prompt?: string,
+    options?: CallOptions & { min?: number; max?: number },
+  ): Promise<number>;
+  requestValue(
+    type: "date" | "time" | "dateTime",
+    prompt?: string,
+    options?: CallOptions,
+  ): Promise<Date>;
+  requestValue(
+    type: "file",
+    prompt?: string,
+    options?: CallOptions,
+  ): Promise<{ name: string; type: string; bytes: Uint8Array }>;
+  requestValue(
+    type: "person",
+    prompt?: string,
+    options?: CallOptions,
+  ): Promise<Person>;
+  requestValue(
+    type: "placemark",
+    prompt?: string,
+    options?: CallOptions,
+  ): Promise<Placemark>;
+  requestDisambiguation(
+    values: string[],
+    prompt: string,
+    options?: CallOptions,
+  ): Promise<string>;
+  requestValueConfirmation(
+    value: string,
+    prompt: string,
+    options?: CallOptions,
+  ): Promise<boolean>;
+  continueInForeground(
+    prompt?: string,
+    options?: CallOptions & { alwaysConfirm?: boolean },
+  ): Promise<void>;
 }
 
 export type ActionCaller = "app" | "shortcuts" | "api";
 
-export type Schema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
+export type Schema<Input = unknown, Output = Input> = StandardSchemaV1<
+  Input,
+  Output
+> &
+  StandardJSONSchemaV1<Input, Output>;
 
 declare const types: unique symbol;
 
@@ -47,7 +137,10 @@ export interface Action<Input = void, Output = void> {
   readonly expose: readonly "shortcuts"[];
 }
 
-export interface Extension<Actions extends Record<string, Action<any, any>> = {}, HasRun extends boolean = boolean> {
+export interface Extension<
+  Actions extends Record<string, Action<any, any>> = {},
+  HasRun extends boolean = boolean,
+> {
   readonly [types]: { hasRun: HasRun };
   readonly actions: Actions;
 }
@@ -66,32 +159,47 @@ type Sent<S> = S extends Schema ? StandardSchemaV1.InferInput<S> : void;
 type Returned<S, R> = S extends Schema ? StandardSchemaV1.InferInput<S> : R;
 type Delivered<S, R> = S extends Schema ? StandardSchemaV1.InferOutput<S> : R;
 
-export declare function defineAction<I extends Schema | undefined = undefined, O extends Schema | undefined = undefined, R = void>(definition: {
+export declare function defineAction<
+  I extends Schema | undefined = undefined,
+  O extends Schema | undefined = undefined,
+  R = void,
+>(definition: {
   readonly title: string;
   readonly description?: string;
   readonly input?: I;
   readonly output?: O;
   readonly expose?: readonly "shortcuts"[];
-  run(input: Received<I>, context: ActionContext): Returned<O, R> | Promise<Returned<O, R>>;
+  run(
+    input: Received<I>,
+    context: ActionContext,
+  ): Returned<O, R> | Promise<Returned<O, R>>;
 }): Action<Sent<I>, Jsonify<Awaited<Delivered<O, R>>>>;
 
-export declare function defineExtension<Actions extends Record<string, Action<any, any>> = {}>(definition: {
+export declare function defineExtension<
+  Actions extends Record<string, Action<any, any>> = {},
+>(definition: {
   run(context: RunContext): Promise<void>;
   readonly actions?: Actions;
 }): Extension<Actions, true>;
-export declare function defineExtension<Actions extends Record<string, Action<any, any>> = {}>(definition: {
-  readonly actions?: Actions;
-}): Extension<Actions, false>;
+export declare function defineExtension<
+  Actions extends Record<string, Action<any, any>> = {},
+>(definition: { readonly actions?: Actions }): Extension<Actions, false>;
 
 export type ServiceStatus = "starting" | "running" | "stopped" | "failed";
 
-type ActionCall<A> = A extends Action<infer Input, infer Output>
-  ? [Input] extends [void]
-    ? (input?: undefined, options?: { signal?: AbortSignal }) => Promise<Output>
-    : (input: Input, options?: { signal?: AbortSignal }) => Promise<Output>
-  : never;
+type ActionCall<A> =
+  A extends Action<infer Input, infer Output>
+    ? [Input] extends [void]
+      ? (
+          input?: undefined,
+          options?: { signal?: AbortSignal },
+        ) => Promise<Output>
+      : (input: Input, options?: { signal?: AbortSignal }) => Promise<Output>
+    : never;
 
-export type ActionCalls<E extends Extension<any, any>> = { readonly [K in keyof E["actions"]]: ActionCall<E["actions"][K]> };
+export type ActionCalls<E extends Extension<any, any>> = {
+  readonly [K in keyof E["actions"]]: ActionCall<E["actions"][K]>;
+};
 
 export interface ServiceHandle {
   readonly enabled: boolean;
@@ -101,10 +209,18 @@ export interface ServiceHandle {
   setEnabled(enabled: boolean): Promise<void>;
 }
 
-export declare function actions<E extends Extension<any, any>>(): ActionCalls<E>;
+export declare function actions<
+  E extends Extension<any, any>,
+>(): ActionCalls<E>;
 
-export declare function useService<E extends Extension<any, true>>(): ServiceHandle;
+export declare function useService<
+  E extends Extension<any, true>,
+>(): ServiceHandle;
 
 export declare function exit(): void;
 
-export declare function preferredLocalizations(localizations: readonly string[]): string[];
+export declare function preferredLocalizations(
+  localizations: readonly string[],
+): string[];
+
+export {};

package/swiplet.mjs

@@ -1,5 +1,7 @@
 const outside = () => {
-  throw new Error("@swipt/api/swiplet runs inside Swipt; build the swiplet with `swipt project build`");
+  throw new Error(
+    "@swipt/api/swiplet runs inside Swipt; build the swiplet with `swipt project build`",
+  );
 };
 
 export const defineExtension = outside;