@dopame/acde-linux-x64 0.0.0-stage → 0.0.10

package/lib/acde/dist/types/driver/expect.d.ts

@@ -0,0 +1,60 @@
+import type { Acde } from './acde.ts';
+import { Locator, type TextMatch, type Timeout } from './locator.ts';
+import { type Image } from './png.ts';
+import { type Capturable } from './screenshot.ts';
+import type { AppWindow } from './window.ts';
+export interface ScreenshotAssertion extends Timeout {
+    readonly maxDiffPixels?: number;
+    readonly maxDiffPixelRatio?: number;
+    readonly threshold?: number;
+    readonly mask?: readonly Capturable[];
+}
+interface Check {
+    readonly pass: boolean | null;
+    readonly saw: string;
+}
+export declare class AssertionError extends Error {
+    constructor(message: string);
+}
+export declare class LocatorAssertions {
+    #private;
+    constructor(locator: Locator, negated?: boolean);
+    get not(): LocatorAssertions;
+    toBeVisible(options?: Timeout): Promise<void>;
+    toBeHidden(options?: Timeout): Promise<void>;
+    toHaveCount(count: number, options?: Timeout): Promise<void>;
+    toHaveText(expected: TextMatch, options?: Timeout & {
+        readonly exact?: boolean;
+    }): Promise<void>;
+    toContainText(expected: TextMatch, options?: Timeout): Promise<void>;
+    toHaveValue(expected: TextMatch, options?: Timeout): Promise<void>;
+    toHaveState(state: string, options?: Timeout): Promise<void>;
+    toBeChecked(options?: Timeout): Promise<void>;
+    toBeDisabled(options?: Timeout): Promise<void>;
+    toBeEnabled(options?: Timeout): Promise<void>;
+    toBeFocused(options?: Timeout): Promise<void>;
+    toHaveAttribute(name: string, expected?: TextMatch, options?: Timeout): Promise<void>;
+    toHaveClass(expected: TextMatch, options?: Timeout): Promise<void>;
+    toHaveCSS(name: string, expected: TextMatch, options?: Timeout): Promise<void>;
+    toHaveJSProperty(name: string, expected: unknown, options?: Timeout): Promise<void>;
+    toBeEmpty(options?: Timeout): Promise<void>;
+    toBeEditable(options?: Timeout): Promise<void>;
+    toBeInViewport(options?: Timeout & {
+        readonly ratio?: number;
+    }): Promise<void>;
+    toHaveScreenshot(name?: string | ScreenshotAssertion, options?: ScreenshotAssertion): Promise<void>;
+    static screenshot(acde: Acde, target: string, name: string | undefined, options: ScreenshotAssertion, take: () => Promise<Image>): Promise<void>;
+    static poll(what: string, timeout: number, negated: boolean, attempt: () => Promise<Check>): Promise<void>;
+}
+export declare class WindowAssertions {
+    #private;
+    constructor(window: AppWindow, negated?: boolean);
+    get not(): WindowAssertions;
+    toBeOpen(options?: Timeout): Promise<void>;
+    toHaveTitle(expected: TextMatch, options?: Timeout): Promise<void>;
+    toHaveScreenshot(name?: string | ScreenshotAssertion, options?: ScreenshotAssertion): Promise<void>;
+}
+export declare function expect(target: Locator): LocatorAssertions;
+export declare function expect(target: AppWindow): WindowAssertions;
+export declare function expect(target: Locator | AppWindow): LocatorAssertions | WindowAssertions;
+export {};

package/lib/acde/dist/types/driver/format.d.ts

