brass-runtime 1.17.0 → 1.18.1

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-YWLLH27R.mjs

@@ -0,0 +1,33 @@
+import {
+  layerEffect,
+  makeServiceTag
+} from "./chunk-EEN5OTCR.mjs";
+import {
+  Runtime
+} from "./chunk-H626ZTDZ.mjs";
+import {
+  asyncSync
+} from "./chunk-36I3M4UC.mjs";
+
+// 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-BKK77SBA.js → chunk-YZ5LQ32F.js}

@@ -2,14 +2,14 @@ import {
   EventBus,
   InMemoryTracer,
   makeMetrics
-} from "./chunk-RKGKFN2A.js";
+} from "./chunk-OW5VHAOE.js";
 import {
   Runtime,
   ctxExtend,
   ctxToObject,
   emptyContext,
   getCurrentFiber
-} from "./chunk-FH2X7BVP.js";
+} from "./chunk-TTSPIU3U.js";
 import {
   asyncFail,
   asyncFlatMap,
@@ -20,7 +20,7 @@ import {
 import {
   Schema,
   parseConfig
-} from "./chunk-C3MDXTRZ.js";
+} from "./chunk-HCJ4S3YB.js";
 
 // 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([