brass-runtime 1.16.0 → 1.16.1

package/dist/index.mjs

@@ -1,30 +1,46 @@
 import {
+  Layer,
+  LayerContext,
   LinkedQueue,
+  MissingLayerServiceError,
   RuntimeRegistry,
   Supervisor,
+  TestClock,
+  TestScheduler,
   assertCompletesWithin,
   assertFails,
   assertFailsWith,
   assertSucceeds,
+  buildLayer,
   catchTag,
   catchTags,
   compose,
   consoleJsonLogger,
   defaultTracer,
+  defineLayer,
+  defineService,
   delayedEffect,
   derivedRef,
   dumpAllFibers,
   flakyEffect,
+  formatLayerError,
+  getService,
   gracefulShutdown,
   joinSupervised,
   layer,
+  layerEffect,
   layerFail,
   layerFrom,
+  layerFromContext,
   layerSucceed,
+  layerValue,
   linkAbortController,
   makeCancelToken,
+  makeLayerScope,
   makeRef,
+  makeRuntime,
   makeSemaphore,
+  makeServiceTag,
   makeSupervisor,
   makeTestRuntime,
   makeTracer,
@@ -34,44 +50,46 @@ import {
   merge,
   neverEffect,
   orElse,
+  provide,
+  provideContext,
   provideLayer,
+  provideLayerContext,
   registerShutdownHooks,
+  runEffect,
+  runExit,
+  runPromise,
+  serviceTag,
   supervise,
   tagError
-} from "./chunk-CY33PGEX.mjs";
+} from "./chunk-KH4SYAOS.mjs";
 import {
   Resource,
-  andThen,
   bracket,
-  contramap,
-  elapsed,
   ensuring,
-  exponential,
-  fibonacci,
-  fixed,
-  intersect,
-  jitter,
-  jittered,
-  jitteredSchedule,
   makeCircuitBreaker,
   makeResource,
   managed,
   managedAll,
-  map as map2,
-  recurs,
-  repeatWithSchedule,
   resource,
   resourceAll,
   resourceFromManaged,
   resourceSucceed,
-  retryWithSchedule,
-  take,
-  union,
   useManaged,
-  useResource,
-  whileInput,
-  windowed
-} from "./chunk-GOV47PPB.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,
@@ -92,14 +110,63 @@ import {
   unwrapScoped,
   widenOpt,
   zip
-} from "./chunk-2WC63LJK.mjs";
+} from "./chunk-FHQGHPMO.mjs";
+import {
+  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-7V4KY4RL.mjs";
+  spaced,
+  take,
+  tapDecision,
+  timeout,
+  union,
+  untilInput,
+  untilOutput,
+  upTo,
+  whileInput,
+  whileOutput,
+  windowed
+} from "./chunk-2HQTDLHF.mjs";
+import {
+  Scope,
+  withScope,
+  withScopeAsync
+} from "./chunk-A2OM6NEH.mjs";
 import {
   EventBus,
   InMemoryTracer,
@@ -107,18 +174,7 @@ import {
   makeRuntimeEventRecord,
   runtimeEventRecordContext,
   runtimeHooksToEventHandler
-} from "./chunk-VFIUZG7J.mjs";
-import {
-  collectAllPar,
-  race,
-  raceWith,
-  zipPar
-} from "./chunk-J3H54ZRV.mjs";
-import {
-  Scope,
-  withScope,
-  withScopeAsync
-} from "./chunk-CCKHV5BT.mjs";
+} from "./chunk-EJ6BPYVR.mjs";
 import {
   ABI_VERSION,
   DefaultHostExecutor,
@@ -154,11 +210,13 @@ import {
   globalScheduler,
   inferCallerLaneFromStack,
   laneTag,
+  liveClock,
   makeBoundedRingBuffer,
   makeFiberReadyQueue,
   resetAbortablePromiseStats,
   resolveWasmModule,
   runtimeCapabilities,
+  runtimeClockFromEnv,
   runtimeForCaller,
   sanitizeLaneKey,
   setBenchmarkBudget,
@@ -168,7 +226,7 @@ import {
   unsafeRunAsync,
   unsafeRunFoldWithEnv,
   withCurrentFiber
-} from "./chunk-G6IQOE4P.mjs";
+} from "./chunk-GYM3LLGS.mjs";
 import {
   Async,
   Cause,
@@ -189,19 +247,25 @@ import {
   end,
   fail,
   flatMap,
+  formatCause,
+  interruptible,
+  isCause,
   map,
   mapAsync,
   mapError,
   mapTryAsync,
   none,
   orElseOptional,
+  prettyCause,
   some,
   succeed,
   sync,
+  uninterruptible,
+  uninterruptibleMask,
   unit,
   withAsyncPromise
-} from "./chunk-NOYZIMUJ.mjs";
-import "./chunk-U5KWK3PX.mjs";
+} from "./chunk-36I3M4UC.mjs";
+import "./chunk-DNFJLJMW.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 
 // src/core/stream/queue.ts
@@ -425,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() {
@@ -1242,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;
@@ -1419,10 +1522,14 @@ export {
   HostRegistry,
   InMemoryTracer,
   JsFiberEngine,
+  Layer,
+  LayerContext,
+  MissingLayerServiceError,
   NONE_U32,
   NoopHooks,
   OpcodeTagCode,
   PURE_PIPELINE_TAG,
+  Pipeline,
   ProgramBuilder,
   PushStatus,
   Resource,
@@ -1430,9 +1537,13 @@ export {
   Runtime,
   RuntimeFiber,
   RuntimeRegistry,
+  Schedule,
   Scheduler,
   Scope,
+  Stream,
   Supervisor,
+  TestClock,
+  TestScheduler,
   WasmFiberEngine,
   WasmFiberRegistryBridge,
   WasmPackFiberBridge,
@@ -1441,6 +1552,7 @@ export {
   andThen2 as andThen,
   andThen as andThenSchedule,
   applyFused,
+  asStream,
   assertCompletesWithin,
   assertFails,
   assertFailsWith,
@@ -1463,6 +1575,7 @@ export {
   broadcastToHub,
   buffer,
   bufferP,
+  buildLayer,
   catchAll,
   catchTag,
   catchTags,
@@ -1481,6 +1594,8 @@ export {
   decodeEvent,
   decodeEventBatch,
   defaultTracer,
+  defineLayer,
+  defineService,
   delayedEffect,
   derivedRef,
   deserializeFusedPipeline,
@@ -1498,6 +1613,7 @@ export {
   ensuring,
   exponential,
   fail,
+  fiberRefSnapshot,
   fibonacci,
   filterMapP,
   filterP,
@@ -1506,7 +1622,10 @@ export {
   flatMap,
   flattenStream,
   foreachStream,
+  forever,
   fork,
+  formatCause,
+  formatLayerError,
   fromArray,
   fromHub,
   fromPromiseAbortable,
@@ -1514,6 +1633,8 @@ export {
   fuse,
   getBenchmarkBudget,
   getCurrentFiber,
+  getFiberRef,
+  getService,
   getStats,
   globalScheduler,
   gracefulShutdown,
@@ -1522,7 +1643,9 @@ export {
   inferCallerLaneFromStack,
   initState,
   interleave,
+  interruptible,
   intersect,
+  isCause,
   isFusionEnabled,
   isFusionVerbose,
   jitter,
@@ -1531,20 +1654,33 @@ export {
   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,
@@ -1566,20 +1702,32 @@ export {
   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,
@@ -1589,20 +1737,30 @@ export {
   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,
@@ -1611,22 +1769,32 @@ export {
   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,