@mu-agent/mu 0.1.1 → 0.2.2

package/dist/types/ai/types.d.ts

@@ -82,6 +82,10 @@ export interface ToolResultMessage {
     usage?: Usage;
     isError: boolean;
     evicted?: boolean;
+    retention?: {
+        key: string;
+        summary: string;
+    };
     timestamp: number;
 }
 export type AiMessage = UserMessage | AssistantMessage | ToolResultMessage;

package/dist/types/core/index.d.ts

@@ -14,11 +14,11 @@ export * from "./messages.js";
 export { customMessage, isCustomMessage, renderCustomMessage, toAiMessages, userMessage, } from "./messages.js";
 export type { MicrocompactionOptions, MicrocompactionResult } from "./microcompaction.js";
 export { IMAGE_TOMBSTONE, MICROCOMPACT_THRESHOLD, microcompact, TOMBSTONE, } from "./microcompaction.js";
-export type { PermissionAction, PermissionPreview, PermissionRequest, PermissionRule, ToolPermissionDetails, } from "./permission.js";
-export { evaluate } from "./permission.js";
+export type { PermissionAction, PermissionField, PermissionPreview, PermissionRequest, PermissionRule, PermissionSection, ToolPermissionDetails, } from "./permission.js";
+export { evaluate, permissionPreviewLines } from "./permission.js";
 export type { ManagedProcessHandle, ProcessEvents, Spawner, SpawnRequest, TaskInfo, TaskStatus, } from "./process.js";
 export { exitNotification, OutputBuffer, ProcessManager } from "./process.js";
-export type { PermissionMode, PermissionModeTone, Profile, ProfileFactory, ProfileRuntime, ProfileRuntimeHost, ProfileSubagents, } from "./profile.js";
+export type { PermissionMode, PermissionModeTone, Profile, ProfileFactory, ProfileRuntime, ProfileRuntimeHost, ProfileSubagents, TaskSubagentSession, } from "./profile.js";
 export type { RecoveryAttempt } from "./recovery.js";
 export { isContextTooLongError, isContextTooLongResult, withContextRecovery, } from "./recovery.js";
 export type { NewTreeEntry, SessionEntry, SessionStore, TreeEntry } from "./session.js";

package/dist/types/core/permission.d.ts

@@ -20,7 +20,19 @@ export type PermissionPreview = {
 } | {
     kind: "diff";
     file: CheckpointDiffFile;
+} | {
+    kind: "fields";
+    sections: PermissionSection[];
 };