@@ -0,0 +1,16 @@
+import type { InspectNode } from '@dopame/acde-api';
+import type { PermissionDecision, PermissionPrompt } from './acde.ts';
+import type { ConsoleEntry, Permissions, QueryResult, RequestEntry, Snapshot, Web } from './acde.ts';
+export declare class Format {
+    static console(e: ConsoleEntry): string;
+    static request(e: RequestEntry): string;
+    static matches(found: QueryResult, selector: string): string;
+    static prompt(prompt: PermissionPrompt): string;
+    static decision(decision: PermissionDecision): string;
+    static permissions(permissions: Permissions): string;
+    static answered(prompt: PermissionPrompt, allow: boolean): string;
+    static waiting(prompt: PermissionPrompt, how: string): string;
+    static webs(webs: readonly Web[]): string;
+    static node(n: InspectNode): string;
+    static found(snapshot: Snapshot, text: string): string[];
+}

package/lib/acde/dist/types/driver/index.d.ts

@@ -0,0 +1,13 @@
+export { ACTIONS, Acde, ActError, type ActResult, type AttachOptions, type ConsoleEntry, type ConsoleLevel, type ConsoleOptions, type DevPage, type Dialog, type DialogAnswer, type DialogType, type DropOptions, type Dropped, type Emulation, LaunchError, type LaunchOptions, type LaunchPhase, type NetworkOptions, type PermissionDecision, type PermissionPrompt, type Permissions, type PromptMatch, type QueryOptions, type QueryResult, type RequestEntry, type RouteOptions, type RouteResponse, type Shot, type Snapshot, type SnapshotOptions, type Step, type UrlMatch, type WaitConsoleOptions, type WaitRequestOptions, type Web, } from './acde.ts';
+export { Clock, type ClockDuration, type ClockState, type ClockTime } from './clock.ts';
+export { Format } from './format.ts';
+export { Keyboard, Modifiers, Mouse, type InputEvent, type Modifier, type MouseButton } from './input.ts';
+export { AssertionError, expect, LocatorAssertions, WindowAssertions, type ScreenshotAssertion } from './expect.ts';
+export { Locator, type FilterOptions, type Query, type RoleOptions, type Source, type TextMatch, type TextOptions, type Timeout } from './locator.ts';
+export { Logs, type LogLine, type LogSlice } from './logs.ts';
+export { Png, type Diff, type DiffOptions, type Image } from './png.ts';
+export { Screenshots, type Capturable, type Capture, type ScreenshotContext, type ScreenshotOptions } from './screenshot.ts';
+export { Trace, type TraceStep } from './trace.ts';
+export { Video } from './video.ts';
+export { AppWindow, type WindowMatch } from './window.ts';
+export type { InspectAction, InspectArg, InspectMatch, InspectNode, InspectWindow } from '@dopame/acde-api';

package/lib/acde/dist/types/driver/input.d.ts

@@ -0,0 +1,75 @@
+import { type Acde, type ActResult } from './acde.ts';
+export type Modifier = 'Shift' | 'Control' | 'Alt' | 'Meta' | 'ControlOrMeta';
+export type MouseButton = 'left' | 'right' | 'middle';
+export type InputEvent = {
+    readonly type: 'move';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly type: 'down' | 'up';
+    readonly x: number;
+    readonly y: number;
+    readonly button?: MouseButton;
+} | {
+    readonly type: 'wheel';
+    readonly x: number;
+    readonly y: number;
+    readonly dx?: number;
+    readonly dy?: number;
+} | {
+    readonly type: 'keydown' | 'keyup';
+    readonly key: string;
+} | {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'wait';
+    readonly ms: number;
+};
+export interface InputTarget {
+    readonly acde: Acde;
+    describe(): string;
+    web(): Promise<string>;
+}
+export declare const Modifiers: {
+    chord(modifiers: readonly Modifier[] | undefined): string | null;
+};
+interface ClickOptions {
+    readonly button?: MouseButton;
+    readonly clickCount?: number;
+    readonly modifiers?: readonly Modifier[];
+}
+export declare class Mouse {
+    #private;
+    constructor(target: InputTarget);
+    get position(): {
+        readonly x: number;
+        readonly y: number;
+    };
+    move(x: number, y: number, options?: {
+        readonly steps?: number;
+    }): Promise<ActResult>;
+    down(options?: {
+        readonly button?: MouseButton;
+    }): Promise<ActResult>;
+    up(options?: {
+        readonly button?: MouseButton;
+    }): Promise<ActResult>;
+    click(x: number, y: number, options?: ClickOptions): Promise<ActResult>;
+    dblclick(x: number, y: number, options?: {
+        readonly button?: MouseButton;
+        readonly modifiers?: readonly Modifier[];
+    }): Promise<ActResult>;
+    wheel(deltaX: number, deltaY: number): Promise<ActResult>;
+}
+export declare class Keyboard {
+    #private;
+    constructor(target: InputTarget);
+    static keys(modifiers: readonly Modifier[] | undefined): string[];
+    down(key: string): Promise<ActResult>;
+    up(key: string): Promise<ActResult>;
+    press(keys: string): Promise<ActResult>;
+    type(text: string): Promise<ActResult>;
+    insertText(text: string): Promise<ActResult>;
+}
+export {};

