brass-runtime 1.13.8 → 1.15.0

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
 
 
 
@@ -18,7 +18,78 @@
 
 
 
-var _chunkZTDK2DLGcjs = require('./chunk-ZTDK2DLG.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkXPZNXSVNcjs = require('./chunk-XPZNXSVN.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkSTVLQ3XDcjs = require('./chunk-STVLQ3XD.cjs');
+
+
+
+
+
+
+
+var _chunkMS34J5LYcjs = require('./chunk-MS34J5LY.cjs');
+
+
+
+
+
+var _chunkR3R2FVLGcjs = require('./chunk-R3R2FVLG.cjs');
+
+
+
+
+
+
 
 
 
@@ -86,93 +157,24 @@ var _chunkZTDK2DLGcjs = require('./chunk-ZTDK2DLG.cjs');
 
 
 
-var _chunk2P4PD6D7cjs = require('./chunk-2P4PD6D7.cjs');
 
-// src/core/types/cancel.ts
-function makeCancelToken() {
-  let cancelled = false;
-  const listeners = /* @__PURE__ */ new Set();
-  const cancel = () => {
-    if (cancelled) return;
-    cancelled = true;
-    listeners.forEach((f) => f());
-    listeners.clear();
-  };
-  return {
-    isCancelled: () => cancelled,
-    onCancel: (f) => {
-      if (cancelled) {
-        try {
-          f();
-        } catch (e2) {
-        }
-        return () => {
-        };
-      }
-      listeners.add(f);
-      return () => {
-        listeners.delete(f);
-      };
-    },
-    cancel
-  };
-}
-function linkAbortController(token, ac) {
-  return token.onCancel(() => ac.abort());
-}
 
-// src/core/runtime/linkedQueue.ts
-var LinkedQueue = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
-  __init() {this.head = null}
-  __init2() {this.tail = null}
-  __init3() {this.len = 0}
-  get length() {
-    return this.len;
-  }
-  isEmpty() {
-    return this.len === 0;
-  }
-  push(value) {
-    const node = { value, next: null, prev: this.tail, removed: false };
-    if (this.tail) this.tail.next = node;
-    else this.head = node;
-    this.tail = node;
-    this.len++;
-    return node;
-  }
-  shift() {
-    const h = this.head;
-    if (!h) return void 0;
-    this.unlink(h);
-    return h.value;
-  }
-  remove(node) {
-    if (node.removed) return;
-    this.unlink(node);
-  }
-  unlink(node) {
-    node.removed = true;
-    const { prev, next } = node;
-    if (prev) prev.next = next;
-    else this.head = next;
-    if (next) next.prev = prev;
-    else this.tail = prev;
-    node.next = null;
-    node.prev = null;
-    this.len--;
-  }
-}, _class);
+
+
+
+
+var _chunkTGIFUAK4cjs = require('./chunk-TGIFUAK4.cjs');
 
 // src/core/stream/queue.ts
 function bounded(capacity, strategy = "backpressure", options = {}) {
-  return _chunk2P4PD6D7cjs.asyncSync.call(void 0, () => makeQueue(capacity, strategy, options));
+  return _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => makeQueue(capacity, strategy, options));
 }
 function makeQueue(capacity, strategy, options) {
-  const items = _chunk2P4PD6D7cjs.makeBoundedRingBuffer.call(void 0, capacity, capacity, options);
+  const items = _chunkTGIFUAK4cjs.makeBoundedRingBuffer.call(void 0, capacity, capacity, options);
   let closed = false;
   const QueueClosedErr = { _tag: "QueueClosed" };
-  const offerWaiters = new LinkedQueue();
-  const takers = new LinkedQueue();
+  const offerWaiters = new (0, _chunkXPZNXSVNcjs.LinkedQueue)();
+  const takers = new (0, _chunkXPZNXSVNcjs.LinkedQueue)();
   const shutdown = () => {
     if (closed) return;
     closed = true;
@@ -189,7 +191,7 @@ function makeQueue(capacity, strategy, options) {
   return {
     size: () => items.length,
     shutdown,
-    offer: (a) => _chunk2P4PD6D7cjs.async.call(void 0, (_env, cb) => {
+    offer: (a) => _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_env, cb) => {
       if (closed) {
         cb({ _tag: "Success", value: false });
         return;
@@ -224,7 +226,7 @@ function makeQueue(capacity, strategy, options) {
       };
       return canceler;
     }),
-    take: () => _chunk2P4PD6D7cjs.async.call(void 0, (_env, cb) => {
+    take: () => _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_env, cb) => {
       if (items.length > 0) {
         const a = items.shift();
         cb({ _tag: "Success", value: a });
@@ -250,6 +252,61 @@ function makeQueue(capacity, strategy, options) {
         takers.remove(node);
       };
       return canceler;
+    }),
+    offerBatch: (values) => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => {
+      const results = [];
+      for (let i = 0; i < values.length; i++) {
+        if (closed) {
+          results.push(false);
+          continue;
+        }
+        const a = values[i];
+        if (takers.length > 0) {
+          const t = takers.shift();
+          t({ _tag: "Success", value: a });
+          results.push(true);
+          continue;
+        }
+        if (items.length < capacity) {
+          items.push(a);
+          results.push(true);
+          continue;
+        }
+        if (strategy === "dropping") {
+          results.push(false);
+        } else if (strategy === "sliding") {
+          items.shift();
+          items.push(a);
+          results.push(true);
+        } else {
+          results.push(false);
+        }
+      }
+      return results;
+    }),
+    takeBatch: (n) => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => {
+      const results = [];
+      const count = Math.min(n, items.length + offerWaiters.length);
+      for (let i = 0; i < count; i++) {
+        if (items.length > 0) {
+          results.push(items.shift());
+          if (offerWaiters.length > 0 && items.length < capacity) {
+            const w = offerWaiters.shift();
+            items.push(w.a);
+            w.cb(true);
+          }
+        } else if (offerWaiters.length > 0) {
+          const w = offerWaiters.shift();
+          w.cb(true);
+          results.push(w.a);
+        } else {
+          break;
+        }
+      }
+      if (results.length === 0 && closed) {
+        throw QueueClosedErr;
+      }
+      return results;
     })
   };
 }
@@ -261,34 +318,34 @@ function buffer(stream, capacity, strategy = "backpressure") {
   let q = null;
   let producer = null;
   let upstream = stream;
-  const onUpstreamFailure = (opt) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, 
+  const onUpstreamFailure = (opt) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, 
     opt._tag === "None" ? SIGNAL_END : { _tag: "Fail", error: opt.value }
   );
-  const onUpstreamSuccess = ([a, tail]) => _chunk2P4PD6D7cjs.asyncSync.call(void 0, () => {
+  const onUpstreamSuccess = ([a, tail]) => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => {
     upstream = tail;
     return { _tag: "Elem", value: a };
   });
-  const nextSignal = () => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-    _chunkZTDK2DLGcjs.uncons.call(void 0, upstream),
+  const nextSignal = () => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+    _chunkSTVLQ3XDcjs.uncons.call(void 0, upstream),
     onUpstreamFailure,
     onUpstreamSuccess
   );
-  const start = (env) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, bounded(capacity, strategy), (_q) => {
+  const start = (env) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, bounded(capacity, strategy), (_q) => {
     q = _q;
     let lastSig;
     const afterOffer = () => {
       if (lastSig._tag !== "Elem") {
-        return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, void 0);
+        return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, void 0);
       }
       return loop();
     };
     const onSignal = (sig) => {
       lastSig = sig;
-      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, q.offer(sig), afterOffer);
+      return _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, q.offer(sig), afterOffer);
     };
-    const loop = () => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, nextSignal(), onSignal);
-    producer = _chunk2P4PD6D7cjs.fork.call(void 0, loop(), env);
-    return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, void 0);
+    const loop = () => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, nextSignal(), onSignal);
+    producer = _chunkTGIFUAK4cjs.fork.call(void 0, loop(), env);
+    return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, void 0);
   });
   const pullDown = {
     _tag: "Async",
@@ -296,7 +353,7 @@ function buffer(stream, capacity, strategy = "backpressure") {
       const go = () => {
         if (!started) {
           started = true;
-          _chunk2P4PD6D7cjs.unsafeGetCurrentRuntime.call(void 0, ).fork(start(env)).join(() => {
+          _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime.call(void 0, ).fork(start(env)).join(() => {
             pullFromQueue(env, cb);
           });
           return;
@@ -308,25 +365,25 @@ function buffer(stream, capacity, strategy = "backpressure") {
   };
   function pullFromQueue(env, cb) {
     const takeEff = q.take();
-    _chunk2P4PD6D7cjs.unsafeGetCurrentRuntime.call(void 0, ).fork(takeEff).join((ex) => {
+    _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime.call(void 0, ).fork(takeEff).join((ex) => {
       if (ex._tag !== "Success") return;
       const sig = ex.value;
       switch (sig._tag) {
         case "Elem":
-          cb({ _tag: "Success", value: [sig.value, _chunkZTDK2DLGcjs.fromPull.call(void 0, pullDown)] });
+          cb({ _tag: "Success", value: [sig.value, _chunkSTVLQ3XDcjs.fromPull.call(void 0, pullDown)] });
           return;
         case "End":
           _optionalChain([producer, 'optionalAccess', _ => _.interrupt, 'optionalCall', _2 => _2()]);
-          cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunk2P4PD6D7cjs.none } });
+          cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkTGIFUAK4cjs.none } });
           return;
         case "Fail":
           _optionalChain([producer, 'optionalAccess', _3 => _3.interrupt, 'optionalCall', _4 => _4()]);
-          cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunk2P4PD6D7cjs.some.call(void 0, sig.error) } });
+          cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkTGIFUAK4cjs.some.call(void 0, sig.error) } });
           return;
       }
     });
   }
