@vincentt-xr/harness 0.3.0 → 1.0.0

package/dist/client/HarnessProvider.d.ts

@@ -17,5 +17,10 @@ export interface HarnessProviderProps {
     captureConsole?: boolean;
     captureNetwork?: boolean;
     captureTrace?: boolean;
+    /**
+     * Mount the floating "Send feedback" button (the reverse-channel capture
+     * overlay). Defaults to `enabled` — on in preview, gone in production.
+     */
+    feedback?: boolean;
 }
 export declare function HarnessProvider(props: HarnessProviderProps): ReactNode;

package/dist/client/HarnessProvider.js

@@ -52,9 +52,20 @@ export function HarnessProvider(props) {
                 captureTrace: props.captureTrace,
             });
         });
+        let unmountFeedback;
+        if (props.feedback !== false) {
+            // Separate dynamic import so the capture overlay (and its DOM code) also
+            // drops from a production bundle.
+            void import("./annotate.js").then(({ mountFeedbackButton }) => {
+                if (cancelled)
+                    return;
+                unmountFeedback = mountFeedbackButton({ sessionId: props.sessionId });
+            });
+        }
         return () => {
             cancelled = true;
             teardown?.();
+            unmountFeedback?.();
         };
         // Instrumentation is installed once for the provider's lifetime; option
         // changes mid-session are not a supported case.

package/dist/client/annotate.d.ts

@@ -0,0 +1,34 @@
+import type { AnnotationInput, AnnotationSpec } from "../shared/events.js";
+/**
+ * Capture the current frame as a PNG data URL. Prefers the largest <canvas> (the
+ * AR/three.js surface); returns an empty-ish 1x1 PNG if there is none.
+ *
+ * Caveat: reading a WebGL canvas requires it to have been created with
+ * `preserveDrawingBuffer: true`, or the read can come back blank. r3f/three set
+ * this via `gl={{ preserveDrawingBuffer: true }}`. DOM-only content isn't captured
+ * here (that needs html2canvas, deliberately not a dependency).
+ */
+export declare function captureScreenshot(): string;
+export interface SendAnnotationOptions {
+    /** Relay HTTP base (default: `<origin>/__harness`). */
+    relayHttpUrl?: string;
+}
+/** POST an annotation to the relay. Resolves with the relay-assigned id + seq. */
+export declare function sendAnnotation(input: AnnotationInput, opts?: SendAnnotationOptions): Promise<{
+    id: string;
+    seq: number;
+}>;
+export interface FeedbackButtonOptions extends SendAnnotationOptions {
+    sessionId?: string;
+    /** Collect the creator's message. Default: window.prompt. */
+    promptMessage?: () => string | null | Promise<string | null>;
+    /** Override the captured spec (strokes/pins/labels). Default: empty. */
+    spec?: AnnotationSpec;
+}
+/**
+ * Mount a minimal floating "Send feedback" button. On click it collects a message,
+ * captures the frame, and sends the annotation. Returns an unmount function. This
+ * is the smallest useful Send action; a richer draw-on-frame overlay can replace
+ * the capture/prompt without changing the wire contract.
+ */
+export declare function mountFeedbackButton(opts?: FeedbackButtonOptions): () => void;

package/dist/client/annotate.js

