lopata 0.0.1

package/runtime/request-cf.ts

@@ -0,0 +1,28 @@
+const DEFAULT_CF: Record<string, unknown> = {
+  country: "US",
+  city: "San Francisco",
+  continent: "NA",
+  latitude: "37.7749",
+  longitude: "-122.4194",
+  timezone: "America/Los_Angeles",
+  region: "California",
+  regionCode: "CA",
+  postalCode: "94102",
+  metroCode: "807",
+  asn: 13335,
+  asOrganization: "Cloudflare",
+  colo: "SFO",
+  httpProtocol: "HTTP/2",
+  tlsVersion: "TLSv1.3",
+  tlsCipher: "AEAD-AES128-GCM-SHA256",
+};
+
+export function addCfProperty(request: Request): Request {
+  Object.defineProperty(request, "cf", {
+    value: Object.freeze({ ...DEFAULT_CF }),
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  });
+  return request;
+}

package/runtime/rpc-validate.ts

@@ -0,0 +1,154 @@
+/**
+ * RPC argument/return-value validation.
+ *
+ * Cloudflare Workers RPC serialises payloads via structured clone with
+ * extensions (function stubs, RpcTarget stubs).  Bunflare runs everything
+ * in-process so values pass by reference — code that works locally may
+ * break in production.  This module warns at dev time when a value
+ * contains types that CF cannot serialise.
+ */
+
+const TYPED_ARRAY_TAGS = new Set([
+  "Int8Array", "Uint8Array", "Uint8ClampedArray",
+  "Int16Array", "Uint16Array",
+  "Int32Array", "Uint32Array",
+  "Float32Array", "Float64Array",
+  "BigInt64Array", "BigUint64Array",
+]);
+
+function typeName(v: unknown): string {
+  if (v === null) return "null";
+  const tag = Object.prototype.toString.call(v);        // "[object Foo]"
+  return tag.slice(8, -1);                               // "Foo"
+}
+
+/**
+ * Recursively validate a value for CF RPC serialisation compatibility.
+ * Returns an array of human-readable error strings (empty = OK).
+ */
+export function validateRpcValue(value: unknown, path = "$"): string[] {
+  return _validate(value, path, new WeakSet());
+}
+
+function _validate(value: unknown, path: string, seen: WeakSet<object>): string[] {
+  // --- primitives ---
+  if (value === null || value === undefined) return [];
+  const t = typeof value;
+  if (t === "boolean" || t === "number" || t === "bigint" || t === "string") return [];
+
+  // --- symbol ---
+  if (t === "symbol") return [`${path}: Symbol values cannot be serialised over RPC`];
+
+  // --- function → CF converts to callback stub ---
+  if (t === "function") return [];
+
+  // --- object ---
+  if (t !== "object") return [`${path}: unsupported typeof "${t}"`];
+
+  const obj = value as object;
+
+  // cycle detection (structured clone handles cycles — just skip)
+  if (seen.has(obj)) return [];
+  seen.add(obj);
+
+  // --- explicitly disallowed ---
+  if (value instanceof Promise)          return [`${path}: Promise values cannot be sent as RPC arguments`];
+  if (value instanceof WeakMap)          return [`${path}: WeakMap cannot be serialised over RPC`];
+  if (value instanceof WeakSet)          return [`${path}: WeakSet cannot be serialised over RPC`];
+  if (value instanceof SharedArrayBuffer) return [`${path}: SharedArrayBuffer cannot be serialised over RPC`];
+  if (typeof Blob !== "undefined" && value instanceof Blob && !(typeof File !== "undefined" && value instanceof File)) {
+    return [`${path}: Blob cannot be serialised over RPC`];
+  }
+  if (typeof File !== "undefined" && value instanceof File) {
+    return [`${path}: File cannot be serialised over RPC`];
+  }
+
+  // --- allowed leaf types (no recursion needed) ---
+  if (value instanceof Date)        return [];
+  if (value instanceof RegExp)      return [];
+  if (value instanceof Error)       return [];
+  if (value instanceof ArrayBuffer) return [];
+  if (value instanceof DataView)    return [];
+
+  // TypedArray: ArrayBuffer.isView but not DataView
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) return [];
+
+  // --- streams & web API types (pass-through on CF) ---
+  if (typeof ReadableStream  !== "undefined" && value instanceof ReadableStream)  return [];
+  if (typeof WritableStream  !== "undefined" && value instanceof WritableStream)  return [];
+  if (typeof Request         !== "undefined" && value instanceof Request)         return [];
+  if (typeof Response        !== "undefined" && value instanceof Response)        return [];
+  if (typeof Headers         !== "undefined" && value instanceof Headers)         return [];
+
+  // --- Map ---
+  if (value instanceof Map) {
+    const errors: string[] = [];
+    let i = 0;
+    for (const [k, v] of value) {
+      errors.push(..._validate(k, `${path}.Map.key(${i})`, seen));
+      errors.push(..._validate(v, `${path}.Map.value(${i})`, seen));
+      i++;
+    }
+    return errors;
+  }
+
+  // --- Set ---
+  if (value instanceof Set) {
+    const errors: string[] = [];
+    let i = 0;
+    for (const v of value) {
+      errors.push(..._validate(v, `${path}.Set(${i})`, seen));
+      i++;
+    }
+    return errors;
+  }
+
+  // --- Array ---
+  if (Array.isArray(value)) {
+    const errors: string[] = [];
+    for (let i = 0; i < value.length; i++) {
+      errors.push(..._validate(value[i], `${path}[${i}]`, seen));
+    }
+    return errors;
+  }
+
+  // --- plain object ---
+  const proto = Object.getPrototypeOf(obj);
+  if (proto === Object.prototype || proto === null) {
+    const errors: string[] = [];
+    for (const key of Object.keys(obj)) {
+      errors.push(..._validate((obj as Record<string, unknown>)[key], `${path}.${key}`, seen));
+    }
+    return errors;
+  }
+
+  // --- RpcTarget instance: valid (becomes a stub on CF) ---
+  const brand = Symbol.for("bunflare.RpcTarget");
+  if ((obj as Record<symbol, unknown>)[brand] === true) return [];
+
+  // --- anything else: custom class instance ---
+  return [
+    `${path}: Custom class instance (${typeName(value)}) cannot be sent over RPC. ` +
+    `Extend RpcTarget or serialise manually.`,
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// Convenience wrappers called from binding proxies
+// ---------------------------------------------------------------------------
+
+export function warnInvalidRpcArgs(args: unknown[], methodName: string): void {
+  for (let i = 0; i < args.length; i++) {
+    const errors = validateRpcValue(args[i], `arg${i}`);
+    for (const msg of errors) {
+      console.warn(`[bunflare] RPC ${methodName}() argument warning: ${msg}`);
+    }
+  }
+}
+
+export function warnInvalidRpcReturn(value: unknown, methodName: string): void {
+  const errors = validateRpcValue(value, "return");
+  for (const msg of errors) {
+    console.warn(`[bunflare] RPC ${methodName}() return value warning: ${msg}`);
+  }
+}

package/runtime/tracing/context.ts

@@ -0,0 +1,40 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+/** Mutable ref shared across all spans in the same trace. Allows fetch()
+ *  call-site stacks captured in sub-spans to be visible in the root span's
+ *  error handler. */
+export interface FetchStackRef {
+  current: Error | null;
+}
+
+export interface SpanContext {
+  traceId: string;
+  spanId: string;
+  /** Shared ref to the last stack captured at an outbound fetch() call site.
+   *  Used to reconstruct async stack traces broken by .then() in third-party
+   *  libraries (e.g. GraphQL clients). The synchronous stack at the fetch()
+   *  call still contains the user's code frames — we stitch it onto caught
+   *  errors. */
+  fetchStack: FetchStackRef;
+}
+
+const storage = new AsyncLocalStorage<SpanContext>();
+
+export function getActiveContext(): SpanContext | undefined {
+  return storage.getStore();
+}
+
+export function runWithContext<T>(ctx: SpanContext, fn: () => T): T {
+  return storage.run(ctx, fn);
+}
+
+export function generateId(byteCount = 8): string {
+  const bytes = new Uint8Array(byteCount);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, b => b.toString(16).padStart(2, "0")).join("");
+}
+
+/** Generate a 128-bit trace ID (OTel standard: 16 bytes / 32 hex chars) */
+export function generateTraceId(): string {
+  return generateId(16);
+}

