@basein/runner 0.1.0

package/dist/replay/pricing.js

@@ -0,0 +1,76 @@
+/**
+ * pricing — token cost, in $/million tokens (docs/calculatedReplay.md §11.3).
+ *
+ * COPIED FROM THE SERVICE, NOT FROM RRepeat. A saving is `baseline − actual`,
+ * where the baseline is priced by BaseIn's `src/scenarios/cost.ts` and the actual
+ * by this file. The two are maintained by hand in separate repositories, so any
+ * drift between them is fake money — and {@link PRICING_VERSION} is stamped on
+ * every execution report so the server can store a mismatched one *unmeasured*
+ * rather than silently differencing two different tables.
+ *
+ * The service owns the baseline, so the service's table is the one to match.
+ * That is not a stylistic preference: at the time of writing, RRepeat and BaseIn
+ * both declare version `2026-08-30` while pricing `claude-opus-4-6` at 3.0/15.0
+ * and 5.0/25.0 respectively. Equal versions are supposed to certify that two
+ * numbers are comparable. For that row, right now, they are not.
+ *
+ * Bump the version — on **every** side — whenever a row changes.
+ */
+/** Identifies {@link MODEL_PRICING}. Must equal the service's constant. */
+export const PRICING_VERSION = "2026-08-30";
+/** Cache reads bill at 0.1x input; a 5-minute cache write at 1.25x. */
+const priced = (input, output) => ({
+    input,
+    output,
+    cacheRead: input * 0.1,
+    cacheWrite: input * 1.25,
+});
+const MODEL_PRICING = {
+    "claude-haiku-4-5": priced(1.0, 5.0),
+    "claude-haiku-4-5-20251001": priced(1.0, 5.0),
+    "claude-sonnet-4-6": priced(3.0, 15.0),
+    "claude-sonnet-5": priced(2.0, 10.0),
+    "claude-opus-4-6": priced(5.0, 25.0),
+    "claude-opus-4-7": priced(5.0, 25.0),
+    "claude-opus-4-8": priced(5.0, 25.0),
+    "claude-opus-5": priced(5.0, 25.0),
+    "claude-fable-5": priced(10.0, 50.0),
+};
+/**
+ * Tolerate provider prefixes (`anthropic/`, `us.anthropic.`), date snapshots and
+ * unseen version bumps by falling back to the longest matching family, so a new
+ * snapshot never silently prices at $0.
+ */
+export function resolveModelPricing(model) {
+    const exact = MODEL_PRICING[model];
+    if (exact)
+        return exact;
+    // Strip a provider prefix: "us.anthropic.claude-haiku-4-5-v1:0" → "claude-haiku-4-5-v1:0".
+    const idx = model.indexOf("claude-");
+    const bare = idx >= 0 ? model.slice(idx) : model;
+    if (MODEL_PRICING[bare])
+        return MODEL_PRICING[bare];
+    // Longest declared family that prefixes the name — so a dated snapshot of a
+    // known model prices as that model rather than as nothing.
+    let best;
+    for (const key of Object.keys(MODEL_PRICING)) {
+        if (bare.startsWith(key) && (!best || key.length > best.length))
+            best = key;
+    }
+    return best ? MODEL_PRICING[best] : undefined;
+}
+export function hasModelPricing(model) {
+    return resolveModelPricing(model) !== undefined;
+}
+/** Cost in USD. An unpriced model yields 0 — the caller reports `measured: false`. */
+export function calculateCostUsd(model, usage) {
+    const p = resolveModelPricing(model);
+    if (!p)
+        return 0;
+    const perToken = 1e-6;
+    return (usage.inputTokens * p.input * perToken +
+        usage.outputTokens * p.output * perToken +
+        (usage.cacheReadTokens ?? 0) * p.cacheRead * perToken +
+        (usage.cacheCreationTokens ?? 0) * p.cacheWrite * perToken);
+}
+//# sourceMappingURL=pricing.js.map

package/dist/replay/source-run.d.ts

