brass-runtime 1.17.0 → 1.18.1

package/dist/chunk-7TKI527D.cjs

@@ -0,0 +1,123 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return 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 _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
+
+// src/core/runtime/circuitBreaker.ts
+function makeCircuitBreaker(config = {}) {
+  const failureThreshold = _nullishCoalesce(config.failureThreshold, () => ( 5));
+  const resetTimeoutMs = _nullishCoalesce(config.resetTimeoutMs, () => ( 3e4));
+  const successThreshold = _nullishCoalesce(config.successThreshold, () => ( 1));
+  const isFailure = _nullishCoalesce(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;
+    _optionalChain([onStateChange, 'optionalCall', _ => _(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 _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, {
+        _tag: "CircuitBreakerOpen",
+        openSince: openedAt,
+        failures: consecutiveFailures
+      });
+    }
+    return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+      effect,
+      (error) => {
+        onFailure(error);
+        return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
+      },
+      (value) => {
+        onSuccess();
+        return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, 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
+  };
+}
+
+
+
+exports.makeCircuitBreaker = makeCircuitBreaker;

package/dist/{chunk-52OB2ROS.js → chunk-7VQLEN37.js}

@@ -2,11 +2,9 @@ import {
   race
 } from "./chunk-UCUBNWM2.js";
 import {
+  fromPromiseAbortable,
   withScopeAsync
-} from "./chunk-L2SYFEBS.js";
-import {
-  fromPromiseAbortable
-} from "./chunk-FH2X7BVP.js";
+} from "./chunk-TTSPIU3U.js";
 import {
   Cause,
   Exit,

package/dist/{chunk-KH4SYAOS.mjs → chunk-B5FKOLTB.mjs}

@@ -1,12 +1,10 @@
 import {
-  ensuring
-} from "./chunk-KN32XNTH.mjs";
+  makeRuntimeEventRecord
+} from "./chunk-6V2AWT4R.mjs";
 import {
+  layerEffect,
   makeScheduleDriver
-} from "./chunk-2HQTDLHF.mjs";
-import {
-  makeRuntimeEventRecord
-} from "./chunk-EJ6BPYVR.mjs";
+} from "./chunk-EEN5OTCR.mjs";
 import {
   Runtime,
   getCurrentFiber,
@@ -14,7 +12,7 @@ import {
   runtimeClockFromEnv,
   toPromise,
   unsafeRunAsync
-} from "./chunk-GYM3LLGS.mjs";
+} from "./chunk-H626ZTDZ.mjs";
 import {
   Cause,
   Exit,
@@ -24,9 +22,11 @@ import {
   asyncFold,
   asyncMap,
   asyncSucceed,
-  asyncSync,
-  unit
+  asyncSync
 } from "./chunk-36I3M4UC.mjs";
+import {
+  parseConfig
+} from "./chunk-6MLAZPBL.mjs";
 
 // src/core/types/cancel.ts
 function makeCancelToken() {
@@ -636,275 +636,19 @@ function neverEffect() {
   });
 }
 
