@reticlehq/server 2.14.0 → 3.2.0

package/dist/cli/daemon-start-options.d.ts

@@ -1,33 +0,0 @@
-/**
- * Turn the parsed `_daemon` / `serve` flags into the options `startDaemon` takes.
- *
- * Extracted from `handleDaemonInner` to be testable, because the thing it got wrong was invisible
- * from outside: `headless` used to be spread INSIDE the `driveUrl !== undefined` branch, so
- * `reticle serve --headed` — no `--drive` — parsed the flag correctly and then dropped it on the
- * floor. `startDaemon` fell back to `headless ?? true` and the pool launched hidden, which reads to
- * a user as "--headed does nothing" and cost a real session of being told a run was visible when
- * four chrome-headless-shell processes said otherwise.
- *
- * `headless` and `driveUrl` are independent: the flag governs the shared browser POOL (leases,
- * replay, the spec runner), which exists whether or not a drive URL was named.
- */
-import type { StartOptions } from '../index.js';
-type DaemonFlags = {
-    port: number;
-    driveUrl?: string;
-    headless: boolean;
-    http: boolean;
-    httpPort?: number;
-    httpToken?: string;
-};
-export declare function daemonStartOptions(parsed: DaemonFlags): StartOptions;
-/**
- * The argv a parent hands its detached `_daemon` child.
- *
- * `serve` and `mcp` each built this list by hand and each made the SAME mistake as the options
- * builder above — pushing `--headed` only inside the `driveUrl` branch — so the flag survived
- * parsing, was dropped at the spawn, and the child launched a hidden pool. Three sites, one wrong
- * idea: that headless belongs to the drive URL. It belongs to the pool, which exists either way.
- */
-export declare function daemonSpawnArgs(parsed: DaemonFlags): string[];
-export {};

package/dist/cli/device-flow.d.ts

@@ -1,76 +0,0 @@
-/**
- * The browser device flow's wire shapes and its hand-off to a real browser.
- *
- * `reticle login` works like `gh auth login`: the CLI asks the cloud for a device code, opens the
- * approval page, and polls until a human confirms it in a session that is already signed in. That
- * confirmation is the whole security of the flow — only somebody already authenticated in the
- * dashboard can turn a device code into a token for their org.
- *
- * Split from `cloud-cli` because it is self-contained: the schemas describe two endpoints and the
- * opener knows only about platforms. Nothing here reads a session, a credential, or a project.
- */
-import { z } from 'zod';
-/** What `/v1/auth/device/start` answers: the codes, where to approve, and how fast to poll. */
-export declare const DeviceStartSchema: z.ZodObject<{
-    deviceCode: z.ZodString;
-    userCode: z.ZodString;
-    verificationUri: z.ZodString;
-    verificationUriComplete: z.ZodString;
-    interval: z.ZodNumber;
-    expiresAt: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    deviceCode: string;
-    userCode: string;
-    verificationUri: string;
-    verificationUriComplete: string;
-    interval: number;
-    expiresAt: number;
-}, {
-    deviceCode: string;
-    userCode: string;
-    verificationUri: string;
-    verificationUriComplete: string;
-    interval: number;
-    expiresAt: number;
-}>;
-/**
- * What `/v1/auth/device/token` answers while polling. Everything past `status` is optional because
- * only an APPROVED poll carries a token, and `org.id` is absent on a cloud older than org-scoped
- * credentials.
- */
-export declare const DevicePollSchema: z.ZodObject<{
-    status: z.ZodString;
-    token: z.ZodOptional<z.ZodString>;
-    org: z.ZodOptional<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        id?: string | undefined;
-    }, {
-        name: string;
-        id?: string | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    status: string;
-    token?: string | undefined;
-    org?: {
-        name: string;
-        id?: string | undefined;
-    } | undefined;
-}, {
-    status: string;
-    token?: string | undefined;
-    org?: {
-        name: string;
-        id?: string | undefined;
-    } | undefined;
-}>;
-/**
- * Best-effort open the approval page in the default browser.
- *
- * Every failure is swallowed on purpose: the URL is printed either way, and a headless box, a
- * container, or an SSH session has no opener at all. Refusing to log in because a convenience did
- * not work would break the one environment that most needs the printed fallback.
- */
-export declare const openBrowser: (target: string) => void;

package/dist/cli/device-flow.js

