brass-runtime 1.17.0 → 1.18.0

package/dist/chunk-W6WR37HN.js

@@ -0,0 +1,33 @@
+import {
+  layerEffect,
+  makeServiceTag
+} from "./chunk-IBRHSH5H.js";
+import {
+  Runtime
+} from "./chunk-XSAHV5HQ.js";
+import {
+  asyncSync
+} from "./chunk-UB4B6OFY.js";
+
+// src/core/runtime/runtimeLayer.ts
+var RuntimeService = makeServiceTag("Runtime");
+function makeRuntimeLayer(env = {}, options = {}) {
+  const { tag = RuntimeService, ...runtimeOptions } = options;
+  return layerEffect(
+    tag,
+    (context) => asyncSync(
+      () => new Runtime({
+        ...runtimeOptions,
+        env: resolveRuntimeLayerEnv(env, context)
+      })
+    )
+  );
+}
+function resolveRuntimeLayerEnv(env, context) {
+  return typeof env === "function" ? env(context) : env;
+}
+
+export {
+  RuntimeService,
+  makeRuntimeLayer
+};

package/dist/{chunk-FH2X7BVP.js → chunk-XSAHV5HQ.js}

@@ -2,12 +2,15 @@ import {
   Async,
   Cause,
   Exit,
-  asyncEffect
+  asyncEffect,
+  asyncFlatMap,
+  asyncFold,
+  unit
 } from "./chunk-UB4B6OFY.js";
 import {
   Schema,
   parseConfig
-} from "./chunk-C3MDXTRZ.js";
+} from "./chunk-HCJ4S3YB.js";
 
 // src/core/runtime/ringBuffer.ts
 var PushStatus = /* @__PURE__ */ ((PushStatus3) => {
@@ -2978,7 +2981,7 @@ var Runtime = class _Runtime {
     if (this.hooks !== NoopHooks) return false;
     if (getCurrentFiber() !== null) return false;
     if (this.scheduler !== globalScheduler) return false;
-    if (this.lane !== void 0 || this.inferLane) return false;
+    if (this.inferLane) return false;
     if (this.engineMode !== "ts") return false;
     new NativeTopLevelRunner(this, effect, cb).start();
     return true;
@@ -3137,7 +3140,7 @@ var NativeTopLevelRunner = class {
         syncExit = exit;
         return;
       }
-      queueMicrotask(() => this.resumeAsync(exit));
+      this.resumeAsync(exit);
     };
     try {
       current.register(this.runtime.env, resume);
@@ -4035,6 +4038,183 @@ var JsFiberEngine = class {
   }
 };
 
+// src/core/runtime/scope.ts
+var nextScopeId = 1;
+function awaitAll(fibers) {
+  return asyncEffect((_env, cb) => {
+    let remaining = fibers.length;
+    if (remaining === 0) {
+      cb({ _tag: "Success", value: void 0 });
+      return;
+    }
+    for (const f of fibers) {
+      f.join(() => {
+        remaining -= 1;
+        if (remaining === 0) cb({ _tag: "Success", value: void 0 });
+      });
+    }
+  });
+}
+var Scope = class _Scope {
+  constructor(runtime, parentScopeId) {
+    this.runtime = runtime;
+    this.parentScopeId = parentScopeId;
+    this.id = nextScopeId++;
+    const inferredParent = this.parentScopeId ?? getCurrentFiber()?.scopeId;
+    if (this.runtime.hasActiveHooks()) {
+      this.runtime.emit({
+        type: "scope.open",
+        scopeId: this.id,
+        parentScopeId: inferredParent
+      });
+    }
+  }
+  runtime;
+  parentScopeId;
+  id;
+  closed = false;
+  children = /* @__PURE__ */ new Set();
+  subScopes = /* @__PURE__ */ new Set();
+  finalizers = [];
+  /** registra un finalizer (LIFO) */
+  addFinalizer(f) {
+    if (this.closed) {
+      throw new Error("Trying to add finalizer to closed scope");
+    }
+    this.finalizers.push(f);
+  }
+  /** crea un sub scope (mismo runtime) */
+  subScope() {
+    if (this.closed) throw new Error("Scope closed");
+    const s = new _Scope(this.runtime, this.id);
+    this.subScopes.add(s);
+    return s;
+  }
+  /** ✅ fork en este scope */
+  fork(eff) {
+    if (this.closed) throw new Error("Scope closed");
+    const f = this.runtime.fork(eff, this.id);
+    this.children.add(f);
+    f.join(() => this.children.delete(f));
+    return f;
+  }
+  /** close fire-and-forget (no bloquea) */
+  close(exit = { _tag: "Success", value: void 0 }) {
+    this.runtime.fork(this.closeAsync(exit));
+  }
+  /** Emit the scope.close event if hooks are active. */
+  emitCloseEvent(exit) {
+    if (this.runtime.hasActiveHooks()) {
+      const status = exit._tag === "Success" ? "success" : Cause.isInterruptedOnly(exit.cause) ? "interrupted" : "failure";
+      const failure = exit._tag === "Failure" ? Cause.firstFailure(exit.cause) : void 0;
+      this.runtime.emit({
+        type: "scope.close",
+        scopeId: this.id,
+        status,
+        error: failure?._tag === "Some" ? failure.value : exit._tag === "Failure" ? exit.cause : void 0
+      });
+    }
+  }
+  /**
+   * Build an effect that executes finalizers in LIFO order.
+   *
+   * Optimization over the original: instead of wrapping every finalizer in
+   * `asyncFold(fin(exit), () => unit(), () => unit())` which creates 3 effect
+   * nodes per finalizer (Fold + 2 Succeed), we use a single Sync thunk per
+   * finalizer that catches errors inline.  When the finalizer returns a
+   * Succeed effect (like `unit()`), the Sync thunk completes without creating
+   * additional effect nodes.
+   */
+  buildFinalizerEffect(exit) {
+    const fins = this.finalizers;
+    if (fins.length === 0) return unit();
+    let chain = unit();
+    for (let i = fins.length - 1; i >= 0; i--) {
+      const fin = fins[i];
+      chain = asyncFlatMap(chain, () => {
+        let result;
+        try {
+          result = fin(exit);
+        } catch {
+          return unit();
+        }
+        if (result._tag === "Succeed") {
+          return unit();
+        }
+        return asyncFold(
+          result,
+          () => unit(),
+          () => unit()
+        );
+      });
+    }
+    return chain;
+  }
+  closeAsync(exit = { _tag: "Success", value: void 0 }, opts = { awaitChildren: true }) {
+    return asyncFlatMap(
+      unit(),
+      () => asyncEffect((env, cb) => {
+        if (this.closed) {
+          cb({ _tag: "Success", value: void 0 });
+          return;
+        }
+        this.closed = true;
+        const children = Array.from(this.children);
+        const subScopes = Array.from(this.subScopes);
+        for (const child of children) {
+          child.interrupt();
+        }
+        const closeSubs = subScopes.reduceRight(
+          (acc, s) => asyncFlatMap(acc, () => s.closeAsync(exit, opts)),
+          unit()
+        );
+        const runFinalizers = this.buildFinalizerEffect(exit);
+        const needsAwait = opts.awaitChildren && children.length > 0;
+        const awaitChildrenEff = needsAwait ? awaitAll(children) : unit();
+        const hasSubScopes = subScopes.length > 0;
+        const hasNoFinalizers = this.finalizers.length === 0;
+        if (!hasSubScopes && !needsAwait && hasNoFinalizers) {
+          this.emitCloseEvent(exit);
+          cb({ _tag: "Success", value: void 0 });
+          return;
+        }
+        const all = asyncFlatMap(closeSubs, () => asyncFlatMap(awaitChildrenEff, () => runFinalizers));
+        this.runtime.fork(all).join(() => {
+          this.emitCloseEvent(exit);
+          cb({ _tag: "Success", value: void 0 });
+        });
+      })
+    );
+  }
+};
+function withScopeAsync(runtime, f) {
+  return asyncEffect((_env, cb) => {
+    const scope = new Scope(runtime);
+    let done = false;
+    const completeAfterClose = (exit) => {
+      runtime.fork(scope.closeAsync(exit)).join(() => {
+        if (done) return;
+        done = true;
+        cb(exit);
+      });
+    };
+    const fiber = runtime.fork(f(scope));
+    fiber.join(completeAfterClose);
+    return () => {
+      if (done) return;
+      fiber.interrupt();
+      runtime.fork(scope.closeAsync(Exit.failCause(Cause.interrupt())));
+    };
+  });
+}
+function withScope(runtime, f) {
+  return withScopeAsync(runtime, (scope) => {
+    const out = f(scope);
+    if (out && typeof out === "object" && "_tag" in out) return out;
+    return unit();
+  });
+}
+
 export {
   PushStatus,
   RingBuffer,
@@ -4085,5 +4265,8 @@ export {
   RuntimeFiber,
   getCurrentFiber,
   unsafeGetCurrentRuntime,
-  withCurrentFiber
+  withCurrentFiber,
+  Scope,
+  withScopeAsync,
+  withScope
 };

package/dist/chunk-YM3EDNYD.js

@@ -0,0 +1,123 @@
+import {
+  asyncFail,
+  asyncFold,
+  asyncSucceed
+} from "./chunk-UB4B6OFY.js";
+
+// src/core/runtime/circuitBreaker.ts
+function makeCircuitBreaker(config = {}) {
+  const failureThreshold = config.failureThreshold ?? 5;
+  const resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
+  const successThreshold = config.successThreshold ?? 1;
+  const isFailure = config.isFailure ?? (() => true);
+  const onStateChange = config.onStateChange;
+  let currentState = "closed";
+  let consecutiveFailures = 0;
+  let consecutiveSuccesses = 0;
+  let openedAt = 0;
+  let totalRequests = 0;
+  let totalFailures = 0;
+  let totalSuccesses = 0;
+  let totalRejected = 0;
+  let lastFailureTime = null;
+  let lastSuccessTime = null;
+  const transition = (to) => {
+    if (currentState === to) return;
+    const from = currentState;
+    currentState = to;
+    onStateChange?.(from, to);
+  };
+  const onSuccess = () => {
+    totalSuccesses++;
+    lastSuccessTime = Date.now();
+    consecutiveFailures = 0;
+    if (currentState === "half-open") {
+      consecutiveSuccesses++;
+      if (consecutiveSuccesses >= successThreshold) {
+        consecutiveSuccesses = 0;
+        transition("closed");
+      }
+    }
+  };
+  const onFailure = (error) => {
+    if (!isFailure(error)) {
+      onSuccess();
+      return;
+    }
+    totalFailures++;
+    lastFailureTime = Date.now();
+    consecutiveSuccesses = 0;
+    consecutiveFailures++;
+    if (currentState === "half-open") {
+      openedAt = Date.now();
+      transition("open");
+    } else if (currentState === "closed" && consecutiveFailures >= failureThreshold) {
+      openedAt = Date.now();
+      transition("open");
+    }
+  };
+  const shouldAllow = () => {
+    switch (currentState) {
+      case "closed":
+        return true;
+      case "open": {
+        const elapsed = Date.now() - openedAt;
+        if (elapsed >= resetTimeoutMs) {
+          transition("half-open");
+          return true;
+        }
+        return false;
+      }
+      case "half-open":
+        return true;
+    }
+  };
+  const protect = (effect) => {
+    totalRequests++;
+    if (!shouldAllow()) {
+      totalRejected++;
+      return asyncFail({
+        _tag: "CircuitBreakerOpen",
+        openSince: openedAt,
+        failures: consecutiveFailures
+      });
+    }
+    return asyncFold(
+      effect,
+      (error) => {
+        onFailure(error);
+        return asyncFail(error);
+      },
+      (value) => {
+        onSuccess();
+        return asyncSucceed(value);
+      }
+    );
+  };
+  const stats = () => ({
+    state: currentState,
+    failures: consecutiveFailures,
+    successes: consecutiveSuccesses,
+    totalRequests,
+    totalFailures,
+    totalSuccesses,
+    totalRejected,
+    lastFailureTime,
+    lastSuccessTime
+  });
+  const reset = () => {
+    consecutiveFailures = 0;
+    consecutiveSuccesses = 0;
+    transition("closed");
+  };
+  return {
+    state: () => currentState,
+    protect,
+    stats,
+    reset
+  };
+}
+
+export {
+  makeCircuitBreaker
+};

package/dist/{chunk-7ZPEZ57L.cjs → chunk-YTX2JYYP.cjs}

@@ -1,26 +1,24 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
-var _chunkPD4EJTQCcjs = require('./chunk-PD4EJTQC.cjs');
+var _chunkN6QNSTWDcjs = require('./chunk-N6QNSTWD.cjs');
 
 
-var _chunkKQLYONSEcjs = require('./chunk-KQLYONSE.cjs');
+var _chunkKHACHFBQcjs = require('./chunk-KHACHFBQ.cjs');
 
 
-var _chunk5EC274J5cjs = require('./chunk-5EC274J5.cjs');
+var _chunkLXBU5E77cjs = require('./chunk-LXBU5E77.cjs');
 
 
-var _chunkF6XWZQY4cjs = require('./chunk-F6XWZQY4.cjs');
+var _chunkAJMKZXRBcjs = require('./chunk-AJMKZXRB.cjs');
 
 
-var _chunkWBGRHGBPcjs = require('./chunk-WBGRHGBP.cjs');
 
+var _chunkVIFA4DPNcjs = require('./chunk-VIFA4DPN.cjs');
 
-var _chunk52PPNNI4cjs = require('./chunk-52PPNNI4.cjs');
 
 
-
-var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
+var _chunkSSQJKDN3cjs = require('./chunk-SSQJKDN3.cjs');
 
 
 
@@ -301,10 +299,10 @@ function makeRuntimeCase(variant, chainDepth) {
     maxCapacity: 8192,
     flushBudget: 2048
   };
-  const scheduler = variant === "wide-scheduler" ? new (0, _chunkGLE2WY7Zcjs.Scheduler)(schedulerConfig) : void 0;
-  const recorder = variant === "recorder" ? _chunkPD4EJTQCcjs.makeRuntimeRecorder.call(void 0, { maxEvents: 1e4 }) : void 0;
-  const hooks = _nullishCoalesce(_optionalChain([recorder, 'optionalAccess', _8 => _8.hooks]), () => ( (variant === "active-hooks" ? new (0, _chunk52PPNNI4cjs.EventBus)() : void 0)));
-  const runtime = _chunkGLE2WY7Zcjs.Runtime.makeWithEngine(hooks ? {} : {}, "ts", {
+  const scheduler = variant === "wide-scheduler" ? new (0, _chunkSSQJKDN3cjs.Scheduler)(schedulerConfig) : void 0;
+  const recorder = variant === "recorder" ? _chunkN6QNSTWDcjs.makeRuntimeRecorder.call(void 0, { maxEvents: 1e4 }) : void 0;
+  const hooks = _nullishCoalesce(_optionalChain([recorder, 'optionalAccess', _8 => _8.hooks]), () => ( (variant === "active-hooks" ? new (0, _chunkAJMKZXRBcjs.EventBus)() : void 0)));
+  const runtime = _chunkSSQJKDN3cjs.Runtime.makeWithEngine(hooks ? {} : {}, "ts", {
     hooks,
     ...scheduler ? { scheduler } : {},
     inferLane: false
@@ -351,7 +349,7 @@ function makeFlatMapChain(depth) {
   return effect;
 }
 function makeFiberRefProgram(depth) {
-  const ref = _chunkPD4EJTQCcjs.makeFiberRef.call(void 0, 0);
+  const ref = _chunkN6QNSTWDcjs.makeFiberRef.call(void 0, 0);
   let effect = ref.set(0);
   for (let i = 0; i < depth; i++) {
     effect = _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, effect, () => ref.update((n) => n + 1));
@@ -653,7 +651,7 @@ async function profileHttpLayers(options = {}) {
 }
 async function runScenario(scenario) {
   const server = await startDummyServer(scenario.delayMs);
-  const observability = scenario.variant === "default-json-observed" ? _chunkWBGRHGBPcjs.makeObservability.call(void 0, {
+  const observability = scenario.variant === "default-json-observed" ? _chunkLXBU5E77cjs.makeObservability.call(void 0, {
     logs: false,
     traces: { maxFinishedSpans: 1e4 },
     autoStart: false
@@ -840,9 +838,9 @@ function makeDefaultJsonRunner(server, scenario, preset, disableAdaptiveLimiter
 }
 function makeProfileRuntime(concurrency, observability) {
   const capacity = Math.max(65536, concurrency * 8);
-  return _chunkGLE2WY7Zcjs.Runtime.makeWithEngine(_nullishCoalesce(_optionalChain([observability, 'optionalAccess', _30 => _30.env]), () => ( {})), "ts", {
+  return _chunkSSQJKDN3cjs.Runtime.makeWithEngine(_nullishCoalesce(_optionalChain([observability, 'optionalAccess', _30 => _30.env]), () => ( {})), "ts", {
     hooks: _optionalChain([observability, 'optionalAccess', _31 => _31.hooks]),
-    scheduler: new (0, _chunkGLE2WY7Zcjs.Scheduler)({
+    scheduler: new (0, _chunkSSQJKDN3cjs.Scheduler)({
       laneMode: "single",
       initialCapacity: capacity,
       maxCapacity: capacity,
@@ -864,24 +862,24 @@ function baseHttpConfig(baseUrl, scenario) {
   };
 }
 function makeWireClient(baseUrl, scenario) {
-  return _chunk5EC274J5cjs.makeHttp.call(void 0, baseHttpConfig(baseUrl, scenario));
+  return _chunkVIFA4DPNcjs.makeHttp.call(void 0, baseHttpConfig(baseUrl, scenario));
 }
 function makeMinimalClient(baseUrl, scenario) {
-  return _chunkKQLYONSEcjs.makeDefaultHttpClient.call(void 0, {
+  return _chunkVIFA4DPNcjs.makeDefaultHttpClient.call(void 0, {
     preset: "minimal",
     compression: false,
     ...baseHttpConfig(baseUrl, scenario)
   });
 }
 function makeDefaultClient(baseUrl, scenario, preset, disableAdaptiveLimiter, observability) {
-  return _chunkKQLYONSEcjs.makeDefaultHttpClient.call(void 0, {
+  return _chunkVIFA4DPNcjs.makeDefaultHttpClient.call(void 0, {
     preset,
     compression: false,
     ...baseHttpConfig(baseUrl, scenario),
     ...disableAdaptiveLimiter ? { adaptiveLimiter: false } : {},
     ...observability ? {
       middleware: [
-        _chunkF6XWZQY4cjs.withHttpObservability.call(void 0, {
+        _chunkKHACHFBQcjs.withHttpObservability.call(void 0, {
           metrics: observability.metrics,
           logs: false,
           spans: {},