-// src/core/runtime/layer.ts
-var MissingLayerServiceError = class extends Error {
-  _tag = "MissingLayerService";
-  serviceName;
-  constructor(serviceName) {
-    super(`Missing layer service '${serviceName}'. Add a layer that provides this ServiceTag or pass a LayerContext containing it.`);
-    this.name = "MissingLayerServiceError";
-    this.serviceName = serviceName;
-  }
-};
-function formatLayerError(error) {
-  if (error instanceof MissingLayerServiceError) return error.message;
-  if (isObjectRecord(error) && error._tag === "MissingLayerService" && typeof error.serviceName === "string") {
-    return `Missing layer service '${error.serviceName}'. Add the provider layer before using the service.`;
-  }
-  return error instanceof Error ? error.message : String(error);
-}
-function makeServiceTag(name) {
-  return {
-    _tag: "ServiceTag",
-    key: Symbol(name),
-    name
-  };
-}
-var serviceTag = makeServiceTag;
-var defineService = makeServiceTag;
-var LayerContext = class _LayerContext {
-  services;
-  constructor(entries) {
-    if (entries instanceof Map) {
-      this.services = new Map(entries);
-      return;
-    }
-    this.services = /* @__PURE__ */ new Map();
-    if (!entries) return;
-    for (const [tag, service] of entries) this.services.set(tag.key, service);
-  }
-  static empty() {
-    return new _LayerContext();
-  }
-  get(tag) {
-    return this.services.get(tag.key);
-  }
-  unsafeGet(tag) {
-    if (!this.services.has(tag.key)) {
-      throw new MissingLayerServiceError(tag.name);
-    }
-    return this.services.get(tag.key);
-  }
-  has(tag) {
-    return this.services.has(tag.key);
-  }
-  add(tag, service) {
-    const next = new Map(this.services);
-    next.set(tag.key, service);
-    return new _LayerContext(next);
-  }
-  merge(other) {
-    const next = new Map(this.services);
-    for (const [key, service] of other.services) next.set(key, service);
-    return new _LayerContext(next);
-  }
-  size() {
-    return this.services.size;
-  }
-};
-function makeLayerScope() {
-  const cache = /* @__PURE__ */ new WeakMap();
-  const finalizers = [];
-  let closed = false;
-  const scope = {
-    get: (l, deps) => {
-      if (closed) return asyncFail(new Error("LayerScope is closed"));
-      if (cache.has(l)) return asyncSucceed(cache.get(l));
-      const built = l.buildScoped ? l.buildScoped(deps, scope) : asyncFlatMap(
-        l.build(deps),
-        ({ service, release }) => asyncFlatMap(scope.addFinalizer(release), () => asyncSucceed(service))
-      );
-      return asyncFlatMap(
-        built,
-        (service) => asyncSync(() => {
-          cache.set(l, service);
-          return service;
-        })
-      );
-    },
-    close: () => {
-      if (closed) return unit();
-      closed = true;
-      return releaseAll(finalizers);
-    },
-    size: () => finalizers.length,
-    addFinalizer: (release) => asyncSync(() => {
-      if (!closed) finalizers.push(release);
-    })
-  };
-  return scope;
-}
-function releaseAll(finalizers) {
-  const next = finalizers.pop();
-  if (!next) return unit();
-  return asyncFold(
-    next(),
-    () => releaseAll(finalizers),
-    () => releaseAll(finalizers)
-  );
-}
-function mergeServices(a, b) {
-  if (a instanceof LayerContext && b instanceof LayerContext) {
-    return a.merge(b);
-  }
-  if (isObjectRecord(a) && isObjectRecord(b)) {
-    return { ...a, ...b };
-  }
-  return Object.assign({}, a, b);
-}
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function layer(acquire, release) {
-  return {
-    _tag: "Layer",
-    build: (_deps) => asyncFlatMap(acquire(), (service) => asyncSucceed({
-      service,
-      release: release ? () => release(service) : () => unit()
-    }))
-  };
-}
-function layerValue(tag, value) {
-  return layerEffect(tag, () => asyncSucceed(value));
-}
-function layerEffect(tag, acquire, release) {
-  return {
-    _tag: "Layer",
-    build: (deps = LayerContext.empty()) => asyncFlatMap(acquire(deps), (service) => asyncSucceed({
-      service: deps.add(tag, service),
-      release: release ? () => release(service) : () => unit()
-    }))
-  };
-}
-var layerFromContext = layerEffect;
-var defineLayer = layerEffect;
-function getService(tag) {
-  return asyncSync((context) => context.unsafeGet(tag));
-}
-function layerFrom() {
-  return (acquire, release) => ({
-    _tag: "Layer",
-    build: (deps) => asyncFlatMap(acquire(deps), (service) => asyncSucceed({
-      service,
-      release: release ? () => release(service) : () => unit()
-    }))
-  });
-}
-function layerSucceed(value) {
-  return {
-    _tag: "Layer",
-    build: () => asyncSucceed({ service: value, release: () => unit() })
-  };
-}
-function layerFail(error) {
-  return {
-    _tag: "Layer",
-    build: () => asyncFail(error)
-  };
-}
-function compose(from, to) {
-  return {
-    _tag: "Layer",
-    buildScoped: (deps, scope) => asyncFlatMap(
-      scope.get(from, deps),
-      (mid) => scope.get(to, mid)
-    ),
-    build: (deps) => asyncFlatMap(
-      from.build(deps),
-      ({ service: mid, release: releaseMid }) => asyncFold(
-        to.build(mid),
-        (error) => asyncFlatMap(releaseMid(), () => asyncFail(error)),
-        ({ service: out, release: releaseOut }) => asyncSucceed({
-          service: out,
-          release: () => asyncFlatMap(releaseOut(), () => releaseMid())
-        })
-      )
-    )
-  };
-}
-function merge(left, right) {
-  return {
-    _tag: "Layer",
-    buildScoped: (deps, scope) => asyncFlatMap(
-      scope.get(left, deps),
-      (a) => asyncFlatMap(
-        scope.get(right, deps),
-        (b) => asyncSucceed(mergeServices(a, b))
-      )
-    ),
-    build: (deps) => asyncFlatMap(
-      left.build(deps),
-      ({ service: a, release: releaseA }) => asyncFold(
-        right.build(deps),
-        (error) => asyncFlatMap(releaseA(), () => asyncFail(error)),
-        ({ service: b, release: releaseB }) => asyncSucceed({
-          service: mergeServices(a, b),
-          release: () => asyncFlatMap(releaseB(), () => releaseA())
-        })
-      )
-    )
-  };
-}
-function mapLayer(l, f) {
-  return {
-    _tag: "Layer",
-    buildScoped: (deps, scope) => asyncFlatMap(
-      scope.get(l, deps),
-      (service) => asyncSucceed(f(service))
-    ),
-    build: (deps) => asyncFlatMap(
-      l.build(deps),
-      ({ service, release }) => asyncSucceed({ service: f(service), release })
+// src/core/runtime/configLayer.ts
+function makeConfigLayer(tag, schema, source, options = {}) {
+  return layerEffect(
+    tag,
+    (context) => asyncSync(
+      () => parseConfig(options.name ?? tag.name, schema, readConfigSource(source, context))
     )
-  };
-}
-function buildLayer(l, deps) {
-  const scope = makeLayerScope();
-  return asyncFold(
-    scope.get(l, deps),
-    (error) => asyncFlatMap(scope.close(), () => asyncFail(error)),
-    (service) => asyncSucceed({
-      service,
-      scope,
-      close: scope.close,
-      use: (body) => body(service)
-    })
   );
 }
-function provideLayer(l, use, deps) {
-  return asyncFlatMap(
-    buildLayer(l, deps ?? {}),
-    ({ service, close }) => ensuring(
-      use(service),
-      () => close()
-    )
-  );
+var defineConfigLayer = makeConfigLayer;
+function readConfigSource(source, context) {
+  return typeof source === "function" ? source(context) : source;
 }
-function provideLayerContext(l, use, deps = LayerContext.empty()) {
-  return provideLayer(l, use, deps);
-}
-var provide = provideLayer;
-var provideContext = provideLayerContext;
-var Layer = Object.freeze({
-  make: layer,
-  from: layerFrom,
-  succeed: layerSucceed,
-  fail: layerFail,
-  value: layerValue,
-  effect: layerEffect,
-  define: defineLayer,
-  fromContext: layerFromContext,
-  compose,
-  merge,
-  map: mapLayer,
-  provide: provideLayer,
-  provideContext: provideLayerContext,
-  build: buildLayer,
-  scope: makeLayerScope,
-  context: LayerContext.empty,
-  tag: makeServiceTag,
-  service: getService
-});
 
 // src/core/runtime/workerPool.ts
 function makeWorkerPool(config = {}) {
@@ -1586,31 +1330,8 @@ export {
   flakyEffect,
   delayedEffect,
   neverEffect,
-  MissingLayerServiceError,
-  formatLayerError,
-  makeServiceTag,
-  serviceTag,
-  defineService,
-  LayerContext,
-  makeLayerScope,
-  layer,
-  layerValue,
-  layerEffect,
-  layerFromContext,
-  defineLayer,
-  getService,
-  layerFrom,
-  layerSucceed,
-  layerFail,
-  compose,
-  merge,
-  mapLayer,
-  buildLayer,
-  provideLayer,
-  provideLayerContext,
-  provide,
-  provideContext,
-  Layer,
+  makeConfigLayer,
+  defineConfigLayer,
   makeWorkerPool,
   makeTracer,
   consoleJsonLogger,

package/dist/{chunk-FHQGHPMO.mjs → chunk-BC6Q6BCO.mjs}

@@ -2,13 +2,11 @@ import {
   raceWith
 } from "./chunk-B5JD23U7.mjs";
 import {
-  Scope
-} from "./chunk-A2OM6NEH.mjs";
-import {
+  Scope,
   getCurrentFiber,
   unsafeGetCurrentRuntime,
   unsafeRunFoldWithEnv
-} from "./chunk-GYM3LLGS.mjs";
+} from "./chunk-H626ZTDZ.mjs";
 import {
   Cause,
   Exit,

package/dist/{chunk-4P2HHGAX.mjs → chunk-COOW7BJX.mjs}

@@ -2,14 +2,14 @@ import {
   EventBus,
   InMemoryTracer,
   makeMetrics
-} from "./chunk-EJ6BPYVR.mjs";
+} from "./chunk-6V2AWT4R.mjs";
 import {
   Runtime,
   ctxExtend,
   ctxToObject,
   emptyContext,
   getCurrentFiber
-} from "./chunk-GYM3LLGS.mjs";
+} from "./chunk-H626ZTDZ.mjs";
 import {
   asyncFail,
   asyncFlatMap,
@@ -20,7 +20,7 @@ import {
 import {
   Schema,
   parseConfig
-} from "./chunk-DNFJLJMW.mjs";
+} from "./chunk-6MLAZPBL.mjs";
 
 // src/observability/health.ts
 function snapshotRuntimeHealth(options = {}) {
@@ -881,24 +881,25 @@ function normalizeLogAttributes(fields) {
 }
 
 // src/observability/sampling.ts
-var alwaysOnSampler = {
+var TRACE_SAMPLER_RATIO = /* @__PURE__ */ Symbol.for("brass-runtime.traceSampler.ratio");
+var alwaysOnSampler = withRatio({
   shouldSample: () => true
-};
-var alwaysOffSampler = {
+}, 1);
+var alwaysOffSampler = withRatio({
   shouldSample: () => false
-};
+}, 0);
 function ratioSampler(ratio2) {
   const bounded = clampRatio(ratio2);
   if (bounded >= 1) return alwaysOnSampler;
   if (bounded <= 0) return alwaysOffSampler;
-  return {
+  return withRatio({
     shouldSample: (input) => traceRatio(input.traceId) < bounded
-  };
+  }, bounded);
 }
 function makeTraceSampler(options = {}) {
   const fallback = options.sampler ?? ratioSampler(options.ratio ?? 1);
   const rules = options.rules ?? [];
-  return {
+  const sampler = {
     shouldSample(input) {
       for (const rule of rules) {
         if (!samplingRuleMatches(rule, input)) continue;
@@ -908,6 +909,8 @@ function makeTraceSampler(options = {}) {
       return shouldSampleWith(fallback, input);
     }
   };
+  const fallbackRatio = samplerRatio(fallback);
+  return rules.length === 0 && fallbackRatio !== void 0 ? withRatio(sampler, fallbackRatio) : sampler;
 }
 function resolveTraceSampling(config) {
   if (config === false) {
@@ -942,6 +945,22 @@ function matchText(pattern, value) {
 function isTraceSampler(value) {
   return typeof value === "function" || typeof value === "object" && value !== null && typeof value.shouldSample === "function";
 }
+function samplerRatio(sampler) {
+  if (!sampler || typeof sampler === "function") return void 0;
+  const ratio2 = sampler[TRACE_SAMPLER_RATIO];
+  return typeof ratio2 === "number" && Number.isFinite(ratio2) ? ratio2 : void 0;
+}
+function withRatio(sampler, ratio2) {
+  try {
+    Object.defineProperty(sampler, TRACE_SAMPLER_RATIO, {
+      configurable: false,
+      enumerable: false,
+      value: ratio2
+    });
+  } catch {
+  }
+  return sampler;
+}
 function traceRatio(traceId) {
   const normalized = normalizeTraceId(traceId);
   const head = normalized.slice(0, 8);
@@ -1538,7 +1557,9 @@ var httpObservabilityOptions = Schema.object({
     Schema.literal(false),
     Schema.object({
       name: Schema.union([Schema.string({ minLength: 1 }), fn]).optional(),
-      attributes: Schema.union([object, fn]).optional()
+      attributes: Schema.union([object, fn]).optional(),
+      events: Schema.boolean().optional(),
+      sampleRate: ratio.optional()
     }, { unknownKeys: "passthrough" })
   ]).optional(),
   adaptiveLimiter: Schema.union([