@@ -1,56 +0,0 @@
-/**
- * The browser device flow's wire shapes and its hand-off to a real browser.
- *
- * `reticle login` works like `gh auth login`: the CLI asks the cloud for a device code, opens the
- * approval page, and polls until a human confirms it in a session that is already signed in. That
- * confirmation is the whole security of the flow — only somebody already authenticated in the
- * dashboard can turn a device code into a token for their org.
- *
- * Split from `cloud-cli` because it is self-contained: the schemas describe two endpoints and the
- * opener knows only about platforms. Nothing here reads a session, a credential, or a project.
- */
-import { z } from 'zod';
-import { spawn } from 'node:child_process';
-import { NodePlatform } from '../platform.js';
-/** What `/v1/auth/device/start` answers: the codes, where to approve, and how fast to poll. */
-export const DeviceStartSchema = z.object({
-    deviceCode: z.string(),
-    userCode: z.string(),
-    verificationUri: z.string(),
-    verificationUriComplete: z.string(),
-    interval: z.number(),
-    expiresAt: z.number(),
-});
-/**
- * What `/v1/auth/device/token` answers while polling. Everything past `status` is optional because
- * only an APPROVED poll carries a token, and `org.id` is absent on a cloud older than org-scoped
- * credentials.
- */
-export const DevicePollSchema = z.object({
-    status: z.string(),
-    token: z.string().optional(),
-    org: z.object({ id: z.string().optional(), name: z.string() }).optional(),
-});
-/**
- * Best-effort open the approval page in the default browser.
- *
- * Every failure is swallowed on purpose: the URL is printed either way, and a headless box, a
- * container, or an SSH session has no opener at all. Refusing to log in because a convenience did
- * not work would break the one environment that most needs the printed fallback.
- */
-export const openBrowser = (target) => {
-    const cmd = NodePlatform.MACOS === process.platform
-        ? 'open'
-        : NodePlatform.WINDOWS === process.platform
-            ? 'cmd'
-            : 'xdg-open';
-    const args = NodePlatform.WINDOWS === process.platform ? ['/c', 'start', '', target] : [target];
-    try {
-        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
-        child.on('error', () => undefined);
-        child.unref();
-    }
-    catch {
-        /* no opener available — the user opens the printed URL manually */
-    }
-};

package/dist/cli/doctor-daemon-line.js

@@ -1,47 +0,0 @@
-/**
- * What `doctor` says about the daemon it found — pure, so it can be tested without a socket.
- *
- * Doctor already stopped lying about the PORT: `probePresence` separates "a daemon is here" from "a
- * stranger holds it" from "nothing is listening", which was the load-bearing half of the report. It
- * still did not say WHICH daemon, though the `/status` payload it already fetches carries `version`
- * and `contract` and it discarded both.
- *
- * That is the gap worth closing, because skew is invisible everywhere else: a CLI and a daemon on
- * different contracts connect anyway and then disagree about behaviour, which reaches the agent as a
- * bare `-32000` naming no version at all. Doctor is the command a human runs at exactly that moment.
- *
- * Same split as `classifyPort`/`probePresence`: the rule lives here and is tested; the fetching stays
- * at the call site.
- */
-import { describeSkew } from '../version/version-skew.js';
-import { DoctorRow, doctorRow } from './doctor-rows.js';
-/**
- * `reticle stop`, not `reticle kill`.
- *
- * The first version of this said `reticle kill`, which this CLI does not dispatch — it is a proposal
- * (#114), described as a gap in docs/system-map.md, and I read it there as if it shipped. A remedy
- * naming a command that errors is a second dead end handed to someone already stuck, on the one
- * command they run when they are confused.
- */
-const FIX = 'Restart it so both ends are the same build: `reticle stop`, then let your agent reconnect (it ' +
-    'spawns a fresh daemon on the next tool call).';
-/**
- * Build the daemon line for a port that answered `/status`.
- *
- * `pid` comes from the pid file and is genuinely optional — a daemon started by another user, or one
- * whose pid file was cleaned up, still answers. Printing `(pid null)` would be worse than printing
- * nothing, which is the same class of mistake as the port lie this command already fixed.
- */
-export function daemonLine(port, pid, peer, self) {
-    const parts = [];
-    if (null !== pid)
-        parts.push(`pid ${String(pid)}`);
-    if (peer.version !== undefined)
-        parts.push(`v${peer.version}`);
-    const detail = 0 === parts.length ? '' : ` (${parts.join(', ')})`;
-    const skew = describeSkew({ what: 'the daemon on this port', version: peer.version, contract: peer.contract, fix: FIX }, self);
-    const line = {
-        text: doctorRow(DoctorRow.DAEMON, `✓ running on :${String(port)}${detail}`),
-    };
-    return skew === undefined ? line : { ...line, skew };
-}