@@ -0,0 +1,50 @@
+/**
+ * source-run — recorded outputs for steps that cannot be executed here
+ * (docs/calculatedReplay.md §8.1).
+ *
+ * RRepeat reads these from `SerializedScenarioStep.recordedOutput`, a field whose
+ * own comment says it is optional because *"it is the server's payload that
+ * decides whether to send it, and older payloads do not."* Verify that before
+ * relying on it: **no payload does.** BaseIn's `scenario_steps` table has
+ * `tool_input_logic`, `tool_output_logic`, `reasoning` and `reasoning_vector` —
+ * and no `recorded_output`. RRepeat's fallback is unreachable in production.
+ *
+ * There is a path that needs no server change, and the match payload already
+ * carries its key: `matched.runId` is the canonical run the scenario was
+ * calculated from, and `GET /recordings/runs/:runId` returns its steps with
+ * their `tool_output`.
+ *
+ * The queue semantics deliberately match the server's own dry replay
+ * (`recordedOutputsByTool` in `scenarios/replay.ts`): a FIFO per tool name, drawn
+ * in order, with a per-tool cursor. A scenario that behaved one way under
+ * `bir scenario replay --dry` and another way here would be untestable.
+ *
+ * Fetched **lazily** — only when a step actually needs it — and cached for the
+ * turn, so a fully-executable replay never makes this call at all.
+ */
+import type { SerializedScenarioStep } from "./types.js";
+export interface SourceRunOptions {
+    baseUrl: string;
+    runId: string;
+    /** Bearer token; refreshed by the caller, read fresh on each fetch. */
+    token: () => string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}
+export declare class SourceRunOutputs {
+    private readonly opts;
+    /** toolName → recorded outputs, in run order. */
+    private byTool?;
+    private cursor;
+    private loading?;
+    constructor(opts: SourceRunOptions);
+    /**
+     * The next recorded output for `step`'s tool, or undefined when the run has
+     * none left (or could not be fetched). Never throws — a missing recorded
+     * output means the step is skipped, which the caller already handles.
+     */
+    outputFor(step: SerializedScenarioStep): Promise<string | undefined>;
+    private load;
+    private fetchRun;
+}
+//# sourceMappingURL=source-run.d.ts.map

package/dist/replay/source-run.js

