brass-runtime 1.12.1 → 1.13.3

package/dist/http/index.mjs

@@ -0,0 +1,453 @@
+import {
+  streamFromReadableStream
+} from "../chunk-QRPYH5J7.mjs";
+import {
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncSucceed,
+  fromPromiseAbortable,
+  mapTryAsync,
+  toPromise,
+  withAsyncPromise
+} from "../chunk-T5XJDGTQ.mjs";
+
+// src/http/optics/lens.ts
+var Lens = {
+  make(get, set) {
+    return { get, set };
+  },
+  over(ln, f) {
+    return (s) => ln.set(f(ln.get(s)))(s);
+  },
+  compose(ab, sa) {
+    return Lens.make(
+      (s) => ab.get(sa.get(s)),
+      (b) => (s) => sa.set(ab.set(b)(sa.get(s)))(s)
+    );
+  }
+};
+
+// src/http/optics/request.ts
+var Request = {
+  headers: Lens.make(
+    (req) => req.headers ?? {},
+    (headers) => (req) => ({ ...req, headers })
+  )
+};
+var mergeHeaders = (extra) => (req) => Lens.over(Request.headers, (h) => ({ ...h, ...extra }))(req);
+var mergeHeadersUnder = (under) => (req) => Lens.over(Request.headers, (h) => ({ ...under, ...h }))(req);
+var setHeaderIfMissing = (k, v) => (req) => Lens.over(Request.headers, (h) => h[k] ? h : { ...h, [k]: v })(req);
+
+// src/http/sleep.ts
+var isHttpError = (e) => typeof e === "object" && e !== null && "_tag" in e;
+var normalizeHttpError = (e) => {
+  if (isHttpError(e)) return e;
+  if (typeof e === "object" && e !== null && e.name === "AbortError") {
+    return { _tag: "Abort" };
+  }
+  return { _tag: "FetchError", message: String(e) };
+};
+var sleepMs = (ms) => fromPromiseAbortable(
+  (signal) => new Promise((resolve, reject) => {
+    if (signal.aborted) return reject({ _tag: "Abort" });
+    const id = setTimeout(resolve, ms);
+    const onAbort = () => {
+      clearTimeout(id);
+      reject({ _tag: "Abort" });
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  }),
+  normalizeHttpError
+);
+
+// src/http/client.ts
+var withMiddleware = (mw) => (c) => decorate(mw(c));
+var decorate = (run) => Object.assign(((req) => run(req)), {
+  with: (mw) => decorate(mw(run))
+});
+var normalizeHttpError2 = (e) => {
+  if (e instanceof DOMException && e.name === "AbortError") return { _tag: "Abort" };
+  if (typeof e === "object" && e && "_tag" in e) return e;
+  return { _tag: "FetchError", message: String(e) };
+};
+var normalizeHeadersInit = (h) => {
+  if (!h) return void 0;
+  if (typeof Headers !== "undefined" && h instanceof Headers) {
+    const out = {};
+    h.forEach((v, k) => out[k] = v);
+    return out;
+  }
+  if (Array.isArray(h)) return Object.fromEntries(h);
+  if (typeof h === "object") return { ...h };
+  return void 0;
+};
+var normalizeRequest = (defaultHeaders) => (req0) => {
+  let req = Object.keys(defaultHeaders).length ? mergeHeadersUnder(defaultHeaders)(req0) : req0;
+  const initHeaders = normalizeHeadersInit(req0.init?.headers);
+  if (initHeaders && Object.keys(initHeaders).length) {
+    req = mergeHeadersUnder(initHeaders)(req);
+  }
+  return req;
+};
+function makeHttpStream(cfg = {}) {
+  const baseUrl = cfg.baseUrl ?? "";
+  const defaultHeaders = cfg.headers ?? {};
+  const normalize = normalizeRequest(defaultHeaders);
+  return (req0) => fromPromiseAbortable(
+    async (signal) => {
+      const req = normalize(req0);
+      let url;
+      try {
+        url = new URL(req.url, baseUrl);
+      } catch {
+        throw { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
+      }
+      const started = performance.now();
+      const res = await fetch(url, {
+        ...req.init ?? {},
+        method: req.method,
+        headers: Request.headers.get(req),
+        // 👈 optics: headers ya normalizados
+        body: req.body,
+        signal
+      });
+      const headers = {};
+      res.headers.forEach((v, k) => headers[k] = v);
+      const body = streamFromReadableStream(res.body, normalizeHttpError2);
+      return {
+        status: res.status,
+        statusText: res.statusText,
+        headers,
+        body,
+        ms: Math.round(performance.now() - started)
+      };
+    },
+    normalizeHttpError2
+  );
+}
+function makeHttp(cfg = {}) {
+  const baseUrl = cfg.baseUrl ?? "";
+  const defaultHeaders = cfg.headers ?? {};
+  const normalize = normalizeRequest(defaultHeaders);
+  const run = (req0) => fromPromiseAbortable(
+    async (signal) => {
+      const req = normalize(req0);
+      let url;
+      try {
+        url = new URL(req.url, baseUrl);
+      } catch {
+        throw { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
+      }
+      const started = performance.now();
+      const res = await fetch(url, {
+        ...req.init ?? {},
+        method: req.method,
+        headers: Request.headers.get(req),
+        // 👈 optics
+        body: req.body,
+        signal
+      });
+      const bodyText = await res.text();
+      const headers = {};
+      res.headers.forEach((v, k) => headers[k] = v);
+      return {
+        status: res.status,
+        statusText: res.statusText,
+        headers,
+        bodyText,
+        ms: Math.round(performance.now() - started)
+      };
+    },
+    normalizeHttpError2
+  );
+  return decorate(run);
+}
+var clamp = (n, min, max) => Math.max(min, Math.min(max, n));
+var defaultRetryOnError = (e) => e._tag === "FetchError";
+var defaultRetryOnStatus = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
+var backoffDelayMs = (attempt, base, cap) => {
+  const exp = base * Math.pow(2, attempt);
+  const lim = clamp(exp, 0, cap);
+  return Math.floor(Math.random() * lim);
+};
+var retryAfterMs = (headers) => {
+  const key = Object.keys(headers).find((k) => k.toLowerCase() === "retry-after");
+  if (!key) return void 0;
+  const v = headers[key]?.trim();
+  if (!v) return void 0;
+  const secs = Number(v);
+  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
+  const t = Date.parse(v);
+  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  return void 0;
+};
+var withRetryStream = (p) => (next) => ((req) => {
+  const loop = (attempt) => asyncFold(
+    next(req),
+    (e) => {
+      if (e._tag === "Abort" || e._tag === "BadUrl") return asyncFail(e);
+      const canRetry = attempt < p.maxRetries && (p.retryOnError ?? defaultRetryOnError)(e);
+      if (!canRetry) return asyncFail(e);
+      const d = backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs);
+      return asyncFlatMap(sleepMs(d), () => loop(attempt + 1));
+    },
+    (w) => {
+      const canRetry = attempt < p.maxRetries && (p.retryOnStatus ?? defaultRetryOnStatus)(w.status);
+      if (!canRetry) return asyncSucceed(w);
+      const ra = retryAfterMs(w.headers);
+      const d = ra ?? backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs);
+      return asyncFlatMap(sleepMs(d), () => loop(attempt + 1));
+    }
+  );
+  return loop(0);
+});
+
+// src/http/retry/retry.ts
+var defaultRetryableMethods = ["GET", "HEAD", "OPTIONS"];
+var defaultRetryOnStatus2 = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
+var defaultRetryOnError2 = (e) => e._tag === "FetchError";
+var clamp2 = (n, min, max) => Math.max(min, Math.min(max, n));
+var backoffDelayMs2 = (attempt, base, cap) => {
+  const b = Math.max(0, base);
+  const c = Math.max(0, cap);
+  const exp = b * Math.pow(2, attempt);
+  const lim = clamp2(exp, 0, c);
+  return Math.floor(Math.random() * lim);
+};
+var headerCI = (h, name) => {
+  const k = Object.keys(h).find((x) => x.toLowerCase() === name.toLowerCase());
+  return k ? h[k] : void 0;
+};
+var retryAfterMs2 = (headers) => {
+  const v = headerCI(headers, "retry-after")?.trim();
+  if (!v) return void 0;
+  const secs = Number(v);
+  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
+  const t = Date.parse(v);
+  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  return void 0;
+};
+var withRetry = (p) => (next) => {
+  const retryOnMethods = p.retryOnMethods ?? defaultRetryableMethods;
+  const retryOnStatus = p.retryOnStatus ?? defaultRetryOnStatus2;
+  const retryOnError = p.retryOnError ?? defaultRetryOnError2;
+  const isMethodRetryable = (req) => retryOnMethods.includes(req.method);
+  const loop = (req, attempt) => {
+    if (!isMethodRetryable(req)) return next(req);
+    return asyncFold(
+      next(req),
+      (e) => {
+        if (e._tag === "Abort" || e._tag === "BadUrl") return asyncFail(e);
+        const canRetry = attempt < p.maxRetries && retryOnError(e);
+        if (!canRetry) return asyncFail(e);
+        const d = backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs);
+        return asyncFlatMap(sleepMs(d), () => loop(req, attempt + 1));
+      },
+      (w) => {
+        const canRetry = attempt < p.maxRetries && retryOnStatus(w.status);
+        if (!canRetry) return asyncSucceed(w);
+        const ra = retryAfterMs2(w.headers);
+        const d = ra ?? backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs);
+        return asyncFlatMap(sleepMs(d), () => loop(req, attempt + 1));
+      }
+    );
+  };
+  return (req) => loop(req, 0);
+};
+
+// src/http/httpClient.ts
+var resolveFinalUrl = (baseUrl, url) => {
+  try {
+    return new URL(url, baseUrl ?? "").toString();
+  } catch {
+    return (baseUrl ?? "") + url;
+  }
+};
+var createHttpCore = (cfg = {}) => {
+  const wire = makeHttp(cfg);
+  const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
+  const requestRaw = (req) => wire(req);
+  const splitInit = (init) => {
+    const { headers, ...rest } = init ?? {};
+    return {
+      headers: normalizeHeadersInit(headers),
+      init: rest
+    };
+  };
+  const applyInitHeaders = (headers) => (req) => headers ? mergeHeaders(headers)(req) : req;
+  const buildReq = (method, url, init, body) => {
+    const s = splitInit(init);
+    const req = {
+      method,
+      url,
+      ...body && body.length > 0 ? { body } : {},
+      init: s.init
+    };
+    return applyInitHeaders(s.headers)(req);
+  };
+  const toResponse = (w, body) => ({
+    status: w.status,
+    statusText: w.statusText,
+    headers: w.headers,
+    body
+  });
+  return {
+    cfg,
+    wire,
+    withPromise,
+    requestRaw,
+    splitInit,
+    applyInitHeaders,
+    buildReq,
+    toResponse
+  };
+};
+function httpClient(cfg = {}) {
+  const core = createHttpCore(cfg);
+  const make = (wire) => {
+    const requestRaw = (req) => wire(req);
+    const request = (req) => core.withPromise(requestRaw(req));
+    const get = (url, init) => request(core.buildReq("GET", url, init));
+    const post = (url, body, init) => request(core.buildReq("POST", url, init, body));
+    const getText = (url, init) => {
+      const req = core.buildReq("GET", url, init);
+      return core.withPromise(mapTryAsync(requestRaw(req), (w) => core.toResponse(w, w.bodyText)));
+    };
+    const getJson = (url, init) => {
+      const base = core.buildReq("GET", url, init);
+      const req = setHeaderIfMissing("accept", "application/json")(base);
+      return core.withPromise(mapTryAsync(requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText))));
+    };
+    const postJson = (url, bodyObj, init) => {
+      const base = core.buildReq("POST", url, init, JSON.stringify(bodyObj ?? {}));
+      const req = setHeaderIfMissing("content-type", "application/json")(
+        setHeaderIfMissing("accept", "application/json")(base)
+      );
+      return core.withPromise(
+        mapTryAsync(requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText)))
+      );
+    };
+    return {
+      request,
+      get,
+      post,
+      getText,
+      getJson,
+      postJson,
+      with: (mw) => make(wire.with(mw)),
+      withRetry: (p) => make(wire.with(withRetry(p))),
+      wire
+    };
+  };
+  return make(core.wire);
+}
+function httpClientWithMeta(cfg = {}) {
+  const core = createHttpCore(cfg);
+  const mkMeta = (req, w, startedAt) => ({
+    request: req,
+    urlFinal: resolveFinalUrl(core.cfg.baseUrl, req.url),
+    startedAt,
+    durationMs: w.ms
+  });
+  const request = (req) => {
+    const startedAt = Date.now();
+    return core.withPromise(
+      mapTryAsync(core.requestRaw(req), (w) => ({
+        wire: w,
+        meta: mkMeta(req, w, startedAt)
+      }))
+    );
+  };
+  const get = (url, init) => {
+    const req = core.buildReq("GET", url, init);
+    return request(req);
+  };
+  const post = (url, body, init) => {
+    const req = core.buildReq("POST", url, init, body);
+    return request(req);
+  };
+  const postJson = (url, bodyObj, init) => {
+    const base = core.buildReq("POST", url, init, JSON.stringify(bodyObj ?? {}));
+    const req = setHeaderIfMissing("content-type", "application/json")(
+      setHeaderIfMissing("accept", "application/json")(base)
+    );
+    const startedAt = Date.now();
+    return core.withPromise(
+      mapTryAsync(core.requestRaw(req), (w) => ({
+        wire: w,
+        response: core.toResponse(w, JSON.parse(w.bodyText)),
+        meta: mkMeta(req, w, startedAt)
+      }))
+    );
+  };
+  const getText = (url, init) => {
+    const req = core.buildReq("GET", url, init);
+    const startedAt = Date.now();
+    return core.withPromise(
+      mapTryAsync(core.requestRaw(req), (w) => ({
+        wire: w,
+        response: core.toResponse(w, w.bodyText),
+        meta: mkMeta(req, w, startedAt)
+      }))
+    );
+  };
+  const getJson = (url, init) => {
+    const base = core.buildReq("GET", url, init);
+    const req = setHeaderIfMissing("accept", "application/json")(base);
+    const startedAt = Date.now();
+    return core.withPromise(
+      mapTryAsync(core.requestRaw(req), (w) => ({
+        wire: w,
+        response: core.toResponse(w, JSON.parse(w.bodyText)),
+        meta: mkMeta(req, w, startedAt)
+      }))
+    );
+  };
+  return {
+    request,
+    // => { wire, meta }
+    get,
+    // => { wire, meta }
+    getText,
+    // => { wire, response(text), meta }
+    getJson,
+    // => { wire, response(json), meta }
+    post,
+    // => { wire, meta }
+    postJson
+    // => { wire, meta } (y además setea headers via optics)
+  };
+}
+function httpClientStream(cfg = {}) {
+  const wire = makeHttpStream(cfg);
+  const make = (w) => {
+    const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
+    const request = (req) => withPromise(w(req));
+    const getStream = (url, init) => {
+      const base = { method: "GET", url, init };
+      const req = setHeaderIfMissing("accept", "*/*")(base);
+      return request(req);
+    };
+    return {
+      request,
+      getStream,
+      get: getStream,
+      with: (mw) => make(mw(w)),
+      withRetry: (p) => make(withRetryStream(p)(w)),
+      wire: w
+    };
+  };
+  return make(wire);
+}
+export {
+  decorate,
+  httpClient,
+  httpClientStream,
+  httpClientWithMeta,
+  makeHttp,
+  makeHttpStream,
+  normalizeHeadersInit,
+  withMiddleware,
+  withRetryStream
+};