-  return _chunkZTDK2DLGcjs.fromPull.call(void 0, pullDown);
+  return _chunkSTVLQ3XDcjs.fromPull.call(void 0, pullDown);
 }
 
 // src/core/stream/hub.ts
@@ -335,45 +392,45 @@ function makeHub(capacity, strategy = "BackPressure") {
   const queues = /* @__PURE__ */ new Set();
   let closed = false;
   const publish = (a) => {
-    if (closed) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, false);
+    if (closed) return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, false);
     const size = queues.size;
-    if (size === 0) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, true);
+    if (size === 0) return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, true);
     if (size === 1) {
       const q = queues.values().next().value;
       return q.offer(a);
     }
-    let eff = _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, true);
+    let eff = _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, true);
     for (const q of queues) {
-      eff = _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
+      eff = _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
         eff,
-        (okSoFar) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, q.offer(a), (ok) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, okSoFar && ok))
+        (okSoFar) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, q.offer(a), (ok) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, okSoFar && ok))
       );
     }
     return eff;
   };
   const publishAll = (as) => {
-    let eff = _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, true);
+    let eff = _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, true);
     const it = as[Symbol.iterator]();
     while (true) {
       const n = it.next();
       if (n.done) break;
       const a = n.value;
-      eff = _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
+      eff = _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
         eff,
-        (okSoFar) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, publish(a), (ok) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, okSoFar && ok))
+        (okSoFar) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, publish(a), (ok) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, okSoFar && ok))
       );
     }
     return eff;
   };
   const subscribe = () => {
     if (closed) {
-      return _chunk2P4PD6D7cjs.asyncTotal.call(void 0, () => {
+      return _chunkTGIFUAK4cjs.asyncTotal.call(void 0, () => {
         throw { _tag: "HubClosed" };
       });
     }
-    return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
+    return _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
       bounded(capacity, toQueueStrategy(strategy)),
-      (q) => _chunk2P4PD6D7cjs.asyncSync.call(void 0, () => {
+      (q) => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => {
         queues.add(q);
         return {
           ...q,
@@ -386,7 +443,7 @@ function makeHub(capacity, strategy = "BackPressure") {
       })
     );
   };
-  const shutdown = () => _chunk2P4PD6D7cjs.asyncSync.call(void 0, () => {
+  const shutdown = () => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => {
     if (closed) return;
     closed = true;
     for (const q of queues) q.shutdown();
@@ -401,23 +458,23 @@ function makeHub(capacity, strategy = "BackPressure") {
 }
 var broadcast = makeHub;
 function broadcastToHub(stream, hub) {
-  return _chunkZTDK2DLGcjs.foreachStream.call(void 0, 
+  return _chunkSTVLQ3XDcjs.foreachStream.call(void 0, 
     stream,
-    (a) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, hub.publish(a), () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, void 0))
+    (a) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, hub.publish(a), () => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, void 0))
   );
 }
 function fromHub(hub) {
-  return _chunkZTDK2DLGcjs.managedStream.call(void 0, 
-    _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, hub.subscribe(), (sub) => {
-      const loop = _chunkZTDK2DLGcjs.fromPull.call(void 0, 
-        _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
-          _chunk2P4PD6D7cjs.asyncMapError.call(void 0, sub.take(), (_queueClosed) => _chunk2P4PD6D7cjs.none),
-          (a) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [a, loop])
+  return _chunkSTVLQ3XDcjs.managedStream.call(void 0, 
+    _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, hub.subscribe(), (sub) => {
+      const loop = _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+        _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
+          _chunkTGIFUAK4cjs.asyncMapError.call(void 0, sub.take(), (_queueClosed) => _chunkTGIFUAK4cjs.none),
+          (a) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [a, loop])
         )
       );
-      return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, {
+      return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, {
         stream: loop,
-        release: (_exit) => _chunk2P4PD6D7cjs.asyncSync.call(void 0, () => sub.unsubscribe())
+        release: (_exit) => _chunkTGIFUAK4cjs.asyncSync.call(void 0, () => sub.unsubscribe())
       });
     })
   );
@@ -427,22 +484,20 @@ function fromHub(hub) {
 var cachedWasmChunkCtor;
 function resolveWasmChunkBuffer() {
   if (cachedWasmChunkCtor !== void 0) return cachedWasmChunkCtor;
-  const mod = _chunk2P4PD6D7cjs.resolveWasmModule.call(void 0, );
+  const mod = _chunkTGIFUAK4cjs.resolveWasmModule.call(void 0, );
   cachedWasmChunkCtor = _nullishCoalesce(_optionalChain([mod, 'optionalAccess', _5 => _5.BrassWasmChunkBuffer]), () => ( null));
   return cachedWasmChunkCtor;
 }
-var JsChunker = (_class2 = class {
-  constructor(maxChunkSize, fallbackUsed = false) {;_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);
+var TsChunker = (_class = class {
+  constructor(maxChunkSize) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);
     this.maxChunkSize = maxChunkSize;
-    this.fallbackUsed = fallbackUsed;
   }
   
-  
-  __init4() {this.engine = "js"}
-  __init5() {this.values = []}
-  __init6() {this.emittedChunks = 0}
-  __init7() {this.emittedItems = 0}
-  __init8() {this.flushes = 0}
+  __init() {this.engine = "ts"}
+  __init2() {this.values = []}
+  __init3() {this.emittedChunks = 0}
+  __init4() {this.emittedItems = 0}
+  __init5() {this.flushes = 0}
   get length() {
     return this.values.length;
   }
@@ -472,8 +527,8 @@ var JsChunker = (_class2 = class {
   }
   stats() {
     return {
-      engine: "js",
-      fallbackUsed: this.fallbackUsed,
+      engine: "ts",
+      fallbackUsed: false,
       data: {
         len: this.values.length,
         maxChunkSize: this.maxChunkSize,
@@ -483,12 +538,12 @@ var JsChunker = (_class2 = class {
       }
     };
   }
-}, _class2);
-var WasmChunker = (_class3 = class {
-  __init9() {this.engine = "wasm"}
-  __init10() {this.fallbackUsed = false}
+}, _class);
+var WasmChunker = (_class2 = class {
+  __init6() {this.engine = "wasm"}
+  __init7() {this.fallbackUsed = false}
   
-  constructor(maxChunkSize) {;_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
+  constructor(maxChunkSize) {;_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);
     const Ctor = resolveWasmChunkBuffer();
     if (!Ctor) {
       throw new Error("brass-runtime wasm chunk buffer is not available. Run npm run build:wasm first.");
@@ -519,29 +574,29 @@ var WasmChunker = (_class3 = class {
   stats() {
     return { engine: "wasm", fallbackUsed: false, data: JSON.parse(this.inner.stats_json()) };
   }
-}, _class3);
+}, _class2);
 function makeStreamChunker(chunkSize, options = {}) {
   const size = Math.max(1, chunkSize | 0);
-  const engine = _nullishCoalesce(options.engine, () => ( "auto"));
-  if (engine === "js") return new JsChunker(size, false);
+  const engine = _nullishCoalesce(options.engine, () => ( "ts"));
+  if (engine === "ts") return new TsChunker(size);
   if (engine === "wasm") return new WasmChunker(size);
-  return resolveWasmChunkBuffer() ? new WasmChunker(size) : new JsChunker(size, true);
+  throw new Error(`brass-runtime stream chunk engine must be 'ts' or 'wasm'; received '${String(engine)}'`);
 }
 function chunks(input, chunkSize, options = {}) {
   const size = Math.max(1, chunkSize | 0);
-  const loop = (cur) => _chunkZTDK2DLGcjs.fromPull.call(void 0, fillChunk(cur, makeStreamChunker(size, options)));
-  const fillChunk = (cur, chunker) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-    _chunkZTDK2DLGcjs.uncons.call(void 0, cur),
+  const loop = (cur) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, fillChunk(cur, makeStreamChunker(size, options)));
+  const fillChunk = (cur, chunker) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+    _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
     (opt) => {
       if (opt._tag === "None" && !chunker.isEmpty()) {
-        return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [chunker.takeChunk(), _chunkZTDK2DLGcjs.fromPull.call(void 0, _chunk2P4PD6D7cjs.asyncFail.call(void 0, _chunk2P4PD6D7cjs.none))]);
+        return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [chunker.takeChunk(), _chunkSTVLQ3XDcjs.fromPull.call(void 0, _chunkTGIFUAK4cjs.asyncFail.call(void 0, _chunkTGIFUAK4cjs.none))]);
       }
-      return _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt);
+      return _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt);
     },
     ([a, tail]) => {
       chunker.push(a);
       if (chunker.isFull()) {
-        return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [chunker.takeChunk(), loop(tail)]);
+        return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [chunker.takeChunk(), loop(tail)]);
       }
       return fillChunk(tail, chunker);
     }
@@ -552,15 +607,15 @@ function mapChunks(input, chunkSize, f, options = {}) {
   const pullOne = (pending, rest) => {
     if (pending.length > 0) {
       const [head, ...tail] = pending;
-      return _chunkZTDK2DLGcjs.fromPull.call(void 0, _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [head, pullOne(tail, rest)]));
+      return _chunkSTVLQ3XDcjs.fromPull.call(void 0, _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [head, pullOne(tail, rest)]));
     }
-    return _chunkZTDK2DLGcjs.fromPull.call(void 0, 
-      _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-        _chunkZTDK2DLGcjs.uncons.call(void 0, rest),
-        (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
+    return _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+      _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        _chunkSTVLQ3XDcjs.uncons.call(void 0, rest),
+        (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
         ([chunk, tail]) => {
           const mapped = f(chunk);
-          return _chunkZTDK2DLGcjs.uncons.call(void 0, pullOne(mapped, tail));
+          return _chunkSTVLQ3XDcjs.uncons.call(void 0, pullOne(mapped, tail));
         }
       )
     );
@@ -573,16 +628,16 @@ function mapChunksEffect(chunkSize, f, options = {}) {
     const pullOne = (pending, rest) => {
       if (pending.length > 0) {
         const [head, ...tail] = pending;
-        return _chunkZTDK2DLGcjs.fromPull.call(void 0, _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [head, pullOne(tail, rest)]));
+        return _chunkSTVLQ3XDcjs.fromPull.call(void 0, _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [head, pullOne(tail, rest)]));
       }
-      return _chunkZTDK2DLGcjs.fromPull.call(void 0, 
-        _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-          _chunk2P4PD6D7cjs.asyncMapError.call(void 0, _chunkZTDK2DLGcjs.uncons.call(void 0, rest), (opt) => _chunkZTDK2DLGcjs.widenOpt.call(void 0, opt)),
-          (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
-          ([chunk, tail]) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-            _chunk2P4PD6D7cjs.asyncMapError.call(void 0, f(chunk), (e) => ({ _tag: "Some", value: e })),
-            (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
-            (mapped) => _chunkZTDK2DLGcjs.uncons.call(void 0, pullOne(mapped, tail))
+      return _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+        _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+          _chunkTGIFUAK4cjs.asyncMapError.call(void 0, _chunkSTVLQ3XDcjs.uncons.call(void 0, rest), (opt) => _chunkSTVLQ3XDcjs.widenOpt.call(void 0, opt)),
+          (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+          ([chunk, tail]) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+            _chunkTGIFUAK4cjs.asyncMapError.call(void 0, f(chunk), (e) => ({ _tag: "Some", value: e })),
+            (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+            (mapped) => _chunkSTVLQ3XDcjs.uncons.call(void 0, pullOne(mapped, tail))
           )
         )
       );
@@ -591,100 +646,517 @@ function mapChunksEffect(chunkSize, f, options = {}) {
   });
 }
 
+// src/core/stream/fusion.ts
+var _fusionEnabled = true;
+var _fusionVerbose = false;
+function setFusionEnabled(enabled) {
+  _fusionEnabled = enabled;
+}
+function isFusionEnabled() {
+  return _fusionEnabled;
+}
+function setFusionVerbose(verbose) {
+  _fusionVerbose = verbose;
+}
+function isFusionVerbose() {
+  return _fusionVerbose;
+}
+function getStats(pipeline) {
+  const p = pipeline;
+  if (p._fusedSteps && Array.isArray(p._fusedSteps)) {
+    const metas = p._fusedSteps;
+    return buildStats(metas);
+  }
+  if (p[PURE_PIPELINE_TAG]) {
+    return null;
+  }
+  return null;
+}
+var PURE_PIPELINE_TAG = /* @__PURE__ */ Symbol("brass:pure-pipeline");
+function makeMapStep(fn) {
+  return (a, _state) => ({ tag: "emit", value: fn(a) });
+}
+function makeFilterStep(pred) {
+  return (a, _state) => pred(a) ? { tag: "emit", value: a } : { tag: "skip" };
+}
+function makeTakeStep(n, counterIndex) {
+  return (a, state) => {
+    if (state.counters[counterIndex] >= n) {
+      return { tag: "halt" };
+    }
+    state.counters[counterIndex]++;
+    return { tag: "emit", value: a };
+  };
+}
+function makeDropStep(n, counterIndex) {
+  return (a, state) => {
+    if (state.counters[counterIndex] < n) {
+      state.counters[counterIndex]++;
+      return { tag: "skip" };
+    }
+    return { tag: "emit", value: a };
+  };
+}
+function initState(counterCount) {
+  return () => ({
+    counters: new Array(counterCount).fill(0)
+  });
+}
+function composeSteps(step1, step2) {
+  return (a, state) => {
+    const r1 = step1(a, state);
+    if (r1.tag !== "emit") return r1;
+    return step2(r1.value, state);
+  };
+}
+function getPureTag(pipeline) {
+  const tagged = pipeline;
+  return _nullishCoalesce(tagged[PURE_PIPELINE_TAG], () => ( null));
+}
+function getFusedSteps(pipeline) {
+  const p = pipeline;
+  if (p._fusedSteps && Array.isArray(p._fusedSteps)) {
+    return p._fusedSteps;
+  }
+  return null;
+}
+function buildStepFromMetadata(meta, counterIndex) {
+  switch (meta.kind) {
+    case "map":
+      return makeMapStep(meta.fn);
+    case "filter":
+      return makeFilterStep(meta.pred);
+    case "take":
+      return makeTakeStep(meta.n, counterIndex);
+    case "drop":
+      return makeDropStep(meta.n, counterIndex);
+  }
+}
+function buildStats(metas) {
+  const steps = metas.map((m) => {
+    switch (m.kind) {
+      case "map":
+        return { kind: "map" };
+      case "filter":
+        return { kind: "filter" };
+      case "take":
+        return { kind: "take", n: m.n };
+      case "drop":
+        return { kind: "drop", n: m.n };
+    }
+  });
+  return {
+    fusedSteps: steps.length,
+    steps,
+    hasTake: metas.some((m) => m.kind === "take"),
+    hasDrop: metas.some((m) => m.kind === "drop")
+  };
+}
+function countCounters(metas) {
+  let count = 0;
+  for (const m of metas) {
+    if (m.kind === "take" || m.kind === "drop") {
+      count++;
+    }
+  }
+  return count;
+}
+function fuse(pipeline, options) {
+  const verbose = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.verbose]), () => ( _fusionVerbose));
+  if (_optionalChain([options, 'optionalAccess', _7 => _7.enabled]) === false || !_fusionEnabled && _optionalChain([options, 'optionalAccess', _8 => _8.enabled]) !== true) {
+    if (verbose) {
+      console.log("[FusionEngine] Fusion disabled by options");
+    }
+    return null;
+  }
+  const metas = collectMetadata(pipeline);
+  if (!metas || metas.length === 0) {
+    if (verbose) {
+      console.log("[FusionEngine] Pipeline is not fusable (no pure tags detected)");
+    }
+    return null;
+  }
+  if (verbose) {
+    console.log(
+      `[FusionEngine] Fusing ${metas.length} steps: ${metas.map((m) => m.kind).join(" \u2192 ")}`
+    );
+  }
+  let counterIndex = 0;
+  let composedStep = buildStepFromMetadata(
+    metas[0],
+    metas[0].kind === "take" || metas[0].kind === "drop" ? counterIndex++ : -1
+  );
+  for (let i = 1; i < metas.length; i++) {
+    const meta = metas[i];
+    const idx = meta.kind === "take" || meta.kind === "drop" ? counterIndex++ : -1;
+    composedStep = composeSteps(composedStep, buildStepFromMetadata(meta, idx));
+  }
+  const counterCount = countCounters(metas);
+  const stats = buildStats(metas);
+  return {
+    _tag: "FusedPipeline",
+    step: composedStep,
+    initState: initState(counterCount),
+    stats
+  };
+}
+function collectMetadata(pipeline) {
+  const fusedSteps = getFusedSteps(pipeline);
+  if (fusedSteps) {
+    return fusedSteps;
+  }
+  const tag = getPureTag(pipeline);
+  if (tag) {
+    return [tag];
+  }
+  return null;
+}
+function runFusedArray(input, fused) {
+  const state = fused.initState();
+  const output = [];
+  for (let i = 0; i < input.length; i++) {
+    const result = fused.step(input[i], state);
+    switch (result.tag) {
+      case "emit":
+        output.push(result.value);
+        break;
+      case "skip":
+        break;
+      case "halt":
+        return output;
+    }
+  }
+  return output;
+}
+function drainStreamSync(stream) {
+  const result = [];
+  let cur = stream;
+  while (true) {
+    switch (cur._tag) {
+      case "Empty":
+        return result;
+      case "FromArray": {
+        const arr = cur.values;
+        for (let i = 0; i < arr.length; i++) {
+          result.push(arr[i]);
+        }
+        return result;
+      }
+      case "Emit": {
+        const zio = cur.value;
+        if (zio._tag === "Succeed") {
+          result.push(zio.value);
+          return result;
+        }
+        return null;
+      }
+      case "Concat": {
+        const leftItems = drainStreamSync(cur.left);
+        if (leftItems === null) return null;
+        for (let i = 0; i < leftItems.length; i++) {
+          result.push(leftItems[i]);
+        }
+        cur = cur.right;
+        break;
+      }
+      default:
+        return null;
+    }
+  }
+}
+function applyFused(stream, fused) {
+  const inputArray = drainStreamSync(stream);
+  if (inputArray !== null) {
+    const outputArray = runFusedArray(inputArray, fused);
+    return arrayToStream(outputArray);
+  }
+  const state = fused.initState();
+  const loop = (cur) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+    _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+      // End-of-stream or error: propagate
+      (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+      ([a, tail]) => {
+        const result = fused.step(a, state);
+        switch (result.tag) {
+          case "emit":
+            return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [result.value, loop(tail)]);
+          case "skip":
+            return _chunkSTVLQ3XDcjs.uncons.call(void 0, loop(tail));
+          case "halt":
+            return _chunkTGIFUAK4cjs.asyncFail.call(void 0, _chunkTGIFUAK4cjs.none);
+        }
+      }
+    )
+  );
+  return loop(stream);
+}
+function arrayToStream(values) {
+  if (values.length === 0) return { _tag: "Empty" };
+  return { _tag: "FromArray", values };
+}
+function serializeFusedPipeline(pipeline) {
+  const p = pipeline;
+  let metas = null;
+  if (p._fusedSteps && Array.isArray(p._fusedSteps)) {
+    metas = p._fusedSteps;
+  } else if (p[PURE_PIPELINE_TAG]) {
+    return null;
+  }
+  if (!metas || metas.length === 0) {
+    return null;
+  }
+  const steps = metas.map((meta) => {
+    switch (meta.kind) {
+      case "map":
+        return { kind: "map", fnSource: meta.fn.toString() };
+      case "filter":
+        return { kind: "filter", predSource: meta.pred.toString() };
+      case "take":
+        return { kind: "take", n: meta.n };
+      case "drop":
+        return { kind: "drop", n: meta.n };
+    }
+  });
+  return { version: 1, steps };
+}
+function deserializeFusedPipeline(serialized) {
+  try {
+    if (serialized.version !== 1) {
+      return null;
+    }
+    if (!serialized.steps || serialized.steps.length === 0) {
+      return null;
+    }
+    const metas = [];
+    for (const step of serialized.steps) {
+      switch (step.kind) {
+        case "map": {
+          const fn = new Function("return " + step.fnSource)();
+          if (typeof fn !== "function") return null;
+          metas.push({ kind: "map", fn });
+          break;
+        }
+        case "filter": {
+          const pred = new Function("return " + step.predSource)();
+          if (typeof pred !== "function") return null;
+          metas.push({ kind: "filter", pred });
+          break;
+        }
+        case "take": {
+          if (typeof step.n !== "number" || step.n < 0) return null;
+          metas.push({ kind: "take", n: step.n });
+          break;
+        }
+        case "drop": {
+          if (typeof step.n !== "number" || step.n < 0) return null;
+          metas.push({ kind: "drop", n: step.n });
+          break;
+        }
+        default:
+          return null;
+      }
+    }
+    const carrier = createDeserializedCarrier(metas);
+    return carrier;
+  } catch (e2) {
+    return null;
+  }
+}
+function createDeserializedCarrier(metas) {
+  let counterIndex = 0;
+  let composedStep = buildStepFromMetadata(
+    metas[0],
+    metas[0].kind === "take" || metas[0].kind === "drop" ? counterIndex++ : -1
+  );
+  for (let i = 1; i < metas.length; i++) {
+    const meta = metas[i];
+    const idx = meta.kind === "take" || meta.kind === "drop" ? counterIndex++ : -1;
+    composedStep = composeSteps(composedStep, buildStepFromMetadata(meta, idx));
+  }
+  const counterCount = countCounters(metas);
+  const stats = buildStats(metas);
+  const fusedRepr = {
+    _tag: "FusedPipeline",
+    step: composedStep,
+    initState: initState(counterCount),
+    stats
+  };
+  const pipeline = ((input) => {
+    return applyFused(input, fusedRepr);
+  });
+  pipeline._fusedSteps = metas;
+  return pipeline;
+}
+
 // src/core/stream/pipeline.ts
 function via(stream, pipeline) {
+  if (isFusionEnabled()) {
+    const p = pipeline;
+    if (p._fusedSteps || p[PURE_PIPELINE_TAG]) {
+      let fusedRepr = p._cachedFusedRepr;
+      if (!fusedRepr) {
+        fusedRepr = fuse(pipeline);
+        if (fusedRepr) p._cachedFusedRepr = fusedRepr;
+      }
+      if (fusedRepr) {
+        return applyFused(stream, fusedRepr);
+      }
+    }
+  }
   return pipeline(stream);
 }
