@humanjs/playwright 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,6 +1,80 @@
-import { ReadKind, PersonalityConfig, HumanPlugin, Point, Personality } from '@humanjs/core';
-export { ActionResult, ActionType, BezierPathOptions, ComputeReadingDwellOptions, DwellProfile, HumanAction, HumanPlugin, HumanizePathOptions, Keystroke, KnownActionType, MouseProfile, Personality, PersonalityConfig, PersonalityExtension, PlanTypingOptions, PluginContext, Point, PresetName, ReadKind, ReadingProfile, Rng, ScrollProfile, ScrollSegment, TypingProfile, applyMicroJitter, applyVelocityProfile, bezierPath, blend, careful, computeReadingDwellMs, countWords, createRng, distracted, fast, humanizePath, planScroll, planTypeKeystrokes, precise, resolvePersonality } from '@humanjs/core';
+import { Point, ReadKind, PersonalityConfig, HumanPlugin, Personality } from '@humanjs/core';
+export { ActionResult, ActionType, BezierPathOptions, ComputeReadingDwellOptions, DwellProfile, HumanAction, HumanPlugin, HumanizePathOptions, Keystroke, KnownActionType, MouseProfile, Personality, PersonalityConfig, PersonalityExtension, PlanTypingOptions, PluginContext, Point, PresetName, ReadKind, ReadingProfile, Rng, ScrollProfile, ScrollSegment, TypingProfile, applyMicroJitter, applyVelocityProfile, bezierPath, blend, careful, computeReadingDwellMs, countWords, createRng, distracted, fast, humanizePath, planScroll, planTypeKeystrokes, precise, resolvePersonality, sleep } from '@humanjs/core';
 import { Locator, BrowserContext, Page } from 'playwright';
