crumbtrail-node 0.1.0

package/dist/index.js

@@ -0,0 +1,2519 @@
+import {
+  BugQueueManager,
+  CLOUDFLARE_AUTH_FIELDS,
+  CLOUDFLARE_DESCRIPTOR,
+  CLOUDFLARE_R2_ACCESS_KEY_ID_ENV,
+  CLOUDFLARE_R2_ACCOUNT_ID_ENV,
+  CLOUDFLARE_R2_BUCKET_ENV,
+  CLOUDFLARE_R2_DATASET_ENV,
+  CLOUDFLARE_R2_ENDPOINT_ENV,
+  CLOUDFLARE_R2_PREFIX_ENV,
+  CLOUDFLARE_R2_SECRET_ACCESS_KEY_ENV,
+  CLOUDWATCH_ACCESS_KEY_ID_ENV,
+  CLOUDWATCH_AUTH_FIELDS,
+  CLOUDWATCH_DESCRIPTOR,
+  CLOUDWATCH_ENDPOINT_ENV,
+  CLOUDWATCH_LOG_GROUPS_ENV,
+  CLOUDWATCH_REGION_ENV,
+  CLOUDWATCH_SECRET_ACCESS_KEY_ENV,
+  CLOUDWATCH_SESSION_TOKEN_ENV,
+  CRUMBTRAIL_REQUEST_HEADER,
+  CRUMBTRAIL_USER_AGENT,
+  CloudWatchEvidenceSource,
+  CloudflareEvidenceSource,
+  CompareError,
+  DATADOG_API_KEY_ENV,
+  DATADOG_APP_KEY_ENV,
+  DATADOG_AUTH_FIELDS,
+  DATADOG_DEFAULT_SITE,
+  DATADOG_DESCRIPTOR,
+  DATADOG_SITE_ENV,
+  DB_DIFF_BULK_EVENT_KIND,
+  DB_DIFF_EVENT_KIND,
+  DB_READ_BULK_EVENT_KIND,
+  DB_READ_EVENT_KIND,
+  DEFAULT_MAX_TOTAL_BYTES,
+  DEFAULT_SOURCE_TIMEOUT_MS,
+  DEFAULT_SWEEP_CHECKPOINT_MS,
+  DEFAULT_SWEEP_IDLE_MS,
+  DEFAULT_SWEEP_INTERVAL_MS,
+  DISTINCT_BUGS_SCHEMA_VERSION,
+  DatadogEvidenceSource,
+  EVIDENCE_SOURCE_PROVIDERS,
+  FIX_CONTEXT_SCHEMA_VERSION,
+  FilesystemSessionStore,
+  FixContextError,
+  InspectError,
+  JiraTicketClient,
+  McpServer,
+  POSTHOG_API_KEY_ENV,
+  POSTHOG_AUTH_FIELDS,
+  POSTHOG_DEFAULT_HOST,
+  POSTHOG_DESCRIPTOR,
+  POSTHOG_HOST_ENV,
+  POSTHOG_PROJECT_ID_ENV,
+  PROVIDER_IDS,
+  PROVIDER_RECIPES,
+  PostHogEvidenceSource,
+  REDACTED_VALUE,
+  REGRESSION_CONTEXT_SCHEMA_VERSION,
+  SENTRY_AUTH_FIELDS,
+  SENTRY_AUTH_TOKEN_ENV,
+  SENTRY_DEFAULT_HOST,
+  SENTRY_DESCRIPTOR,
+  SENTRY_HOST_ENV,
+  SENTRY_ORG_ENV,
+  SESSION_COMPARE_SCHEMA_VERSION,
+  SPLUNK_AUTH_FIELDS,
+  SPLUNK_DESCRIPTOR,
+  SPLUNK_HOST_ENV,
+  SPLUNK_INDEX_ENV,
+  SPLUNK_TOKEN_ENV,
+  SPLUNK_WEB_URL_ENV,
+  SentryEvidenceSource,
+  SessionManager,
+  SplunkEvidenceSource,
+  TicketError,
+  buildBackendRequestEndEvent,
+  buildBackendRequestErrorEvent,
+  buildBackendRequestStartEvent,
+  buildCloudWatchQuery,
+  buildCloudflarePlan,
+  buildDatadogQuery,
+  buildDistinctBugSignature,
+  buildFixContext,
+  buildPostHogQuery,
+  buildRegressionContext,
+  buildSentryQuery,
+  buildSessionSummary,
+  buildSplunkQuery,
+  cloudWatchDeepLink,
+  cloudWatchEvidenceProvider,
+  cloudflareEvidenceProvider,
+  compareSessions,
+  createServer,
+  datadogAppBase,
+  datadogEvidenceProvider,
+  decodeOtlpLogsProtobuf,
+  decodeOtlpTraceProtobuf,
+  defaultSessionStore,
+  evidenceRequestHeaders,
+  evidenceSourcesFromEnv,
+  fetchAdapterEvidence,
+  formatComparisonSummary,
+  formatDuration,
+  formatInspection,
+  getProviderRecipe,
+  groupDistinctBugRecurrences,
+  groupDistinctBugs,
+  inspectSession,
+  isProviderId,
+  jiraToSymptom,
+  mergeRedactionMetadata,
+  normalizeCloudWatchRow,
+  normalizeDatadogLog,
+  normalizeDatadogSpan,
+  normalizePostHogEvent,
+  normalizePostHogRecording,
+  normalizeSentryIssue,
+  normalizeSplunkRow,
+  posthogEventDeepLink,
+  posthogEvidenceProvider,
+  posthogRecordingDeepLink,
+  readPackageVersion,
+  redactEvidenceGap,
+  redactEvidenceItem,
+  redactSourceResult,
+  redactValue,
+  registerEvidenceProvider,
+  renderCompareReport,
+  renderProviderCliOutput,
+  renderProviderConfig,
+  renderProviderDoc,
+  renderProviderReadme,
+  resolveBackendRequestCorrelation,
+  sentryEvidenceProvider,
+  signSigV4,
+  splunkEvidenceProvider,
+  splunkSearchDeepLink,
+  splunkWebBase,
+  startSessionSweeper,
+  sweepIdleSessions,
+  withBoundedRetry
+} from "./chunk-EASSXKUJ.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/db/columns.ts
+var DEFAULT_SENSITIVE_DB_COLUMNS = [
+  "password",
+  "token",
+  "secret",
+  "api_key",
+  "ssn"
+];
+function normalizeColumnName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function buildSensitiveColumnSet(extra = []) {
+  const set = /* @__PURE__ */ new Set();
+  for (const name of [...DEFAULT_SENSITIVE_DB_COLUMNS, ...extra]) {
+    if (typeof name === "string" && name.trim())
+      set.add(normalizeColumnName(name));
+  }
+  return set;
+}
+function redactColumns(row, sensitive, path) {
+  if (!row) return { value: void 0 };
+  const masked = {};
+  for (const [key, value] of Object.entries(row)) {
+    masked[key] = sensitive.has(normalizeColumnName(key)) ? REDACTED_VALUE : value;
+  }
+  const scrubbed = redactValue(masked, path);
+  return {
+    value: scrubbed.value,
+    metadata: scrubbed.metadata
+  };
+}
+
+// src/db/diff-event.ts
+var MAX_DB_VALUE_LENGTH = 8 * 1024;
+function boundStringValue(value, max = MAX_DB_VALUE_LENGTH) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max)}\u2026[truncated ${value.length} chars]`;
+}
+function boundColumnValue(value) {
+  if (typeof value === "string") return boundStringValue(value);
+  if (Array.isArray(value)) return value.map(boundColumnValue);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, inner] of Object.entries(
+      value
+    )) {
+      out[key] = boundColumnValue(inner);
+    }
+    return out;
+  }
+  return value;
+}
+function boundColumnRow(row) {
+  return row ? boundColumnValue(row) : void 0;
+}
+function buildDbDiffEvent(input) {
+  const now = Number.isFinite(input.now) ? Math.round(input.now) : Date.now();
+  const sensitive = buildSensitiveColumnSet(input.redactColumns);
+  const after = redactColumns(input.after, sensitive, "db.diff.after");
+  const before = redactColumns(input.before, sensitive, "db.diff.before");
+  const pk = input.pk ? redactColumns(input.pk, sensitive, "db.diff.pk") : { value: null, metadata: void 0 };
+  const boundedAfter = boundColumnRow(after.value);
+  const boundedBefore = boundColumnRow(before.value);
+  const boundedPk = boundColumnRow(pk.value ?? void 0) ?? null;
+  const d = {
+    engine: input.engine ?? "postgres",
+    op: input.op,
+    table: input.table,
+    pk: boundedPk,
+    requestId: input.requestId,
+    ...boundedAfter !== void 0 ? { after: boundedAfter } : {},
+    ...boundedBefore !== void 0 ? { before: boundedBefore } : {},
+    ...input.rowCount !== void 0 ? { rowCount: input.rowCount } : {}
+  };
+  const redaction = mergeRedactionMetadata(
+    after.metadata,
+    before.metadata,
+    pk.metadata
+  );
+  if (redaction) d.redaction = redaction;
+  const event = {
+    t: now,
+    k: DB_DIFF_EVENT_KIND,
+    d
+  };
+  if (input.sessionId) event.sessionId = input.sessionId;
+  const startedAt = normalizeStartedAt(input.sessionStartedAt);
+  if (startedAt !== void 0) event.offsetMs = Math.max(0, now - startedAt);
+  return event;
+}
+function normalizeStartedAt(startedAt) {
+  if (startedAt instanceof Date) {
+    const time = startedAt.getTime();
+    return Number.isFinite(time) ? time : void 0;
+  }
+  return Number.isFinite(startedAt) ? Math.round(startedAt) : void 0;
+}
+
+// src/db/read-event.ts
+function buildDbReadEvent(input) {
+  const now = Number.isFinite(input.now) ? Math.round(input.now) : Date.now();
+  const sensitive = buildSensitiveColumnSet(input.redactColumns);
+  const row = redactColumns(input.row, sensitive, "db.read.row");
+  const pk = input.pk ? redactColumns(input.pk, sensitive, "db.read.pk") : { value: null, metadata: void 0 };
+  const boundedRow = boundColumnRow(row.value) ?? {};
+  const boundedPk = boundColumnRow(pk.value ?? void 0) ?? null;
+  const d = {
+    engine: input.engine ?? "postgres",
+    table: input.table,
+    pk: boundedPk,
+    row: boundedRow,
+    requestId: input.requestId
+  };
+  const redaction = mergeRedactionMetadata(row.metadata, pk.metadata);
+  if (redaction) d.redaction = redaction;
+  const event = {
+    t: now,
+    k: DB_READ_EVENT_KIND,
+    d
+  };
+  if (input.sessionId) event.sessionId = input.sessionId;
+  const startedAt = normalizeStartedAt2(input.sessionStartedAt);
+  if (startedAt !== void 0) event.offsetMs = Math.max(0, now - startedAt);
+  return event;
+}
+function buildDbReadBulkEvent(input) {
+  const now = Number.isFinite(input.now) ? Math.round(input.now) : Date.now();
+  const d = {
+    engine: input.engine ?? "postgres",
+    table: input.table,
+    requestId: input.requestId,
+    rowCount: input.rowCount,
+    emittedRows: input.emittedRows,
+    truncatedRows: Math.max(0, input.rowCount - input.emittedRows),
+    samplePks: input.samplePks
+  };
+  const event = {
+    t: now,
+    k: DB_READ_BULK_EVENT_KIND,
+    d
+  };
+  if (input.sessionId) event.sessionId = input.sessionId;
+  const startedAt = normalizeStartedAt2(input.sessionStartedAt);
+  if (startedAt !== void 0) event.offsetMs = Math.max(0, now - startedAt);
+  return event;
+}
+function normalizeStartedAt2(startedAt) {
+  if (startedAt instanceof Date) {
+    const time = startedAt.getTime();
+    return Number.isFinite(time) ? time : void 0;
+  }
+  return Number.isFinite(startedAt) ? Math.round(startedAt) : void 0;
+}
+
+// src/db/sql.ts
+var IDENT_PART = String.raw`(?:"[^"]+"|\`[^\`]+\`|\[[^\]]+\]|[\w$]+)`;
+var TABLE_IDENT = String.raw`(${IDENT_PART}(?:\s*\.\s*${IDENT_PART})*)`;
+var TOP_CLAUSE = String.raw`(?:top\s*(?:\(\s*\d+\s*\)|\d+)\s+)?`;
+var INSERT_RE = new RegExp(
+  String.raw`^\s*insert\s+into\s+${TABLE_IDENT}`,
+  "i"
+);
+var UPDATE_RE = new RegExp(
+  String.raw`^\s*update\s+${TOP_CLAUSE}(?:only\s+)?${TABLE_IDENT}\s+set\b`,
+  "i"
+);
+var DELETE_RE = new RegExp(
+  String.raw`^\s*delete\s+${TOP_CLAUSE}from\s+(?:only\s+)?${TABLE_IDENT}`,
+  "i"
+);
+var SELECT_FROM_RE = new RegExp(
+  String.raw`^\s*select\b[\s\S]*?\bfrom\s+${TABLE_IDENT}`,
+  "i"
+);
+var WHERE_RE = /\bwhere\b[\s\S]*?(?=\breturning\b|$)/i;
+var RETURNING_RE = /\breturning\b/i;
+function parseMutation(sql) {
+  const insert = INSERT_RE.exec(sql);
+  if (insert) return { op: "insert", table: normalizeTable(insert[1]) };
+  const update = UPDATE_RE.exec(sql);
+  if (update)
+    return {
+      op: "update",
+      table: normalizeTable(update[1]),
+      whereClause: extractWhere(sql)
+    };
+  const del = DELETE_RE.exec(sql);
+  if (del)
+    return {
+      op: "delete",
+      table: normalizeTable(del[1]),
+      whereClause: extractWhere(sql)
+    };
+  return void 0;
+}
+function parseRead(sql) {
+  const select = SELECT_FROM_RE.exec(sql);
+  if (!select) return void 0;
+  return { table: normalizeTable(select[1]) };
+}
+function stripIdentifierQuotes(part) {
+  const trimmed = part.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("`") && trimmed.endsWith("`") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function normalizeTable(raw) {
+  return raw.trim().split(".").map((part) => stripIdentifierQuotes(part)).join(".");
+}
+function extractWhere(sql) {
+  const match = WHERE_RE.exec(sql);
+  return match ? match[0].trim() : void 0;
+}
+function ensureReturning(sql) {
+  return RETURNING_RE.test(sql) ? sql : `${sql.replace(/;\s*$/, "")} RETURNING *`;
+}
+function countPlaceholders(sqlFragment) {
+  let count = 0;
+  let closing = null;
+  for (let index = 0; index < sqlFragment.length; index += 1) {
+    const ch = sqlFragment[index];
+    if (closing !== null) {
+      if (ch === closing) {
+        if ((closing === "'" || closing === '"') && sqlFragment[index + 1] === closing) {
+          index += 1;
+          continue;
+        }
+        closing = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      closing = ch;
+      continue;
+    }
+    if (ch === "[") {
+      closing = "]";
+      continue;
+    }
+    if (ch === "?") count += 1;
+  }
+  return count;
+}
+
+// src/db/instrument-shared.ts
+var DEFAULT_MAX_ROWS_PER_STATEMENT = 100;
+var DEFAULT_MAX_READ_ROWS_PER_STATEMENT = 25;
+var DEFAULT_MAX_READ_ROWS_PER_REQUEST = 100;
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function extractPk(row, table, pkColumns) {
+  const cols = pkColumns?.[table] ?? ["id"];
+  const pk = {};
+  for (const col of cols) {
+    if (col in row) pk[col] = row[col];
+  }
+  return Object.keys(pk).length > 0 ? pk : null;
+}
+function pkKey(pk) {
+  return pk ? JSON.stringify(pk) : "";
+}
+function redactPkSample(pk, sensitive) {
+  return pk ? redactColumns(pk, sensitive, "db.diff.bulk.samplePks").value ?? null : null;
+}
+function normalizeMaxRowsPerStatement(value) {
+  if (value === void 0) return DEFAULT_MAX_ROWS_PER_STATEMENT;
+  if (!Number.isFinite(value)) return DEFAULT_MAX_ROWS_PER_STATEMENT;
+  return Math.max(0, Math.floor(value));
+}
+function normalizeReadCap(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function buildDbDiffBulkEvent(input) {
+  const now = Number.isFinite(input.now) ? Math.round(input.now) : Date.now();
+  const d = {
+    engine: input.engine,
+    op: input.op,
+    table: input.table,
+    requestId: input.requestId,
+    rowCount: input.rowCount,
+    emittedRows: input.emittedRows,
+    truncatedRows: Math.max(0, input.rowCount - input.emittedRows),
+    samplePks: input.samplePks
+  };
+  const event = {
+    t: now,
+    k: DB_DIFF_BULK_EVENT_KIND,
+    d
+  };
+  if (input.sessionId) event.sessionId = input.sessionId;
+  const startedAt = normalizeStartedAt3(input.sessionStartedAt);
+  if (startedAt !== void 0) event.offsetMs = Math.max(0, now - startedAt);
+  return event;
+}
+function normalizeStartedAt3(startedAt) {
+  if (startedAt instanceof Date) {
+    const time = startedAt.getTime();
+    return Number.isFinite(time) ? time : void 0;
+  }
+  return Number.isFinite(startedAt) ? Math.round(startedAt) : void 0;
+}
+function emitDbDiffEvents(input) {
+  const { engine, op, table, requestId, rows, beforeByPk, rowCount, options } = input;
+  const maxRows = normalizeMaxRowsPerStatement(options.maxRowsPerStatement);
+  const emittedRows = Math.min(rows.length, maxRows);
+  const emitRows = rows.slice(0, emittedRows);
+  const samplePks = [];
+  const sensitive = buildSensitiveColumnSet(options.redactColumns);
+  for (const row of emitRows) {
+    const pk = extractPk(row, table, options.pkColumns);
+    const samplePk = redactPkSample(pk, sensitive);
+    if (samplePks.length < 3 && samplePk) samplePks.push(samplePk);
+    const event = buildDbDiffEvent({
+      engine,
+      op,
+      table,
+      pk,
+      requestId,
+      sessionId: options.sessionId,
+      redactColumns: options.redactColumns,
+      now: options.now?.(),
+      sessionStartedAt: options.sessionStartedAt,
+      ...op === "delete" ? { before: row } : { after: row, before: beforeByPk?.get(pkKey(pk)) }
+    });
+    options.emit(event);
+  }
+  if (rowCount > maxRows) {
+    for (let index = emittedRows; index < rows.length && samplePks.length < 3; index += 1) {
+      const samplePk = redactPkSample(
+        extractPk(rows[index], table, options.pkColumns),
+        sensitive
+      );
+      if (samplePk) samplePks.push(samplePk);
+    }
+    options.emit(
+      buildDbDiffBulkEvent({
+        engine,
+        op,
+        table,
+        requestId,
+        rowCount,
+        emittedRows,
+        samplePks,
+        sessionId: options.sessionId,
+        now: options.now?.(),
+        sessionStartedAt: options.sessionStartedAt
+      })
+    );
+  }
+}
+function emitImagelessDbDiff(input) {
+  const { engine, op, table, requestId, rowCount, options } = input;
+  options.emit(
+    buildDbDiffEvent({
+      engine,
+      op,
+      table,
+      pk: null,
+      rowCount,
+      requestId,
+      sessionId: options.sessionId,
+      redactColumns: options.redactColumns,
+      now: options.now?.(),
+      sessionStartedAt: options.sessionStartedAt
+    })
+  );
+  const maxRows = normalizeMaxRowsPerStatement(options.maxRowsPerStatement);
+  if (rowCount > maxRows) {
+    options.emit(
+      buildDbDiffBulkEvent({
+        engine,
+        op,
+        table,
+        requestId,
+        rowCount,
+        emittedRows: 0,
+        samplePks: [],
+        sessionId: options.sessionId,
+        now: options.now?.(),
+        sessionStartedAt: options.sessionStartedAt
+      })
+    );
+  }
+}
+function emitDbReadEvents(input) {
+  const { engine, table, requestId, rows, rowCount, options } = input;
+  const emittedReadRowsByRequest = input.emittedReadRowsByRequest;
+  const perStatementCap = normalizeReadCap(
+    options.maxReadRowsPerStatement,
+    DEFAULT_MAX_READ_ROWS_PER_STATEMENT
+  );
+  const perRequestCap = normalizeReadCap(
+    options.maxReadRowsPerRequest,
+    DEFAULT_MAX_READ_ROWS_PER_REQUEST
+  );
+  const emittedForRequest = emittedReadRowsByRequest.get(requestId) ?? 0;
+  const remainingForRequest = Math.max(0, perRequestCap - emittedForRequest);
+  const emittedRows = Math.min(
+    rows.length,
+    perStatementCap,
+    remainingForRequest
+  );
+  const emitRows = rows.slice(0, emittedRows);
+  const samplePks = [];
+  const sensitive = buildSensitiveColumnSet(options.redactColumns);
+  for (const row of emitRows) {
+    const pk = extractPk(row, table, options.pkColumns);
+    const samplePk = redactPkSample(pk, sensitive);
+    if (samplePks.length < 3 && samplePk) samplePks.push(samplePk);
+    options.emit(
+      buildDbReadEvent({
+        engine,
+        table,
+        pk,
+        row,
+        requestId,
+        sessionId: options.sessionId,
+        redactColumns: options.redactColumns,
+        now: options.now?.(),
+        sessionStartedAt: options.sessionStartedAt
+      })
+    );
+    emittedReadRowsByRequest.set(
+      requestId,
+      (emittedReadRowsByRequest.get(requestId) ?? 0) + 1
+    );
+  }
+  if (rowCount > emittedRows) {
+    for (let index = emittedRows; index < rows.length && samplePks.length < 3; index += 1) {
+      const samplePk = redactPkSample(
+        extractPk(rows[index], table, options.pkColumns),
+        sensitive
+      );
+      if (samplePk) samplePks.push(samplePk);
+    }
+    options.emit(
+      buildDbReadBulkEvent({
+        engine,
+        table,
+        requestId,
+        rowCount,
+        emittedRows,
+        samplePks,
+        sessionId: options.sessionId,
+        now: options.now?.(),
+        sessionStartedAt: options.sessionStartedAt
+      })
+    );
+  }
+}
+
+// src/db/pg.ts
+var ENGINE = "postgres";
+function instrumentPgClient(client, options) {
+  const emittedReadRowsByRequest = /* @__PURE__ */ new Map();
+  const wrappedQuery = async (text2, params) => {
+    if (typeof text2 !== "string") return client.query(text2, params);
+    let parsed;
+    let parsedRead;
+    let requestId;
+    try {
+      parsed = parseMutation(text2);
+      parsedRead = parsed ? void 0 : parseRead(text2);
+      requestId = options.requestId ?? options.getRequestId?.();
+    } catch {
+      return client.query(text2, params);
+    }
+    if (!requestId) return client.query(text2, params);
+    if (!parsed) {
+      const result2 = await client.query(text2, params);
+      if (options.captureReads && parsedRead) {
+        try {
+          const rows = (result2.rows ?? []).filter(isRecord);
+          const rowCount = typeof result2.rowCount === "number" && Number.isFinite(result2.rowCount) ? result2.rowCount : rows.length;
+          emitDbReadEvents({
+            engine: ENGINE,
+            table: parsedRead.table,
+            requestId,
+            rows,
+            rowCount,
+            options,
+            emittedReadRowsByRequest
+          });
+        } catch {
+        }
+      }
+      return result2;
+    }
+    const paramArray = Array.isArray(params) ? params : void 0;
+    let beforeByPk;
+    if (options.captureBefore && parsed.op === "update" && parsed.whereClause) {
+      try {
+        const pre = await client.query(
+          `SELECT * FROM ${parsed.table} ${parsed.whereClause}`,
+          paramArray
+        );
+        beforeByPk = /* @__PURE__ */ new Map();
+        for (const row of pre.rows ?? []) {
+          if (!isRecord(row)) continue;
+          beforeByPk.set(
+            pkKey(extractPk(row, parsed.table, options.pkColumns)),
+            row
+          );
+        }
+      } catch {
+        beforeByPk = void 0;
+      }
+    }
+    let instrumentedText;
+    try {
+      instrumentedText = ensureReturning(text2);
+    } catch {
+      return client.query(text2, paramArray);
+    }
+    const result = await client.query(instrumentedText, paramArray);
+    try {
+      const rows = (result.rows ?? []).filter(isRecord);
+      const rowCount = typeof result.rowCount === "number" && Number.isFinite(result.rowCount) ? result.rowCount : rows.length;
+      emitDbDiffEvents({
+        engine: ENGINE,
+        op: parsed.op,
+        table: parsed.table,
+        requestId,
+        rows,
+        beforeByPk,
+        rowCount,
+        options
+      });
+    } catch {
+    }
+    return result;
+  };
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "query") return wrappedQuery;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
+// src/db/mysql.ts
+var ENGINE2 = "mysql";
+function resultPayload(result) {
+  return Array.isArray(result) ? result[0] : void 0;
+}
+function mutationHeader(payload) {
+  if (isRecord(payload) && typeof payload.affectedRows === "number" && Number.isFinite(payload.affectedRows)) {
+    return payload;
+  }
+  return void 0;
+}
+function isPositiveInt(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function extractWhereParams(whereClause, paramArray) {
+  if (!whereClause || !paramArray) return [];
+  const n = countPlaceholders(whereClause);
+  if (n <= 0) return [];
+  return paramArray.slice(Math.max(0, paramArray.length - n));
+}
+function buildPkSelect(table, pks) {
+  const cols = Object.keys(pks[0]);
+  if (cols.length === 1) {
+    const col = cols[0];
+    const placeholders = pks.map(() => "?").join(", ");
+    return {
+      text: `SELECT * FROM ${table} WHERE ${col} IN (${placeholders})`,
+      params: pks.map((pk) => pk[col])
+    };
+  }
+  const groups = pks.map(() => `(${cols.map((col) => `${col} = ?`).join(" AND ")})`).join(" OR ");
+  const params = [];
+  for (const pk of pks) for (const col of cols) params.push(pk[col]);
+  return { text: `SELECT * FROM ${table} WHERE ${groups}`, params };
+}
+function instrumentMysqlClient(client, options) {
+  const emittedReadRowsByRequest = /* @__PURE__ */ new Map();
+  const rawQuery = client.query.bind(client);
+  const rawExecute = typeof client.execute === "function" ? client.execute.bind(
+    client
+  ) : void 0;
+  const selectRows = async (text2, params) => {
+    const result = await rawQuery(text2, params);
+    const payload = resultPayload(result);
+    return Array.isArray(payload) ? payload.filter(isRecord) : [];
+  };
+  const captureInsert = async (parsed, result, requestId) => {
+    const header = mutationHeader(resultPayload(result));
+    if (!header || header.affectedRows <= 0) return;
+    const pkCols = options.pkColumns?.[parsed.table] ?? ["id"];
+    if (header.affectedRows === 1 && isPositiveInt(header.insertId) && pkCols.length === 1) {
+      let rows = [];
+      try {
+        rows = await selectRows(
+          `SELECT * FROM ${parsed.table} WHERE ${pkCols[0]} = ?`,
+          [header.insertId]
+        );
+      } catch {
+        rows = [];
+      }
+      if (rows.length > 0) {
+        emitDbDiffEvents({
+          engine: ENGINE2,
+          op: "insert",
+          table: parsed.table,
+          requestId,
+          rows,
+          rowCount: header.affectedRows,
+          options
+        });
+        return;
+      }
+    }
+    emitImagelessDbDiff({
+      engine: ENGINE2,
+      op: "insert",
+      table: parsed.table,
+      requestId,
+      rowCount: header.affectedRows,
+      options
+    });
+  };
+  const captureUpdate = async (parsed, result, requestId, preRows) => {
+    const header = mutationHeader(resultPayload(result));
+    const affected = header ? header.affectedRows : 0;
+    if (affected <= 0) return;
+    if (parsed.whereClause && preRows && preRows.length > 0) {
+      const beforeByPk = /* @__PURE__ */ new Map();
+      const pkList = [];
+      for (const row of preRows) {
+        const pk = extractPk(row, parsed.table, options.pkColumns);
+        beforeByPk.set(pkKey(pk), row);
+        if (pk) pkList.push(pk);
+      }
+      const maxRows = normalizeMaxRowsPerStatement(options.maxRowsPerStatement);
+      const cappedPks = pkList.slice(0, maxRows);
+      let postRows = [];
+      if (cappedPks.length > 0) {
+        const pkSelect = buildPkSelect(parsed.table, cappedPks);
+        try {
+          postRows = await selectRows(pkSelect.text, pkSelect.params);
+        } catch {
+          postRows = [];
+        }
+      }
+      emitDbDiffEvents({
+        engine: ENGINE2,
+        op: "update",
+        table: parsed.table,
+        requestId,
+        rows: postRows,
+        beforeByPk: options.captureBefore ? beforeByPk : void 0,
+        rowCount: affected,
+        options
+      });
+      if (options.captureBefore) {
+        const postKeys = new Set(
+          postRows.map(
+            (row) => pkKey(extractPk(row, parsed.table, options.pkColumns))
+          )
+        );
+        for (const pk of cappedPks) {
+          const key = pkKey(pk);
+          if (postKeys.has(key)) continue;
+          const before = beforeByPk.get(key);
+          if (!before) continue;
+          options.emit(
+            buildDbDiffEvent({
+              engine: ENGINE2,
+              op: "update",
+              table: parsed.table,
+              pk,
+              before,
+              requestId,
+              sessionId: options.sessionId,
+              redactColumns: options.redactColumns,
+              now: options.now?.(),
+              sessionStartedAt: options.sessionStartedAt
+            })
+          );
+        }
+      }
+      return;
+    }
+    emitImagelessDbDiff({
+      engine: ENGINE2,
+      op: "update",
+      table: parsed.table,
+      requestId,
+      rowCount: affected,
+      options
+    });
+  };
+  const captureDelete = async (parsed, result, requestId, preRows) => {
+    const header = mutationHeader(resultPayload(result));
+    const affected = header ? header.affectedRows : 0;
+    if (affected <= 0) return;
+    if (parsed.whereClause && preRows && preRows.length > 0) {
+      emitDbDiffEvents({
+        engine: ENGINE2,
+        op: "delete",
+        table: parsed.table,
+        requestId,
+        rows: preRows,
+        rowCount: affected,
+        options
+      });
+      return;
+    }
+    emitImagelessDbDiff({
+      engine: ENGINE2,
+      op: "delete",
+      table: parsed.table,
+      requestId,
+      rowCount: affected,
+      options
+    });
+  };
+  const makeInstrumented = (run) => async (sql, values) => {
+    if (typeof sql !== "string") return run(sql, values);
+    let parsed;
+    let parsedRead;
+    let requestId;
+    try {
+      parsed = parseMutation(sql);
+      parsedRead = parsed ? void 0 : parseRead(sql);
+      requestId = options.requestId ?? options.getRequestId?.();
+    } catch {
+      return run(sql, values);
+    }
+    if (!requestId) return run(sql, values);
+    const paramArray = Array.isArray(values) ? values : void 0;
+    if (!parsed) {
+      const result2 = await run(sql, values);
+      if (options.captureReads && parsedRead) {
+        try {
+          const payload = resultPayload(result2);
+          const rows = Array.isArray(payload) ? payload.filter(isRecord) : [];
+          emitDbReadEvents({
+            engine: ENGINE2,
+            table: parsedRead.table,
+            requestId,
+            rows,
+            rowCount: rows.length,
+            options,
+            emittedReadRowsByRequest
+          });
+        } catch {
+        }
+      }
+      return result2;
+    }
+    if (parsed.op === "insert") {
+      const result2 = await run(sql, values);
+      try {
+        await captureInsert(parsed, result2, requestId);
+      } catch {
+      }
+      return result2;
+    }
+    const parsedMutation = parsed;
+    let preRows;
+    if (parsedMutation.whereClause) {
+      const whereParams = extractWhereParams(
+        parsedMutation.whereClause,
+        paramArray
+      );
+      try {
+        preRows = await selectRows(
+          `SELECT * FROM ${parsedMutation.table} ${parsedMutation.whereClause}`,
+          whereParams
+        );
+      } catch {
+        preRows = void 0;
+      }
+    }
+    const result = await run(sql, values);
+    try {
+      if (parsedMutation.op === "update") {
+        await captureUpdate(parsedMutation, result, requestId, preRows);
+      } else {
+        await captureDelete(parsedMutation, result, requestId, preRows);
+      }
+    } catch {
+    }
+    return result;
+  };
+  const wrappedQuery = makeInstrumented(rawQuery);
+  const wrappedExecute = rawExecute ? makeInstrumented(rawExecute) : void 0;
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "query") return wrappedQuery;
+      if (prop === "execute" && wrappedExecute) return wrappedExecute;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
+// src/db/mssql.ts
+var ENGINE3 = "mssql";
+var IDENT_PART2 = String.raw`(?:"[^"]+"|\`[^\`]+\`|\[[^\]]+\]|[\w$]+)`;
+var TABLE_IDENT2 = String.raw`${IDENT_PART2}(?:\s*\.\s*${IDENT_PART2})*`;
+var TOP_CLAUSE2 = String.raw`(?:top\s*(?:\(\s*\d+\s*\)|\d+)\s+)?`;
+var DELETE_TARGET_RE = new RegExp(
+  String.raw`^\s*delete\s+${TOP_CLAUSE2}from\s+(?:only\s+)?${TABLE_IDENT2}`,
+  "i"
+);
+function matchesKeywordAt(sql, index, keyword) {
+  const words = keyword.split(" ");
+  let pos = index;
+  for (let w = 0; w < words.length; w += 1) {
+    const word = words[w];
+    if (sql.slice(pos, pos + word.length).toLowerCase() !== word) return false;
+    pos += word.length;
+    if (w < words.length - 1) {
+      const wsStart = pos;
+      while (pos < sql.length && /\s/.test(sql[pos])) pos += 1;
+      if (pos === wsStart) return false;
+    }
+  }
+  const after = sql[pos];
+  return after === void 0 || !/[\w$]/.test(after);
+}
+function skipRegion(sql, i) {
+  const ch = sql[i];
+  const n = sql.length;
+  if (ch === "-" && sql[i + 1] === "-") {
+    let j = i + 2;
+    while (j < n && sql[j] !== "\n") j += 1;
+    return j;
+  }
+  if (ch === "/" && sql[i + 1] === "*") {
+    let j = i + 2;
+    while (j < n && !(sql[j] === "*" && sql[j + 1] === "/")) j += 1;
+    return j >= n ? n : j + 2;
+  }
+  if (ch === "'" || ch === '"') {
+    let j = i + 1;
+    while (j < n) {
+      if (sql[j] === ch) {
+        if (sql[j + 1] === ch) {
+          j += 2;
+          continue;
+        }
+        return j + 1;
+      }
+      j += 1;
+    }
+    return n;
+  }
+  if (ch === "`" || ch === "[") {
+    const close = ch === "`" ? "`" : "]";
+    let j = i + 1;
+    while (j < n && sql[j] !== close) j += 1;
+    return j >= n ? n : j + 1;
+  }
+  return null;
+}
+function findTopLevelKeywordIndex(sql, keywords) {
+  let depth = 0;
+  let i = 0;
+  const n = sql.length;
+  while (i < n) {
+    const skipped = skipRegion(sql, i);
+    if (skipped !== null) {
+      i = skipped;
+      continue;
+    }
+    const ch = sql[i];
+    if (ch === "(") {
+      depth += 1;
+      i += 1;
+      continue;
+    }
+    if (ch === ")") {
+      if (depth > 0) depth -= 1;
+      i += 1;
+      continue;
+    }
+    if (depth === 0) {
+      const before = i === 0 ? " " : sql[i - 1];
+      if (!/[\w$]/.test(before)) {
+        for (const keyword of keywords) {
+          if (matchesKeywordAt(sql, i, keyword)) return i;
+        }
+      }
+    }
+    i += 1;
+  }
+  return void 0;
+}
+function isQuoteChar(ch) {
+  return ch === "'" || ch === '"' || ch === "`";
+}
+function scanStatementSafety(sql) {
+  const n = sql.length;
+  let depth = 0;
+  let sawTopLevelSemicolon = false;
+  let multiStatement = false;
+  let quoteInComment = false;
+  let unterminated = false;
+  let i = 0;
+  while (i < n) {
+    const ch = sql[i];
+    if (ch === "-" && sql[i + 1] === "-") {
+      i += 2;
+      while (i < n && sql[i] !== "\n") {
+        if (isQuoteChar(sql[i])) quoteInComment = true;
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "/" && sql[i + 1] === "*") {
+      i += 2;
+      let closed = false;
+      while (i < n) {
+        if (sql[i] === "*" && sql[i + 1] === "/") {
+          i += 2;
+          closed = true;
+          break;
+        }
+        if (isQuoteChar(sql[i])) quoteInComment = true;
+        i += 1;
+      }
+      if (!closed) {
+        unterminated = true;
+        break;
+      }
+      continue;
+    }
+    if (sawTopLevelSemicolon && !/\s/.test(ch)) {
+      multiStatement = true;
+      break;
+    }
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i += 1;
+      let closed = false;
+      while (i < n) {
+        if (sql[i] === quote) {
+          if (sql[i + 1] === quote) {
+            i += 2;
+            continue;
+          }
+          i += 1;
+          closed = true;
+          break;
+        }
+        i += 1;
+      }
+      if (!closed) {
+        unterminated = true;
+        break;
+      }
+      continue;
+    }
+    if (ch === "`" || ch === "[") {
+      const close = ch === "`" ? "`" : "]";
+      i += 1;
+      let closed = false;
+      while (i < n) {
+        if (sql[i] === close) {
+          i += 1;
+          closed = true;
+          break;
+        }
+        i += 1;
+      }
+      if (!closed) {
+        unterminated = true;
+        break;
+      }
+      continue;
+    }
+    if (ch === "(") {
+      depth += 1;
+      i += 1;
+      continue;
+    }
+    if (ch === ")") {
+      if (depth > 0) depth -= 1;
+      i += 1;
+      continue;
+    }
+    if (depth === 0 && ch === ";") {
+      sawTopLevelSemicolon = true;
+      i += 1;
+      continue;
+    }
+    i += 1;
+  }
+  return { unterminated, multiStatement, quoteInComment };
+}
+function spliceBefore(sql, index, clause) {
+  return `${sql.slice(0, index)}${clause} ${sql.slice(index)}`;
+}
+function injectInsertOutput(sql) {
+  const index = findTopLevelKeywordIndex(sql, [
+    "default values",
+    "values",
+    "select"
+  ]);
+  if (index === void 0) return void 0;
+  return spliceBefore(sql, index, "OUTPUT INSERTED.*");
+}
+var HAS_FROM_OR_WHERE_RE = /\b(?:from|where)\b/i;
+function injectUpdateOutput(sql) {
+  const fromIndex = findTopLevelKeywordIndex(sql, ["from"]);
+  if (fromIndex !== void 0)
+    return spliceBefore(sql, fromIndex, "OUTPUT INSERTED.*");
+  const whereIndex = findTopLevelKeywordIndex(sql, ["where"]);
+  if (whereIndex !== void 0)
+    return spliceBefore(sql, whereIndex, "OUTPUT INSERTED.*");
+  if (HAS_FROM_OR_WHERE_RE.test(sql)) return void 0;
+  return `${sql.replace(/;\s*$/, "")} OUTPUT INSERTED.*`;
+}
+function injectDeleteOutput(sql) {
+  const match = DELETE_TARGET_RE.exec(sql);
+  if (!match) return void 0;
+  const end = match[0].length;
+  return `${sql.slice(0, end)} OUTPUT DELETED.*${sql.slice(end)}`;
+}
+function injectOutput(op, sql) {
+  if (op === "insert") return injectInsertOutput(sql);
+  if (op === "update") return injectUpdateOutput(sql);
+  if (op === "delete") return injectDeleteOutput(sql);
+  return void 0;
+}
+function hasOutputClause(sql) {
+  return findTopLevelKeywordIndex(sql, ["output"]) !== void 0;
+}
+var COMPILE_RERUN_ERROR_NUMBERS = /* @__PURE__ */ new Set([
+  334,
+  156,
+  102
+]);
+function isSafeCompileRerunError(err) {
+  if (!err || typeof err !== "object") return false;
+  const candidate = err;
+  if (candidate.number !== void 0 && candidate.number !== null) {
+    return typeof candidate.number === "number" && COMPILE_RERUN_ERROR_NUMBERS.has(candidate.number);
+  }
+  const message = typeof candidate.message === "string" ? candidate.message : "";
+  return /output clause/i.test(message) && /trigger/i.test(message);
+}
+function recordsetRows(result) {
+  return (Array.isArray(result?.recordset) ? result.recordset : []).filter(
+    isRecord
+  );
+}
+function rowCountFromResult(result, fallback) {
+  const affected = result?.rowsAffected;
+  if (Array.isArray(affected) && Number.isFinite(affected[0]))
+    return affected[0];
+  return fallback;
+}
+function stripInjectedRows(result) {
+  return { ...result, recordset: void 0, recordsets: [] };
+}
+function replayInputs(request, recordedInputs) {
+  for (const args of recordedInputs) {
+    request.input(...args);
+  }
+}
+function instrumentMssqlPool(pool, options) {
+  const emittedReadRowsByRequest = /* @__PURE__ */ new Map();
+  const runInstrumentedQuery = async (request, recordedInputs, text2) => {
+    if (typeof text2 !== "string") return request.query(text2);
+    const sql = text2;
+    let parsed;
+    let parsedRead;
+    let requestId;
+    try {
+      parsed = parseMutation(sql);
+      parsedRead = parsed ? void 0 : parseRead(sql);
+      requestId = options.requestId ?? options.getRequestId?.();
+    } catch {
+      return request.query(sql);
+    }
+    if (!requestId) return request.query(sql);
+    if (!parsed) {
+      const result2 = await request.query(sql);
+      if (options.captureReads && parsedRead) {
+        try {
+          const rows = recordsetRows(result2);
+          emitDbReadEvents({
+            engine: ENGINE3,
+            table: parsedRead.table,
+            requestId,
+            rows,
+            rowCount: rowCountFromResult(result2, rows.length),
+            options,
+            emittedReadRowsByRequest
+          });
+        } catch {
+        }
+      }
+      return result2;
+    }
+    const mutation = parsed;
+    const reqId = requestId;
+    const runOriginalWithImagelessDiff = async () => {
+      const result2 = await request.query(sql);
+      try {
+        const rowCount = rowCountFromResult(result2, 0);
+        if (rowCount > 0) {
+          emitImagelessDbDiff({
+            engine: ENGINE3,
+            op: mutation.op,
+            table: mutation.table,
+            requestId: reqId,
+            rowCount,
+            options
+          });
+        }
+      } catch {
+      }
+      return result2;
+    };
+    if (hasOutputClause(sql)) return request.query(sql);
+    const safety = scanStatementSafety(sql);
+    if (safety.unterminated || safety.multiStatement || safety.quoteInComment) {
+      return runOriginalWithImagelessDiff();
+    }
+    let beforeByPk;
+    if (options.captureBefore && mutation.op === "update" && mutation.whereClause) {
+      try {
+        const pre = pool.request();
+        replayInputs(pre, recordedInputs);
+        const preResult = await pre.query(
+          `SELECT * FROM ${mutation.table} ${mutation.whereClause}`
+        );
+        beforeByPk = /* @__PURE__ */ new Map();
+        for (const row of recordsetRows(preResult)) {
+          beforeByPk.set(
+            pkKey(extractPk(row, mutation.table, options.pkColumns)),
+            row
+          );
+        }
+      } catch {
+        beforeByPk = void 0;
+      }
+    }
+    let injectedText;
+    try {
+      injectedText = injectOutput(mutation.op, sql);
+    } catch {
+      injectedText = void 0;
+    }
+    if (injectedText === void 0) {
+      return runOriginalWithImagelessDiff();
+    }
+    let result;
+    try {
+      result = await request.query(injectedText);
+    } catch (err) {
+      if (!isSafeCompileRerunError(err)) throw err;
+      const fresh = pool.request();
+      replayInputs(fresh, recordedInputs);
+      const fallbackResult = await fresh.query(sql);
+      try {
+        const rowCount = rowCountFromResult(fallbackResult, 0);
+        if (rowCount > 0) {
+          emitImagelessDbDiff({
+            engine: ENGINE3,
+            op: mutation.op,
+            table: mutation.table,
+            requestId: reqId,
+            rowCount,
+            options
+          });
+        }
+      } catch {
+      }
+      return fallbackResult;
+    }
+    try {
+      const rows = recordsetRows(result);
+      const rowCount = rowCountFromResult(result, rows.length);
+      if (rows.length > 0) {
+        emitDbDiffEvents({
+          engine: ENGINE3,
+          op: mutation.op,
+          table: mutation.table,
+          requestId: reqId,
+          rows,
+          beforeByPk,
+          rowCount,
+          options
+        });
+      } else if (rowCount > 0) {
+        emitImagelessDbDiff({
+          engine: ENGINE3,
+          op: mutation.op,
+          table: mutation.table,
+          requestId: reqId,
+          rowCount,
+          options
+        });
+      }
+    } catch {
+    }
+    return stripInjectedRows(result);
+  };
+  const wrapRequest = (raw) => {
+    const recordedInputs = [];
+    const proxy = new Proxy(raw, {
+      get(target, prop, receiver) {
+        if (prop === "input") {
+          return (...args) => {
+            target.input.apply(target, args);
+            recordedInputs.push(args);
+            return proxy;
+          };
+        }
+        if (prop === "query") {
+          return (text2) => runInstrumentedQuery(target, recordedInputs, text2);
+        }
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+    return proxy;
+  };
+  return new Proxy(pool, {
+    get(target, prop, receiver) {
+      if (prop === "request") {
+        return (...args) => wrapRequest(
+          target.request.apply(target, args)
+        );
+      }
+      if (prop === "query" && typeof target.query === "function") {
+        return (text2, ...rest) => {
+          if (typeof text2 === "string" && rest.length === 0) {
+            return wrapRequest(target.request()).query(text2);
+          }
+          return target.query.call(
+            target,
+            text2,
+            ...rest
+          );
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
+// src/db/sqlite.ts
+var ENGINE4 = "sqlite";
+function resolveParams(args) {
+  if (args.length === 1 && isRecord(args[0])) {
+    return { kind: "named", value: args[0] };
+  }
+  const values = [];
+  for (const arg of args) {
+    if (Array.isArray(arg)) values.push(...arg);
+    else values.push(arg);
+  }
+  return { kind: "positional", values };
+}
+function bindReusedParams(resolved, whereClause) {
+  if (resolved.kind === "named") return [resolved.value];
+  const count = countPlaceholders(whereClause);
+  const start = Math.max(0, resolved.values.length - count);
+  return resolved.values.slice(start);
+}
+function buildPostSelectByPk(table, pkCols, pks) {
+  if (pks.length === 0 || pkCols.length === 0) return null;
+  if (pkCols.length === 1) {
+    const col = pkCols[0];
+    const params2 = pks.map((pk) => pk[col]);
+    const placeholders = params2.map(() => "?").join(", ");
+    return {
+      sql: `SELECT * FROM ${table} WHERE ${col} IN (${placeholders})`,
+      params: params2
+    };
+  }
+  const clause = pks.map(() => `(${pkCols.map((col) => `${col} = ?`).join(" AND ")})`).join(" OR ");
+  const params = pks.flatMap((pk) => pkCols.map((col) => pk[col]));
+  return { sql: `SELECT * FROM ${table} WHERE ${clause}`, params };
+}
+function toChangeCount(info) {
+  if (isRecord(info) && typeof info.changes === "number" && Number.isFinite(info.changes)) {
+    return Math.max(0, Math.floor(info.changes));
+  }
+  return 0;
+}
+function validRowid(info) {
+  if (!isRecord(info)) return void 0;
+  const rowid = info.lastInsertRowid;
+  if (typeof rowid === "number" && Number.isFinite(rowid) && rowid > 0)
+    return rowid;
+  if (typeof rowid === "bigint" && rowid > 0n) return rowid;
+  return void 0;
+}
+function instrumentSqliteDatabase(db, options) {
+  const emittedReadRowsByRequest = /* @__PURE__ */ new Map();
+  const resolveRequestId = () => options.requestId ?? options.getRequestId?.();
+  const handleInsert = (realStmt, parsed, args, requestId) => {
+    const info = realStmt.run(...args);
+    try {
+      const changes = toChangeCount(info);
+      const rowid = validRowid(info);
+      if (changes === 1 && rowid !== void 0) {
+        let afterRow;
+        try {
+          const row = db.prepare(`SELECT * FROM ${parsed.table} WHERE rowid = ?`).get(rowid);
+          if (isRecord(row)) afterRow = row;
+        } catch {
+          afterRow = void 0;
+        }
+        if (afterRow) {
+          emitDbDiffEvents({
+            engine: ENGINE4,
+            op: "insert",
+            table: parsed.table,
+            requestId,
+            rows: [afterRow],
+            rowCount: 1,
+            options
+          });
+          return info;
+        }
+      }
+      if (changes > 0) {
+        emitImagelessDbDiff({
+          engine: ENGINE4,
+          op: "insert",
+          table: parsed.table,
+          requestId,
+          rowCount: changes,
+          options
+        });
+      }
+    } catch {
+    }
+    return info;
+  };
+  const handleUpdate = (realStmt, parsed, args, requestId) => {
+    const resolved = resolveParams(args);
+    const pkCols = options.pkColumns?.[parsed.table] ?? ["id"];
+    let usablePks;
+    let beforeByPk;
+    if (parsed.whereClause) {
+      try {
+        const preRows = db.prepare(`SELECT * FROM ${parsed.table} ${parsed.whereClause}`).all(...bindReusedParams(resolved, parsed.whereClause));
+        const pks = [];
+        const beforeMap = /* @__PURE__ */ new Map();
+        for (const row of Array.isArray(preRows) ? preRows : []) {
+          if (!isRecord(row)) continue;
+          const pk = extractPk(row, parsed.table, options.pkColumns);
+          if (pk && pkCols.every((col) => col in pk)) pks.push(pk);
+          if (pk) beforeMap.set(pkKey(pk), row);
+        }
+        usablePks = pks;
+        if (options.captureBefore) beforeByPk = beforeMap;
+      } catch {
+        usablePks = void 0;
+        beforeByPk = void 0;
+      }
+    }
+    const info = realStmt.run(...args);
+    try {
+      const changes = toChangeCount(info);
+      if (usablePks && usablePks.length > 0) {
+        const maxRows = normalizeMaxRowsPerStatement(
+          options.maxRowsPerStatement
+        );
+        const capped = usablePks.slice(0, maxRows);
+        let afterRows;
+        try {
+          const post = buildPostSelectByPk(parsed.table, pkCols, capped);
+          if (post) {
+            const rows = db.prepare(post.sql).all(...post.params);
+            afterRows = (Array.isArray(rows) ? rows : []).filter(isRecord);
+          }
+        } catch {
+          afterRows = void 0;
+        }
+        if (afterRows && afterRows.length > 0) {
+          emitDbDiffEvents({
+            engine: ENGINE4,
+            op: "update",
+            table: parsed.table,
+            requestId,
+            rows: afterRows,
+            beforeByPk,
+            rowCount: changes,
+            options
+          });
+          return info;
+        }
+      }
+      if (changes > 0) {
+        emitImagelessDbDiff({
+          engine: ENGINE4,
+          op: "update",
+          table: parsed.table,
+          requestId,
+          rowCount: changes,
+          options
+        });
+      }
+    } catch {
+    }
+    return info;
+  };
+  const handleDelete = (realStmt, parsed, args, requestId) => {
+    const resolved = resolveParams(args);
+    let beforeRows;
+    if (parsed.whereClause) {
+      try {
+        const preRows = db.prepare(`SELECT * FROM ${parsed.table} ${parsed.whereClause}`).all(...bindReusedParams(resolved, parsed.whereClause));
+        beforeRows = (Array.isArray(preRows) ? preRows : []).filter(isRecord);
+      } catch {
+        beforeRows = void 0;
+      }
+    }
+    const info = realStmt.run(...args);
+    try {
+      const changes = toChangeCount(info);
+      if (beforeRows && beforeRows.length > 0) {
+        emitDbDiffEvents({
+          engine: ENGINE4,
+          op: "delete",
+          table: parsed.table,
+          requestId,
+          rows: beforeRows,
+          rowCount: changes,
+          options
+        });
+        return info;
+      }
+      if (changes > 0) {
+        emitImagelessDbDiff({
+          engine: ENGINE4,
+          op: "delete",
+          table: parsed.table,
+          requestId,
+          rowCount: changes,
+          options
+        });
+      }
+    } catch {
+    }
+    return info;
+  };
+  const instrumentedRun = (realStmt, parsed, args) => {
+    let requestId;
+    try {
+      requestId = resolveRequestId();
+    } catch {
+      return realStmt.run(...args);
+    }
+    if (!requestId) return realStmt.run(...args);
+    switch (parsed.op) {
+      case "insert":
+        return handleInsert(realStmt, parsed, args, requestId);
+      case "update":
+        return handleUpdate(realStmt, parsed, args, requestId);
+      case "delete":
+        return handleDelete(realStmt, parsed, args, requestId);
+      default:
+        return realStmt.run(...args);
+    }
+  };
+  const instrumentedAll = (realStmt, parsedRead, args) => {
+    const result = realStmt.all(...args);
+    let requestId;
+    try {
+      requestId = resolveRequestId();
+    } catch {
+      return result;
+    }
+    if (!requestId) return result;
+    try {
+      const rows = (Array.isArray(result) ? result : []).filter(isRecord);
+      emitDbReadEvents({
+        engine: ENGINE4,
+        table: parsedRead.table,
+        requestId,
+        rows,
+        rowCount: rows.length,
+        options,
+        emittedReadRowsByRequest
+      });
+    } catch {
+    }
+    return result;
+  };
+  const wrapStatement = (stmt, parsed, parsedRead) => new Proxy(stmt, {
+    get(target, prop, _receiver) {
+      if (prop === "run" && parsed) {
+        return (...args) => instrumentedRun(target, parsed, args);
+      }
+      if (prop === "all" && parsedRead && options.captureReads) {
+        return (...args) => instrumentedAll(target, parsedRead, args);
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  return new Proxy(db, {
+    get(target, prop, _receiver) {
+      if (prop === "prepare") {
+        return (...prepareArgs) => {
+          const realStmt = target.prepare(
+            ...prepareArgs
+          );
+          const sql = prepareArgs[0];
+          if (typeof sql !== "string") return realStmt;
+          let parsed;
+          let parsedRead;
+          try {
+            parsed = parseMutation(sql);
+            parsedRead = parsed ? void 0 : parseRead(sql);
+          } catch {
+            return realStmt;
+          }
+          if (!parsed && !parsedRead) return realStmt;
+          return wrapStatement(realStmt, parsed, parsedRead);
+        };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
+// src/db/index.ts
+function resolveDbRequestContext(input) {
+  const correlation = resolveBackendRequestCorrelation(input);
+  return {
+    requestId: correlation.requestId,
+    ...correlation.sessionId ? { sessionId: correlation.sessionId } : {}
+  };
+}
+
+// src/backend-intake.ts
+var DEFAULT_BACKEND_INTAKE_ENDPOINT = "http://localhost:9898";
+var MAX_SAFE_STRING_LENGTH = 200;
+var MAX_WARNING_MESSAGE_LENGTH = 300;
+async function sendBackendEvent(options) {
+  const event = options.event;
+  const sessionId = safeString(options.sessionId) ?? safeString(event.sessionId);
+  const requestId = safeString(event.d.requestId);
+  const eventKind = safeString(event.k);
+  const warningContext = { sessionId, requestId, eventKind };
+  if (!sessionId) {
+    reportWarning(options.onWarning, {
+      kind: "missing-session",
+      message: "Backend event was not sent because no usable session ID was available.",
+      requestId,
+      eventKind
+    });
+    return;
+  }
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    reportWarning(options.onWarning, {
+      kind: "missing-fetch",
+      message: "Backend event was not sent because no fetch implementation is available.",
+      ...warningContext
+    });
+    return;
+  }
+  const endpoint = normalizeEndpoint(options.endpoint);
+  const headers = { "Content-Type": "application/json" };
+  const authToken = options.authToken?.trim();
+  if (authToken) headers["X-Crumbtrail-Auth"] = authToken;
+  try {
+    const response = await fetchImpl(`${endpoint}/api/events`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ sessionId, events: [event] }),
+      signal: options.signal
+    });
+    if (!response.ok) {
+      reportWarning(options.onWarning, {
+        kind: "http-error",
+        message: `Backend intake returned HTTP ${safeStatus(response.status) ?? "error"}.`,
+        status: safeStatus(response.status),
+        ...warningContext
+      });
+      return;
+    }
+    await readAndValidateResponse(response);
+  } catch (error) {
+    reportWarning(options.onWarning, {
+      kind: classifyCaughtError(error),
+      message: safeErrorMessage(error),
+      ...warningContext
+    });
+  }
+}
+async function readAndValidateResponse(response) {
+  if (typeof response.text === "function") {
+    const text2 = await response.text();
+    if (!text2.trim()) return;
+    const parsed = JSON.parse(text2);
+    if (!isRecord2(parsed) || parsed.ok !== true) {
+      throw new MalformedBackendResponseError(
+        "Backend intake response did not contain ok: true."
+      );
+    }
+    return;
+  }
+  if (typeof response.json === "function") {
+    const parsed = await response.json();
+    if (!isRecord2(parsed) || parsed.ok !== true) {
+      throw new MalformedBackendResponseError(
+        "Backend intake response did not contain ok: true."
+      );
+    }
+  }
+}
+function normalizeEndpoint(endpoint) {
+  const trimmed = endpoint?.trim() || DEFAULT_BACKEND_INTAKE_ENDPOINT;
+  return trimmed.replace(/\/+$/, "");
+}
+function reportWarning(onWarning, warning) {
+  if (!onWarning) return;
+  try {
+    onWarning(
+      removeUndefined({
+        kind: warning.kind,
+        message: boundString(warning.message, MAX_WARNING_MESSAGE_LENGTH) ?? "Backend intake warning.",
+        status: warning.status,
+        sessionId: safeString(warning.sessionId),
+        requestId: safeString(warning.requestId),
+        eventKind: safeString(warning.eventKind)
+      })
+    );
+  } catch {
+  }
+}
+function classifyCaughtError(error) {
+  return error instanceof SyntaxError || error instanceof MalformedBackendResponseError ? "malformed-response" : "fetch-rejected";
+}
+function safeErrorMessage(error) {
+  if (error instanceof SyntaxError || error instanceof MalformedBackendResponseError) {
+    return "Backend intake response was malformed.";
+  }
+  if (error instanceof Error) {
+    if (error.name === "AbortError")
+      return "Backend intake request was aborted.";
+    return boundString(error.name, MAX_WARNING_MESSAGE_LENGTH) ?? "Backend intake request failed.";
+  }
+  return "Backend intake request failed.";
+}
+function safeStatus(status) {
+  return Number.isInteger(status) && status >= 100 && status <= 599 ? status : void 0;
+}
+function safeString(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const text2 = String(value).trim();
+  return boundString(text2, MAX_SAFE_STRING_LENGTH);
+}
+function boundString(value, maxLength) {
+  if (!value) return void 0;
+  return value.length > maxLength ? `${value.slice(0, maxLength)}\u2026` : value;
+}
+function removeUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var MalformedBackendResponseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MalformedBackendResponseError";
+  }
+};
+
+// src/express.ts
+var requestStates = /* @__PURE__ */ new WeakMap();
+function createCrumbtrailExpressMiddleware(options = {}) {
+  return function crumbtrailExpressMiddleware(req, res, next) {
+    const startedAtMs = readNow(options);
+    const startEvent = buildBackendRequestStartEvent({
+      ...readRequestInput(req, options),
+      now: startedAtMs
+    });
+    const state = stateFromEvent(startEvent, startedAtMs);
+    requestStates.set(req, state);
+    exposeRequestIdHeader(req, state);
+    attemptSend(startEvent, options, state.sessionId);
+    attachFinishListener(req, res, options, state);
+    next();
+  };
+}
+function createCrumbtrailExpressErrorMiddleware(options = {}) {
+  return function crumbtrailExpressErrorMiddleware(error, req, res, next) {
+    const now = readNow(options);
+    const existingState = requestStates.get(req);
+    const state = existingState ?? createMinimalState(req, options, now);
+    if (!existingState) requestStates.set(req, state);
+    exposeRequestIdHeader(req, state);
+    const errorEvent = buildBackendRequestErrorEvent({
+      ...readRequestInput(req, options, state),
+      now,
+      statusCode: safeStatusCode(res.statusCode),
+      durationMs: now - state.startedAtMs,
+      error
+    });
+    attemptSend(errorEvent, options, state.sessionId);
+    next(error);
+  };
+}
+function attachFinishListener(req, res, options, state) {
+  if (typeof res.once !== "function") return;
+  res.once("finish", () => {
+    const now = readNow(options);
+    const endEvent = buildBackendRequestEndEvent({
+      ...readRequestInput(req, options, state),
+      now,
+      statusCode: safeStatusCode(res.statusCode),
+      durationMs: now - state.startedAtMs
+    });
+    attemptSend(endEvent, options, state.sessionId);
+  });
+}
+function exposeRequestIdHeader(req, state) {
+  if (!state.requestId) return;
+  req.headers ??= {};
+  const existingKey = Object.keys(req.headers).find(
+    (key) => key.toLowerCase() === CRUMBTRAIL_REQUEST_HEADER
+  );
+  if (!existingKey) req.headers[CRUMBTRAIL_REQUEST_HEADER] = state.requestId;
+}
+function createMinimalState(req, options, now) {
+  const event = buildBackendRequestStartEvent({
+    ...readRequestInput(req, options),
+    now
+  });
+  return stateFromEvent(event, now);
+}
+function stateFromEvent(event, startedAtMs) {
+  const requestId = typeof event.d.requestId === "string" ? event.d.requestId : "unknown";
+  const sessionId = typeof event.sessionId === "string" ? event.sessionId : typeof event.d.sessionId === "string" ? event.d.sessionId : void 0;
+  return { startedAtMs, requestId, sessionId };
+}
+function readRequestInput(req, options, state) {
+  return {
+    method: req.method,
+    url: req.url,
+    originalUrl: req.originalUrl,
+    path: req.path,
+    route: readRoute(req),
+    headers: req.headers,
+    sessionId: state?.sessionId ?? resolveRequestValue(options.sessionId, req),
+    requestId: state?.requestId ?? resolveRequestValue(options.requestId, req),
+    sessionStartedAt: resolveSessionStartedAt(options.sessionStartedAt, req)
+  };
+}
+function readRoute(req) {
+  if (typeof req.route === "string") return req.route;
+  if (req.route && typeof req.route.path === "string") return req.route.path;
+  return void 0;
+}
+function resolveRequestValue(value, req) {
+  try {
+    return typeof value === "function" ? value(req) : value;
+  } catch {
+    return void 0;
+  }
+}
+function resolveSessionStartedAt(value, req) {
+  try {
+    return typeof value === "function" ? value(req) : value;
+  } catch {
+    return void 0;
+  }
+}
+function readNow(options) {
+  try {
+    const value = options.now?.() ?? Date.now();
+    return Number.isFinite(value) ? Math.round(value) : Date.now();
+  } catch {
+    return Date.now();
+  }
+}
+function safeStatusCode(statusCode) {
+  return Number.isFinite(statusCode) ? statusCode : void 0;
+}
+function attemptSend(event, options, sessionId) {
+  void sendBackendEvent({
+    event,
+    sessionId,
+    endpoint: options.endpoint,
+    authToken: options.authToken,
+    fetch: options.fetch,
+    signal: options.signal,
+    onWarning: options.onWarning
+  }).catch(() => {
+  });
+}
+
+// src/headless-session.ts
+async function startHeadlessSession(options) {
+  const fetcher = options.fetchImpl ?? fetch;
+  const endpoint = options.endpoint.replace(/\/+$/, "");
+  const headers = buildHeaders(options.authToken);
+  await postJson(fetcher, `${endpoint}/api/session/start`, headers, {
+    sessionId: options.sessionId,
+    metadata: {
+      ...options.metadata,
+      source: "headless"
+    }
+  });
+  return {
+    sessionId: options.sessionId,
+    async record(events) {
+      const batch = Array.isArray(events) ? events : [events];
+      await postJson(fetcher, `${endpoint}/api/events`, headers, {
+        sessionId: options.sessionId,
+        events: batch
+      });
+    },
+    async end() {
+      return postJson(fetcher, `${endpoint}/api/session/end`, headers, {
+        sessionId: options.sessionId
+      });
+    }
+  };
+}
+function buildHeaders(authToken) {
+  return {
+    "content-type": "application/json",
+    ...authToken ? { "x-crumbtrail-auth": authToken } : {}
+  };
+}
+async function postJson(fetcher, url, headers, body) {
+  const response = await fetcher(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  const text2 = await response.text();
+  let parsed = {};
+  try {
+    parsed = text2 ? JSON.parse(text2) : {};
+  } catch {
+    parsed = { error: text2 || `HTTP ${response.status}` };
+  }
+  if (!response.ok) {
+    const message = isRecord3(parsed) && typeof parsed.error === "string" ? parsed.error : `HTTP ${response.status}`;
+    throw new Error(`Crumbtrail headless session request failed: ${message}`);
+  }
+  return isRecord3(parsed) ? parsed : {};
+}
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/ticket/comment.ts
+var REASON_PHRASES = {
+  semantic: "wording overlap with the captured incident",
+  "same-route": "same route",
+  "same-error": "same error signature",
+  "env-overlap": "shared environment or configuration",
+  "time-proximity": "occurred near the report time",
+  "release-hint": "same release"
+};
+function humanizeReason(reason) {
+  return REASON_PHRASES[reason] ?? reason;
+}
+function text(value) {
+  return { type: "text", text: value };
+}
+function code(value) {
+  return { type: "text", text: value, marks: [{ type: "code" }] };
+}
+function link(label, href) {
+  return {
+    type: "text",
+    text: label,
+    marks: [{ type: "link", attrs: { href } }]
+  };
+}
+function paragraph(...content) {
+  return { type: "paragraph", content };
+}
+function bulletList(items) {
+  return {
+    type: "bulletList",
+    content: items.map((content) => ({
+      type: "listItem",
+      content: [paragraph(...content)]
+    }))
+  };
+}
+function confidencePercent(confidence) {
+  const pct = Math.round(confidence * 100);
+  if (Number.isNaN(pct)) return 0;
+  return Math.min(100, Math.max(0, pct));
+}
+function linkParagraph(label, bundleUrl) {
+  return paragraph(text(`${label} `), link(bundleUrl, bundleUrl));
+}
+function correlationLines(correlation) {
+  if (!correlation) return [];
+  const items = [];
+  const sessionId = typeof correlation.sessionId === "string" ? correlation.sessionId.trim() : "";
+  if (sessionId) items.push([text("Session: "), code(sessionId)]);
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of correlation.requestIds ?? []) {
+    if (typeof raw !== "string") continue;
+    const id = raw.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    items.push([text("Request: "), code(id)]);
+    if (seen.size >= 3) break;
+  }
+  return items;
+}
+function buildAdvisoryComment(input) {
+  const { match, bundleUrl } = input;
+  const gaps = input.gaps ?? [];
+  const content = [];
+  if (match.outcome === "matched") {
+    content.push(
+      paragraph(
+        text(
+          "Crumbtrail located a candidate incident that likely matches this ticket."
+        )
+      )
+    );
+    content.push(
+      paragraph(
+        text(
+          `Match confidence: ${confidencePercent(match.confidence)}% (advisory \u2014 review the evidence before acting).`
+        )
+      )
+    );
+    const reasons = (match.reasons ?? []).filter(
+      (reason) => typeof reason === "string" && reason.trim().length > 0
+    );
+    if (reasons.length > 0) {
+      content.push(paragraph(text("Why this was matched:")));
+      content.push(
+        bulletList(reasons.map((reason) => [text(humanizeReason(reason))]))
+      );
+    }
+    const correlationItems = correlationLines(input.correlation);
+    if (correlationItems.length > 0) {
+      content.push(
+        paragraph(
+          text("Correlation keys (match these against your logs and traces):")
+        )
+      );
+      content.push(bulletList(correlationItems));
+    }
+    content.push(linkParagraph("View the full evidence bundle:", bundleUrl));
+    return { version: 1, type: "doc", content };
+  }
+  content.push(
+    paragraph(
+      text(
+        "Crumbtrail could not locate a recorded incident matching this ticket yet."
+      )
+    )
+  );
+  const namedGaps = gaps.filter(
+    (gap) => gap && typeof gap.reason === "string" && gap.reason.trim().length > 0
+  );
+  if (namedGaps.length > 0) {
+    content.push(paragraph(text("What is missing:")));
+    content.push(
+      bulletList(
+        namedGaps.map((gap) => {
+          const label = gap.suggestion ? `${gap.reason} \u2014 ${gap.suggestion}` : gap.reason;
+          return [text(label)];
+        })
+      )
+    );
+  }
+  content.push(linkParagraph("Open the evidence bundle:", bundleUrl));
+  return { version: 1, type: "doc", content };
+}
+
+// src/replay/result.ts
+import fs from "fs";
+var REPLAY_RESULT_SCHEMA_VERSION = "replay-result.v1";
+var RESOLUTIONS = /* @__PURE__ */ new Set(["exact", "role-label", "structural", "failed"]);
+function buildReplayResult(input) {
+  return {
+    schemaVersion: REPLAY_RESULT_SCHEMA_VERSION,
+    sourceSessionId: input.sourceSessionId,
+    actuatedSessionId: input.actuatedSessionId,
+    steps: input.steps,
+    divergences: input.divergences,
+    completed: input.completed
+  };
+}
+function parseReplayResult(raw) {
+  if (!isRecord4(raw)) {
+    throw new Error("replay-result.v1: payload must be an object");
+  }
+  if (raw.schemaVersion !== REPLAY_RESULT_SCHEMA_VERSION) {
+    throw new Error(`replay-result.v1: unsupported schemaVersion ${JSON.stringify(raw.schemaVersion)}`);
+  }
+  if (!Array.isArray(raw.steps)) {
+    throw new Error("replay-result.v1: steps must be an array");
+  }
+  if (!Array.isArray(raw.divergences)) {
+    throw new Error("replay-result.v1: divergences must be an array");
+  }
+  if (typeof raw.completed !== "boolean") {
+    throw new Error("replay-result.v1: completed must be a boolean");
+  }
+  return {
+    schemaVersion: REPLAY_RESULT_SCHEMA_VERSION,
+    sourceSessionId: reqString(raw, "sourceSessionId", "result"),
+    actuatedSessionId: reqString(raw, "actuatedSessionId", "result"),
+    steps: raw.steps.map(parseStep),
+    divergences: raw.divergences.map(parseDivergence),
+    completed: raw.completed
+  };
+}
+function writeReplayResult(filePath, result) {
+  fs.writeFileSync(filePath, `${JSON.stringify(result, null, 2)}
+`);
+}
+function parseStep(step, index) {
+  const context = `steps[${index}]`;
+  if (!isRecord4(step)) {
+    throw new Error(`replay-result.v1: ${context} must be an object`);
+  }
+  const resolution = step.resolution;
+  if (typeof resolution !== "string" || !RESOLUTIONS.has(resolution)) {
+    throw new Error(`replay-result.v1: ${context}.resolution must be one of exact|role-label|structural|failed`);
+  }
+  return {
+    index: reqNumber(step, "index", context),
+    sig: reqString(step, "sig", context),
+    action: reqString(step, "action", context),
+    resolution,
+    durationMs: reqNumber(step, "durationMs", context)
+  };
+}
+function parseDivergence(divergence, index) {
+  const context = `divergences[${index}]`;
+  if (!isRecord4(divergence)) {
+    throw new Error(`replay-result.v1: ${context} must be an object`);
+  }
+  return {
+    index: reqNumber(divergence, "index", context),
+    sig: reqString(divergence, "sig", context),
+    reason: reqString(divergence, "reason", context)
+  };
+}
+function isRecord4(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function reqString(obj, key, context) {
+  const value = obj[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`replay-result.v1: ${context}.${key} must be a non-empty string`);
+  }
+  return value;
+}
+function reqNumber(obj, key, context) {
+  const value = obj[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`replay-result.v1: ${context}.${key} must be a finite number`);
+  }
+  return value;
+}
+
+// src/auto-capture.ts
+var AUTO_CAPTURE_ERROR_EVENT = "backend.uncaught";
+var MAX_MESSAGE = 500;
+var MAX_STACK = 4e3;
+var CRASH_FLUSH_MS = 150;
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+var installed = false;
+async function autoCapture(options) {
+  if (installed) {
+    return { stop() {
+    } };
+  }
+  installed = true;
+  const proc = options.processImpl ?? process;
+  const consoleRef = options.consoleImpl ?? console;
+  if (options.loadEnv !== false) {
+    try {
+      const loader = proc.loadEnvFile;
+      if (typeof loader === "function") loader.call(proc);
+    } catch {
+    }
+  }
+  const authToken = options.authToken ?? proc.env.CRUMBTRAIL_KEY;
+  let session;
+  try {
+    session = await startHeadlessSession({
+      endpoint: options.endpoint,
+      sessionId: options.sessionId ?? generateSessionId(),
+      authToken,
+      metadata: { ...options.metadata, capture: "auto" },
+      fetchImpl: options.fetchImpl
+    });
+  } catch {
+    session = void 0;
+  }
+  let capturing = false;
+  const record = (error, source) => {
+    if (!session || capturing) return void 0;
+    capturing = true;
+    try {
+      return session.record(buildErrorEvent(error, source)).catch(() => {
+      });
+    } catch {
+      return void 0;
+    } finally {
+      capturing = false;
+    }
+  };
+  const originalError = consoleRef.error;
+  const patchedError = (...args) => {
+    const errorArg = args.find((a) => a instanceof Error);
+    record(errorArg ?? args.map((a) => String(a)).join(" "), "console.error");
+    originalError.apply(consoleRef, args);
+  };
+  consoleRef.error = patchedError;
+  const exit = (code2) => {
+    const exiter = options.onCrashExit ?? ((c) => proc.exit(c));
+    exiter(code2);
+  };
+  let crashing = false;
+  const flushThenExit = async (error, source) => {
+    if (crashing) return;
+    crashing = true;
+    try {
+      const recordPromise = record(error, source);
+      if (recordPromise) {
+        await Promise.race([recordPromise, sleep(CRASH_FLUSH_MS)]);
+      }
+    } catch {
+    } finally {
+      exit(1);
+    }
+  };
+  const onUncaught = (error) => {
+    void flushThenExit(error, "uncaughtException");
+  };
+  proc.on("uncaughtException", onUncaught);
+  const onUnhandled = (reason) => {
+    void flushThenExit(reason, "unhandledRejection");
+  };
+  proc.on("unhandledRejection", onUnhandled);
+  let stopped = false;
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    if (consoleRef.error === patchedError) {
+      consoleRef.error = originalError;
+    }
+    proc.removeListener("uncaughtException", onUncaught);
+    proc.removeListener("unhandledRejection", onUnhandled);
+    installed = false;
+  };
+  return { sessionId: session?.sessionId, stop };
+}
+function generateSessionId() {
+  const random = Math.random().toString(36).slice(2, 10);
+  return `auto_${Date.now().toString(36)}_${random}`;
+}
+function buildErrorEvent(error, source) {
+  const normalized = normalizeError(error);
+  return {
+    t: Date.now(),
+    k: AUTO_CAPTURE_ERROR_EVENT,
+    d: {
+      source,
+      error: normalized
+    }
+  };
+}
+function normalizeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name || "Error",
+      message: bounded(error.message, MAX_MESSAGE),
+      ...error.stack ? { stack: bounded(error.stack, MAX_STACK) } : {}
+    };
+  }
+  if (typeof error === "string") {
+    return { name: "Error", message: bounded(error, MAX_MESSAGE) };
+  }
+  return {
+    name: typeof error,
+    message: bounded(safeString2(error), MAX_MESSAGE)
+  };
+}
+function safeString2(value) {
+  try {
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+  } catch {
+    return "Non-serializable value";
+  }
+}
+function bounded(value, max) {
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
+}
+export {
+  AUTO_CAPTURE_ERROR_EVENT,
+  BugQueueManager,
+  CLOUDFLARE_AUTH_FIELDS,
+  CLOUDFLARE_DESCRIPTOR,
+  CLOUDFLARE_R2_ACCESS_KEY_ID_ENV,
+  CLOUDFLARE_R2_ACCOUNT_ID_ENV,
+  CLOUDFLARE_R2_BUCKET_ENV,
+  CLOUDFLARE_R2_DATASET_ENV,
+  CLOUDFLARE_R2_ENDPOINT_ENV,
+  CLOUDFLARE_R2_PREFIX_ENV,
+  CLOUDFLARE_R2_SECRET_ACCESS_KEY_ENV,
+  CLOUDWATCH_ACCESS_KEY_ID_ENV,
+  CLOUDWATCH_AUTH_FIELDS,
+  CLOUDWATCH_DESCRIPTOR,
+  CLOUDWATCH_ENDPOINT_ENV,
+  CLOUDWATCH_LOG_GROUPS_ENV,
+  CLOUDWATCH_REGION_ENV,
+  CLOUDWATCH_SECRET_ACCESS_KEY_ENV,
+  CLOUDWATCH_SESSION_TOKEN_ENV,
+  CRUMBTRAIL_USER_AGENT,
+  CloudWatchEvidenceSource,
+  CloudflareEvidenceSource,
+  CompareError,
+  DATADOG_API_KEY_ENV,
+  DATADOG_APP_KEY_ENV,
+  DATADOG_AUTH_FIELDS,
+  DATADOG_DEFAULT_SITE,
+  DATADOG_DESCRIPTOR,
+  DATADOG_SITE_ENV,
+  DEFAULT_MAX_TOTAL_BYTES,
+  DEFAULT_SENSITIVE_DB_COLUMNS,
+  DEFAULT_SOURCE_TIMEOUT_MS,
+  DEFAULT_SWEEP_CHECKPOINT_MS,
+  DEFAULT_SWEEP_IDLE_MS,
+  DEFAULT_SWEEP_INTERVAL_MS,
+  DISTINCT_BUGS_SCHEMA_VERSION,
+  DatadogEvidenceSource,
+  EVIDENCE_SOURCE_PROVIDERS,
+  CRUMBTRAIL_USER_AGENT as EVIDENCE_SOURCE_USER_AGENT,
+  FIX_CONTEXT_SCHEMA_VERSION,
+  FilesystemSessionStore,
+  FixContextError,
+  InspectError,
+  JiraTicketClient,
+  McpServer,
+  POSTHOG_API_KEY_ENV,
+  POSTHOG_AUTH_FIELDS,
+  POSTHOG_DEFAULT_HOST,
+  POSTHOG_DESCRIPTOR,
+  POSTHOG_HOST_ENV,
+  POSTHOG_PROJECT_ID_ENV,
+  PROVIDER_IDS,
+  PROVIDER_RECIPES,
+  PostHogEvidenceSource,
+  REGRESSION_CONTEXT_SCHEMA_VERSION,
+  REPLAY_RESULT_SCHEMA_VERSION,
+  SENTRY_AUTH_FIELDS,
+  SENTRY_AUTH_TOKEN_ENV,
+  SENTRY_DEFAULT_HOST,
+  SENTRY_DESCRIPTOR,
+  SENTRY_HOST_ENV,
+  SENTRY_ORG_ENV,
+  SESSION_COMPARE_SCHEMA_VERSION,
+  SPLUNK_AUTH_FIELDS,
+  SPLUNK_DESCRIPTOR,
+  SPLUNK_HOST_ENV,
+  SPLUNK_INDEX_ENV,
+  SPLUNK_TOKEN_ENV,
+  SPLUNK_WEB_URL_ENV,
+  SentryEvidenceSource,
+  SessionManager,
+  SplunkEvidenceSource,
+  TicketError,
+  autoCapture,
+  buildAdvisoryComment,
+  buildCloudWatchQuery,
+  buildCloudflarePlan,
+  buildDatadogQuery,
+  buildDbDiffEvent,
+  buildDbReadBulkEvent,
+  buildDbReadEvent,
+  buildDistinctBugSignature,
+  buildFixContext,
+  buildPostHogQuery,
+  buildRegressionContext,
+  buildReplayResult,
+  buildSentryQuery,
+  buildSessionSummary,
+  buildSplunkQuery,
+  cloudWatchDeepLink,
+  cloudWatchEvidenceProvider,
+  cloudflareEvidenceProvider,
+  compareSessions,
+  createCrumbtrailExpressErrorMiddleware,
+  createCrumbtrailExpressMiddleware,
+  createServer,
+  datadogAppBase,
+  datadogEvidenceProvider,
+  decodeOtlpLogsProtobuf,
+  decodeOtlpTraceProtobuf,
+  defaultSessionStore,
+  evidenceRequestHeaders,
+  evidenceSourcesFromEnv,
+  fetchAdapterEvidence,
+  formatComparisonSummary,
+  formatDuration,
+  formatInspection,
+  getProviderRecipe,
+  groupDistinctBugRecurrences,
+  groupDistinctBugs,
+  inspectSession,
+  instrumentMssqlPool,
+  instrumentMysqlClient,
+  instrumentPgClient,
+  instrumentSqliteDatabase,
+  isProviderId,
+  jiraToSymptom,
+  normalizeCloudWatchRow,
+  normalizeDatadogLog,
+  normalizeDatadogSpan,
+  normalizePostHogEvent,
+  normalizePostHogRecording,
+  normalizeSentryIssue,
+  normalizeSplunkRow,
+  parseMutation,
+  parseRead,
+  parseReplayResult,
+  posthogEventDeepLink,
+  posthogEvidenceProvider,
+  posthogRecordingDeepLink,
+  readPackageVersion,
+  redactEvidenceGap,
+  redactEvidenceItem,
+  redactSourceResult,
+  registerEvidenceProvider,
+  renderCompareReport,
+  renderProviderCliOutput,
+  renderProviderConfig,
+  renderProviderDoc,
+  renderProviderReadme,
+  resolveDbRequestContext,
+  sentryEvidenceProvider,
+  signSigV4,
+  splunkEvidenceProvider,
+  splunkSearchDeepLink,
+  splunkWebBase,
+  startHeadlessSession,
+  startSessionSweeper,
+  sweepIdleSessions,
+  withBoundedRetry,
+  writeReplayResult
+};