-function andThen(p1, p2) {
+function andThen2(p1, p2) {
+  const fused = tryFuse(p1, p2);
+  if (fused) return fused;
   return ((input) => p2(p1(input)));
 }
-function compose(p2, p1) {
-  return andThen(p1, p2);
+function collectPureMetas(pipeline) {
+  const p = pipeline;
+  if (p._fusedSteps && Array.isArray(p._fusedSteps)) {
+    return p._fusedSteps;
+  }
+  const tag = p[PURE_PIPELINE_TAG];
+  if (tag) {
+    return [tag];
+  }
+  return null;
+}
+function tryFuse(p1, p2) {
+  if (!isFusionEnabled()) {
+    if (isFusionVerbose()) {
+      console.log("[FusionEngine] andThen: fusion globally disabled, skipping");
+    }
+    return null;
+  }
+  const metas1 = collectPureMetas(p1);
+  const metas2 = collectPureMetas(p2);
+  if (!metas1 || !metas2) {
+    if (isFusionVerbose()) {
+      const reason = !metas1 && !metas2 ? "neither operand is pure" : !metas1 ? "left operand is not pure" : "right operand is not pure";
+      console.log(`[FusionEngine] andThen: cannot fuse \u2014 ${reason}`);
+    }
+    return null;
+  }
+  const combinedMetas = [...metas1, ...metas2];
+  const fusedRepr = fuse(
+    createMetadataCarrier(combinedMetas)
+  );
+  if (!fusedRepr) {
+    return null;
+  }
+  if (isFusionVerbose()) {
+    console.log(
+      `[FusionEngine] andThen: fused ${combinedMetas.length} steps: ${combinedMetas.map((m) => m.kind).join(" \u2192 ")}`
+    );
+  }
+  const fusedPipeline = ((input) => {
+    return applyFused(input, fusedRepr);
+  });
+  fusedPipeline._fusedSteps = combinedMetas;
+  return fusedPipeline;
+}
+function createMetadataCarrier(metas) {
+  const carrier = (() => {
+  });
+  carrier._fusedSteps = metas;
+  return carrier;
+}
+function compose2(p2, p1) {
+  return andThen2(p1, p2);
 }
 function identity() {
   return ((input) => input);
 }
 function mapP(f) {
-  return ((input) => {
-    const onError = (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt);
-    const onSuccess = ([a, tail]) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [f(a), loop(tail)]);
-    const loop = (cur) => _chunkZTDK2DLGcjs.fromPull.call(void 0, 
-      _chunk2P4PD6D7cjs.asyncFold.call(void 0, _chunkZTDK2DLGcjs.uncons.call(void 0, cur), onError, onSuccess)
+  const pipeline = ((input) => {
+    const onError = (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt);
+    const onSuccess = ([a, tail]) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [f(a), loop(tail)]);
+    const loop = (cur) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+      _chunkTGIFUAK4cjs.asyncFold.call(void 0, _chunkSTVLQ3XDcjs.uncons.call(void 0, cur), onError, onSuccess)
     );
     return loop(input);
   });
+  pipeline[PURE_PIPELINE_TAG] = { kind: "map", fn: f };
+  return pipeline;
 }
 function filterP(pred) {
-  return ((input) => {
-    const onError = (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt);
-    const onSuccess = ([a, tail]) => pred(a) ? _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [a, loop(tail)]) : next(tail);
-    const next = (cur) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, _chunkZTDK2DLGcjs.uncons.call(void 0, cur), onError, onSuccess);
-    const loop = (cur) => _chunkZTDK2DLGcjs.fromPull.call(void 0, next(cur));
+  const pipeline = ((input) => {
+    const onError = (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt);
+    const onSuccess = ([a, tail]) => pred(a) ? _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [a, loop(tail)]) : next(tail);
+    const next = (cur) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, _chunkSTVLQ3XDcjs.uncons.call(void 0, cur), onError, onSuccess);
+    const loop = (cur) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, next(cur));
     return loop(input);
   });