package/dist/index.d.mts

@@ -1,46 +1,123 @@
-import { A as Async, S as Scope, E as Exit, F as Fiber, O as Option } from './effect-NSaHksNl.mjs';
-export { a as AsyncWithPromise, C as CancelToken, b as Canceler, c as Cause, d as FiberId, e as FiberStatus, I as Interrupted, N as None, R as Runtime, f as RuntimeFiber, g as Scheduler, h as ScopeId, i as Some, T as Task, Z as ZIO, j as acquireRelease, k as async, l as asyncCatchAll, m as asyncFail, n as asyncFlatMap, o as asyncFold, p as asyncInterruptible, q as asyncMap, r as asyncMapError, s as asyncSucceed, t as asyncSync, u as asyncTotal, v as catchAll, w as end, x as fail, y as flatMap, z as fork, B as fromPromiseAbortable, D as getCurrentFiber, G as globalScheduler, H as linkAbortController, J as makeCancelToken, K as map, L as mapAsync, M as mapError, P as mapTryAsync, Q as none, U as orElseOptional, V as some, W as succeed, X as sync, Y as toPromise, _ as unit, $ as unsafeGetCurrentRuntime, a0 as unsafeRunAsync, a1 as unsafeRunFoldWithEnv, a2 as withAsyncPromise, a3 as withCurrentFiber, a4 as withScope, a5 as withScopeAsync } from './effect-NSaHksNl.mjs';
-import { Z as ZStream } from './stream-FwtnWmgX.mjs';
-export { C as Concat, E as Emit, a as Empty, F as Flatten, b as FromPull, M as Managed, c as Merge, N as Normalize, S as Scoped, d as assertNever, e as collectStream, f as concatStream, g as emitStream, h as emptyStream, i as flattenStream, j as foreachStream, k as fromArray, l as fromPull, m as managedStream, n as mapStream, o as merge, p as mergeStream, r as rangeStream, s as streamFromReadableStream, u as uncons, q as unwrapScoped, w as widenOpt, z as zip } from './stream-FwtnWmgX.mjs';
+import { F as FiberEngine, W as WasmEngineRuntime, A as Async, R as RuntimeFiber, b as FiberEngineStats, c as Fiber, d as FiberId, e as FiberStatus, E as Exit, f as RuntimeEvent, g as WasmBridge, h as OpcodeProgram, i as FiberId$1, j as EngineEvent, k as RefId, N as NodeId, l as OpcodeNode, S as Scope, m as RingBufferOptions, n as EngineStats, O as Option } from './effect-ISvXPLgc.mjs';
+export { o as AsyncRegisterRef, a as AsyncWithPromise, p as BoundedRingBuffer, C as CancelToken, q as Canceler, r as Cause, s as CustomHostAction, D as DbHostAction, t as DecodeRef, u as DefaultHostExecutor, v as EngineKind, w as EngineSelection, x as EngineSelectionMode, y as FiberEngineKind, z as FlatMapRef, B as FoldFailureRef, G as FoldSuccessRef, H as HostAction, I as HostActionKind, J as HostActionResult, K as HostExecutionContext, L as HostExecutor, M as HostRegistry, P as HttpHostAction, Q as Interrupted, T as Joiner, U as None, V as NoopHooks, X as ProgramBuilder, Y as ProgramPatch, _ as PushStatus, $ as QueueHostAction, a0 as RingBuffer, a1 as RingBufferEngine, a2 as RingBufferStatsData, a3 as Runtime, a4 as RuntimeCapabilities, a5 as RuntimeEngineMode, a6 as RuntimeOptions, a7 as Scheduler, a8 as SchedulerEngine, a9 as SchedulerOptions, aa as SchedulerStats, ab as SchedulerStatsData, ac as ScopeId, ad as Some, ae as SyncRef, af as Task, ag as WasmFiberEngine, ah as WasmFiberEngineOptions, Z as ZIO, ai as acquireRelease, aj as async, ak as asyncCatchAll, al as asyncFail, am as asyncFlatMap, an as asyncFold, ao as asyncInterruptible, ap as asyncMap, aq as asyncMapError, ar as asyncSucceed, as as asyncSync, at as asyncTotal, au as catchAll, av as end, aw as engineStats, ax as fail, ay as flatMap, az as fork, aA as fromPromiseAbortable, aB as getBenchmarkBudget, aC as getCurrentFiber, aD as globalScheduler, aE as linkAbortController, aF as makeBoundedRingBuffer, aG as makeCancelToken, aH as map, aI as mapAsync, aJ as mapError, aK as mapTryAsync, aL as none, aM as orElseOptional, aN as runtimeCapabilities, aO as selectedEngineStats, aP as setBenchmarkBudget, aQ as some, aR as succeed, aS as sync, aT as toPromise, aU as unit, aV as unsafeGetCurrentRuntime, aW as unsafeRunAsync, aX as unsafeRunFoldWithEnv, aY as withAsyncPromise, aZ as withCurrentFiber, a_ as withScope, a$ as withScopeAsync } from './effect-ISvXPLgc.mjs';
+import { Z as ZStream } from './stream-C0-LWnUP.mjs';
+export { C as Concat, E as Emit, a as Empty, F as Flatten, b as FromPull, M as Managed, c as Merge, N as Normalize, S as Scoped, d as assertNever, e as collectStream, f as concatStream, g as emitStream, h as emptyStream, i as flattenStream, j as foreachStream, k as fromArray, l as fromPull, m as managedStream, n as mapStream, o as merge, p as mergeStream, r as rangeStream, s as streamFromReadableStream, u as uncons, q as unwrapScoped, w as widenOpt, z as zip } from './stream-C0-LWnUP.mjs';
 