+export { Browser, BrowserContext, BrowserContextOptions, ElementHandle, LaunchOptions, Locator, Page, chromium, firefox, webkit } from 'playwright';
+
+/**
+ * Modifier tokens accepted in a `human.press()` chord. `Mod` and `CmdOrCtrl` /
+ * `CommandOrControl` are the magic auto-mapping tokens (Meta on Mac,
+ * Control elsewhere). The rest are literal — they always resolve to the
+ * keycode they name, on every platform.
+ *
+ * Canonical-case names are listed here for IntelliSense; the runtime
+ * parser is case-insensitive, so `'cmd+s'` and `'CMD+S'` work too — they
+ * just won't autocomplete.
+ */
+type KeyModifier = 'Mod' | 'CmdOrCtrl' | 'CommandOrControl' | 'Cmd' | 'Command' | 'Meta' | 'Win' | 'Super' | 'Ctrl' | 'Control' | 'Alt' | 'Option' | 'Opt' | 'Shift';
+/**
+ * The canonical key names that autocomplete in a `KeyOrChord`. Mirrors
+ * Playwright's accepted key vocabulary, plus a few common synonyms.
+ * CamelCase names (`ArrowDown`, `PageUp`) are listed in their canonical
+ * form — `normalizeKey` preserves case from the input, so what you type is
+ * what gets dispatched.
+ *
+ * Not exhaustive: every other Playwright key (less-common Numpad keys,
+ * `BracketLeft`, locale-specific keys, etc.) is outside the typed union
+ * and needs a cast at the call site (`'BracketLeft' as KeyOrChord`). The
+ * runtime parser handles them — the type just doesn't enumerate them,
+ * because adding a `(string & {})` escape hatch would collapse TypeScript's
+ * template-literal IntelliSense for the chord autocompletes.
+ */
+type KeyName = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'F1' | 'F2' | 'F3' | 'F4' | 'F5' | 'F6' | 'F7' | 'F8' | 'F9' | 'F10' | 'F11' | 'F12' | 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'PageUp' | 'PageDown' | 'Home' | 'End' | 'Enter' | 'Tab' | 'Escape' | 'Space' | 'Backspace' | 'Delete' | 'Insert' | 'CapsLock' | 'NumLock' | 'ScrollLock' | 'PrintScreen' | 'Pause';
+/**
+ * Strings accepted by `human.press(key)`:
+ *
+ *  - A bare known key: `'Enter'`, `'F4'`, `'ArrowDown'`, `'S'`, …
+ *  - One known modifier + a known key: `'Mod+S'`, `'Shift+ArrowDown'`, …
+ *  - Two known modifiers + a known key: `'Mod+Shift+P'`, `'Ctrl+Alt+Tab'`, …
+ *
+ * Every member of the union is a fully-enumerated literal, which is what
+ * makes IDE autocomplete work — type `'Shift+'` and you get every
+ * `Shift+<key>` combination as a completion. Adding a `(string & {})`
+ * escape hatch anywhere would collapse that down to a single wide
+ * template member, killing the completion list.
+ *
+ * Modifier typos (`'Mosd+S'`) and uncommon-key typos (`'Mod+BraketLeft'`)
+ * are both TS errors at the call site — the closed sets on both sides
+ * give you compile-time protection that Playwright's plain `string` key
+ * type can't.
+ *
+ * **Escape hatch for uncommon keys.** Less-common Playwright keys
+ * (`'BracketLeft'`, `'NumpadAdd'`, locale-specific keys, …) and 3+
+ * modifier chords (`'Ctrl+Shift+Alt+K'`) aren't in the union and need a
+ * cast at the call site:
+ *
+ * ```ts
+ * await human.press('Mod+BracketLeft' as KeyOrChord);
+ * await human.press('Ctrl+Shift+Alt+K' as KeyOrChord);
+ * ```
+ *
+ * The runtime parser handles these fine — the cast just acknowledges
+ * "I'm using a key outside the autocomplete vocabulary." If you find
+ * yourself casting often for a specific key, propose adding it to
+ * `KeyName` in a PR.
+ *
+ * Lowercase modifiers (`'mod+s'`) also don't typecheck even though the
+ * runtime accepts them — TS-strict steers users toward the canonical
+ * casing, which keeps key strings consistent across a codebase.
+ */
+type KeyOrChord = KeyName | `${KeyModifier}+${KeyName}` | `${KeyModifier}+${KeyModifier}+${KeyName}`;
+/** Result of a `press` action. */
+interface PressResult {
+    /** The exact chord that was dispatched (after Mod-resolution). */
+    readonly dispatched: string;
+}
+
+/** Anything that can resolve to a click/move point. */
+type MouseTarget = Locator | string | Point;
 
 /**
  * What to read:
@@ -39,9 +113,10 @@ interface ReadOptions {
     /**
      * For selector/Locator targets: trace a humanized cursor path through the
      * target's bounding box while the dwell elapses, like an eye tracking
-     * lines of text. Off by default — opt in when you want the humanization
-     * signal (or when reading-time mouseover behavior matters, e.g. tooltips
-     * that activate while a real user's cursor moves over the content).
+     * lines of text. **Defaults to `true`** — "reading" implies looking, and
+     * looking implies motion. Pass `false` to skip motion when you only
+     * care about the temporal pattern (typical AI-agent use case where
+     * the cursor position is irrelevant).
      *
      * The scan path is generated by `planReadingScan` from `@humanjs/core`
      * (same deterministic-by-seed contract as the rest of the library) and
@@ -63,6 +138,183 @@ interface ReadResult {
     readonly kind: ReadKind;
 }
 
+/**
+ * A captured frame in the timer-based capture session. `tMs` is the
+ * wall-clock offset (ms) from the capture start.
+ */
+interface CapturedFrame {
+    readonly path: string;
+    readonly tMs: number;
+}
+/** Outcome of a finalized capture session. */
+interface CaptureResult {
+    readonly dir: string;
+    readonly frames: readonly CapturedFrame[];
+    readonly startedAtMs: number;
+    readonly stoppedAtMs: number;
+    readonly format: 'jpeg' | 'png';
+    readonly fps: number;
+    /**
+     * Removes the temp directory + all frames. Called by `Recording.dispose()`
+     * and by the sweep-on-exit handler — not by the exporters, which are
+     * repeatable and read the frames without consuming them. Also called
+     * directly by the error path in `human.record()` when the callback throws.
+     */
+    cleanup(): Promise<void>;
+}
+
+/**
+ * Encoding quality preset. Picks the per-frame capture quality + the
+ * ffmpeg encode settings used to assemble them into a video.
+ *
+ * - `'fast'` — JPEG q=85, CRF 23, preset fast (iteration)
+ * - `'standard'` — JPEG q=90, CRF 20, preset fast (balanced)
+ * - `'high'` (default) — JPEG q=95, CRF 18, preset slow, tune animation (marketing-grade)
+ * - `'lossless'` — PNG capture, CRF 12, preset veryslow (archival; huge temp files)
+ */
+type RecordingQuality = 'fast' | 'high' | 'lossless' | 'standard';
+/** ffmpeg `-preset` values, ordered from fastest to slowest. */
+type FfmpegPreset = 'fast' | 'faster' | 'medium' | 'slow' | 'slower' | 'superfast' | 'ultrafast' | 'veryfast' | 'veryslow';
+/** ffmpeg `-tune` values for libx264. */
+type FfmpegTune = 'animation' | 'fastdecode' | 'film' | 'grain' | 'stillimage' | 'zerolatency';
+/** Options for {@link Recording.toVideo}. */
+interface ToVideoOptions {
+    /** Encoding quality preset. Defaults to `'high'`. */
+    readonly quality?: RecordingQuality;
+    /** Override CRF (0–51, lower = better). Defaults to the quality preset's CRF. */
+    readonly crf?: number;
+    /** Override ffmpeg `-preset`. Defaults to the quality preset's preset. */
+    readonly preset?: FfmpegPreset;
+    /** Override ffmpeg `-tune`. Defaults to the quality preset's tune (if any). */
+    readonly tune?: FfmpegTune;
+}
+/** Options for {@link Recording.toGif}. */
+interface ToGifOptions {
+    /**
+     * Frames per second of the output GIF. Defaults to `15` — high enough for
+     * smooth motion in most renderers, low enough to keep file size sane.
+     * Renderers cap GIF playback around 50fps anyway.
+     */
+    readonly fps?: number;
+    /**
+     * Scale the GIF to this width (pixels). Height is computed to preserve
+     * aspect ratio. Omit to keep the source viewport size — but most embedded
+     * GIFs (README, PR, Slack) look fine at 640–960px and weigh a fraction.
+     */
+    readonly width?: number;
+}
+/** One action captured during a recording, as emitted in {@link Timeline.events}. */
+interface TimelineEvent {
+    readonly type: string;
+    readonly params: Readonly<Record<string, unknown>>;
+    /** Offset (ms) from the recording start when the action began. */
+    readonly tMs: number;
+    readonly durationMs: number;
+    /** Error message, present only if the action threw. */
+    readonly error?: string;
+}
+/** Structured action timeline of a recording. */
+interface Timeline {
+    readonly version: 1;
+    readonly personality: string;
+    readonly seed: string | null;
+    readonly speed: string;
+    readonly durationMs: number;
+    readonly events: readonly TimelineEvent[];
+}
+/** Metadata passed from `human.record()` into the Recording constructor. */
+interface RecordingTimelineSource {
+    readonly personality: string;
+    readonly seed: string | null;
+    readonly speed: string;
+    readonly events: readonly TimelineEvent[];
+}
+/**
+ * A recorded window of a humanized session. Returned by `human.record(cb)`.
+ *
+ * A Recording can hold a frame capture (`hasVideo === true`) OR be
+ * timeline-only (`hasVideo === false`). `toVideo()` / `toGif()` require a
+ * capture; `toTimeline()` and `.timeline` work either way.
+ *
+ * The video exporters are repeatable and interleavable — they read the
+ * captured frames without consuming them. Calling `dispose()` is OPTIONAL:
+ * the captured-frames temp dir is also swept by a `process.on('exit')`
+ * handler installed on first use, so casual scripts can skip it entirely.
+ * Call `dispose()` (or use `await using`) when you want to release the
+ * frames proactively — long-running services, batch jobs, etc.
+ */
+declare class Recording {
+    #private;
+    constructor(capture: CaptureResult | null, windowStartMs: number, windowEndMs: number, timelineSource: RecordingTimelineSource);
+    /** Wall-clock duration of the recorded window. */
+    get durationMs(): number;
+    /** True if frames were captured during this recording. */
+    get hasVideo(): boolean;
+    /**
+     * The structured action timeline of this recording — same data that
+     * `toTimeline()` writes to disk.
+     */
+    get timeline(): Timeline;
+    /**
+     * Assembles the captured frames into a video at `outputPath`. The output
+     * format is inferred from the extension — `.mp4` (H.264, re-encoded
+     * with the configured quality) or `.webm` (VP9).
+     *
+     * Repeatable and interleavable with `toGif()` — the frame source is read,
+     * not consumed. Frames live until you call `dispose()` (or `await using`
+     * goes out of scope, or the process exits and the OS reaps `tmpdir`).
+     *
+     * @returns the resolved output path.
+     */
+    toVideo(outputPath: string, options?: ToVideoOptions): Promise<string>;
+    /**
+     * Assembles the captured frames into an animated GIF at `outputPath`.
+     * Optimized for embedding in READMEs, PRs, Slack, and docs — uses a
+     * per-recording palette (`palettegen` + `paletteuse`) with Bayer dithering
+     * so gradients stay smooth without exploding the file size.
+     *
+     * Repeatable and interleavable with `toVideo()` — call them in any order,
+     * any number of times. Frames live until you call `dispose()`.
+     *
+     * @returns the resolved output path.
+     */
+    toGif(outputPath: string, options?: ToGifOptions): Promise<string>;
+    /**
+     * Writes the structured action timeline to `outputPath` as JSON.
+     * Independent of `toVideo()` / `toGif()` — call before, after, in between,
+     * or instead. Safe to call multiple times. Unaffected by `dispose()`
+     * (the timeline lives in memory, not in the captured-frames temp dir).
+     *
+     * @returns the resolved output path.
+     */
+    toTimeline(outputPath: string): Promise<string>;
+    /**
+     * Releases the captured-frames temp directory. After this call, `toVideo()`
+     * and `toGif()` throw — but `toTimeline()` and the in-memory `timeline`
+     * still work because those don't depend on the frames.
+     *
+     * **Optional.** A process-exit handler also sweeps any un-disposed frame
+     * dirs, so casual scripts can skip this entirely. Call it explicitly when
+     * you want to release frames proactively (long-running services, batch
+     * jobs, or anywhere you want predictable disk usage).
+     *
+     * Idempotent. Safe to call on a Recording that never had a capture
+     * (timeline-only mode) — no-op there.
+     *
+     * Also wired to `Symbol.asyncDispose`, so the explicit-resource-management
+     * `await using` syntax (TypeScript ≥ 5.2 / Node ≥ 20.4) works:
+     *
+     * ```ts
+     * await using rec = await human.record(fn);
+     * await rec.toVideo('demo.mp4');
+     * await rec.toGif('demo.gif');
+     * // frames cleaned up automatically when `rec` goes out of scope
+     * ```
+     */
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
 /**
  * What / where to scroll. The chosen axis (`'y'` by default, `'x'` via
  * `options.axis`) decides whether targets resolve along the vertical or
@@ -165,31 +417,6 @@ interface InstallMouseHelperOptions {
     /** Halo opacity behind the cursor. Defaults to `0.18`. */
     readonly haloOpacity?: number;
 }
