@basein/runner 0.1.0

package/dist/proxy/intercept.d.ts

@@ -0,0 +1,55 @@
+/**
+ * intercept — the whole intercept table (Phase 3). Three methods. That is all.
+ *
+ * | Method       | Direction      | Action                                        |
+ * |--------------|----------------|-----------------------------------------------|
+ * | `initialize` | host → upstream| Relay, and rewrite as little as possible.      |
+ * | `tools/list` | host → upstream| Relay; relax schemas only when Tier 1 needs it.|
+ * | `tools/call` | host → upstream| Strip the call id, time it, relay, report it.  |
+ *
+ * `initialize` DESERVES ITS OWN PARAGRAPH, because getting it wrong is what makes
+ * a proxy silently swallow half a server. The host's `capabilities` go upstream
+ * **verbatim**, so the upstream learns whether sampling and elicitation exist;
+ * the upstream's `capabilities` and `serverInfo` come back **verbatim**, so
+ * prompts, resources and logging stay advertised. Nothing here hard-codes
+ * `{ tools: {} }`, and `serverInfo` stays the upstream's — `bir doctor` proves a
+ * proxy is in the path by asking the control server which proxies registered, not
+ * by branding the handshake.
+ *
+ * TWO RULES THAT ARE EASY TO GET WRONG, and are enforced here:
+ *   - **Never rewrite a `tools/call` result.** The upstream object is returned
+ *     as-is, `_meta` and `structuredContent` included. A *copy* is recorded.
+ *   - **Never let recording block the response.** The step is queued after the
+ *     result is already on its way to the host.
+ */
+import { BIR_CALL_ID } from "../control/correlation.js";
+import { type JsonRpcMessage, type JsonRpcResponse } from "../jsonrpc/types.js";
+import type { Interceptor, PendingRequest } from "./relay.js";
+import type { ProxySession } from "./session.js";
+export interface RecordingInterceptorOptions {
+    serverName: string;
+    session: ProxySession;
+}
+export declare class RecordingInterceptor implements Interceptor {
+    private readonly serverName;
+    private readonly session;
+    /** Host request id → the call it opened. Only `tools/call` ids appear here. */
+    private readonly calls;
+    constructor(opts: RecordingInterceptorOptions);
+    onHostMessage(msg: JsonRpcMessage): ReturnType<NonNullable<Interceptor["onHostMessage"]>>;
+    onUpstreamResponse(pending: PendingRequest, response: JsonRpcResponse): JsonRpcMessage | void;
+    onAbandoned(pending: PendingRequest, reason: string): void;
+    /** Build the step report from a completed call. Redaction happens on the copy. */
+    private report;
+    /**
+     * Redact, then clip long strings, on the recording copy only.
+     *
+     * Clipping happens here rather than only at serialization time because a
+     * browser MCP's base64 screenshot would otherwise sit in the step queue in
+     * full, possibly for the length of the run.
+     */
+    private scrub;
+}
+/** Re-exported so callers wiring a proxy need one import for the correlation key. */
+export { BIR_CALL_ID };
+//# sourceMappingURL=intercept.d.ts.map

package/dist/proxy/intercept.js