package/dist/cli/doctor-rows.d.ts

@@ -1,63 +0,0 @@
-/**
- * The row labels `reticle doctor` can print, and the one place that pads them into a column.
- *
- * These were free strings before, hand-padded at every call site across three modules
- * (`cli-doctor.ts`, `doctor-daemon-line.ts`, `doctor-sessions-line.ts`). Two problems with that,
- * and the second is the one that motivated #340:
- *
- * 1. The padding was maintained by eye. Every label happened to be padded to the same column, but
- *    nothing enforced it, and a label longer than the column would have quietly broken the
- *    alignment of one row in a checklist whose whole readability is the column.
- * 2. Nothing connected the labels to the docs pages that reproduce doctor's output. A row could be
- *    added, renamed or removed and the three pages showing sample output would go on describing the
- *    old vocabulary, with no gate noticing. `doctor` is the command a stuck user runs, and the docs
- *    are what they read when its output does not match what they were told to expect.
- *
- * The label set is exported so the docs guard can derive its expectation from the command rather
- * than from a hand-kept list, which is the direction that catches the case that actually bites: a
- * row added and never documented.
- *
- * NOT every row prints on every run. `version` prints only on skew, `port check` only on a
- * mismatch, `sibling` only when a well-known Reticle port other than ours has a listener,
- * `desktop` only on a desktop project, and `sessions` only when a daemon answered. The
- * vocabulary is therefore "what this command can print", not "what one run printed" — a guard built
- * by scraping a single invocation would silently stop covering the conditional rows, which are
- * exactly the ones a reader is least likely to have seen before.
- */
-/** Every row label `doctor` can emit. Values are the literal text at the head of the row. */
-export declare const DoctorRow: {
-    readonly NODE: "node";
-    readonly CHROMIUM: "chromium";
-    readonly DAEMON: "daemon";
-    readonly VERSION: "version";
-    readonly SESSIONS: "sessions";
-    /**
-     * The agent-to-daemon hop, which every other row here is blind to.
-     *
-     * Reported from the field: a user with the SDK injected, the overlay visible, a live session on
-     * the daemon and every tool listed in their client was still told by three separate agents that
-     * Reticle was not present. Their words: "four green checkmarks that don't add up to a working
-     * verification." Every row in this list checks a COMPONENT; none checked a LINK.
-     */
-    readonly AGENT_LINK: "agent link";
-    readonly BRIDGE_PORT: "bridge port";
-    readonly PORT_CHECK: "port check";
-    readonly SIBLING: "sibling";
-    readonly DAEMON_LOG: "daemon log";
-    readonly TRACING: "tracing";
-    readonly DESKTOP: "desktop";
-};
-type DoctorRowLabel = (typeof DoctorRow)[keyof typeof DoctorRow];
-export declare const DOCTOR_ROW_LABELS: readonly DoctorRowLabel[];
-/**
- * Width the label column pads to.
- *
- * Derived from the longest label rather than hardcoded, so adding a longer row realigns the whole
- * checklist instead of breaking one line of it. With the current set the longest is `bridge port`
- * (11), so this is 13 — byte-identical to the hand-padding it replaces. A test pins that, so a
- * change to the column is a deliberate, visible change rather than an invisible reflow.
- */
-export declare const LABEL_COLUMN: number;
-/** Build one `doctor` row: the standard indent, the label padded to the column, then `rest`. */
-export declare function doctorRow(label: DoctorRowLabel, rest: string): string;
-export {};

package/dist/cli/doctor-rows.js