-type Node<T> = {
-    value: T;
-    next: Node<T> | null;
-    prev: Node<T> | null;
-    removed: boolean;
-};
-declare class LinkedQueue<T> {
-    private head;
-    private tail;
-    private len;
-    get length(): number;
-    isEmpty(): boolean;
-    push(value: T): Node<T>;
-    shift(): T | undefined;
-    remove(node: Node<T>): void;
-    private unlink;
+declare class JsFiberEngine<R> implements FiberEngine<R> {
+    private readonly runtime;
+    readonly kind: "js";
+    private startedFibers;
+    constructor(runtime: WasmEngineRuntime<R> & any);
+    fork<E, A>(effect: Async<R, E, A>, scopeId?: number): RuntimeFiber<R, E, A>;
+    stats(): FiberEngineStats;
 }
 
-declare const enum PushStatus {
-    Ok = 0,
-    Grew = 1,
-    Dropped = 2
+type InternalFiberStatus = "queued" | "running" | "suspended" | "done" | "failed" | "interrupted";
+declare class EngineFiberHandle<R, E, A> implements Fiber<E, A> {
+    private readonly onScheduledStep;
+    private readonly onInterrupt;
+    private readonly onJoiner?;
+    private readonly onQueued?;
+    readonly id: FiberId;
+    readonly runtime: WasmEngineRuntime<R> & any;
+    fiberContext: any;
+    name?: string;
+    scopeId?: number;
+    parentFiberId?: number;
+    private result;
+    private readonly joiners;
+    private readonly finalizers;
+    private finalizersDrained;
+    private internalStatus;
+    private queued;
+    constructor(id: FiberId, runtime: WasmEngineRuntime<R> & any, onScheduledStep: (fiberId: FiberId) => void, onInterrupt: (fiberId: FiberId, reason: unknown) => void, onJoiner?: ((fiberId: FiberId) => void) | undefined, onQueued?: ((fiberId: FiberId) => void) | undefined);
+    status(): FiberStatus;
+    engineStatus(): InternalFiberStatus;
+    setEngineStatus(status: InternalFiberStatus): void;
+    join(cb: (exit: Exit<E, A>) => void): void;
+    interrupt(): void;
+    addFinalizer(f: (exit: Exit<E, A>) => void): void;
+    schedule(tag?: string): void;
+    emit(ev: RuntimeEvent): void;
+    succeed(value: A): void;
+    fail(error: E): void;
+    die(defect: unknown): void;
+    interrupted(): void;
+    complete(exit: Exit<E, A>): void;
+    private runFinalizersOnce;
 }
-declare class RingBuffer<T> {
-    private buf;
-    private head;
-    private tail;
-    private size_;
-    private readonly maxCap;
-    constructor(initialCapacity?: number, maxCapacity?: number);
-    get length(): number;
-    get capacity(): number;
-    isEmpty(): boolean;
-    push(value: T): PushStatus;
-    shift(): T | undefined;
-    clear(): void;
-    private grow;
-    private nextPow2;
+
+declare class ReferenceWasmBridge implements WasmBridge {
+    readonly kind: "wasm-reference";
+    private nextFiberId;
+    private readonly fibers;
+    private started;
+    private completed;
+    private failed;
+    private interrupted;
+    createFiber(program: OpcodeProgram): FiberId$1;
+    poll(fiberId: FiberId$1): EngineEvent;
+    provideValue(fiberId: FiberId$1, valueRef: RefId): EngineEvent;
+    provideError(fiberId: FiberId$1, errorRef: RefId): EngineEvent;
+    provideEffect(fiberId: FiberId$1, root: NodeId, nodes: OpcodeNode[]): EngineEvent;
+    interrupt(fiberId: FiberId$1, reasonRef: RefId): EngineEvent;
+    dropFiber(fiberId: FiberId$1): void;
+    stats(): unknown;
+    private mustFiber;
+    private step;
+    private success;
+    private failure;
+    private suspend;
+    private markDone;
+    private markFailed;
+}
+
+declare class WasmPackFiberBridge implements WasmBridge {
+    readonly kind: "wasm";
+    private readonly vm;
+    constructor(modulePath?: string);
+    createFiber(program: OpcodeProgram): FiberId$1;
+    poll(fiberId: FiberId$1): EngineEvent;
+    provideValue(fiberId: FiberId$1, valueRef: RefId): EngineEvent;
+    provideError(fiberId: FiberId$1, errorRef: RefId): EngineEvent;
+    provideEffect(fiberId: FiberId$1, root: NodeId, nodes: OpcodeNode[]): EngineEvent;
+    interrupt(fiberId: FiberId$1, reasonRef: RefId): EngineEvent;
+    dropFiber(fiberId: FiberId$1): void;
+    stats(): unknown;
+}
+
+type WasmFiberRegistryStats = {
+    readonly live: number;
+    readonly queued: number;
+    readonly running: number;
+    readonly suspended: number;
+    readonly done: number;
+    readonly failed: number;
+    readonly interrupted: number;
+    readonly wakeQueueLen: number;
+    readonly registered: number;
+    readonly completed: number;
+    readonly wakeups: number;
+    readonly duplicateWakeups: number;
+    readonly joins: number;
+};
+type FiberRegistryStatus = "queued" | "running" | "suspended" | "done" | "failed" | "interrupted";
+declare class WasmFiberRegistryBridge {
+    private readonly registry;
+    constructor();
+    registerFiber(fiberId: FiberId$1, parentId?: number, scopeId?: number): void;
+    markQueued(fiberId: FiberId$1): void;
+    markRunning(fiberId: FiberId$1): void;
+    markSuspended(fiberId: FiberId$1): void;
+    markDone(fiberId: FiberId$1, status: Exclude<FiberRegistryStatus, "queued" | "running" | "suspended">): number;
+    dropFiber(fiberId: FiberId$1): void;
+    addJoiner(fiberId: FiberId$1): void;
+    wake(fiberId: FiberId$1): boolean;
+    drainWakeup(): FiberId$1 | undefined;
+    drainWakeups(): FiberId$1[];
+    wakeQueueLength(): number;
+    stateOf(fiberId: FiberId$1): FiberRegistryStatus | "missing";
+    stats(): WasmFiberRegistryStats;
 }
 
 declare function buffer<R, E, A>(stream: ZStream<{} & R, E, A>, capacity: number, strategy?: "backpressure" | "dropping" | "sliding"): ZStream<{} & R, E, A>;
@@ -78,7 +155,8 @@ type Queue<A> = {
     size: () => number;
     shutdown: () => void;
 };
-declare function bounded<A>(capacity: number, strategy?: Strategy): Async<unknown, unknown, Queue<A>>;
+type QueueOptions = RingBufferOptions;
+declare function bounded<A>(capacity: number, strategy?: Strategy, options?: QueueOptions): Async<unknown, unknown, Queue<A>>;
 
 type HubStrategy = "BackPressure" | "Dropping" | "Sliding";
 type HubClosed = {
@@ -98,6 +176,42 @@ declare const broadcast: typeof makeHub;
 declare function broadcastToHub<R, E, A>(stream: ZStream<R, E, A>, hub: Hub<A>): Async<R, E, void>;
 declare function fromHub<A>(hub: Hub<A>): ZStream<unknown, HubClosed, A>;
 
+type StreamChunkEngine = "auto" | "js" | "wasm";
+type StreamChunkOptions = {
+    /**
+     * auto: use WASM when wasm/pkg is available, otherwise JS.
+     * js: always use the JS array chunker.
+     * wasm: require BrassWasmChunkBuffer from wasm/pkg.
+     */
+    engine?: StreamChunkEngine;
+};
+type StreamChunkStats = {
+    len: number;
+    maxChunkSize: number;
+    emittedChunks: number;
+    emittedItems: number;
+    flushes: number;
+};
+type Chunker<A> = {
+    readonly length: number;
+    readonly maxChunkSize: number;
+    push(value: A): boolean;
+    isFull(): boolean;
+    isEmpty(): boolean;
+    takeChunk(): readonly A[];
+    clear(): void;
+    stats(): EngineStats<StreamChunkStats>;
+};
+declare function makeStreamChunker<A>(chunkSize: number, options?: StreamChunkOptions): Chunker<A>;
+/**
+ * Re-chunk a stream so downstream operators receive arrays instead of single
+ * items. This is the intended WASM boundary: pay the JS↔WASM crossing while
+ * assembling chunks, then process bigger batches downstream.
+ */
+declare function chunks<R, E, A>(input: ZStream<R, E, A>, chunkSize: number, options?: StreamChunkOptions): ZStream<R, E, readonly A[]>;
+declare function mapChunks<R, E, A, B>(input: ZStream<R, E, A>, chunkSize: number, f: (chunk: readonly A[]) => readonly B[], options?: StreamChunkOptions): ZStream<R, E, B>;
+declare function mapChunksEffect<Rp, Ep, A, B>(chunkSize: number, f: (chunk: readonly A[]) => Async<Rp, Ep, readonly B[]>, options?: StreamChunkOptions): <R, E>(input: ZStream<R, E, A>) => ZStream<R & Rp, E | Ep, B>;
+
 /**
  * ZPipeline-style transformer.
  *
@@ -129,6 +243,10 @@ declare function dropP<A>(n: number): ZPipeline<unknown, never, A, A>;
 declare function mapEffectP<Rp, Ep, A, B>(f: (a: A) => Async<Rp, Ep, B>): ZPipeline<Rp, Ep, A, B>;
 /** Tap each element with an effect, preserving the element. */
 declare function tapEffectP<Rp, Ep, A>(f: (a: A) => Async<Rp, Ep, any>): ZPipeline<Rp, Ep, A, A>;
+/** Re-chunk a stream into arrays of up to `chunkSize` elements. */
+declare function chunksP<A>(chunkSize: number, options?: StreamChunkOptions): ZPipeline<unknown, never, A, readonly A[]>;
+/** Apply one effect per chunk and flatten the returned chunk back to elements. */
+declare function mapChunksEffectP<Rp, Ep, A, B>(chunkSize: number, f: (chunk: readonly A[]) => Async<Rp, Ep, readonly B[]>, options?: StreamChunkOptions): ZPipeline<Rp, Ep, A, B>;
 /** Buffer upstream using your existing queue-based buffer implementation. */
 declare function bufferP<A>(capacity: number, strategy?: "backpressure" | "dropping" | "sliding"): ZPipeline<unknown, never, A, A>;
 /**
@@ -137,4 +255,4 @@ declare function bufferP<A>(capacity: number, strategy?: "backpressure" | "dropp
  */
 declare function groupedP<A>(n: number): ZPipeline<unknown, never, A, A[]>;
 
-export { Async, Exit, Fiber, type Hub, type HubClosed, type HubStrategy, LinkedQueue, type Node, Option, PushStatus, type Queue, type QueueClosed, RingBuffer, Scope, type Strategy, type Subscription, type ZPipeline, ZStream, andThen, bounded, broadcast, broadcastToHub, buffer, bufferP, collectAllPar, compose, dropP, filterMapP, filterP, fromHub, groupedP, identity, makeHub, mapEffectP, mapP, race, raceWith, takeP, tapEffectP, via, zipPar };
+export { Async, EngineEvent, EngineFiberHandle, EngineStats, Exit, Fiber, FiberEngine, FiberEngineStats, FiberId, FiberStatus, type Hub, type HubClosed, type HubStrategy, type InternalFiberStatus, JsFiberEngine, NodeId, OpcodeNode, OpcodeProgram, Option, type Queue, type QueueClosed, type QueueOptions, RefId, ReferenceWasmBridge, RingBufferOptions, RuntimeFiber, Scope, type Strategy, type StreamChunkEngine, type StreamChunkOptions, type StreamChunkStats, type Subscription, WasmBridge, WasmEngineRuntime, WasmFiberRegistryBridge, type WasmFiberRegistryStats, WasmPackFiberBridge, type ZPipeline, ZStream, andThen, bounded, broadcast, broadcastToHub, buffer, bufferP, chunks, chunksP, collectAllPar, compose, dropP, filterMapP, filterP, fromHub, groupedP, identity, makeHub, makeStreamChunker, mapChunks, mapChunksEffect, mapChunksEffectP, mapEffectP, mapP, race, raceWith, takeP, tapEffectP, via, zipPar };