@@ -0,0 +1,147 @@
+/**
+ * intercept — the whole intercept table (Phase 3). Three methods. That is all.
+ *
+ * | Method       | Direction      | Action                                        |
+ * |--------------|----------------|-----------------------------------------------|
+ * | `initialize` | host → upstream| Relay, and rewrite as little as possible.      |
+ * | `tools/list` | host → upstream| Relay; relax schemas only when Tier 1 needs it.|
+ * | `tools/call` | host → upstream| Strip the call id, time it, relay, report it.  |
+ *
+ * `initialize` DESERVES ITS OWN PARAGRAPH, because getting it wrong is what makes
+ * a proxy silently swallow half a server. The host's `capabilities` go upstream
+ * **verbatim**, so the upstream learns whether sampling and elicitation exist;
+ * the upstream's `capabilities` and `serverInfo` come back **verbatim**, so
+ * prompts, resources and logging stay advertised. Nothing here hard-codes
+ * `{ tools: {} }`, and `serverInfo` stays the upstream's — `bir doctor` proves a
+ * proxy is in the path by asking the control server which proxies registered, not
+ * by branding the handshake.
+ *
+ * TWO RULES THAT ARE EASY TO GET WRONG, and are enforced here:
+ *   - **Never rewrite a `tools/call` result.** The upstream object is returned
+ *     as-is, `_meta` and `structuredContent` included. A *copy* is recorded.
+ *   - **Never let recording block the response.** The step is queued after the
+ *     result is already on its way to the host.
+ */
+import { BIR_CALL_ID, extractCallId, qualifyToolName, relaxToolsListResult, } from "../control/correlation.js";
+import { redact } from "../record/redact.js";
+import { truncateStrings, DEFAULT_MAX_STRING_BYTES } from "../record/truncate.js";
+import { paramsObject } from "../jsonrpc/types.js";
+import { logDetail } from "../util/log.js";
+export class RecordingInterceptor {
+    serverName;
+    session;
+    /** Host request id → the call it opened. Only `tools/call` ids appear here. */
+    calls = new Map();
+    constructor(opts) {
+        this.serverName = opts.serverName;
+        this.session = opts.session;
+    }
+    onHostMessage(msg) {
+        const method = msg.method;
+        const id = msg.id;
+        if (method !== "tools/call" || id === undefined || id === null) {
+            // Everything else — including `initialize` — is forwarded untouched.
+            return { action: "forward" };
+        }
+        const params = paramsObject(msg.params);
+        const toolName = String(params.name ?? "");
+        const { callId, cleaned } = extractCallId(params.arguments);
+        this.calls.set(id, { callId, toolName, args: cleaned, startedAt: Date.now() });
+        if (callId === undefined)
+            return { action: "forward" };
+        // The upstream must never see a key its schema does not declare, so the
+        // correlation id is stripped here rather than being relayed and ignored.
+        logDetail("call.correlated", { server: this.serverName, tool: toolName, callId });
+        return {
+            action: "forward",
+            message: {
+                ...msg,
+                params: { ...params, arguments: cleaned },
+            },
+        };
+    }
+    onUpstreamResponse(pending, response) {
+        if (pending.method === "tools/list") {
+            // The only rewrite in the whole proxy, and only when Tier 1 correlation is
+            // actually active: relaxation is visible to the model on every call, so it
+            // is never paid for unless it is buying a merged step (Phase 6).
+            if (!this.session.correlationActive || response.error)
+                return;
+            return { ...response, result: relaxToolsListResult(response.result) };
+        }
+        if (pending.method !== "tools/call")
+            return;
+        const call = this.calls.get(pending.id);
+        this.calls.delete(pending.id);
+        if (!call)
+            return;
+        // Report *after* returning: the relay writes what we return here, and the
+        // queue push below runs on this same tick but does no I/O of its own.
+        this.report(call, response);
+        return; // the upstream's result, verbatim
+    }
+    onAbandoned(pending, reason) {
+        const call = this.calls.get(pending.id);
+        if (!call)
+            return;
+        this.calls.delete(pending.id);
+        this.session.reportStep({
+            callId: call.callId,
+            serverName: this.serverName,
+            toolName: call.toolName,
+            qualifiedName: qualifyToolName(this.serverName, call.toolName),
+            args: this.scrub(call.args),
+            isError: true,
+            errorMessage: reason,
+            startedAt: call.startedAt,
+            durationMs: Date.now() - call.startedAt,
+        });
+    }
+    /** Build the step report from a completed call. Redaction happens on the copy. */
+    report(call, response) {
+        const durationMs = Date.now() - call.startedAt;
+        const result = response.result;
+        let isError = false;
+        let errorMessage;
+        if (response.error) {
+            // A protocol-level failure: the call never produced a tool result.
+            isError = true;
+            errorMessage = `${response.error.code}: ${response.error.message}`;
+        }
+        else if (result && typeof result === "object" && result.isError === true) {
+            isError = true;
+        }
+        const step = {
+            callId: call.callId,
+            serverName: this.serverName,
+            toolName: call.toolName,
+            qualifiedName: qualifyToolName(this.serverName, call.toolName),
+            args: this.scrub(call.args),
+            result: response.error ? this.scrub(response.error) : this.scrub(response.result),
+            isError,
+            errorMessage,
+            startedAt: call.startedAt,
+            durationMs,
+        };
+        this.session.reportStep(step);
+        logDetail("call.done", {
+            server: this.serverName,
+            tool: call.toolName,
+            ms: durationMs,
+            isError,
+        });
+    }
+    /**
+     * Redact, then clip long strings, on the recording copy only.
+     *
+     * Clipping happens here rather than only at serialization time because a
+     * browser MCP's base64 screenshot would otherwise sit in the step queue in
+     * full, possibly for the length of the run.
+     */
+    scrub(value) {
+        return truncateStrings(redact(value), DEFAULT_MAX_STRING_BYTES);
+    }
+}
+/** Re-exported so callers wiring a proxy need one import for the correlation key. */
+export { BIR_CALL_ID };
+//# sourceMappingURL=intercept.js.map