@@ -0,0 +1,104 @@
+// The in-app capture overlay's Send action — the client half of the reverse
+// channel. It captures the current frame, packages the creator's message + spec,
+// and POSTs it to the relay over the same tunnel the app is served on. The relay
+// (see the CLI's relay/annotations) stamps + persists it and unblocks a waiting
+// `vincentt feedback --wait`.
+//
+// Loaded via dynamic import from HarnessProvider (like the instrumentation), so a
+// production build never ships it. DOM-only, no React.
+/** Default relay HTTP base: the same origin the app is served on + the harness path. */
+function defaultRelayHttpUrl() {
+    return `${window.location.origin}/__harness`;
+}
+/**
+ * Capture the current frame as a PNG data URL. Prefers the largest <canvas> (the
+ * AR/three.js surface); returns an empty-ish 1x1 PNG if there is none.
+ *
+ * Caveat: reading a WebGL canvas requires it to have been created with
+ * `preserveDrawingBuffer: true`, or the read can come back blank. r3f/three set
+ * this via `gl={{ preserveDrawingBuffer: true }}`. DOM-only content isn't captured
+ * here (that needs html2canvas, deliberately not a dependency).
+ */
+export function captureScreenshot() {
+    const canvases = Array.from(document.querySelectorAll("canvas"));
+    const biggest = canvases.sort((a, b) => b.width * b.height - a.width * a.height)[0];
+    if (biggest) {
+        try {
+            return biggest.toDataURL("image/png");
+        }
+        catch {
+            // Tainted canvas (cross-origin texture without CORS) — fall through.
+        }
+    }
+    const fallback = document.createElement("canvas");
+    fallback.width = fallback.height = 1;
+    return fallback.toDataURL("image/png");
+}
+/** POST an annotation to the relay. Resolves with the relay-assigned id + seq. */
+export async function sendAnnotation(input, opts = {}) {
+    const base = opts.relayHttpUrl ?? defaultRelayHttpUrl();
+    const res = await fetch(`${base}/annotation`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(input),
+    });
+    if (!res.ok)
+        throw new Error(`annotation POST failed: ${res.status}`);
+    return (await res.json());
+}
+/**
+ * Mount a minimal floating "Send feedback" button. On click it collects a message,
+ * captures the frame, and sends the annotation. Returns an unmount function. This
+ * is the smallest useful Send action; a richer draw-on-frame overlay can replace
+ * the capture/prompt without changing the wire contract.
+ */
+export function mountFeedbackButton(opts = {}) {
+    if (typeof document === "undefined")
+        return () => undefined;
+    const btn = document.createElement("button");
+    btn.textContent = "Send feedback";
+    Object.assign(btn.style, {
+        position: "fixed",
+        right: "12px",
+        bottom: "12px",
+        zIndex: "2147483647",
+        padding: "10px 14px",
+        borderRadius: "10px",
+        border: "none",
+        background: "linear-gradient(135deg,#7c3aed,#2563eb)",
+        color: "#fff",
+        font: "600 13px/1 -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif",
+        boxShadow: "0 4px 16px rgba(0,0,0,.25)",
+        cursor: "pointer",
+    });
+    const setBusy = (busy, label) => {
+        btn.disabled = busy;
+        btn.textContent = label ?? "Send feedback";
+        btn.style.opacity = busy ? "0.6" : "1";
+    };
+    btn.addEventListener("click", async () => {
+        const getMsg = opts.promptMessage ?? (() => window.prompt("Feedback for the agent:"));
+        const message = await getMsg();
+        if (message == null || message.trim() === "")
+            return;
+        setBusy(true, "Sending…");
+        try {
+            const screenshot = captureScreenshot();
+            const input = {
+                message: message.trim(),
+                screenshot,
+                spec: opts.spec ?? {},
+                sessionId: opts.sessionId,
+            };
+            await sendAnnotation(input, { relayHttpUrl: opts.relayHttpUrl });
+            setBusy(false, "Sent ✓");
+            window.setTimeout(() => setBusy(false), 1500);
+        }
+        catch (err) {
+            setBusy(false, "Failed — retry");
+            console.error("[harness] annotation send failed:", err);
+        }
+    });
+    document.body.appendChild(btn);
+    return () => btn.remove();
+}

package/dist/client/index.d.ts

@@ -1,3 +1,5 @@
 export { HarnessProvider } from "./HarnessProvider.js";
 export type { HarnessProviderProps } from "./HarnessProvider.js";
+export { sendAnnotation, captureScreenshot, mountFeedbackButton, type SendAnnotationOptions, type FeedbackButtonOptions, } from "./annotate.js";
 export type { DiagEvent, LogEvent, NetworkEvent, TraceEvent } from "../shared/events.js";
+export type { Annotation, AnnotationInput, AnnotationSpec, AnnotationStroke, AnnotationPin, } from "../shared/events.js";

package/dist/client/index.js

@@ -3,3 +3,4 @@
 // tree-shakes it). The relay and MCP server are NOT exported here; they are
 // run-from-bin, not imported.
 export { HarnessProvider } from "./HarnessProvider.js";
