brass-runtime 1.16.0 → 1.17.0

package/dist/perf/index.mjs

@@ -0,0 +1,141 @@
+import {
+  HTTP_PROFILE_VARIANTS,
+  captureMemorySnapshot,
+  comparePerfToBaseline,
+  compareRuntimeProfiles,
+  createPerfHistoryEntry,
+  defaultPerfHistoryDirectory,
+  diagnoseRuntimeProfile,
+  diffMemorySnapshots,
+  extractPerfMetrics,
+  forceGc,
+  formatHttpMemoryLabReport,
+  formatPerfBaselineComparison,
+  formatPerformanceReport,
+  formatRuntimeAbReport,
+  formatRuntimeSoakReport,
+  hasGc,
+  loadPerfBaseline,
+  makePerfRecorder,
+  profileHttpLayers,
+  profileHttpMemoryLab,
+  profileMemoryRetention,
+  profileRuntimeAb,
+  profileRuntimePrimitives,
+  profileRuntimeSoak,
+  readPerfHistory,
+  recommendPerformance,
+  recordPerfHistoryRun,
+  runBrassPerformanceProfile,
+  savePerfBaseline,
+  summarizePerfEvents,
+  writePerfHistoryEntry
+} from "../chunk-6RY2FFN4.mjs";
+import "../chunk-EOC4UHBS.mjs";
+import "../chunk-7CMJS3QE.mjs";
+import "../chunk-5VRJNBLZ.mjs";
+import "../chunk-MOO4L7F4.mjs";
+import "../chunk-FHQGHPMO.mjs";
+import "../chunk-B5JD23U7.mjs";
+import "../chunk-2HQTDLHF.mjs";
+import "../chunk-A2OM6NEH.mjs";
+import "../chunk-SK7UZRNI.mjs";
+import "../chunk-4P2HHGAX.mjs";
+import "../chunk-EJ6BPYVR.mjs";
+import "../chunk-PWC3RBQE.mjs";
+import "../chunk-GYM3LLGS.mjs";
+import "../chunk-36I3M4UC.mjs";
+import "../chunk-DNFJLJMW.mjs";
+import "../chunk-Y6FXYEAI.mjs";
+
+// src/perf/budget.ts
+async function runRuntimePerfBudget(options = {}) {
+  const ab = await profileRuntimeAb({
+    ...options,
+    thresholds: {
+      maxRegressionPercent: options.thresholds?.maxRegressionPercent ?? 50,
+      minSignificantDeltaPercent: options.thresholds?.minSignificantDeltaPercent ?? 5
+    }
+  });
+  const minOpsPerSecond = positiveNumber(options.minOpsPerSecond, 1e4);
+  const maxHeapDeltaMb = positiveNumber(options.maxHeapDeltaMb, 32);
+  const violations = [];
+  for (const violation of ab.budgetViolations) {
+    violations.push({ area: "regression", message: violation });
+  }
+  for (const result of ab.candidate.results) {
+    if (result.units >= 1e3 && result.operationsPerSecond < minOpsPerSecond) {
+      violations.push({
+        area: "throughput",
+        message: `${result.name} throughput ${result.operationsPerSecond} ops/s is below ${minOpsPerSecond} ops/s`
+      });
+    }
+  }
+  if (ab.memory.delta.heapUsedMb > maxHeapDeltaMb) {
+    violations.push({
+      area: "memory",
+      message: `runtime A/B heap delta ${ab.memory.delta.heapUsedMb}MB exceeds ${maxHeapDeltaMb}MB`
+    });
+  }
+  return Object.freeze({
+    ab,
+    passed: violations.length === 0,
+    violations: Object.freeze(violations.map((item) => Object.freeze(item)))
+  });
+}
+function formatRuntimePerfBudgetReport(report) {
+  const lines = [];
+  lines.push(`Runtime performance budget: ${report.passed ? "pass" : "fail"}`);
+  lines.push(`baseline=${report.ab.baselineVariant} candidate=${report.ab.candidateVariant}`);
+  for (const comparison of report.ab.comparisons) {
+    const sign = comparison.deltaPercent >= 0 ? "+" : "";
+    lines.push(`- ${comparison.primitive}: ${sign}${comparison.deltaPercent}%`);
+  }
+  if (report.violations.length > 0) {
+    lines.push("");
+    lines.push("Violations");
+    for (const violation of report.violations) {
+      lines.push(`- [${violation.area}] ${violation.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+function positiveNumber(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, value);
+}
+export {
+  HTTP_PROFILE_VARIANTS,
+  captureMemorySnapshot,
+  comparePerfToBaseline,
+  compareRuntimeProfiles,
+  createPerfHistoryEntry,
+  defaultPerfHistoryDirectory,
+  diagnoseRuntimeProfile,
+  diffMemorySnapshots,
+  extractPerfMetrics,
+  forceGc,
+  formatHttpMemoryLabReport,
+  formatPerfBaselineComparison,
+  formatPerformanceReport,
+  formatRuntimeAbReport,
+  formatRuntimePerfBudgetReport,
+  formatRuntimeSoakReport,
+  hasGc,
+  loadPerfBaseline,
+  makePerfRecorder,
+  profileHttpLayers,
+  profileHttpMemoryLab,
+  profileMemoryRetention,
+  profileRuntimeAb,
+  profileRuntimePrimitives,
+  profileRuntimeSoak,
+  readPerfHistory,
+  recommendPerformance,
+  recordPerfHistoryRun,
+  runBrassPerformanceProfile,
+  runRuntimePerfBudget,
+  savePerfBaseline,
+  summarizePerfEvents,
+  writePerfHistoryEntry
+};

package/dist/schedule-CK3Ml_7p.d.ts

@@ -0,0 +1,259 @@
+import { A as Async, R as RuntimeHooks, a as RuntimeEmitContext } from './effect-DIUHZ9IN.js';
+
+type CircuitBreakerState = "closed" | "open" | "half-open";
+type CircuitBreakerError = {
+    readonly _tag: "CircuitBreakerOpen";
+    readonly openSince: number;
+    readonly failures: number;
+};
+type CircuitBreakerConfig = {
+    /** Number of consecutive failures before opening the circuit. Default: 5 */
+    readonly failureThreshold?: number;
+    /** Time in ms to wait before transitioning from OPEN to HALF_OPEN. Default: 30000 */
+    readonly resetTimeoutMs?: number;
+    /** Number of successes in HALF_OPEN needed to close the circuit. Default: 1 */
+    readonly successThreshold?: number;
+    /** Custom predicate: should this error count as a failure? Default: all errors count. */
+    readonly isFailure?: (error: unknown) => boolean;
+    /** Called on state transitions (for observability). */
+    readonly onStateChange?: (from: CircuitBreakerState, to: CircuitBreakerState) => void;
+};
+type CircuitBreakerStats = {
+    readonly state: CircuitBreakerState;
+    readonly failures: number;
+    readonly successes: number;
+    readonly totalRequests: number;
+    readonly totalFailures: number;
+    readonly totalSuccesses: number;
+    readonly totalRejected: number;
+    readonly lastFailureTime: number | null;
+    readonly lastSuccessTime: number | null;
+};
+type CircuitBreaker = {
+    /** Current state of the circuit breaker. */
+    readonly state: () => CircuitBreakerState;
+    /** Run an effect through the circuit breaker. */
+    readonly protect: <R, E, A>(effect: Async<R, E, A>) => Async<R, E | CircuitBreakerError, A>;
+    /** Get current stats. */
+    readonly stats: () => CircuitBreakerStats;
+    /** Manually reset to closed state. */
+    readonly reset: () => void;
+};
+/**
+ * Creates a circuit breaker.
+ *
+ * ```ts
+ * const breaker = makeCircuitBreaker({ failureThreshold: 3, resetTimeoutMs: 10000 });
+ *
+ * // Protect an effect:
+ * const result = await run(breaker.protect(callExternalService()));
+ * // Throws CircuitBreakerOpen if circuit is open
+ * ```
+ */
+declare function makeCircuitBreaker(config?: CircuitBreakerConfig): CircuitBreaker;
+
+type RuntimeTimerId = unknown;
+type RuntimeClock = {
+    readonly now: () => number;
+    readonly setTimeout: (task: () => void, ms: number) => RuntimeTimerId;
+    readonly clearTimeout: (timer: RuntimeTimerId) => void;
+};
+type RuntimeClockEnv = {
+    readonly brass?: {
+        readonly clock?: RuntimeClock;
+    };
+};
+declare const liveClock: RuntimeClock;
+declare function runtimeClockFromEnv(env: unknown): RuntimeClock;
+
+type ScheduleDecision = {
+    readonly continue: boolean;
+    readonly delayMs: number;
+    readonly attempt?: number;
+    readonly elapsedMs?: number;
+    readonly reason?: string;
+    readonly name?: string;
+};
+type ScheduleJitterOptions = {
+    /** 1 means full jitter in [0, delay], 0.2 means +/-20% around delay. */
+    readonly factor?: number;
+    /** Deterministic hook for tests. Defaults to Math.random. */
+    readonly random?: () => number;
+};
+type ScheduleStepContext = {
+    readonly clock: RuntimeClock;
+    readonly startedAtMs: number;
+    readonly attempt: number;
+    readonly name?: string;
+};
+type ScheduleObserverEvent<I, O> = {
+    readonly name?: string;
+    readonly input: I;
+    readonly output: O;
+    readonly decision: ScheduleDecision;
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly state: unknown;
+    readonly nextState: unknown;
+    readonly timestamp: number;
+};
+type ScheduleObserver<I, O> = (event: ScheduleObserverEvent<I, O>) => void;
+type ScheduleDriverDecision<O> = {
+    readonly continue: boolean;
+    readonly delayMs: number;
+    readonly output: O;
+    readonly decision: ScheduleDecision;
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly state: unknown;
+};
+type ScheduleDriverSnapshot<O = unknown> = {
+    readonly name?: string;
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly state: unknown;
+    readonly last?: ScheduleDriverDecision<O>;
+};
+type ScheduleDriverOptions<I = unknown, O = unknown> = {
+    readonly name?: string;
+    readonly clock?: RuntimeClock;
+    readonly startedAtMs?: number;
+    readonly onDecision?: ScheduleObserver<I, O>;
+    readonly hooks?: RuntimeHooks;
+    readonly emitContext?: RuntimeEmitContext;
+    readonly captureInput?: boolean;
+    readonly captureOutput?: boolean;
+};
+type ScheduleDriver<I, O> = {
+    readonly next: (input: I) => ScheduleDriverDecision<O>;
+    readonly reset: () => void;
+    readonly snapshot: () => ScheduleDriverSnapshot<O>;
+    readonly state: () => unknown;
+    readonly last: () => ScheduleDriverDecision<O> | undefined;
+};
+/** Retry/repeat up to N times with no delay. */
+declare function recurs(n: number): Schedule<unknown, number>;
+/** Continue forever with no delay. */
+declare function forever(): Schedule<unknown, number>;
+/** Never continue. */
+declare function never(): Schedule<unknown, number>;
+/** Continue exactly once. */
+declare function once(): Schedule<unknown, number>;
+/** Fixed delay between each retry/repeat. */
+declare function fixed(delayMs: number): Schedule<unknown, number>;
+/** Alias for fixed delay schedules. */
+declare const spaced: typeof fixed;
+/** Exponential backoff: delay doubles each time, capped at maxDelayMs. */
+declare function exponential(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Linear backoff: base, 2*base, 3*base... capped at maxDelayMs. */
+declare function linear(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Fibonacci backoff: base, base, 2*base, 3*base, 5*base, capped at maxDelayMs. */
+declare function fibonacci(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Exponential backoff with full jitter (random in [0, delay]). */
+declare function jittered(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Stop after a total elapsed time. */
+declare function elapsed(maxMs: number): Schedule<unknown, number>;
+/** Only continue while a predicate holds on the input. */
+declare function whileInput<I>(pred: (input: I) => boolean): Schedule<I, I>;
+/** Continue until the input predicate becomes true. */
+declare function untilInput<I>(pred: (input: I) => boolean): Schedule<I, I>;
+/** Limit a schedule to N repetitions. */
+declare function take<I, O>(schedule: Schedule<I, O>, n: number): Schedule<I, O>;
+/** Transform schedule output while preserving decisions and state. */
+declare function map<I, O, O2>(schedule: Schedule<I, O>, f: (output: O) => O2): Schedule<I, O2>;
+/** Transform schedule input before it reaches the wrapped schedule. */
+declare function contramap<I0, I, O>(schedule: Schedule<I, O>, f: (input: I0) => I): Schedule<I0, O>;
+/** Add jitter to any schedule's delay. */
+declare function jitteredSchedule<I, O>(schedule: Schedule<I, O>, options?: number | ScheduleJitterOptions): Schedule<I, O>;
+declare const jitter: typeof jitteredSchedule;
+/**
+ * Reset a schedule's internal state after a rolling time window.
+ * Useful for retry/polling policies that should forgive old bursts.
+ */
+declare function windowed<I, O>(schedule: Schedule<I, O>, windowMs: number, clock?: () => number): Schedule<I, O>;
+/** Cap a schedule's delay without changing its state or output. */
+declare function maxDelay<I, O>(schedule: Schedule<I, O>, maxMs: number): Schedule<I, O>;
+/** Stop a schedule after a total elapsed runtime-clock budget. */
+declare function maxElapsed<I, O>(schedule: Schedule<I, O>, maxMs: number): Schedule<I, O>;
+declare const upTo: typeof maxElapsed;
+/** Continue while a predicate holds on the wrapped schedule output. */
+declare function whileOutput<I, O>(schedule: Schedule<I, O>, pred: (output: O) => boolean): Schedule<I, O>;
+/** Continue until a predicate holds on the wrapped schedule output. */
+declare function untilOutput<I, O>(schedule: Schedule<I, O>, pred: (output: O) => boolean): Schedule<I, O>;
+/** Attach an observability name to a schedule. */
+declare function named<I, O>(name: string, schedule: Schedule<I, O>): Schedule<I, O>;
+/** Observe each schedule decision without changing semantics. */
+declare function tapDecision<I, O>(schedule: Schedule<I, O>, tap: ScheduleObserver<I, O>): Schedule<I, O>;
+/** Compose two schedules: use the first, then switch to the second. */
+declare function andThen<I, O1, O2>(first: Schedule<I, O1>, second: Schedule<I, O2>): Schedule<I, O1 | O2>;
+/** Run both schedules and continue while BOTH say continue. Use max delay. */
+declare function intersect<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
+/** Run both schedules and continue while EITHER says continue. Use min delay. */
+declare function union<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
+declare function makeScheduleDriver<I, O>(schedule: Schedule<I, O>, options?: ScheduleDriverOptions<I, O>): ScheduleDriver<I, O>;
+declare const scheduleDriver: typeof makeScheduleDriver;
+declare function runSchedule<I, O>(schedule: Schedule<I, O>, inputs: Iterable<I>, options?: ScheduleDriverOptions<I, O>): ScheduleDriverDecision<O>[];
+/**
+ * Retry an effect according to a schedule.
+ * The schedule receives the error as input on each failure.
+ */
+declare function retryWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<E, O>, options?: ScheduleDriverOptions<E, O>): Async<R, E, A>;
+declare const retry: typeof retryWithSchedule;
+/**
+ * Repeat an effect according to a schedule.
+ * The schedule receives the success value as input on each iteration.
+ * Returns the last successful value.
+ */
+declare function repeatWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<A, O>, options?: ScheduleDriverOptions<A, O>): Async<R, E, A>;
+declare const repeat: typeof repeatWithSchedule;
+declare const poll: typeof repeatWithSchedule;
+/**
+ * A Schedule<I, O> takes an input I (typically the error or output of an effect)
+ * and decides whether to continue and with what delay.
+ */
+type Schedule<I, O> = {
+    readonly _tag: "Schedule";
+    readonly name?: string;
+    /** Initial state */
+    readonly initial: (context?: ScheduleStepContext) => any;
+    /** Given current state and input, produce a decision and next state */
+    readonly step: (state: any, input: I, context?: ScheduleStepContext) => [ScheduleDecision, any, O];
+};
+declare const Schedule: Readonly<{
+    driver: typeof makeScheduleDriver;
+    run: typeof runSchedule;
+    recurs: typeof recurs;
+    forever: typeof forever;
+    never: typeof never;
+    once: typeof once;
+    fixed: typeof fixed;
+    spaced: typeof fixed;
+    linear: typeof linear;
+    exponential: typeof exponential;
+    fibonacci: typeof fibonacci;
+    jittered: typeof jittered;
+    jitteredSchedule: typeof jitteredSchedule;
+    jitter: typeof jitteredSchedule;
+    elapsed: typeof elapsed;
+    whileInput: typeof whileInput;
+    untilInput: typeof untilInput;
+    whileOutput: typeof whileOutput;
+    untilOutput: typeof untilOutput;
+    take: typeof take;
+    map: typeof map;
+    contramap: typeof contramap;
+    maxDelay: typeof maxDelay;
+    maxElapsed: typeof maxElapsed;
+    upTo: typeof maxElapsed;
+    windowed: typeof windowed;
+    named: typeof named;
+    tapDecision: typeof tapDecision;
+    andThen: typeof andThen;
+    intersect: typeof intersect;
+    union: typeof union;
+    retry: typeof retryWithSchedule;
+    repeat: typeof repeatWithSchedule;
+    poll: typeof repeatWithSchedule;
+}>;
+
+export { upTo as $, liveClock as A, makeCircuitBreaker as B, type CircuitBreakerError as C, makeScheduleDriver as D, map as E, maxDelay as F, maxElapsed as G, named as H, never as I, once as J, poll as K, recurs as L, repeatWithSchedule as M, repeat as N, retryWithSchedule as O, retry as P, runSchedule as Q, type RuntimeClock as R, Schedule as S, runtimeClockFromEnv as T, scheduleDriver as U, spaced as V, take as W, tapDecision as X, union as Y, untilInput as Z, untilOutput as _, type ScheduleObserver as a, whileInput as a0, whileOutput as a1, windowed as a2, type CircuitBreakerStats as b, type CircuitBreaker as c, type CircuitBreakerConfig as d, type CircuitBreakerState as e, type RuntimeClockEnv as f, type RuntimeTimerId as g, type ScheduleDecision as h, type ScheduleDriver as i, type ScheduleDriverDecision as j, type ScheduleDriverOptions as k, type ScheduleDriverSnapshot as l, type ScheduleObserverEvent as m, type ScheduleStepContext as n, andThen as o, contramap as p, elapsed as q, exponential as r, fibonacci as s, fixed as t, forever as u, intersect as v, jitter as w, jittered as x, jitteredSchedule as y, linear as z };

package/dist/schema/index.cjs

@@ -9,7 +9,9 @@
 
 
 
-var _chunkSPUEME2Bcjs = require('../chunk-SPUEME2B.cjs');
+
+
+var _chunkCZIVE6NTcjs = require('../chunk-CZIVE6NT.cjs');
 require('../chunk-OBGZSXTJ.cjs');
 
 
@@ -22,4 +24,6 @@ require('../chunk-OBGZSXTJ.cjs');
 
 
 
-exports.ConfigValidationError = _chunkSPUEME2Bcjs.ConfigValidationError; exports.Schema = _chunkSPUEME2Bcjs.Schema; exports.SchemaValidationException = _chunkSPUEME2Bcjs.SchemaValidationException; exports.formatIssues = _chunkSPUEME2Bcjs.formatIssues; exports.isSchema = _chunkSPUEME2Bcjs.isSchema; exports.makeSchemaIssue = _chunkSPUEME2Bcjs.makeSchemaIssue; exports.parseConfig = _chunkSPUEME2Bcjs.parseConfig; exports.s = _chunkSPUEME2Bcjs.s; exports.schema = _chunkSPUEME2Bcjs.schema; exports.validateValue = _chunkSPUEME2Bcjs.validateValue;
+
+
+exports.ConfigValidationError = _chunkCZIVE6NTcjs.ConfigValidationError; exports.Schema = _chunkCZIVE6NTcjs.Schema; exports.SchemaValidationException = _chunkCZIVE6NTcjs.SchemaValidationException; exports.formatConfigError = _chunkCZIVE6NTcjs.formatConfigError; exports.formatIssues = _chunkCZIVE6NTcjs.formatIssues; exports.isConfigValidationError = _chunkCZIVE6NTcjs.isConfigValidationError; exports.isSchema = _chunkCZIVE6NTcjs.isSchema; exports.makeSchemaIssue = _chunkCZIVE6NTcjs.makeSchemaIssue; exports.parseConfig = _chunkCZIVE6NTcjs.parseConfig; exports.s = _chunkCZIVE6NTcjs.s; exports.schema = _chunkCZIVE6NTcjs.schema; exports.validateValue = _chunkCZIVE6NTcjs.validateValue;

package/dist/schema/index.d.ts

@@ -66,6 +66,8 @@ declare class ConfigValidationError extends Error {
     readonly issues: readonly SchemaIssue[];
     constructor(configName: string, issues: readonly SchemaIssue[]);
 }
+declare function isConfigValidationError(error: unknown): error is ConfigValidationError;
+declare function formatConfigError(error: unknown): string;
 declare const makeSchemaIssue: (path: readonly SchemaPathPart[], expected: string, received: unknown, message?: string) => SchemaIssue;
 declare function formatIssues(issues: readonly SchemaIssue[]): string;
 declare function stringSchema(options?: StringSchemaOptions): Schema<string>;
@@ -174,4 +176,4 @@ declare function isSchema(value: unknown): value is AnySchema;
 declare function validateValue<A>(data: unknown, validator: JsonSchemaLike<A>): SchemaResult<A>;
 declare function parseConfig<A>(configName: string, validator: JsonSchemaLike<A>, value: unknown): A;
 
-export { type AnyJsonSchemaLike, type AnySchema, ConfigValidationError, type InferJsonSchema, type InferObject, type InferSchema, type JsonSchemaLike, type JsonValidator, type JsonValidatorResult, type NumberSchemaOptions, type ObjectSchemaOptions, Schema, type SchemaIssue, type SchemaPathPart, type SchemaResult, type SchemaShape, SchemaValidationException, type StringSchemaOptions, formatIssues, isSchema, makeSchemaIssue, parseConfig, s, schema, validateValue };
+export { type AnyJsonSchemaLike, type AnySchema, ConfigValidationError, type InferJsonSchema, type InferObject, type InferSchema, type JsonSchemaLike, type JsonValidator, type JsonValidatorResult, type NumberSchemaOptions, type ObjectSchemaOptions, Schema, type SchemaIssue, type SchemaPathPart, type SchemaResult, type SchemaShape, SchemaValidationException, type StringSchemaOptions, formatConfigError, formatIssues, isConfigValidationError, isSchema, makeSchemaIssue, parseConfig, s, schema, validateValue };

package/dist/schema/index.js

@@ -2,20 +2,24 @@ import {
   ConfigValidationError,
   Schema,
   SchemaValidationException,
+  formatConfigError,
   formatIssues,
+  isConfigValidationError,
   isSchema,
   makeSchemaIssue,
   parseConfig,
   s,
   schema,
   validateValue
-} from "../chunk-TDVMADDN.js";
+} from "../chunk-C3MDXTRZ.js";
 import "../chunk-3RG5ZIWI.js";
 export {
   ConfigValidationError,
   Schema,
   SchemaValidationException,
+  formatConfigError,
   formatIssues,
+  isConfigValidationError,
   isSchema,
   makeSchemaIssue,
   parseConfig,

package/dist/schema/index.mjs

@@ -2,20 +2,24 @@ import {
   ConfigValidationError,
   Schema,
   SchemaValidationException,
+  formatConfigError,
   formatIssues,
+  isConfigValidationError,
   isSchema,
   makeSchemaIssue,
   parseConfig,
   s,
   schema,
   validateValue
-} from "../chunk-U5KWK3PX.mjs";
+} from "../chunk-DNFJLJMW.mjs";
 import "../chunk-Y6FXYEAI.mjs";
 export {
   ConfigValidationError,
   Schema,
   SchemaValidationException,
+  formatConfigError,
   formatIssues,
+  isConfigValidationError,
   isSchema,
   makeSchemaIssue,
   parseConfig,

package/dist/{server-C8hDXA74.d.ts → server-D6JZ15_e.d.ts}

@@ -1,6 +1,7 @@
-import { a as MetricExemplar, b as MetricSnapshot, M as MetricsRegistry, T as TraceSampler, c as TraceSamplingInput, C as CircuitBreakerStats, E as EventBus, B as BrassEnv, I as InMemoryTracer, d as Tracer, R as RuntimeSpan, e as InMemoryTracerOptions } from './tracer-B5tRH9H7.js';
-import { T as TraceContext, R as RuntimeHooks, A as Async, J as JSONValue, B as Baggage, f as Runtime, g as RuntimeRegistry, h as RuntimeOptions } from './effect-CGNl5Rqp.js';
-import { A as AdaptiveLimiterStats } from './client-CtFmoDvM.js';
+import { a as MetricExemplar, b as MetricSnapshot, M as MetricsRegistry, T as TraceSampler, c as TraceSamplingInput, E as EventBus, B as BrassEnv, I as InMemoryTracer, d as Tracer, R as RuntimeSpan, e as InMemoryTracerOptions } from './tracer-Hwt1cl7h.js';
+import { T as TraceContext, R as RuntimeHooks, A as Async, J as JSONValue, B as Baggage, f as Runtime, g as RuntimeRegistry, h as RuntimeOptions } from './effect-DIUHZ9IN.js';
+import { b as CircuitBreakerStats } from './schedule-CK3Ml_7p.js';
+import { A as AdaptiveLimiterStats } from './client-CZHU674n.js';
 
 declare const PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
 declare const OTLP_JSON_CONTENT_TYPE = "application/json";
@@ -411,6 +412,17 @@ type ObservabilityOtlpOptions = {
     readonly retry?: ExportRetryOptions;
     readonly pipeline?: ExportPipelineTuning;
 };
+type ObservabilityOtlpSignal = "metrics" | "traces" | "logs";
+type MakeOtlpOptionsInput = {
+    readonly endpoint: string;
+    readonly headers?: ObservabilityOtlpOptions["headers"];
+    readonly fetch?: ObservabilityOtlpOptions["fetch"];
+    readonly timeoutMs?: ObservabilityOtlpOptions["timeoutMs"];
+    readonly retry?: ObservabilityOtlpOptions["retry"];
+    readonly pipeline?: ObservabilityOtlpOptions["pipeline"];
+    readonly signals?: readonly ObservabilityOtlpSignal[];
+};
+declare function makeOtlpOptions(input: MakeOtlpOptionsInput): ObservabilityOtlpOptions;
 type ObservabilityOptions = {
     readonly serviceName?: string;
     readonly serviceVersion?: string;
@@ -671,4 +683,4 @@ type ObservedHttpServerResult<A> = {
 declare function runObservedHttpServerEffect<R extends object = {}, E = never, A = never>(observability: Observability, input: RequestObservabilityContextInput, effect: Async<R, E, A>, options?: HttpServerObservabilityOptions<A>, env?: R, runtimeOptions?: RequestObservabilityRuntimeOptions<R>): Promise<ObservedHttpServerResult<A>>;
 declare function observeHttpServerRequest<A>(observability: Observability, input: RequestObservabilityContextInput, handler: (ctx: RequestObservabilityContext) => Promise<A>, options?: HttpServerObservabilityOptions<A>): Promise<ObservedHttpServerResult<A>>;
 
-export { type RuntimeMetricsSinkOptions as $, type ObservabilityRuntimeEnv as A, type ObservabilityTraceExportResult as B, type CardinalityConfig as C, type ObservedHttpServerResult as D, type ExportBatchResult as E, type OtlpAttributeValue as F, type OtlpExportOptions as G, type HealthCheck as H, type InjectTraceContextOptions as I, type OtlpFetch as J, type OtlpHttpExportResult as K, type LogLevel as L, type OtlpHttpExporterOptions as M, type OtlpHttpResponse as N, type Observability as O, PROMETHEUS_CONTENT_TYPE as P, type PrometheusMetricsExporter as Q, type RequestObservabilityContextInput as R, type SpanAttributes as S, type TraceContextCarrier as T, type PrometheusMetricsOptions as U, type RedactionConfig as V, type RedactionOptions as W, type RequestObservabilityRuntimeOptions as X, type ResolvedTraceSampling as Y, type RuntimeHealthOptions as Z, type RuntimeHealthReport as _, type RequestObservabilityContext as a, toOtlpAttributes as a$, type SpanLink as a0, type SpanOptions as a1, type SpanSource as a2, type StructuredLogRecord as a3, type StructuredLogSinkOptions as a4, type StructuredLogSource as a5, type TraceContextHeaderValue as a6, type TraceSamplingConfig as a7, type TraceSamplingOptions as a8, type TraceSamplingRule as a9, makeRuntimeHealth as aA, makeRuntimeMetricsSink as aB, makeStructuredLogSink as aC, makeTraceSampler as aD, metricsSnapshotToOtlp as aE, normalizeHttpRoute as aF, normalizeSpanId as aG, normalizeTraceId as aH, observeHttpServerRequest as aI, otlpAnyValue as aJ, parseBaggage as aK, parseTraceparent as aL, postOtlpJson as aM, ratioSampler as aN, readiness as aO, resolveRequestBaggage as aP, resolveRequestTraceSeed as aQ, resolveTraceSampling as aR, runObservedHttpServerEffect as aS, runtimeHealth as aT, sanitizeHttpTarget as aU, shouldSampleWith as aV, snapshotRuntimeHealth as aW, spanEvent as aX, spanLink as aY, spansToOtlp as aZ, structuredLogsToOtlp as a_, alwaysOffSampler as aa, alwaysOnSampler as ab, currentBaggage as ac, currentSpanLink as ad, defaultStructuredLogWriter as ae, exemplarFromTraceContext as af, exportWithRetry as ag, extractBaggage as ah, extractTraceContext as ai, formatBaggage as aj, formatPrometheusMetrics as ak, formatStructuredLog as al, formatTraceparent as am, healthToHttpResponse as an, injectBaggage as ao, injectTraceContext as ap, logEffect as aq, makeCardinalityLimitedMetrics as ar, makeExportPipeline as as, makeObservability as at, makeObservabilityRedactor as au, makeOtlpHttpLogExporter as av, makeOtlpHttpMetricsExporter as aw, makeOtlpHttpSpanExporter as ax, makePrometheusMetricsExporter as ay, makeRequestObservabilityContext as az, type ObservabilityOptions as b, unixNanoFromMs as b0, withBaggage as b1, withLogContext as b2, withSpan as b3, withTimeout as b4, type CardinalityLimiterOptions as c, type ExportPipeline as d, type ExportPipelineFlushOptions as e, type ExportPipelineFlushResult as f, type ExportPipelineOptions as g, type ExportPipelineStats as h, type ExportPipelineTuning as i, type ExportRetryOptions as j, type ExportSignal as k, type HealthCheckResult as l, type HealthHttpResponse as m, type HealthStatus as n, type HttpServerObservabilityLogOptions as o, type HttpServerObservabilityOptions as p, type HttpServerObservabilitySpanOptions as q, type HttpServerOutcome as r, OTLP_JSON_CONTENT_TYPE as s, type ObservabilityExporters as t, type ObservabilityFlushError as u, type ObservabilityFlushResult as v, type ObservabilityLogExportResult as w, type ObservabilityOtlpOptions as x, type ObservabilityRedactor as y, type ObservabilityRequestEnvInput as z };
+export { type RuntimeHealthOptions as $, type ObservabilityRequestEnvInput as A, type ObservabilityRuntimeEnv as B, type CardinalityConfig as C, type ObservabilityTraceExportResult as D, type ExportBatchResult as E, type ObservedHttpServerResult as F, type OtlpAttributeValue as G, type HealthCheck as H, type InjectTraceContextOptions as I, type OtlpExportOptions as J, type OtlpFetch as K, type LogLevel as L, type MakeOtlpOptionsInput as M, type OtlpHttpExportResult as N, type Observability as O, type OtlpHttpExporterOptions as P, type OtlpHttpResponse as Q, type RequestObservabilityContextInput as R, type SpanAttributes as S, type TraceContextCarrier as T, PROMETHEUS_CONTENT_TYPE as U, type PrometheusMetricsExporter as V, type PrometheusMetricsOptions as W, type RedactionConfig as X, type RedactionOptions as Y, type RequestObservabilityRuntimeOptions as Z, type ResolvedTraceSampling as _, type RequestObservabilityContext as a, spanLink as a$, type RuntimeHealthReport as a0, type RuntimeMetricsSinkOptions as a1, type SpanLink as a2, type SpanOptions as a3, type SpanSource as a4, type StructuredLogRecord as a5, type StructuredLogSinkOptions as a6, type StructuredLogSource as a7, type TraceContextHeaderValue as a8, type TraceSamplingConfig as a9, makeOtlpOptions as aA, makePrometheusMetricsExporter as aB, makeRequestObservabilityContext as aC, makeRuntimeHealth as aD, makeRuntimeMetricsSink as aE, makeStructuredLogSink as aF, makeTraceSampler as aG, metricsSnapshotToOtlp as aH, normalizeHttpRoute as aI, normalizeSpanId as aJ, normalizeTraceId as aK, observeHttpServerRequest as aL, otlpAnyValue as aM, parseBaggage as aN, parseTraceparent as aO, postOtlpJson as aP, ratioSampler as aQ, readiness as aR, resolveRequestBaggage as aS, resolveRequestTraceSeed as aT, resolveTraceSampling as aU, runObservedHttpServerEffect as aV, runtimeHealth as aW, sanitizeHttpTarget as aX, shouldSampleWith as aY, snapshotRuntimeHealth as aZ, spanEvent as a_, type TraceSamplingOptions as aa, type TraceSamplingRule as ab, alwaysOffSampler as ac, alwaysOnSampler as ad, currentBaggage as ae, currentSpanLink as af, defaultStructuredLogWriter as ag, exemplarFromTraceContext as ah, exportWithRetry as ai, extractBaggage as aj, extractTraceContext as ak, formatBaggage as al, formatPrometheusMetrics as am, formatStructuredLog as an, formatTraceparent as ao, healthToHttpResponse as ap, injectBaggage as aq, injectTraceContext as ar, logEffect as as, makeCardinalityLimitedMetrics as at, makeExportPipeline as au, makeObservability as av, makeObservabilityRedactor as aw, makeOtlpHttpLogExporter as ax, makeOtlpHttpMetricsExporter as ay, makeOtlpHttpSpanExporter as az, type ObservabilityOptions as b, spansToOtlp as b0, structuredLogsToOtlp as b1, toOtlpAttributes as b2, unixNanoFromMs as b3, withBaggage as b4, withLogContext as b5, withSpan as b6, withTimeout as b7, type CardinalityLimiterOptions as c, type ExportPipeline as d, type ExportPipelineFlushOptions as e, type ExportPipelineFlushResult as f, type ExportPipelineOptions as g, type ExportPipelineStats as h, type ExportPipelineTuning as i, type ExportRetryOptions as j, type ExportSignal as k, type HealthCheckResult as l, type HealthHttpResponse as m, type HealthStatus as n, type HttpServerObservabilityLogOptions as o, type HttpServerObservabilityOptions as p, type HttpServerObservabilitySpanOptions as q, type HttpServerOutcome as r, OTLP_JSON_CONTENT_TYPE as s, type ObservabilityExporters as t, type ObservabilityFlushError as u, type ObservabilityFlushResult as v, type ObservabilityLogExportResult as w, type ObservabilityOtlpOptions as x, type ObservabilityOtlpSignal as y, type ObservabilityRedactor as z };

package/dist/{stream-dvSs0QS5.d.ts → stream-B4oK9JFP.d.ts}

@@ -1,4 +1,4 @@
-import { Z as ZIO, O as Option, E as Exit, A as Async } from './effect-CGNl5Rqp.js';
+import { Z as ZIO, O as Option, E as Exit, A as Async } from './effect-DIUHZ9IN.js';
 
 type Empty<R, E, A> = {
     readonly _tag: "Empty";

package/dist/{tracer-B5tRH9H7.d.ts → tracer-Hwt1cl7h.d.ts}

@@ -1,56 +1,5 @@
-import { A as Async, R as RuntimeHooks, a as RingBufferOptions, b as RuntimeEvent, c as RuntimeEmitContext, d as RuntimeEventRecord, e as RuntimeSpanLink, T as TraceContext, B as Baggage } from './effect-CGNl5Rqp.js';
-
-type CircuitBreakerState = "closed" | "open" | "half-open";
-type CircuitBreakerError = {
-    readonly _tag: "CircuitBreakerOpen";
-    readonly openSince: number;
-    readonly failures: number;
-};
-type CircuitBreakerConfig = {
-    /** Number of consecutive failures before opening the circuit. Default: 5 */
-    readonly failureThreshold?: number;
-    /** Time in ms to wait before transitioning from OPEN to HALF_OPEN. Default: 30000 */
-    readonly resetTimeoutMs?: number;
-    /** Number of successes in HALF_OPEN needed to close the circuit. Default: 1 */
-    readonly successThreshold?: number;
-    /** Custom predicate: should this error count as a failure? Default: all errors count. */
-    readonly isFailure?: (error: unknown) => boolean;
-    /** Called on state transitions (for observability). */
-    readonly onStateChange?: (from: CircuitBreakerState, to: CircuitBreakerState) => void;
-};
-type CircuitBreakerStats = {
-    readonly state: CircuitBreakerState;
-    readonly failures: number;
-    readonly successes: number;
-    readonly totalRequests: number;
-    readonly totalFailures: number;
-    readonly totalSuccesses: number;
-    readonly totalRejected: number;
-    readonly lastFailureTime: number | null;
-    readonly lastSuccessTime: number | null;
-};
-type CircuitBreaker = {
-    /** Current state of the circuit breaker. */
-    readonly state: () => CircuitBreakerState;
-    /** Run an effect through the circuit breaker. */
-    readonly protect: <R, E, A>(effect: Async<R, E, A>) => Async<R, E | CircuitBreakerError, A>;
-    /** Get current stats. */
-    readonly stats: () => CircuitBreakerStats;
-    /** Manually reset to closed state. */
-    readonly reset: () => void;
-};
-/**
- * Creates a circuit breaker.
- *
- * ```ts
- * const breaker = makeCircuitBreaker({ failureThreshold: 3, resetTimeoutMs: 10000 });
- *
- * // Protect an effect:
- * const result = await run(breaker.protect(callExternalService()));
- * // Throws CircuitBreakerOpen if circuit is open
- * ```
- */
-declare function makeCircuitBreaker(config?: CircuitBreakerConfig): CircuitBreaker;
+import { R as RuntimeHooks, b as RingBufferOptions, c as RuntimeEvent, a as RuntimeEmitContext, d as RuntimeEventRecord, e as RuntimeSpanLink, T as TraceContext, B as Baggage } from './effect-DIUHZ9IN.js';
+import { R as RuntimeClock } from './schedule-CK3Ml_7p.js';
 
 type MetricType = "counter" | "gauge" | "histogram";
 type MetricValue = {
@@ -188,6 +137,10 @@ type InMemoryTracerStats = {
 declare class InMemoryTracer implements RuntimeHooks {
     private readonly options;
     spans: Map<string, RuntimeSpan>;
+    private readonly finishedSpanIds;
+    private readonly finishedSpanSet;
+    private finishedSpanOffset;
+    private finishedSpanCount;
     private prunedFinishedSpans;
     constructor(options?: InMemoryTracerOptions);
     emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
@@ -199,6 +152,11 @@ declare class InMemoryTracer implements RuntimeHooks {
     private now;
     private pruneExpiredFinished;
     private pruneFinishedOverLimit;
+    private markFinished;
+    private deleteFinished;
+    private peekOldestFinished;
+    private deleteOldestFinished;
+    private compactFinishedIds;
 }
 
 type TraceSamplingInput = {
@@ -224,7 +182,8 @@ type BrassEnv = {
         respectRemoteSampled?: boolean;
         forceSampleOnError?: boolean;
         childName?: (parentName?: string) => string | undefined;
+        clock?: RuntimeClock;
     };
 };
 
-export { type BrassEnv as B, type CircuitBreakerStats as C, EventBus as E, type Gauge as G, type Histogram as H, InMemoryTracer as I, type MetricsRegistry as M, type RuntimeSpan as R, type TraceSampler as T, type MetricExemplar as a, type MetricSnapshot as b, type TraceSamplingInput as c, type Tracer as d, type InMemoryTracerOptions as e, type CircuitBreaker as f, type CircuitBreakerConfig as g, type CircuitBreakerError as h, type CircuitBreakerState as i, type Counter as j, type EventBusOptions as k, type EventHandler as l, type HistogramBuckets as m, type InMemoryTracerStats as n, type MetricType as o, type MetricValue as p, type RuntimeSpanEvent as q, defaultTracer as r, makeCircuitBreaker as s, makeMetrics as t, runtimeHooksToEventHandler as u };
+export { type BrassEnv as B, type Counter as C, EventBus as E, type Gauge as G, type Histogram as H, InMemoryTracer as I, type MetricsRegistry as M, type RuntimeSpan as R, type TraceSampler as T, type MetricExemplar as a, type MetricSnapshot as b, type TraceSamplingInput as c, type Tracer as d, type InMemoryTracerOptions as e, type EventBusOptions as f, type EventHandler as g, type HistogramBuckets as h, type InMemoryTracerStats as i, type MetricType as j, type MetricValue as k, type RuntimeSpanEvent as l, defaultTracer as m, makeMetrics as n, runtimeHooksToEventHandler as r };

package/dist/{tracing-Dt9S_6V8.d.ts → tracing-DqbTKGcf.d.ts}

@@ -1,4 +1,4 @@
-import { A as Async, E as Exit } from './effect-CGNl5Rqp.js';
+import { A as Async, E as Exit } from './effect-DIUHZ9IN.js';
 
 /**
  * Acquires a resource, uses it, and guarantees release regardless of outcome.