package/runtime/tracing/db.ts

@@ -0,0 +1,73 @@
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+const DATA_DIR = join(process.cwd(), ".bunflare");
+const DB_PATH = join(DATA_DIR, "traces.sqlite");
+
+let instance: Database | null = null;
+
+export function getTracingDatabase(): Database {
+  if (instance) return instance;
+
+  mkdirSync(DATA_DIR, { recursive: true });
+
+  instance = new Database(DB_PATH, { create: true });
+  instance.run("PRAGMA journal_mode=WAL");
+  runTracingMigrations(instance);
+  return instance;
+}
+
+export function runTracingMigrations(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS spans (
+      span_id TEXT PRIMARY KEY,
+      trace_id TEXT NOT NULL,
+      parent_span_id TEXT,
+      name TEXT NOT NULL,
+      kind TEXT NOT NULL DEFAULT 'internal',
+      status TEXT NOT NULL DEFAULT 'unset',
+      status_message TEXT,
+      start_time INTEGER NOT NULL,
+      end_time INTEGER,
+      duration_ms REAL,
+      attributes TEXT,
+      worker_name TEXT
+    )
+  `);
+  db.run("CREATE INDEX IF NOT EXISTS idx_spans_trace ON spans(trace_id)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_spans_start ON spans(start_time DESC)");
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS span_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      span_id TEXT NOT NULL,
+      trace_id TEXT NOT NULL,
+      timestamp INTEGER NOT NULL,
+      name TEXT NOT NULL,
+      level TEXT,
+      message TEXT,
+      attributes TEXT
+    )
+  `);
+  db.run("CREATE INDEX IF NOT EXISTS idx_events_span ON span_events(span_id)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_events_trace ON span_events(trace_id)");
+
+  db.run(`
+    CREATE TABLE IF NOT EXISTS errors (
+      id TEXT PRIMARY KEY,
+      timestamp INTEGER NOT NULL,
+      error_name TEXT NOT NULL,
+      error_message TEXT NOT NULL,
+      request_method TEXT,
+      request_url TEXT,
+      worker_name TEXT,
+      trace_id TEXT,
+      span_id TEXT,
+      source TEXT,
+      data TEXT NOT NULL
+    )
+  `);
+  db.run("CREATE INDEX IF NOT EXISTS idx_errors_timestamp ON errors(timestamp DESC)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_errors_trace ON errors(trace_id)");
+}

