brass-runtime 1.15.0 → 1.16.1

package/dist/chunk-RKGKFN2A.js

@@ -0,0 +1,416 @@
+import {
+  makeBoundedRingBuffer
+} 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];
+function makeMetrics() {
+  const counters = /* @__PURE__ */ new Map();
+  const gauges = /* @__PURE__ */ new Map();
+  const histograms = /* @__PURE__ */ new Map();
+  const key = (name, labels) => labels ? `${name}|${Object.entries(labels).sort().map(([k, v]) => `${k}=${v}`).join(",")}` : name;
+  const counter = (name, labels = {}) => {
+    const k = key(name, labels);
+    if (!counters.has(k)) counters.set(k, { labels, value: 0 });
+    const entry = counters.get(k);
+    return {
+      increment: (n = 1) => {
+        entry.value += Math.max(0, n);
+      },
+      value: () => entry.value
+    };
+  };
+  const gauge = (name, labels = {}) => {
+    const k = key(name, labels);
+    if (!gauges.has(k)) gauges.set(k, { labels, value: 0 });
+    const entry = gauges.get(k);
+    return {
+      set: (v) => {
+        entry.value = v;
+      },
+      increment: (n = 1) => {
+        entry.value += n;
+      },
+      decrement: (n = 1) => {
+        entry.value -= n;
+      },
+      value: () => entry.value
+    };
+  };
+  const histogram = (name, boundaries = DEFAULT_BOUNDARIES, labels = {}) => {
+    const k = key(name, labels);
+    if (!histograms.has(k)) {
+      const sorted = [...boundaries].sort((a, b) => a - b);
+      histograms.set(k, {
+        labels,
+        boundaries: sorted,
+        data: { boundaries: sorted, counts: new Array(sorted.length + 1).fill(0), sum: 0, count: 0, min: Infinity, max: -Infinity }
+      });
+    }
+    const entry = histograms.get(k);
+    return {
+      observe: (value, exemplar) => {
+        entry.data.sum += value;
+        entry.data.count++;
+        entry.data.min = Math.min(entry.data.min, value);
+        entry.data.max = Math.max(entry.data.max, value);
+        let placed = false;
+        let bucketIndex = entry.boundaries.length;
+        for (let i = 0; i < entry.boundaries.length; i++) {
+          if (value <= entry.boundaries[i]) {
+            entry.data.counts[i]++;
+            bucketIndex = i;
+            placed = true;
+            break;
+          }
+        }
+        if (!placed) entry.data.counts[entry.boundaries.length]++;
+        if (exemplar) {
+          const exemplars = entry.data.exemplars ?? new Array(entry.boundaries.length + 1).fill(void 0);
+          exemplars[bucketIndex] = {
+            ...exemplar,
+            value,
+            timestamp: exemplar.timestamp
+          };
+          entry.data.exemplars = exemplars;
+        }
+      },
+      buckets: () => ({ ...entry.data, counts: [...entry.data.counts], exemplars: entry.data.exemplars ? [...entry.data.exemplars] : void 0 }),
+      percentile: (p) => {
+        const target = Math.ceil(entry.data.count * (p / 100));
+        let cumulative = 0;
+        for (let i = 0; i < entry.boundaries.length; i++) {
+          cumulative += entry.data.counts[i];
+          if (cumulative >= target) return entry.boundaries[i];
+        }
+        return entry.data.max;
+      }
+    };
+  };
+  return {
+    counter,
+    gauge,
+    histogram,
+    snapshot: () => ({
+      counters: Array.from(counters.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
+      gauges: Array.from(gauges.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
+      histograms: Array.from(histograms.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, buckets: v.data }))
+    }),
+    reset: () => {
+      counters.clear();
+      gauges.clear();
+      histograms.clear();
+    }
+  };
+}
+
+// src/core/runtime/events.ts
+function makeRuntimeEventRecord(ev, ctx, seq) {
+  const wallTs = Date.now();
+  const ts = typeof performance !== "undefined" ? performance.now() : wallTs;
+  return {
+    ...ctx,
+    contextFiberId: ctx.fiberId,
+    contextScopeId: ctx.scopeId,
+    ...ev,
+    seq,
+    wallTs,
+    ts
+  };
+}
+function runtimeEventRecordContext(record) {
+  return {
+    fiberId: record.contextFiberId ?? record.fiberId,
+    scopeId: record.contextScopeId ?? record.scopeId,
+    traceId: record.traceId,
+    spanId: record.spanId,
+    parentSpanId: record.parentSpanId,
+    traceState: record.traceState,
+    baggage: record.baggage,
+    sampled: record.sampled
+  };
+}
+
+// src/core/runtime/eventBus.ts
+function runtimeHooksToEventHandler(hooks) {
+  return (record) => {
+    hooks.emit(record, runtimeEventRecordContext(record));
+  };
+}
+var EventBus = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  seq = 1;
+  subs = [];
+  flushScheduled = false;
+  boundFlush = () => this.flush();
+  emit(ev, ctx) {
+    if (this.subs.length === 0) return;
+    const full = makeRuntimeEventRecord(ev, ctx, this.seq++);
+    for (const s of this.subs) {
+      const st = s.q.push(full);
+      if (st & 2 /* Dropped */) s.dropped++;
+    }
+    if (!this.flushScheduled) {
+      this.flushScheduled = true;
+      queueMicrotask(this.boundFlush);
+    }
+  }
+  subscribe(handler, perSubscriberCapacity = 2048) {
+    this.subs.push({
+      handler,
+      q: makeBoundedRingBuffer(perSubscriberCapacity, perSubscriberCapacity, this.options),
+      dropped: 0
+    });
+    return () => {
+      this.subs = this.subs.filter((s) => s.handler !== handler);
+    };
+  }
+  subscribeHooks(hooks, perSubscriberCapacity = 2048) {
+    return this.subscribe(runtimeHooksToEventHandler(hooks), perSubscriberCapacity);
+  }
+  flush(budget = 4096) {
+    this.flushScheduled = false;
+    for (const s of this.subs) {
+      let n = 0;
+      if (s.dropped > 0) {
+        const dropEv = makeRuntimeEventRecord(
+          {
+            type: "log",
+            level: "warn",
+            message: "eventbus.dropped",
+            fields: { dropped: s.dropped }
+          },
+          {},
+          0
+        );
+        try {
+          s.handler(dropEv);
+        } catch {
+        }
+        s.dropped = 0;
+      }
+      while (n++ < budget) {
+        const ev = s.q.shift();
+        if (!ev) break;
+        try {
+          s.handler(ev);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/core/runtime/tracingSink.ts
+var InMemoryTracer = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  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;
+    const wallTs = this.now();
+    const traceId = ctx.traceId ?? "no-trace";
+    const spanId = ctx.spanId;
+    if (ev.type === "fiber.start") {
+      if (!spanId) return;
+      this.spans.set(spanId, {
+        traceId,
+        spanId,
+        parentSpanId: ctx.parentSpanId,
+        traceState: ctx.traceState,
+        name: ev.name ?? `fiber#${ev.fiberId}`,
+        startWallTs: wallTs,
+        attrs: this.attrs({ fiberId: ev.fiberId, parentFiberId: ev.parentFiberId, scopeId: ev.scopeId }),
+        links: [],
+        events: []
+      });
+      return;
+    }
+    if (ev.type === "fiber.end") {
+      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;
+    }
+    if (ev.type === "span.start") {
+      if (!spanId) return;
+      this.spans.set(spanId, {
+        traceId,
+        spanId,
+        parentSpanId: ctx.parentSpanId,
+        traceState: ctx.traceState,
+        name: ev.name,
+        startWallTs: wallTs,
+        attrs: this.attrs(ev.attributes ?? {}),
+        links: ev.links ?? [],
+        events: []
+      });
+      return;
+    }
+    if (ev.type === "span.event") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (!sp) return;
+      sp.events.push({ wallTs, name: ev.name, attrs: this.attrs(ev.attributes ?? {}) });
+      return;
+    }
+    if (ev.type === "span.end") {
+      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" || ev.type === "schedule.decision") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (!sp) return;
+      sp.events.push({ wallTs, name: ev.type, attrs: this.attrs(ev) });
+    }
+  }
+  exportFinished() {
+    this.pruneFinished();
+    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) {
+        if (this.deleteFinished(spanId)) dropped++;
+      }
+      this.prunedFinishedSpans += dropped;
+      return dropped;
+    }
+    dropped += this.pruneExpiredFinished();
+    dropped += this.pruneFinishedOverLimit();
+    this.prunedFinishedSpans += dropped;
+    return dropped;
+  }
+  stats() {
+    return {
+      storedSpans: this.spans.size,
+      finishedSpans: this.finishedSpanCount,
+      prunedFinishedSpans: this.prunedFinishedSpans
+    };
+  }
+  attrs(attrs) {
+    return this.options.sanitizeAttributes?.(attrs) ?? attrs;
+  }
+  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();
+  }
+  pruneExpiredFinished() {
+    const maxAgeMs = this.options.maxSpanAgeMs;
+    if (maxAgeMs === void 0 || maxAgeMs <= 0) return 0;
+    const now = this.now();
+    let dropped = 0;
+    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;
+    let dropped = 0;
+    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 {
+  makeMetrics,
+  makeRuntimeEventRecord,
+  runtimeEventRecordContext,
+  runtimeHooksToEventHandler,
+  EventBus,
+  InMemoryTracer
+};

package/dist/{chunk-R3R2FVLG.cjs → chunk-SA6HUJVI.cjs}

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkTGIFUAK4cjs = require('./chunk-TGIFUAK4.cjs');
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
 
 // src/core/stream/structuredConcurrency.ts
 function race(left, right, parentScope) {
-  return _chunkTGIFUAK4cjs.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 _chunkTGIFUAK4cjs.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 _chunkTGIFUAK4cjs.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 _chunkTGIFUAK4cjs.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);

package/dist/chunk-TRM4JUZQ.js

@@ -0,0 +1,104 @@
+import {
+  Cause
+} from "./chunk-UB4B6OFY.js";
+
+// src/http/effectRunner.ts
+function registerHttpEffect(effect, env, cb) {
+  let done = false;
+  let currentCancel;
+  const finish = (exit) => {
+    if (done) return;
+    done = true;
+    currentCancel = void 0;
+    cb(exit);
+  };
+  const run = (current, cont) => {
+    if (done) return;
+    switch (current._tag) {
+      case "Succeed":
+        cont({ _tag: "Success", value: current.value });
+        return;
+      case "Fail":
+        cont({ _tag: "Failure", cause: Cause.fail(current.error) });
+        return;
+      case "Sync":
+        try {
+          cont({ _tag: "Success", value: current.thunk(env) });
+        } catch (e) {
+          cont({ _tag: "Failure", cause: Cause.die(e) });
+        }
+        return;
+      case "Async": {
+        const cancel = current.register(env, (exit) => {
+          currentCancel = void 0;
+          if (done) return;
+          cont(exit);
+        });
+        currentCancel = typeof cancel === "function" ? cancel : void 0;
+        return;
+      }
+      case "FlatMap":
+        run(current.first, (exit) => {
+          if (done) return;
+          if (exit._tag === "Failure") {
+            cont(exit);
+            return;
+          }
+          try {
+            run(current.andThen(exit.value), cont);
+          } catch (e) {
+            cont({ _tag: "Failure", cause: Cause.die(e) });
+          }
+        });
+        return;
+      case "Fold":
+        run(current.first, (exit) => {
+          if (done) return;
+          try {
+            if (exit._tag === "Success") {
+              run(current.onSuccess(exit.value), cont);
+              return;
+            }
+            if (Cause.isFailureOnly(exit.cause)) {
+              const failure = Cause.firstFailure(exit.cause);
+              if (failure._tag === "Some") {
+                run(current.onFailure(failure.value), cont);
+                return;
+              }
+            }
+            cont(exit);
+          } catch (e) {
+            cont({ _tag: "Failure", cause: Cause.die(e) });
+          }
+        });
+        return;
+      case "Fork":
+        cont({ _tag: "Success", value: void 0 });
+        return;
+      case "Interruptibility":
+      case "InterruptibilityRestore":
+      case "FiberRefLocally":
+        run(current.effect, cont);
+        return;
+      case "InterruptibilityMask":
+        run(current.body((effect2) => effect2), cont);
+        return;
+    }
+  };
+  run(effect, finish);
+  return () => {
+    if (done) return;
+    const cancel = currentCancel;
+    currentCancel = void 0;
+    done = true;
+    try {
+      cancel?.();
+    } finally {
+      cb({ _tag: "Failure", cause: Cause.interrupt() });
+    }
+  };
+}
+
+export {
+  registerHttpEffect
+};