@@ -1,65 +0,0 @@
-/**
- * The row labels `reticle doctor` can print, and the one place that pads them into a column.
- *
- * These were free strings before, hand-padded at every call site across three modules
- * (`cli-doctor.ts`, `doctor-daemon-line.ts`, `doctor-sessions-line.ts`). Two problems with that,
- * and the second is the one that motivated #340:
- *
- * 1. The padding was maintained by eye. Every label happened to be padded to the same column, but
- *    nothing enforced it, and a label longer than the column would have quietly broken the
- *    alignment of one row in a checklist whose whole readability is the column.
- * 2. Nothing connected the labels to the docs pages that reproduce doctor's output. A row could be
- *    added, renamed or removed and the three pages showing sample output would go on describing the
- *    old vocabulary, with no gate noticing. `doctor` is the command a stuck user runs, and the docs
- *    are what they read when its output does not match what they were told to expect.
- *
- * The label set is exported so the docs guard can derive its expectation from the command rather
- * than from a hand-kept list, which is the direction that catches the case that actually bites: a
- * row added and never documented.
- *
- * NOT every row prints on every run. `version` prints only on skew, `port check` only on a
- * mismatch, `sibling` only when a well-known Reticle port other than ours has a listener,
- * `desktop` only on a desktop project, and `sessions` only when a daemon answered. The
- * vocabulary is therefore "what this command can print", not "what one run printed" — a guard built
- * by scraping a single invocation would silently stop covering the conditional rows, which are
- * exactly the ones a reader is least likely to have seen before.
- */
-/** Every row label `doctor` can emit. Values are the literal text at the head of the row. */
-export const DoctorRow = {
-    NODE: 'node',
-    CHROMIUM: 'chromium',
-    DAEMON: 'daemon',
-    VERSION: 'version',
-    SESSIONS: 'sessions',
-    /**
-     * The agent-to-daemon hop, which every other row here is blind to.
-     *
-     * Reported from the field: a user with the SDK injected, the overlay visible, a live session on
-     * the daemon and every tool listed in their client was still told by three separate agents that
-     * Reticle was not present. Their words: "four green checkmarks that don't add up to a working
-     * verification." Every row in this list checks a COMPONENT; none checked a LINK.
-     */
-    AGENT_LINK: 'agent link',
-    BRIDGE_PORT: 'bridge port',
-    PORT_CHECK: 'port check',
-    SIBLING: 'sibling',
-    DAEMON_LOG: 'daemon log',
-    TRACING: 'tracing',
-    DESKTOP: 'desktop',
-};
-export const DOCTOR_ROW_LABELS = Object.values(DoctorRow);
-/** Indent every row carries, before the label. */
-const INDENT = '  ';
-/**
- * Width the label column pads to.
- *
- * Derived from the longest label rather than hardcoded, so adding a longer row realigns the whole
- * checklist instead of breaking one line of it. With the current set the longest is `bridge port`
- * (11), so this is 13 — byte-identical to the hand-padding it replaces. A test pins that, so a
- * change to the column is a deliberate, visible change rather than an invisible reflow.
- */
-export const LABEL_COLUMN = DOCTOR_ROW_LABELS.reduce((widest, label) => Math.max(widest, label.length), 0) + 2;
-/** Build one `doctor` row: the standard indent, the label padded to the column, then `rest`. */
-export function doctorRow(label, rest) {
-    return `${INDENT}${label.padEnd(LABEL_COLUMN)}${rest}`;
-}

package/dist/cli/doctor-sessions-line.js

