@reticlehq/server 3.2.0 → 3.4.0

package/dist/features/exhaust/ledger.d.ts

@@ -0,0 +1,202 @@
+/**
+ * The app-wide coverage ledger: what "everything" is, and how much of it has been proved.
+ *
+ * "Done" used to be the agent's opinion, which is the root of shallow verification: every rule it
+ * read pushed it to stop, and nothing it could read said what was left. This makes it a number per
+ * level, each with the missing items named, accumulated across every drive and every session.
+ *
+ * Six levels, each stricter than the last, and never averaged — an average is exactly how "the
+ * controls were clicked" hides "none of them were proved":
+ *
+ *   reached   — routes rendered, of routes discovered
+ *   touched   — controls acted on, of controls seen
+ *   proved    — controls with a `yes` verdict on a declared consequence, of controls seen
+ *   completed — journeys proved at their end (count only: there is no honest denominator)
+ *   branched  — writes whose FAILURE path was driven, of writes seen
+ *   executed  — app functions that ran, of app functions loaded
+ *
+ * Union-only. A later drive can add coverage and never remove it, so the number only moves down when
+ * the app grows something nobody has covered yet — which is precisely what the ratchet is for.
+ */
+import { z } from 'zod';
+import type { FileSystemPort } from '../../memory/project/fs/fs-port.js';
+import type { CodeCoverage } from './code-coverage.js';
+export declare const CoverageLevel: {
+    readonly REACHED: "reached";
+    readonly TOUCHED: "touched";
+    readonly PROVED: "proved";
+    readonly COMPLETED: "completed";
+    readonly BRANCHED: "branched";
+    readonly EXECUTED: "executed";
+};
+export type CoverageLevel = (typeof CoverageLevel)[keyof typeof CoverageLevel];
+declare const LedgerSchema: z.ZodObject<{
+    routes: z.ZodObject<{
+        discovered: z.ZodArray<z.ZodString, "many">;
+        reached: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        reached: string[];
+        discovered: string[];
+    }, {
+        reached: string[];
+        discovered: string[];
+    }>;
+    controls: z.ZodObject<{
+        seen: z.ZodArray<z.ZodString, "many">;
+        touched: z.ZodArray<z.ZodString, "many">;
+        proved: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        proved: string[];
+        touched: string[];
+        seen: string[];
+    }, {
+        proved: string[];
+        touched: string[];
+        seen: string[];
+    }>;
+    journeys: z.ZodObject<{
+        completed: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        completed: string[];
+    }, {
+        completed: string[];
+    }>;
+    writes: z.ZodObject<{
+        seen: z.ZodArray<z.ZodString, "many">;
+        branched: z.ZodArray<z.ZodString, "many">;
+        unhandled: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        branched: string[];
+        seen: string[];
+        unhandled: string[];
+    }, {
+        branched: string[];
+        seen: string[];
+        unhandled: string[];
+    }>;
+    code: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        executed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        executed: boolean;
+    }, {
+        name: string;
+        executed: boolean;
+    }>>>;
+    /** Per file, when its code coverage was last taken. Absent in a ledger from before it existed. */
+    codeTaken: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    best: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    code: Record<string, Record<string, {
+        name: string;
+        executed: boolean;
+    }>>;
+    best: Record<string, number>;
+    routes: {
+        reached: string[];
+        discovered: string[];
+    };
+    controls: {
+        proved: string[];
+        touched: string[];
+        seen: string[];
+    };
+    journeys: {
+        completed: string[];
+    };
+    writes: {
+        branched: string[];
+        seen: string[];
+        unhandled: string[];
+    };
+    codeTaken: Record<string, number>;
+}, {
+    code: Record<string, Record<string, {
+        name: string;
+        executed: boolean;
+    }>>;
+    best: Record<string, number>;
+    routes: {
+        reached: string[];
+        discovered: string[];
+    };
+    controls: {
+        proved: string[];
+        touched: string[];
+        seen: string[];
+    };
+    journeys: {
+        completed: string[];
+    };
+    writes: {
+        branched: string[];
+        seen: string[];
+        unhandled: string[];
+    };
+    codeTaken?: Record<string, number> | undefined;
+}>;
+export type AppLedger = z.infer<typeof LedgerSchema>;
+/** What one producer contributes. Every part optional: a drive adds what it saw and nothing else. */
+export interface LedgerDelta {
+    routes?: Partial<AppLedger['routes']>;
+    controls?: Partial<AppLedger['controls']>;
+    journeys?: Partial<AppLedger['journeys']>;
+    writes?: Partial<AppLedger['writes']>;
+    code?: CodeCoverage;
+    /** When `code` was taken, so a file edited since reads as not measured rather than as covered. */
+    codeTakenAt?: number;
+}
+export interface LevelReport {
+    level: CoverageLevel;
+    covered: number;
+    /** Absent where no honest denominator exists. */
+    total?: number;
+    /** Absent when nothing was measured: 0 of 0 is not 100%. */
+    pct?: number;
+    missing: string[];
+    /** How many more are missing than `missing` names. */
+    missingOverflow?: number;
+}
+export declare function emptyLedger(): AppLedger;
+export declare function mergeLedger(into: AppLedger, delta: LedgerDelta): AppLedger;
+export declare function levelsOf(ledger: AppLedger): LevelReport[];
+/** The best percentage each level has reached, raised to today's where today is higher. */
+export declare function raiseBest(ledger: AppLedger): AppLedger;
+/**
+ * Today's levels become the best, so a drop someone decided to accept stops blocking. What was
+ * measured stays; only the bar moves, and only when asked (`reticle gate --accept-coverage`).
+ */
+export declare function acceptCurrent(ledger: AppLedger): AppLedger;
+/** Levels now below the best they ever reached — something new appeared and nothing covered it. */
+export declare function regressions(ledger: AppLedger): {
+    level: CoverageLevel;
+    was: number;
+    now: number;
+}[];
+/** Changed files the browser loaded and never ran a single function of. */
+export declare function unexecutedChanged(code: CodeCoverage, changed: readonly string[]): string[];
+/**
+ * Changed files whose coverage was last taken BEFORE they changed. Counts are kept per file across
+ * takes, so an edited file still carries the counts of the version before the edit, and "it ran"
+ * read from them is about code that no longer exists. A take with no recorded time is as old as
+ * any edit. A file with no modification time (deleted) has nothing left to run.
+ */
+export declare function staleChanged(ledger: AppLedger, changed: readonly string[], modifiedAt: (file: string) => number | undefined): string[];
+/** `.reticle/coverage.json`. Loads never throw: a bad file degrades to an empty ledger. */
+export declare class LedgerStore {
+    #private;
+    constructor(fs: FileSystemPort, root: string);
+    load(): Promise<AppLedger>;
+    /**
+     * Fold a delta in, raise the best, persist, and hand back the result. Under the file's lock: two
+     * sessions folding at once each loaded the same copy, and the later write discarded the other.
+     *
+     * ponytail: the lock is per daemon process. The CLI's `gate --accept-coverage` in another process
+     * can still race a fold; add a lock file if that ever shows up.
+     */
+    merge(delta: LedgerDelta): Promise<AppLedger>;
+    /** Accept today's levels as the best. Returns the drops that were accepted. */
+    acceptCurrent(): Promise<ReturnType<typeof regressions>>;
+}
+export {};

