@reticlehq/server 3.3.0 → 3.5.0

package/dist/language/flows/flows.js

@@ -1,14 +1,15 @@
 import { asFlowName, asProjectId, } from '@reticlehq/core';
 import { REDACTED_FILL } from './fields/flow-secret-field.js';
-export { REDACTED_FILL } from './fields/flow-secret-field.js';
+export { REDACTED_FILL, secretEnvKey } from './fields/flow-secret-field.js';
 import { safeProjectId } from './flow-result.js';
 import { changeInPlace } from './narrow-write.js';
-import { AnchorKind, DEGRADED_ANCHOR_ROLE, FLOW_FILE_VERSION, FlowErrorCode, FlowFileSchema, FlowStepTool, QueryBy, defaultIsSensitiveKey, } from '@reticlehq/core';
+import { AnchorKind, DEGRADED_ANCHOR_ROLE, FLOW_FILE_VERSION, flowFileVersionFor, FlowErrorCode, FlowFileSchema, FlowStepTool, QueryBy, defaultIsSensitiveKey, } from '@reticlehq/core';
 import { ReticleTool } from '@reticlehq/core';
 import { asRecord, asString } from '@reticlehq/core';
 import { applyHealChanges } from './heal.js';
 import { withLearnedSources } from './learned-sources.js';
 import { flowIntentGap, linkFlowIntent } from './flow-intent.js';
+import { journeyFingerprint, journeyName, mergeJourney, routeClaims } from './flow-journey.js';
 import { IntentStore } from '../../memory/intent/intent-store.js';
 import { flowDir, flowParentDir, flowPath, reticleDirPaths, isValidFlowName, } from '../../memory/project/dir/reticle-dir.js';
 import { describeFlowZodFailure, parseFlowFileText } from './flow-expect-grammar.js';
