brass-runtime 1.16.0 → 1.17.0

package/dist/chunk-B33ICAKP.js

@@ -0,0 +1,313 @@
+import {
+  Scope
+} from "./chunk-L2SYFEBS.js";
+import {
+  unsafeGetCurrentRuntime
+} from "./chunk-FH2X7BVP.js";
+import {
+  Cause,
+  Exit,
+  asyncEffect,
+  asyncFail,
+  asyncFold,
+  asyncSucceed,
+  unit
+} from "./chunk-UB4B6OFY.js";
+
+// src/core/runtime/resource.ts
+function bracket(acquire, use, release) {
+  return asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const scope = new Scope(runtime);
+    const acquireFiber = scope.fork(acquire);
+    acquireFiber.join((acquireExit) => {
+      if (acquireExit._tag === "Failure") {
+        scope.close(acquireExit);
+        cb(acquireExit);
+        return;
+      }
+      const resource2 = acquireExit.value;
+      const useFiber = scope.fork(use(resource2));
+      useFiber.join((useExit) => {
+        const releaseEffect = safeRelease(release, resource2, useExit);
+        const releaseFiber = runtime.fork(releaseEffect);
+        releaseFiber.join(() => {
+          scope.close(useExit);
+          cb(useExit);
+        });
+      });
+    });
+    return () => {
+      scope.close(Exit.failCause(Cause.interrupt()));
+    };
+  });
+}
+function safeRelease(release, resource2, exit) {
+  return asyncFold(
+    (() => {
+      try {
+        return release(resource2, exit);
+      } catch {
+        return unit();
+      }
+    })(),
+    () => unit(),
+    () => unit()
+  );
+}
+function ensuring(effect, finalizer) {
+  return asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      const fin = asyncFold(
+        (() => {
+          try {
+            return finalizer(exit);
+          } catch {
+            return unit();
+          }
+        })(),
+        () => unit(),
+        () => unit()
+      );
+      runtime.fork(fin).join(() => {
+        cb(exit);
+      });
+    });
+    return () => {
+      fiber.interrupt();
+    };
+  });
+}
+function resource(acquire, release) {
+  return makeResourceFromUse((body) => bracket(acquire, body, release));
+}
+var makeResource = resource;
+function resourceSucceed(value) {
+  return makeResourceFromUse((body) => body(value));
+}
+function resourceFromManaged(m) {
+  return makeResourceFromUse((body) => useManaged(m, body));
+}
+function useResource(res, body) {
+  return res.use(body);
+}
+function resourceAll(resources) {
+  const build = (index) => {
+    if (index >= resources.length) return resourceSucceed([]);
+    return resources[index].flatMap(
+      (head) => build(index + 1).map((tail) => [head, ...tail])
+    );
+  };
+  return build(0).map((values) => values);
+}
+var Resource = Object.freeze({
+  make: resource,
+  succeed: resourceSucceed,
+  fromManaged: resourceFromManaged,
+  all: resourceAll,
+  use: useResource
+});
+function makeResourceFromUse(use) {
+  const self = {
+    _tag: "Resource",
+    use,
+    map: (f) => makeResourceFromUse((body) => self.use((a) => body(f(a)))),
+    flatMap: (f) => makeResourceFromUse((body) => self.use((a) => f(a).use(body))),
+    zip: (that) => self.flatMap((a) => that.map((b) => [a, b]))
+  };
+  return self;
+}
+function managed(acquire, release) {
+  return {
+    _tag: "Managed",
+    acquire,
+    release: (resource2, exit) => release(resource2, exit)
+  };
+}
+function useManaged(m, body) {
+  return bracket(m.acquire, body, m.release);
+}
+function managedAll(manageds) {
+  const acquire = asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const resources = [];
+    let i = 0;
+    const acquireNext = () => {
+      if (i >= manageds.length) {
+        cb({ _tag: "Success", value: resources });
+        return;
+      }
+      const m = manageds[i];
+      const fiber = runtime.fork(m.acquire);
+      fiber.join((exit) => {
+        if (exit._tag === "Failure") {
+          releaseAcquired(runtime, manageds, resources, exit).then(() => {
+            cb(exit);
+          });
+          return;
+        }
+        resources.push(exit.value);
+        i++;
+        acquireNext();
+      });
+    };
+    acquireNext();
+  });
+  const release = (resources, exit) => {
+    return asyncEffect((_env, cb) => {
+      const runtime = unsafeGetCurrentRuntime();
+      releaseAcquired(runtime, manageds, resources, exit).then(() => {
+        cb({ _tag: "Success", value: void 0 });
+      });
+    });
+  };
+  return { _tag: "Managed", acquire, release };
+}
+async function releaseAcquired(runtime, manageds, resources, exit) {
+  for (let i = resources.length - 1; i >= 0; i--) {
+    try {
+      const m = manageds[i];
+      await new Promise((resolve) => {
+        const releaseEff = asyncFold(
+          m.release(resources[i], exit),
+          () => unit(),
+          () => unit()
+        );
+        runtime.fork(releaseEff).join(() => resolve());
+      });
+    } catch {
+    }
+  }
+}
+
+// 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 {
+  bracket,
+  ensuring,
+  resource,
+  makeResource,
+  resourceSucceed,
+  resourceFromManaged,
+  useResource,
+  resourceAll,
+  Resource,
+  managed,
+  useManaged,
+  managedAll,
+  makeCircuitBreaker
+};