+export { sendAnnotation, captureScreenshot, mountFeedbackButton, } from "./annotate.js";

package/dist/shared/events.d.ts

@@ -75,4 +75,54 @@ export interface RelayResult {
     /** Sessions the relay has seen events for (so the agent can disambiguate). */
     sessions: string[];
 }
+/** A freehand stroke over the frame, in normalized [0,1] frame coordinates. */
+export interface AnnotationStroke {
+    points: {
+        x: number;
+        y: number;
+    }[];
+    color?: string;
+}
+/** A point marker on the frame, in normalized [0,1] frame coordinates. */
+export interface AnnotationPin {
+    x: number;
+    y: number;
+    label?: string;
+}
+/** The drawn overlay accompanying an annotation. All fields optional — a bare
+ *  message with a screenshot is a valid annotation. */
+export interface AnnotationSpec {
+    strokes?: AnnotationStroke[];
+    pins?: AnnotationPin[];
+    labels?: string[];
+    note?: string;
+}
+/** Client → relay POST body (`POST /__harness/annotation`). The relay stamps the
+ *  id, receipt time, project binding, and on-disk screenshot path. */
+export interface AnnotationInput {
+    /** The creator's message to the agent. */
+    message: string;
+    /** Annotated frame as a data URL (image/png). */
+    screenshot: string;
+    spec?: AnnotationSpec;
+    /** Optional preview session id, to correlate with diag events. */
+    sessionId?: string;
+}
+/** A persisted annotation the agent consumes (via `vincentt feedback --wait`). */
+export interface Annotation {
+    /** Short relay-assigned id (e.g. "a7f3"). */
+    id: string;
+    /** Monotonic per-project cursor; a consumer polls "after this seq". */
+    seq: number;
+    /** Receipt time, stamped by the relay (not the browser). */
+    createdAt: Timestamp;
+    /** The bound project directory this annotation belongs to. */
+    projectDir: string;
+    /** The creator's message to the agent. */
+    message: string;
+    /** Absolute path to the full-res annotated screenshot on disk. */
+    screenshotPath: string;
+    spec: AnnotationSpec;
+    sessionId?: string;
+}
 export {};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@vincentt-xr/harness",
-  "version": "0.3.0",
-  "description": "Vincentt AR dev-loop harness — in-app diagnostics client + relay + agent-agnostic MCP server",
+  "version": "1.0.0",
+  "description": "Vincentt AR dev-loop harness — in-app diagnostics provider + wire contract",
   "license": "UNLICENSED",
   "type": "module",
   "sideEffects": false,
   "files": [
-    "/dist"
+    "dist"
   ],
   "main": "./dist/client/index.js",
   "module": "./dist/client/index.js",
@@ -16,45 +16,20 @@
       "types": "./dist/client/index.d.ts",
       "import": "./dist/client/index.js"
     },
-    "./relay": {
-      "types": "./dist/relay/server.d.ts",
-      "import": "./dist/relay/server.js"
-    },
-    "./preview": {
-      "types": "./dist/preview/index.d.ts",
-      "import": "./dist/preview/index.js"
+    "./events": {
+      "types": "./dist/shared/events.d.ts",
+      "import": "./dist/shared/events.js"
     }
   },
-  "bin": {
-    "harness-relay": "./dist/relay/cli.js",
-    "harness-mcp": "./dist/mcp/cli.js"
-  },
   "peerDependencies": {
     "react": "^18.2.0"
   },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "cloudflared": "^0.7.1",
-    "ws": "^8.18.0",
-    "zod": "^3.23.8"
-  },
   "devDependencies": {
-    "@types/node": "^22.9.0",
-    "@types/react": "^18.3.12",
-    "@types/ws": "^8.5.13",
-    "prettier": "3.3.3",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.5"
+    "@types/react": "^18.3.12"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "relay": "node --loader ts-node/esm src/relay/cli.ts",
-    "mcp": "node --loader ts-node/esm src/mcp/cli.ts",
-    "test": "vitest run",
-    "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
-    "format:check": "prettier --check .",
-    "format": "prettier --write ."
+    "test": "vitest run"
   }
 }