+export interface PermissionField {
+    label: string;
+    value: string;
+}
+export interface PermissionSection {
+    title?: string;
+    fields: PermissionField[];
+}
+export declare function permissionPreviewLines(preview: PermissionPreview | undefined): string[];
 export interface ToolPermissionDetails {
     description?: string;
     preview?: PermissionPreview;

package/dist/types/core/profile.d.ts

@@ -24,7 +24,14 @@ export interface ProfileRuntime {
     stop?: () => void;
     shutdown?: () => void | Promise<void>;
 }
+export interface TaskSubagentSession {
+    tools: AnyTool[];
+    prompt?: string;
+    refreshContext?: Profile["refreshContext"];
+    close: () => void | Promise<void>;
+}
 export interface ProfileSubagents {
+    taskSession?: (description: string, signal: AbortSignal) => Promise<TaskSubagentSession>;
     inspectionTools: string[];
     searchPrompt?: string;
     counselPrompt?: string;

package/dist/types/core/tools.d.ts

@@ -7,6 +7,10 @@ export interface ToolResult {
     isError?: boolean;
     directResponse?: string;
     terminate?: boolean;
+    retention?: {
+        key: string;
+        summary: string;
+    };
 }
 export interface Tool<Args = Record<string, unknown>> {
     name: string;

package/dist/types/index.d.ts

@@ -1,10 +1,14 @@
+import { type BrowserProfile, type BrowserProfileOptions, browserProfile } from "./profile-browser/index.js";
 import { type CodingProfile, type CodingProfileOptions, codingProfile } from "./profile-coding/index.js";
 import { Agent, type AgentOptions, type Profile } from "./sdk/index.js";
 export * from "./sdk/index.js";
-export { codingProfile };
-export type { CodingProfile, CodingProfileOptions };
-export interface CreateAgentOptions extends AgentOptions {
+export { browserProfile, codingProfile };
+export type { BrowserProfile, BrowserProfileOptions, CodingProfile, CodingProfileOptions };
+export type CreateAgentOptions = AgentOptions & ({
     profile?: "coding" | Profile;
     profileOptions?: CodingProfileOptions;
-}
+} | {
+    profile: "browser";
+    profileOptions?: BrowserProfileOptions;
+});
 export declare function createAgent(options?: CreateAgentOptions): Promise<Agent>;

package/dist/types/profile-browser/actions/classify.d.ts

@@ -0,0 +1,19 @@
+import type { RefMeta } from "../page/refs.js";
+export interface Classification {
+    scope: string;
+    reason?: string;
+}
+export declare function matchesCommitLexicon(text: string | undefined): boolean;
+export interface PageContext {
+    url: string;
+    title: string;
+}
+export type CommitStrength = "final" | "step";
+export declare function commitStrength(names: (string | undefined)[], before: PageContext, after?: PageContext, credentials?: boolean): CommitStrength;
+export interface ClassifyInput {
+    tool: string;
+    args: Record<string, unknown>;
+    meta: (ref: string) => RefMeta | undefined;
+    page?: PageContext | undefined;
+}
+export declare function classify({ tool, args, meta, page }: ClassifyInput): Classification;

package/dist/types/profile-browser/actions/click.d.ts

@@ -0,0 +1,48 @@
+import type { BrowserManager } from "../browser/manager.js";
+import type { Tab, TabInfo } from "../browser/tabs.js";
+import { type ResolvedRef } from "../page/resolve.js";
+import { type Modifier, type MouseButton, type Occluder, type Point } from "./pointer.js";
+import type { OutcomeKind, Stopwatch } from "./types.js";
+export interface ActionContext {
+    tab: Tab;
+    browser: BrowserManager;
+    stopwatch: Stopwatch;
+    signal: AbortSignal;
+}
+export interface ActionResult {
+    ok?: boolean;
+    summary: string;
+    kind?: OutcomeKind;
+    settle?: string;
+    tab?: Tab;
+    extra?: string;
+    path?: "mouse" | "js" | "keyboard";
+    occludedBy?: Occluder;
+    newTab?: TabInfo;
+}
+interface TargetInfo {
+    tag: string;
+    type: string;
+    disabled: boolean;
+    options?: string[];
+}
+export declare function targetInfo(target: ResolvedRef, signal?: AbortSignal): Promise<TargetInfo>;
+export declare function viewportSize(tab: Tab, signal?: AbortSignal): Promise<{
+    width: number;
+    height: number;
+}>;
+export declare function describeOccluder(occluder: Occluder): string;
+export declare function raceDialog(tab: Tab, work: Promise<unknown>): Promise<"done" | "dialog">;
+export declare function mainPoint(ctx: ActionContext, target: ResolvedRef, point: Point): Promise<Point>;
+export declare function clickRef(ctx: ActionContext, ref: string, options?: {
+    button?: MouseButton;
+    double?: boolean;
+    modifiers?: Modifier[];
+}): Promise<ActionResult>;
+export declare function clickPoint(ctx: ActionContext, point: Point, options?: {
+    button?: MouseButton;
+    double?: boolean;
+}): Promise<ActionResult>;
+export declare function hoverRef(ctx: ActionContext, ref: string): Promise<ActionResult>;
+export declare function dragBetween(ctx: ActionContext, from: string | Point, to: string | Point): Promise<ActionResult>;
+export {};

package/dist/types/profile-browser/actions/dates.d.ts

@@ -0,0 +1,11 @@
+export interface DateTarget {
+    year: number;
+    month?: number;
+    day?: number;
+}
+export declare const MONTHS: string[];
+export declare function parseDate(text: string): DateTarget | undefined;
+export declare function isoFor(type: string, target: DateTarget): string | undefined;
+export declare function namesDate(name: string, target: DateTarget, shown: string): boolean;
+export declare function shownPeriod(names: string[]): number | undefined;
+export declare function periodOf(target: DateTarget): number;

package/dist/types/profile-browser/actions/files.d.ts

@@ -0,0 +1,9 @@
+import { type ActionContext, type ActionResult } from "./click.js";
+export declare function sensitivePath(path: string): boolean;
+export declare function uploadRoots(config: {
+    workspace: string;
+    downloadsDir: string;
+}): string[];
+export declare function resolveUploadPaths(paths: string[], roots: string[]): string[];
+export declare function uploadFiles(ctx: ActionContext, ref: string, paths: string[], roots: string[]): Promise<ActionResult>;
+export declare function handleDialog(ctx: ActionContext, action: "accept" | "dismiss", text?: string): Promise<ActionResult>;

package/dist/types/profile-browser/actions/filetype.d.ts

@@ -0,0 +1,8 @@
+export interface FileType {
+    mime: string;
+    label: string;
+    extensions: string[];
+}
+export declare function detectType(path: string): FileType;
+export declare function describeFile(path: string): string;
+export declare function uploadProblem(accept: string, path: string): string | undefined;

package/dist/types/profile-browser/actions/input.d.ts

@@ -0,0 +1,17 @@
+import { type ActionContext, type ActionResult } from "./click.js";
+export declare function normalizeDateValue(type: string, value: string): string;
+export interface TypeOptions {
+    clear?: boolean;
+    submit?: boolean;
+    keystrokes?: boolean;
+    settle?: boolean;
+}
+export declare function typeText(ctx: ActionContext, ref: string, text: string, options?: TypeOptions): Promise<ActionResult>;
+export declare function pressKeys(ctx: ActionContext, keys: string, ref?: string): Promise<ActionResult>;
+export declare function setChecked(ctx: ActionContext, ref: string, checked: boolean): Promise<ActionResult>;
+export declare function selectOptions(ctx: ActionContext, ref: string, options: string[]): Promise<ActionResult>;
+export interface FormField {
+    ref: string;
+    value: string | boolean | string[];
+}
+export declare function fillForm(ctx: ActionContext, fields: FormField[], submitRef?: string): Promise<ActionResult>;

package/dist/types/profile-browser/actions/keyboard.d.ts

@@ -0,0 +1,16 @@
+import type { CdpSession } from "../cdp/session.js";
+import type { Modifier } from "./pointer.js";
+export interface KeyDefinition {
+    key: string;
+    code: string;
+    keyCode: number;
+    text?: string;
+}
+export interface KeyCombo {
+    modifiers: Modifier[];
+    key: KeyDefinition;
+    label: string;
+}
+export declare function parseKeys(input: string, platform?: NodeJS.Platform): KeyCombo;
+export declare function pressCombo(session: CdpSession, combo: KeyCombo, signal?: AbortSignal, platform?: NodeJS.Platform): Promise<void>;
+export declare function typeKeystrokes(session: CdpSession, text: string, signal?: AbortSignal): Promise<void>;

package/dist/types/profile-browser/actions/navigate.d.ts

@@ -0,0 +1,11 @@
+import type { Tab } from "../browser/tabs.js";
+export declare function normalizeUrl(input: string): string;
+export declare function hostOf(url: string): string;
+export interface NavigationResult {
+    settle: string;
+    sameDocument: boolean;
+    ms: number;
+}
+export declare function navigateTo(tab: Tab, url: string, signal?: AbortSignal): Promise<NavigationResult>;
+export declare function goHistory(tab: Tab, delta: -1 | 1, signal?: AbortSignal): Promise<NavigationResult | undefined>;
+export declare function reload(tab: Tab, signal?: AbortSignal): Promise<NavigationResult>;

package/dist/types/profile-browser/actions/page.d.ts

@@ -0,0 +1,8 @@
+import { type ActionContext, type ActionResult } from "./click.js";
+export declare const MAX_WAIT_SECONDS = 30;
+export declare function waitFor(ctx: ActionContext, options: {
+    text?: string | undefined;
+    gone?: boolean | undefined;
+    seconds?: number | undefined;
+}): Promise<ActionResult>;
+export declare function evaluateScript(ctx: ActionContext, source: string, ref?: string): Promise<ActionResult>;

package/dist/types/profile-browser/actions/pointer.d.ts

@@ -0,0 +1,39 @@
+import type { Tab } from "../browser/tabs.js";
+import type { CdpSession } from "../cdp/session.js";
+import type { ResolvedRef } from "../page/resolve.js";
+export type MouseButton = "left" | "right" | "middle";
+export type Modifier = "Alt" | "Control" | "Meta" | "Shift";
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Occluder {
+    ref?: string;
+    role: string;
+    name: string;
+    inside: {
+        ref?: string;
+        role: string;
+        name: string;
+    }[];
+}
+export declare function modifierMask(modifiers?: Modifier[]): number;
+export declare function sessionOffset(tab: Tab, frameId: string, signal?: AbortSignal): Promise<Point>;
+export declare function clickablePoint(target: ResolvedRef, viewport: {
+    width: number;
+    height: number;
+}, signal?: AbortSignal): Promise<Point | undefined>;
+export declare function hitTest(target: ResolvedRef, point: Point, refOf: (frameId: string, backendNodeId: number) => string | undefined, signal?: AbortSignal): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    occluder: Occluder;
+}>;
+export declare function mouseClick(session: CdpSession, point: Point, options?: {
+    button?: MouseButton;
+    clickCount?: number;
+    modifiers?: Modifier[];
+    signal?: AbortSignal | undefined;
+}): Promise<void>;
+export declare function mouseMove(session: CdpSession, point: Point, signal?: AbortSignal): Promise<boolean>;
+export declare function mouseDrag(session: CdpSession, from: Point, to: Point, signal?: AbortSignal): Promise<"html5" | "pointer">;

package/dist/types/profile-browser/actions/scroll.d.ts

@@ -0,0 +1,8 @@
+import type { ActionContext, ActionResult } from "./click.js";
+export interface ScrollOptions {
+    direction?: "up" | "down" | "left" | "right";
+    to?: "top" | "bottom";
+    amount?: "page" | "half" | number;
+    ref?: string;
+}
+export declare function scrollPage(ctx: ActionContext, options: ScrollOptions): Promise<ActionResult>;

package/dist/types/profile-browser/actions/submission.d.ts

@@ -0,0 +1,7 @@
+import type { Tab } from "../browser/tabs.js";
+export interface SubmissionContent {
+    kind: "fields" | "text";
+    lines: string[];
+    credentials?: boolean;
+}
+export declare function submissionContent(tab: Tab, ref: string): Promise<SubmissionContent | undefined>;

package/dist/types/profile-browser/actions/types.d.ts

@@ -0,0 +1,38 @@
+import type { TabInfo } from "../browser/tabs.js";
+export type Ref = string;
+export interface Timings {
+    cdpMs: number;
+    settleMs: number;
+    snapshotMs: number;
+    screenshotMs: number;
+    totalMs: number;
+}
+export type OutcomeKind = "stale-ref" | "occluded" | "no-change" | "navigated" | "new-tab" | "dialog" | "value-mismatch" | "timeout" | "blocked-by-dialog" | "not-interactable" | "error";
+export interface OutcomeDetails {
+    timings: Timings;
+    url: string;
+    title: string;
+    tabId: string;
+    fingerprint: string;
+    snapshotTokens: number;
+    settle?: string;
+    path?: "mouse" | "js" | "keyboard";
+}
+export interface ActionOutcome {
+    ok: boolean;
+    summary: string;
+    kind?: OutcomeKind;
+    occludedBy?: {
+        ref?: Ref;
+        role: string;
+        name: string;
+    };
+    newTab?: TabInfo;
+    details: OutcomeDetails;
+}
+export declare class Stopwatch {
+    private readonly started;
+    readonly timings: Omit<Timings, "totalMs">;
+    time<T>(phase: keyof Omit<Timings, "totalMs">, work: () => Promise<T>): Promise<T>;
+    finish(): Timings;
+}

package/dist/types/profile-browser/agent/dataflow.d.ts

@@ -0,0 +1,18 @@
+export interface Leak {
+    from: string;
+    sample: string;
+}
+export declare class DataFlowGuard {
+    private readonly corpora;
+    private readonly tokens;
+    private readonly links;
+    private user;
+    observe(host: string, text: string): void;
+    private tokenLeak;
+    link(url: string): void;
+    userSaid(text: string): void;
+    visited(host: string): boolean;
+    leak(value: string, targetHost: string): Leak | undefined;
+    navigationLeak(url: string): string | undefined;
+    typingLeak(values: string[], pageUrl: string): string | undefined;
+}

package/dist/types/profile-browser/agent/handoff.d.ts

@@ -0,0 +1,15 @@
+import { type ProfileRuntimeHost } from "../../core/index.js";
+import type { BrowserManager } from "../browser/manager.js";
+import type { Tab } from "../browser/tabs.js";
+export declare class Handoffs {
+    private readonly pollMs;
+    private host;
+    private timer;
+    constructor(pollMs?: number);
+    attach(host: ProfileRuntimeHost): void;
+    start(tab: Tab, reason: string): void;
+    cancel(): void;
+}
+export declare function handoffTool(browser: BrowserManager, handoffs: Handoffs): import("../../sdk/index.js").Tool<{
+    reason: string;
+}>;

package/dist/types/profile-browser/agent/ledger.d.ts

@@ -0,0 +1,4 @@
+import type { AnyTool } from "../../core/index.js";
+import type { BrowserManager } from "../browser/manager.js";
+import type { BrowserState } from "./state.js";
+export declare function recordingCommits(tool: AnyTool, browser: BrowserManager, state: BrowserState): AnyTool;

package/dist/types/profile-browser/agent/notes.d.ts

@@ -0,0 +1,6 @@
+import { type BrowserState } from "./state.js";
+export declare function notesTool(state: BrowserState): import("../../sdk/index.js").Tool<{
+    action: "read" | "replace" | "append" | "clear";
+    key?: string | undefined;
+    text?: string | undefined;
+}>;

package/dist/types/profile-browser/agent/permissions.d.ts

@@ -0,0 +1,18 @@
+import type { PermissionMode, PermissionRule } from "../../core/index.js";
+export declare const SCOPES: {
+    readonly observe: "browser:observe";
+    readonly navigate: "browser:navigate";
+    readonly interact: "browser:interact";
+    readonly commit: "browser:commit";
+    readonly secret: "browser:secret";
+    readonly upload: "browser:upload";
+    readonly script: "browser:script";
+    readonly delegate: "browser:delegate";
+    readonly share: "browser:share";
+};
+export declare const BROWSER_PERMISSION_DEFAULTS: PermissionRule[];
+export declare function hostRules(allowedHosts: string[], blockedHosts: string[]): PermissionRule[];
+export declare function browserPermissionModes(hosts?: PermissionRule[]): PermissionMode[];
+export declare function rememberedPermissionsPath(home: string): string;
+export declare function loadRememberedPermissions(home: string, onWarning?: (message: string) => void): PermissionRule[];
+export declare function rememberAllow(home: string, permission: string, pattern: string): PermissionRule[];

package/dist/types/profile-browser/agent/prompts.d.ts

@@ -0,0 +1,4 @@
+import type { PromptSection } from "../../ai/index.js";
+export declare function browserPrompt(modelRef: string): PromptSection[];
+export declare const BROWSER_TASK_PROMPT = "You are a browser sub-task, running alongside others for the main agent in a browser window of your own.\n- Your first browser action opens your window. You see and use only the tabs you open (and popups from them); other tabs belong to the main agent or other sub-tasks.\n- The brief is all you know about the task; the rules above still apply. Only take consequential actions the brief explicitly authorizes (the user still approves each one), and stop where the brief says to stop.\n- Keep the progress file the brief names (under progress/) up to date as you finish steps; never edit another sub-task's file.\n- Anything only the user can do (sign in, a CAPTCHA, an answer your files do not give) is a blocker: stop and report exactly what is needed.\n- Before finishing, close the tabs you no longer need. Leave open only a tab the user should review (for example a filled form waiting for their submit) and name it in your report.\n- Report the outcome, what was submitted and the confirmation the page showed, what is left and why, and any tab left open.";
+export declare const BROWSER_SIDE_BOUNDARY = "This is a side conversation about the browser session. Do not operate the browser, submit forms or change pages unless the user deliberately changes the side conversation's permission mode.";

package/dist/types/profile-browser/agent/state.d.ts

@@ -0,0 +1,48 @@
+import { type AgentMessage } from "../../core/index.js";
+import type { CommitStrength } from "../actions/classify.js";
+export interface NoteEntry {
+    key: string;
+    text: string;
+}
+export interface CommitRecord {
+    id: string;
+    at: number;
+    host: string;
+    url: string;
+    action: string;
+    target: string;
+    valuesDigest?: string;
+}
+export interface CommitDetails extends CommitRecord {
+    name?: string;
+    sends?: string[];
+    strength: CommitStrength;
+}
+export declare const STATE_TYPE = "browser-state";
+export declare const DEFAULT_NOTE_KEY = "notes";
+export declare class NotesStore {
+    private readonly notes;
+    entries(): NoteEntry[];
+    get(key: string): string | undefined;
+    append(key: string, text: string): void;
+    replace(key: string, text: string): void;
+    clear(key?: string): void;
+    load(entries: NoteEntry[]): void;
+}
+export declare class CommitLedger {
+    private list;
+    records(): CommitRecord[];
+    append(record: CommitRecord): void;
+    load(records: CommitRecord[]): void;
+}
+export declare function formatNotes(entries: NoteEntry[]): string;
+export declare function formatLedger(records: CommitRecord[]): string;
+export declare class BrowserState {
+    readonly ledger: CommitLedger;
+    readonly notes: NotesStore;
+    sessionId: string | undefined;
+    constructor(ledger?: CommitLedger);
+    rebuild(messages: AgentMessage[]): void;
+    private snapshotText;
+    snapshotIfChanged(messages: AgentMessage[]): AgentMessage[];
+}

package/dist/types/profile-browser/browser/connect.d.ts

@@ -0,0 +1,45 @@
+import { type CdpConnection } from "../cdp/connection.js";
+import { type DiscoveredBrowser } from "./discover.js";
+import { type BrowserEndpoint, type LaunchOptions, type Size } from "./launch.js";
+export interface BrowserLauncher {
+    discover(prefs: {
+        executable?: string | undefined;
+        channel?: string | undefined;
+    }): Promise<DiscoveredBrowser>;
+    launch(options: LaunchOptions): Promise<BrowserEndpoint>;
+}
+export declare const defaultLauncher: BrowserLauncher;
+interface Signals {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+}
+export declare function endpointAlive(wsUrl: string, options?: Signals): Promise<boolean>;
+export declare function resolveCdpUrl(endpoint: string, options?: Signals): Promise<string>;
+export declare function profileLocked(userDataDir: string): boolean;
+export declare function waitForUnlock(userDataDir: string, signal?: AbortSignal, timeoutMs?: number): Promise<void>;
+export interface ManagedConnectOptions {
+    userDataDir: string;
+    headless: boolean;
+    viewport: Size;
+    executable?: string | undefined;
+    channel?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+    launcher?: BrowserLauncher | undefined;
+    signal?: AbortSignal | undefined;
+}
+export interface ConnectedBrowser {
+    connection: CdpConnection;
+    endpoint: BrowserEndpoint;
+    browser?: DiscoveredBrowser;
+}
+export declare function connectManaged(options: ManagedConnectOptions): Promise<ConnectedBrowser>;
+export declare function connectToEndpoint(endpoint: string, options?: Signals): Promise<ConnectedBrowser>;
+export interface ManagedState {
+    running: boolean;
+    endpoint?: string;
+    locked: boolean;
+}
+export declare function managedState(userDataDir: string): Promise<ManagedState>;
+export declare function closeManaged(userDataDir: string): Promise<boolean>;
+export {};

package/dist/types/profile-browser/browser/discover.d.ts

@@ -0,0 +1,31 @@
+export type BrowserChannel = "chrome" | "chromium" | "brave" | "edge";
+export declare const BROWSER_CHANNELS: BrowserChannel[];
+export interface BrowserCandidate {
+    channel: BrowserChannel;
+    path: string;
+}
+export interface DiscoveredBrowser {
+    path: string;
+    channel: BrowserChannel | "custom";
+    product: string;
+    version: string;
+}
+export interface DiscoverDeps {
+    platform: NodeJS.Platform;
+    env: Record<string, string | undefined>;
+    home: string;
+    exists: (path: string) => boolean;
+    which: (command: string) => string | null;
+    probeVersion: (path: string) => Promise<string | undefined>;
+}
+export declare function knownPaths(platform: NodeJS.Platform, env: Record<string, string | undefined>, home: string): BrowserCandidate[];
+export declare function parseVersionOutput(output: string): {
+    product: string;
+    version: string;
+};
+export declare function defaultDiscoverDeps(): DiscoverDeps;
+export declare function findCandidates(channel: BrowserChannel | undefined, deps: DiscoverDeps): BrowserCandidate[];
+export declare function discoverBrowser(prefs?: {
+    executable?: string | undefined;
+    channel?: string | undefined;
+}, deps?: DiscoverDeps): Promise<DiscoveredBrowser>;

package/dist/types/profile-browser/browser/downloads.d.ts

@@ -0,0 +1,24 @@
+import type { CdpConnection } from "../cdp/connection.js";
+export interface DownloadRecord {
+    guid: string;
+    url: string;
+    filename: string;
+    path: string;
+    state: "in progress" | "completed" | "canceled";
+    receivedBytes: number;
+    totalBytes: number;
+    startedAt: number;
+}
+export declare class DownloadTracker {
+    readonly directory: string;
+    private readonly records;
+    private readonly listeners;
+    constructor(directory: string);
+    attach(connection: CdpConnection, signal?: AbortSignal): Promise<void>;
+    private notify;
+    list(): DownloadRecord[];
+    since(time: number): DownloadRecord[];
+    waitForStart(time: number, capMs: number, signal?: AbortSignal): Promise<void>;
+    waitForFinished(time: number, capMs: number, signal?: AbortSignal): Promise<void>;
+}
+export declare function formatDownloads(records: DownloadRecord[]): string;

package/dist/types/profile-browser/browser/frames.d.ts

@@ -0,0 +1,34 @@
+import type { CdpConnection } from "../cdp/connection.js";
+import { CdpSession } from "../cdp/session.js";
+export interface FrameInfo {
+    frameId: string;
+    parentId?: string | undefined;
+    url: string;
+    loaderId?: string | undefined;
+    session: CdpSession;
+}
+export declare class FrameRegistry {
+    private readonly connection;
+    readonly root: CdpSession;
+    private readonly frames;
+    private readonly children;
+    private readonly offs;
+    private readonly worlds;
+    private readonly sessionHooks;
+    private readonly hookOffs;
+    constructor(connection: CdpConnection, root: CdpSession);
+    get mainFrameId(): string | undefined;
+    list(): FrameInfo[];
+    get(frameId: string): FrameInfo | undefined;
+    childSessions(): CdpSession[];
+    onSession(hook: (session: CdpSession) => () => void): void;
+    private runHook;
+    start(signal?: AbortSignal): Promise<void>;
+    isolatedWorld(frameId: string, signal?: AbortSignal): Promise<number>;
+    forgetWorlds(frameId?: string): void;
+    dispose(): void;
+    private record;
+    private watchSession;
+    private removeFrame;
+    private adoptChild;
+}