package/lib/acde/dist/types/driver/locator.d.ts

@@ -0,0 +1,151 @@
+import type { InspectMatch, InspectNode, InspectWindow } from '@dopame/acde-api';
+import { type Acde, type ActResult, type Shot } from './acde.ts';
+import { type Modifier } from './input.ts';
+import { type Capture, type ScreenshotOptions } from './screenshot.ts';
+export type TextMatch = string | RegExp;
+export interface RoleOptions {
+    readonly name?: TextMatch;
+    readonly exact?: boolean;
+    readonly checked?: boolean;
+    readonly disabled?: boolean;
+    readonly selected?: boolean;
+    readonly expanded?: boolean;
+    readonly pressed?: boolean;
+    readonly focused?: boolean;
+    readonly level?: number;
+}
+export interface TextOptions {
+    readonly exact?: boolean;
+}
+export interface FilterOptions {
+    readonly hasText?: TextMatch;
+    readonly hasNotText?: TextMatch;
+    readonly has?: Locator;
+    readonly hasNot?: Locator;
+}
+export interface Timeout {
+    readonly timeout?: number;
+}
+export interface Source {
+    readonly nodes: readonly InspectNode[];
+    children(node: InspectNode): Promise<readonly InspectNode[]>;
+    query(selector: string, within: InspectNode | null, attributes?: readonly string[]): Promise<readonly InspectMatch[]>;
+}
+export interface Tree {
+    readonly window: InspectWindow | null;
+    readonly source: Source;
+}
+export interface Scope {
+    readonly acde: Acde;
+    tree(): Promise<Tree>;
+    capture(): Promise<Capture>;
+    describe(): string;
+}
+export type Query = {
+    readonly kind: 'role';
+    readonly role: string;
+    readonly options: RoleOptions;
+} | {
+    readonly kind: 'text';
+    readonly text: TextMatch;
+    readonly options: TextOptions;
+} | {
+    readonly kind: 'css';
+    readonly selector: string;
+} | {
+    readonly kind: 'label';
+    readonly text: TextMatch;
+    readonly options: TextOptions;
+} | {
+    readonly kind: 'attr';
+    readonly name: 'placeholder' | 'title' | 'alt';
+    readonly text: TextMatch;
+    readonly options: TextOptions;
+} | {
+    readonly kind: 'filter';
+    readonly options: FilterOptions;
+} | {
+    readonly kind: 'nth';
+    readonly index: number;
+} | {
+    readonly kind: 'or';
+    readonly alternatives: readonly (readonly Query[])[];
+} | {
+    readonly kind: 'and';
+    readonly queries: readonly Query[];
+};
+export interface Resolved {
+    readonly window: InspectWindow | null;
+    readonly nodes: readonly InspectNode[];
+    readonly source: Source;
+}
+export declare class Locator {
+    #private;
+    readonly scope: Scope;
+    constructor(scope: Scope, queries: readonly Query[]);
+    getByRole(role: string, options?: RoleOptions): Locator;
+    getByText(text: TextMatch, options?: TextOptions): Locator;
+    locator(selector: string): Locator;
+    getByTestId(id: string): Locator;
+    getByLabel(text: TextMatch, options?: TextOptions): Locator;
+    getByPlaceholder(text: TextMatch, options?: TextOptions): Locator;
+    getByTitle(text: TextMatch, options?: TextOptions): Locator;
+    getByAltText(text: TextMatch, options?: TextOptions): Locator;
+    filter(options: FilterOptions): Locator;
+    or(other: Locator): Locator;
+    and(other: Locator): Locator;
+    get queries(): readonly Query[];
+    nth(index: number): Locator;
+    first(): Locator;
+    last(): Locator;
+    describe(): string;
+    toString(): string;
+    resolve(): Promise<Resolved>;
+    text(options?: Timeout): Promise<string>;
+    textContent(options?: Timeout): Promise<string>;
+    static content(source: Source, node: InspectNode): Promise<string>;
+    static text(source: Source, node: InspectNode): Promise<string>;
+    count(): Promise<number>;
+    isVisible(): Promise<boolean>;
+    static visible(node: InspectNode): boolean;
+    all(): Promise<Locator[]>;
+    node(options?: Timeout): Promise<InspectNode>;
+    ref(options?: Timeout): Promise<string>;
+    name(options?: Timeout): Promise<string>;
+    value(options?: Timeout): Promise<string | null>;
+    states(options?: Timeout): Promise<readonly string[]>;
+    waitFor(options?: Timeout & {
+        readonly state?: 'visible' | 'hidden';
+    }): Promise<void>;
+    click(options?: Timeout & {
+        readonly button?: 'left' | 'right';
+        readonly clickCount?: 1 | 2;
+        readonly modifiers?: readonly Modifier[];
+    }): Promise<ActResult>;
+    dblclick(options?: Timeout & {
+        readonly modifiers?: readonly Modifier[];
+    }): Promise<ActResult>;
+    hover(options?: Timeout & {
+        readonly modifiers?: readonly Modifier[];
+    }): Promise<ActResult>;
+    fill(text: string, options?: Timeout): Promise<ActResult>;
+    clear(options?: Timeout): Promise<ActResult>;
+    type(text: string, options?: Timeout): Promise<ActResult>;
+    press(keys: string, options?: Timeout): Promise<ActResult>;
+    focus(options?: Timeout): Promise<ActResult>;
+    scroll(dy?: number, options?: Timeout): Promise<ActResult>;
+    selectOption(values: string | readonly string[], options?: Timeout): Promise<ActResult>;
+    check(options?: Timeout): Promise<void>;
+    uncheck(options?: Timeout): Promise<void>;
+    setChecked(checked: boolean, options?: Timeout): Promise<void>;
+    dragTo(target: Locator, options?: Timeout): Promise<ActResult>;
+    screenshot(options?: ScreenshotOptions & Timeout): Promise<Shot>;
+    capture(): Promise<Capture>;
+    rects(): Promise<readonly (readonly [number, number, number, number])[]>;
+    static match(source: Source, queries: readonly Query[]): Promise<InspectNode[]>;
+    evaluate<T = unknown, A = unknown>(fn: string | ((element: any, arg: A) => T | Promise<T>), arg?: A, options?: Timeout): Promise<Awaited<T>>;
+    static testId(id: string): string;
+    static normalize(text: string): string;
+    static matches(actual: string | undefined, expected: TextMatch, exact?: boolean): boolean;
+    static line(node: InspectNode, hidden?: boolean): string;
+}

