brass-runtime 1.13.2 → 1.13.3

package/dist/index.mjs

@@ -0,0 +1,855 @@
+import {
+  assertNever,
+  collectStream,
+  concatStream,
+  emitStream,
+  emptyStream,
+  flattenStream,
+  foreachStream,
+  fromArray,
+  fromPull,
+  managedStream,
+  mapStream,
+  merge,
+  mergeStream,
+  rangeStream,
+  streamFromReadableStream,
+  uncons,
+  unwrapScoped,
+  widenOpt,
+  zip
+} from "./chunk-QRPYH5J7.mjs";
+import {
+  Async,
+  Cause,
+  DefaultHostExecutor,
+  EngineFiberHandle,
+  Exit,
+  HostRegistry,
+  JsFiberEngine,
+  NoopHooks,
+  ProgramBuilder,
+  PushStatus,
+  ReferenceWasmBridge,
+  RingBuffer,
+  Runtime,
+  RuntimeFiber,
+  Scheduler,
+  Scope,
+  WasmFiberEngine,
+  WasmFiberRegistryBridge,
+  WasmPackFiberBridge,
+  acquireRelease,
+  async,
+  asyncCatchAll,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncInterruptible,
+  asyncMap,
+  asyncMapError,
+  asyncSucceed,
+  asyncSync,
+  asyncTotal,
+  catchAll,
+  collectAllPar,
+  end,
+  fail,
+  flatMap,
+  fork,
+  fromPromiseAbortable,
+  getBenchmarkBudget,
+  getCurrentFiber,
+  globalScheduler,
+  makeBoundedRingBuffer,
+  map,
+  mapAsync,
+  mapError,
+  mapTryAsync,
+  none,
+  orElseOptional,
+  race,
+  raceWith,
+  resolveWasmModule,
+  runtimeCapabilities,
+  setBenchmarkBudget,
+  some,
+  succeed,
+  sync,
+  toPromise,
+  unit,
+  unsafeGetCurrentRuntime,
+  unsafeRunAsync,
+  unsafeRunFoldWithEnv,
+  withAsyncPromise,
+  withCurrentFiber,
+  withScope,
+  withScopeAsync,
+  zipPar
+} from "./chunk-T5XJDGTQ.mjs";
+
+// 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 {
+        }
+        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 {
+  head = null;
+  tail = null;
+  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--;
+  }
+};
+
+// src/core/stream/queue.ts
+function bounded(capacity, strategy = "backpressure", options = {}) {
+  return asyncSync(() => makeQueue(capacity, strategy, options));
+}
+function makeQueue(capacity, strategy, options) {
+  const items = makeBoundedRingBuffer(capacity, capacity, options);
+  let closed = false;
+  const QueueClosedErr = { _tag: "QueueClosed" };
+  const offerWaiters = new LinkedQueue();
+  const takers = new LinkedQueue();
+  const shutdown = () => {
+    if (closed) return;
+    closed = true;
+    while (takers.length > 0) {
+      const t = takers.shift();
+      t({ _tag: "Failure", cause: { _tag: "Fail", error: QueueClosedErr } });
+    }
+    while (offerWaiters.length > 0) {
+      const w = offerWaiters.shift();
+      w.cb(false);
+    }
+    items.clear();
+  };
+  return {
+    size: () => items.length,
+    shutdown,
+    offer: (a) => async((_env, cb) => {
+      if (closed) {
+        cb({ _tag: "Success", value: false });
+        return;
+      }
+      if (takers.length > 0) {
+        const t = takers.shift();
+        t({ _tag: "Success", value: a });
+        cb({ _tag: "Success", value: true });
+        return;
+      }
+      if (items.length < capacity) {
+        items.push(a);
+        cb({ _tag: "Success", value: true });
+        return;
+      }
+      if (strategy === "dropping") {
+        cb({ _tag: "Success", value: false });
+        return;
+      }
+      if (strategy === "sliding") {
+        items.shift();
+        items.push(a);
+        cb({ _tag: "Success", value: true });
+        return;
+      }
+      const node = offerWaiters.push({
+        a,
+        cb: (ok) => cb({ _tag: "Success", value: ok })
+      });
+      const canceler = () => {
+        offerWaiters.remove(node);
+      };
+      return canceler;
+    }),
+    take: () => async((_env, cb) => {
+      if (items.length > 0) {
+        const a = items.shift();
+        cb({ _tag: "Success", value: a });
+        if (offerWaiters.length > 0 && items.length < capacity) {
+          const w = offerWaiters.shift();
+          items.push(w.a);
+          w.cb(true);
+        }
+        return;
+      }
+      if (offerWaiters.length > 0) {
+        const w = offerWaiters.shift();
+        w.cb(true);
+        cb({ _tag: "Success", value: w.a });
+        return;
+      }
+      if (closed) {
+        cb({ _tag: "Failure", cause: { _tag: "Fail", error: QueueClosedErr } });
+        return;
+      }
+      const node = takers.push(cb);
+      const canceler = () => {
+        takers.remove(node);
+      };
+      return canceler;
+    })
+  };
+}
+
+// src/core/stream/buffer.ts
+var SIGNAL_END = { _tag: "End" };
+function buffer(stream, capacity, strategy = "backpressure") {
+  let started = false;
+  let q = null;
+  let producer = null;
+  let upstream = stream;
+  const onUpstreamFailure = (opt) => asyncSucceed(
+    opt._tag === "None" ? SIGNAL_END : { _tag: "Fail", error: opt.value }
+  );
+  const onUpstreamSuccess = ([a, tail]) => asyncSync(() => {
+    upstream = tail;
+    return { _tag: "Elem", value: a };
+  });
+  const nextSignal = () => asyncFold(
+    uncons(upstream),
+    onUpstreamFailure,
+    onUpstreamSuccess
+  );
+  const start = (env) => asyncFlatMap(bounded(capacity, strategy), (_q) => {
+    q = _q;
+    let lastSig;
+    const afterOffer = () => {
+      if (lastSig._tag !== "Elem") {
+        return asyncSucceed(void 0);
+      }
+      return loop();
+    };
+    const onSignal = (sig) => {
+      lastSig = sig;
+      return asyncFlatMap(q.offer(sig), afterOffer);
+    };
+    const loop = () => asyncFlatMap(nextSignal(), onSignal);
+    producer = fork(loop(), env);
+    return asyncSucceed(void 0);
+  });
+  const pullDown = {
+    _tag: "Async",
+    register: (env, cb) => {
+      const go = () => {
+        if (!started) {
+          started = true;
+          unsafeGetCurrentRuntime().fork(start(env)).join(() => {
+            pullFromQueue(env, cb);
+          });
+          return;
+        }
+        pullFromQueue(env, cb);
+      };
+      go();
+    }
+  };
+  function pullFromQueue(env, cb) {
+    const takeEff = q.take();
+    unsafeGetCurrentRuntime().fork(takeEff).join((ex) => {
+      if (ex._tag !== "Success") return;
+      const sig = ex.value;
+      switch (sig._tag) {
+        case "Elem":
+          cb({ _tag: "Success", value: [sig.value, fromPull(pullDown)] });
+          return;
+        case "End":
+          producer?.interrupt?.();
+          cb({ _tag: "Failure", cause: { _tag: "Fail", error: none } });
+          return;
+        case "Fail":
+          producer?.interrupt?.();
+          cb({ _tag: "Failure", cause: { _tag: "Fail", error: some(sig.error) } });
+          return;
+      }
+    });
+  }
+  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() {
+  if (cachedWasmChunkCtor !== void 0) return cachedWasmChunkCtor;
+  const mod = resolveWasmModule();
+  cachedWasmChunkCtor = mod?.BrassWasmChunkBuffer ?? null;
+  return cachedWasmChunkCtor;
+}
+var JsChunker = class {
+  constructor(maxChunkSize, fallbackUsed = false) {
+    this.maxChunkSize = maxChunkSize;
+    this.fallbackUsed = fallbackUsed;
+  }
+  maxChunkSize;
+  fallbackUsed;
+  engine = "js";
+  values = [];
+  emittedChunks = 0;
+  emittedItems = 0;
+  flushes = 0;
+  get length() {
+    return this.values.length;
+  }
+  push(value) {
+    if (this.values.length >= this.maxChunkSize) return false;
+    this.values.push(value);
+    return true;
+  }
+  isFull() {
+    return this.values.length >= this.maxChunkSize;
+  }
+  isEmpty() {
+    return this.values.length === 0;
+  }
+  takeChunk() {
+    this.flushes += 1;
+    const chunk = this.values;
+    this.values = [];
+    if (chunk.length > 0) {
+      this.emittedChunks += 1;
+      this.emittedItems += chunk.length;
+    }
+    return chunk;
+  }
+  clear() {
+    this.values = [];
+  }
+  stats() {
+    return {
+      engine: "js",
+      fallbackUsed: this.fallbackUsed,
+      data: {
+        len: this.values.length,
+        maxChunkSize: this.maxChunkSize,
+        emittedChunks: this.emittedChunks,
+        emittedItems: this.emittedItems,
+        flushes: this.flushes
+      }
+    };
+  }
+};
+var WasmChunker = class {
+  engine = "wasm";
+  fallbackUsed = false;
+  inner;
+  constructor(maxChunkSize) {
+    const Ctor = resolveWasmChunkBuffer();
+    if (!Ctor) {
+      throw new Error("brass-runtime wasm chunk buffer is not available. Run npm run build:wasm first.");
+    }
+    this.inner = new Ctor(maxChunkSize);
+  }
+  get length() {
+    return this.inner.len();
+  }
+  get maxChunkSize() {
+    return this.inner.max_chunk_size();
+  }
+  push(value) {
+    return this.inner.push(value);
+  }
+  isFull() {
+    return this.inner.is_full();
+  }
+  isEmpty() {
+    return this.inner.is_empty();
+  }
+  takeChunk() {
+    return Array.from(this.inner.take_chunk());
+  }
+  clear() {
+    this.inner.clear();
+  }
+  stats() {
+    return { engine: "wasm", fallbackUsed: false, data: JSON.parse(this.inner.stats_json()) };
+  }
+};
+function makeStreamChunker(chunkSize, options = {}) {
+  const size = Math.max(1, chunkSize | 0);
+  const engine = options.engine ?? "auto";
+  if (engine === "js") return new JsChunker(size, false);
+  if (engine === "wasm") return new WasmChunker(size);
+  return resolveWasmChunkBuffer() ? new WasmChunker(size) : new JsChunker(size, true);
+}
+function chunks(input, chunkSize, options = {}) {
+  const size = Math.max(1, chunkSize | 0);
+  const loop = (cur) => fromPull(fillChunk(cur, makeStreamChunker(size, options)));
+  const fillChunk = (cur, chunker) => asyncFold(
+    uncons(cur),
+    (opt) => {
+      if (opt._tag === "None" && !chunker.isEmpty()) {
+        return asyncSucceed([chunker.takeChunk(), fromPull(asyncFail(none))]);
+      }
+      return asyncFail(opt);
+    },
+    ([a, tail]) => {
+      chunker.push(a);
+      if (chunker.isFull()) {
+        return asyncSucceed([chunker.takeChunk(), loop(tail)]);
+      }
+      return fillChunk(tail, chunker);
+    }
+  );
+  return loop(input);
+}
+function mapChunks(input, chunkSize, f, options = {}) {
+  const pullOne = (pending, rest) => {
+    if (pending.length > 0) {
+      const [head, ...tail] = pending;
+      return fromPull(asyncSucceed([head, pullOne(tail, rest)]));
+    }
+    return fromPull(
+      asyncFold(
+        uncons(rest),
+        (opt) => asyncFail(opt),
+        ([chunk, tail]) => {
+          const mapped = f(chunk);
+          return uncons(pullOne(mapped, tail));
+        }
+      )
+    );
+  };
+  return pullOne([], chunks(input, chunkSize, options));
+}
+function mapChunksEffect(chunkSize, f, options = {}) {
+  return ((input) => {
+    const chunked = chunks(input, chunkSize, options);
+    const pullOne = (pending, rest) => {
+      if (pending.length > 0) {
+        const [head, ...tail] = pending;
+        return fromPull(asyncSucceed([head, pullOne(tail, rest)]));
+      }
+      return fromPull(
+        asyncFold(
+          asyncMapError(uncons(rest), (opt) => widenOpt(opt)),
+          (opt) => asyncFail(opt),
+          ([chunk, tail]) => asyncFold(
+            asyncMapError(f(chunk), (e) => ({ _tag: "Some", value: e })),
+            (opt) => asyncFail(opt),
+            (mapped) => uncons(pullOne(mapped, tail))
+          )
+        )
+      );
+    };
+    return pullOne([], chunked);
+  });
+}
+
+// src/core/stream/pipeline.ts
+function via(stream, pipeline) {
+  return pipeline(stream);
+}
+function andThen(p1, p2) {
+  return ((input) => p2(p1(input)));
+}
+function compose(p2, p1) {
+  return andThen(p1, p2);
+}
+function identity() {
+  return ((input) => input);
+}
+function mapP(f) {
+  return ((input) => {
+    const onError = (opt) => asyncFail(opt);
+    const onSuccess = ([a, tail]) => asyncSucceed([f(a), loop(tail)]);
+    const loop = (cur) => fromPull(
+      asyncFold(uncons(cur), onError, onSuccess)
+    );
+    return loop(input);
+  });
+}
+function filterP(pred) {
+  return ((input) => {
+    const onError = (opt) => asyncFail(opt);
+    const onSuccess = ([a, tail]) => pred(a) ? asyncSucceed([a, loop(tail)]) : next(tail);
+    const next = (cur) => asyncFold(uncons(cur), onError, onSuccess);
+    const loop = (cur) => fromPull(next(cur));
+    return loop(input);
+  });
+}
+function filterMapP(f) {
+  return ((input) => {
+    const onError = (opt) => asyncFail(opt);
+    const next = (cur) => asyncFold(
+      uncons(cur),
+      onError,
+      ([a, tail]) => {
+        const ob = f(a);
+        return ob._tag === "Some" ? asyncSucceed([ob.value, loop(tail)]) : next(tail);
+      }
+    );
+    const loop = (cur) => fromPull(next(cur));
+    return loop(input);
+  });
+}
+function takeP(n) {
+  const m = Math.max(0, n | 0);
+  return ((input) => {
+    const loop = (cur, remaining) => {
+      if (remaining <= 0) return emptyStream();
+      return fromPull(
+        asyncFold(
+          uncons(cur),
+          (opt) => asyncFail(opt),
+          ([a, tail]) => asyncSucceed([a, loop(tail, remaining - 1)])
+        )
+      );
+    };
+    return loop(input, m);
+  });
+}
+function dropP(n) {
+  const m = Math.max(0, n | 0);
+  return ((input) => {
+    const skip = (cur, remaining) => {
+      if (remaining <= 0) return cur;
+      return fromPull(
+        asyncFold(
+          uncons(cur),
+          (opt) => asyncFail(opt),
+          ([_a, tail]) => uncons(skip(tail, remaining - 1))
+        )
+      );
+    };
+    return skip(input, m);
+  });
+}
+function mapEffectP(f) {
+  return ((input) => {
+    const raiseToOpt = (fa) => asyncMapError(fa, (e) => some(e));
+    const loop = (cur) => fromPull(
+      asyncFold(
+        asyncMapError(
+          uncons(cur),
+          (opt) => widenOpt(opt)
+        ),
+        (opt) => asyncFail(opt),
+        ([a, tail]) => asyncFold(
+          raiseToOpt(f(a)),
+          // Async<Rp, ...>
+          (opt2) => asyncFail(opt2),
+          (b) => asyncSucceed([b, loop(tail)])
+        )
+      )
+    );
+    return loop(input);
+  });
+}
+function tapEffectP(f) {
+  return mapEffectP((a) => asyncFlatMap(f(a), () => asyncSucceed(a)));
+}
+function chunksP(chunkSize, options = {}) {
+  return ((input) => chunks(input, chunkSize, options));
+}
+function mapChunksEffectP(chunkSize, f, options = {}) {
+  return mapChunksEffect(chunkSize, f, options);
+}
+function bufferP(capacity, strategy = "backpressure") {
+  return ((input) => buffer(input, capacity, strategy));
+}
+function groupedP(n) {
+  const size = Math.max(1, n | 0);
+  return ((input) => {
+    const gather = (cur, remaining, acc) => {
+      if (remaining <= 0) return asyncSucceed({ chunk: acc, rest: cur });
+      return asyncFold(
+        uncons(cur),
+        (opt) => {
+          if (opt._tag === "None") return asyncSucceed({ chunk: acc, rest: emptyStream() });
+          return asyncFail(opt);
+        },
+        ([a, tail]) => gather(tail, remaining - 1, [...acc, a])
+      );
+    };
+    const loop = (cur) => fromPull(
+      asyncFold(
+        uncons(cur),
+        (opt) => asyncFail(opt),
+        ([a, tail]) => asyncFlatMap(
+          gather(tail, size - 1, [a]),
+          ({ chunk, rest }) => asyncSucceed([chunk, loop(rest)])
+        )
+      )
+    );
+    return loop(input);
+  });
+}
+
+// src/core/runtime/engineStats.ts
+function engineStats(engine, data, fallbackUsed = false) {
+  return { engine, data, fallbackUsed };
+}
+function selectedEngineStats(requested, engine, data) {
+  return { requested, engine, data, fallbackUsed: requested === "auto" && engine !== "wasm" };
+}
+export {
+  Async,
+  Cause,
+  DefaultHostExecutor,
+  EngineFiberHandle,
+  Exit,
+  HostRegistry,
+  JsFiberEngine,
+  NoopHooks,
+  ProgramBuilder,
+  PushStatus,
+  ReferenceWasmBridge,
+  RingBuffer,
+  Runtime,
+  RuntimeFiber,
+  Scheduler,
+  Scope,
+  WasmFiberEngine,
+  WasmFiberRegistryBridge,
+  WasmPackFiberBridge,
+  acquireRelease,
+  andThen,
+  assertNever,
+  async,
+  asyncCatchAll,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncInterruptible,
+  asyncMap,
+  asyncMapError,
+  asyncSucceed,
+  asyncSync,
+  asyncTotal,
+  bounded,
+  broadcast,
+  broadcastToHub,
+  buffer,
+  bufferP,
+  catchAll,
+  chunks,
+  chunksP,
+  collectAllPar,
+  collectStream,
+  compose,
+  concatStream,
+  dropP,
+  emitStream,
+  emptyStream,
+  end,
+  engineStats,
+  fail,
+  filterMapP,
+  filterP,
+  flatMap,
+  flattenStream,
+  foreachStream,
+  fork,
+  fromArray,
+  fromHub,
+  fromPromiseAbortable,
+  fromPull,
+  getBenchmarkBudget,
+  getCurrentFiber,
+  globalScheduler,
+  groupedP,
+  identity,
+  linkAbortController,
+  makeBoundedRingBuffer,
+  makeCancelToken,
+  makeHub,
+  makeStreamChunker,
+  managedStream,
+  map,
+  mapAsync,
+  mapChunks,
+  mapChunksEffect,
+  mapChunksEffectP,
+  mapEffectP,
+  mapError,
+  mapP,
+  mapStream,
+  mapTryAsync,
+  merge,
+  mergeStream,
+  none,
+  orElseOptional,
+  race,
+  raceWith,
+  rangeStream,
+  runtimeCapabilities,
+  selectedEngineStats,
+  setBenchmarkBudget,
+  some,
+  streamFromReadableStream,
+  succeed,
+  sync,
+  takeP,
+  tapEffectP,
+  toPromise,
+  uncons,
+  unit,
+  unsafeGetCurrentRuntime,
+  unsafeRunAsync,
+  unsafeRunFoldWithEnv,
+  unwrapScoped,
+  via,
+  widenOpt,
+  withAsyncPromise,
+  withCurrentFiber,
+  withScope,
+  withScopeAsync,
+  zip,
+  zipPar
+};