brass-runtime 1.16.0 → 1.17.0

package/dist/{chunk-XDZOO4L5.js → chunk-EJ6BPYVR.mjs}

@@ -1,6 +1,9 @@
 import {
   makeBoundedRingBuffer
-} from "./chunk-7LVI2GIN.js";
+} from "./chunk-GYM3LLGS.mjs";
+import {
+  Cause
+} from "./chunk-36I3M4UC.mjs";
 
 // src/core/runtime/metrics.ts
 var DEFAULT_BOUNDARIES = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 5e3, 1e4];
@@ -212,6 +215,10 @@ var InMemoryTracer = class {
   options;
   spans = /* @__PURE__ */ new Map();
   // key: spanId
+  finishedSpanIds = [];
+  finishedSpanSet = /* @__PURE__ */ new Set();
+  finishedSpanOffset = 0;
+  finishedSpanCount = 0;
   prunedFinishedSpans = 0;
   emit(ev, ctx) {
     if (ctx.sampled === false) return;
@@ -237,8 +244,10 @@ var InMemoryTracer = class {
       if (!spanId) return;
       const sp = this.spans.get(spanId);
       if (sp) {
+        const wasOpen = sp.endWallTs == null;
         sp.endWallTs = wallTs;
         sp.events.push({ wallTs, name: "fiber.end", attrs: this.attrs({ status: ev.status, error: this.error(ev.error) }) });
+        if (wasOpen) this.markFinished(spanId);
         this.pruneFinished();
       }
       return;
@@ -269,13 +278,15 @@ var InMemoryTracer = class {
       if (!spanId) return;
       const sp = this.spans.get(spanId);
       if (sp) {
+        const wasOpen = sp.endWallTs == null;
         sp.endWallTs = wallTs;
         sp.events.push({ wallTs, name: "span.end", attrs: this.attrs({ status: ev.status, error: this.error(ev.error), ...ev.attributes ?? {} }) });
+        if (wasOpen) this.markFinished(spanId);
         this.pruneFinished();
       }
       return;
     }
-    if (ev.type === "fiber.suspend" || ev.type === "fiber.resume" || ev.type === "scope.open" || ev.type === "scope.close") {
+    if (ev.type === "fiber.suspend" || ev.type === "fiber.resume" || ev.type === "scope.open" || ev.type === "scope.close" || ev.type === "schedule.decision") {
       if (!spanId) return;
       const sp = this.spans.get(spanId);
       if (!sp) return;
@@ -284,15 +295,20 @@ var InMemoryTracer = class {
   }
   exportFinished() {
     this.pruneFinished();
-    return Array.from(this.spans.values()).filter((s) => s.endWallTs != null);
+    const out = [];
+    for (let i = this.finishedSpanOffset; i < this.finishedSpanIds.length; i++) {
+      const spanId = this.finishedSpanIds[i];
+      if (!this.finishedSpanSet.has(spanId)) continue;
+      const span = this.spans.get(spanId);
+      if (span?.endWallTs != null) out.push(span);
+    }
+    return out;
   }
   pruneFinished(spanIds) {
     let dropped = 0;
     if (spanIds) {
       for (const spanId of spanIds) {
-        const span = this.spans.get(spanId);
-        if (span?.endWallTs == null) continue;
-        if (this.spans.delete(spanId)) dropped++;
+        if (this.deleteFinished(spanId)) dropped++;
       }
       this.prunedFinishedSpans += dropped;
       return dropped;
@@ -305,7 +321,7 @@ var InMemoryTracer = class {
   stats() {
     return {
       storedSpans: this.spans.size,
-      finishedSpans: Array.from(this.spans.values()).filter((s) => s.endWallTs != null).length,
+      finishedSpans: this.finishedSpanCount,
       prunedFinishedSpans: this.prunedFinishedSpans
     };
   }
@@ -313,7 +329,8 @@ var InMemoryTracer = class {
     return this.options.sanitizeAttributes?.(attrs) ?? attrs;
   }
   error(error) {
-    return error === void 0 ? void 0 : this.options.sanitizeError?.(error) ?? error;
+    const normalized = Cause.isCause(error) ? Cause.pretty(error, { singleLine: true }) : error;
+    return normalized === void 0 ? void 0 : this.options.sanitizeError?.(normalized) ?? normalized;
   }
   now() {
     return this.options.clock?.() ?? Date.now();
@@ -323,25 +340,70 @@ var InMemoryTracer = class {
     if (maxAgeMs === void 0 || maxAgeMs <= 0) return 0;
     const now = this.now();
     let dropped = 0;
-    for (const [spanId, span] of this.spans) {
-      if (span.endWallTs == null) continue;
-      if (now - span.endWallTs > maxAgeMs && this.spans.delete(spanId)) dropped++;
+    while (true) {
+      const oldest = this.peekOldestFinished();
+      if (!oldest) break;
+      if (now - (oldest.span.endWallTs ?? now) <= maxAgeMs) break;
+      if (this.deleteOldestFinished()) dropped++;
     }
     return dropped;
   }
   pruneFinishedOverLimit() {
     const maxFinishedSpans = this.options.maxFinishedSpans;
     if (maxFinishedSpans === void 0 || maxFinishedSpans < 0) return 0;
-    const finished = Array.from(this.spans.values()).filter((span) => span.endWallTs != null).sort((a, b) => (a.endWallTs ?? 0) - (b.endWallTs ?? 0));
-    const overflow = finished.length - maxFinishedSpans;
-    if (overflow <= 0) return 0;
     let dropped = 0;
-    for (let i = 0; i < overflow; i++) {
-      const span = finished[i];
-      if (this.spans.delete(span.spanId)) dropped++;
+    while (this.finishedSpanCount > maxFinishedSpans) {
+      if (this.deleteOldestFinished()) dropped++;
+      else break;
     }
     return dropped;
   }
+  markFinished(spanId) {
+    if (this.finishedSpanSet.has(spanId)) return;
+    this.finishedSpanSet.add(spanId);
+    this.finishedSpanIds.push(spanId);
+    this.finishedSpanCount++;
+    this.compactFinishedIds();
+  }
+  deleteFinished(spanId) {
+    const span = this.spans.get(spanId);
+    if (span?.endWallTs == null) return false;
+    const deleted = this.spans.delete(spanId);
+    if (this.finishedSpanSet.delete(spanId)) {
+      this.finishedSpanCount = Math.max(0, this.finishedSpanCount - 1);
+    }
+    return deleted;
+  }
+  peekOldestFinished() {
+    while (this.finishedSpanOffset < this.finishedSpanIds.length) {
+      const spanId = this.finishedSpanIds[this.finishedSpanOffset];
+      if (!this.finishedSpanSet.has(spanId)) {
+        this.finishedSpanOffset++;
+        continue;
+      }
+      const span = this.spans.get(spanId);
+      if (!span || span.endWallTs == null) {
+        this.finishedSpanSet.delete(spanId);
+        this.finishedSpanCount = Math.max(0, this.finishedSpanCount - 1);
+        this.finishedSpanOffset++;
+        continue;
+      }
+      return { spanId, span };
+    }
+    this.compactFinishedIds();
+    return void 0;
+  }
+  deleteOldestFinished() {
+    const oldest = this.peekOldestFinished();
+    if (!oldest) return false;
+    this.finishedSpanOffset++;
+    return this.deleteFinished(oldest.spanId);
+  }
+  compactFinishedIds() {
+    if (this.finishedSpanOffset < 1024 || this.finishedSpanOffset * 2 < this.finishedSpanIds.length) return;
+    this.finishedSpanIds.splice(0, this.finishedSpanOffset);
+    this.finishedSpanOffset = 0;
+  }
 };
 
 export {

package/dist/chunk-EOC4UHBS.mjs

@@ -0,0 +1,229 @@
+import {
+  makeRuntimeEventRecord
+} from "./chunk-EJ6BPYVR.mjs";
+import {
+  emptyContext,
+  getCurrentFiber
+} from "./chunk-GYM3LLGS.mjs";
+import {
+  Cause,
+  asyncFlatMap,
+  asyncSync
+} from "./chunk-36I3M4UC.mjs";
+
+// src/core/runtime/fiberRef.ts
+var nextFiberRefId = 1;
+function makeFiberRef(initial) {
+  const ref = {
+    id: nextFiberRefId++,
+    initial,
+    get: () => getFiberRef(ref),
+    set: (value) => setFiberRef(ref, value),
+    update: (f) => updateFiberRef(ref, f),
+    modify: (f) => modifyFiberRef(ref, f),
+    locally: (value, effect) => locallyFiberRef(ref, value, effect),
+    locallyWith: (f, effect) => locallyFiberRefWith(ref, f, effect),
+    unsafeGet: () => unsafeGetFiberRef(ref),
+    unsafeSet: (value) => unsafeSetFiberRef(ref, value)
+  };
+  return ref;
+}
+function getFiberRef(ref) {
+  return asyncSync(() => unsafeGetFiberRef(ref));
+}
+function setFiberRef(ref, value) {
+  return asyncSync(() => {
+    unsafeSetFiberRef(ref, value);
+  });
+}
+function updateFiberRef(ref, f) {
+  return asyncSync(() => {
+    const next = f(unsafeGetFiberRef(ref));
+    unsafeSetFiberRef(ref, next);
+    return next;
+  });
+}
+function modifyFiberRef(ref, f) {
+  return asyncSync(() => {
+    const [result, next] = f(unsafeGetFiberRef(ref));
+    unsafeSetFiberRef(ref, next);
+    return result;
+  });
+}
+function locallyFiberRef(ref, value, effect) {
+  return {
+    _tag: "FiberRefLocally",
+    refId: ref.id,
+    value,
+    effect
+  };
+}
+function locallyFiberRefWith(ref, f, effect) {
+  return asyncFlatMap(getFiberRef(ref), (value) => locallyFiberRef(ref, f(value), effect));
+}
+function unsafeGetFiberRef(ref) {
+  const refs = currentFiberRefs(false);
+  return refs?.has(ref.id) ? refs.get(ref.id) : ref.initial;
+}
+function unsafeSetFiberRef(ref, value) {
+  const refs = currentFiberRefs(true);
+  refs?.set(ref.id, value);
+}
+function fiberRefSnapshot() {
+  return new Map(currentFiberRefs(false));
+}
+function currentFiberRefs(create) {
+  const fiber = getCurrentFiber();
+  if (!fiber) return void 0;
+  fiber.fiberContext ??= { log: emptyContext, trace: null };
+  if (!fiber.fiberContext.fiberRefs && create) fiber.fiberContext.fiberRefs = /* @__PURE__ */ new Map();
+  return fiber.fiberContext.fiberRefs;
+}
+
+// src/core/runtime/recorder.ts
+function makeRuntimeRecorder(options = {}) {
+  const capacity = Math.max(1, Math.floor(options.maxEvents ?? 2048));
+  const records = new Array(capacity);
+  let next = 0;
+  let size = 0;
+  let dropped = 0;
+  let seq = 1;
+  const snapshot = () => {
+    const out = [];
+    const start = size === capacity ? next : 0;
+    for (let i = 0; i < size; i++) {
+      const record = records[(start + i) % capacity];
+      if (record) out.push(record);
+    }
+    return out;
+  };
+  const emit = (ev, ctx) => {
+    records[next] = makeRuntimeEventRecord(ev, ctx, seq++);
+    next = (next + 1) % capacity;
+    if (size < capacity) size++;
+    else dropped++;
+  };
+  const clear = () => {
+    records.fill(void 0);
+    next = 0;
+    size = 0;
+    dropped = 0;
+  };
+  const stats = () => {
+    const current = snapshot();
+    return {
+      size,
+      capacity,
+      dropped,
+      ...current[0] ? { firstSeq: current[0].seq } : {},
+      ...current[current.length - 1] ? { lastSeq: current[current.length - 1].seq } : {}
+    };
+  };
+  const recorder = {
+    emit,
+    snapshot,
+    clear,
+    stats,
+    explain: (explainOptions = {}) => explainRuntimeEvents(snapshot(), dropped, explainOptions)
+  };
+  return Object.assign(recorder, { hooks: recorder });
+}
+function explainRuntimeEvents(events, dropped, options) {
+  const maxEvents = Math.max(1, Math.floor(options.maxEvents ?? 80));
+  const slice = events.length > maxEvents ? events.slice(events.length - maxEvents) : events;
+  const fiberStarts = /* @__PURE__ */ new Map();
+  const fiberSuspends = /* @__PURE__ */ new Map();
+  const lines = [`Runtime flight recorder: ${events.length} event${events.length === 1 ? "" : "s"}${dropped > 0 ? `, ${dropped} dropped` : ""}.`];
+  for (const event of slice) {
+    switch (event.type) {
+      case "fiber.start": {
+        fiberStarts.set(event.fiberId, event);
+        lines.push(`fiber#${event.fiberId} started${event.name ? ` "${event.name}"` : ""}${event.parentFiberId !== void 0 ? ` parent=fiber#${event.parentFiberId}` : ""}`);
+        break;
+      }
+      case "fiber.suspend": {
+        fiberSuspends.set(event.fiberId, event);
+        lines.push(`fiber#${event.fiberId} suspended awaiting ${event.reason ?? "unknown"}`);
+        break;
+      }
+      case "fiber.resume": {
+        const suspended = fiberSuspends.get(event.fiberId);
+        fiberSuspends.delete(event.fiberId);
+        lines.push(`fiber#${event.fiberId} resumed${suspended ? ` after ${durationMs(suspended, event)} awaiting ${fiberSuspendReason(suspended)}` : ""}`);
+        break;
+      }
+      case "fiber.end": {
+        const started = fiberStarts.get(event.fiberId);
+        const suspended = fiberSuspends.get(event.fiberId);
+        fiberSuspends.delete(event.fiberId);
+        lines.push(`fiber#${event.fiberId} ended ${event.status}${started ? ` after ${durationMs(started, event)}` : ""}${suspended ? ` while awaiting ${fiberSuspendReason(suspended)}` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      }
+      case "scope.open":
+        lines.push(`scope#${event.scopeId} opened${event.parentScopeId !== void 0 ? ` parent=scope#${event.parentScopeId}` : ""}`);
+        break;
+      case "scope.close":
+        lines.push(`scope#${event.scopeId} closed ${event.status}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      case "supervisor.child.restart":
+        lines.push(`supervisor#${event.supervisorId} restarting child#${event.childId} attempt=${event.restartCount} delay=${event.delayMs}ms${event.reason ? ` reason=${event.reason}` : ""}`);
+        break;
+      case "supervisor.child.escalate":
+        lines.push(`supervisor#${event.supervisorId} escalated child#${event.childId}${event.reason ? ` reason=${event.reason}` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      case "schedule.decision":
+        lines.push(`schedule${event.name ? ` "${event.name}"` : ""} attempt=${event.attempt} ${event.continue ? "continues" : "stops"} delay=${event.delayMs}ms elapsed=${Math.round(event.elapsedMs)}ms${event.reason ? ` reason=${event.reason}` : ""}`);
+        break;
+      case "log":
+        if (event.level === "warn" || event.level === "error") {
+          lines.push(`${event.level}: ${event.message ?? ""}${event.fields ? ` ${JSON.stringify(event.fields)}` : ""}`);
+        }
+        break;
+      case "span.start":
+        lines.push(`span started "${event.name}"${event.traceId ? ` trace=${event.traceId}` : ""}`);
+        break;
+      case "span.end":
+        lines.push(`span ended ${event.status}${event.name ? ` "${event.name}"` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      default:
+        break;
+    }
+  }
+  for (const suspended of fiberSuspends.values()) {
+    lines.push(`fiber#${suspended.fiberId} still suspended for ${durationFromNowMs(suspended)} awaiting ${fiberSuspendReason(suspended)}`);
+  }
+  return lines.join("\n");
+}
+function durationMs(start, end) {
+  return `${Math.max(0, Math.round(end.wallTs - start.wallTs))}ms`;
+}
+function durationFromNowMs(start) {
+  return `${Math.max(0, Math.round(Date.now() - start.wallTs))}ms`;
+}
+function formatUnknown(value) {
+  if (Cause.isCause(value)) return Cause.pretty(value, { singleLine: true });
+  if (value instanceof Error) return value.message;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function fiberSuspendReason(record) {
+  return record.type === "fiber.suspend" ? record.reason ?? "unknown" : "unknown";
+}
+
+export {
+  makeFiberRef,
+  getFiberRef,
+  setFiberRef,
+  updateFiberRef,
+  modifyFiberRef,
+  locallyFiberRef,
+  locallyFiberRefWith,
+  unsafeGetFiberRef,
+  unsafeSetFiberRef,
+  fiberRefSnapshot,
+  makeRuntimeRecorder
+};