brass-runtime 1.15.0 → 1.16.1

package/dist/index.mjs

@@ -1,54 +1,95 @@
 import {
+  Layer,
+  LayerContext,
   LinkedQueue,
-  andThen,
+  MissingLayerServiceError,
+  RuntimeRegistry,
+  Supervisor,
+  TestClock,
+  TestScheduler,
   assertCompletesWithin,
   assertFails,
   assertFailsWith,
   assertSucceeds,
-  bracket,
+  buildLayer,
   catchTag,
   catchTags,
   compose,
+  consoleJsonLogger,
+  defaultTracer,
+  defineLayer,
+  defineService,
   delayedEffect,
   derivedRef,
-  elapsed,
-  ensuring,
-  exponential,
-  fixed,
+  dumpAllFibers,
   flakyEffect,
+  formatLayerError,
+  getService,
   gracefulShutdown,
-  intersect,
-  jittered,
+  joinSupervised,
   layer,
+  layerEffect,
   layerFail,
   layerFrom,
+  layerFromContext,
   layerSucceed,
+  layerValue,
   linkAbortController,
   makeCancelToken,
-  makeMetrics,
+  makeLayerScope,
   makeRef,
+  makeRuntime,
   makeSemaphore,
+  makeServiceTag,
+  makeSupervisor,
   makeTestRuntime,
   makeTracer,
   makeWorkerPool,
-  managed,
-  managedAll,
   mapError as mapError2,
   mapLayer,
   merge,
   neverEffect,
   orElse,
+  provide,
+  provideContext,
   provideLayer,
-  recurs,
+  provideLayerContext,
   registerShutdownHooks,
-  repeatWithSchedule,
-  retryWithSchedule,
-  tagError,
-  take,
-  union,
+  runEffect,
+  runExit,
+  runPromise,
+  serviceTag,
+  supervise,
+  tagError
+} from "./chunk-KH4SYAOS.mjs";
+import {
+  Resource,
+  bracket,
+  ensuring,
+  makeCircuitBreaker,
+  makeResource,
+  managed,
+  managedAll,
+  resource,
+  resourceAll,
+  resourceFromManaged,
+  resourceSucceed,
   useManaged,
-  whileInput
-} from "./chunk-JFPU5GQI.mjs";
+  useResource
+} from "./chunk-KN32XNTH.mjs";
+import {
+  fiberRefSnapshot,
+  getFiberRef,
+  locallyFiberRef,
+  locallyFiberRefWith,
+  makeFiberRef,
+  makeRuntimeRecorder,
+  modifyFiberRef,
+  setFiberRef,
+  unsafeGetFiberRef,
+  unsafeSetFiberRef,
+  updateFiberRef
+} from "./chunk-EOC4UHBS.mjs";
 import {
   assertNever,
   collectStream,
@@ -69,30 +110,77 @@ import {
   unwrapScoped,
   widenOpt,
   zip
-} from "./chunk-4NHES7VK.mjs";
+} from "./chunk-FHQGHPMO.mjs";
 import {
-  makeCircuitBreaker,
+  collectAllPar,
+  race,
+  raceWith,
+  zipPar
+} from "./chunk-B5JD23U7.mjs";
+import {
+  Schedule,
+  andThen,
+  contramap,
+  elapsed,
+  exponential,
+  fibonacci,
+  fixed,
+  forever,
+  intersect,
+  jitter,
+  jittered,
+  jitteredSchedule,
+  linear,
+  makeScheduleDriver,
+  map as map2,
+  maxDelay,
+  maxElapsed,
+  named,
+  never,
+  once,
+  poll,
+  recurs,
+  repeat,
+  repeatWithSchedule,
   retry,
+  retry2,
   retryN,
   retryWithBackoff,
+  retryWithSchedule,
+  runSchedule,
+  scheduleDriver,
   sleep,
-  timeout
-} from "./chunk-UMAZLXAB.mjs";
+  spaced,
+  take,
+  tapDecision,
+  timeout,
+  union,
+  untilInput,
+  untilOutput,
+  upTo,
+  whileInput,
+  whileOutput,
+  windowed
+} from "./chunk-2HQTDLHF.mjs";
 import {
-  collectAllPar,
-  race,
-  raceWith,
-  zipPar
-} from "./chunk-ELOOF35R.mjs";
+  Scope,
+  withScope,
+  withScopeAsync
+} from "./chunk-A2OM6NEH.mjs";
+import {
+  EventBus,
+  InMemoryTracer,
+  makeMetrics,
+  makeRuntimeEventRecord,
+  runtimeEventRecordContext,
+  runtimeHooksToEventHandler
+} from "./chunk-EJ6BPYVR.mjs";
 import {
   ABI_VERSION,
-  Async,
-  Cause,
   DefaultHostExecutor,
   EVENT_WORDS,
   EngineFiberHandle,
   EventKindCode,
-  Exit,
   HostRegistry,
   JsFiberEngine,
   NONE_U32,
@@ -104,11 +192,45 @@ import {
   Runtime,
   RuntimeFiber,
   Scheduler,
-  Scope,
   WasmFiberEngine,
   WasmFiberRegistryBridge,
   WasmPackFiberBridge,
   abortablePromiseStats,
+  ctxExtend,
+  ctxToObject,
+  decodeEvent,
+  decodeEventBatch,
+  emptyContext,
+  encodeOpcodeNodes,
+  encodeOpcodeProgram,
+  fork,
+  fromPromiseAbortable,
+  getBenchmarkBudget,
+  getCurrentFiber,
+  globalScheduler,
+  inferCallerLaneFromStack,
+  laneTag,
+  liveClock,
+  makeBoundedRingBuffer,
+  makeFiberReadyQueue,
+  resetAbortablePromiseStats,
+  resolveWasmModule,
+  runtimeCapabilities,
+  runtimeClockFromEnv,
+  runtimeForCaller,
+  sanitizeLaneKey,
+  setBenchmarkBudget,
+  toPromise,
+  toPromiseByCaller,
+  unsafeGetCurrentRuntime,
+  unsafeRunAsync,
+  unsafeRunFoldWithEnv,
+  withCurrentFiber
+} from "./chunk-GYM3LLGS.mjs";
+import {
+  Async,
+  Cause,
+  Exit,
   acquireRelease,
   asyncCatchAll,
   asyncEffect,
@@ -122,48 +244,29 @@ import {
   asyncSync,
   asyncTotal,
   catchAll,
-  decodeEvent,
-  decodeEventBatch,
-  encodeOpcodeNodes,
-  encodeOpcodeProgram,
   end,
   fail,
   flatMap,
-  fork,
-  fromPromiseAbortable,
-  getBenchmarkBudget,
-  getCurrentFiber,
-  globalScheduler,
-  inferCallerLaneFromStack,
-  laneTag,
-  makeBoundedRingBuffer,
-  makeFiberReadyQueue,
+  formatCause,
+  interruptible,
+  isCause,
   map,
   mapAsync,
   mapError,
   mapTryAsync,
   none,
   orElseOptional,
-  resetAbortablePromiseStats,
-  resolveWasmModule,
-  runtimeCapabilities,
-  runtimeForCaller,
-  sanitizeLaneKey,
-  setBenchmarkBudget,
+  prettyCause,
   some,
   succeed,
   sync,
-  toPromise,
-  toPromiseByCaller,
+  uninterruptible,
+  uninterruptibleMask,
   unit,
-  unsafeGetCurrentRuntime,
-  unsafeRunAsync,
-  unsafeRunFoldWithEnv,
-  withAsyncPromise,
-  withCurrentFiber,
-  withScope,
-  withScopeAsync
-} from "./chunk-BDF4AMWX.mjs";
+  withAsyncPromise
+} from "./chunk-36I3M4UC.mjs";
+import "./chunk-DNFJLJMW.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 
 // src/core/stream/queue.ts
 function bounded(capacity, strategy = "backpressure", options = {}) {
@@ -386,100 +489,6 @@ function buffer(stream, capacity, strategy = "backpressure") {
   return fromPull(pullDown);
 }
 
-// src/core/stream/hub.ts
-var toQueueStrategy = (s) => s === "BackPressure" ? "backpressure" : s === "Dropping" ? "dropping" : "sliding";
-function makeHub(capacity, strategy = "BackPressure") {
-  const queues = /* @__PURE__ */ new Set();
-  let closed = false;
-  const publish = (a) => {
-    if (closed) return asyncSucceed(false);
-    const size = queues.size;
-    if (size === 0) return asyncSucceed(true);
-    if (size === 1) {
-      const q = queues.values().next().value;
-      return q.offer(a);
-    }
-    let eff = asyncSucceed(true);
-    for (const q of queues) {
-      eff = asyncFlatMap(
-        eff,
-        (okSoFar) => asyncFlatMap(q.offer(a), (ok) => asyncSucceed(okSoFar && ok))
-      );
-    }
-    return eff;
-  };
-  const publishAll = (as) => {
-    let eff = asyncSucceed(true);
-    const it = as[Symbol.iterator]();
-    while (true) {
-      const n = it.next();
-      if (n.done) break;
-      const a = n.value;
-      eff = asyncFlatMap(
-        eff,
-        (okSoFar) => asyncFlatMap(publish(a), (ok) => asyncSucceed(okSoFar && ok))
-      );
-    }
-    return eff;
-  };
-  const subscribe = () => {
-    if (closed) {
-      return asyncTotal(() => {
-        throw { _tag: "HubClosed" };
-      });
-    }
-    return asyncFlatMap(
-      bounded(capacity, toQueueStrategy(strategy)),
-      (q) => asyncSync(() => {
-        queues.add(q);
-        return {
-          ...q,
-          unsubscribe: () => {
-            if (!queues.has(q)) return;
-            queues.delete(q);
-            q.shutdown();
-          }
-        };
-      })
-    );
-  };
-  const shutdown = () => asyncSync(() => {
-    if (closed) return;
-    closed = true;
-    for (const q of queues) q.shutdown();
-    queues.clear();
-  });
-  return {
-    publish,
-    publishAll,
-    subscribe,
-    shutdown
-  };
-}
-var broadcast = makeHub;
-function broadcastToHub(stream, hub) {
-  return foreachStream(
-    stream,
-    (a) => asyncFlatMap(hub.publish(a), () => asyncSucceed(void 0))
-  );
-}
-function fromHub(hub) {
-  return managedStream(
-    asyncFlatMap(hub.subscribe(), (sub) => {
-      const loop = fromPull(
-        asyncFlatMap(
-          asyncMapError(sub.take(), (_queueClosed) => none),
-          (a) => asyncSucceed([a, loop])
-        )
-      );
-      return asyncSucceed({
-        stream: loop,
-        release: (_exit) => asyncSync(() => sub.unsubscribe())
-      });
-    })
-  );
-}
-
 // src/core/stream/chunks.ts
 var cachedWasmChunkCtor;
 function resolveWasmChunkBuffer() {
@@ -1203,6 +1212,139 @@ function groupedP(n) {
   });
 }
 
+// src/core/stream/dx.ts
+var Stream = Object.freeze({
+  from: (values) => asStream(fromArray(values)),
+  empty: () => asStream(emptyStream()),
+  range: (start, end2) => asStream(rangeStream(start, end2)),
+  wrap: asStream
+});
+var Pipeline = Object.freeze({
+  map: mapP,
+  filter: filterP
+});
+function asStream(stream) {
+  const target = stream;
+  if (typeof target.pipe === "function") return target;
+  Object.defineProperties(target, {
+    pipe: {
+      value(pipeline) {
+        return asStream(via(target, pipeline));
+      }
+    },
+    map: {
+      value(f) {
+        return asStream(via(target, mapP(f)));
+      }
+    },
+    filter: {
+      value(predicate) {
+        return asStream(via(target, filterP(predicate)));
+      }
+    },
+    collect: {
+      value(runtime) {
+        return runtime.toPromise(collectStream(target));
+      }
+    }
+  });
+  return target;
+}
+
+// src/core/stream/hub.ts
+var toQueueStrategy = (s) => s === "BackPressure" ? "backpressure" : s === "Dropping" ? "dropping" : "sliding";
+function makeHub(capacity, strategy = "BackPressure") {
+  const queues = /* @__PURE__ */ new Set();
+  let closed = false;
+  const publish = (a) => {
+    if (closed) return asyncSucceed(false);
+    const size = queues.size;
+    if (size === 0) return asyncSucceed(true);
+    if (size === 1) {
+      const q = queues.values().next().value;
+      return q.offer(a);
+    }
+    let eff = asyncSucceed(true);
+    for (const q of queues) {
+      eff = asyncFlatMap(
+        eff,
+        (okSoFar) => asyncFlatMap(q.offer(a), (ok) => asyncSucceed(okSoFar && ok))
+      );
+    }
+    return eff;
+  };
+  const publishAll = (as) => {
+    let eff = asyncSucceed(true);
+    const it = as[Symbol.iterator]();
+    while (true) {
+      const n = it.next();
+      if (n.done) break;
+      const a = n.value;
+      eff = asyncFlatMap(
+        eff,
+        (okSoFar) => asyncFlatMap(publish(a), (ok) => asyncSucceed(okSoFar && ok))
+      );
+    }
+    return eff;
+  };
+  const subscribe = () => {
+    if (closed) {
+      return asyncTotal(() => {
+        throw { _tag: "HubClosed" };
+      });
+    }
+    return asyncFlatMap(
+      bounded(capacity, toQueueStrategy(strategy)),
+      (q) => asyncSync(() => {
+        queues.add(q);
+        return {
+          ...q,
+          unsubscribe: () => {
+            if (!queues.has(q)) return;
+            queues.delete(q);
+            q.shutdown();
+          }
+        };
+      })
+    );
+  };
+  const shutdown = () => asyncSync(() => {
+    if (closed) return;
+    closed = true;
+    for (const q of queues) q.shutdown();
+    queues.clear();
+  });
+  return {
+    publish,
+    publishAll,
+    subscribe,
+    shutdown
+  };
+}
+var broadcast = makeHub;
+function broadcastToHub(stream, hub) {
+  return foreachStream(
+    stream,
+    (a) => asyncFlatMap(hub.publish(a), () => asyncSucceed(void 0))
+  );
+}
+function fromHub(hub) {
+  return managedStream(
+    asyncFlatMap(hub.subscribe(), (sub) => {
+      const loop = fromPull(
+        asyncFlatMap(
+          asyncMapError(sub.take(), (_queueClosed) => none),
+          (a) => asyncSucceed([a, loop])
+        )
+      );
+      return asyncSucceed({
+        stream: loop,
+        release: (_exit) => asyncSync(() => sub.unsubscribe())
+      });
+    })
+  );
+}
+
 // src/core/stream/operators.ts
 function throttle(stream, intervalMs) {
   let lastEmitTime = 0;
@@ -1374,21 +1516,34 @@ export {
   DefaultHostExecutor,
   EVENT_WORDS,
   EngineFiberHandle,
+  EventBus,
   EventKindCode,
   Exit,
   HostRegistry,
+  InMemoryTracer,
   JsFiberEngine,
+  Layer,
+  LayerContext,
+  MissingLayerServiceError,
   NONE_U32,
   NoopHooks,
   OpcodeTagCode,
   PURE_PIPELINE_TAG,
+  Pipeline,
   ProgramBuilder,
   PushStatus,
+  Resource,
   RingBuffer,
   Runtime,
   RuntimeFiber,
+  RuntimeRegistry,
+  Schedule,
   Scheduler,
   Scope,
+  Stream,
+  Supervisor,
+  TestClock,
+  TestScheduler,
   WasmFiberEngine,
   WasmFiberRegistryBridge,
   WasmPackFiberBridge,
@@ -1397,6 +1552,7 @@ export {
   andThen2 as andThen,
   andThen as andThenSchedule,
   applyFused,
+  asStream,
   assertCompletesWithin,
   assertFails,
   assertFailsWith,
@@ -1419,6 +1575,7 @@ export {
   broadcastToHub,
   buffer,
   bufferP,
+  buildLayer,
   catchAll,
   catchTag,
   catchTags,
@@ -1429,16 +1586,25 @@ export {
   compose2 as compose,
   compose as composeLayer,
   concatStream,
+  consoleJsonLogger,
+  contramap as contramapSchedule,
+  ctxExtend,
+  ctxToObject,
   debounce,
   decodeEvent,
   decodeEventBatch,
+  defaultTracer,
+  defineLayer,
+  defineService,
   delayedEffect,
   derivedRef,
   deserializeFusedPipeline,
   dropP,
   drop as dropStream,
+  dumpAllFibers,
   elapsed,
   emitStream,
+  emptyContext,
   emptyStream,
   encodeOpcodeNodes,
   encodeOpcodeProgram,
@@ -1447,6 +1613,8 @@ export {
   ensuring,
   exponential,
   fail,
+  fiberRefSnapshot,
+  fibonacci,
   filterMapP,
   filterP,
   fixed,
@@ -1454,7 +1622,10 @@ export {
   flatMap,
   flattenStream,
   foreachStream,
+  forever,
   fork,
+  formatCause,
+  formatLayerError,
   fromArray,
   fromHub,
   fromPromiseAbortable,
@@ -1462,6 +1633,8 @@ export {
   fuse,
   getBenchmarkBudget,
   getCurrentFiber,
+  getFiberRef,
+  getService,
   getStats,
   globalScheduler,
   gracefulShutdown,
@@ -1470,25 +1643,46 @@ export {
   inferCallerLaneFromStack,
   initState,
   interleave,
+  interruptible,
   intersect,
+  isCause,
   isFusionEnabled,
   isFusionVerbose,
+  jitter,
   jittered,
+  jitteredSchedule,
+  joinSupervised,
   laneTag,
   layer,
+  layerEffect,
   layerFail,
   layerFrom,
+  layerFromContext,
   layerSucceed,
+  layerValue,
+  linear,
   linkAbortController,
+  liveClock,
+  locallyFiberRef,
+  locallyFiberRefWith,
   makeBoundedRingBuffer,
   makeCancelToken,
   makeCircuitBreaker,
   makeFiberReadyQueue,
+  makeFiberRef,
   makeHub,
+  makeLayerScope,
   makeMetrics,
   makeRef,
+  makeResource,
+  makeRuntime,
+  makeRuntimeEventRecord,
+  makeRuntimeRecorder,
+  makeScheduleDriver,
   makeSemaphore,
+  makeServiceTag,
   makeStreamChunker,
+  makeSupervisor,
   makeTestRuntime,
   makeTracer,
   makeWorkerPool,
@@ -1505,62 +1699,104 @@ export {
   mapError2 as mapErrorTyped,
   mapLayer,
   mapP,
+  map2 as mapSchedule,
   mapStream,
   mapTryAsync,
+  maxDelay,
+  maxElapsed,
   merge2 as merge,
   merge as mergeLayer,
   mergeStream,
+  modifyFiberRef,
+  named as namedSchedule,
+  never,
   neverEffect,
   none,
+  once,
   orElse,
   orElseOptional,
+  poll as pollWithSchedule,
+  prettyCause,
+  provide,
+  provideContext,
   provideLayer,
+  provideLayerContext,
   race,
   raceWith,
   rangeStream,
   recurs,
   registerShutdownHooks,
   repeatWithSchedule,
+  repeat as repeatWithScheduleAlias,
   resetAbortablePromiseStats,
+  resource,
+  resourceAll,
+  resourceFromManaged,
+  resourceSucceed,
   retry,
   retryN,
   retryWithBackoff,
   retryWithSchedule,
+  retry2 as retryWithScheduleAlias,
+  runEffect,
+  runExit,
   runFusedArray,
+  runPromise,
+  runSchedule,
   runtimeCapabilities,
+  runtimeClockFromEnv,
+  runtimeEventRecordContext,
   runtimeForCaller,
+  runtimeHooksToEventHandler,
   sanitizeLaneKey,
   scan,
+  scheduleDriver,
   selectedEngineStats,
   serializeFusedPipeline,
+  serviceTag,
   setBenchmarkBudget,
+  setFiberRef,
   setFusionEnabled,
   setFusionVerbose,
   sleep,
   some,
+  spaced,
   streamFromReadableStream,
   succeed,
+  supervise,
   sync,
   tagError,
   takeP,
   take as takeSchedule,
   take2 as takeStream,
+  tapDecision,
   tapEffectP,
   throttle,
   timeout,
   toPromise,
   toPromiseByCaller,
   uncons,
+  uninterruptible,
+  uninterruptibleMask,
   union,
   unit,
   unsafeGetCurrentRuntime,
+  unsafeGetFiberRef,
   unsafeRunAsync,
   unsafeRunFoldWithEnv,
+  unsafeSetFiberRef,
+  untilInput,
+  untilOutput,
   unwrapScoped,
+  upTo,
+  updateFiberRef,
   useManaged,
+  useResource,
   via,
   whileInput,
+  whileOutput,
   widenOpt,
+  windowed,
   withAsyncPromise,
   withCurrentFiber,
   withScope,