@lunora/do 1.0.0-alpha.34 → 1.0.0-alpha.36

package/dist/packem_shared/{ROOT_DO_SIZE_WARN_BYTES-B5c6kQIN.mjs → ROOT_DO_SIZE_WARN_BYTES-CBlw_ir3.mjs}

@@ -5,12 +5,14 @@ import { j as jsonResponse } from './json-response-BdbtpOhm.mjs';
 import { e as encodeWire, d as decodeWire } from './wire-codec-CzQc1pvf.mjs';
 import { parseExportShardArgs, parseImportShardArgs } from './exportShardRows-Dy3oFZ26.mjs';
 import { recordAuthEvent, readAuthMetrics } from './AUTH_METRICS_BUCKETS_TABLE-CiHHYeJi.mjs';
+import { n as normalizeLogFields, r as resolveTraceAnchor, a as createTracer, c as createMetrics, d as dispatchRootSpan } from './context-telemetry-DWfYDxCS.mjs';
 import { DATA_MIGRATION_STATE_TABLE, readMigrationStatus } from './DATA_MIGRATION_STATE_TABLE-CYwBpyTr.mjs';
 import { SCAN_DEP, createDependencyTracker, tableFromDepKey } from './SCAN_DEP-DLJF8dsj.mjs';
 import { readFunctionMetricsTotals, readFunctionMetricIndexHits, recordFunctionMetric, mergeScanAttribution, readFunctionMetrics, readFunctionMetricBuckets } from './FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs';
-import { createFanoutCounters, ADMIN_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, selectMatchingIds, ADMIN_FUNCTIONS, findStorageReferences, listTables, summarizeSubscriptions, summarizeFanoutTopics, readTablePage, facetColumn, FLAGS_FUNCTION_PREFIX, recordFanoutPass, MAX_PAGE_SIZE } from './ADMIN_FUNCTIONS-CAHLZMj8.mjs';
+import { createFanoutCounters, ADMIN_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, selectMatchingIds, ADMIN_FUNCTIONS, findStorageReferences, listTables, summarizeSubscriptions, summarizeFanoutTopics, readTablePage, facetColumn, FLAGS_FUNCTION_PREFIX, recordFanoutPass, MAX_PAGE_SIZE } from './ADMIN_FUNCTIONS-DVk02KpP.mjs';
 import { LogBuffer } from './LogBuffer-B_Ezju_N.mjs';
 import { recordCapturedMail, clearCapturedMail, readCapturedMail, MAIL_TABLE } from './MAIL_RETENTION-CPpgl-dX.mjs';
+import { stableStringify } from './stableStringify-mC40mZts.mjs';
 import { readBookmark, armRestore } from './armRestore-4Px61hHS.mjs';
 import { ReactiveCache, reactiveCacheKey } from './ReactiveCache-DnSvbjil.mjs';
 import { stableWireKey } from './stableWireKey-DKuXO7T5.mjs';
@@ -22,35 +24,10 @@ import { runReadonlySql } from './MAX_SQL_ROWS-iFAA8FbD.mjs';
 import { ConflictError } from './ConflictError-CLoq37xH.mjs';
 import { e as deleteGlobalShapeSnapshotsForConnection, g as readIdempotent, h as writeIdempotent, t as trimIdempotent, r as readClientWatermark, m as migrateClientWatermark, c as advanceClientWatermark, d as deleteGlobalShapeSnapshot, f as readGlobalShapeSnapshot, w as writeGlobalShapeSnapshot } from './ctx-db-idempotency-BdcNpvY4.mjs';
 import { CDC_LOG_TABLE, readCdcChanges, readCdcCursor, readCdcEpoch, minCdcSeq, bumpCdcEpoch } from './CDC_LOG_TABLE-uwOJxJJZ.mjs';