@@ -0,0 +1,98 @@
+/**
+ * source-run — recorded outputs for steps that cannot be executed here
+ * (docs/calculatedReplay.md §8.1).
+ *
+ * RRepeat reads these from `SerializedScenarioStep.recordedOutput`, a field whose
+ * own comment says it is optional because *"it is the server's payload that
+ * decides whether to send it, and older payloads do not."* Verify that before
+ * relying on it: **no payload does.** BaseIn's `scenario_steps` table has
+ * `tool_input_logic`, `tool_output_logic`, `reasoning` and `reasoning_vector` —
+ * and no `recorded_output`. RRepeat's fallback is unreachable in production.
+ *
+ * There is a path that needs no server change, and the match payload already
+ * carries its key: `matched.runId` is the canonical run the scenario was
+ * calculated from, and `GET /recordings/runs/:runId` returns its steps with
+ * their `tool_output`.
+ *
+ * The queue semantics deliberately match the server's own dry replay
+ * (`recordedOutputsByTool` in `scenarios/replay.ts`): a FIFO per tool name, drawn
+ * in order, with a per-tool cursor. A scenario that behaved one way under
+ * `bir scenario replay --dry` and another way here would be untestable.
+ *
+ * Fetched **lazily** — only when a step actually needs it — and cached for the
+ * turn, so a fully-executable replay never makes this call at all.
+ */
+import { logDetail, logLine, errText } from "../util/log.js";
+export class SourceRunOutputs {
+    opts;
+    /** toolName → recorded outputs, in run order. */
+    byTool;
+    cursor = new Map();
+    loading;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /**
+     * The next recorded output for `step`'s tool, or undefined when the run has
+     * none left (or could not be fetched). Never throws — a missing recorded
+     * output means the step is skipped, which the caller already handles.
+     */
+    async outputFor(step) {
+        try {
+            await this.load();
+        }
+        catch (err) {
+            logLine("replay.source_run_failed", {
+                run: this.opts.runId,
+                why: "no recorded outputs available for steps that cannot run here",
+                error: errText(err),
+            });
+            return undefined;
+        }
+        const list = this.byTool?.get(step.toolName);
+        if (!list || list.length === 0)
+            return undefined;
+        const at = this.cursor.get(step.toolName) ?? 0;
+        this.cursor.set(step.toolName, at + 1);
+        return list[at];
+    }
+    load() {
+        if (!this.loading) {
+            this.loading = this.fetchRun();
+        }
+        return this.loading;
+    }
+    async fetchRun() {
+        const doFetch = this.opts.fetchImpl ?? fetch;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs ?? 10_000);
+        timer.unref?.();
+        try {
+            const res = await doFetch(`${this.opts.baseUrl.replace(/\/+$/, "")}/recordings/runs/${this.opts.runId}`, {
+                headers: { authorization: `Bearer ${this.opts.token()}` },
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const body = (await res.json());
+            const map = new Map();
+            for (const row of body.steps ?? []) {
+                if (row.type !== "tool_response" || !row.tool_name)
+                    continue;
+                const list = map.get(row.tool_name) ?? [];
+                list.push(row.tool_output ?? "{}");
+                map.set(row.tool_name, list);
+            }
+            this.byTool = map;
+            logDetail("replay.source_run_loaded", {
+                run: this.opts.runId,
+                tools: map.size,
+                outputs: [...map.values()].reduce((n, l) => n + l.length, 0),
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+//# sourceMappingURL=source-run.js.map

package/dist/replay/tool-error.d.ts

@@ -0,0 +1,22 @@
+/**
+ * tool-error — telling a tool that ran and *failed* from one that ran and worked.
+ *
+ * A step's tool call resolving is not the same as the step's work happening.
+ * `executeStep` rejects only when a tool could not be run here; a tool that ran
+ * and answered `Error: relation does not exist` resolves normally, with that
+ * error as its response — which is right for threading (the output logic may
+ * want to see it) and wrong for the verdict. Eight such steps once logged
+ * `ok=true` each, the plan reported `steered_full`, and the ledger booked its
+ * largest saving of the day on a replay that created nothing (docs/mcpmark.md §13).
+ *
+ * The signal is the MCP result itself: `isError: true` per the spec, or — for
+ * servers that report failures as ordinary text, `postgres-mcp` among them — a
+ * first text block that begins with the word "Error". Nothing else is read, and
+ * a built-in's hook-shaped response is never judged.
+ */
+/**
+ * The error a serialized `CallToolResult` reports, or undefined when it does
+ * not. `serialized` is the proxy's own serialization — the whole result, as JSON.
+ */
+export declare function toolResultError(serialized: string): string | undefined;
+//# sourceMappingURL=tool-error.d.ts.map

package/dist/replay/tool-error.js

@@ -0,0 +1,60 @@
+/**
+ * tool-error — telling a tool that ran and *failed* from one that ran and worked.
+ *
+ * A step's tool call resolving is not the same as the step's work happening.
+ * `executeStep` rejects only when a tool could not be run here; a tool that ran
+ * and answered `Error: relation does not exist` resolves normally, with that
+ * error as its response — which is right for threading (the output logic may
+ * want to see it) and wrong for the verdict. Eight such steps once logged
+ * `ok=true` each, the plan reported `steered_full`, and the ledger booked its
+ * largest saving of the day on a replay that created nothing (docs/mcpmark.md §13).
+ *
+ * The signal is the MCP result itself: `isError: true` per the spec, or — for
+ * servers that report failures as ordinary text, `postgres-mcp` among them — a
+ * first text block that begins with the word "Error". Nothing else is read, and
+ * a built-in's hook-shaped response is never judged.
+ */
+const MAX_ERROR_CHARS = 500;
+/**
+ * The error a serialized `CallToolResult` reports, or undefined when it does
+ * not. `serialized` is the proxy's own serialization — the whole result, as JSON.
+ */
+export function toolResultError(serialized) {
+    let parsed;
+    try {
+        parsed = JSON.parse(serialized);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed === "string")
+        return looksLikeError(parsed) ? clip(parsed) : undefined;
+    if (!parsed || typeof parsed !== "object")
+        return undefined;
+    const result = parsed;
+    const text = firstText(result.content);
+    if (result.isError === true)
+        return clip(text ?? "the tool reported an error");
+    if (text !== undefined && looksLikeError(text))
+        return clip(text);
+    return undefined;
+}
+function firstText(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    for (const block of content) {
+        const text = block?.text;
+        if (typeof text === "string")
+            return text;
+    }
+    return undefined;
+}
+/** "Error: …" / "ERROR: …" / "error occurred" — not "Errors were fixed". */
+function looksLikeError(text) {
+    return /^\s*error\b/i.test(text);
+}
+function clip(text) {
+    const trimmed = text.trim();
+    return trimmed.length > MAX_ERROR_CHARS ? `${trimmed.slice(0, MAX_ERROR_CHARS)}…` : trimmed;
+}
+//# sourceMappingURL=tool-error.js.map

package/dist/replay/types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The scenario payload, exactly as the BaseIn service serializes it.
+ *
+ * Shapes mirror `serializeScenario` in the service's `src/scenarios/repo.ts`.
+ * They arrive on a similar-prompt hit, embedded in `POST /recordings/runs`'s
+ * `matched.scenario` — there is no follow-up fetch, so this is the whole
+ * contract (docs/calculatedReplay.md §2).
+ *
+ * Every field is typed as the service actually sends it, which means `null` is
+ * everywhere and nothing is assumed present. A scenario whose `state` is not
+ * `"ready"` carries an **empty** `steps` array, by the service's own rule.
+ */
+/** One step: the tool, and the JS logic that recomputes its arguments. */
+export interface SerializedScenarioStep {
+    stepIndex: number;
+    /** As the recorder wrote it — `mcp__<server>__<tool>` for an MCP call. */
+    toolName: string;
+    /** JS body: `(parameters, intent, respParams) => object`. Required. */
+    toolInputLogic: string;
+    /** JS body: `(toolOutput, parameters, intent, respParams) => object`. */
+    toolOutputLogic: string | null;
+    /** The model's reasoning for this step, used in the steering directive. */
+    reasoning: string | null;
+    /**
+     * The literal output recorded for this step.
+     *
+     * **The service does not send this today** — `scenario_steps` has no such
+     * column (docs/calculatedReplay.md §8.1). Kept in the type because the field
+     * is part of the wider contract and costs nothing to honour if it appears;
+     * {@link ../replay/source-run.ts} is what actually supplies recorded outputs.
+     */
+    recordedOutput?: string | null;
+}
+/** The `paramsObject` schema: one entry per parameter the scenario takes. */
+export type ParamsSchema = Record<string, {
+    sampleValue: unknown;
+    description: string;
+}>;
+/** A `ready` scenario, as serialized by the BaseIn service on a match. */
+export interface SerializedScenario {
+    id: string;
+    runId: string;
+    state: string;
+    intent: string;
+    parameters: unknown;
+    responseParameters: unknown;
+    /** name → { sampleValue, description }. The schema derivation fills in. */
+    paramsObject: ParamsSchema | null;
+    toolParameterMap: unknown;
+    toolOutputParameterMap: unknown;
+    /** JS body: `(parameters, intent) => object`. Applied once, before step 0. */
+    paramsLogic: string | null;
+    /** JS body: `(respParams, parameters, intent) => object`. The final model. */
+    responseParamsLogic: string | null;
+    outParamsObject?: unknown;
+    originalCostUsd: number | null;
+    originalMs: number | null;
+    calcCostUsd: number | null;
+    baselineCostUsd?: number | null;
+    baselineSamples?: number | null;
+    steps: SerializedScenarioStep[];
+}
+/**
+ * How a matched run's execution is classified when it is reported back.
+ * Mirrors the service's zod enum on `POST /scenarios/:id/executions`.
+ */
+export type ExecutionOutcome = "steered_full" | "diverged" | "not_steered" | "failed";
+/**
+ * Upgrade order. `not_steered` is the floor — the control group, and the safe
+ * answer if a turn dies mid-flight — and each later decision point can only move
+ * the classification forward, never back (docs/calculatedReplay.md §11.1).
+ */
+export declare const OUTCOME_RANK: Record<ExecutionOutcome, number>;
+/**
+ * What became of one step of a replay.
+ *
+ *   `ok`       — its tool ran here and its output threaded.
+ *   `recorded` — its tool could not run here, so its recorded output stood in.
+ *                A pass, with an asterisk: the values are from the source run.
+ *   `skipped`  — its tool could not run and there was no recorded output. The
+ *                step did not happen at all; later steps read nothing from it.
+ *   `failed`   — the *scenario's own logic* threw, or its tool ran and reported
+ *                an error (stage `tool_call`). Either way the step's work did
+ *                not happen, and a plan cannot claim success past it.
+ *
+ * A step the run never reached is simply absent from the report. The console
+ * renders those as "not run" — asserting anything about a step that never
+ * started would be inventing a result.
+ */
+export type ExecutionStepStatus = "ok" | "recorded" | "skipped" | "failed";
+/**
+ * Where inside a step (or a run) something broke. Mirrors the service's
+ * `ExecutionStage` (its `src/db.ts`) — a closed vocabulary, so the console can
+ * say which part failed without parsing an error message.
+ */
+export type ExecutionStage = "derive_params" | "params_logic" | "tool_input_logic" | "tool_call" | "tool_output_logic" | "response_logic" | "setup" | "unknown";
+/**
+ * One step's verdict, as reported to the service alongside the execution.
+ *
+ * `stepIndex` is the scenario's own `scenario_steps.step_index`, not a position
+ * in this array: a diverged turn reports only the steps it reached, and the
+ * console lines them up against the full chain by index.
+ */
+export interface ExecutionStepResult {
+    stepIndex: number;
+    toolName: string;
+    status: ExecutionStepStatus;
+    /** Only for `failed` / `skipped`. */
+    stage?: ExecutionStage;
+    /** Message only — never a tool payload; this is rendered in a web page. */
+    error?: string;
+    durationMs?: number;
+}
+/** Narrowing guard for a payload that is worth arming a plan from. */
+export declare function isReadyScenario(value: unknown): value is SerializedScenario;
+//# sourceMappingURL=types.d.ts.map

package/dist/replay/types.js

@@ -0,0 +1,35 @@
+/**
+ * The scenario payload, exactly as the BaseIn service serializes it.
+ *
+ * Shapes mirror `serializeScenario` in the service's `src/scenarios/repo.ts`.
+ * They arrive on a similar-prompt hit, embedded in `POST /recordings/runs`'s
+ * `matched.scenario` — there is no follow-up fetch, so this is the whole
+ * contract (docs/calculatedReplay.md §2).
+ *
+ * Every field is typed as the service actually sends it, which means `null` is
+ * everywhere and nothing is assumed present. A scenario whose `state` is not
+ * `"ready"` carries an **empty** `steps` array, by the service's own rule.
+ */
+/**
+ * Upgrade order. `not_steered` is the floor — the control group, and the safe
+ * answer if a turn dies mid-flight — and each later decision point can only move
+ * the classification forward, never back (docs/calculatedReplay.md §11.1).
+ */
+export const OUTCOME_RANK = {
+    not_steered: 0,
+    failed: 1,
+    diverged: 2,
+    steered_full: 3,
+};
+/** Narrowing guard for a payload that is worth arming a plan from. */
+export function isReadyScenario(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const s = value;
+    return (typeof s.id === "string" &&
+        s.state === "ready" &&
+        Array.isArray(s.steps) &&
+        s.steps.length > 0 &&
+        s.steps.every((step) => typeof step?.toolName === "string" && typeof step?.toolInputLogic === "string"));
+}
+//# sourceMappingURL=types.js.map

package/dist/upstream/client.d.ts

@@ -0,0 +1,78 @@
+/**
+ * UpstreamClient — the transport contract every upstream implements.
+ *
+ * DEVIATION FROM §5 OF THE DESIGN, AND WHY. The design sketches
+ * `request(method, params)` / `notify(...)` / `onIncoming(...)`. That surface
+ * cannot express the one thing D7 requires: sending a **response** toward the
+ * upstream. An upstream that issues `sampling/createMessage` or
+ * `elicitation/create` is waiting for the host's answer, and there is no
+ * `request`/`notify` shape that carries it — so a relay built on that interface
+ * would hang exactly the servers §8 says must work.
+ *
+ * The primitive here is therefore message-level: {@link send} takes any
+ * `JsonRpcMessage` verbatim and {@link onMessage} hands back any message the
+ * upstream originates, in either role. `request`/`notify` remain, implemented on
+ * top, for the few places that genuinely want a call (`bir doctor`, tests) — and
+ * they allocate ids in the reserved `bir:` space so they can never collide with a
+ * host id passing through (Phase 1.3).
+ */
+import type { JsonRpcMessage } from "../jsonrpc/types.js";
+/** Why the upstream connection ended. */
+export interface UpstreamCloseInfo {
+    code?: number | null;
+    signal?: NodeJS.Signals | null;
+    error?: Error;
+}
+export interface UpstreamClient {
+    /** Resolves when the transport is usable; rejects if the upstream is unusable. */
+    readonly ready: Promise<void>;
+    /** True once the upstream has died or `close()` was called. */
+    readonly dead: boolean;
+    /** Send any JSON-RPC message toward the upstream, verbatim. */
+    send(msg: JsonRpcMessage): void;
+    /** Every message the upstream originates (requests, notifications, responses). */
+    onMessage(handler: (msg: JsonRpcMessage) => void): void;
+    /** Called once when the upstream connection ends, for any reason. */
+    onClose(handler: (info: UpstreamCloseInfo) => void): void;
+    /** Convenience call in the reserved `bir:` id space. Never used by the relay. */
+    request(method: string, params?: unknown, signal?: AbortSignal): Promise<unknown>;
+    /** Fire-and-forget notification toward the upstream. */
+    notify(method: string, params?: unknown): void;
+    close(): void;
+}
+/**
+ * The id prefix reserved for requests the proxy itself originates. Host ids pass
+ * through unchanged (the relay is 1:1), so the only way a collision could happen
+ * is a proxy-originated id colliding with a host one — impossible while every
+ * proxy id lives in this disjoint string space.
+ */
+export declare const BIR_ID_PREFIX = "bir:";
+export declare function isBirId(id: unknown): boolean;
+/**
+ * Shared plumbing for the transports: `bir:`-id request tracking, handler
+ * fan-out, and one-shot close. Subclasses implement {@link deliver} (bytes out)
+ * and call {@link accept} (bytes in) / {@link closed} (connection over).
+ */
+export declare abstract class BaseUpstreamClient implements UpstreamClient {
+    abstract readonly ready: Promise<void>;
+    private readonly messageHandlers;
+    private readonly closeHandlers;
+    private readonly pending;
+    private nextId;
+    private isDead;
+    get dead(): boolean;
+    abstract send(msg: JsonRpcMessage): void;
+    abstract close(): void;
+    onMessage(handler: (msg: JsonRpcMessage) => void): void;
+    onClose(handler: (info: UpstreamCloseInfo) => void): void;
+    request(method: string, params?: unknown, signal?: AbortSignal): Promise<unknown>;
+    notify(method: string, params?: unknown): void;
+    /**
+     * Route one upstream message. Responses to proxy-originated (`bir:`) ids are
+     * consumed here and never reach the relay; everything else fans out verbatim.
+     */
+    protected accept(msg: JsonRpcMessage): void;
+    /** Mark the connection over. Idempotent; fails every in-flight `request()`. */
+    protected closed(info: UpstreamCloseInfo): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/upstream/client.js

@@ -0,0 +1,114 @@
+/**
+ * UpstreamClient — the transport contract every upstream implements.
+ *
+ * DEVIATION FROM §5 OF THE DESIGN, AND WHY. The design sketches
+ * `request(method, params)` / `notify(...)` / `onIncoming(...)`. That surface
+ * cannot express the one thing D7 requires: sending a **response** toward the
+ * upstream. An upstream that issues `sampling/createMessage` or
+ * `elicitation/create` is waiting for the host's answer, and there is no
+ * `request`/`notify` shape that carries it — so a relay built on that interface
+ * would hang exactly the servers §8 says must work.
+ *
+ * The primitive here is therefore message-level: {@link send} takes any
+ * `JsonRpcMessage` verbatim and {@link onMessage} hands back any message the
+ * upstream originates, in either role. `request`/`notify` remain, implemented on
+ * top, for the few places that genuinely want a call (`bir doctor`, tests) — and
+ * they allocate ids in the reserved `bir:` space so they can never collide with a
+ * host id passing through (Phase 1.3).
+ */
+/**
+ * The id prefix reserved for requests the proxy itself originates. Host ids pass
+ * through unchanged (the relay is 1:1), so the only way a collision could happen
+ * is a proxy-originated id colliding with a host one — impossible while every
+ * proxy id lives in this disjoint string space.
+ */
+export const BIR_ID_PREFIX = "bir:";
+export function isBirId(id) {
+    return typeof id === "string" && id.startsWith(BIR_ID_PREFIX);
+}
+/**
+ * Shared plumbing for the transports: `bir:`-id request tracking, handler
+ * fan-out, and one-shot close. Subclasses implement {@link deliver} (bytes out)
+ * and call {@link accept} (bytes in) / {@link closed} (connection over).
+ */
+export class BaseUpstreamClient {
+    messageHandlers = [];
+    closeHandlers = [];
+    pending = new Map();
+    nextId = 1;
+    isDead = false;
+    get dead() {
+        return this.isDead;
+    }
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    onClose(handler) {
+        if (this.isDead) {
+            handler({});
+            return;
+        }
+        this.closeHandlers.push(handler);
+    }
+    request(method, params, signal) {
+        if (this.isDead)
+            return Promise.reject(new Error("upstream is not available"));
+        const id = `${BIR_ID_PREFIX}${this.nextId++}`;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                this.pending.delete(id);
+                reject(new Error(`${method} aborted`));
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            this.pending.set(id, {
+                resolve,
+                reject,
+                cleanup: () => signal?.removeEventListener("abort", onAbort),
+            });
+            this.send({ jsonrpc: "2.0", id, method, params });
+        });
+    }
+    notify(method, params) {
+        if (this.isDead)
+            return;
+        this.send({ jsonrpc: "2.0", method, params });
+    }
+    /**
+     * Route one upstream message. Responses to proxy-originated (`bir:`) ids are
+     * consumed here and never reach the relay; everything else fans out verbatim.
+     */
+    accept(msg) {
+        const id = msg.id;
+        if (isBirId(id)) {
+            const waiter = this.pending.get(id);
+            if (waiter) {
+                this.pending.delete(id);
+                waiter.cleanup();
+                const res = msg;
+                if (res.error)
+                    waiter.reject(new Error(res.error.message ?? "upstream error"));
+                else
+                    waiter.resolve(res.result);
+            }
+            return;
+        }
+        for (const handler of this.messageHandlers)
+            handler(msg);
+    }
+    /** Mark the connection over. Idempotent; fails every in-flight `request()`. */
+    closed(info) {
+        if (this.isDead)
+            return;
+        this.isDead = true;
+        const err = info.error ?? new Error("upstream closed");
+        for (const [, waiter] of this.pending) {
+            waiter.cleanup();
+            waiter.reject(err);
+        }
+        this.pending.clear();
+        for (const handler of this.closeHandlers)
+            handler(info);
+        this.closeHandlers.length = 0;
+    }
+}
+//# sourceMappingURL=client.js.map