package/runtime/tracing/frames.ts

@@ -0,0 +1,75 @@
+import { readFileSync } from "node:fs";
+
+export interface StackFrame {
+  file: string;
+  line: number;
+  column: number;
+  function: string;
+  source?: string[];
+  sourceLine?: number;
+}
+
+const STACK_LINE_RE = /at\s+(?:(.+?)\s+\()?(.+):(\d+):(\d+)\)?/;
+
+export function parseStackFrames(stack: string): StackFrame[] {
+  const frames: StackFrame[] = [];
+  for (const line of stack.split("\n")) {
+    const match = line.match(STACK_LINE_RE);
+    if (!match) continue;
+    frames.push({
+      file: match[2]!,
+      line: parseInt(match[3]!, 10),
+      column: parseInt(match[4]!, 10),
+      function: match[1] ?? "(anonymous)",
+    });
+  }
+  return frames;
+}
+
+/** Async version — reads source files asynchronously. */
+export async function enrichFrameWithSourceAsync(frame: StackFrame): Promise<void> {
+  try {
+    const file = Bun.file(frame.file);
+    if (!await file.exists()) return;
+    const text = await file.text();
+    addSourceContext(frame, text);
+  } catch {
+    // File unreadable — skip source preview
+  }
+}
+
+/** Sync version — reads source files synchronously. Safe for use in catch blocks. */
+export function enrichFrameWithSource(frame: StackFrame): void {
+  try {
+    const text = readFileSync(frame.file, "utf-8");
+    addSourceContext(frame, text);
+  } catch {
+    // File unreadable — skip source preview
+  }
+}
+
+function addSourceContext(frame: StackFrame, text: string): void {
+  const lines = text.split("\n");
+  const contextRadius = 7;
+  const start = Math.max(0, frame.line - 1 - contextRadius);
+  const end = Math.min(lines.length, frame.line + contextRadius);
+  frame.source = lines.slice(start, end);
+  frame.sourceLine = frame.line - 1 - start;
+}
+
+/** Parse, filter, enrich, and strip cwd from frames. Synchronous. */
+export function buildErrorFrames(stack: string): StackFrame[] {
+  const frames = parseStackFrames(stack)
+    .filter(f => !f.file.startsWith("native:") && !f.file.startsWith("node:"));
+
+  const framesToEnrich = frames.slice(0, 20);
+  for (const frame of framesToEnrich) {
+    enrichFrameWithSource(frame);
+  }
+
+  const cwdPrefix = process.cwd() + "/";
+  return framesToEnrich.filter(f => f.source).map(f => ({
+    ...f,
+    file: f.file.startsWith(cwdPrefix) ? f.file.slice(cwdPrefix.length) : f.file,
+  }));
+}