package/lib/acde/dist/types/driver/logs.d.ts

@@ -0,0 +1,26 @@
+export interface LogLine {
+    readonly seq: number;
+    readonly stream: 'stdout' | 'stderr';
+    readonly text: string;
+}
+export interface LogSlice {
+    readonly lines: readonly LogLine[];
+    readonly text: string;
+    readonly next: number;
+    readonly dropped: number;
+}
+export declare class Logs {
+    #private;
+    static readonly KEEP = 5000;
+    follow(stream: AsyncIterable<Uint8Array | string>, name: LogLine['stream']): void;
+    drained(ms: number): Promise<boolean>;
+    push(stream: LogLine['stream'], text: string): void;
+    get next(): number;
+    since(seq: number, options?: {
+        readonly grep?: RegExp;
+        readonly limit?: number;
+    }): LogSlice;
+    tail(count: number, options?: {
+        readonly grep?: RegExp;
+    }): LogSlice;
+}

package/lib/acde/dist/types/driver/png.d.ts

@@ -0,0 +1,31 @@
+export interface Image {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+}
+export interface DiffOptions {
+    readonly threshold?: number;
+    readonly antialiasing?: boolean;
+}
+export interface Diff {
+    readonly pixels: number;
+    readonly image: Image;
+}
+export declare class Png {
+    #private;
+    static readonly DIFF_THRESHOLD = 0.2;
+    static decode(png: Uint8Array): Image;
+    static encode(image: Image): Buffer;
+    static crop(image: Image, x: number, y: number, width: number, height: number): Image;
+    static fill(image: Image, x: number, y: number, width: number, height: number, rgba: readonly [number, number, number, number]): Image;
+    static same(a: Image, b: Image): boolean;
+    static diff(actual: Image, expected: Image, options?: DiffOptions): Diff;
+    static chunks(png: Uint8Array): {
+        type: string;
+        data: Buffer;
+    }[];
+    static animate(frames: readonly {
+        readonly png: Uint8Array;
+        readonly ms: number;
+    }[]): Buffer;
+}