package/dist/proxy/relay.d.ts

@@ -0,0 +1,97 @@
+/**
+ * relay — the bidirectional JSON-RPC relay (Phase 1.2). The heart, and
+ * deliberately dumb.
+ *
+ * THE DESIGN RULE THAT MAKES FULL PASSTHROUGH TRACTABLE:
+ *
+ *   > **Default-forward, intercept by exception.** Do not enumerate the
+ *   > protocol. Forward any message you have no specific reason to touch.
+ *
+ * So this file knows about exactly two things: matching responses to the
+ * requests that caused them (needed to time a call and to answer in-flight
+ * requests when an upstream dies), and handing each message to an
+ * {@link Interceptor} that may look at it. Everything else — `prompts/*`,
+ * `resources/*`, `completion/complete`, `logging/setLevel`, progress,
+ * cancellation, and the whole reverse direction (`sampling/createMessage`,
+ * `elicitation/create`, `roots/list`, every `list_changed` notification) —
+ * passes through *because it is never mentioned*. Unknown methods work for the
+ * same reason. That is D7.
+ *
+ * IDS. The relay is 1:1, so host ids pass through unchanged; a `Map` of them is
+ * kept anyway because it is what makes timing and cancellation possible. Any
+ * request the proxy originates itself lives in the disjoint `bir:` id space
+ * (see `upstream/client.ts`), so a collision cannot happen.
+ */
+import { type JsonRpcMessage, type JsonRpcResponse } from "../jsonrpc/types.js";
+import type { UpstreamClient } from "../upstream/client.js";
+import type { Readable, Writable } from "node:stream";
+/** A host request the upstream has not answered yet. */
+export interface PendingRequest {
+    id: string | number;
+    method: string;
+    /** Params as the *upstream* received them (post-transform). */
+    params: unknown;
+    startedAt: number;
+}
+export type HostDecision = 
+/** Send `message` (or the original) upstream. */
+{
+    action: "forward";
+    message?: JsonRpcMessage;
+}
+/** Answer the host directly; the upstream never sees it. */
+ | {
+    action: "respond";
+    message: JsonRpcMessage;
+};
+/**
+ * The intercept table's interface. Every method is optional and **synchronous**:
+ * recording must never sit between the upstream's answer and the host (§3,
+ * Phase 3), so an interceptor queues work rather than awaiting it.
+ */
+export interface Interceptor {
+    /** Called for every host→upstream message. Default: forward unchanged. */
+    onHostMessage?(msg: JsonRpcMessage): HostDecision | void;
+    /**
+     * Called for an upstream response that answers a tracked host request.
+     * Returning a message replaces it — used *only* for `tools/list` schema
+     * relaxation. A `tools/call` result is always returned verbatim.
+     */
+    onUpstreamResponse?(pending: PendingRequest, response: JsonRpcResponse): JsonRpcMessage | void;
+    /** Called for anything else the upstream sends. Observation only. */
+    onUpstreamMessage?(msg: JsonRpcMessage): void;
+    /** Called when a tracked request will never be answered (upstream died). */
+    onAbandoned?(pending: PendingRequest, reason: string): void;
+}
+export interface RelayOptions {
+    upstream: UpstreamClient;
+    hostIn: Readable;
+    hostOut: Writable;
+    interceptor?: Interceptor;
+    /** Label for log lines. */
+    label?: string;
+    /** Called when the host closes its side. */
+    onHostDisconnect?: () => void;
+}
+export declare class Relay {
+    private readonly pending;
+    private readonly opts;
+    private detach?;
+    private stopped;
+    constructor(opts: RelayOptions);
+    /** Number of host requests awaiting an upstream answer. */
+    get inFlight(): number;
+    start(): void;
+    stop(): void;
+    private onHostMessage;
+    /**
+     * What the host gets for a request the upstream can no longer answer.
+     *
+     * A dead upstream mid-`tools/call` is a **tool failure**, not a protocol
+     * failure: returning `isError: true` gives the model something it can react to,
+     * where a JSON-RPC error just breaks the client's tool plumbing (§10).
+     */
+    private deadUpstreamAnswer;
+    private abandonAll;
+}
+//# sourceMappingURL=relay.d.ts.map