package/runtime/tracing/instrument.ts

@@ -0,0 +1,186 @@
+import { startSpan } from "./span";
+import type { SpanData } from "./types";
+
+/** Append caller frames to an error stack when Bun/JSC loses async context (ALS.run, .then). */
+function stitchAsyncStack(err: Error, callerError: Error): void {
+  if (!err.stack || !callerError.stack) return;
+  if (err.stack.includes("--- async ---")) return;
+
+  const errFrames = err.stack.split("\n").filter(l => l.trim().startsWith("at "));
+  if (errFrames.length > 5 && !err.stack.includes("processTicksAndRejections")) return;
+
+  const callerLines = callerError.stack.split("\n").slice(1);
+  const filtered = callerLines.filter(l => !l.includes("/bunflare/runtime/"));
+  if (filtered.length === 0) return;
+
+  err.stack += "\n    --- async ---\n" + filtered.join("\n");
+}
+
+interface InstrumentConfig {
+  type: string;
+  name: string;
+  methods: string[];
+  kind?: SpanData["kind"];
+}
+
+function wrapMethod(target: Function, type: string, bindingName: string, method: string, kind: SpanData["kind"]): Function {
+  return wrapMethodWithExtraAttrs(target, type, bindingName, method, kind, {});
+}
+
+function wrapMethodWithExtraAttrs(target: Function, type: string, bindingName: string, method: string, kind: SpanData["kind"], extraAttrs: Record<string, unknown>): Function {
+  return function (this: unknown, ...args: unknown[]) {
+    const attrs: Record<string, unknown> = {
+      "binding.type": type,
+      "binding.name": bindingName,
+      ...extraAttrs,
+    };
+    if (args.length > 0 && typeof args[0] === "string") {
+      attrs["binding.key"] = args[0];
+    }
+    return startSpan(
+      { name: `${type}.${method}`, kind, attributes: attrs },
+      () => target.apply(this, args),
+    );
+  };
+}
+
+export function instrumentBinding<T extends object>(binding: T, config: InstrumentConfig): T {
+  const kind = config.kind ?? "client";
+  const methodSet = new Set(config.methods);
+
+  return new Proxy(binding, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (typeof prop === "string" && methodSet.has(prop) && typeof value === "function") {
+        return wrapMethod(value, config.type, config.name, prop, kind);
+      }
+      return value;
+    },
+  });
+}
+
+/**
+ * Wrap D1 database: instrument statement execution methods (first, all, run, raw),
+ * not prepare() itself.
+ */
+export function instrumentD1<T extends object>(binding: T, name: string): T {
+  return new Proxy(binding, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (prop === "prepare" && typeof value === "function") {
+        return function (this: unknown, ...args: unknown[]) {
+          const stmt = value.apply(obj, args);
+          if (typeof stmt !== "object" || stmt === null) return stmt;
+          const sql = typeof args[0] === "string" ? args[0] : undefined;
+          return wrapD1Stmt(stmt, name, sql);
+        };
+      }
+      // Also instrument batch and exec directly
+      if ((prop === "batch" || prop === "exec" || prop === "dump") && typeof value === "function") {
+        return wrapMethod(value, "d1", name, prop as string, "client");
+      }
+      // withSession() returns a new database-like object — wrap it with the same instrumentation
+      if (prop === "withSession" && typeof value === "function") {
+        return function (this: unknown, ...args: unknown[]) {
+          const session = value.apply(obj, args);
+          if (typeof session === "object" && session !== null) {
+            return instrumentD1(session, name);
+          }
+          return session;
+        };
+      }
+      return value;
+    },
+  });
+}
+
+function wrapD1Stmt(stmt: object, name: string, sql: string | undefined): object {
+  const stmtMethods = ["first", "all", "run", "raw"];
+  return new Proxy(stmt, {
+    get(s, sProp, sReceiver) {
+      const sValue = Reflect.get(s, sProp, sReceiver);
+      if (typeof sProp === "string" && stmtMethods.includes(sProp) && typeof sValue === "function") {
+        return wrapMethodWithExtraAttrs(sValue.bind(s), "d1", name, sProp, "client", sql ? { "db.statement": sql } : {});
+      }
+      // bind() returns a new statement — re-wrap it so execution methods stay instrumented
+      if (sProp === "bind" && typeof sValue === "function") {
+        return function (this: unknown, ...args: unknown[]) {
+          const bound = sValue.apply(s, args);
+          if (typeof bound === "object" && bound !== null) {
+            return wrapD1Stmt(bound, name, sql);
+          }
+          return bound;
+        };
+      }
+      return sValue;
+    },
+  });
+}
+
+/**
+ * Wrap DO namespace: get() returns a wrapped stub where fetch() and RPC methods are traced.
+ */
+export function instrumentDONamespace<T extends object>(namespace: T, className: string): T {
+  return new Proxy(namespace, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (prop === "get" && typeof value === "function") {
+        return function (this: unknown, ...args: unknown[]) {
+          const stub = value.apply(obj, args);
+          if (typeof stub !== "object" || stub === null) return stub;
+          return instrumentDOStub(stub, className);
+        };
+      }
+      return value;
+    },
+  });
+}
+
+function instrumentDOStub<T extends object>(stub: T, className: string): T {
+  return new Proxy(stub, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (typeof prop === "symbol") return value;
+      // Skip internal/promise props
+      if (["then", "catch", "finally", "toJSON", "valueOf", "toString"].includes(prop)) return value;
+      if (typeof value === "function") {
+        // bind(obj) ensures correct `this` when the actual method is called;
+        // the wrapper's own `this` (from Proxy get trap) is intentionally ignored.
+        const wrapped = wrapMethod(value.bind(obj), "do", className, prop, "client");
+        // Capture caller stack at access site (before ALS.run destroys it)
+        // and stitch onto errors so the full call chain is visible.
+        return async function (this: unknown, ...args: unknown[]) {
+          const callerStack = new Error();
+          try {
+            return await (wrapped as Function).apply(this, args);
+          } catch (err) {
+            if (err instanceof Error) stitchAsyncStack(err, callerStack);
+            throw err;
+          }
+        };
+      }
+      return value;
+    },
+  });
+}
+
+/**
+ * Wrap service binding: instrument fetch() and RPC methods.
+ */
+export function instrumentServiceBinding<T extends object>(binding: T, serviceName: string): T {
+  const internalProps = new Set(["_wire", "isWired", "_subrequestCount"]);
+
+  return new Proxy(binding, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (typeof prop === "symbol") return value;
+      if (internalProps.has(prop)) return value;
+      if (["then", "catch", "finally", "toJSON", "valueOf", "toString", "connect"].includes(prop)) return value;
+      if (typeof value === "function") {
+        const method = prop === "fetch" ? "fetch" : prop;
+        return wrapMethod(value, "service", serviceName, method, "client");
+      }
+      return value;
+    },
+  });
+}