package/dist/{chunk-J3H54ZRV.mjs → chunk-B5JD23U7.mjs}

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

package/dist/{chunk-F5EUMJL7.mjs → chunk-BKK77SBA.js}

@@ -2,25 +2,25 @@ import {
   EventBus,
   InMemoryTracer,
   makeMetrics
-} from "./chunk-VFIUZG7J.mjs";
+} from "./chunk-RKGKFN2A.js";
 import {
   Runtime,
   ctxExtend,
   ctxToObject,
   emptyContext,
   getCurrentFiber
-} from "./chunk-G6IQOE4P.mjs";
+} from "./chunk-FH2X7BVP.js";
 import {
   asyncFail,
   asyncFlatMap,
   asyncFold,
   asyncSucceed,
   asyncSync
-} from "./chunk-NOYZIMUJ.mjs";
+} from "./chunk-UB4B6OFY.js";
 import {
   Schema,
   parseConfig
-} from "./chunk-U5KWK3PX.mjs";
+} from "./chunk-C3MDXTRZ.js";
 
 // src/observability/health.ts
 function snapshotRuntimeHealth(options = {}) {
@@ -1462,6 +1462,7 @@ var object = Schema.custom(
 );
 var falseOrObject = Schema.union([Schema.literal(false), object]);
 var ratio = Schema.number({ min: 0, max: 1 });
+var logLevel = Schema.enum(["debug", "info", "warn", "error"]);
 var retryOptions = Schema.object({
   attempts: Schema.number({ min: 0, int: true }).optional(),
   initialDelayMs: Schema.number({ min: 0, int: true }).optional(),
@@ -1523,11 +1524,78 @@ var observabilityOptions = Schema.object({
   childName: fn.optional(),
   onFlushError: fn.optional()
 }, { unknownKeys: "passthrough" });
+var httpObservabilityOptions = Schema.object({
+  metrics: falseOrObject.optional(),
+  logs: Schema.union([
+    Schema.literal(false),
+    Schema.object({
+      requestLevel: Schema.union([logLevel, Schema.literal(false)]).optional(),
+      responseLevel: Schema.union([logLevel, Schema.literal(false)]).optional(),
+      errorLevel: Schema.union([logLevel, Schema.literal(false)]).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  spans: Schema.union([
+    Schema.literal(false),
+    Schema.object({
+      name: Schema.union([Schema.string({ minLength: 1 }), fn]).optional(),
+      attributes: Schema.union([object, fn]).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  adaptiveLimiter: Schema.union([
+    Schema.boolean(),
+    Schema.object({
+      enabled: Schema.boolean().optional(),
+      includeKeyLabel: Schema.boolean().optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  policy: Schema.union([
+    Schema.boolean(),
+    Schema.object({
+      enabled: Schema.boolean().optional(),
+      labelKeys: Schema.array(Schema.enum(["preset", "lane", "poolKey", "dedupKey", "priority", "retry"])).optional()
+    }, { unknownKeys: "passthrough" })
+  ]).optional(),
+  injectTraceHeaders: Schema.boolean().optional(),
+  includeHostLabel: Schema.boolean().optional(),
+  route: Schema.union([Schema.string({ minLength: 1 }), fn]).optional(),
+  clock: fn.optional(),
+  durationBuckets: Schema.array(Schema.number({ min: 0 }).refine((n) => n > 0, "duration bucket must be > 0")).optional()
+}, { unknownKeys: "passthrough" });
 function validateObservabilityOptions(options) {
   parseConfig("ObservabilityOptions", observabilityOptions, options);
 }
+function validateHttpObservabilityOptions(options) {
+  parseConfig("HttpObservabilityOptions", httpObservabilityOptions, options);
+}
 
 // src/observability/setup.ts
+var DEFAULT_OTLP_SIGNALS = ["metrics", "traces", "logs"];
+function makeOtlpOptions(input) {
+  const endpoint = normalizeOtlpEndpoint(input.endpoint);
+  const signals = input.signals ?? DEFAULT_OTLP_SIGNALS;
+  return {
+    ...signals.includes("metrics") ? { metricsUrl: `${endpoint}/v1/metrics` } : {},
+    ...signals.includes("traces") ? { tracesUrl: `${endpoint}/v1/traces` } : {},
+    ...signals.includes("logs") ? { logsUrl: `${endpoint}/v1/logs` } : {},
+    ...input.headers ? { headers: input.headers } : {},
+    ...input.fetch ? { fetch: input.fetch } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+    ...input.retry ? { retry: input.retry } : {},
+    ...input.pipeline ? { pipeline: input.pipeline } : {}
+  };
+}
+function normalizeOtlpEndpoint(endpoint) {
+  const trimmed = endpoint.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  const normalized = trimmed.slice(0, end);
+  if (!normalized) {
+    throw new Error("makeOtlpOptions endpoint must not be empty");
+  }
+  return normalized;
+}
 function makeObservability(options = {}) {
   validateObservabilityOptions(options);
   const serviceName = options.serviceName ?? "brass-runtime";
@@ -1861,12 +1929,13 @@ function makeRuntimeTraceIdGenerator() {
     newSpanId: () => randomHexId(16)
   };
 }
+var HEX_BYTE = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"));
 function randomHexId(length) {
   const cryptoLike = globalThis.crypto;
   if (typeof cryptoLike?.getRandomValues === "function") {
     const bytes = new Uint8Array(Math.ceil(length / 2));
     cryptoLike.getRandomValues(bytes);
-    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
+    return bytesToHex(bytes, length);
   }
   if (typeof cryptoLike?.randomUUID === "function") {
     const hex = cryptoLike.randomUUID().replace(/-/g, "");
@@ -1878,6 +1947,13 @@ function randomHexId(length) {
   }
   return out.slice(0, length);
 }
+function bytesToHex(bytes, length) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += HEX_BYTE[bytes[i]];
+  }
+  return out.length === length ? out : out.slice(0, length);
+}
 
 // src/observability/request.ts
 function makeRequestObservabilityContext(observability, input = {}) {
@@ -2134,6 +2210,8 @@ export {
   makeCardinalityLimitedMetrics,
   normalizeHttpRoute,
   sanitizeHttpTarget,
+  validateHttpObservabilityOptions,
+  makeOtlpOptions,
   makeObservability,
   resolveRequestTraceSeed,
   resolveRequestBaggage,

package/dist/{chunk-U5KWK3PX.mjs → chunk-C3MDXTRZ.js}

@@ -18,6 +18,15 @@ var ConfigValidationError = class extends Error {
     this.issues = issues;
   }
 };
+function isConfigValidationError(error) {
+  return error instanceof ConfigValidationError || typeof error === "object" && error !== null && error._tag === "ConfigValidationError" && typeof error.configName === "string" && Array.isArray(error.issues);
+}
+function formatConfigError(error) {
+  if (!isConfigValidationError(error)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  return `${error.configName} failed validation: ${formatIssues(error.issues)}`;
+}
 var ok = (data) => ({ success: true, data });
 var fail = (issues) => ({ success: false, issues });
 var receivedKind = (value) => {
@@ -332,6 +341,8 @@ function parseConfig(configName, validator, value) {
 export {
   SchemaValidationException,
   ConfigValidationError,
+  isConfigValidationError,
+  formatConfigError,
   makeSchemaIssue,
   formatIssues,
   schema,

package/dist/{chunk-SPUEME2B.cjs → chunk-CZIVE6NT.cjs}

@@ -18,6 +18,15 @@ var ConfigValidationError = (_class = class extends Error {
     this.issues = issues;
   }
 }, _class);
+function isConfigValidationError(error) {
+  return error instanceof ConfigValidationError || typeof error === "object" && error !== null && error._tag === "ConfigValidationError" && typeof error.configName === "string" && Array.isArray(error.issues);
+}
+function formatConfigError(error) {
+  if (!isConfigValidationError(error)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  return `${error.configName} failed validation: ${formatIssues(error.issues)}`;
+}
 var ok = (data) => ({ success: true, data });
 var fail = (issues) => ({ success: false, issues });
 var receivedKind = (value) => {
@@ -340,4 +349,6 @@ function parseConfig(configName, validator, value) {
 
 
 
-exports.SchemaValidationException = SchemaValidationException; exports.ConfigValidationError = ConfigValidationError; exports.makeSchemaIssue = makeSchemaIssue; exports.formatIssues = formatIssues; exports.schema = schema; exports.s = s; exports.Schema = Schema; exports.isSchema = isSchema; exports.validateValue = validateValue; exports.parseConfig = parseConfig;
+
+
+exports.SchemaValidationException = SchemaValidationException; exports.ConfigValidationError = ConfigValidationError; exports.isConfigValidationError = isConfigValidationError; exports.formatConfigError = formatConfigError; exports.makeSchemaIssue = makeSchemaIssue; exports.formatIssues = formatIssues; exports.schema = schema; exports.s = s; exports.Schema = Schema; exports.isSchema = isSchema; exports.validateValue = validateValue; exports.parseConfig = parseConfig;

package/dist/{chunk-TDVMADDN.js → chunk-DNFJLJMW.mjs}

@@ -18,6 +18,15 @@ var ConfigValidationError = class extends Error {
     this.issues = issues;
   }
 };
+function isConfigValidationError(error) {
+  return error instanceof ConfigValidationError || typeof error === "object" && error !== null && error._tag === "ConfigValidationError" && typeof error.configName === "string" && Array.isArray(error.issues);
+}
+function formatConfigError(error) {
+  if (!isConfigValidationError(error)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  return `${error.configName} failed validation: ${formatIssues(error.issues)}`;
+}
 var ok = (data) => ({ success: true, data });
 var fail = (issues) => ({ success: false, issues });
 var receivedKind = (value) => {
@@ -332,6 +341,8 @@ function parseConfig(configName, validator, value) {
 export {
   SchemaValidationException,
   ConfigValidationError,
+  isConfigValidationError,
+  formatConfigError,
   makeSchemaIssue,
   formatIssues,
   schema,