package/dist/proxy/relay.js

@@ -0,0 +1,166 @@
+/**
+ * relay — the bidirectional JSON-RPC relay (Phase 1.2). The heart, and
+ * deliberately dumb.
+ *
+ * THE DESIGN RULE THAT MAKES FULL PASSTHROUGH TRACTABLE:
+ *
+ *   > **Default-forward, intercept by exception.** Do not enumerate the
+ *   > protocol. Forward any message you have no specific reason to touch.
+ *
+ * So this file knows about exactly two things: matching responses to the
+ * requests that caused them (needed to time a call and to answer in-flight
+ * requests when an upstream dies), and handing each message to an
+ * {@link Interceptor} that may look at it. Everything else — `prompts/*`,
+ * `resources/*`, `completion/complete`, `logging/setLevel`, progress,
+ * cancellation, and the whole reverse direction (`sampling/createMessage`,
+ * `elicitation/create`, `roots/list`, every `list_changed` notification) —
+ * passes through *because it is never mentioned*. Unknown methods work for the
+ * same reason. That is D7.
+ *
+ * IDS. The relay is 1:1, so host ids pass through unchanged; a `Map` of them is
+ * kept anyway because it is what makes timing and cancellation possible. Any
+ * request the proxy originates itself lives in the disjoint `bir:` id space
+ * (see `upstream/client.ts`), so a collision cannot happen.
+ */
+import { readFrames, writeFrame } from "../jsonrpc/framing.js";
+import { JsonRpcErrorCode, errorResponse, isRequest, isResponse, paramsObject, } from "../jsonrpc/types.js";
+import { logDetail, logLine, errText } from "../util/log.js";
+export class Relay {
+    pending = new Map();
+    opts;
+    detach;
+    stopped = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Number of host requests awaiting an upstream answer. */
+    get inFlight() {
+        return this.pending.size;
+    }
+    start() {
+        const { upstream, hostIn, hostOut, interceptor, label } = this.opts;
+        upstream.onMessage((msg) => {
+            const id = msg.id;
+            if (isResponse(msg) && id !== undefined && id !== null && this.pending.has(id)) {
+                const p = this.pending.get(id);
+                this.pending.delete(id);
+                let out = msg;
+                try {
+                    const replaced = interceptor?.onUpstreamResponse?.(p, msg);
+                    if (replaced)
+                        out = replaced;
+                }
+                catch (err) {
+                    // An interceptor bug must not swallow the upstream's answer.
+                    logLine("relay.intercept_failed", { label, method: p.method, error: errText(err) });
+                }
+                writeFrame(hostOut, out, (err) => logLine("relay.write_failed", { label, error: errText(err) }));
+                return;
+            }
+            try {
+                interceptor?.onUpstreamMessage?.(msg);
+            }
+            catch (err) {
+                logLine("relay.intercept_failed", { label, error: errText(err) });
+            }
+            writeFrame(hostOut, msg, (err) => logLine("relay.write_failed", { label, error: errText(err) }));
+        });
+        upstream.onClose(() => this.abandonAll("upstream closed"));
+        this.detach = readFrames(hostIn, {
+            onMessage: (msg) => this.onHostMessage(msg),
+            onParseError: (detail) => {
+                // The host sent something unparseable. Answer -32700 with a null id (we
+                // have no id to echo) and keep going — never crash on bad input.
+                logLine("relay.host_unparseable", { label, reason: detail.reason, bytes: detail.bytes });
+                writeFrame(hostOut, errorResponse(null, JsonRpcErrorCode.ParseError, `parse error: ${detail.reason}`));
+            },
+            onEnd: () => {
+                logDetail("relay.host_disconnected", { label });
+                this.opts.onHostDisconnect?.();
+            },
+        });
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.detach?.();
+        this.abandonAll("relay stopped");
+    }
+    onHostMessage(msg) {
+        const { upstream, hostOut, interceptor, label } = this.opts;
+        let decision = { action: "forward" };
+        try {
+            decision = interceptor?.onHostMessage?.(msg) ?? { action: "forward" };
+        }
+        catch (err) {
+            logLine("relay.intercept_failed", { label, error: errText(err) });
+        }
+        if (decision.action === "respond") {
+            writeFrame(hostOut, decision.message, (err) => logLine("relay.write_failed", { label, error: errText(err) }));
+            return;
+        }
+        const outgoing = decision.message ?? msg;
+        const method = outgoing.method;
+        // A cancellation retires the request it names; the notification itself still
+        // goes upstream, because only the upstream can actually stop the work.
+        if (method === "notifications/cancelled") {
+            const requestId = paramsObject(outgoing.params).requestId;
+            if (typeof requestId === "string" || typeof requestId === "number") {
+                const p = this.pending.get(requestId);
+                if (p) {
+                    this.pending.delete(requestId);
+                    interceptor?.onAbandoned?.(p, "cancelled by host");
+                }
+            }
+        }
+        if (isRequest(outgoing)) {
+            if (upstream.dead) {
+                // §10: the host must get an answer, or it waits forever.
+                writeFrame(hostOut, this.deadUpstreamAnswer(outgoing.id, outgoing.method));
+                return;
+            }
+            this.pending.set(outgoing.id, {
+                id: outgoing.id,
+                method: outgoing.method,
+                params: outgoing.params,
+                startedAt: Date.now(),
+            });
+        }
+        if (upstream.dead) {
+            logDetail("relay.dropped", { label, method, why: "upstream is dead" });
+            return;
+        }
+        upstream.send(outgoing);
+    }
+    /**
+     * What the host gets for a request the upstream can no longer answer.
+     *
+     * A dead upstream mid-`tools/call` is a **tool failure**, not a protocol
+     * failure: returning `isError: true` gives the model something it can react to,
+     * where a JSON-RPC error just breaks the client's tool plumbing (§10).
+     */
+    deadUpstreamAnswer(id, method) {
+        const message = `upstream MCP server "${this.opts.label ?? "unknown"}" is not available`;
+        if (method === "tools/call") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                result: { content: [{ type: "text", text: message }], isError: true },
+            };
+        }
+        return errorResponse(id, JsonRpcErrorCode.UpstreamUnavailable, message);
+    }
+    abandonAll(reason) {
+        if (this.pending.size === 0)
+            return;
+        const { hostOut, interceptor, label } = this.opts;
+        logLine("relay.abandoning", { label, requests: this.pending.size, reason });
+        for (const [id, p] of [...this.pending]) {
+            this.pending.delete(id);
+            interceptor?.onAbandoned?.(p, reason);
+            writeFrame(hostOut, this.deadUpstreamAnswer(p.id, p.method), (err) => logLine("relay.write_failed", { label, error: errText(err) }));
+        }
+    }
+}
+//# sourceMappingURL=relay.js.map

