brass-runtime 1.16.0 → 1.17.0

package/dist/{chunk-VFIUZG7J.mjs → chunk-RKGKFN2A.js}

@@ -1,6 +1,9 @@
 import {
   makeBoundedRingBuffer
-} from "./chunk-G6IQOE4P.mjs";
+} from "./chunk-FH2X7BVP.js";
+import {
+  Cause
+} from "./chunk-UB4B6OFY.js";
 
 // 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-NYL4D7SK.cjs → chunk-SA6HUJVI.cjs}

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkDJQ7OMMBcjs = require('./chunk-DJQ7OMMB.cjs');
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
 
 // src/core/stream/structuredConcurrency.ts
 function race(left, right, parentScope) {
-  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (env, cb) => {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
     const scope = parentScope.subScope();
     let done = false;
     const onResult = (exit) => {
@@ -20,7 +20,7 @@ function race(left, right, parentScope) {
   });
 }
 function zipPar(left, right, parentScope) {
-  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (env, cb) => {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
     const scope = parentScope.subScope();
     let leftExit = null;
     let rightExit = null;
@@ -64,7 +64,7 @@ function zipPar(left, right, parentScope) {
   });
 }
 function collectAllPar(effects, parentScope) {
-  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (env, cb) => {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
     const scope = parentScope.subScope();
     const results = new Array(effects.length);
     let completed = 0;
@@ -99,7 +99,7 @@ function collectAllPar(effects, parentScope) {
   });
 }
 function raceWith(left, right, parentScope, onLeft, onRight) {
-  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (env, cb) => {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
     const scope = parentScope.subScope();
     let done = false;
     const fiberLeft = scope.fork(left);