+  pipeline[PURE_PIPELINE_TAG] = { kind: "filter", pred };
+  return pipeline;
 }
 function filterMapP(f) {
   return ((input) => {
-    const onError = (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt);
-    const next = (cur) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-      _chunkZTDK2DLGcjs.uncons.call(void 0, cur),
+    const onError = (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt);
+    const next = (cur) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
       onError,
       ([a, tail]) => {
         const ob = f(a);
-        return ob._tag === "Some" ? _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [ob.value, loop(tail)]) : next(tail);
+        return ob._tag === "Some" ? _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [ob.value, loop(tail)]) : next(tail);
       }
     );
-    const loop = (cur) => _chunkZTDK2DLGcjs.fromPull.call(void 0, next(cur));
+    const loop = (cur) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, next(cur));
     return loop(input);
   });
 }
 function takeP(n) {
   const m = Math.max(0, n | 0);
-  return ((input) => {
+  const pipeline = ((input) => {
     const loop = (cur, remaining) => {
-      if (remaining <= 0) return _chunkZTDK2DLGcjs.emptyStream.call(void 0, );
-      return _chunkZTDK2DLGcjs.fromPull.call(void 0, 
-        _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-          _chunkZTDK2DLGcjs.uncons.call(void 0, cur),
-          (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
-          ([a, tail]) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [a, loop(tail, remaining - 1)])
+      if (remaining <= 0) return _chunkSTVLQ3XDcjs.emptyStream.call(void 0, );
+      return _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+        _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+          _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+          (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+          ([a, tail]) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [a, loop(tail, remaining - 1)])
         )
       );
     };
     return loop(input, m);
   });
+  pipeline[PURE_PIPELINE_TAG] = { kind: "take", n: m };
+  return pipeline;
 }
 function dropP(n) {
   const m = Math.max(0, n | 0);
-  return ((input) => {
+  const pipeline = ((input) => {
     const skip = (cur, remaining) => {
       if (remaining <= 0) return cur;
-      return _chunkZTDK2DLGcjs.fromPull.call(void 0, 
-        _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-          _chunkZTDK2DLGcjs.uncons.call(void 0, cur),
-          (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
-          ([_a, tail]) => _chunkZTDK2DLGcjs.uncons.call(void 0, skip(tail, remaining - 1))
+      return _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+        _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+          _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+          (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+          ([_a, tail]) => _chunkSTVLQ3XDcjs.uncons.call(void 0, skip(tail, remaining - 1))
         )
       );
     };
     return skip(input, m);
   });
+  pipeline[PURE_PIPELINE_TAG] = { kind: "drop", n: m };
+  return pipeline;
 }
 function mapEffectP(f) {
   return ((input) => {
-    const raiseToOpt = (fa) => _chunk2P4PD6D7cjs.asyncMapError.call(void 0, fa, (e) => _chunk2P4PD6D7cjs.some.call(void 0, e));
-    const loop = (cur) => _chunkZTDK2DLGcjs.fromPull.call(void 0, 
-      _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-        _chunk2P4PD6D7cjs.asyncMapError.call(void 0, 
-          _chunkZTDK2DLGcjs.uncons.call(void 0, cur),
-          (opt) => _chunkZTDK2DLGcjs.widenOpt.call(void 0, opt)
+    const raiseToOpt = (fa) => _chunkTGIFUAK4cjs.asyncMapError.call(void 0, fa, (e) => _chunkTGIFUAK4cjs.some.call(void 0, e));
+    const loop = (cur) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+      _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        _chunkTGIFUAK4cjs.asyncMapError.call(void 0, 
+          _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+          (opt) => _chunkSTVLQ3XDcjs.widenOpt.call(void 0, opt)
         ),
-        (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
-        ([a, tail]) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
+        (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+        ([a, tail]) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
           raiseToOpt(f(a)),
           // Async<Rp, ...>
-          (opt2) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt2),
-          (b) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [b, loop(tail)])
+          (opt2) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt2),
+          (b) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [b, loop(tail)])
         )
       )
     );
@@ -692,7 +1164,7 @@ function mapEffectP(f) {
   });
 }
 function tapEffectP(f) {
-  return mapEffectP((a) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, f(a), () => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, a)));
+  return mapEffectP((a) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, f(a), () => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, a)));
 }
 function chunksP(chunkSize, options = {}) {
   return ((input) => chunks(input, chunkSize, options));
@@ -707,23 +1179,23 @@ function groupedP(n) {
   const size = Math.max(1, n | 0);
   return ((input) => {
     const gather = (cur, remaining, acc) => {
-      if (remaining <= 0) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { chunk: acc, rest: cur });
-      return _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-        _chunkZTDK2DLGcjs.uncons.call(void 0, cur),
+      if (remaining <= 0) return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, { chunk: acc, rest: cur });
+      return _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
         (opt) => {
-          if (opt._tag === "None") return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, { chunk: acc, rest: _chunkZTDK2DLGcjs.emptyStream.call(void 0, ) });
-          return _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt);
+          if (opt._tag === "None") return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, { chunk: acc, rest: _chunkSTVLQ3XDcjs.emptyStream.call(void 0, ) });
+          return _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt);
         },
         ([a, tail]) => gather(tail, remaining - 1, [...acc, a])
       );
     };
