@apisurf/wire-db 0.1.1

package/dist/index.js

@@ -0,0 +1,1237 @@
+// src/open.ts
+import { dirname, isAbsolute, resolve } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import Database from "better-sqlite3";
+
+// src/schema.ts
+var MIGRATIONS = [
+  // ---------------------------------------------------------------------------
+  // 001 — initial schema
+  // ---------------------------------------------------------------------------
+  `
+  -- One row per \`wire execute\`.
+  CREATE TABLE runs (
+    id            INTEGER PRIMARY KEY,
+    uid           TEXT    NOT NULL UNIQUE,        -- stable external id
+    label         TEXT,                           -- --label, else the entry basename
+    entry         TEXT    NOT NULL,               -- absolute path of the executed file
+    cwd           TEXT    NOT NULL,
+    node_version  TEXT    NOT NULL,
+    started_at    INTEGER NOT NULL,               -- epoch ms
+    finished_at   INTEGER,                        -- NULL while in flight / on hard crash
+    exit_status   TEXT,                           -- 'ok' | 'error'
+    error_name    TEXT,
+    error_message TEXT
+  );
+  CREATE INDEX idx_runs_started ON runs (started_at DESC);
+
+  -- Interned dimensions. Every one is a small, hot, fully-cached table.
+  CREATE TABLE methods       (id INTEGER PRIMARY KEY, method       TEXT NOT NULL UNIQUE);
+  CREATE TABLE hosts         (id INTEGER PRIMARY KEY, host         TEXT NOT NULL UNIQUE);
+  CREATE TABLE content_types (id INTEGER PRIMARY KEY, content_type TEXT NOT NULL UNIQUE);
+  CREATE TABLE header_names  (id INTEGER PRIMARY KEY, name         TEXT NOT NULL UNIQUE);
+
+  -- Content-addressed payloads. \`sha256\` is over the bytes AS STORED (i.e. after
+  -- redaction and truncation), which is exactly the dedupe key we want: two
+  -- captures that would render identically share one row.
+  CREATE TABLE bodies (
+    id          INTEGER PRIMARY KEY,
+    sha256      BLOB    NOT NULL UNIQUE,          -- 32 raw bytes, not hex
+    size        INTEGER NOT NULL,                 -- ORIGINAL length before truncation
+    stored_size INTEGER NOT NULL,                 -- length(content)
+    truncated   INTEGER NOT NULL DEFAULT 0,
+    is_text     INTEGER NOT NULL DEFAULT 1,       -- 0 => binary, content is raw bytes
+    content     BLOB    NOT NULL
+  );
+
+  -- Full-text index over text payloads. Populated once per *unique* body.
+  -- Query it directly:  SELECT body_id FROM body_fts WHERE body_fts MATCH 'foo'
+  CREATE VIRTUAL TABLE body_fts USING fts5(
+    content,
+    body_id UNINDEXED,
+    tokenize = 'unicode61'
+  );
+
+  CREATE TABLE requests (
+    id                       INTEGER PRIMARY KEY,
+    run_id                   INTEGER NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    seq                      INTEGER NOT NULL,    -- capture order within the run
+    ts                       INTEGER NOT NULL,    -- epoch ms at request start
+    method_id                INTEGER NOT NULL REFERENCES methods (id),
+    host_id                  INTEGER NOT NULL REFERENCES hosts (id),
+    path                     TEXT    NOT NULL,
+    query                    TEXT,                -- search string without the '?'
+    url                      TEXT    NOT NULL,
+    status                   INTEGER,             -- NULL when the request never got a response
+    ok                       INTEGER,
+    error_name               TEXT,
+    error_message            TEXT,
+    duration_ms              REAL    NOT NULL,
+    dns_ms                   REAL,
+    connect_ms               REAL,
+    tls_ms                   REAL,
+    ttfb_ms                  REAL,
+    download_ms              REAL,
+    request_bytes            INTEGER NOT NULL DEFAULT 0,
+    response_bytes           INTEGER NOT NULL DEFAULT 0,
+    request_content_type_id  INTEGER REFERENCES content_types (id),
+    response_content_type_id INTEGER REFERENCES content_types (id),
+    request_body_id          INTEGER REFERENCES bodies (id),
+    response_body_id         INTEGER REFERENCES bodies (id)
+  );
+  CREATE UNIQUE INDEX idx_requests_run_seq ON requests (run_id, seq);
+  CREATE INDEX idx_requests_ts     ON requests (ts DESC);
+  CREATE INDEX idx_requests_host   ON requests (host_id, ts DESC);
+  CREATE INDEX idx_requests_status ON requests (status);
+  CREATE INDEX idx_requests_slow   ON requests (duration_ms DESC);
+
+  -- kind: 0 = request, 1 = response. \`ord\` preserves wire order and keeps
+  -- repeated headers (Set-Cookie) as distinct rows.
+  CREATE TABLE headers (
+    request_id INTEGER NOT NULL REFERENCES requests (id) ON DELETE CASCADE,
+    kind       INTEGER NOT NULL,
+    ord        INTEGER NOT NULL,
+    name_id    INTEGER NOT NULL REFERENCES header_names (id),
+    value      TEXT    NOT NULL,
+    PRIMARY KEY (request_id, kind, ord)
+  ) WITHOUT ROWID;
+  -- Reverse lookup: find requests by header name, or by name+value prefix.
+  CREATE INDEX idx_headers_name ON headers (name_id, value);
+
+  CREATE TABLE tags (
+    request_id INTEGER NOT NULL REFERENCES requests (id) ON DELETE CASCADE,
+    key        TEXT    NOT NULL,
+    value      TEXT    NOT NULL,
+    PRIMARY KEY (request_id, key)
+  ) WITHOUT ROWID;
+  CREATE INDEX idx_tags_kv ON tags (key, value);
+
+  -- ---------------------------------------------------------------------------
+  -- Views: the denormalized surface. Normalization is for the query planner;
+  -- these are for whoever is typing \`wire sql\`.
+  -- ---------------------------------------------------------------------------
+
+  CREATE VIEW v_requests AS
+  SELECT
+    r.id,
+    r.run_id,
+    r.seq,
+    r.ts,
+    m.method            AS method,
+    h.host              AS host,
+    r.path,
+    r.query,
+    r.url,
+    r.status,
+    r.ok,
+    r.error_name,
+    r.error_message,
+    r.duration_ms,
+    r.dns_ms,
+    r.connect_ms,
+    r.tls_ms,
+    r.ttfb_ms,
+    r.download_ms,
+    r.request_bytes,
+    r.response_bytes,
+    rct.content_type    AS request_content_type,
+    sct.content_type    AS response_content_type,
+    r.request_body_id,
+    r.response_body_id
+  FROM requests r
+  JOIN methods m        ON m.id   = r.method_id
+  JOIN hosts   h        ON h.id   = r.host_id
+  LEFT JOIN content_types rct ON rct.id = r.request_content_type_id
+  LEFT JOIN content_types sct ON sct.id = r.response_content_type_id;
+
+  CREATE VIEW v_headers AS
+  SELECT
+    hd.request_id,
+    CASE hd.kind WHEN 0 THEN 'request' ELSE 'response' END AS kind,
+    hd.ord,
+    hn.name  AS name,
+    hd.value AS value
+  FROM headers hd
+  JOIN header_names hn ON hn.id = hd.name_id;
+
+  -- Text bodies decoded to TEXT so they are greppable straight out of a query;
+  -- binary bodies surface as NULL text with their size intact.
+  CREATE VIEW v_bodies AS
+  SELECT
+    b.id,
+    b.size,
+    b.stored_size,
+    b.truncated,
+    b.is_text,
+    CASE WHEN b.is_text = 1 THEN CAST(b.content AS TEXT) END AS text
+  FROM bodies b;
+
+  -- Run summary with counters computed on read, so they are always correct even
+  -- if a run is killed mid-flight and never gets to finalize.
+  CREATE VIEW v_runs AS
+  SELECT
+    r.id,
+    r.uid,
+    r.label,
+    r.entry,
+    r.cwd,
+    r.node_version,
+    r.started_at,
+    r.finished_at,
+    r.exit_status,
+    r.error_name,
+    r.error_message,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id) AS request_count,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id
+       AND (q.error_name IS NOT NULL OR q.status >= 400))   AS error_count,
+    (SELECT SUM(q.duration_ms) FROM requests q WHERE q.run_id = r.id) AS total_duration_ms,
+    (SELECT SUM(q.request_bytes + q.response_bytes) FROM requests q
+       WHERE q.run_id = r.id)                               AS total_bytes
+  FROM runs r;
+  `,
+  // ---------------------------------------------------------------------------
+  // 002 — WebSocket and SSE
+  //
+  // A connection is a request. It has a url, a host, a handshake, a status and
+  // a duration, and modelling it as anything else would have meant a second of
+  // everything: headers, tags, byte counts, run totals, views, UI. So `requests`
+  // gains a `kind`, and the frames and events hang off it in one new table.
+  //
+  // For a connection, the request columns read slightly differently:
+  //   status         101 for a WebSocket upgrade, the response status for SSE
+  //   duration_ms    how long it stayed open, not how slow it was
+  //   connect_ms     the handshake
+  //   ttfb_ms        time to the first message in
+  //   request_bytes  total sent  /  response_bytes  total received
+  // ---------------------------------------------------------------------------
+  `
+  ALTER TABLE requests ADD COLUMN kind TEXT NOT NULL DEFAULT 'http';
+  CREATE INDEX idx_requests_kind ON requests (kind);
+
+  -- Interned like every other repeated low-cardinality string. For WebSockets
+  -- that is 'text' | 'binary' | 'close'; for SSE it is the event name, which is
+  -- the same handful of values over and over.
+  CREATE TABLE message_names (id INTEGER PRIMARY KEY, name TEXT NOT NULL UNIQUE);
+
+  -- One row per WebSocket frame or SSE event. Payloads go through the same
+  -- content-addressed \`bodies\` table as HTTP ones, so a socket that echoes the
+  -- same heartbeat 10,000 times stores it once and is searchable in body_fts.
+  CREATE TABLE messages (
+    id         INTEGER PRIMARY KEY,
+    request_id INTEGER NOT NULL REFERENCES requests (id) ON DELETE CASCADE,
+    seq        INTEGER NOT NULL,               -- order within the connection
+    ts         INTEGER NOT NULL,               -- epoch ms
+    dir        INTEGER NOT NULL,               -- 0 = sent, 1 = received
+    name_id    INTEGER NOT NULL REFERENCES message_names (id),
+    code       INTEGER,                        -- WebSocket close code
+    event_id   TEXT,                           -- SSE event id
+    bytes      INTEGER NOT NULL DEFAULT 0,     -- payload size before truncation
+    body_id    INTEGER REFERENCES bodies (id)
+  );
+  CREATE UNIQUE INDEX idx_messages_request_seq ON messages (request_id, seq);
+  CREATE INDEX idx_messages_ts ON messages (ts);
+
+  -- v_requests gains \`kind\` and a message count. Views cannot be altered, so it
+  -- is dropped and rebuilt.
+  DROP VIEW v_requests;
+  CREATE VIEW v_requests AS
+  SELECT
+    r.id,
+    r.run_id,
+    r.seq,
+    r.ts,
+    r.kind,
+    m.method            AS method,
+    h.host              AS host,
+    r.path,
+    r.query,
+    r.url,
+    r.status,
+    r.ok,
+    r.error_name,
+    r.error_message,
+    r.duration_ms,
+    r.dns_ms,
+    r.connect_ms,
+    r.tls_ms,
+    r.ttfb_ms,
+    r.download_ms,
+    r.request_bytes,
+    r.response_bytes,
+    rct.content_type    AS request_content_type,
+    sct.content_type    AS response_content_type,
+    r.request_body_id,
+    r.response_body_id,
+    (SELECT COUNT(*) FROM messages g WHERE g.request_id = r.id) AS message_count
+  FROM requests r
+  JOIN methods m        ON m.id   = r.method_id
+  JOIN hosts   h        ON h.id   = r.host_id
+  LEFT JOIN content_types rct ON rct.id = r.request_content_type_id
+  LEFT JOIN content_types sct ON sct.id = r.response_content_type_id;
+
+  -- Messages with their payload decoded, the way v_bodies does it: text is
+  -- greppable straight out of a query, binary surfaces as NULL with its size.
+  CREATE VIEW v_messages AS
+  SELECT
+    g.id,
+    g.request_id,
+    r.run_id,
+    r.kind,
+    hh.host || r.path AS endpoint,
+    g.seq,
+    g.ts,
+    CASE g.dir WHEN 0 THEN 'sent' ELSE 'received' END AS direction,
+    n.name,
+    g.code,
+    g.event_id,
+    g.bytes,
+    g.body_id,
+    b.truncated,
+    CASE WHEN b.is_text = 1 THEN CAST(b.content AS TEXT) END AS text
+  FROM messages g
+  JOIN message_names n ON n.id = g.name_id
+  JOIN requests r      ON r.id = g.request_id
+  JOIN hosts   hh      ON hh.id = r.host_id
+  LEFT JOIN bodies b   ON b.id = g.body_id;
+
+  -- v_runs gains the message count. Byte totals already include socket traffic:
+  -- a connection's request_bytes/response_bytes are the sums of its messages.
+  DROP VIEW v_runs;
+  CREATE VIEW v_runs AS
+  SELECT
+    r.id,
+    r.uid,
+    r.label,
+    r.entry,
+    r.cwd,
+    r.node_version,
+    r.started_at,
+    r.finished_at,
+    r.exit_status,
+    r.error_name,
+    r.error_message,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id) AS request_count,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id
+       AND (q.error_name IS NOT NULL OR q.status >= 400))   AS error_count,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id
+       AND q.kind <> 'http')                                AS connection_count,
+    (SELECT COUNT(*) FROM messages g JOIN requests q ON q.id = g.request_id
+       WHERE q.run_id = r.id)                               AS message_count,
+    (SELECT SUM(q.duration_ms) FROM requests q WHERE q.run_id = r.id) AS total_duration_ms,
+    (SELECT SUM(q.request_bytes + q.response_bytes) FROM requests q
+       WHERE q.run_id = r.id)                               AS total_bytes
+  FROM runs r;
+  `,
+  // ---------------------------------------------------------------------------
+  // 003 — where a run came from
+  //
+  // Two facts a recording could not previously carry.
+  //
+  //   env           which environment it ran against. Without it, two runs of
+  //                 the same script against staging and prod are
+  //                 indistinguishable after the fact, which undercuts the whole
+  //                 point of keeping the history.
+  //   entry_source  the snippet, for runs started with `execute -e` or stdin.
+  //                 An inline run has no file to go back to, so without this it
+  //                 is the one kind of run that cannot be reproduced from the
+  //                 database.
+  //
+  // Both are nullable: every run recorded before this migration predates the
+  // question, and NULL is the honest answer rather than a fabricated default.
+  // ---------------------------------------------------------------------------
+  `
+  ALTER TABLE runs ADD COLUMN env          TEXT;
+  ALTER TABLE runs ADD COLUMN entry_source TEXT;
+  CREATE INDEX idx_runs_env ON runs (env);
+
+  DROP VIEW v_runs;
+  CREATE VIEW v_runs AS
+  SELECT
+    r.id,
+    r.uid,
+    r.label,
+    r.entry,
+    r.entry_source,
+    r.cwd,
+    r.env,
+    r.node_version,
+    r.started_at,
+    r.finished_at,
+    r.exit_status,
+    r.error_name,
+    r.error_message,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id) AS request_count,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id
+       AND (q.error_name IS NOT NULL OR q.status >= 400))   AS error_count,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id
+       AND q.kind <> 'http')                                AS connection_count,
+    (SELECT COUNT(*) FROM messages g JOIN requests q ON q.id = g.request_id
+       WHERE q.run_id = r.id)                               AS message_count,
+    (SELECT SUM(q.duration_ms) FROM requests q WHERE q.run_id = r.id) AS total_duration_ms,
+    (SELECT SUM(q.request_bytes + q.response_bytes) FROM requests q
+       WHERE q.run_id = r.id)                               AS total_bytes
+  FROM runs r;
+  `,
+  // ---------------------------------------------------------------------------
+  // 004 — checks
+  //
+  // What a run ASSERTED, next to what it observed. A recording says a request
+  // returned 200 in 40 ms; only the script's author knows whether that was the
+  // right answer. `check()` and `assert()` write that judgement down at the
+  // moment it was made, so a run carries its own verdict instead of leaving one
+  // to be re-derived from the traffic later.
+  //
+  // A check hangs off the run rather than off a request on purpose. Plenty of
+  // them are not about a single exchange — "the cart total matches the sum of
+  // its lines" spans three — and pinning every check to one request would have
+  // meant either guessing which, or refusing the ones that fit none.
+  //
+  //   mode     'check'  recorded, execution continues
+  //            'assert' recorded, then thrown — this is the last check in the run
+  //   status   'pass' | 'fail'
+  //   message  the author's line, stored only on a failure, which is the only
+  //            time it describes anything. NULL on a pass, and NULL when the
+  //            author passed no message at all.
+  // ---------------------------------------------------------------------------
+  `
+  CREATE TABLE checks (
+    id      INTEGER PRIMARY KEY,
+    run_id  INTEGER NOT NULL REFERENCES runs (id) ON DELETE CASCADE,
+    seq     INTEGER NOT NULL,                -- order within the run, from 0
+    ts      INTEGER NOT NULL,                -- epoch ms, when the check ran
+    name    TEXT    NOT NULL,                -- what was being checked
+    mode    TEXT    NOT NULL,                -- 'check' | 'assert'
+    status  TEXT    NOT NULL,                -- 'pass' | 'fail'
+    message TEXT                             -- the author's message, on failure
+  );
+  CREATE UNIQUE INDEX idx_checks_run_seq ON checks (run_id, seq);
+  -- "every failure across every run", the query this table exists to answer.
+  CREATE INDEX idx_checks_status ON checks (status, run_id);
+  -- One check's history: has "login returns 200" always passed?
+  CREATE INDEX idx_checks_name ON checks (name, ts DESC);
+
+  -- A straight projection today. It exists so checks are part of the documented
+  -- view surface \u2014 what \`wire schema\` lists, what \`get\` and \`ls\` read \u2014 rather
+  -- than a raw table callers are expected to know the shape of.
+  CREATE VIEW v_checks AS
+  SELECT c.id, c.run_id, c.seq, c.ts, c.name, c.mode, c.status, c.message
+  FROM checks c;
+
+  -- v_runs gains the two counters that make a run's verdict readable without a
+  -- join: how many checks it made, and how many of them failed.
+  DROP VIEW v_runs;
+  CREATE VIEW v_runs AS
+  SELECT
+    r.id,
+    r.uid,
+    r.label,
+    r.entry,
+    r.entry_source,
+    r.cwd,
+    r.env,
+    r.node_version,
+    r.started_at,
+    r.finished_at,
+    r.exit_status,
+    r.error_name,
+    r.error_message,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id) AS request_count,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id
+       AND (q.error_name IS NOT NULL OR q.status >= 400))   AS error_count,
+    (SELECT COUNT(*) FROM requests q WHERE q.run_id = r.id
+       AND q.kind <> 'http')                                AS connection_count,
+    (SELECT COUNT(*) FROM messages g JOIN requests q ON q.id = g.request_id
+       WHERE q.run_id = r.id)                               AS message_count,
+    (SELECT COUNT(*) FROM checks c WHERE c.run_id = r.id)   AS check_count,
+    (SELECT COUNT(*) FROM checks c WHERE c.run_id = r.id
+       AND c.status = 'fail')                               AS failed_check_count,
+    (SELECT SUM(q.duration_ms) FROM requests q WHERE q.run_id = r.id) AS total_duration_ms,
+    (SELECT SUM(q.request_bytes + q.response_bytes) FROM requests q
+       WHERE q.run_id = r.id)                               AS total_bytes
+  FROM runs r;
+  `
+];
+var SCHEMA_VERSION = MIGRATIONS.length;
+
+// src/open.ts
+var DEFAULT_DB_FILENAME = "wire.sqlite";
+function resolveDbPath(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const raw = options.path ?? DEFAULT_DB_FILENAME;
+  return isAbsolute(raw) ? raw : resolve(cwd, raw);
+}
+function openDb(options = {}) {
+  const file = resolveDbPath(options);
+  if (options.mustExist && !existsSync(file)) {
+    throw new Error(
+      `No database at ${file}. Run \`wire execute <file>\` first, or pass --db <path>.`
+    );
+  }
+  if (!options.mustExist) mkdirSync(dirname(file), { recursive: true });
+  const db = new Database(file);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("temp_store = MEMORY");
+  db.pragma("cache_size = -65536");
+  db.pragma("foreign_keys = ON");
+  if (!options.skipMigrations) applyMigrations(db);
+  return db;
+}
+function applyMigrations(db) {
+  const current = db.pragma("user_version", { simple: true });
+  if (current > MIGRATIONS.length) {
+    throw new Error(
+      `Database schema version ${current} is newer than this build of wire understands (${MIGRATIONS.length}). Upgrade the CLI.`
+    );
+  }
+  for (let version = current; version < MIGRATIONS.length; version++) {
+    const sql = MIGRATIONS[version];
+    if (!sql) continue;
+    db.exec(`BEGIN; ${sql} PRAGMA user_version = ${version + 1}; COMMIT;`);
+  }
+}
+
+// src/entities.ts
+var COMPUTED_TYPES = {
+  "v_runs.request_count": "INTEGER",
+  "v_runs.error_count": "INTEGER",
+  "v_runs.connection_count": "INTEGER",
+  "v_runs.message_count": "INTEGER",
+  "v_runs.check_count": "INTEGER",
+  "v_runs.failed_check_count": "INTEGER",
+  "v_runs.total_duration_ms": "REAL",
+  "v_runs.total_bytes": "INTEGER",
+  "v_requests.message_count": "INTEGER",
+  "v_messages.endpoint": "TEXT",
+  "v_messages.direction": "TEXT",
+  "v_messages.text": "TEXT",
+  "v_headers.kind": "TEXT",
+  "v_bodies.text": "TEXT"
+};
+var RELATION_DESCRIPTIONS = {
+  v_runs: "One row per execute, counts computed on read.",
+  v_requests: "One HTTP request, or one WebSocket/SSE connection.",
+  v_headers: "Request and response headers, in wire order.",
+  v_bodies: "Deduped payloads, content-addressed by SHA-256.",
+  v_messages: "WebSocket frames and SSE events, with payloads.",
+  v_checks: "Assertions a run made, from check() and assert().",
+  tags: "Per-request key/value tags, from execute --tag.",
+  body_fts: "FTS5 index over text payloads. Join on body_id."
+};
+function listRelations(db, options = {}) {
+  const types = options.all ? ["view", "table"] : ["view"];
+  const rows = db.prepare(
+    `SELECT name, type FROM sqlite_master
+       WHERE type IN (${types.map(() => "?").join(", ")})
+         AND name NOT LIKE 'sqlite_%'
+         AND name NOT LIKE 'body_fts_%'
+       ORDER BY type DESC, name`
+  ).all(...types);
+  return rows.map((r) => ({
+    name: r.name,
+    type: r.type,
+    description: RELATION_DESCRIPTIONS[r.name] ?? null
+  }));
+}
+function relationExists(db, name) {
+  const row = db.prepare(`SELECT 1 FROM sqlite_master WHERE name = ? AND type IN ('view', 'table')`).get(name);
+  return row !== void 0;
+}
+function describeRelation(db, name) {
+  const rows = db.prepare(`SELECT name, type FROM pragma_table_info(?) ORDER BY cid`).all(name);
+  return rows.map((r) => {
+    const declared = r.type.trim();
+    if (declared) return { name: r.name, type: declared, computed: false };
+    return {
+      name: r.name,
+      type: COMPUTED_TYPES[`${name}.${r.name}`] ?? "",
+      computed: true
+    };
+  });
+}
+function untypedColumns(db) {
+  const missing = [];
+  for (const rel of listRelations(db)) {
+    for (const col of describeRelation(db, rel.name)) {
+      if (col.computed && !col.type) missing.push(`${rel.name}.${col.name}`);
+    }
+  }
+  return missing;
+}
+var ENTITIES = [
+  {
+    name: "run",
+    plural: "runs",
+    view: "v_runs",
+    key: "id",
+    defaultFields: ["id", "uid", "label", "started_at", "exit_status", "request_count"],
+    description: "One execute.",
+    filters: {},
+    order: "started_at DESC",
+    derived: {}
+  },
+  {
+    name: "request",
+    plural: "requests",
+    view: "v_requests",
+    key: "id",
+    defaultFields: ["id", "seq", "method", "host", "path", "status", "duration_ms"],
+    description: "One HTTP request, or one WebSocket/SSE connection.",
+    filters: { run: "run_id" },
+    order: "id DESC",
+    derived: {}
+  },
+  {
+    name: "check",
+    plural: "checks",
+    view: "v_checks",
+    key: "id",
+    // `message` earns its place in a default set the way no other payload-ish
+    // column does: it is at most a line, and it is the answer to the only
+    // question anyone asks a failing check.
+    defaultFields: ["id", "run_id", "seq", "name", "status", "message"],
+    description: "One assertion, from check() or assert().",
+    filters: { run: "run_id" },
+    order: "id DESC",
+    derived: {}
+  },
+  {
+    name: "body",
+    plural: "bodies",
+    view: "v_bodies",
+    key: "id",
+    defaultFields: ["id", "size", "stored_size", "truncated", "is_text", "preview"],
+    description: "One deduped payload.",
+    filters: {},
+    order: "id DESC",
+    derived: { preview: "text" }
+  },
+  {
+    name: "message",
+    plural: "messages",
+    view: "v_messages",
+    key: "id",
+    defaultFields: ["id", "request_id", "seq", "direction", "name", "bytes"],
+    description: "One WebSocket frame or SSE event.",
+    filters: { run: "run_id", request: "request_id" },
+    order: "id DESC",
+    derived: { preview: "text" }
+  },
+  {
+    name: "header",
+    plural: "headers",
+    view: "v_headers",
+    // Headers have no id of their own: many rows share one request_id, so
+    // `get header 42` reads as "the headers of request 42".
+    key: "request_id",
+    defaultFields: ["request_id", "kind", "name", "value"],
+    description: "Request and response headers. Keyed by request id, many per id.",
+    filters: { request: "request_id" },
+    order: "request_id DESC, kind, ord",
+    derived: {}
+  }
+];
+function findEntity(name) {
+  const wanted = name.toLowerCase();
+  return ENTITIES.find((e) => e.name === wanted || e.plural === wanted || e.view === wanted) ?? null;
+}
+function entityFields(db, entity) {
+  const columns = describeRelation(db, entity.view).map((c) => c.name);
+  return [...columns, ...Object.keys(entity.derived)];
+}
+var UnknownFieldError = class extends Error {
+  constructor(entity, field, available) {
+    super(`unknown field "${field}" on ${entity.name}`);
+    this.entity = entity;
+    this.field = field;
+    this.available = available;
+    this.name = "UnknownFieldError";
+  }
+};
+var PREVIEW_CHARS = 120;
+function assertFieldsExist(entity, fields, available) {
+  for (const field of fields) {
+    if (!available.includes(field)) {
+      throw new UnknownFieldError(entity, field, available);
+    }
+  }
+}
+function columnsFor(entity, fields) {
+  const columns = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    columns.add(entity.derived[field] ?? field);
+  }
+  if (columns.size === 0) columns.add(entity.key);
+  return [...columns];
+}
+function whereClause(entity, options) {
+  const where = [];
+  const params = [];
+  if (options.ids && options.ids.length > 0) {
+    where.push(`"${entity.key}" IN (${options.ids.map(() => "?").join(", ")})`);
+    params.push(...options.ids);
+  }
+  for (const [name, value] of Object.entries(options.filters ?? {})) {
+    const column = entity.filters[name];
+    if (!column) continue;
+    where.push(`"${column}" = ?`);
+    params.push(value);
+  }
+  return { where, params };
+}
+function selectEntity(db, entity, options) {
+  assertFieldsExist(entity, options.fields, entityFields(db, entity));
+  const columns = columnsFor(entity, options.fields);
+  const { where, params } = whereClause(entity, options);
+  const order = (entity.name === "request" || entity.name === "check") && options.filters?.run !== void 0 ? "seq" : entity.order;
+  const sql = `SELECT ${columns.map((c) => `"${c}"`).join(", ")} FROM "${entity.view}"` + (where.length ? ` WHERE ${where.join(" AND ")}` : "") + ` ORDER BY ${order}` + (options.limit !== void 0 && options.limit > 0 ? ` LIMIT ${Number(options.limit)}` : "");
+  const rows = db.prepare(sql).all(...params);
+  return rows.map((row) => {
+    const out = {};
+    for (const field of options.fields) {
+      const source = entity.derived[field];
+      out[field] = source === void 0 ? row[field] : preview(row[source]);
+    }
+    return out;
+  });
+}
+function preview(value) {
+  if (value === null || value === void 0) return null;
+  const text = typeof value === "string" ? value : String(value);
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= PREVIEW_CHARS ? flat : `${flat.slice(0, PREVIEW_CHARS)}\u2026`;
+}
+
+// src/writer.ts
+import { createHash } from "node:crypto";
+var RunWriter = class {
+  runId;
+  db;
+  seq = 0;
+  /** Check ordering is its own sequence: checks and requests interleave freely. */
+  checkSeq = 0;
+  // Interning caches: string -> row id. Bounded by the traffic's real
+  // cardinality (a handful of hosts and methods, a few dozen header names).
+  methodIds = /* @__PURE__ */ new Map();
+  hostIds = /* @__PURE__ */ new Map();
+  contentTypeIds = /* @__PURE__ */ new Map();
+  headerNameIds = /* @__PURE__ */ new Map();
+  messageNameIds = /* @__PURE__ */ new Map();
+  bodyIds = /* @__PURE__ */ new Map();
+  // uid -> requests.id, for connections. A WebSocket or SSE stream is written
+  // once when it opens and updated when it closes; this is how the second
+  // record finds the row the first one created.
+  connectionIds = /* @__PURE__ */ new Map();
+  stmt;
+  writeBatch;
+  writeCheckBatch;
+  constructor(db, run) {
+    this.db = db;
+    const internSql = (table, column) => db.prepare(
+      `INSERT INTO ${table} (${column}) VALUES (?)
+         ON CONFLICT(${column}) DO UPDATE SET ${column} = excluded.${column}
+         RETURNING id`
+    );
+    this.stmt = {
+      intern: {
+        method: internSql("methods", "method"),
+        host: internSql("hosts", "host"),
+        contentType: internSql("content_types", "content_type"),
+        headerName: internSql("header_names", "name"),
+        messageName: internSql("message_names", "name")
+      },
+      // DO NOTHING (not DO UPDATE) so a duplicate payload doesn't rewrite the
+      // blob. It returns no row on conflict; selectBody covers that path.
+      insertBody: db.prepare(
+        `INSERT INTO bodies (sha256, size, stored_size, truncated, is_text, content)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(sha256) DO NOTHING
+         RETURNING id`
+      ),
+      selectBody: db.prepare(`SELECT id FROM bodies WHERE sha256 = ?`),
+      insertFts: db.prepare(`INSERT INTO body_fts (body_id, content) VALUES (?, ?)`),
+      insertRequest: db.prepare(
+        `INSERT INTO requests (
+           run_id, seq, ts, kind, method_id, host_id, path, query, url,
+           status, ok, error_name, error_message,
+           duration_ms, dns_ms, connect_ms, tls_ms, ttfb_ms, download_ms,
+           request_bytes, response_bytes,
+           request_content_type_id, response_content_type_id,
+           request_body_id, response_body_id
+         ) VALUES (
+           @run_id, @seq, @ts, @kind, @method_id, @host_id, @path, @query, @url,
+           @status, @ok, @error_name, @error_message,
+           @duration_ms, @dns_ms, @connect_ms, @tls_ms, @ttfb_ms, @download_ms,
+           @request_bytes, @response_bytes,
+           @request_content_type_id, @response_content_type_id,
+           @request_body_id, @response_body_id
+         )`
+      ),
+      // A connection's closing record: everything that was unknown while it
+      // was open. Headers and tags are not touched — they were written on the
+      // way in and have not changed.
+      updateConnection: db.prepare(
+        `UPDATE requests SET
+           status = @status, ok = @ok,
+           error_name = @error_name, error_message = @error_message,
+           duration_ms = @duration_ms, connect_ms = @connect_ms, ttfb_ms = @ttfb_ms,
+           request_bytes = @request_bytes, response_bytes = @response_bytes
+         WHERE id = @id`
+      ),
+      insertMessage: db.prepare(
+        `INSERT INTO messages (request_id, seq, ts, dir, name_id, code, event_id, bytes, body_id)
+         VALUES (@request_id, @seq, @ts, @dir, @name_id, @code, @event_id, @bytes, @body_id)`
+      ),
+      insertHeader: db.prepare(
+        `INSERT INTO headers (request_id, kind, ord, name_id, value) VALUES (?, ?, ?, ?, ?)`
+      ),
+      insertTag: db.prepare(
+        `INSERT INTO tags (request_id, key, value) VALUES (?, ?, ?)
+         ON CONFLICT(request_id, key) DO UPDATE SET value = excluded.value`
+      ),
+      insertCheck: db.prepare(
+        `INSERT INTO checks (run_id, seq, ts, name, mode, status, message)
+         VALUES (@run_id, @seq, @ts, @name, @mode, @status, @message)`
+      ),
+      finishRun: db.prepare(
+        `UPDATE runs SET finished_at = ?, exit_status = ?, error_name = ?, error_message = ?
+         WHERE id = ?`
+      )
+    };
+    const inserted = db.prepare(
+      `INSERT INTO runs (uid, label, entry, entry_source, cwd, env, node_version, started_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      run.uid,
+      run.label,
+      run.entry,
+      run.entrySource ?? null,
+      run.cwd,
+      run.env ?? null,
+      run.nodeVersion,
+      run.startedAt
+    );
+    this.runId = Number(inserted.lastInsertRowid);
+    this.writeBatch = db.transaction((records) => {
+      for (const record of records) {
+        if (record.type === "message") this.insertMessage(record);
+        else this.insertRequest(record);
+      }
+    });
+    this.writeCheckBatch = db.transaction((records) => {
+      for (const record of records) {
+        this.stmt.insertCheck.run({
+          run_id: this.runId,
+          seq: this.checkSeq++,
+          ts: record.ts,
+          name: record.name,
+          mode: record.mode,
+          status: record.status,
+          // A message describes a failure. Keeping it off the passing rows is
+          // what makes `SELECT name, message FROM v_checks WHERE status='fail'`
+          // read as a list of reasons rather than a column half full of lines
+          // that never applied.
+          message: record.status === "fail" ? record.message ?? null : null
+        });
+      }
+    });
+  }
+  /** Persist a batch of captures in a single transaction. */
+  write(records) {
+    if (records.length === 0) return;
+    this.writeBatch(records);
+  }
+  /**
+   * Persist a batch of assertions in a single transaction.
+   *
+   * Separate from {@link RunWriter.write} because checks are not traffic: they
+   * arrive from the script itself rather than from a capture, and they carry no
+   * bodies, headers or interning. `seq` is assigned here, in arrival order, so
+   * a run's checks read back in the order the script made them.
+   */
+  writeChecks(records) {
+    if (records.length === 0) return;
+    this.writeCheckBatch(records);
+  }
+  /** Record how the run ended. */
+  finish(end) {
+    this.stmt.finishRun.run(
+      end.finishedAt,
+      end.exitStatus,
+      end.errorName ?? null,
+      end.errorMessage ?? null,
+      this.runId
+    );
+  }
+  // ---------------------------------------------------------------------------
+  /**
+   * Write one exchange. For a connection this runs twice — once at open, once
+   * at close — and the second pass updates the row rather than adding one.
+   */
+  insertRequest(r) {
+    const existing = r.uid === void 0 ? void 0 : this.connectionIds.get(r.uid);
+    if (existing !== void 0) {
+      this.updateConnection(existing, r);
+      return;
+    }
+    const result = this.stmt.insertRequest.run(this.requestRow(r));
+    const requestId = Number(result.lastInsertRowid);
+    if (r.uid !== void 0) this.connectionIds.set(r.uid, requestId);
+    this.insertHeaders(requestId, 0, r.requestHeaders);
+    this.insertHeaders(requestId, 1, r.responseHeaders);
+    if (r.tags) {
+      for (const [key, value] of Object.entries(r.tags)) {
+        this.stmt.insertTag.run(requestId, key, value);
+      }
+    }
+  }
+  /** The closing pass over a connection: outcome and timings, onto the open row. */
+  updateConnection(id, r) {
+    this.stmt.updateConnection.run({
+      id,
+      status: r.status ?? null,
+      ok: r.ok === void 0 ? null : r.ok ? 1 : 0,
+      error_name: r.error?.name ?? null,
+      error_message: r.error?.message ?? null,
+      duration_ms: r.timings.duration,
+      connect_ms: r.timings.connect ?? null,
+      ttfb_ms: r.timings.ttfb ?? null,
+      request_bytes: r.requestBytes,
+      response_bytes: r.responseBytes
+    });
+  }
+  requestRow(r) {
+    return {
+      run_id: this.runId,
+      seq: this.seq++,
+      ts: r.ts,
+      kind: r.kind,
+      method_id: this.intern("method", this.methodIds, r.method),
+      host_id: this.intern("host", this.hostIds, r.host),
+      path: r.path,
+      query: r.query,
+      url: r.url,
+      status: r.status ?? null,
+      ok: r.ok === void 0 ? null : r.ok ? 1 : 0,
+      error_name: r.error?.name ?? null,
+      error_message: r.error?.message ?? null,
+      duration_ms: r.timings.duration,
+      dns_ms: r.timings.dns ?? null,
+      connect_ms: r.timings.connect ?? null,
+      tls_ms: r.timings.tls ?? null,
+      ttfb_ms: r.timings.ttfb ?? null,
+      download_ms: r.timings.download ?? null,
+      request_bytes: r.requestBytes,
+      response_bytes: r.responseBytes,
+      request_content_type_id: this.internContentType(r.request?.contentType),
+      response_content_type_id: this.internContentType(r.response?.contentType),
+      request_body_id: this.internBody(r.request),
+      response_body_id: this.internBody(r.response)
+    };
+  }
+  /**
+   * Write one frame or event against the connection that carried it.
+   *
+   * A message whose connection is unknown is dropped: records reach a sink in
+   * order, so the only way here is a sink that reordered them, and half a
+   * connection is worse than none.
+   */
+  insertMessage(m) {
+    const requestId = this.connectionIds.get(m.connection);
+    if (requestId === void 0) return;
+    this.stmt.insertMessage.run({
+      request_id: requestId,
+      seq: m.seq,
+      ts: m.ts,
+      dir: m.direction === "sent" ? 0 : 1,
+      name_id: this.intern("messageName", this.messageNameIds, m.name),
+      code: m.code ?? null,
+      event_id: m.eventId ?? null,
+      bytes: m.bytes,
+      body_id: this.internBody(m.body)
+    });
+  }
+  insertHeaders(requestId, kind, headers) {
+    for (let ord = 0; ord < headers.length; ord++) {
+      const header = headers[ord];
+      if (!header) continue;
+      const nameId = this.intern("headerName", this.headerNameIds, header[0].toLowerCase());
+      this.stmt.insertHeader.run(requestId, kind, ord, nameId, header[1]);
+    }
+  }
+  intern(kind, cache, value) {
+    const hit = cache.get(value);
+    if (hit !== void 0) return hit;
+    const row = this.stmt.intern[kind].get(value);
+    cache.set(value, row.id);
+    return row.id;
+  }
+  internContentType(contentType) {
+    if (!contentType) return null;
+    return this.intern("contentType", this.contentTypeIds, contentType);
+  }
+  /**
+   * Store a payload once per distinct content. The SHA-256 is over the bytes as
+   * stored, so a run that polls the same unchanged endpoint 500 times keeps one
+   * copy of the response and 500 integer references to it.
+   */
+  internBody(body) {
+    if (!body) return null;
+    const digest = createHash("sha256").update(body.bytes).digest();
+    const key = digest.toString("hex");
+    const cached = this.bodyIds.get(key);
+    if (cached !== void 0) return cached;
+    const created = this.stmt.insertBody.get(
+      digest,
+      body.size,
+      body.bytes.byteLength,
+      body.truncated ? 1 : 0,
+      body.isText ? 1 : 0,
+      body.bytes
+    );
+    let id;
+    if (created) {
+      id = created.id;
+      if (body.isText) {
+        this.stmt.insertFts.run(id, Buffer.from(body.bytes).toString("utf8"));
+      }
+    } else {
+      id = this.stmt.selectBody.get(digest).id;
+    }
+    this.bodyIds.set(key, id);
+    return id;
+  }
+};
+
+// src/queries.ts
+function listRuns(db, limit = 200) {
+  return db.prepare(`SELECT * FROM v_runs ORDER BY started_at DESC LIMIT ?`).all(limit);
+}
+function getRun(db, id) {
+  return db.prepare(`SELECT * FROM v_runs WHERE id = ?`).get(id) ?? null;
+}
+function listScripts(db) {
+  return db.prepare(
+    `SELECT entry,
+              cwd,
+              label,
+              id                                  AS last_run_id,
+              MAX(started_at)                     AS last_started_at,
+              exit_status                         AS last_exit_status,
+              COUNT(*)                            AS run_count,
+              SUM(exit_status = 'error')          AS failed_run_count,
+              SUM(request_count)                  AS request_count,
+              SUM(connection_count)               AS connection_count,
+              SUM(message_count)                  AS message_count,
+              SUM(error_count)                    AS error_count,
+              SUM(check_count)                    AS check_count,
+              SUM(failed_check_count)             AS failed_check_count,
+              SUM(total_bytes)                    AS total_bytes
+       FROM v_runs
+       GROUP BY entry
+       ORDER BY last_started_at DESC`
+  ).all();
+}
+function listRunsForEntry(db, entry, limit = 200) {
+  return db.prepare(`SELECT * FROM v_runs WHERE entry = ? ORDER BY started_at DESC LIMIT ?`).all(entry, limit);
+}
+function listRequests(db, runId) {
+  return db.prepare(
+    `SELECT id, seq, ts, kind, message_count, method, host, path, status, ok, error_name,
+              duration_ms, request_bytes, response_bytes
+       FROM v_requests WHERE run_id = ? ORDER BY seq ASC`
+  ).all(runId);
+}
+function getRequestDetail(db, id) {
+  const request = db.prepare(`SELECT * FROM v_requests WHERE id = ?`).get(id);
+  if (!request) return null;
+  const headers = db.prepare(`SELECT kind, name, value FROM v_headers WHERE request_id = ? ORDER BY kind, ord`).all(id);
+  const tags = db.prepare(`SELECT key, value FROM tags WHERE request_id = ? ORDER BY key`).all(id);
+  const split = (kind) => headers.filter((h) => h.kind === kind).map((h) => [h.name, h.value]);
+  return {
+    request,
+    requestHeaders: split("request"),
+    responseHeaders: split("response"),
+    requestBody: loadBody(db, request.request_body_id, request.request_content_type),
+    responseBody: loadBody(db, request.response_body_id, request.response_content_type),
+    tags,
+    // Only a connection has any, and then the whole point is seeing them in order.
+    messages: request.kind === "http" ? [] : listMessages(db, id)
+  };
+}
+function listRunTags(db, runId) {
+  return db.prepare(
+    `SELECT DISTINCT t.key, t.value
+       FROM tags t JOIN requests r ON r.id = t.request_id
+       WHERE r.run_id = ?
+       ORDER BY t.key, t.value`
+  ).all(runId);
+}
+function listChecks(db, runId) {
+  return db.prepare(
+    `SELECT id, run_id, seq, ts, name, mode, status, message
+       FROM v_checks WHERE run_id = ? ORDER BY seq ASC`
+  ).all(runId);
+}
+function listMessages(db, requestId) {
+  return db.prepare(
+    `SELECT id, request_id, seq, ts, direction, name, code, event_id,
+              bytes, body_id, truncated, text
+       FROM v_messages WHERE request_id = ? ORDER BY seq ASC`
+  ).all(requestId);
+}
+var IMAGE_MIME = /* @__PURE__ */ new Set([
+  "image/apng",
+  "image/avif",
+  "image/bmp",
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/svg+xml",
+  "image/webp",
+  "image/x-icon",
+  "image/vnd.microsoft.icon"
+]);
+var MAX_INLINE_IMAGE_BYTES = 2e6;
+function imageMime(contentType) {
+  if (!contentType) return null;
+  const mime = contentType.split(";")[0].trim().toLowerCase();
+  return IMAGE_MIME.has(mime) ? mime : null;
+}
+function loadBody(db, bodyId, contentType) {
+  const base = {
+    present: false,
+    text: null,
+    json: null,
+    dataUrl: null,
+    contentType,
+    size: null,
+    truncated: false
+  };
+  const empty = (note) => ({ ...base, kind: "empty", note });
+  if (bodyId == null) return empty("No body captured (absent or redacted).");
+  const row = db.prepare(`SELECT size, stored_size, truncated, is_text, content FROM bodies WHERE id = ?`).get(bodyId);
+  if (!row) return empty("Body reference is set but the payload row is missing.");
+  const truncated = row.truncated === 1;
+  const stored = { ...base, present: true, size: row.size, truncated };
+  const binary = (note) => ({ ...stored, kind: "binary", note });
+  const mime = imageMime(contentType);
+  if (mime) {
+    if (truncated) {
+      return binary(
+        `Image truncated at ${row.stored_size} of ${row.size} bytes \u2014 too incomplete to draw.`
+      );
+    }
+    if (row.stored_size > MAX_INLINE_IMAGE_BYTES) {
+      return binary(`Image is ${row.stored_size} bytes \u2014 too large to inline.`);
+    }
+    return {
+      ...stored,
+      kind: "image",
+      // The source of an SVG is readable, and worth offering alongside it.
+      text: row.is_text === 1 ? row.content.toString("utf8") : null,
+      dataUrl: `data:${mime};base64,${row.content.toString("base64")}`,
+      note: null
+    };
+  }
+  if (row.is_text !== 1) return binary(`Binary body \u2014 ${row.stored_size} bytes stored, not shown.`);
+  const text = row.content.toString("utf8");
+  if (contentType && /json/i.test(contentType)) {
+    try {
+      const json = JSON.parse(text);
+      if (json !== null && typeof json === "object") {
+        return { ...stored, kind: "json", json, note: null };
+      }
+    } catch {
+      return {
+        ...stored,
+        kind: "text",
+        text,
+        note: "Content-Type is JSON but the body did not parse; shown as-is."
+      };
+    }
+  }
+  return { ...stored, kind: "text", text, note: null };
+}
+function getRunAnalytics(db, runId) {
+  const quantiles = db.prepare(
+    `WITH d AS (
+         SELECT duration_ms, ROW_NUMBER() OVER (ORDER BY duration_ms) AS rn
+         FROM requests WHERE run_id = @run AND kind = 'http'
+       ), c AS (SELECT COUNT(*) AS n FROM d)
+       SELECT
+         (SELECT COUNT(*) FROM requests WHERE run_id = @run) AS total,
+         (SELECT n FROM c) AS latency_samples,
+         (SELECT duration_ms FROM d
+            WHERE rn = MAX(1, CAST((SELECT n FROM c) * 0.50 AS INTEGER))) AS p50,
+         (SELECT duration_ms FROM d
+            WHERE rn = MAX(1, CAST((SELECT n FROM c) * 0.95 AS INTEGER))) AS p95,
+         (SELECT duration_ms FROM d
+            WHERE rn = MAX(1, CAST((SELECT n FROM c) * 0.99 AS INTEGER))) AS p99`
+  ).get({ run: runId });
+  const statusMix = db.prepare(
+    `SELECT CASE
+                WHEN status IS NULL THEN 'error'
+                ELSE CAST(status / 100 AS TEXT) || 'xx'
+              END AS status_class,
+              COUNT(*) AS count
+       FROM requests WHERE run_id = ?
+       GROUP BY status_class ORDER BY status_class`
+  ).all(runId);
+  const slowest = db.prepare(
+    `SELECT id, method, host, path, duration_ms FROM v_requests
+       WHERE run_id = ? AND kind = 'http' ORDER BY duration_ms DESC LIMIT 5`
+  ).all(runId);
+  const byHost = db.prepare(
+    `WITH d AS (
+         SELECT host_id, duration_ms, status, error_name,
+                ROW_NUMBER() OVER (PARTITION BY host_id ORDER BY duration_ms) AS rn,
+                COUNT(*)     OVER (PARTITION BY host_id)                      AS n
+         FROM requests WHERE run_id = @run AND kind = 'http'
+       )
+       SELECT h.host AS host,
+              MAX(d.n) AS count,
+              MAX(CASE WHEN d.rn = MAX(1, CAST(d.n * 0.95 AS INTEGER))
+                       THEN d.duration_ms END) AS p95,
+              SUM(CASE WHEN d.error_name IS NOT NULL OR d.status >= 400
+                       THEN 1 ELSE 0 END) AS errors
+       FROM d JOIN hosts h ON h.id = d.host_id
+       GROUP BY d.host_id ORDER BY count DESC`
+  ).all({ run: runId });
+  return {
+    total: quantiles.total,
+    latencySamples: quantiles.latency_samples,
+    statusMix,
+    p50: quantiles.latency_samples > 0 ? quantiles.p50 : null,
+    p95: quantiles.latency_samples > 0 ? quantiles.p95 : null,
+    p99: quantiles.latency_samples > 0 ? quantiles.p99 : null,
+    slowest,
+    byHost
+  };
+}
+export {
+  ENTITIES,
+  PREVIEW_CHARS,
+  RunWriter,
+  SCHEMA_VERSION,
+  UnknownFieldError,
+  describeRelation,
+  entityFields,
+  findEntity,
+  getRequestDetail,
+  getRun,
+  getRunAnalytics,
+  listChecks,
+  listMessages,
+  listRelations,
+  listRequests,
+  listRunTags,
+  listRuns,
+  listRunsForEntry,
+  listScripts,
+  openDb,
+  relationExists,
+  resolveDbPath,
+  selectEntity,
+  untypedColumns
+};