package/dist/proxy/session.d.ts

@@ -0,0 +1,116 @@
+/**
+ * proxy/session — tier negotiation and the proxy's recording lifecycle (§0.1).
+ *
+ * D5 says the hook binary owns run identity. D8 says support any MCP client.
+ * Only Claude Code has hooks, so both cannot hold universally, and ownership is
+ * negotiated here at startup:
+ *
+ *   **Tier 1 — Bound.** A control server is discoverable for this cwd. It owns
+ *   the run; this proxy only reports steps. Built-ins and MCP land in one
+ *   ordered stream, with the prompt and the final answer.
+ *
+ *   **Tier 2 — Standalone.** No control server inside the discovery window. The
+ *   proxy owns a run of its own and records MCP calls only — no prompt, no final
+ *   answer, no built-in steps. That is not a degraded bug; it is the honest
+ *   ceiling of what an MCP proxy can observe, and the run says so in
+ *   `metadata.tier` so nothing downstream mistakes it for a complete trace.
+ *
+ * THE DISCOVERY WINDOW EXISTS BECAUSE OF A RACE: the host may spawn MCP servers
+ * before `SessionStart` fires, and the ordering between the two is not
+ * guaranteed. So steps are **buffered in memory** while the search runs, and
+ * flushed into whichever owner wins. Nothing is lost to the race, and nothing
+ * blocks: relaying never waits on this.
+ */
+import type { UpstreamClient } from "../upstream/client.js";
+import type { ProxyStepReport } from "../control/correlation.js";
+import { type Recorder } from "../record/recorder.js";
+/** How long a proxy waits for a control server before falling to Tier 2. */
+export declare const DISCOVERY_WINDOW_MS = 5000;
+export type Tier = "bound" | "standalone" | "pending";
+export interface ProxySessionOptions {
+    serverName: string;
+    cwd: string;
+    /** Skip discovery and go straight to Tier 2. */
+    standalone?: boolean;
+    /** Suppress schema relaxation; the control server joins on fingerprints instead. */
+    noCorrelation?: boolean;
+    discoveryWindowMs?: number;
+    /** Injected by tests. */
+    recorderFactory?: () => Promise<Recorder | undefined>;
+    /**
+     * The live upstream, so the control server can have this proxy run a
+     * calculated scenario's steps on the connection it already holds
+     * (docs/calculatedReplay.md §16.2). Absent → no work loop, and every step that
+     * would have come here falls back to a recorded output.
+     */
+    upstream?: UpstreamClient;
+}
+export declare class ProxySession {
+    readonly serverName: string;
+    private readonly opts;
+    private tierValue;
+    private control?;
+    /** Tier 2 only. */
+    private recorder?;
+    private runId?;
+    private ordering;
+    private queue;
+    /** Steps that arrived before the tier was known. */
+    private buffer;
+    private lossyValue;
+    private negotiation?;
+    private startedAt;
+    /** The replay work loop, when one was started. */
+    private workLoop?;
+    private closing;
+    constructor(opts: ProxySessionOptions);
+    get tier(): Tier;
+    get lossy(): boolean;
+    /**
+     * Whether the schema-relaxation half of correlation should be applied to
+     * `tools/list` (Phase 6). Only ever true in Tier 1 with correlation enabled:
+     * relaxation is visible to the model on every call, so it is never paid for
+     * unless it is actually buying a merge.
+     */
+    get correlationActive(): boolean;
+    /** Begin tier negotiation. Returns immediately; relaying never waits on it. */
+    start(): void;
+    private negotiate;
+    /**
+     * Take calculated-scenario steps from the control server and run them on the
+     * upstream this proxy already owns (docs/calculatedReplay.md §16.2).
+     *
+     * The whole point of the design lives in three lines below: `upstream.request`
+     * allocates an id in the reserved `bir:` space and the transport consumes its
+     * own response in `accept()` before the relay's handlers ever see it — so this
+     * costs **zero tokens**, the model is not involved, and `RecordingInterceptor`
+     * cannot double-record it. That interface comment says `request()` is "never
+     * used by the relay"; it was built for `bir doctor` and tests, and this is its
+     * second, load-bearing user.
+     */
+    private startWorkLoop;
+    /**
+     * Take ownership of a run ourselves.
+     *
+     * ORDER MATTERS HERE. The recorder is built (which may mean an auth round
+     * trip) *before* the tier is published, because `dispatch` routes on the tier:
+     * publishing "standalone" first opens a window in which a step is neither
+     * buffered nor recordable, and every `tools/call` in that window is lost.
+     * `dispatch` re-buffers defensively too — belt and braces on a race whose
+     * failure mode is silent data loss.
+     */
+    private becomeStandalone;
+    private buildRecorder;
+    /**
+     * Record one completed `tools/call`. Fire-and-forget by contract: it is called
+     * *after* the result is already on its way to the host, and it never awaits.
+     */
+    reportStep(step: ProxyStepReport): void;
+    /** Hold a step until an owner exists. Bounded, and honest when it overflows. */
+    private bufferStep;
+    private flushBuffer;
+    private dispatch;
+    /** Close the Tier 2 run, if we own one, and drain the queue. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=session.d.ts.map