-    const loop = (cur) => _chunkZTDK2DLGcjs.fromPull.call(void 0, 
-      _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-        _chunkZTDK2DLGcjs.uncons.call(void 0, cur),
-        (opt) => _chunk2P4PD6D7cjs.asyncFail.call(void 0, opt),
-        ([a, tail]) => _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, 
+    const loop = (cur) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+      _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+        (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+        ([a, tail]) => _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, 
           gather(tail, size - 1, [a]),
-          ({ chunk, rest }) => _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, [chunk, loop(rest)])
+          ({ chunk, rest }) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [chunk, loop(rest)])
         )
       )
     );
@@ -731,12 +1203,169 @@ function groupedP(n) {
   });
 }
 
+// src/core/stream/operators.ts
+function throttle(stream, intervalMs) {
+  let lastEmitTime = 0;
+  const loop = (cur) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+    _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+      (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+      ([a, tail]) => {
+        const now = Date.now();
+        if (now - lastEmitTime >= intervalMs) {
+          lastEmitTime = now;
+          return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [a, loop(tail)]);
+        }
+        return _chunkSTVLQ3XDcjs.uncons.call(void 0, loop(tail));
+      }
+    )
+  );
+  return loop(stream);
+}
+function debounce(stream, delayMs) {
+  return _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+    _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (_env, cb) => {
+      let lastValue;
+      let hasValue = false;
+      let timerId;
+      let done = false;
+      let tail = stream;
+      const pullNext = () => {
+        if (done) return;
+        const pull = _chunkSTVLQ3XDcjs.uncons.call(void 0, tail);
+        _chunkTGIFUAK4cjs.unsafeRunAsync.call(void 0, pull, _env, (exit) => {
+          if (done) return;
+          if (exit._tag === "Failure") {
+            if (hasValue) {
+              const value = lastValue;
+              hasValue = false;
+              clearTimeout(timerId);
+              cb({ _tag: "Success", value: [value, _chunkSTVLQ3XDcjs.emptyStream.call(void 0, )] });
+            } else {
+              cb(exit);
+            }
+            return;
+          }
+          const [a, nextTail] = exit.value;
+          tail = nextTail;
+          lastValue = a;
+          hasValue = true;
+          clearTimeout(timerId);
+          timerId = setTimeout(() => {
+            if (done) return;
+            const value = lastValue;
+            hasValue = false;
+            done = true;
+            cb({ _tag: "Success", value: [value, debounce(tail, delayMs)] });
+          }, delayMs);
+          pullNext();
+        });
+      };
+      pullNext();
+      return () => {
+        done = true;
+        clearTimeout(timerId);
+      };
+    })
+  );
+}
+function zip2(left, right) {
+  const loop = (l, r) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+    _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      _chunkSTVLQ3XDcjs.uncons.call(void 0, l),
+      (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+      ([a, lTail]) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        _chunkSTVLQ3XDcjs.uncons.call(void 0, r),
+        (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+        ([b, rTail]) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [[a, b], loop(lTail, rTail)])
+      )
+    )
+  );
+  return loop(left, right);
+}
+function zipWith(left, right, f) {
+  const loop = (l, r) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+    _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      _chunkSTVLQ3XDcjs.uncons.call(void 0, l),
+      (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+      ([a, lTail]) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        _chunkSTVLQ3XDcjs.uncons.call(void 0, r),
+        (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+        ([b, rTail]) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [f(a, b), loop(lTail, rTail)])
+      )
+    )
+  );
+  return loop(left, right);
+}
+function scan(stream, initial, f) {
+  const loop = (cur, acc) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+    _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+      (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+      ([a, tail]) => {
+        const next = f(acc, a);
+        return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [next, loop(tail, next)]);
+      }
+    )
+  );
+  return _chunkSTVLQ3XDcjs.concatStream.call(void 0, 
+    _chunkSTVLQ3XDcjs.emitStream.call(void 0, _chunkTGIFUAK4cjs.succeed.call(void 0, initial)),
+    loop(stream, initial)
+  );
+}
+function interleave(left, right) {
+  const loop = (l, r, pickLeft) => _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+    _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      _chunkSTVLQ3XDcjs.uncons.call(void 0, pickLeft ? l : r),
+      // Current stream ended — drain the other
+      (_opt) => _chunkSTVLQ3XDcjs.uncons.call(void 0, pickLeft ? r : l),
+      ([a, tail]) => {
+        const nextL = pickLeft ? tail : l;
+        const nextR = pickLeft ? r : tail;
+        return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [a, loop(nextL, nextR, !pickLeft)]);
+      }
+    )
+  );
+  return loop(left, right, true);
+}
+function take2(stream, n) {
+  if (n <= 0) return _chunkSTVLQ3XDcjs.emptyStream.call(void 0, );
+  const loop = (cur, remaining) => {
+    if (remaining <= 0) return _chunkSTVLQ3XDcjs.emptyStream.call(void 0, );
+    return _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+      _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+        (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+        ([a, tail]) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, [a, loop(tail, remaining - 1)])
+      )
+    );
+  };
+  return loop(stream, n);
+}
+function drop(stream, n) {
+  if (n <= 0) return stream;
+  const skip = (cur, remaining) => {
+    if (remaining <= 0) return cur;
+    return _chunkSTVLQ3XDcjs.fromPull.call(void 0, 
+      _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+        _chunkSTVLQ3XDcjs.uncons.call(void 0, cur),
+        (opt) => _chunkTGIFUAK4cjs.asyncFail.call(void 0, opt),
+        ([_a, tail]) => _chunkSTVLQ3XDcjs.uncons.call(void 0, skip(tail, remaining - 1))
+      )
+    );
+  };
+  return skip(stream, n);
+}
+
 // src/core/runtime/engineStats.ts