-import { stableStringify } from './stableStringify-mC40mZts.mjs';
 import { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes-Cz9dHyh1.mjs';
 
 const MAX_BATCH_ENTRIES = 500;
 
-const BUFFER_LEVEL = {
-  debug: "debug",
-  error: "error",
-  fatal: "error",
-  info: "info",
-  log: "info",
-  trace: "debug",
-  warn: "warn"
-};
-
-const HEX_ONLY = /^[0-9a-f]+$/;
-const parseTraceparent = (header) => {
-  if (header === null || header === void 0) {
-    return void 0;
-  }
-  const parts = header.trim().toLowerCase().split("-");
-  const [version, traceId, parentSpanId, flags] = parts;
-  if (parts.length < 4 || version === void 0 || version.length !== 2 || !HEX_ONLY.test(version) || version === "ff" || // Version 00 forbids trailing fields; only a future version may carry them.
-  version === "00" && parts.length !== 4 || traceId === void 0 || parentSpanId === void 0 || flags === void 0 || flags.length !== 2 || !HEX_ONLY.test(flags) || traceId.length !== 32 || parentSpanId.length !== 16 || !HEX_ONLY.test(traceId) || !HEX_ONLY.test(parentSpanId) || traceId === "00000000000000000000000000000000" || parentSpanId === "0000000000000000") {
-    return void 0;
-  }
-  return { parentSpanId, traceId };
-};
-
 const evictOldestEntry = (map, capacity) => {
   if (map.size < capacity) {
     return;
@@ -116,12 +93,12 @@ const verifyWsAdminToken = async (secret, token, now = Date.now()) => {
 
 const AUDIT_LOG_TABLE = "__lunora_audit__";
 const AUDIT_LOG_RETENTION = 1e3;
-const runSql$3 = (sql, query, ...params) => {
+const runSql$4 = (sql, query, ...params) => {
   const runner = sql.exec;
   return runner.call(sql, query, ...params);
 };
 const ensureAuditTable = (sql) => {
-  runSql$3(
+  runSql$4(
     sql,
     `CREATE TABLE IF NOT EXISTS "${AUDIT_LOG_TABLE}" (
             seq INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -135,7 +112,7 @@ const ensureAuditTable = (sql) => {
 };
 const appendAuditEntry = (sql, entry) => {
   ensureAuditTable(sql);
-  runSql$3(
+  runSql$4(
     sql,
     `INSERT INTO "${AUDIT_LOG_TABLE}" (ts, op, "table", id, detail) VALUES (?, ?, ?, ?, ?)`,
     entry.ts,
@@ -147,13 +124,13 @@ const appendAuditEntry = (sql, entry) => {
     // eslint-disable-next-line unicorn/no-null -- SQL NULL is the correct value for an op with no associated table/id/detail.
     entry.detail === void 0 ? null : JSON.stringify(entry.detail)
   );
-  runSql$3(sql, `DELETE FROM "${AUDIT_LOG_TABLE}" WHERE seq <= (SELECT MAX(seq) - ? FROM "${AUDIT_LOG_TABLE}")`, AUDIT_LOG_RETENTION);
+  runSql$4(sql, `DELETE FROM "${AUDIT_LOG_TABLE}" WHERE seq <= (SELECT MAX(seq) - ? FROM "${AUDIT_LOG_TABLE}")`, AUDIT_LOG_RETENTION);
 };
 const readAuditLog = (sql, options = {}) => {
   ensureAuditTable(sql);
   const sinceSeq = options.sinceSeq ?? 0;
   const limit = Math.max(1, Math.min(options.limit ?? AUDIT_LOG_RETENTION, 1e4));
-  const rows = runSql$3(
+  const rows = runSql$4(
     sql,
     `SELECT seq, ts, op, "table", id, detail FROM "${AUDIT_LOG_TABLE}" WHERE seq > ? ORDER BY seq DESC LIMIT ?`,
     sinceSeq,
@@ -206,6 +183,164 @@ const buildBatchEntryRequest = (batchRequest, entry) => {
   });
 };
 
+const ISSUE_STATE_TABLE = "__lunora_issue_state__";
+const HASH_QUERY_BATCH = 100;
+const ISSUE_STATUSES = ["ignored", "open", "resolved"];
+const ISSUE_SEVERITIES = ["critical", "high", "low", "medium"];
+const runSql$3 = (sql, query, ...parameters) => {
+  const runner = sql.exec;
+  return runner.call(sql, query, ...parameters);
+};
+const SQL_NULL = null;
+const orNull$1 = (value) => value ?? SQL_NULL;
+const ensureIssueStateTable = (sql) => {
+  runSql$3(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${ISSUE_STATE_TABLE}" (
+            hash TEXT PRIMARY KEY,
+            status TEXT NOT NULL DEFAULT 'open',
+            assignee TEXT,
+            severity TEXT,
+            updated_at REAL NOT NULL,
+            updated_by TEXT
+        )`
+  );
+};
+const hydrate = (row) => {
+  return {
+    ...row.assignee === null ? {} : { assignee: row.assignee },
+    hash: row.hash,
+    ...row.severity === null ? {} : { severity: row.severity },
+    status: row.status,
+    updatedAt: row.updated_at,
+    ...row.updated_by === null ? {} : { updatedBy: row.updated_by }
+  };
+};
+const readIssueStates = (sql, hashes) => {
+  const states = /* @__PURE__ */ new Map();
+  if (hashes.length === 0) {
+    return states;
+  }
+  ensureIssueStateTable(sql);
+  for (let start = 0; start < hashes.length; start += HASH_QUERY_BATCH) {
+    const batch = hashes.slice(start, start + HASH_QUERY_BATCH);
+    const placeholders = batch.map(() => "?").join(", ");
+    const rows = runSql$3(
+      sql,
+      `SELECT hash, status, assignee, severity, updated_at, updated_by FROM "${ISSUE_STATE_TABLE}" WHERE hash IN (${placeholders})`,
+      ...batch
+    ).toArray();
+    for (const row of rows) {
+      states.set(row.hash, hydrate(row));
+    }
+  }
+  return states;
+};
+const upsertIssueState = (sql, hash, patch, updatedAt, updatedBy) => {
+  ensureIssueStateTable(sql);
+  const status = orNull$1(patch.status);
+  const assignee = orNull$1(patch.assignee);
+  const clearAssignee = patch.assignee === null ? 1 : 0;
+  const severity = orNull$1(patch.severity);
+  const clearSeverity = patch.severity === null ? 1 : 0;
+  const actor = orNull$1(updatedBy);
+  runSql$3(
+    sql,
+    `INSERT INTO "${ISSUE_STATE_TABLE}" (hash, status, assignee, severity, updated_at, updated_by)
+         VALUES (?, COALESCE(?, 'open'), ?, ?, ?, ?)
+         ON CONFLICT(hash) DO UPDATE SET
+            status = COALESCE(?, status),
+            assignee = CASE WHEN ? = 1 THEN NULL ELSE COALESCE(?, assignee) END,
+            severity = CASE WHEN ? = 1 THEN NULL ELSE COALESCE(?, severity) END,
+            updated_at = ?,
+            updated_by = ?`,
+    hash,
+    status,
+    assignee,
+    severity,
+    updatedAt,
+    actor,
+    status,
+    clearAssignee,
+    assignee,
+    clearSeverity,
+    severity,
+    updatedAt,
+    actor
+  );
+  const [row] = runSql$3(
+    sql,
+    `SELECT hash, status, assignee, severity, updated_at, updated_by FROM "${ISSUE_STATE_TABLE}" WHERE hash = ?`,
+    hash
+  ).toArray();
+  return row === void 0 ? { hash, status: status ?? "open", updatedAt, ...updatedBy === void 0 ? {} : { updatedBy } } : hydrate(row);
+};
+
+const DEFAULT_CAPACITY$1 = 256;
+const seriesKey = (event) => `${event.kind}\0${event.name}\0${stableStringify(event.attributes ?? {})}`;
+class MetricBuffer {
+  capacity;
+  series = /* @__PURE__ */ new Map();
+  constructor(capacity = DEFAULT_CAPACITY$1) {
+    this.capacity = capacity > 0 ? Math.trunc(capacity) : DEFAULT_CAPACITY$1;
+  }
+  /** Number of distinct series currently aggregated. */
+  get size() {
+    return this.series.size;
+  }
+  /** Drop every aggregated series. */
+  clear() {
+    this.series.clear();
+  }
+  /**
+   * Snapshot of the aggregated series, most-recently-updated first, each a fresh
+   * copy so a caller can't mutate the live aggregate. `series` is kept in
+   * update order (tail = newest), so one reverse yields newest-first.
+   */
+  entries() {
+    return [...this.series.values()].toReversed().map((s) => {
+      return { ...s };
+    });
+  }
+  /** Fold one measurement into its series, creating or updating the aggregate. */
+  push(event) {
+    const key = seriesKey(event);
+    const existing = this.series.get(key);
+    if (existing === void 0) {
+      if (this.series.size >= this.capacity) {
+        const oldest = this.series.keys().next().value;
+        if (oldest !== void 0) {
+          this.series.delete(oldest);
+        }
+      }
+      this.series.set(key, {
+        ...event.attributes === void 0 ? {} : { attributes: event.attributes },
+        count: 1,
+        firstTs: event.ts,
+        functionPath: event.functionPath,
+        kind: event.kind,
+        last: event.value,
+        lastTs: event.ts,
+        max: event.value,
+        min: event.value,
+        name: event.name,
+        ...event.shardKey === void 0 ? {} : { shardKey: event.shardKey },
+        sum: event.value
+      });
+      return;
+    }
+    this.series.delete(key);
+    existing.count += 1;
+    existing.sum += event.value;
+    existing.min = Math.min(existing.min, event.value);
+    existing.max = Math.max(existing.max, event.value);
+    existing.last = event.value;
+    existing.lastTs = event.ts;
+    existing.functionPath = event.functionPath;
+    this.series.set(key, existing);
+  }
+}
+
 const QUERY_METRICS_TABLE = "__lunora_metrics_queries";
 const QUERY_METRICS_MAX_SQL_LEN = 512;
 const QUERY_METRICS_MAX_STATEMENTS = 500;
@@ -1182,35 +1317,6 @@ const createRelayLink = (host) => {
   return parsed === void 0 ? new OwnerRelay(host, name) : new RelayMember(host, parsed.ownerKey, parsed.relayIndex);
 };
 
-const stringifyFieldValue = (value) => {
-  if (typeof value === "string") {
-    return value;
-  }
-  try {
-    return JSON.stringify(value) ?? String(value);
-  } catch {
-    return String(value);
-  }
-};
-const coerceFieldValue = (value) => typeof value === "boolean" || typeof value === "number" || typeof value === "string" ? value : stringifyFieldValue(value);
-const normalizeLogFields = (perCall, bound) => {
-  if (perCall === void 0 && bound === void 0) {
-    return void 0;
-  }
-  const merged = {};
-  if (bound !== void 0) {
-    for (const [key, value] of Object.entries(bound)) {
-      merged[key] = coerceFieldValue(value);
-    }
-  }
-  if (perCall !== void 0) {
-    for (const [key, value] of Object.entries(perCall)) {
-      merged[key] = coerceFieldValue(value);
-    }
-  }
-  return Object.keys(merged).length === 0 ? void 0 : merged;
-};
-
 const REQUEST_LOG_TABLE = "__lunora_reqlog__";
 const REQUEST_LOG_RETENTION = 1e3;
 const REQUEST_LOG_EVENT_SOURCE = "lunora";
@@ -1439,6 +1545,23 @@ const readRequestLog = (sql, options = {}) => {
     return base;
   });
 };
+const applyIssueStates = (sql, issues) => {
+  const states = readIssueStates(sql, [...issues.keys()]);
+  for (const issue of issues.values()) {
+    const state = states.get(issue.hash);
+    if (state === void 0) {
+      continue;
+    }
+    issue.stateUpdatedAt = state.updatedAt;
+    if (state.assignee !== void 0) {
+      issue.assignee = state.assignee;
+    }
+    if (state.severity !== void 0) {
+      issue.severity = state.severity;
+    }
+    issue.status = state.status === "resolved" && issue.lastSeen > state.updatedAt ? "open" : state.status;
+  }
+};
 const readErrorIssues = (sql, options = {}) => {
   ensureRequestLogTable(sql);
   const limit = Math.max(1, Math.min(options.limit ?? REQUEST_LOG_RETENTION, 1e4));
@@ -1470,7 +1593,7 @@ const readErrorIssues = (sql, options = {}) => {
     const { culprit, hash, title } = fingerprintError({ functionPath: row.function_path, message });
     const existing = issues.get(hash);
     if (existing === void 0) {
-      issues.set(hash, { count: 1, culprit, firstSeen: row.ts, hash, lastSeen: row.ts, sampleMessage: message, title });
+      issues.set(hash, { count: 1, culprit, firstSeen: row.ts, hash, lastSeen: row.ts, sampleMessage: message, status: "open", title });
       sampleTs.set(hash, row.ts);
       continue;
     }
@@ -1483,7 +1606,10 @@ const readErrorIssues = (sql, options = {}) => {
       existing.title = title;
     }
   }
-  return [...issues.values()].toSorted((a, b) => b.lastSeen - a.lastSeen);
+  applyIssueStates(sql, issues);
+  const folded = [...issues.values()];
+  const filtered = options.status === void 0 ? folded : folded.filter((issue) => issue.status === options.status);
+  return filtered.toSorted((a, b) => b.lastSeen - a.lastSeen);
 };
 
 const runSocketPool = async (items, processOne, concurrency = 8) => {
@@ -1503,6 +1629,136 @@ const runSocketPool = async (items, processOne, concurrency = 8) => {
   await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
 };
 
+const DEFAULT_CAPACITY = 500;
+class SpanBuffer {
+  buffer = [];
+  capacity;
+  constructor(capacity = DEFAULT_CAPACITY) {
+    this.capacity = capacity > 0 ? Math.trunc(capacity) : DEFAULT_CAPACITY;
+  }
+  /** Number of spans currently buffered. */
+  get size() {
+    return this.buffer.length;
+  }
+  /** Drop every buffered span. */
+  clear() {
+    this.buffer.length = 0;
+  }
+  /** Snapshot of the buffered spans in insertion order. Fresh array per call. */
+  entries() {
+    return [...this.buffer];
+  }
+  /**
+   * Whether any buffered span belongs to `traceId`. A membership test rather
+   * than `entries().some(...)` so the per-dispatch check that decides whether
+   * to record a root span doesn't copy the whole ring on every request.
+   */
+  hasTrace(traceId) {
+    return this.buffer.some((span) => span.traceId === traceId);
+  }
+  /** Append a span, evicting the oldest when at capacity. */
+  push(span) {
+    this.buffer.push(span);
+    if (this.buffer.length > this.capacity) {
+      this.buffer.shift();
+    }
+  }
+}
+const DEFAULT_TRACE_LIMIT = 50;
+const groupByTrace = (spans) => {
+  const byTrace = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const group = byTrace.get(span.traceId);
+    if (group === void 0) {
+      byTrace.set(span.traceId, [span]);
+    } else {
+      group.push(span);
+    }
+  }
+  return byTrace;
+};
+const selectAnchor = (group, byId) => {
+  const declaredRoot = group.find((span) => span.dispatch === true);
+  if (declaredRoot !== void 0) {
+    return declaredRoot;
+  }
+  const byStart = group.toSorted((a, b) => a.startTs - b.startTs);
+  return byStart.find((span) => !byId.has(span.parentSpanId)) ?? byStart[0];
+};
+const depthResolver = (anchor, byId) => {
+  const cache = /* @__PURE__ */ new Map([[anchor.spanId, 0]]);
+  return (span) => {
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = span;
+    let base = 0;
+    for (; ; ) {
+      const known = cache.get(current.spanId);
+      if (known !== void 0) {
+        base = known;
+        break;
+      }
+      if (seen.has(current.spanId)) {
+        break;
+      }
+      seen.add(current.spanId);
+      chain.push(current);
+      const parent = byId.get(current.parentSpanId);
+      if (parent === void 0) {
+        break;
+      }
+      current = parent;
+    }
+    for (const [index, entry] of chain.toReversed().entries()) {
+      cache.set(entry.spanId, base + index + 1);
+    }
+    return cache.get(span.spanId) ?? base;
+  };
+};
+const foldTraces = (spans, limit = DEFAULT_TRACE_LIMIT) => {
+  const byTrace = groupByTrace(spans);
+  const selected = [...byTrace.entries()].map(([traceId, group]) => {
+    return { group, startTs: Math.min(...group.map((span) => span.startTs)), traceId };
+  }).toSorted((a, b) => b.startTs - a.startTs).slice(0, limit);
+  const summaries = [];
+  for (const { group, traceId } of selected) {
+    const byId = new Map(group.map((span) => [span.spanId, span]));
+    const anchor = selectAnchor(group, byId);
+    if (anchor === void 0) {
+      continue;
+    }
+    const depthOf = depthResolver(anchor, byId);
+    const { startTs } = anchor;
+    const endTs = Math.max(...group.map((span) => span.startTs + span.durationMs));
+    const rows = group.map((span) => {
+      return {
+        ...span.attributes === void 0 ? {} : { attributes: span.attributes },
+        depth: depthOf(span),
+        durationMs: span.durationMs,
+        ...span.error === void 0 ? {} : { error: span.error },
+        name: span.name,
+        // Clamped at 0: a child whose parent was evicted can predate the
+        // anchor, and a negative offset would render as a bar off-canvas.
+        offsetMs: Math.max(0, span.startTs - startTs),
+        ok: span.ok,
+        parentSpanId: span.parentSpanId,
+        spanId: span.spanId
+      };
+    }).toSorted((a, b) => a.offsetMs - b.offsetMs || a.depth - b.depth);
+    summaries.push({
+      durationMs: endTs - startTs,
+      functionPath: anchor.functionPath,
+      ok: group.every((span) => span.ok),
+      rootName: anchor.name,
+      ...anchor.shardKey === void 0 ? {} : { shardKey: anchor.shardKey },
+      spans: rows,
+      startTs,
+      traceId
+    });
+  }
+  return { total: byTrace.size, traces: summaries.toSorted((a, b) => b.startTs - a.startTs) };
+};
+
 const DANGLING_SCAN_CAP = 5e3;
 const DANGLING_RESULT_CAP = 500;
 const DOC_COLUMN = "__doc__";
@@ -1618,6 +1874,36 @@ const parseWriteRowArgs = (args) => {
   }
   return { doc: record, id, op, table };
 };
+const isIssueStatus = (value) => typeof value === "string" && ISSUE_STATUSES.includes(value);
+const isIssueSeverity = (value) => typeof value === "string" && ISSUE_SEVERITIES.includes(value);
+const parseIssueHash = (args) => {
+  const hash = typeof args["hash"] === "string" ? args["hash"].trim() : "";
+  if (hash === "") {
+    throw new LunoraError("BAD_REQUEST", "issue triage: `hash` is required");
+  }
+  return hash;
+};
+const CLEAR = null;
+const parseAssigneeArgument = (args) => {
+  const raw = args["assignee"];
+  if (raw === null) {
+    return CLEAR;
+  }
+  if (typeof raw === "string" && raw.trim() !== "") {
+    return raw;
+  }
+  throw new LunoraError("BAD_REQUEST", "assignIssue: `assignee` must be a non-empty string (assign) or null (unassign)");
+};
+const parseSeverityArgument = (args) => {
+  const raw = args["severity"];
+  if (raw === null) {
+    return CLEAR;
+  }
+  if (isIssueSeverity(raw)) {
+    return raw;
+  }
+  throw new LunoraError("BAD_REQUEST", "setIssueSeverity: `severity` must be one of critical|high|medium|low, or null to clear");
+};
 const parseCreateWorkflowInstanceArgs = (args) => {
   const exportName = typeof args["exportName"] === "string" ? args["exportName"].trim() : "";
   if (exportName === "") {
@@ -2239,6 +2525,14 @@ class ShardDO {
   currentRequestIp;
   /** W3C `traceparent` of the inbound RPC; forwarded onto outbound container fetches. */
   currentRequestTraceparent;
+  /**
+   * Trace ids for the in-flight dispatch, resolved once at entry (see
+   * {@link resolveTraceAnchor}). Shared by `ctx.trace` and by the synthetic
+   * root span recorded on the way out so both agree even with no inbound
+   * `traceparent`. Cleared in the same `finally` as the other per-request
+   * fields.
+   */
+  currentRequestTrace;
   /**
    * Client-issued idempotency key for the in-flight mutation, forwarded via the
    * `x-lunora-mutation-id` header. When set, the dispatch path dedups the call
@@ -2436,6 +2730,19 @@ class ShardDO {
    * "recent RPC errors on this instance" feed, not a general application log.
    */
   logs = new LogBuffer();
+  /**
+   * Recent `ctx.trace` spans (plus the synthetic per-dispatch root), powering
+   * the studio's Traces panel. In-memory and hibernation-volatile like
+   * `logs` — production tracing ships to a collector via `otlpSink`.
+   */
+  spans = new SpanBuffer();
+  /**
+   * Running aggregates of `ctx.metrics.*` measurements, powering the studio's
+   * Metrics panel. In-memory and hibernation-volatile like `logs` and
+   * `spans`, but folds samples into per-series totals rather than ringing
+   * raw events — production aggregation ships to a collector via the sink.
+   */
+  metricSeries = new MetricBuffer();
   /**
    * In-flight dependency tracker for the currently-executing query. Set by
    * `runCachedQuery` so the ctx-db hooks (wired via `onRead`) can
@@ -2527,6 +2834,7 @@ class ShardDO {
    * Worker-side fetch entry point. Handles WebSocket upgrades and the
    * shard-local RPC endpoint forwarded by `@lunora/runtime`.
    */
+  // eslint-disable-next-line sonarjs/cognitive-complexity -- the DO's central request router; #149 added the trace-anchor capture and root-span record, tipping it to 16. Splitting the request lifecycle across helpers would hurt readability more than the +1 costs.
   async fetch(request) {
     const url = new URL(request.url);
     this.shardBinding = request.headers.get("x-lunora-shard-binding") ?? this.shardBinding;
@@ -2558,6 +2866,8 @@ class ShardDO {
     this.currentRequestIp = request.headers.get("x-lunora-client-ip") ?? void 0;
     this.currentRequestSystem = request.headers.get("x-lunora-system") === "1";
     this.currentRequestTraceparent = request.headers.get("traceparent") ?? void 0;
+    this.currentRequestTrace = resolveTraceAnchor(this.currentRequestTraceparent);
+    const dispatchTrace = this.currentRequestTrace;
     this.currentRequestReadTables = void 0;
     this.currentRequestCacheHit = void 0;
     this.metrics.requests += 1;
@@ -2565,6 +2875,7 @@ class ShardDO {
     this.currentScannedTables = /* @__PURE__ */ new Set();
     this.currentIndexHits = /* @__PURE__ */ new Set();
     this.currentStmtSamples = [];
+    let dispatchError;
     try {
       if (payload.functionPath.startsWith(RELATION_FUNCTION_PREFIX)) {
         const value = await this.runRelationFanoutRead(payload.functionPath, payload.args ?? {});
@@ -2596,6 +2907,7 @@ class ShardDO {
       return response;
     } catch (error) {
       this.metrics.errors += 1;
+      dispatchError = { thrown: error };
       const durationMs = Date.now() - dispatchStartedAt;
       const message = error instanceof Error ? error.message : String(error);
       const conflicted = error instanceof ConflictError && error.kind === "occ";
@@ -2615,6 +2927,10 @@ class ShardDO {
       await this.flushChangedTables();
       return this.errorToResponse(error);
     } finally {
+      if (this.spans.hasTrace(dispatchTrace.traceId)) {
+        this.recordDispatchRootSpan(payload.functionPath, dispatchStartedAt, dispatchError, dispatchTrace);
+      }
+      this.currentRequestTrace = void 0;
       this.currentRequestBookmark = void 0;
       this.currentResponseBookmark = void 0;
       this.currentRequestUserId = void 0;
@@ -3084,6 +3400,14 @@ class ShardDO {
   getCurrentTraceparent() {
     return this.currentRequestTraceparent;
   }
+  /**
+   * The in-flight dispatch's trace ids, for the generated `buildCtx` to hand to
+   * {@link makeTracer}. `undefined` outside a dispatch (an alarm, a lifecycle
+   * hook), where the tracer mints its own anchor.
+   */
+  getCurrentTrace() {
+    return this.currentRequestTrace;
+  }
   /**
    * Identity claims (email, name, roles, …) forwarded by the runtime's
    * `resolveIdentity` hook. Returns `undefined` for anonymous requests
@@ -4158,7 +4482,7 @@ class ShardDO {
    * chose to log them, exactly like a raw `console.log`.
    */
   recordUserLog(functionPath, level, args, message, fields, sink) {
-    const trace = parseTraceparent(this.getCurrentTraceparent());
+    const trace = this.currentRequestTrace;
     const event = {
       args,
       fields,
@@ -4166,12 +4490,12 @@ class ShardDO {
       level,
       message,
       shardKey: this.state.id?.name,
-      spanId: trace?.parentSpanId,
+      spanId: trace?.rootSpanId,
       traceId: trace?.traceId,
       ts: Date.now(),
       userId: this.getCurrentUserId()
     };
-    this.logs.push({ fields, functionPath, level: BUFFER_LEVEL[level], message, timestamp: event.ts });
+    this.logs.push({ fields, functionPath, level, message, timestamp: event.ts });
     try {
       emitLogEvent(event);
     } catch {
@@ -4196,16 +4520,138 @@ class ShardDO {
       this.recordUserLog(functionPath, level, args, message, fields, sink);
     };
     return {
-      debug: (...args) => emit("debug", args),
-      error: (...args) => emit("error", args),
-      fatal: (...args) => emit("fatal", args),
-      info: (...args) => emit("info", args),
-      log: (...args) => emit("log", args),
-      trace: (...args) => emit("trace", args),
-      warn: (...args) => emit("warn", args),
+      debug: (...args) => {
+        emit("debug", args);
+      },
+      error: (...args) => {
+        emit("error", args);
+      },
+      fatal: (...args) => {
+        emit("fatal", args);
+      },
+      info: (...args) => {
+        emit("info", args);
+      },
+      log: (...args) => {
+        emit("log", args);
+      },
+      trace: (...args) => {
+        emit("trace", args);
+      },
+      warn: (...args) => {
+        emit("warn", args);
+      },
       with: (fields) => this.makeLogger(functionPath, sink, boundFields ? { ...boundFields, ...fields } : fields)
     };
   }
+  /**
+   * Build the `ctx.trace` span factory for one dispatched function. The
+   * generated `buildCtx` calls this once per dispatch and assigns the result to
+   * `ctx.trace`.
+   *
+   * Thin wiring over {@link createTracer}, which owns the span semantics (see
+   * there for why nesting is explicit rather than ambient). Everything it needs
+   * from the shard is passed explicitly.
+   *
+   * `anchor` is the trace this ctx's spans belong to; omit it for a ctx with no
+   * owning dispatch (an alarm, a subscription re-run) to mint a fresh anchor, so
+   * `ctx.trace` still yields a coherent self-contained trace there.
+   */
+  makeTracer(functionPath, sink, anchor) {
+    return createTracer({
+      anchor: anchor ?? resolveTraceAnchor(void 0),
+      functionPath,
+      record: (span) => {
+        this.recordSpan(span, sink);
+      },
+      shardKey: this.state.id?.name,
+      userId: () => this.getCurrentUserId()
+    });
+  }
+  /**
+   * Build the `ctx.metrics` recorder for one dispatched function. Thin wiring
+   * over {@link createMetrics}, which owns the instrument semantics.
+   */
+  makeMetrics(functionPath, sink) {
+    return createMetrics({
+      functionPath,
+      record: (event) => {
+        this.recordMetric(event, sink);
+      },
+      shardKey: this.state.id?.name
+    });
+  }
+  /**
+   * Fold one measurement into the in-memory {@link metricSeries} readout and
+   * hand it to the optional `sink.onMetric`. Best-effort like
+   * {@link recordUserLog} and {@link recordSpan}: recording a measurement must
+   * never break the handler that recorded it.
+   *
+   * The buffer folds rather than rings: a measurement's value is in its
+   * aggregate over a window, which a bounded ring of raw samples can't represent
+   * (it evicts the oldest samples, the ones a running total needs). So the
+   * buffer keeps one running aggregate per series and resets on hibernation like
+   * logs and spans — a "recent metrics on this instance" dev readout. Durable,
+   * cross-instance aggregation is still the sink's job.
+   */
+  recordMetric(event, sink) {
+    try {
+      this.metricSeries.push(event);
+    } catch {
+    }
+    if (sink?.onMetric) {
+      try {
+        sink.onMetric(event, { waitUntil: this.state.waitUntil?.bind(this.state) });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Buffer the synthetic root span for a finished dispatch. The caller gates
+   * this on the dispatch having actually produced spans (the `hasTrace` check at
+   * the call site): every request minting a root would fill the bounded ring
+   * with single-bar traces from uninstrumented handlers and evict the
+   * instrumented ones the panel exists to show.
+   *
+   * `anchor` carries the dispatch's trace ids, captured at entry rather than
+   * read from `this` here — this runs after the handler's awaits, where the
+   * shared field may already belong to an interleaved dispatch.
+   */
+  recordDispatchRootSpan(functionPath, startedAt, failure, anchor) {
+    try {
+      this.spans.push(
+        dispatchRootSpan({
+          anchor,
+          durationMs: Date.now() - startedAt,
+          failure,
+          functionPath,
+          shardKey: this.state.id?.name,
+          startTs: startedAt,
+          userId: this.getCurrentUserId()
+        })
+      );
+    } catch {
+    }
+  }
+  /**
+   * Buffer one span for the studio Traces panel and hand it to the optional
+   * `sink.onSpan`. Best-effort throughout, exactly like {@link recordUserLog}:
+   * a span is recorded *after* its body already settled, so letting a telemetry
+   * failure escape here would turn a succeeded operation into a failed request.
+   */
+  // eslint-disable-next-line @typescript-eslint/member-ordering -- kept in the span-recording cluster (next to recordDispatchRootSpan) for cohesion rather than hoisted above every private member
+  recordSpan(span, sink) {
+    try {
+      this.spans.push(span);
+    } catch {
+    }
+    if (sink?.onSpan) {
+      try {
+        sink.onSpan(span, { waitUntil: this.state.waitUntil?.bind(this.state) });
+      } catch {
+      }
+    }
+  }
   /**
    * Assemble the per-socket {@link LifecycleDispatchInfo} from its attachment:
    * the verified identity to replay and the {@link LifecycleEvent} the hooks
@@ -4652,8 +5098,63 @@ class ShardDO {
     if (functionPath === ADMIN_FUNCTIONS.listFlags) {
       return this.handleListFlags(args);
     }
+    const triaged = await this.handleIssueTriageOp(functionPath, args);
+    if (triaged !== void 0) {
+      return triaged;
+    }
     return this.handlePitrAdminOp(functionPath, args);
   }
+  /**
+   * Serve the four Issue-triage admin writes — `resolveIssue` / `ignoreIssue`
+   * (a status change), `assignIssue` (set/clear an owner), `setIssueSeverity`
+   * (tag/clear severity). Each upserts one row in the reserved
+   * `__lunora_issue_state__` side table keyed by the Issue's fingerprint
+   * `hash`, then re-derives at read time in {@link readErrorIssues}. Returns
+   * `undefined` for any path it doesn't own so `handleExtraAdminOp` falls
+   * through. Admin-gated by `handleAdminRpc`'s caller (the `LUNORA_ADMIN_TOKEN`
+   * bearer); a bad/missing `hash` (or a bad status/severity value) is a 400.
+   *
+   * The write lands through raw SQL the change-tracker can't observe, so it
+   * marks {@link ISSUE_STATE_TABLE} changed and flushes — the live Issues
+   * subscription is an admin-wildcard memo that re-runs whenever a flush finds
+   * a changed table, so the triage shows up without an unrelated write.
+   */
+  async handleIssueTriageOp(functionPath, args) {
+    const patch = this.parseIssueTriagePatch(functionPath, args);
+    if (patch === void 0) {
+      return void 0;
+    }
+    const hash = parseIssueHash(args);
+    const updatedBy = typeof args["updatedBy"] === "string" ? args["updatedBy"] : void 0;
+    const sql = this.state.storage.sql;
+    const state = upsertIssueState(sql, hash, patch, Date.now(), updatedBy);
+    this.recordChangedTable(ISSUE_STATE_TABLE);
+    await this.flushChangedTables();
+    this.recordAudit(functionPath.slice(ADMIN_FUNCTION_PREFIX.length), { detail: { ...patch, hash } });
+    return jsonResponse({ result: { state } }, 200);
+  }
+  /**
+   * Map an Issue-triage admin path to the `IssueStatePatch` it applies, or
+   * `undefined` when the path isn't a triage write. `assignIssue`/
+   * `setIssueSeverity` accept an explicit `null` to CLEAR the field (unassign /
+   * untag); a missing or malformed value is a 400 rather than a silent no-op.
+   */
+  // eslint-disable-next-line class-methods-use-this -- kept an instance method for symmetry with the other `parse*`/handler seams
+  parseIssueTriagePatch(functionPath, args) {
+    if (functionPath === ADMIN_FUNCTIONS.resolveIssue) {
+      return { status: "resolved" };
+    }
+    if (functionPath === ADMIN_FUNCTIONS.ignoreIssue) {
+      return { status: "ignored" };
+    }
+    if (functionPath === ADMIN_FUNCTIONS.assignIssue) {
+      return { assignee: parseAssigneeArgument(args), status: "open" };
+    }
+    if (functionPath === ADMIN_FUNCTIONS.setIssueSeverity) {
+      return { severity: parseSeverityArgument(args) };
+    }
+    return void 0;
+  }
   /**
    * Record one app-level auth attempt for the auth-failure SLO (PLAN3 §2.3).
    * The worker calls this fire-and-forget (via `waitUntil`) after a top-level
@@ -5281,6 +5782,7 @@ class ShardDO {
    * wraps each in the {@link ADMIN_WILDCARD} sentinel, keeping that one fact in
    * a single place and `readAdminOp` under its complexity budget.
    */
+  // eslint-disable-next-line sonarjs/cognitive-complexity -- a flat admin-RPC dispatch chain (one trivial branch per function); #149 added the getTraces/getMetrics branches. A lookup table would obscure the 1:1 path→reader mapping this deliberately keeps.
   readAdminWildcardOp(functionPath) {
     if (functionPath === ADMIN_FUNCTIONS.listTables) {
       return listTables(this.state.storage.sql);
@@ -5300,6 +5802,13 @@ class ShardDO {
     if (functionPath === ADMIN_FUNCTIONS.getLogs) {
       return { entries: this.logs.entries() };
     }
+    if (functionPath === ADMIN_FUNCTIONS.getTraces) {
+      const folded = foldTraces(this.spans.entries());
+      return { total: folded.total, traces: folded.traces };
+    }
+    if (functionPath === ADMIN_FUNCTIONS.getMetricSeries) {
+      return { series: this.metricSeries.entries() };
+    }
     if (functionPath === ADMIN_FUNCTIONS.getSettings) {
       return buildSettings(this.env);
     }
@@ -5418,6 +5927,7 @@ class ShardDO {
         functionPathPrefix: typeof args["functionPathPrefix"] === "string" ? args["functionPathPrefix"] : void 0,
         limit: typeof args["limit"] === "number" ? args["limit"] : void 0,
         shardKey: typeof args["shardKey"] === "string" ? args["shardKey"] : void 0,
+        status: isIssueStatus(args["status"]) ? args["status"] : void 0,
         userId: typeof args["userId"] === "string" ? args["userId"] : void 0
       })
     };