-/**
- * Installs a visual cursor overlay that follows every `mousemove` on each
- * page in the target. Real synthetic motion from Playwright (e.g.
- * `human.click()`, `human.read(..., { withMotion: true })`) is *already*
- * happening — the page just doesn't render a system cursor for it. This
- * helper injects a HumanJS-styled SVG cursor that listens to mousemove
- * events and follows them, making the motion visible in headed demos and
- * screen recordings.
- *
- * Re-runs on every navigation via `addInitScript`, so the overlay survives
- * page reloads. Idempotent — guard flag on `window` prevents double-install.
- *
- * Accepts either a `Page` (overlay applies to that page) or a
- * `BrowserContext` (overlay applies to every page in the context, including
- * pages opened later).
- *
- * @example
- * ```ts
- * const browser = await chromium.launch({ headless: false });
- * const context = await browser.newContext();
- * await installMouseHelper(context);
- * const page = await context.newPage();
- * // human-driven actions are now visible in the page
- * ```
- */
 declare function installMouseHelper(target: BrowserContext | Page, options?: InstallMouseHelperOptions): Promise<void>;
 
 /**
@@ -239,6 +466,53 @@ interface Human {
      * native `locator.click()` is used directly.
      */
     click(target: Locator | string): Promise<void>;
+    /**
+     * Right-click `target` — opens a native context menu. Same Bezier-path
+     * motion and hover dwell as `click()`; only the dispatched button differs.
+     *
+     * In `speed: 'instant'`, falls back to `locator.click({ button: 'right' })`.
+     */
+    rightClick(target: Locator | string): Promise<void>;
+    /**
+     * Move the cursor to `target` along a humanized Bezier path and settle
+     * on it — no click is dispatched. Useful for hover-triggered UI
+     * (tooltips, dropdowns), for positioning the cursor before a non-target
+     * action, or for visible demos where the cursor should pause on
+     * something noteworthy.
+     *
+     * In `speed: 'instant'`, dispatches one `mouse.move()` to the element's
+     * center.
+     */
+    hover(target: Locator | string): Promise<void>;
+    /**
+     * Move the cursor to `target` along a humanized Bezier path. Pure
+     * positioning — no settle dwell, no element interaction. `target` accepts
+     * a CSS selector, a `Locator`, or a literal `Point`; the `Point` form
+     * lets you position the cursor anywhere (canvas, SVG, dead space) without
+     * a DOM element to anchor on.
+     *
+     * Distinct from `hover()`: `hover` is element-bound and includes a settle
+     * dwell to let hover-state UI fire (tooltips, dropdowns). `move` is
+     * positional only — use it when you want the cursor placed somewhere
+     * without implying interaction with what's under it (pre-press
+     * placement, canvas painting, cinematic beats).
+     *
+     * In `speed: 'instant'`, dispatches one `mouse.move()` at the resolved
+     * coordinates.
+     */
+    move(target: MouseTarget): Promise<void>;
+    /**
+     * Drag from `from` to `to`. Each endpoint accepts a CSS selector, a
+     * `Locator`, or a literal `Point` — the last form matters for canvas /
+     * SVG / slider drags where the destination isn't a DOM element.
+     *
+     * The motion is two humanized paths back-to-back: cursor → source,
+     * then source → destination with the left button held throughout.
+     *
+     * In `speed: 'instant'`, dispatches `mouse.down → move → up` at the
+     * resolved coordinates without humanized motion.
+     */
+    drag(from: MouseTarget, to: MouseTarget): Promise<void>;
     /**
      * Type `value` into `target` with humanized per-key timing, optional typo
      * injection (with backspace recovery), and occasional think-pauses.
@@ -250,6 +524,48 @@ interface Human {
      * zero inter-key delay — events still fire, but humanization is skipped.
      */
     type(target: Locator | string, value: string): Promise<void>;