@@ -1,69 +0,0 @@
-import { SELF_RECOVERING_MARKER } from '../session/no-session-diagnosis.js';
-import { DoctorRow, doctorRow } from './doctor-rows.js';
-/**
- * The line `doctor` was missing: is anything actually CONNECTED?
- *
- * `doctor` collapses the first-run failure modes into one command, and it checked every one of them
- * except the one the funnel actually stalls on. A user who has installed the SDK, wired the plugin
- * and started the daemon runs `doctor`, gets node, chromium, daemon, bridge port and desktop wiring
- * all ✓, and is no better off — because the thing that is wrong is that no page has ever dialled in,
- * and nothing on that screen mentions pages.
- *
- * The daemon has always known. `/status` carries `sessionCount`, the session list, and `why` — the
- * same no-session diagnosis an agent gets from an empty `reticle_sessions`, which is careful about
- * what it can and cannot prove. `reticle status` prints it. `doctor` fetched the identical payload
- * to read `version` and `contract` off it and dropped the rest on the floor.
- *
- * So this invents no new diagnosis. It surfaces one that already exists, on the command a stuck human
- * runs, which is the difference between a checklist that ends in "everything is fine" and one that
- * ends in a next action.
- *
- * Pure and payload-shaped rather than reaching for the bridge: `doctor` runs in a separate process
- * from the daemon and can only ever know what `/status` told it.
- */
-/**
- * The diagnosis is written for an AGENT, and `doctor` has a human in front of it.
- *
- * Every branch of it ends by telling the reader to call `reticle_sessions` again, which is right for
- * the caller it was written for and useless to somebody in a shell: an MCP tool is not something you
- * can type. Printing it unchanged would make `doctor` end on a recovery its reader cannot perform,
- * which is the same defect as the aged-out lease message that told an agent to ask a human to reopen
- * a tab that never existed.
- *
- * So the last sentence is swapped for the shell equivalent of itself. Only that sentence — the rest
- * of the diagnosis is about the app and reads the same to either audience.
- */
-const HUMAN_RETRY = 'Then run `reticle doctor` again — it will appear within a second of the page loading.';
-function forAHuman(why) {
-    // Imported, not re-typed: a copy of a sentence that has to match another file's byte-for-byte is a
-    // drift bug with a delay on it, and the failure is silent — the swap simply stops happening and
-    // doctor goes back to telling a human to call an MCP tool.
-    return why.replace(SELF_RECOVERING_MARKER, HUMAN_RETRY);
-}
-function countOf(facts) {
-    const raw = facts.sessionCount;
-    return 'number' === typeof raw && Number.isFinite(raw) && raw >= 0 ? raw : undefined;
-}
-export function sessionsLine(facts) {
-    const count = countOf(facts);
-    if (count === undefined) {
-        // An older daemon that does not report it. Saying "0 connected" here would be a claim about the
-        // app made from a payload that never mentioned the app — the exact kind of confident wrong
-        // sentence the no-session diagnosis exists to avoid.
-        return {
-            text: doctorRow(DoctorRow.SESSIONS, '? this daemon did not report connected pages (older build)'),
-        };
-    }
-    if (count > 0) {
-        const plural = 1 === count ? 'page' : 'pages';
-        return { text: doctorRow(DoctorRow.SESSIONS, `✓ ${String(count)} ${plural} connected`) };
-    }
-    const why = 'string' === typeof facts.why && facts.why.length > 0 ? forAHuman(facts.why) : undefined;
-    return {
-        // Deliberately ✗ rather than a neutral note. Zero connected pages is why somebody is running
-        // doctor, and a ✓-coloured checklist that hides the one failing thing is how the old output
-        // convinced people their setup was fine.
-        text: doctorRow(DoctorRow.SESSIONS, '✗ no page has connected to this daemon'),
-        ...(why === undefined ? {} : { why }),
-    };
-}

package/dist/cli/drive-attach.d.ts