package/README.md

@@ -1,87 +0,0 @@
-# @vincentt-xr/harness
-
-The Vincentt AR dev-loop harness. It is **one always-on diagnostics channel**
-between the AR app running on a phone and the coding agent running on a laptop,
-so the agent can see what the phone sees — console logs, network requests,
-performance — without the developer hand-ferrying DevTools traces or pasting
-console output.
-
-Agent-agnostic: the agent side is a plain **MCP server**, so any MCP-capable
-agent (Claude Code, Codex, Cursor, Cline, …) uses it the same way.
-
-## The three parts
-
-```
-  PHONE (preview app)          RELAY (laptop)         AGENT (laptop)
-  ┌──────────────────┐    ┌────────────────┐    ┌────────────────────┐
-  │ HarnessProvider  │    │  harness-relay │    │  harness-mcp       │
-  │ • patch console  │─ws→│  ring buffer   │←──→│  diag_logs         │
-  │ • wrap fetch/XHR │    │  per session   │http│  diag_network      │
-  │ • sample perf    │    │                │    │  diag_trace        │
-  └──────────────────┘    └────────────────┘    └────────────────────┘
-   src/client (npm pkg)      src/relay (bin)        src/mcp (bin)
-```
-
-- **`src/client`** — the in-app half; the published npm package. `HarnessProvider`
-  patches `console.*`, wraps `fetch`/`XHR`, and samples `performance`, shipping
-  events to the relay over a WebSocket. Auto-on in a dev build, no-op (and
-  tree-shaken) in production.
-- **`src/relay`** — a small WebSocket + HTTP server beside Vite. Holds a bounded
-  ring buffer of recent events per session. The phone pushes; the agent pulls.
-- **`src/mcp`** — the agent-agnostic MCP server. Exposes `diag_logs`,
-  `diag_network`, `diag_trace` that pull from the relay.
-
-- **`src/shared/events.ts`** — the wire contract all three import, so they can't
-  drift on the event shape.
-
-## Use it
-
-**In the app (once):**
-
-```tsx
-import { HarnessProvider } from "@vincentt-xr/harness";
-
-<HarnessProvider>
-  <App />
-</HarnessProvider>;
-```
-
-That's the whole author-facing surface. It self-activates in dev and disappears
-in the production build.
-
-**Run the relay** beside your dev server (the preview tunnel carries its socket
-to the phone):
-
-```
-npx harness-relay          # listens on :7331, ws path /__harness
-```
-
-**Point your agent at the MCP server.** In the agent's MCP config:
-
-```json
-{
-  "mcpServers": {
-    "vincentt-harness": { "command": "npx", "args": ["harness-mcp"] }
-  }
-}
-```
-
-Then, while the app is open on the phone, the agent calls `diag_logs`,
-`diag_network`, `diag_trace` to read what the device is doing — no DevTools, no
-copy-paste.
-
-## Develop
-
-```
-pnpm install
-pnpm test         # unit tests (pure event-shaping, buffer, ring store, formatting, fps)
-pnpm typecheck
-pnpm build        # emits dist/ (client = npm surface; relay/mcp = bins)
-```
-
-## Status
-
-Local-first. The diagnostics limb is built and proven end-to-end
-(phone → relay → agent). The platform lifecycle (per-project server-minted
-tunnels, `createProject`/`publish`, auth) is a separate later phase; the same
-client + relay also feed the production client-review service.

package/dist/mcp/backend.d.ts