+    /**
+     * Insert `value` into `target` in one shot — the Cmd-V semantic. No
+     * per-character timing. Like `type()`, drives an implicit click to focus
+     * the field first; unlike `type()`, dispatches the whole value via
+     * `keyboard.insertText` rather than per-key presses.
+     *
+     * Use this for long strings (code blocks, multi-line content, secrets)
+     * where the typing simulation would be slow and unnecessary. If you need
+     * the page's `paste` event handler to fire, call `human.press('Mod+V')`
+     * after setting clipboard contents yourself.
+     *
+     * In `speed: 'instant'`, behaves identically — paste is already instant
+     * by nature.
+     */
+    paste(target: Locator | string, value: string): Promise<void>;
+    /**
+     * Press a single key (`'Tab'`, `'Enter'`, `'Escape'`, `'ArrowDown'`, …)
+     * or a keyboard chord (`'Mod+S'`, `'Cmd+Shift+P'`, `'Ctrl+C'`, …).
+     *
+     * Modifier rules:
+     *
+     * - `Mod` / `CmdOrCtrl` / `CommandOrControl` — magic: `Meta` on Mac,
+     *   `Control` elsewhere. Use for cross-platform app shortcuts. The three
+     *   are aliases; `Mod` is shortest.
+     * - `Cmd`, `Command`, `Meta`, `Win`, `Super` — literal `Meta` keycode
+     *   (Command on Mac, Windows key on Windows, Super on Linux).
+     * - `Ctrl`, `Control` — literal Control. Stays Control on every OS.
+     * - `Alt`, `Option`, `Opt` — literal Alt.
+     * - `Shift` — literal Shift.
+     *
+     * Case-insensitive. Throws on unknown modifiers. The `KeyOrChord` type
+     * is a template-literal union of every modifier × key combination (up to
+     * two literal modifiers + a key), so IDEs autocomplete common bare keys
+     * and chords as you type. Less common keys (`BracketLeft`, `NumpadAdd`,
+     * locale-specific keys) still typecheck through the union's string
+     * escape hatch — they just don't autocomplete.
+     *
+     * Does **not** move the cursor — keyboard input dispatches against
+     * focus, not cursor position. Compose with `click` / `hover` / `move`
+     * when you need both.
+     */
+    press(key: KeyOrChord): Promise<void>;
     /**
      * Dwell as if reading `target` — the third pillar of humanization after
      * the cursor and the keyboard. Real users pause to read; HumanJS models
@@ -310,6 +626,65 @@ interface Human {
      * Returns a {@link ScrollResult} for assertions in tests.
      */
     scroll(target?: ScrollTarget, options?: ScrollOptions): Promise<ScrollResult>;
