brass-runtime 1.16.0 → 1.16.1

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);

package/dist/{chunk-K2T3DV26.mjs → chunk-TRM4JUZQ.js}

@@ -1,6 +1,6 @@
 import {
   Cause
-} from "./chunk-NOYZIMUJ.mjs";
+} from "./chunk-UB4B6OFY.js";
 
 // src/http/effectRunner.ts
 function registerHttpEffect(effect, env, cb) {
@@ -59,9 +59,12 @@ function registerHttpEffect(effect, env, cb) {
               run(current.onSuccess(exit.value), cont);
               return;
             }
-            if (exit.cause._tag === "Fail") {
-              run(current.onFailure(exit.cause.error), 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) {
@@ -72,6 +75,14 @@ function registerHttpEffect(effect, env, cb) {
       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);

package/dist/chunk-UB4B6OFY.js

@@ -0,0 +1,370 @@
+// src/core/types/asyncEffect.ts
+var Async = {
+  succeed: (value) => ({ _tag: "Succeed", value }),
+  fail: (error) => ({ _tag: "Fail", error }),
+  sync: (thunk) => ({ _tag: "Sync", thunk }),
+  async: (register) => ({ _tag: "Async", register }),
+  interruptibility: (mode, effect) => ({ _tag: "Interruptibility", mode, effect })
+};
+function asyncFold(fa, onFailure, onSuccess) {
+  return {
+    _tag: "Fold",
+    first: fa,
+    onFailure,
+    onSuccess
+  };
+}
+function asyncCatchAll(fa, handler) {
+  return asyncFold(fa, handler, asyncSucceed);
+}
+function asyncMapError(fa, f) {
+  return asyncFold(fa, (e) => asyncFail(f(e)), asyncSucceed);
+}
+var SUCCEED_UNDEFINED = { _tag: "Succeed", value: void 0 };
+var SUCCEED_TRUE = { _tag: "Succeed", value: true };
+var SUCCEED_FALSE = { _tag: "Succeed", value: false };
+var SUCCEED_NULL = { _tag: "Succeed", value: null };
+var unit = () => SUCCEED_UNDEFINED;
+var asyncSucceed = (value) => {
+  if (value === void 0) return SUCCEED_UNDEFINED;
+  if (value === true) return SUCCEED_TRUE;
+  if (value === false) return SUCCEED_FALSE;
+  if (value === null) return SUCCEED_NULL;
+  return { _tag: "Succeed", value };
+};
+var asyncFail = (error) => ({
+  _tag: "Fail",
+  error
+});
+var asyncSync = (thunk) => ({
+  _tag: "Sync",
+  thunk
+});
+var asyncTotal = (thunk) => asyncSync(() => thunk());
+var asyncEffect = (register) => ({
+  _tag: "Async",
+  register
+});
+function asyncMap(fa, f) {
+  return asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
+}
+function asyncFlatMap(fa, f) {
+  return {
+    _tag: "FlatMap",
+    first: fa,
+    andThen: f
+  };
+}
+function acquireRelease(acquire, release, scope) {
+  return asyncFlatMap(acquire, (resource) => {
+    scope.addFinalizer((exit) => release(resource, exit));
+    return asyncSucceed(resource);
+  });
+}
+function asyncInterruptible(register) {
+  return asyncEffect(register);
+}
+var withAsyncPromise = (run) => (eff) => {
+  const anyEff = eff;
+  if (!anyEff.toPromise) {
+    anyEff.toPromise = (env) => run(eff, env);
+    anyEff.unsafeRunPromise = () => run(eff, {});
+  }
+  return anyEff;
+};
+var mapAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
+var mapTryAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSync(() => f(a)));
+
+// src/core/types/option.ts
+var none = { _tag: "None" };
+var some = (value) => ({ _tag: "Some", value });
+
+// src/core/types/effect.ts
+var Cause = {
+  fail: (error) => ({ _tag: "Fail", error }),
+  interrupt: () => ({ _tag: "Interrupt" }),
+  die: (defect) => ({ _tag: "Die", defect }),
+  then: (left, right) => ({ _tag: "Then", left, right }),
+  both: (left, right) => ({ _tag: "Both", left, right }),
+  isCause: isCauseValue,
+  failures: causeFailures,
+  defects: causeDefects,
+  firstFailure: firstCauseFailure,
+  firstDefect: firstCauseDefect,
+  containsFailure: causeContainsFailure,
+  containsDefect: causeContainsDefect,
+  containsInterrupt: causeContainsInterrupt,
+  isInterruptedOnly: causeIsInterruptedOnly,
+  isFailureOnly: causeIsFailureOnly,
+  squash: squashCause,
+  toError: causeToError,
+  pretty: prettyCause,
+  format: prettyCause
+};
+function isCause(value) {
+  return isCauseValue(value);
+}
+function prettyCause(cause, options = {}) {
+  const indent = options.indent ?? "  ";
+  const renderError = options.renderError ?? ((error) => formatCauseValue(error));
+  const renderDefect = options.renderDefect ?? formatCauseValue;
+  const lines = [];
+  const visit = (current, depth, label) => {
+    const prefix = indent.repeat(depth);
+    const head = label ? `${label}: ` : "";
+    switch (current._tag) {
+      case "Fail":
+        lines.push(`${prefix}${head}Fail(${renderError(current.error)})`);
+        return;
+      case "Die":
+        lines.push(`${prefix}${head}Die(${renderDefect(current.defect)})`);
+        return;
+      case "Interrupt":
+        lines.push(`${prefix}${head}Interrupt`);
+        return;
+      case "Then":
+        lines.push(`${prefix}${head}Then`);
+        visit(current.left, depth + 1, "left");
+        visit(current.right, depth + 1, "right");
+        return;
+      case "Both":
+        lines.push(`${prefix}${head}Both`);
+        visit(current.left, depth + 1, "left");
+        visit(current.right, depth + 1, "right");
+        return;
+    }
+  };
+  visit(cause, 0);
+  if (options.singleLine) return lines.map((line) => line.trim()).join("; ");
+  return lines.join("\n");
+}
+var formatCause = prettyCause;
+function isCauseValue(value) {
+  if (typeof value !== "object" || value === null || !("_tag" in value)) return false;
+  const tag = value._tag;
+  switch (tag) {
+    case "Fail":
+      return "error" in value;
+    case "Die":
+      return "defect" in value;
+    case "Interrupt":
+      return true;
+    case "Then":
+    case "Both":
+      return isCauseValue(value.left) && isCauseValue(value.right);
+    default:
+      return false;
+  }
+}
+function causeFailures(cause) {
+  const failures = [];
+  collectFailures(cause, failures);
+  return failures;
+}
+function collectFailures(cause, out) {
+  switch (cause._tag) {
+    case "Fail":
+      out.push(cause.error);
+      return;
+    case "Then":
+    case "Both":
+      collectFailures(cause.left, out);
+      collectFailures(cause.right, out);
+      return;
+    case "Die":
+    case "Interrupt":
+      return;
+  }
+}
+function causeDefects(cause) {
+  const defects = [];
+  collectDefects(cause, defects);
+  return defects;
+}
+function collectDefects(cause, out) {
+  switch (cause._tag) {
+    case "Die":
+      out.push(cause.defect);
+      return;
+    case "Then":
+    case "Both":
+      collectDefects(cause.left, out);
+      collectDefects(cause.right, out);
+      return;
+    case "Fail":
+    case "Interrupt":
+      return;
+  }
+}
+function firstCauseFailure(cause) {
+  switch (cause._tag) {
+    case "Fail":
+      return some(cause.error);
+    case "Then":
+    case "Both": {
+      const left = firstCauseFailure(cause.left);
+      return left._tag === "Some" ? left : firstCauseFailure(cause.right);
+    }
+    case "Die":
+    case "Interrupt":
+      return none;
+  }
+}
+function firstCauseDefect(cause) {
+  switch (cause._tag) {
+    case "Die":
+      return some(cause.defect);
+    case "Then":
+    case "Both": {
+      const left = firstCauseDefect(cause.left);
+      return left._tag === "Some" ? left : firstCauseDefect(cause.right);
+    }
+    case "Fail":
+    case "Interrupt":
+      return none;
+  }
+}
+function causeContainsFailure(cause) {
+  switch (cause._tag) {
+    case "Fail":
+      return true;
+    case "Then":
+    case "Both":
+      return causeContainsFailure(cause.left) || causeContainsFailure(cause.right);
+    case "Die":
+    case "Interrupt":
+      return false;
+  }
+}
+function causeContainsDefect(cause) {
+  switch (cause._tag) {
+    case "Die":
+      return true;
+    case "Then":
+    case "Both":
+      return causeContainsDefect(cause.left) || causeContainsDefect(cause.right);
+    case "Fail":
+    case "Interrupt":
+      return false;
+  }
+}
+function causeContainsInterrupt(cause) {
+  switch (cause._tag) {
+    case "Interrupt":
+      return true;
+    case "Then":
+    case "Both":
+      return causeContainsInterrupt(cause.left) || causeContainsInterrupt(cause.right);
+    case "Fail":
+    case "Die":
+      return false;
+  }
+}
+function causeIsInterruptedOnly(cause) {
+  return causeContainsInterrupt(cause) && !causeContainsFailure(cause) && !causeContainsDefect(cause);
+}
+function causeIsFailureOnly(cause) {
+  return causeContainsFailure(cause) && !causeContainsInterrupt(cause) && !causeContainsDefect(cause);
+}
+function squashCause(cause) {
+  const failure = firstCauseFailure(cause);
+  if (failure._tag === "Some") return failure.value;
+  const defect = firstCauseDefect(cause);
+  if (defect._tag === "Some") return defect.value instanceof Error ? defect.value : new Error(String(defect.value));
+  if (causeContainsInterrupt(cause)) return new Error("Interrupted");
+  return new Error(prettyCause(cause, { singleLine: true }));
+}
+function causeToError(cause) {
+  const squashed = squashCause(cause);
+  if (squashed instanceof Error) return squashed;
+  return new Error(formatCauseValue(squashed));
+}
+function formatCauseValue(value) {
+  if (value instanceof Error) return `${value.name}: ${value.message}`;
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var Exit = {
+  succeed: (value) => ({
+    _tag: "Success",
+    value
+  }),
+  failCause: (cause) => ({
+    _tag: "Failure",
+    cause
+  })
+};
+var succeed = (value) => asyncSucceed(value);
+var fail = (error) => asyncFail(error);
+var sync = (thunk) => asyncSync((env) => thunk(env));
+var map = (fa, f) => asyncMap(fa, f);
+var flatMap = (fa, f) => asyncFlatMap(fa, f);
+var mapError = (fa, f) => asyncMapError(fa, f);
+var catchAll = (fa, handler) => asyncFold(fa, handler, asyncSucceed);
+var uninterruptible = (effect) => ({
+  _tag: "Interruptibility",
+  mode: "uninterruptible",
+  effect
+});
+var interruptible = (effect) => ({
+  _tag: "Interruptibility",
+  mode: "interruptible",
+  effect
+});
+function uninterruptibleMask(body) {
+  return { _tag: "InterruptibilityMask", body };
+}
+function orElseOptional(fa, that) {
+  return asyncFold(
+    fa,
+    (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
+    asyncSucceed
+  );
+}
+var end = () => fail(none);
+
+export {
+  Async,
+  asyncFold,
+  asyncCatchAll,
+  asyncMapError,
+  unit,
+  asyncSucceed,
+  asyncFail,
+  asyncSync,
+  asyncTotal,
+  asyncEffect,
+  asyncMap,
+  asyncFlatMap,
+  acquireRelease,
+  asyncInterruptible,
+  withAsyncPromise,
+  mapAsync,
+  mapTryAsync,
+  none,
+  some,
+  Cause,
+  isCause,
+  prettyCause,
+  formatCause,
+  Exit,
+  succeed,
+  fail,
+  sync,
+  map,
+  flatMap,
+  mapError,
+  catchAll,
+  uninterruptible,
+  interruptible,
+  uninterruptibleMask,
+  orElseOptional,
+  end
+};

package/dist/{chunk-G3XGCZDQ.js → chunk-UCUBNWM2.js}

@@ -1,6 +1,6 @@
 import {
   asyncEffect
-} from "./chunk-PNVFW245.js";
+} from "./chunk-UB4B6OFY.js";
 
 // src/core/stream/structuredConcurrency.ts
 function race(left, right, parentScope) {