package/lib/acde/dist/types/driver/poll.d.ts

@@ -0,0 +1,4 @@
+export declare class Poll {
+    static readonly INTERVAL_MS = 100;
+    static until<T>(timeout: number, attempt: () => T | null | undefined | Promise<T | null | undefined>, fail: () => Error | string | Promise<Error | string>): Promise<T>;
+}

package/lib/acde/dist/types/driver/screenshot.d.ts

@@ -0,0 +1,37 @@
+import type { InspectNode, InspectWindow } from '@dopame/acde-api';
+import { type Image } from './png.ts';
+export interface Capture {
+    readonly image: Image;
+    readonly window: InspectWindow;
+    readonly scale: number;
+}
+export interface Capturable {
+    capture(): Promise<Capture>;
+    rects(): Promise<readonly (readonly [number, number, number, number])[]>;
+    describe(): string;
+}
+export interface ScreenshotOptions {
+    readonly path?: string;
+    readonly mask?: readonly Capturable[];
+}
+export interface ScreenshotContext {
+    readonly dir: string;
+    readonly results: string | null;
+    readonly update: boolean;
+    readonly ci: boolean;
+    readonly test: string;
+}
+export declare class Screenshots {
+    #private;
+    static readonly MASK: readonly [number, number, number, number];
+    static context: ScreenshotContext | null;
+    static window(capture: Capture, mask?: readonly Capturable[]): Promise<Image>;
+    static element(capture: Capture, node: InspectNode, mask?: readonly Capturable[]): Promise<Image>;
+    static save(image: Image, path: string | undefined): Buffer;
+    static baseline(name: string | undefined): {
+        path: string;
+        label: string;
+    };
+    static read(path: string): Image | null;
+    static slug(text: string): string;
+}

package/lib/acde/dist/types/driver/trace.d.ts