package/runtime/tracing/span.ts

@@ -0,0 +1,138 @@
+import { getActiveContext, runWithContext, generateId, generateTraceId } from "./context";
+import { getTraceStore } from "./store";
+import type { SpanData } from "./types";
+import { buildErrorFrames } from "./frames";
+
+export interface SpanOptions {
+  name: string;
+  kind?: SpanData["kind"];
+  attributes?: Record<string, unknown>;
+  workerName?: string;
+  /** Force a new root trace, ignoring any active parent context. */
+  newTrace?: boolean;
+}
+
+export async function startSpan<T>(opts: SpanOptions, fn: () => T | Promise<T>): Promise<T> {
+  const store = getTraceStore();
+  const parent = opts.newTrace ? undefined : getActiveContext();
+
+  const spanId = generateId();
+  const traceId = parent?.traceId ?? generateTraceId();
+  const parentSpanId = parent?.spanId ?? null;
+
+  const span: SpanData = {
+    spanId,
+    traceId,
+    parentSpanId,
+    name: opts.name,
+    kind: opts.kind ?? "internal",
+    status: "unset",
+    statusMessage: null,
+    startTime: Date.now(),
+    endTime: null,
+    durationMs: null,
+    attributes: opts.attributes ?? {},
+    workerName: opts.workerName ?? null,
+  };
+
+  store.insertSpan(span);
+
+  // Share fetchStack ref across all spans in the same trace so that
+  // fetch call-site stacks captured in sub-spans are visible in the root
+  // span's error handler.
+  const fetchStack = parent?.fetchStack ?? { current: null };
+
+  try {
+    const result = await runWithContext({ traceId, spanId, fetchStack }, () => fn());
+    if (result instanceof Response && result.status >= 500) {
+      store.setSpanStatus(spanId, "error", `HTTP ${result.status}`);
+    }
+    const currentStatus = store.getSpanStatus(spanId);
+    store.endSpan(spanId, Date.now(), currentStatus === "error" ? "error" : "ok");
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    store.endSpan(spanId, Date.now(), "error", message);
+    store.addEvent({
+      spanId,
+      traceId,
+      timestamp: Date.now(),
+      name: "exception",
+      level: "error",
+      message,
+      attributes: err instanceof Error ? { stack: err.stack } : {},
+    });
+    throw err;
+  }
+}
+
+export function setSpanStatus(status: "ok" | "error", message?: string): void {
+  const ctx = getActiveContext();
+  if (!ctx) return;
+  const store = getTraceStore();
+  store.setSpanStatus(ctx.spanId, status, message ?? null);
+}
+
+export function setSpanAttribute(key: string, value: unknown): void {
+  const ctx = getActiveContext();
+  if (!ctx) return;
+  const store = getTraceStore();
+  store.updateAttributes(ctx.spanId, { [key]: value });
+}
+
+export function addSpanEvent(name: string, level: string, message: string, attrs?: Record<string, unknown>): void {
+  const ctx = getActiveContext();
+  if (!ctx) return;
+  const store = getTraceStore();
+  store.addEvent({
+    spanId: ctx.spanId,
+    traceId: ctx.traceId,
+    timestamp: Date.now(),
+    name,
+    level,
+    message,
+    attributes: attrs ?? {},
+  });
+}
+
+/** Persist an error to the errors table, linking it to the current trace/span context.
+ *  Optional traceId/spanId override ALS context (needed when ALS scope is lost, e.g. after startSpan returns in Bun). */
+export function persistError(error: unknown, source: string, workerName?: string, traceId?: string, spanId?: string): string | null {
+  try {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const ctx = getActiveContext();
+    const store = getTraceStore();
+    const id = crypto.randomUUID();
+    store.insertError({
+      id,
+      timestamp: Date.now(),
+      errorName: err.name,
+      errorMessage: err.message,
+      workerName: workerName ?? null,
+      traceId: traceId ?? ctx?.traceId ?? null,
+      spanId: spanId ?? ctx?.spanId ?? null,
+      source,
+      data: JSON.stringify({
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack ?? String(error),
+          frames: buildErrorFrames(err.stack ?? ""),
+        },
+        request: { method: "", url: "", headers: {} },
+        env: {},
+        bindings: [],
+        runtime: {
+          bunVersion: Bun.version,
+          platform: process.platform,
+          arch: process.arch,
+          workerName,
+        },
+      }),
+    });
+    return id;
+  } catch {
+    // Never let error persistence break the caller
+    return null;
+  }
+}