@@ -1,52 +0,0 @@
-import type { ResolvedConfig } from "../shared/config.js";
-export interface CreatedProject {
-    projectId: string;
-    slug: string;
-    name: string;
-}
-export interface PublishResult {
-    version: number;
-    /** Immutable versioned URL (<slug>.<apex>/v<n>/). */
-    url: string;
-    /** Stable live alias (<slug>.<apex>/). */
-    liveUrl: string;
-}
-export declare class BackendError extends Error {
-    readonly status?: number | undefined;
-    constructor(message: string, status?: number | undefined);
-}
-/**
- * Create a backend project (reuses POST /projects). A `slug` pins the permanent
- * <slug>.vincentt.app host; omit it and the platform assigns a catchy one. A
- * taken slug comes back 409, surfaced so the caller can re-ask.
- */
-export declare function createProject(cfg: ResolvedConfig, name: string, slug?: string): Promise<CreatedProject>;
-export interface MintedTunnel {
-    tunnelId: string;
-    /** The public host the phone opens: <slug>-<token>.<previewApex>. */
-    hostname: string;
-    /** cloudflared run token — `cloudflared tunnel run --token <this>`. */
-    runToken: string;
-    /** DNS record id, passed back on reap. */
-    dnsRecordId: string;
-}
-/** Mint a per-session dev tunnel for `localPort` (the backend holds CF creds). */
-export declare function mintTunnel(cfg: ResolvedConfig, projectId: string, localPort: number): Promise<MintedTunnel>;
-/** Tear down a session tunnel (DNS route + tunnel). Best-effort; never throws. */
-export declare function reapTunnel(cfg: ResolvedConfig, projectId: string, ref: {
-    tunnelId: string;
-    dnsRecordId?: string;
-}): Promise<void>;
-/** Recursively list files under `dir`, returning dir-relative POSIX paths. */
-export declare function walkDir(dir: string, base?: string): Promise<string[]>;
-/**
- * Upload a locally-built dist and make it live. Each file rides as a multipart
- * part whose filename is its dist-relative path (the backend reconstructs the
- * tree). Requires an index.html at the dist root.
- */
-export declare function publishUpload(cfg: ResolvedConfig, projectId: string, distDir: string, opts?: {
-    note?: string;
-    commitSha?: string;
-}): Promise<PublishResult>;
-/** The working tree's current commit, for publish provenance. Undefined if not a repo. */
-export declare function gitHeadSha(cwd: string): Promise<string | undefined>;

package/dist/mcp/backend.js