@@ -0,0 +1,26 @@
+export interface TraceStep {
+    readonly index: number;
+    readonly title: string;
+    readonly at: number;
+    readonly ms: number;
+    readonly ok: boolean;
+    readonly text: string;
+    readonly screen: string | null;
+}
+export interface TraceShooter {
+    readonly closed: boolean;
+    screen(): Promise<{
+        readonly png: Buffer;
+    }>;
+}
+export declare class Trace {
+    #private;
+    static readonly TEXT_MAX = 4000;
+    screenshots: boolean;
+    constructor(shooter: TraceShooter);
+    get steps(): readonly TraceStep[];
+    step<T>(title: string, run: () => Promise<T>, said?: (value: T) => string): Promise<T>;
+    text(): string;
+    write(dir: string, title: string): string[];
+    static html(title: string, steps: readonly TraceStep[], started: number): string;
+}

package/lib/acde/dist/types/driver/types.d.ts

@@ -0,0 +1,213 @@
+import type { InspectAction, InspectArg, InspectMatch, InspectNode, InspectWindow } from '@dopame/acde-api';
+import type { Logs } from './logs.ts';
+export interface Web {
+    readonly name: string;
+    readonly app: string | null;
+    readonly kind: string;
+    readonly window: number;
+    readonly title: string | null;
+}
+export interface Shot {
+    readonly png: Buffer;
+    readonly width: number;
+    readonly height: number;
+    readonly path: string | null;
+}
+export interface SnapshotOptions {
+    readonly window?: string;
+    readonly ref?: string;
+    readonly all?: boolean;
+    readonly diff?: boolean;
+    readonly limit?: number;
+    readonly find?: string;
+    readonly tree?: boolean;
+    readonly offscreen?: boolean;
+}
+export interface QueryOptions {
+    readonly selector: string;
+    readonly window?: string;
+    readonly ref?: string;
+    readonly limit?: number;
+    readonly attributes?: readonly string[];
+}
+export interface QueryResult {
+    readonly window: string;
+    readonly count: number;
+    readonly nodes: readonly InspectMatch[];
+}
+export type ConsoleLevel = 'log' | 'info' | 'warn' | 'error' | 'debug';
+export interface ConsoleEntry {
+    readonly seq: number;
+    readonly time: number;
+    readonly web: string;
+    readonly app: string | null;
+    readonly kind: 'console' | 'error' | 'rejection' | 'dialog';
+    readonly level: ConsoleLevel;
+    readonly text: string;
+    readonly dialog?: Dialog;
+}
+export type DialogType = 'alert' | 'confirm' | 'prompt';
+export interface Dialog {
+    readonly type: DialogType;
+    readonly message: string;
+    readonly defaultValue: string | null;
+    readonly answered: boolean;
+    readonly accept: boolean;
+    readonly text: string | null;
+}
+export interface DialogAnswer {
+    readonly accept?: boolean;
+    readonly text?: string;
+}
+export interface RequestEntry {
+    readonly seq: number;
+    readonly time: number;
+    readonly web: string;
+    readonly app: string | null;
+    readonly id: number;
+    readonly kind: 'fetch' | 'xhr' | 'websocket' | 'eventsource' | 'image' | 'stylesheet' | 'font';
+    readonly method: string;
+    readonly url: string;
+    readonly requestBytes: number;
+    readonly status: number | null;
+    readonly statusText: string | null;
+    readonly responseBytes: number | null;
+    readonly ms: number | null;
+    readonly error: string | null;
+    readonly done: boolean;
+    readonly mocked?: true;
+}
+export interface DevPage<T> {
+    readonly entries: readonly T[];
+    readonly next: number;
+    readonly dropped: number;
+}
+export interface ConsoleOptions {
+    readonly web?: string;
+    readonly since?: number;
+    readonly limit?: number;
+    readonly level?: ConsoleLevel | 'errors';
+}
+export interface NetworkOptions {
+    readonly web?: string;
+    readonly since?: number;
+    readonly limit?: number;
+    readonly failed?: boolean;
+}
+export interface Emulation {
+    readonly colorScheme?: 'light' | 'dark' | null;
+}
+export interface Snapshot {
+    readonly text: string;
+    readonly windows: readonly InspectWindow[];
+    readonly trees: Readonly<Record<string, readonly InspectNode[]>>;
+}
+export interface ActResult {
+    readonly ok: boolean;
+    readonly text: string;
+    readonly ended?: true;
+}
+export declare const ACTIONS: readonly InspectAction[];
+export interface Step {
+    readonly ref: string;
+    readonly action: InspectAction;
+    readonly arg?: InspectArg;
+}
+export type UrlMatch = string | RegExp;
+export type RouteResponse = {
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly contentType?: string;
+    readonly body?: string | Uint8Array;
+    readonly json?: unknown;
+} | {
+    readonly abort: true | string;
+};
+export interface RouteOptions {
+    readonly method?: string;
+    readonly web?: string;
+    readonly times?: number;
+}
+export interface WaitRequestOptions {
+    readonly method?: string;
+    readonly web?: string;
+    readonly timeout?: number;
+}
+export interface WaitConsoleOptions {
+    readonly level?: ConsoleLevel | 'errors';
+    readonly web?: string;
+    readonly timeout?: number;
+}
+export interface AttachOptions {
+    readonly session?: number;
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly timeout?: number;
+    readonly say?: (line: string) => void;
+}
+export interface LaunchOptions {
+    readonly dirs?: readonly string[];
+    readonly desktop?: string;
+    readonly app?: string;
+    readonly out?: string;
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly headless?: boolean;
+    readonly timeout?: number;
+    readonly startTimeout?: number;
+    readonly force?: boolean;
+}
+export interface PermissionPrompt {
+    readonly id: number;
+    readonly app: string;
+    readonly label: string;
+    readonly capability: string;
+    readonly reason: string;
+}
+export interface PermissionDecision {
+    readonly app: string;
+    readonly label: string | null;
+    readonly capability: string;
+    readonly decision: 'granted' | 'denied';
+    readonly folder?: {
+        readonly label: string;
+        readonly exists: boolean;
+    };
+}
+export interface Permissions {
+    readonly pending: readonly PermissionPrompt[];
+    readonly decisions: readonly PermissionDecision[];
+}
+export interface PromptMatch {
+    readonly app?: string;
+    readonly capability?: string;
+    readonly timeout?: number;
+}
+export interface DropOptions {
+    readonly web?: string;
+    readonly x?: number;
+    readonly y?: number;
+}
+export interface Dropped {
+    readonly web: string;
+    readonly window: number;
+    readonly files: readonly string[];
+}
+export declare class ActError extends Error {
+    readonly result: ActResult;
+    constructor(what: string, result: ActResult);
+}
+export type LaunchPhase = 'session' | 'window' | 'exited' | 'failed';
+export declare class LaunchError extends Error {
+    #private;
+    static readonly TAIL = 40;
+    constructor(phase: LaunchPhase, said: string, logs: Logs, options?: {
+        code?: number;
+        cause?: unknown;
+    });
+    get phase(): LaunchPhase;
+    get logs(): Logs;
+    get code(): number | null;
+    static stalled(phase: 'session' | 'window' | 'exited', head: string, logs: Logs, code?: number): LaunchError;
+}

package/lib/acde/dist/types/driver/video.d.ts

@@ -0,0 +1,14 @@
+import type { Acde } from './acde.ts';
+export declare class Video {
+    #private;
+    static readonly FPS = 4;
+    static readonly MAX_FRAMES = 600;
+    private constructor();
+    static start(acde: Acde, fps?: number): Video;
+    get frames(): number;
+    stop(): Promise<void>;
+    write(path: string): {
+        readonly frames: number;
+        readonly dropped: number;
+    } | null;
+}