@@ -1,113 +0,0 @@
-/**
- * Who gets the bridge port when `reticle drive <url>` runs — and what happens when the answer is
- * "not you".
- *
- * `drive` used to bind :4400 unconditionally. A daemon on that port is the NORMAL state the moment
- * any MCP client has started one, so the bind died with a raw `node:net` EADDRINUSE stack — in the
- * exact situation the product tells people to run `drive` in, since `reticle_sessions` recommends it
- * for a throttled tab and a throttled tab nearly always coexists with the daemon that makes the bind
- * impossible. Two independent field reports hit it; the second lost half an hour to the workaround,
- * because `reticle stop` frees the port and the MCP proxy respawns a daemon into the gap before
- * `drive` can bind, so the "escape hatch" is a race the user cannot win.
- *
- * The fix is arbitration, not a better race:
- *
- * - **A healthy daemon owns the port → ATTACH.** Driving is a REQUEST to the process that already
- *   owns the browser plane, not a competing process. The daemon hands out a pooled, isolated,
- *   never-throttled context (the same one `reticle_lease` returns) and the caller gets back a
- *   sessionId every Reticle tool — including the ones the agent already has open on that daemon —
- *   can address. Nothing is bound, so there is nothing to race for and no reason to run `stop`.
- * - **Nothing on the port → BIND.** Unchanged: `drive` is still a self-contained foreground engine
- *   with its own browser when it can have the port.
- * - **A stranger owns the port → REFUSE**, naming the holder. Neither binding nor attaching can
- *   work, and pretending otherwise is the lie this module exists to remove.
- *
- * Making `stop` block until the port is genuinely free (and muzzling the proxy meanwhile) was the
- * alternative. It is strictly more machinery — a cross-process handoff, a suppression window, a new
- * way for the proxy to be wrong — to earn the same browser the daemon can already open, and it would
- * still leave `drive` unable to run while an agent is working. Attaching deletes the race instead of
- * refereeing it.
- */
-import { PortPresence } from '../daemon/port-presence.js';
-/** What `drive` should do about the port, given what is on it. */
-export declare const DriveMode: {
-    /** Nothing is listening: bind it and run the foreground engine. */
-    readonly BIND: "bind";
-    /** Our daemon is serving it: ask that daemon for a driveable session. */
-    readonly ATTACH: "attach";
-    /** Someone else holds it: neither is possible. */
-    readonly REFUSE: "refuse";
-};
-export type DriveMode = (typeof DriveMode)[keyof typeof DriveMode];
-/** Pure. Exhaustive by switch, so a fourth presence has to decide what driving means for it. */
-export declare function decideDriveMode(presence: PortPresence): DriveMode;
-/** A driveable session the daemon opened on our behalf. */
-interface DriveSession {
-    sessionId: string;
-    /** Whether the tab's SDK actually registered — false ⇒ the app may not embed @reticlehq/core. */
-    ready: boolean;
-    /** How long the session survives untouched. Absent from a daemon that does not report it. */
-    expiresInMs?: number;
-    /** The daemon's own diagnosis when the tab did not connect. */
-    hint?: string;
-}
-type DriveAttachResult = {
-    ok: true;
-    session: DriveSession;
-} | {
-    ok: false;
-    reason: string;
-};
-/** POST the drive request. Injected so the decision logic is tested without a socket. */
-type DrivePost = (port: number, path: string, body: string) => Promise<{
-    status: number;
-    body: string;
-}>;
-/**
- * Turn the daemon's answer into a session or a sentence. Pure.
- *
- * Every failure branch has to end in something the reader can DO, because this is the path that
- * replaces the EADDRINUSE stack — an answer that is merely accurate ("404") repeats the original
- * mistake in a politer font.
- */
-export declare function readAttachResponse(port: number, url: string, res: {
-    status: number;
-    body: string;
-}): DriveAttachResult;
-/** Ask the daemon on `port` to open a driveable browser at `url`. */
-export declare function requestDriveSession(port: number, url: string, post?: DrivePost): Promise<DriveAttachResult>;
-/** The success line. Names the session, because that is the handle everything downstream needs. */
-export declare function describeAttached(port: number, url: string, session: DriveSession): string;
-/**
- * What an attach cannot honour: the window.
- *
- * `drive` documents a HEADED browser and parses `--headless` as the opt-out, but the attach path
- * POSTs a url and nothing else — the daemon answers from a pool it launched headless at boot, and no
- * per-request flag can change a browser that is already running. So the run is invisible, which is
- * the half of the field report that reads "the app starts to run headlessly".
- *
- * Saying so is the honest half. The other half is that the run is no longer unwatchable: the HUD
- * feed is mirrored to every other tab of the same app (see Session.setViewers), so a tab the human
- * already has open shows the narration and the counters as the leased context is driven.
- */
-export declare function driveHeadlessOnAttach(port: number, url: string): string;
-/**
- * A stranger holds the port, in words `drive` can honour.
- *
- * The shared sentence for a foreign holder offers `--port`, which is true of `serve`, `status` and
- * `doctor` and false here: `drive` rejects that flag outright and reads the port from the
- * environment. Sending someone to a flag that does not exist is a second dead end at the moment they
- * have already hit one, so the route that works is named instead. The shared sentence is passed in
- * rather than rebuilt, so the description of the holder stays in one place.
- */
-export declare function driveForeignHolder(description: string): string;
-/**
- * The port went from free to taken between the probe and the bind.
- *
- * The probe cannot close that window, and the loser of the race learns about it as an EADDRINUSE on
- * the server object, outside every promise `drive` holds. It is a DISTINCT state from a foreign
- * holder — the likeliest winner is a daemon the proxy just spawned — so it gets its own sentence,
- * and that sentence is "run it again", because the second run attaches instead of binding.
- */
-export declare function driveRaceLost(port: number, url: string): string;
-export {};