-function engineStats(engine, data, fallbackUsed = false) {
-  return { engine, data, fallbackUsed };
+function engineStats(engine, data) {
+  return { engine, data, fallbackUsed: false };
 }
 function selectedEngineStats(requested, engine, data) {
-  return { requested, engine, data, fallbackUsed: requested === "auto" && engine !== "wasm" };
+  if (requested !== engine) {
+    throw new Error(`brass-runtime strict engine mismatch: requested '${requested}', got '${engine}'`);
+  }
+  return { requested, engine, data, fallbackUsed: false };
 }
 
 
@@ -852,4 +1481,92 @@ function selectedEngineStats(requested, engine, data) {
 
 
 
-exports.Async = _chunk2P4PD6D7cjs.Async; exports.Cause = _chunk2P4PD6D7cjs.Cause; exports.DefaultHostExecutor = _chunk2P4PD6D7cjs.DefaultHostExecutor; exports.EngineFiberHandle = _chunk2P4PD6D7cjs.EngineFiberHandle; exports.Exit = _chunk2P4PD6D7cjs.Exit; exports.HostRegistry = _chunk2P4PD6D7cjs.HostRegistry; exports.JsFiberEngine = _chunk2P4PD6D7cjs.JsFiberEngine; exports.NoopHooks = _chunk2P4PD6D7cjs.NoopHooks; exports.ProgramBuilder = _chunk2P4PD6D7cjs.ProgramBuilder; exports.PushStatus = _chunk2P4PD6D7cjs.PushStatus; exports.ReferenceWasmBridge = _chunk2P4PD6D7cjs.ReferenceWasmBridge; exports.RingBuffer = _chunk2P4PD6D7cjs.RingBuffer; exports.Runtime = _chunk2P4PD6D7cjs.Runtime; exports.RuntimeFiber = _chunk2P4PD6D7cjs.RuntimeFiber; exports.Scheduler = _chunk2P4PD6D7cjs.Scheduler; exports.Scope = _chunk2P4PD6D7cjs.Scope; exports.WasmFiberEngine = _chunk2P4PD6D7cjs.WasmFiberEngine; exports.WasmFiberRegistryBridge = _chunk2P4PD6D7cjs.WasmFiberRegistryBridge; exports.WasmPackFiberBridge = _chunk2P4PD6D7cjs.WasmPackFiberBridge; exports.acquireRelease = _chunk2P4PD6D7cjs.acquireRelease; exports.andThen = andThen; exports.assertNever = _chunkZTDK2DLGcjs.assertNever; exports.async = _chunk2P4PD6D7cjs.async; exports.asyncCatchAll = _chunk2P4PD6D7cjs.asyncCatchAll; exports.asyncFail = _chunk2P4PD6D7cjs.asyncFail; exports.asyncFlatMap = _chunk2P4PD6D7cjs.asyncFlatMap; exports.asyncFold = _chunk2P4PD6D7cjs.asyncFold; exports.asyncInterruptible = _chunk2P4PD6D7cjs.asyncInterruptible; exports.asyncMap = _chunk2P4PD6D7cjs.asyncMap; exports.asyncMapError = _chunk2P4PD6D7cjs.asyncMapError; exports.asyncSucceed = _chunk2P4PD6D7cjs.asyncSucceed; exports.asyncSync = _chunk2P4PD6D7cjs.asyncSync; exports.asyncTotal = _chunk2P4PD6D7cjs.asyncTotal; exports.bounded = bounded; exports.broadcast = broadcast; exports.broadcastToHub = broadcastToHub; exports.buffer = buffer; exports.bufferP = bufferP; exports.catchAll = _chunk2P4PD6D7cjs.catchAll; exports.chunks = chunks; exports.chunksP = chunksP; exports.collectAllPar = _chunk2P4PD6D7cjs.collectAllPar; exports.collectStream = _chunkZTDK2DLGcjs.collectStream; exports.compose = compose; exports.concatStream = _chunkZTDK2DLGcjs.concatStream; exports.dropP = dropP; exports.emitStream = _chunkZTDK2DLGcjs.emitStream; exports.emptyStream = _chunkZTDK2DLGcjs.emptyStream; exports.end = _chunk2P4PD6D7cjs.end; exports.engineStats = engineStats; exports.fail = _chunk2P4PD6D7cjs.fail; exports.filterMapP = filterMapP; exports.filterP = filterP; exports.flatMap = _chunk2P4PD6D7cjs.flatMap; exports.flattenStream = _chunkZTDK2DLGcjs.flattenStream; exports.foreachStream = _chunkZTDK2DLGcjs.foreachStream; exports.fork = _chunk2P4PD6D7cjs.fork; exports.fromArray = _chunkZTDK2DLGcjs.fromArray; exports.fromHub = fromHub; exports.fromPromiseAbortable = _chunk2P4PD6D7cjs.fromPromiseAbortable; exports.fromPull = _chunkZTDK2DLGcjs.fromPull; exports.getBenchmarkBudget = _chunk2P4PD6D7cjs.getBenchmarkBudget; exports.getCurrentFiber = _chunk2P4PD6D7cjs.getCurrentFiber; exports.globalScheduler = _chunk2P4PD6D7cjs.globalScheduler; exports.groupedP = groupedP; exports.identity = identity; exports.linkAbortController = linkAbortController; exports.makeBoundedRingBuffer = _chunk2P4PD6D7cjs.makeBoundedRingBuffer; exports.makeCancelToken = makeCancelToken; exports.makeHub = makeHub; exports.makeStreamChunker = makeStreamChunker; exports.managedStream = _chunkZTDK2DLGcjs.managedStream; exports.map = _chunk2P4PD6D7cjs.map; exports.mapAsync = _chunk2P4PD6D7cjs.mapAsync; exports.mapChunks = mapChunks; exports.mapChunksEffect = mapChunksEffect; exports.mapChunksEffectP = mapChunksEffectP; exports.mapEffectP = mapEffectP; exports.mapError = _chunk2P4PD6D7cjs.mapError; exports.mapP = mapP; exports.mapStream = _chunkZTDK2DLGcjs.mapStream; exports.mapTryAsync = _chunk2P4PD6D7cjs.mapTryAsync; exports.merge = _chunkZTDK2DLGcjs.merge; exports.mergeStream = _chunkZTDK2DLGcjs.mergeStream; exports.none = _chunk2P4PD6D7cjs.none; exports.orElseOptional = _chunk2P4PD6D7cjs.orElseOptional; exports.race = _chunk2P4PD6D7cjs.race; exports.raceWith = _chunk2P4PD6D7cjs.raceWith; exports.rangeStream = _chunkZTDK2DLGcjs.rangeStream; exports.runtimeCapabilities = _chunk2P4PD6D7cjs.runtimeCapabilities; exports.selectedEngineStats = selectedEngineStats; exports.setBenchmarkBudget = _chunk2P4PD6D7cjs.setBenchmarkBudget; exports.some = _chunk2P4PD6D7cjs.some; exports.streamFromReadableStream = _chunkZTDK2DLGcjs.streamFromReadableStream; exports.succeed = _chunk2P4PD6D7cjs.succeed; exports.sync = _chunk2P4PD6D7cjs.sync; exports.takeP = takeP; exports.tapEffectP = tapEffectP; exports.toPromise = _chunk2P4PD6D7cjs.toPromise; exports.uncons = _chunkZTDK2DLGcjs.uncons; exports.unit = _chunk2P4PD6D7cjs.unit; exports.unsafeGetCurrentRuntime = _chunk2P4PD6D7cjs.unsafeGetCurrentRuntime; exports.unsafeRunAsync = _chunk2P4PD6D7cjs.unsafeRunAsync; exports.unsafeRunFoldWithEnv = _chunk2P4PD6D7cjs.unsafeRunFoldWithEnv; exports.unwrapScoped = _chunkZTDK2DLGcjs.unwrapScoped; exports.via = via; exports.widenOpt = _chunkZTDK2DLGcjs.widenOpt; exports.withAsyncPromise = _chunk2P4PD6D7cjs.withAsyncPromise; exports.withCurrentFiber = _chunk2P4PD6D7cjs.withCurrentFiber; exports.withScope = _chunk2P4PD6D7cjs.withScope; exports.withScopeAsync = _chunk2P4PD6D7cjs.withScopeAsync; exports.zip = _chunkZTDK2DLGcjs.zip; exports.zipPar = _chunk2P4PD6D7cjs.zipPar;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ABI_VERSION = _chunkTGIFUAK4cjs.ABI_VERSION; exports.Async = _chunkTGIFUAK4cjs.Async; exports.Cause = _chunkTGIFUAK4cjs.Cause; exports.DefaultHostExecutor = _chunkTGIFUAK4cjs.DefaultHostExecutor; exports.EVENT_WORDS = _chunkTGIFUAK4cjs.EVENT_WORDS; exports.EngineFiberHandle = _chunkTGIFUAK4cjs.EngineFiberHandle; exports.EventKindCode = _chunkTGIFUAK4cjs.EventKindCode; exports.Exit = _chunkTGIFUAK4cjs.Exit; exports.HostRegistry = _chunkTGIFUAK4cjs.HostRegistry; exports.JsFiberEngine = _chunkTGIFUAK4cjs.JsFiberEngine; exports.NONE_U32 = _chunkTGIFUAK4cjs.NONE_U32; exports.NoopHooks = _chunkTGIFUAK4cjs.NoopHooks; exports.OpcodeTagCode = _chunkTGIFUAK4cjs.OpcodeTagCode; exports.PURE_PIPELINE_TAG = PURE_PIPELINE_TAG; exports.ProgramBuilder = _chunkTGIFUAK4cjs.ProgramBuilder; exports.PushStatus = _chunkTGIFUAK4cjs.PushStatus; exports.RingBuffer = _chunkTGIFUAK4cjs.RingBuffer; exports.Runtime = _chunkTGIFUAK4cjs.Runtime; exports.RuntimeFiber = _chunkTGIFUAK4cjs.RuntimeFiber; exports.Scheduler = _chunkTGIFUAK4cjs.Scheduler; exports.Scope = _chunkTGIFUAK4cjs.Scope; exports.WasmFiberEngine = _chunkTGIFUAK4cjs.WasmFiberEngine; exports.WasmFiberRegistryBridge = _chunkTGIFUAK4cjs.WasmFiberRegistryBridge; exports.WasmPackFiberBridge = _chunkTGIFUAK4cjs.WasmPackFiberBridge; exports.abortablePromiseStats = _chunkTGIFUAK4cjs.abortablePromiseStats; exports.acquireRelease = _chunkTGIFUAK4cjs.acquireRelease; exports.andThen = andThen2; exports.andThenSchedule = _chunkXPZNXSVNcjs.andThen; exports.applyFused = applyFused; exports.assertCompletesWithin = _chunkXPZNXSVNcjs.assertCompletesWithin; exports.assertFails = _chunkXPZNXSVNcjs.assertFails; exports.assertFailsWith = _chunkXPZNXSVNcjs.assertFailsWith; exports.assertNever = _chunkSTVLQ3XDcjs.assertNever; exports.assertSucceeds = _chunkXPZNXSVNcjs.assertSucceeds; exports.async = _chunkTGIFUAK4cjs.asyncEffect; exports.asyncCatchAll = _chunkTGIFUAK4cjs.asyncCatchAll; exports.asyncFail = _chunkTGIFUAK4cjs.asyncFail; exports.asyncFlatMap = _chunkTGIFUAK4cjs.asyncFlatMap; exports.asyncFold = _chunkTGIFUAK4cjs.asyncFold; exports.asyncInterruptible = _chunkTGIFUAK4cjs.asyncInterruptible; exports.asyncMap = _chunkTGIFUAK4cjs.asyncMap; exports.asyncMapError = _chunkTGIFUAK4cjs.asyncMapError; exports.asyncSucceed = _chunkTGIFUAK4cjs.asyncSucceed; exports.asyncSync = _chunkTGIFUAK4cjs.asyncSync; exports.asyncTotal = _chunkTGIFUAK4cjs.asyncTotal; exports.bounded = bounded; exports.bracket = _chunkXPZNXSVNcjs.bracket; exports.broadcast = broadcast; exports.broadcastToHub = broadcastToHub; exports.buffer = buffer; exports.bufferP = bufferP; exports.catchAll = _chunkTGIFUAK4cjs.catchAll; exports.catchTag = _chunkXPZNXSVNcjs.catchTag; exports.catchTags = _chunkXPZNXSVNcjs.catchTags; exports.chunks = chunks; exports.chunksP = chunksP; exports.collectAllPar = _chunkR3R2FVLGcjs.collectAllPar; exports.collectStream = _chunkSTVLQ3XDcjs.collectStream; exports.compose = compose2; exports.composeLayer = _chunkXPZNXSVNcjs.compose; exports.concatStream = _chunkSTVLQ3XDcjs.concatStream; exports.debounce = debounce; exports.decodeEvent = _chunkTGIFUAK4cjs.decodeEvent; exports.decodeEventBatch = _chunkTGIFUAK4cjs.decodeEventBatch; exports.delayedEffect = _chunkXPZNXSVNcjs.delayedEffect; exports.derivedRef = _chunkXPZNXSVNcjs.derivedRef; exports.deserializeFusedPipeline = deserializeFusedPipeline; exports.dropP = dropP; exports.dropStream = drop; exports.elapsed = _chunkXPZNXSVNcjs.elapsed; exports.emitStream = _chunkSTVLQ3XDcjs.emitStream; exports.emptyStream = _chunkSTVLQ3XDcjs.emptyStream; exports.encodeOpcodeNodes = _chunkTGIFUAK4cjs.encodeOpcodeNodes; exports.encodeOpcodeProgram = _chunkTGIFUAK4cjs.encodeOpcodeProgram; exports.end = _chunkTGIFUAK4cjs.end; exports.engineStats = engineStats; exports.ensuring = _chunkXPZNXSVNcjs.ensuring; exports.exponential = _chunkXPZNXSVNcjs.exponential; exports.fail = _chunkTGIFUAK4cjs.fail; exports.filterMapP = filterMapP; exports.filterP = filterP; exports.fixed = _chunkXPZNXSVNcjs.fixed; exports.flakyEffect = _chunkXPZNXSVNcjs.flakyEffect; exports.flatMap = _chunkTGIFUAK4cjs.flatMap; exports.flattenStream = _chunkSTVLQ3XDcjs.flattenStream; exports.foreachStream = _chunkSTVLQ3XDcjs.foreachStream; exports.fork = _chunkTGIFUAK4cjs.fork; exports.fromArray = _chunkSTVLQ3XDcjs.fromArray; exports.fromHub = fromHub; exports.fromPromiseAbortable = _chunkTGIFUAK4cjs.fromPromiseAbortable; exports.fromPull = _chunkSTVLQ3XDcjs.fromPull; exports.fuse = fuse; exports.getBenchmarkBudget = _chunkTGIFUAK4cjs.getBenchmarkBudget; exports.getCurrentFiber = _chunkTGIFUAK4cjs.getCurrentFiber; exports.getStats = getStats; exports.globalScheduler = _chunkTGIFUAK4cjs.globalScheduler; exports.gracefulShutdown = _chunkXPZNXSVNcjs.gracefulShutdown; exports.groupedP = groupedP; exports.identity = identity; exports.inferCallerLaneFromStack = _chunkTGIFUAK4cjs.inferCallerLaneFromStack; exports.initState = initState; exports.interleave = interleave; exports.intersect = _chunkXPZNXSVNcjs.intersect; exports.isFusionEnabled = isFusionEnabled; exports.isFusionVerbose = isFusionVerbose; exports.jittered = _chunkXPZNXSVNcjs.jittered; exports.laneTag = _chunkTGIFUAK4cjs.laneTag; exports.layer = _chunkXPZNXSVNcjs.layer; exports.layerFail = _chunkXPZNXSVNcjs.layerFail; exports.layerFrom = _chunkXPZNXSVNcjs.layerFrom; exports.layerSucceed = _chunkXPZNXSVNcjs.layerSucceed; exports.linkAbortController = _chunkXPZNXSVNcjs.linkAbortController; exports.makeBoundedRingBuffer = _chunkTGIFUAK4cjs.makeBoundedRingBuffer; exports.makeCancelToken = _chunkXPZNXSVNcjs.makeCancelToken; exports.makeCircuitBreaker = _chunkMS34J5LYcjs.makeCircuitBreaker; exports.makeFiberReadyQueue = _chunkTGIFUAK4cjs.makeFiberReadyQueue; exports.makeHub = makeHub; exports.makeMetrics = _chunkXPZNXSVNcjs.makeMetrics; exports.makeRef = _chunkXPZNXSVNcjs.makeRef; exports.makeSemaphore = _chunkXPZNXSVNcjs.makeSemaphore; exports.makeStreamChunker = makeStreamChunker; exports.makeTestRuntime = _chunkXPZNXSVNcjs.makeTestRuntime; exports.makeTracer = _chunkXPZNXSVNcjs.makeTracer; exports.makeWorkerPool = _chunkXPZNXSVNcjs.makeWorkerPool; exports.managed = _chunkXPZNXSVNcjs.managed; exports.managedAll = _chunkXPZNXSVNcjs.managedAll; exports.managedStream = _chunkSTVLQ3XDcjs.managedStream; exports.map = _chunkTGIFUAK4cjs.map; exports.mapAsync = _chunkTGIFUAK4cjs.mapAsync; exports.mapChunks = mapChunks; exports.mapChunksEffect = mapChunksEffect; exports.mapChunksEffectP = mapChunksEffectP; exports.mapEffectP = mapEffectP; exports.mapError = _chunkTGIFUAK4cjs.mapError; exports.mapErrorTyped = _chunkXPZNXSVNcjs.mapError; exports.mapLayer = _chunkXPZNXSVNcjs.mapLayer; exports.mapP = mapP; exports.mapStream = _chunkSTVLQ3XDcjs.mapStream; exports.mapTryAsync = _chunkTGIFUAK4cjs.mapTryAsync; exports.merge = _chunkSTVLQ3XDcjs.merge; exports.mergeLayer = _chunkXPZNXSVNcjs.merge; exports.mergeStream = _chunkSTVLQ3XDcjs.mergeStream; exports.neverEffect = _chunkXPZNXSVNcjs.neverEffect; exports.none = _chunkTGIFUAK4cjs.none; exports.orElse = _chunkXPZNXSVNcjs.orElse; exports.orElseOptional = _chunkTGIFUAK4cjs.orElseOptional; exports.provideLayer = _chunkXPZNXSVNcjs.provideLayer; exports.race = _chunkR3R2FVLGcjs.race; exports.raceWith = _chunkR3R2FVLGcjs.raceWith; exports.rangeStream = _chunkSTVLQ3XDcjs.rangeStream; exports.recurs = _chunkXPZNXSVNcjs.recurs; exports.registerShutdownHooks = _chunkXPZNXSVNcjs.registerShutdownHooks; exports.repeatWithSchedule = _chunkXPZNXSVNcjs.repeatWithSchedule; exports.resetAbortablePromiseStats = _chunkTGIFUAK4cjs.resetAbortablePromiseStats; exports.retry = _chunkMS34J5LYcjs.retry; exports.retryN = _chunkMS34J5LYcjs.retryN; exports.retryWithBackoff = _chunkMS34J5LYcjs.retryWithBackoff; exports.retryWithSchedule = _chunkXPZNXSVNcjs.retryWithSchedule; exports.runFusedArray = runFusedArray; exports.runtimeCapabilities = _chunkTGIFUAK4cjs.runtimeCapabilities; exports.runtimeForCaller = _chunkTGIFUAK4cjs.runtimeForCaller; exports.sanitizeLaneKey = _chunkTGIFUAK4cjs.sanitizeLaneKey; exports.scan = scan; exports.selectedEngineStats = selectedEngineStats; exports.serializeFusedPipeline = serializeFusedPipeline; exports.setBenchmarkBudget = _chunkTGIFUAK4cjs.setBenchmarkBudget; exports.setFusionEnabled = setFusionEnabled; exports.setFusionVerbose = setFusionVerbose; exports.sleep = _chunkMS34J5LYcjs.sleep; exports.some = _chunkTGIFUAK4cjs.some; exports.streamFromReadableStream = _chunkSTVLQ3XDcjs.streamFromReadableStream; exports.succeed = _chunkTGIFUAK4cjs.succeed; exports.sync = _chunkTGIFUAK4cjs.sync; exports.tagError = _chunkXPZNXSVNcjs.tagError; exports.takeP = takeP; exports.takeSchedule = _chunkXPZNXSVNcjs.take; exports.takeStream = take2; exports.tapEffectP = tapEffectP; exports.throttle = throttle; exports.timeout = _chunkMS34J5LYcjs.timeout; exports.toPromise = _chunkTGIFUAK4cjs.toPromise; exports.toPromiseByCaller = _chunkTGIFUAK4cjs.toPromiseByCaller; exports.uncons = _chunkSTVLQ3XDcjs.uncons; exports.union = _chunkXPZNXSVNcjs.union; exports.unit = _chunkTGIFUAK4cjs.unit; exports.unsafeGetCurrentRuntime = _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime; exports.unsafeRunAsync = _chunkTGIFUAK4cjs.unsafeRunAsync; exports.unsafeRunFoldWithEnv = _chunkTGIFUAK4cjs.unsafeRunFoldWithEnv; exports.unwrapScoped = _chunkSTVLQ3XDcjs.unwrapScoped; exports.useManaged = _chunkXPZNXSVNcjs.useManaged; exports.via = via; exports.whileInput = _chunkXPZNXSVNcjs.whileInput; exports.widenOpt = _chunkSTVLQ3XDcjs.widenOpt; exports.withAsyncPromise = _chunkTGIFUAK4cjs.withAsyncPromise; exports.withCurrentFiber = _chunkTGIFUAK4cjs.withCurrentFiber; exports.withScope = _chunkTGIFUAK4cjs.withScope; exports.withScopeAsync = _chunkTGIFUAK4cjs.withScopeAsync; exports.zip = _chunkSTVLQ3XDcjs.zip; exports.zipPar = _chunkR3R2FVLGcjs.zipPar; exports.zipStream = zip2; exports.zipWith = zipWith;