@@ -1,146 +0,0 @@
-// The lifecycle verbs' backend calls, isolated from the MCP SDK wiring (server.ts)
-// so they're unit-testable and the transport can change without touching them.
-// Every call is PAT-authed (Bearer). The publish path uploads an already-built
-// dist as-is — the backend never rebuilds (Principle 0).
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-export class BackendError extends Error {
-    status;
-    constructor(message, status) {
-        super(message);
-        this.status = status;
-        this.name = "BackendError";
-    }
-}
-async function authFetch(cfg, pathname, init = {}) {
-    return fetch(`${cfg.apiUrl}${pathname}`, {
-        ...init,
-        headers: { ...(init.headers ?? {}), authorization: `Bearer ${cfg.pat}` },
-    });
-}
-async function safeText(res) {
-    try {
-        return (await res.text()).slice(0, 300);
-    }
-    catch {
-        return "";
-    }
-}
-/**
- * Create a backend project (reuses POST /projects). A `slug` pins the permanent
- * <slug>.vincentt.app host; omit it and the platform assigns a catchy one. A
- * taken slug comes back 409, surfaced so the caller can re-ask.
- */
-export async function createProject(cfg, name, slug) {
-    const res = await authFetch(cfg, "/projects", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ name, ...(slug ? { slug } : {}) }),
-    });
-    if (res.status === 409) {
-        throw new BackendError(`slug "${slug}" is already in use — pick another.`, 409);
-    }
-    if (!res.ok) {
-        throw new BackendError(`create project failed (${res.status}): ${await safeText(res)}`, res.status);
-    }
-    const p = (await res.json());
-    const projectId = p._id ?? p.id;
-    if (!projectId || !p.slug) {
-        throw new BackendError("create project: response missing id/slug");
-    }
-    return { projectId, slug: p.slug, name: p.name ?? name };
-}
-/** Mint a per-session dev tunnel for `localPort` (the backend holds CF creds). */
-export async function mintTunnel(cfg, projectId, localPort) {
-    const res = await authFetch(cfg, `/projects/${projectId}/tunnel`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ port: localPort }),
-    });
-    if (!res.ok) {
-        throw new BackendError(`tunnel mint failed (${res.status}): ${await safeText(res)}`, res.status);
-    }
-    return (await res.json());
-}
-/** Tear down a session tunnel (DNS route + tunnel). Best-effort; never throws. */
-export async function reapTunnel(cfg, projectId, ref) {
-    try {
-        await authFetch(cfg, `/projects/${projectId}/tunnel/reap`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(ref),
-        });
-    }
-    catch {
-        // Reap is a cleanup courtesy — a failure must never crash the preview teardown.
-    }
-}
-/** Recursively list files under `dir`, returning dir-relative POSIX paths. */
-export async function walkDir(dir, base = dir) {
-    const out = [];
-    let entries;
-    try {
-        entries = await fs.readdir(dir, { withFileTypes: true });
-    }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            throw new BackendError(`dist directory not found: ${dir}`);
-        }
-        throw err;
-    }
-    for (const entry of entries) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...(await walkDir(full, base)));
-        else if (entry.isFile())
-            out.push(path.relative(base, full).split(path.sep).join("/"));
-    }
-    return out;
-}
-/**
- * Upload a locally-built dist and make it live. Each file rides as a multipart
- * part whose filename is its dist-relative path (the backend reconstructs the
- * tree). Requires an index.html at the dist root.
- */
-export async function publishUpload(cfg, projectId, distDir, opts = {}) {
-    const files = await walkDir(distDir);
-    if (!files.includes("index.html")) {
-        throw new BackendError(`dist at ${distDir} has no index.html at its root — did the build run?`);
-    }
-    const form = new FormData();
-    // The real dist-relative paths ride as an ordered manifest — a multipart filename
-    // can't carry a directory (FormData strips it to a basename), so the backend maps
-    // paths[i] → files[i] to rebuild the tree.
-    form.append("paths", JSON.stringify(files));
-    for (const rel of files) {
-        const bytes = await fs.readFile(path.join(distDir, rel));
-        // Uint8Array (Buffer) is a valid BlobPart; the filename is cosmetic (the backend
-        // uses the manifest), but pass the basename so server logs read sensibly.
-        form.append("files", new Blob([bytes]), path.basename(rel));
-    }
-    if (opts.note)
-        form.append("note", opts.note);
-    if (opts.commitSha)
-        form.append("commitSha", opts.commitSha);
-    const res = await authFetch(cfg, `/projects/${projectId}/publish/upload`, {
-        method: "POST",
-        body: form,
-    });
-    if (!res.ok) {
-        throw new BackendError(`publish failed (${res.status}): ${await safeText(res)}`, res.status);
-    }
-    return (await res.json());
-}
-/** The working tree's current commit, for publish provenance. Undefined if not a repo. */
-export async function gitHeadSha(cwd) {
-    try {
-        const { stdout } = await execFileAsync("git", ["-C", cwd, "rev-parse", "HEAD"]);
-        return stdout.trim();
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/mcp/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/mcp/cli.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// `harness-mcp` — the agent-side MCP server. An MCP agent spawns this over
-// stdio. Point it at a non-default relay with --relay-url.
-import { runStdio } from "./server.js";
-const urlArg = process.argv.indexOf("--relay-url");
-const relayUrl = urlArg !== -1 ? process.argv[urlArg + 1] : undefined;
-runStdio({ relayUrl }).catch((err) => {
-    console.error("[harness-mcp] fatal:", err);
-    process.exit(1);
-});

package/dist/mcp/diagnostics.d.ts

@@ -1,13 +0,0 @@
-import type { DiagEvent, LogEvent, NetworkEvent, RelayQuery, RelayResult, TraceEvent } from "../shared/events.js";
-export interface RelayClient {
-    query(q: RelayQuery): Promise<RelayResult>;
-}
-/** A RelayClient backed by the relay's HTTP /query endpoint. */
-export declare function httpRelayClient(baseUrl: string): RelayClient;
-export declare function formatLog(e: LogEvent, now: number): string;
-export declare function formatNetwork(e: NetworkEvent, now: number): string;
-export declare function formatTrace(e: TraceEvent, now: number): string;
-/** Render a RelayResult for one kind into the text block a tool returns. */
-export declare function renderResult(result: RelayResult, kind: DiagEvent["kind"], now: number): string;
-/** Only-errors convenience filter applied on top of a log query result. */
-export declare function filterErrors(result: RelayResult): RelayResult;