@@ -164,6 +165,14 @@ function buildStep(tool, anchor, action, args, degraded) {
  * NEVER silently dropped. ACT_SEQUENCE recurses over its sub-steps.
  */
 export function recordedStepToFlowStep(step) {
+    const out = anchoredStep(step);
+    if (step.page !== undefined)
+        out.page = step.page;
+    if (step.endPage !== undefined && step.endPage !== step.page)
+        out.endPage = step.endPage;
+    return out;
+}
+function anchoredStep(step) {
     if (step.invoke !== undefined) {
         // An invocation drives nothing: no action, no args, and an anchor only because every step
         // carries one. Falling through to the action path below would give it an `action` and a
@@ -237,7 +246,8 @@ export class FlowStore {
      * of them produces byte-identical on-disk content (locked by the byte-stability tests).
      */
     #serialize(flow) {
-        return `${JSON.stringify(flow, null, JSON_INDENT)}\n`;
+        const stamped = { ...flow, version: flowFileVersionFor(flow) };
+        return `${JSON.stringify(stamped, null, JSON_INDENT)}\n`;
     }
     /**
      * Register the flow's business goal in the intent ledger and stamp the row's id onto the flow.
@@ -267,16 +277,8 @@ export class FlowStore {
             ...(gap === undefined ? {} : { intentGap: gap }),
         };
     }
-    /**
-     * Convert a CompiledProgram (testid-normalized) into an anchored, on-disk flow + write it.
-     * Optionally fold structured annotations (per-step expect, dynamic[], success) onto
-     * the flow before writing. Omitting `annotations` reproduces the same bytes.
-     */
-    async save(program, annotations, projectId) {
-        if (!isValidFlowName(program.name)) {
-            return { ok: false, code: FlowErrorCode.INVALID_NAME };
-        }
-        const pid = safeProjectId(projectId);
+    /** The on-disk flow a compiled recording becomes, before anything is written. */
+    #build(program, annotations, pid) {
         const steps = program.steps.map(recordedStepToFlowStep);
         const base = {
             version: FLOW_FILE_VERSION,
@@ -295,11 +297,85 @@ export class FlowStore {
              */
             ...(program.startPath === undefined ? {} : { startPath: program.startPath }),
         };
-        const flow = await this.#linkIntent(withAnnotations(base, annotations));
+        const intent = program.steps.find((step) => step.intent !== undefined)?.intent;
+        const annotated = withAnnotations(base, annotations);
+        return {
+            ...annotated,
+            // The action's own intent, when nobody annotated the flow — see RecordedStep.intent.
+            ...(annotated.intent === undefined && intent !== undefined ? { intent } : {}),
+            ...routeClaims(annotated.startPath, annotated.steps),
+            ...(program.author === undefined ? {} : { author: program.author }),
+        };
+    }
+    /**
+     * Convert a CompiledProgram (testid-normalized) into an anchored, on-disk flow + write it.
+     * Optionally fold structured annotations (per-step expect, dynamic[], success) onto
+     * the flow before writing. Omitting `annotations` reproduces the same bytes.
+     */
+    async save(program, annotations, projectId) {
+        if (!isValidFlowName(program.name)) {
+            return { ok: false, code: FlowErrorCode.INVALID_NAME };
+        }
+        const pid = safeProjectId(projectId);
+        const base = this.#build(program, annotations, pid);
+        const flow = await this.#linkIntent(base);
         await this.#fs.mkdir(flowParentDir(this.#root, program.name, pid));
         await this.#fs.writeFile(flowPath(this.#root, program.name, pid), this.#serialize(flow));
         return { ok: true, value: this.#summary(flow) };
     }
+    /**
+     * Save a flow the session drove, folded into any saved copy of the same journey.
+     *
+     * Every session saves its own drive, so one journey arrived as a near-copy per session. Flows
+     * under `prefix` (the auto-saved ones — a hand-named flow is never merged or removed) that start
+     * on the same page and take the same steps become ONE file: the oldest keeps its name, the others
+     * fill its gaps and are removed. The same scan collapses copies saved before this existed.
+     */
+    async saveJourney(program, projectId, prefix) {
+        if (!isValidFlowName(program.name))
+            return { ok: false, code: FlowErrorCode.INVALID_NAME };
+        const pid = safeProjectId(projectId);
+        const fresh = this.#build(program, undefined, pid);
+        const saved = [];
+        for (const name of (await this.list(pid)).filter((n) => n.startsWith(prefix))) {
+            const loaded = await this.load(name, pid);
+            if (loaded.ok)
+                saved.push(loaded.value);
+        }
+        const byPrint = new Map();
+        for (const flow of saved) {
+            const print = journeyFingerprint(flow);
+            byPrint.set(print, [...(byPrint.get(print) ?? []), flow]);
+        }
+        const print = journeyFingerprint(fresh);
+        const taken = new Map(saved.map((flow) => [flow.name, journeyFingerprint(flow)]));
+        const named = { ...fresh, name: journeyName(fresh.name, print, taken) };
+        byPrint.set(print, [...(byPrint.get(print) ?? []), named]);
+        let result = named;
+        for (const [groupPrint, group] of byPrint) {
+            if (group.length < 2 && groupPrint !== print)
+                continue;
+            const [kept, ...rest] = [...group].sort((a, b) => a.createdAt - b.createdAt);
+            if (kept === undefined)
+                continue;
+            const merged = await this.#linkIntent(rest.reduce(mergeJourney, kept));
+            await this.#writeInPlace(merged, pid);
+            for (const dropped of rest) {
+                if (dropped.name !== merged.name && dropped !== named)
+                    await this.remove(dropped.name, pid);
+            }
+            if (groupPrint === print)
+                result = merged;
+        }
+        return { ok: true, value: this.#summary(result) };
+    }
+    /** Write a flow where it already lives, or into its project's directory when it is new. */
+    async #writeInPlace(flow, pid) {
+        const name = asFlowName(flow.name);
+        const path = (await this.#resolveReadPath(name, pid)) ?? flowPath(this.#root, name, pid);
+        await this.#fs.mkdir(flowParentDir(this.#root, name, pid));
+        await this.#fs.writeFile(path, this.#serialize(flow));
+    }
     /**
      * Persist an already-anchored FlowFile captured in-page (no recompilation). The
      * browser resolved every semantic anchor at capture time; here we only validate the name +

package/dist/language/flows/recording/replay-halt.js

@@ -21,7 +21,9 @@ export function haltedFrom(results, total) {
         return undefined;
     if (last.ok && last.drift === undefined)
         return undefined;
-    const notAttempted = total - results.length;
+    // From the step's own index, not the count of results: a resumed replay does not report its setup
+    // prefix, so the results array no longer starts at step 0.
+    const notAttempted = total - (last.step + 1);
     // A failure on the FINAL step is not a halt: nothing was left to attempt, and `notAttempted: 0`
     // would send a reader looking for steps that do not exist.
     if (notAttempted <= 0)

package/dist/language/flows/recording/tape/recordings.d.ts

@@ -1,4 +1,4 @@
-import { type Predicate } from '@reticlehq/core';
+import { type FlowFile, type Predicate } from '@reticlehq/core';
 /** One captured agent action, normalized for replay. */
 export interface RecordedStep {
     /** ReticleTool.ACT | ReticleTool.ACT_SEQUENCE */
@@ -27,6 +27,12 @@ export interface RecordedStep {
      * `invoke` first and treats the step as a call.
      */
     invoke?: string;
+    /** The page this step ran on. Written to the saved step (unlike `route`, which cuts journeys). */
+    page?: string;
+    /** The page it ended on once it settled — see `markEnded`. */
+    endPage?: string;
+    /** Why the agent took this step: the `intent` it declared on the action. Names the saved flow. */
+    intent?: string;
 }
 interface ActiveRecording {
     cursor: number;
@@ -59,6 +65,8 @@ export interface CompiledProgram {
      * format change.
      */
     routes?: string[];
+    /** Who made it — see FlowFile.author. Stamped by the caller that knows. */
+    author?: FlowFile['author'];
 }
 /**
  * The `tool` written on an invocation step — core's constant, re-exported for this module's callers.
@@ -105,6 +113,27 @@ export declare class RecordingStore {
      * anything should not carry an empty tape, and "did anything happen at all" stays answerable.
      */
     capture(step: RecordedStep, route?: string): void;
+    /**
+     * Add a consequence to the last captured step of every active recording.
+     *
+     * A separate `reticle_assert` after an act is how an agent proves what the act did, and it never
+     * reached the recorder — only the act tools called `capture` — so the flow kept the click and lost
+     * the proof. What the step already declared is kept; the new check joins it under `allOf`.
+     */
+    attachExpect(expect: Predicate): void;
+    /**
+     * A navigation happened. Navigating records no step, so until the next one is captured, a check
+     * proved now is about the page the navigation opened, not about the last step — and kept on that
+     * step, replay would ask it right after the click, of a page it was never true on.
+     */
+    markNavigated(): void;
+    /**
+     * The page the step just captured ended on, once its action settled.
+     *
+     * Fills only a step that has none, so calling it after an action that captured nothing leaves the
+     * previous step's own answer alone.
+     */
+    markEnded(page: string | undefined): void;
     /**
      * Returns the active recording (cursor + steps) and clears it, or undefined if not recording.
      *

package/dist/language/flows/recording/tape/recordings.js

@@ -1,4 +1,4 @@
-import { FlowStepTool } from '@reticlehq/core';
+import { FlowStepTool, PredicateKind } from '@reticlehq/core';
 /**
  * The `tool` written on an invocation step — core's constant, re-exported for this module's callers.
  *
@@ -31,6 +31,8 @@ const AMBIENT_STEP_CAP = 400;
 export class RecordingStore {
     #active = new Map();
     #compiled = new Map();
+    /** A navigation came after the last captured step — see markNavigated. */
+    #navigatedSinceStep = false;
     start(name, cursor, startPath) {
         const openedOver = new Map();
         for (const [outer, rec] of this.#active)
@@ -67,6 +69,7 @@ export class RecordingStore {
      * anything should not carry an empty tape, and "did anything happen at all" stays answerable.
      */
     capture(step, route) {
+        this.#navigatedSinceStep = false;
         if (!this.#active.has(AMBIENT_RECORDING)) {
             this.#active.set(AMBIENT_RECORDING, {
                 cursor: 0,
@@ -83,12 +86,63 @@ export class RecordingStore {
             // opened on purpose is not capped — they said when it starts and they say when it stops.
             if (AMBIENT_RECORDING === name && rec.steps.length >= AMBIENT_STEP_CAP)
                 continue;
+            // A step nobody marked ended where the next one began.
+            const previous = rec.steps.at(-1);
+            if (previous !== undefined && previous.endPage === undefined && step.page !== undefined) {
+                previous.endPage = step.page;
+            }
             // The route rides on the AMBIENT tape only: a recording somebody opened deliberately is
             // already one journey by construction, and stamping a route on its steps would change what a
             // deliberate recording contains.
             rec.steps.push(AMBIENT_RECORDING === name && route !== undefined ? { ...step, route } : step);
         }
     }
+    /**
+     * Add a consequence to the last captured step of every active recording.
+     *
+     * A separate `reticle_assert` after an act is how an agent proves what the act did, and it never
+     * reached the recorder — only the act tools called `capture` — so the flow kept the click and lost
+     * the proof. What the step already declared is kept; the new check joins it under `allOf`.
+     */
+    attachExpect(expect) {
+        if (this.#navigatedSinceStep)
+            return;
+        for (const rec of this.#active.values()) {
+            const last = rec.steps.at(-1);
+            if (last === undefined)
+                continue;
+            const held = last.expect;
+            last.expect =
+                held === undefined
+                    ? expect
+                    : PredicateKind.ALL_OF === held.kind
+                        ? { ...held, predicates: [...held.predicates, expect] }
+                        : { kind: PredicateKind.ALL_OF, predicates: [held, expect] };
+        }
+    }
+    /**
+     * A navigation happened. Navigating records no step, so until the next one is captured, a check
+     * proved now is about the page the navigation opened, not about the last step — and kept on that
+     * step, replay would ask it right after the click, of a page it was never true on.
+     */
+    markNavigated() {
+        this.#navigatedSinceStep = true;
+    }
+    /**
+     * The page the step just captured ended on, once its action settled.
+     *
+     * Fills only a step that has none, so calling it after an action that captured nothing leaves the
+     * previous step's own answer alone.
+     */
+    markEnded(page) {
+        if (page === undefined)
+            return;
+        for (const rec of this.#active.values()) {
+            const last = rec.steps.at(-1);
+            if (last !== undefined && last.endPage === undefined)
+                last.endPage = page;
+        }
+    }
     /**
      * Returns the active recording (cursor + steps) and clears it, or undefined if not recording.
      *

package/dist/language/flows/replay.d.ts

@@ -1,3 +1,4 @@
+import { type Predicate } from '@reticlehq/core';
 import { type CommandResult } from '@reticlehq/core';
 import type { RecordedStep, CompiledProgram } from './recording/tape/recordings.js';
 import type { Session } from '../../portal/session/session.js';
@@ -27,6 +28,13 @@ export declare function queryRefs(result: CommandResult): string[];
  * an empty box fails identically and tells the reader nothing.
  */
 export declare function replayActionArgs(value: unknown, confirmDangerous?: boolean, field?: string): Record<string, unknown>;
+/**
+ * The pathname of a session's live url, or undefined when it has none yet.
+ *
+ * Pathname rather than the whole url, because that is what `startPath` is compared against and what
+ * a hash-routed app makes meaningless in the document location — see routeOfEvent.
+ */
+export declare function pathOf(url: string | undefined): string | undefined;
 /**
  * Capture an act into every in-flight recording, or do nothing when none is running.
  *
@@ -40,6 +48,17 @@ export declare function captureAct(recordings: {
 }, args: Record<string, unknown>, res: unknown, 
 /** Where this step ran, so the ambient tape can be cut into journeys. See RecordedStep.route. */
 route?: string): void;
+/**
+ * Capture an act_and_wait once its verdict is known, keeping `until` as the step's expectation only
+ * on a yes. Recorded before the verdict, a step kept an `until` that came back `no` or `no-fault` —
+ * a regression test asserting something never once observed to hold because of the action. The
+ * action itself is always recorded: it happened, and replay needs it to reach the next step.
+ */
+export declare function captureVerdictedAct(recordings: Parameters<typeof captureAct>[0], args: Record<string, unknown>, res: unknown, route: string | undefined, verified: string | undefined): void;
+/** Fold a PASSING standalone assertion into the step it proved. See RecordingStore.attachExpect. */
+export declare function captureAssertion(recordings: {
+    attachExpect: (expect: Predicate) => void;
+}, raw: unknown): void;
 /**
  * Compile a single reticle_act invocation into a normalized RecordedStep using the action result. Anchor
  * priority mirrors synthesizeAnchor: a data-testid is the gold standard; failing that, the element's

package/dist/language/flows/replay.js

@@ -1,5 +1,5 @@
 import { REDACTED_FILL, secretEnvKey } from './fields/flow-secret-field.js';
-import { FlowPredicateSchema } from '@reticlehq/core';
+import { FlowPredicateSchema, Verified } from '@reticlehq/core';
 import { DANGEROUS_ACTION_CONFIRM_ARG, ReticleCommand, QueryBy, } from '@reticlehq/core';
 import { ReticleTool } from '@reticlehq/core';
 import { formatStepAddress } from 'open-verification';
@@ -71,6 +71,22 @@ function sourceFromResult(res) {
         out['column'] = source['column'];
     return out;
 }
+/**
+ * The pathname of a session's live url, or undefined when it has none yet.
+ *
+ * Pathname rather than the whole url, because that is what `startPath` is compared against and what
+ * a hash-routed app makes meaningless in the document location — see routeOfEvent.
+ */
+export function pathOf(url) {
+    if (url === undefined)
+        return undefined;
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Capture an act into every in-flight recording, or do nothing when none is running.
  *
@@ -87,20 +103,40 @@ route) {
     // — "recording is a property of the system rather than a rule an agent has to remember" — was true
     // about the intent and false about the code, and every drive nobody wrapped by hand was discarded.
     //
-    // That is the whole supply of regression tests this product could have had for free: the corpus
-    // measures 3 of 33 flows mutation-testable and 6 of 112 steps declaring a consequence, and a drive
-    // that is never recorded cannot contribute to either.
+    // That is the whole supply of regression tests this product could have had for free: few saved
+    // flows are mutation-testable and few steps declare a consequence, and a drive that is never
+    // recorded cannot contribute to either.
     const step = compileActStep(args, res);
     // Keep the assertion the agent actually made. `act_and_wait { until }` IS the agent saying what
     // success means — the large majority of calls carry one — and dropping it produced a flow graded
     // "assertion-free: it will pass even if the feature is broken", which is the regression-suite
-    // story failing at its last step. Only kinds FlowExpect can express survive; see
-    // predicate-to-expect.ts.
+    // story failing at its last step. See enforceableExpect below.
     const expect = enforceableExpect(args['until'] ?? args['predicate']);
     if (expect !== undefined)
         step.expect = expect;
+    if (route !== undefined)
+        step.page = route;
+    const intent = asString(args['intent'])?.trim();
+    if (intent !== undefined && intent.length > 0)
+        step.intent = intent;
     recordings.capture(step, route);
 }
+/**
+ * Capture an act_and_wait once its verdict is known, keeping `until` as the step's expectation only
+ * on a yes. Recorded before the verdict, a step kept an `until` that came back `no` or `no-fault` —
+ * a regression test asserting something never once observed to hold because of the action. The
+ * action itself is always recorded: it happened, and replay needs it to reach the next step.
+ */
+export function captureVerdictedAct(recordings, args, res, route, verified) {
+    const { until: _until, predicate: _predicate, ...unproved } = args;
+    captureAct(recordings, Verified.YES === verified ? args : unproved, res, route);
+}
+/** Fold a PASSING standalone assertion into the step it proved. See RecordingStore.attachExpect. */
+export function captureAssertion(recordings, raw) {
+    const expect = enforceableExpect(raw);
+    if (expect !== undefined)
+        recordings.attachExpect(expect);
+}
 /**
  * A declared predicate, as a recorded expectation — or nothing.
  *

package/dist/language/flows/verify-change-tools.js

@@ -172,9 +172,12 @@ export const VERIFY_CHANGE_TOOLS = [
             const extra = await inspectAfterReplay(deps, args, cursor);
             if (extra.contradictions.length > 0) {
                 const kinds = extra.contradictions.map((c) => c.kind).join(', ');
+                const earned = attributedFailures(affected, unknownProvenance).length > 0;
                 return {
-                    verified: Verified.NO,
-                    because: `every covering flow passed, but channels disagreed during the replay (${kinds}) — a green suite over a failed write is the false green worth looking at${provenanceNote}`,
+                    verified: earned ? Verified.NO : Verified.UNKNOWN,
+                    because: earned
+                        ? `every covering flow passed, but channels disagreed during the replay (${kinds}) — a green suite over a failed write is the false green worth looking at${provenanceNote}`
+                        : `channels disagreed during the replay (${kinds}), but Reticle cannot tell which sources any of the flows that ran cover (${affected.join(', ')}), so this says nothing about the files you changed. Drive the change directly; the drive is saved as a flow with its sources stamped`,
                     changedFiles,
                     flowsRun: affected,
                     suite,

package/dist/launch-chromium.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The ONE place a Reticle-owned Chromium is launched — the pooled lease browser
+ * (`playwright-launcher`) and the drive browser (`real-input`) both come through here.
+ *
+ * Why it is more than `chromium.launch`: on a fresh machine the `playwright` package is present
+ * (npx pulled it in with the server) but its browser build is not, because that is a separate
+ * ~150 MiB download nobody told the user about. Every lease, `reticle verify`, `open` and `drive`
+ * then refused with "Chromium is not installed for Playwright. Run: npx playwright@… install
+ * chromium" — the first run stopped on a human step a machine could do. Most machines already have
+ * a Chrome or an Edge, and Playwright drives either through `channel`, so that is tried before any
+ * download; only a machine with neither gets the pinned install, run for them and announced.
+ *
+ * Announcements go to STDERR, never stdout: `reticle mcp` speaks JSON-RPC on stdout and one stray
+ * line there corrupts the client's stream.
+ */
+import { type ChromiumLaunchOptions } from './chromium-launch-options.js';
+import { type ChromiumProbe } from './command/cli/doctor/browser/chromium-hint.js';
+/** The installed-browser channels Playwright can drive in place of its own build. */
+export declare const ChromiumChannel: {
+    readonly CHROME: "chrome";
+    readonly MSEDGE: "msedge";
+};
+export type ChromiumChannel = (typeof ChromiumChannel)[keyof typeof ChromiumChannel];
+export declare const CHANNEL_LABEL: Record<ChromiumChannel, string>;
+/** Candidate executable paths for a channel on this platform; empty where it is not installable. */
+export declare function channelExecutableCandidates(channel: ChromiumChannel, platform: NodeJS.Platform, env: NodeJS.ProcessEnv): string[];
+/** The first installed Chrome/Edge on this machine, or undefined. Looks only; installs nothing. */
+export declare function findInstalledChannel(deps: Pick<ChromiumTargetDeps, 'exists' | 'platform' | 'env'>): ChromiumChannel | undefined;
+/** Everything the resolver touches, injected so it runs against a fake machine in tests. */
+export interface ChromiumTargetDeps {
+    /** Where the bundled playwright expects its Chromium build. */
+    executablePath: () => string;
+    exists: (path: string) => boolean;
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    /** Run the pinned Chromium install; resolves true when it succeeded. */
+    install: () => Promise<boolean>;
+    /** A progress line for a human — stderr in production. */
+    announce: (line: string) => void;
+}
+/** Which browser to launch: the bundled build (no channel), an installed channel, or none at all. */
+export type ChromiumTarget = {
+    found: true;
+    channel?: ChromiumChannel;
+} | {
+    found: false;
+};
+/**
+ * Decide which browser a launch will use, installing the pinned Chromium only as the last resort.
+ * Order: bundled build on disk → installed Chrome → installed Edge → install, then bundled.
+ */
+export declare function resolveChromiumTarget(deps: ChromiumTargetDeps): Promise<ChromiumTarget>;
+/** The subset of Playwright's `BrowserType` this file needs, so tests can pass a fake. */
+export interface LaunchableChromium<B> {
+    executablePath: () => string;
+    launch: (options: ChromiumLaunchOptions) => Promise<B>;
+}
+/**
+ * A progress writer that says each distinct line once. The Chrome/Edge fallback line was written on
+ * every launch, and the pool launches per context, so one daemon repeated the same notice into the
+ * terminal of whoever started it.
+ */
+export declare function announceOnce(write: (line: string) => void): (line: string) => void;
+/**
+ * Launch a Chromium with the shared options, on whichever browser this machine can offer. When none
+ * can be found or installed, launch anyway: Playwright's own error is what `chromiumLaunchHint`
+ * turns into the pinned install command, so the user still gets the one line that fixes it.
+ */
+export declare function launchChromium<B>(chromium: LaunchableChromium<B>, headless: boolean, deps?: ChromiumTargetDeps): Promise<B>;
+/**
+ * The lease preflight's probe: "can a launch succeed?", which now includes the Chrome/Edge fallback
+ * and the automatic install. Without this the preflight would refuse a lease on a machine the
+ * launcher itself could serve. Falls back to the plain probe so a real refusal keeps its evidence.
+ */
+export declare function probeLaunchableChromium(): Promise<ChromiumProbe>;
+/**
+ * `doctor`'s probe: the plain Chromium probe, plus the installed browser that stands in when the
+ * bundled build is missing. Never installs — a diagnostic that downloads 150 MiB is not one.
+ */
+export declare function probeChromiumWithFallback(): Promise<ChromiumProbe>;