+    /**
+     * Pause for `ms` milliseconds. Equivalent to importing `sleep` from
+     * `@humanjs/playwright` and calling it — exposed on the Human instance
+     * so users who already have `human` in scope don't need an extra import.
+     *
+     * Not a humanized action: this is a raw `setTimeout` wait, not scaled
+     * by personality or speed mode, and no plugin events fire. Use it for
+     * generic pacing between humanized actions.
+     */
+    sleep(ms: number): Promise<void>;
+    /**
+     * Records `fn`'s actions. Returns a {@link Recording} you can export
+     * to mp4/webm video (`toVideo`), JSON timeline (`toTimeline`), or both.
+     *
+     * By default, frames are captured from the browser via timer-polled
+     * `page.screenshot()` — fully controllable quality, not limited by
+     * Playwright's recordVideo bitrate ceiling. Pass `{ video: false }` to
+     * skip capture entirely (timeline-only mode, zero video overhead).
+     *
+     * Plugins observe `'record'` in `beforeAction` / `afterAction` so
+     * recording shows up alongside the other primitives in observability
+     * pipelines.
+     *
+     * Single-use per session: `Recording.toVideo()` finalizes the captured
+     * frames, so calling `human.record()` twice on the same human throws.
+     *
+     * @example
+     * ```ts
+     * // Default: video + timeline
+     * const rec = await human.record(async () => {
+     *   await human.click('#login');
+     * });
+     * await rec.toVideo('demo.mp4');
+     * await rec.toTimeline('demo.json');
+     *
+     * // Timeline-only, no video overhead
+     * const rec = await human.record({ video: false }, async () => {
+     *   await human.click('#login');
+     * });
+     * await rec.toTimeline('demo.json');
+     * ```
+     */
+    record(fn: () => Promise<void>): Promise<Recording>;
+    record(options: HumanRecordOptions, fn: () => Promise<void>): Promise<Recording>;
+}
+/** Options for {@link Human.record}. */
+interface HumanRecordOptions {
+    /**
+     * Whether to capture frames for video output. Defaults to `true`.
+     * Set to `false` for timeline-only recordings (no capture loop, no
+     * temp files, no encoding overhead — `toTimeline()` still works).
+     */
+    readonly video?: boolean;
+    /**
+     * Capture quality preset. Controls per-frame JPEG quality (or PNG for
+     * lossless) AND the ffmpeg encode settings used by `toVideo()`.
+     * Defaults to `'high'`. Ignored when `video: false`.
+     */
+    readonly quality?: RecordingQuality;
 }
 /**
  * Creates a humanized session bound to a Playwright `Page`.
@@ -332,4 +707,4 @@ interface Human {
  */
 declare function createHuman(page: Page, options?: CreateHumanOptions): Promise<Human>;
 
-export { type CreateHumanOptions, type Human, type InstallMouseHelperOptions, type ReadOptions, type ReadResult, type ReadTarget, type ScrollOptions, type ScrollResult, type ScrollTarget, type Speed, createHuman, installMouseHelper };
+export { type CreateHumanOptions, type FfmpegPreset, type FfmpegTune, type Human, type HumanRecordOptions, type InstallMouseHelperOptions, type KeyModifier, type KeyName, type KeyOrChord, type MouseTarget, type PressResult, type ReadOptions, type ReadResult, type ReadTarget, Recording, type RecordingQuality, type ScrollOptions, type ScrollResult, type ScrollTarget, type Speed, type Timeline, type TimelineEvent, type ToGifOptions, type ToVideoOptions, createHuman, installMouseHelper };