package/dist/features/exhaust/ledger.js

@@ -0,0 +1,252 @@
+/**
+ * The app-wide coverage ledger: what "everything" is, and how much of it has been proved.
+ *
+ * "Done" used to be the agent's opinion, which is the root of shallow verification: every rule it
+ * read pushed it to stop, and nothing it could read said what was left. This makes it a number per
+ * level, each with the missing items named, accumulated across every drive and every session.
+ *
+ * Six levels, each stricter than the last, and never averaged — an average is exactly how "the
+ * controls were clicked" hides "none of them were proved":
+ *
+ *   reached   — routes rendered, of routes discovered
+ *   touched   — controls acted on, of controls seen
+ *   proved    — controls with a `yes` verdict on a declared consequence, of controls seen
+ *   completed — journeys proved at their end (count only: there is no honest denominator)
+ *   branched  — writes whose FAILURE path was driven, of writes seen
+ *   executed  — app functions that ran, of app functions loaded
+ *
+ * Union-only. A later drive can add coverage and never remove it, so the number only moves down when
+ * the app grows something nobody has covered yet — which is precisely what the ratchet is for.
+ */
+import { dirname } from 'node:path';
+import { z } from 'zod';
+import { writeFileAtomic } from '../../memory/project/fs/write-atomic.js';
+import { withFileLock } from '../../memory/project/file-lock.js';
+import { reticleDirPaths } from '../../memory/project/dir/reticle-dir.js';
+export const CoverageLevel = {
+    REACHED: 'reached',
+    TOUCHED: 'touched',
+    PROVED: 'proved',
+    COMPLETED: 'completed',
+    BRANCHED: 'branched',
+    EXECUTED: 'executed',
+};
+const LEDGER_VERSION = 1;
+/** How many missing items a level names before it only counts them. */
+const MAX_MISSING = 50;
+const names = z.array(z.string());
+const LedgerSchema = z.object({
+    routes: z.object({ discovered: names, reached: names }),
+    controls: z.object({ seen: names, touched: names, proved: names }),
+    journeys: z.object({ completed: names }),
+    writes: z.object({ seen: names, branched: names, unhandled: names }),
+    code: z.record(z.record(z.object({ name: z.string(), executed: z.boolean() }))),
+    /** Per file, when its code coverage was last taken. Absent in a ledger from before it existed. */
+    codeTaken: z.record(z.number()).default({}),
+    best: z.record(z.number()),
+});
+export function emptyLedger() {
+    return {
+        routes: { discovered: [], reached: [] },
+        controls: { seen: [], touched: [], proved: [] },
+        journeys: { completed: [] },
+        writes: { seen: [], branched: [], unhandled: [] },
+        code: {},
+        codeTaken: {},
+        best: {},
+    };
+}
+const union = (a, b) => b === undefined ? [...a] : [...new Set([...a, ...b])];
+export function mergeLedger(into, delta) {
+    const code = { ...into.code };
+    const codeTaken = { ...into.codeTaken };
+    for (const [file, fns] of Object.entries(delta.code ?? {})) {
+        const merged = { ...(code[file] ?? {}) };
+        for (const [key, fn] of Object.entries(fns)) {
+            merged[key] = { name: fn.name, executed: fn.executed || true === merged[key]?.executed };
+        }
+        code[file] = merged;
+        if (delta.codeTakenAt !== undefined)
+            codeTaken[file] = delta.codeTakenAt;
+    }
+    // Reaching a route discovers it; touching or proving a control means it was seen.
+    const reached = union(into.routes.reached, delta.routes?.reached);
+    const touched = union(into.controls.touched, delta.controls?.touched);
+    const proved = union(into.controls.proved, delta.controls?.proved);
+    const branched = union(into.writes.branched, delta.writes?.branched);
+    return {
+        routes: {
+            discovered: union(union(into.routes.discovered, delta.routes?.discovered), reached),
+            reached,
+        },
+        controls: {
+            seen: union(union(union(into.controls.seen, delta.controls?.seen), touched), proved),
+            touched: union(touched, proved),
+            proved,
+        },
+        journeys: { completed: union(into.journeys.completed, delta.journeys?.completed) },
+        writes: {
+            seen: union(union(into.writes.seen, delta.writes?.seen), branched),
+            branched,
+            unhandled: union(into.writes.unhandled, delta.writes?.unhandled),
+        },
+        code,
+        codeTaken,
+        best: { ...into.best },
+    };
+}
+function level(name, universe, covered) {
+    const done = new Set(covered);
+    const missing = universe.filter((item) => !done.has(item));
+    const count = universe.length - missing.length;
+    return {
+        level: name,
+        covered: count,
+        total: universe.length,
+        ...(0 === universe.length ? {} : { pct: Math.round((100 * count) / universe.length) }),
+        missing: missing.slice(0, MAX_MISSING),
+        ...(missing.length > MAX_MISSING ? { missingOverflow: missing.length - MAX_MISSING } : {}),
+    };
+}
+/** Functions are identified by file + key (names repeat) and reported by file + name. */
+function executedLevel(code) {
+    const fns = Object.entries(code).flatMap(([file, map]) => Object.values(map).map((fn) => ({ label: `${file}: ${fn.name}`, executed: fn.executed })));
+    const missing = fns.filter((fn) => !fn.executed).map((fn) => fn.label);
+    const covered = fns.length - missing.length;
+    return {
+        level: CoverageLevel.EXECUTED,
+        covered,
+        total: fns.length,
+        ...(0 === fns.length ? {} : { pct: Math.round((100 * covered) / fns.length) }),
+        missing: missing.slice(0, MAX_MISSING),
+        ...(missing.length > MAX_MISSING ? { missingOverflow: missing.length - MAX_MISSING } : {}),
+    };
+}
+export function levelsOf(ledger) {
+    return [
+        level(CoverageLevel.REACHED, ledger.routes.discovered, ledger.routes.reached),
+        level(CoverageLevel.TOUCHED, ledger.controls.seen, ledger.controls.touched),
+        level(CoverageLevel.PROVED, ledger.controls.seen, ledger.controls.proved),
+        { level: CoverageLevel.COMPLETED, covered: ledger.journeys.completed.length, missing: [] },
+        level(CoverageLevel.BRANCHED, ledger.writes.seen, ledger.writes.branched),
+        executedLevel(ledger.code),
+    ];
+}
+/** The best percentage each level has reached, raised to today's where today is higher. */
+export function raiseBest(ledger) {
+    const best = { ...ledger.best };
+    for (const l of levelsOf(ledger)) {
+        if (l.pct !== undefined && l.pct > (best[l.level] ?? -1))
+            best[l.level] = l.pct;
+    }
+    return { ...ledger, best };
+}
+/**
+ * Today's levels become the best, so a drop someone decided to accept stops blocking. What was
+ * measured stays; only the bar moves, and only when asked (`reticle gate --accept-coverage`).
+ */
+export function acceptCurrent(ledger) {
+    const best = {};
+    for (const l of levelsOf(ledger))
+        if (l.pct !== undefined)
+            best[l.level] = l.pct;
+    return { ...ledger, best };
+}
+/** Levels now below the best they ever reached — something new appeared and nothing covered it. */
+export function regressions(ledger) {
+    const out = [];
+    for (const l of levelsOf(ledger)) {
+        const was = ledger.best[l.level];
+        if (l.pct !== undefined && was !== undefined && l.pct < was)
+            out.push({ level: l.level, was, now: l.pct });
+    }
+    return out;
+}
+/**
+ * The ledger's name for a changed file. Matched by path suffix, the same way the flow index matches,
+ * so a repo-relative change finds a served `src/...` path.
+ */
+function servedAs(code, file) {
+    return Object.keys(code).find((served) => file === served || file.endsWith(`/${served}`) || served.endsWith(`/${file}`));
+}
+/** Changed files the browser loaded and never ran a single function of. */
+export function unexecutedChanged(code, changed) {
+    return changed.filter((file) => {
+        const served = servedAs(code, file);
+        if (served === undefined)
+            return false;
+        const fns = Object.values(code[served] ?? {});
+        return fns.length > 0 && fns.every((fn) => !fn.executed);
+    });
+}
+/**
+ * Changed files whose coverage was last taken BEFORE they changed. Counts are kept per file across
+ * takes, so an edited file still carries the counts of the version before the edit, and "it ran"
+ * read from them is about code that no longer exists. A take with no recorded time is as old as
+ * any edit. A file with no modification time (deleted) has nothing left to run.
+ */
+export function staleChanged(ledger, changed, modifiedAt) {
+    return changed.filter((file) => {
+        const served = servedAs(ledger.code, file);
+        const modified = modifiedAt(file);
+        if (served === undefined || modified === undefined)
+            return false;
+        const taken = ledger.codeTaken[served];
+        return taken === undefined || modified > taken;
+    });
+}
+/** `.reticle/coverage.json`. Loads never throw: a bad file degrades to an empty ledger. */
+export class LedgerStore {
+    #fs;
+    #path;
+    constructor(fs, root) {
+        this.#fs = fs;
+        this.#path = reticleDirPaths(root).coverage;
+    }
+    async load() {
+        let text;
+        try {
+            text = await this.#fs.readFile(this.#path);
+        }
+        catch (error) {
+            if (this.#fs.isNotFound(error))
+                return emptyLedger();
+            throw error;
+        }
+        try {
+            const parsed = z
+                .object({ version: z.literal(LEDGER_VERSION), ledger: LedgerSchema })
+                .safeParse(JSON.parse(text));
+            return parsed.success ? parsed.data.ledger : emptyLedger();
+        }
+        catch {
+            return emptyLedger();
+        }
+    }
+    /**
+     * Fold a delta in, raise the best, persist, and hand back the result. Under the file's lock: two
+     * sessions folding at once each loaded the same copy, and the later write discarded the other.
+     *
+     * ponytail: the lock is per daemon process. The CLI's `gate --accept-coverage` in another process
+     * can still race a fold; add a lock file if that ever shows up.
+     */
+    merge(delta) {
+        return withFileLock(this.#path, async () => this.#save(raiseBest(mergeLedger(await this.load(), delta))));
+    }
+    /** Accept today's levels as the best. Returns the drops that were accepted. */
+    acceptCurrent() {
+        return withFileLock(this.#path, async () => {
+            const ledger = await this.load();
+            const accepted = regressions(ledger);
+            if (accepted.length > 0)
+                await this.#save(acceptCurrent(ledger));
+            return accepted;
+        });
+    }
+    async #save(next) {
+        await this.#fs.mkdir(dirname(this.#path));
+        const body = `${JSON.stringify({ version: LEDGER_VERSION, ledger: next })}\n`;
+        await writeFileAtomic(this.#fs, this.#path, body);
+        return next;
+    }
+}

package/dist/features/exhaust/session-fold.d.ts

@@ -0,0 +1,31 @@
+/**
+ * One session's evidence, as a contribution to the coverage ledger.
+ *
+ * Pure over what the caller read: the controls on the page, the labels the session drove and proved,
+ * where it is, and the events it holds. The ledger does the accumulating; this only says what one
+ * session saw.
+ */
+import { type ReticleEvent } from '@reticlehq/core';
+import type { LedgerDelta } from './ledger.js';
+/**
+ * `POST /api/orders/:id/refund` for a mutating request, else undefined. Ids are collapsed so the
+ * refund of order 41 and of order 42 are one endpoint with one failure path to drive, not two.
+ */
+export declare function writeKeyOf(event: ReticleEvent): string | undefined;
+/**
+ * The ledger's identity for a control: the snapshot label, with numbers collapsed. The rows of a
+ * table — `button "Delete row 12"` — are one control to cover, not five hundred, which is what keeps
+ * `touched` meaningful on any page with a list.
+ */
+export declare function controlKey(label: string): string;
+export declare function sessionDelta(input: {
+    seen: readonly string[];
+    acted: Iterable<string>;
+    proved: Iterable<string>;
+    url?: string;
+    events: readonly ReticleEvent[];
+}): LedgerDelta;
+/** An error the page threw or logged — a fault whatever the screen shows. */
+export declare function isConsoleError(e: ReticleEvent): boolean;
+/** Requests that answered at or above `floor`. */
+export declare function failedRequests(events: ReticleEvent[], floor: number): ReticleEvent[];

package/dist/features/exhaust/session-fold.js

@@ -0,0 +1,79 @@
+/**
+ * One session's evidence, as a contribution to the coverage ledger.
+ *
+ * Pure over what the caller read: the controls on the page, the labels the session drove and proved,
+ * where it is, and the events it holds. The ledger does the accumulating; this only says what one
+ * session saw.
+ */
+import { EventType, MUTATING_METHODS, asNumber, asString, } from '@reticlehq/core';
+import { routeFromUrl, routesFromEvents } from '../../memory/project/learned-routes.js';
+/** A path segment that is a record id rather than part of the endpoint's name. */
+const ID_SEGMENT = /^(?:\d+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{24,})$/i;
+/**
+ * `POST /api/orders/:id/refund` for a mutating request, else undefined. Ids are collapsed so the
+ * refund of order 41 and of order 42 are one endpoint with one failure path to drive, not two.
+ */
+export function writeKeyOf(event) {
+    if (EventType.NET_REQUEST !== event.type)
+        return undefined;
+    const method = asString(event.data['method'])?.toUpperCase();
+    const url = asString(event.data['url']);
+    if (method === undefined || url === undefined || !MUTATING_METHODS.includes(method))
+        return undefined;
+    let path;
+    try {
+        path = new URL(url, 'http://localhost').pathname;
+    }
+    catch {
+        return undefined;
+    }
+    const named = path
+        .split('/')
+        .map((segment) => (ID_SEGMENT.test(segment) ? ':id' : segment))
+        .join('/');
+    return `${method} ${named}`;
+}
+/**
+ * The ledger's identity for a control: the snapshot label, with numbers collapsed. The rows of a
+ * table — `button "Delete row 12"` — are one control to cover, not five hundred, which is what keeps
+ * `touched` meaningful on any page with a list.
+ */
+export function controlKey(label) {
+    const bare = label.replace(/^\s*-\s*/, '').replace(/\s*\(ref=e\d+\)/, '');
+    // Role and accessible name only. Attributes are the control's momentary STATE — the value typed
+    // into it, whether it has focus — and keying on them made one control several, and every
+    // keystroke a new page state. Found by driving the fixture.
+    const identity = /^(\S+(?:\s+"(?:[^"\\]|\\.)*")?)/.exec(bare)?.[1] ?? bare;
+    return identity.replace(/\d+/g, '#').trim();
+}
+export function sessionDelta(input) {
+    const here = input.url === undefined ? undefined : routeFromUrl(input.url);
+    const reached = [
+        ...new Set([...(here === undefined ? [] : [here]), ...routesFromEvents(input.events)]),
+    ];
+    const writes = [
+        ...new Set(input.events.map(writeKeyOf).filter((k) => k !== undefined)),
+    ];
+    return {
+        routes: { reached },
+        controls: {
+            seen: [...new Set([...input.seen].map(controlKey))],
+            touched: [...new Set([...input.acted].map(controlKey))],
+            proved: [...new Set([...input.proved].map(controlKey))],
+        },
+        writes: { seen: writes },
+    };
+}
+/** An error the page threw or logged — a fault whatever the screen shows. */
+export function isConsoleError(e) {
+    return e.type === EventType.CONSOLE_ERROR || e.type === EventType.ERROR_UNCAUGHT;
+}
+/** Requests that answered at or above `floor`. */
+export function failedRequests(events, floor) {
+    return events.filter((e) => {
+        if (e.type !== EventType.NET_REQUEST)
+            return false;
+        const status = asNumber(e.data['status']);
+        return status !== undefined && status >= floor;
+    });
+}

package/dist/features/exhaust/session-port.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A live session, as the explorer's port.
+ *
+ * The one hard part is that a full page load REPLACES the session: the SDK reconnects under the
+ * same id (sessionStorage keeps it) but as a new object, and a command in flight on the old one is
+ * rejected. So every call reads the CURRENT session, and anything that may have navigated waits for
+ * the successor before it answers — the same wait `navigate { reload }` does.
+ */
+import { type CommandResult, type ReticleEvent } from '@reticlehq/core';
+import type { ExplorePort } from './explorer.js';
+export interface PortSession {
+    readonly id: string;
+    readonly url: string;
+    command(name: string, args?: Record<string, unknown>): Promise<CommandResult>;
+    elapsed(): number;
+    eventsSince(cursor: number): ReticleEvent[];
+    beginAction?(tool: string, args: Record<string, unknown>): unknown;
+    finishAction?(): void;
+}
+export declare function sessionPort(input: {
+    sessions: {
+        get(id: string): PortSession | undefined;
+    };
+    start: PortSession;
+    startUrl: string;
+    settleMs: number;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+    setMocks?: (sessionUrl: string, rules: {
+        urlContains: string;
+        method?: string;
+        abort?: boolean;
+    }[]) => Promise<boolean>;
+}): ExplorePort & {
+    current(): PortSession;
+};