brass-runtime 1.12.1 → 1.13.3

package/dist/index.d.ts

@@ -1,46 +1,123 @@
-import { A as Async, S as Scope, E as Exit, F as Fiber, O as Option } from './effect-NSaHksNl.js';
-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.js';
-import { Z as ZStream } from './stream-DNTGNv-G.js';
-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-DNTGNv-G.js';
+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.js';
+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.js';
+import { Z as ZStream } from './stream-BvukHxCv.js';
+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-BvukHxCv.js';
 
-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 };