brass-runtime 1.13.5 → 1.13.7

package/dist/http/index.d.mts

@@ -1,154 +0,0 @@
-import { A as Async, a as AsyncWithPromise } from '../effect-ISvXPLgc.mjs';
-import { Z as ZStream } from '../stream-C0-LWnUP.mjs';
-
-type RetryPolicy = {
-    maxRetries: number;
-    baseDelayMs: number;
-    maxDelayMs: number;
-    retryOnMethods?: HttpMethod[];
-    retryOnStatus?: (status: number) => boolean;
-    retryOnError?: (e: HttpError) => boolean;
-};
-
-type HttpError = {
-    _tag: "Abort";
-} | {
-    _tag: "BadUrl";
-    message: string;
-} | {
-    _tag: "FetchError";
-    message: string;
-};
-type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
-type HttpInit = Omit<RequestInit, "method" | "body" | "headers">;
-type HttpRequest = {
-    method: HttpMethod;
-    url: string;
-    headers?: Record<string, string>;
-    body?: string;
-    init?: HttpInit;
-};
-type HttpWireResponse = {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    bodyText: string;
-    ms: number;
-};
-type MakeHttpConfig = {
-    baseUrl?: string;
-    headers?: Record<string, string>;
-};
-type HttpWireResponseStream = {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: ZStream<unknown, HttpError, Uint8Array>;
-    ms: number;
-};
-type HttpClientStream = (req: HttpRequest) => Async<unknown, HttpError, HttpWireResponseStream>;
-type HttpClient = HttpClientFn & {
-    with: (mw: HttpMiddleware) => HttpClient;
-};
-declare const withMiddleware: (mw: HttpMiddleware) => (c: HttpClient) => HttpClient;
-declare const decorate: (run: HttpClientFn) => HttpClient;
-type HttpClientFn = (req: HttpRequest) => Async<unknown, HttpError, HttpWireResponse>;
-type HttpMiddleware = (next: HttpClientFn) => HttpClientFn;
-declare const normalizeHeadersInit: (h: any) => Record<string, string> | undefined;
-declare function makeHttpStream(cfg?: MakeHttpConfig): HttpClientStream;
-declare function makeHttp(cfg?: MakeHttpConfig): HttpClient;
-declare const withRetryStream: (p: RetryPolicy) => (next: HttpClientStream) => HttpClientStream;
-
-type InitNoMethodBody = Omit<RequestInit, "method" | "body">;
-type HttpMeta = {
-    request: HttpRequest;
-    urlFinal: string;
-    startedAt: number;
-    durationMs: number;
-};
-type HttpResponse<A> = {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: A;
-};
-type HttpWireWithMeta = {
-    wire: HttpWireResponse;
-    meta: HttpMeta;
-};
-type HttpResponseWithMeta<A> = {
-    wire: HttpWireResponse;
-    response: HttpResponse<A>;
-    meta: HttpMeta;
-};
-type AnyInitWithHeaders = {
-    headers?: any;
-} & Record<string, any>;
-type Dx = {
-    request: (req: HttpRequest) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
-    get: (url: string, init?: AnyInitWithHeaders) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
-    post: (url: string, body?: string, init?: AnyInitWithHeaders) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
-    getText: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpResponse<string>>;
-    getJson: <A>(url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpResponse<A>>;
-    postJson: <A>(url: string, bodyObj: unknown, init?: AnyInitWithHeaders) => AsyncWithPromise<unknown, HttpError, HttpResponse<A>>;
-    with: (mw: HttpMiddleware) => Dx;
-    withRetry: (p: RetryPolicy) => Dx;
-    wire: HttpClient;
-};
-declare function httpClient(cfg?: MakeHttpConfig): Dx;
-declare function httpClientWithMeta(cfg?: MakeHttpConfig): {
-    request: (req: HttpRequest) => AsyncWithPromise<unknown, HttpError, {
-        wire: HttpWireResponse;
-        meta: HttpMeta;
-    }>;
-    get: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, {
-        wire: HttpWireResponse;
-        meta: HttpMeta;
-    }>;
-    getText: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, {
-        wire: HttpWireResponse;
-        response: {
-            status: number;
-            statusText: string;
-            headers: Record<string, string>;
-            body: string;
-        };
-        meta: HttpMeta;
-    }>;
-    getJson: <A>(url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, {
-        wire: HttpWireResponse;
-        response: {
-            status: number;
-            statusText: string;
-            headers: Record<string, string>;
-            body: A;
-        };
-        meta: HttpMeta;
-    }>;
-    post: (url: string, body?: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, {
-        wire: HttpWireResponse;
-        meta: HttpMeta;
-    }>;
-    postJson: <A>(url: string, bodyObj: unknown, init?: HttpInit & {
-        headers?: Record<string, string>;
-    }) => AsyncWithPromise<unknown, HttpError, {
-        wire: HttpWireResponse;
-        response: {
-            status: number;
-            statusText: string;
-            headers: Record<string, string>;
-            body: A;
-        };
-        meta: HttpMeta;
-    }>;
-};
-declare function httpClientStream(cfg?: MakeHttpConfig): {
-    request: (req: HttpRequest) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream>;
-    getStream: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream>;
-    get: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream>;
-    with: (mw: (n: HttpClientStream) => HttpClientStream) => /*elided*/ any;
-    withRetry: (p: RetryPolicy) => /*elided*/ any;
-    wire: HttpClientStream;
-};
-
-export { type Dx, type HttpClient, type HttpClientFn, type HttpClientStream, type HttpError, type HttpInit, type HttpMeta, type HttpMethod, type HttpMiddleware, type HttpRequest, type HttpResponse, type HttpResponseWithMeta, type HttpWireResponse, type HttpWireResponseStream, type HttpWireWithMeta, type MakeHttpConfig, decorate, httpClient, httpClientStream, httpClientWithMeta, makeHttp, makeHttpStream, normalizeHeadersInit, withMiddleware, withRetryStream };

package/dist/index.d.mts

@@ -1,258 +0,0 @@
-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';
-
-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;
-}
-
-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 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>;
-
-/**
- * race(A, B):
- *   - corre A y B en paralelo
- *   - el primero que termine gana
- *   - el otro es cancelado
- */
-declare function race<R, E, A>(left: Async<R, E, A>, right: Async<R, E, A>, parentScope: Scope<R>): Async<R, E, A>;
-/**
- * zipPar(A, B):
- *   - corre A y B en paralelo
- *   - si ambas terminan bien → éxito con (A, B)
- *   - si una falla → cancelar todo y devolver fallo
- */
-declare function zipPar<R, E, A, B>(left: Async<R, E, A>, right: Async<R, E, B>, parentScope: Scope<R>): Async<R, E, [A, B]>;
-/**
- * collectAllPar:
- *   - corre todos en paralelo
- *   - si uno falla → cancela todos
- *   - si todos terminan bien → devuelve array de resultados
- */
-declare function collectAllPar<R, E, A>(effects: ReadonlyArray<Async<R, E, A>>, parentScope: Scope<R>): Async<R, E, A[]>;
-declare function raceWith<R, E, A, B, C>(left: Async<R, E, A>, right: Async<R, E, B>, parentScope: Scope<R>, onLeft: (exit: Exit<E, A>, rightFiber: Fiber<E, B>, scope: Scope<R>) => Async<R, E, C>, onRight: (exit: Exit<E, B>, leftFiber: Fiber<E, A>, scope: Scope<R>) => Async<R, E, C>): Async<R, E, C>;
-
-type Strategy = "backpressure" | "dropping" | "sliding";
-type QueueClosed = {
-    _tag: "QueueClosed";
-};
-type Queue<A> = {
-    offer: (a: A) => Async<unknown, never, boolean>;
-    take: () => Async<unknown, QueueClosed, A>;
-    size: () => number;
-    shutdown: () => void;
-};
-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 = {
-    _tag: "HubClosed";
-};
-type Subscription<A> = Queue<A> & {
-    unsubscribe: () => void;
-};
-type Hub<A> = {
-    publish: (a: A) => Async<unknown, never, boolean>;
-    publishAll: (as: Iterable<A>) => Async<unknown, never, boolean>;
-    subscribe: () => Async<unknown, HubClosed, Subscription<A>>;
-    shutdown: () => Async<unknown, any, any>;
-};
-declare function makeHub<A>(capacity: number, strategy?: HubStrategy): Hub<A>;
-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.
- *
- * A pipeline that consumes `In` and produces `Out`, potentially requiring `Rp` and failing with `Ep`.
- * When applied to a stream `ZStream<R, E, In>`, the result is `ZStream<R & Rp, E | Ep, Out>`.
- */
-type ZPipeline<Rp, Ep, In, Out> = <R, E>(input: ZStream<R, E, In>) => ZStream<R & Rp, E | Ep, Out>;
-/** Apply a pipeline to a stream (alias of `pipeline(stream)`). */
-declare function via<R, E, A, Rp, Ep, B>(stream: ZStream<R, E, A>, pipeline: ZPipeline<Rp, Ep, A, B>): ZStream<R & Rp, E | Ep, B>;
-/** Compose pipelines left-to-right (p1 >>> p2). */
-declare function andThen<R1, E1, In, Mid, R2, E2, Out>(p1: ZPipeline<R1, E1, In, Mid>, p2: ZPipeline<R2, E2, Mid, Out>): ZPipeline<R1 & R2, E1 | E2, In, Out>;
-/** Compose pipelines right-to-left (p2 <<< p1). */
-declare function compose<R1, E1, In, Mid, R2, E2, Out>(p2: ZPipeline<R2, E2, Mid, Out>, p1: ZPipeline<R1, E1, In, Mid>): ZPipeline<R1 & R2, E1 | E2, In, Out>;
-/** Identity pipeline. */
-declare function identity<A>(): ZPipeline<unknown, never, A, A>;
-/** Map elements. */
-declare function mapP<A, B>(f: (a: A) => B): ZPipeline<unknown, never, A, B>;
-/** Filter elements, preserving end/error. */
-declare function filterP<A>(pred: (a: A) => boolean): ZPipeline<unknown, never, A, A>;
-/**
- * Filter-map (aka collectSome).
- * If `f(a)` returns None, the element is dropped.
- */
-declare function filterMapP<A, B>(f: (a: A) => Option<B>): ZPipeline<unknown, never, A, B>;
-/** Take at most N elements. */
-declare function takeP<A>(n: number): ZPipeline<unknown, never, A, A>;
-/** Drop the first N elements. */
-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>;
-/**
- * Group elements into arrays of size `n` (last chunk may be smaller).
- * Example: [1,2,3,4,5].grouped(2) => [1,2],[3,4],[5]
- */
-declare function groupedP<A>(n: number): ZPipeline<unknown, never, A, A[]>;
-
-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 };

package/dist/stream-C0-LWnUP.d.mts

@@ -1,66 +0,0 @@
-import { Z as ZIO, O as Option, E as Exit, A as Async } from './effect-ISvXPLgc.mjs';
-
-type Empty<R, E, A> = {
-    readonly _tag: "Empty";
-};
-type Emit<R, E, A> = {
-    readonly _tag: "Emit";
-    readonly value: ZIO<R, E, A>;
-};
-type Concat<R, E, A> = {
-    readonly _tag: "Concat";
-    readonly left: ZStream<R, E, A>;
-    readonly right: ZStream<R, E, A>;
-};
-type Flatten<R, E, A> = {
-    readonly _tag: "Flatten";
-    readonly stream: ZStream<R, E, ZStream<R, E, A>>;
-};
-type FromPull<R, E, A> = {
-    readonly _tag: "FromPull";
-    readonly pull: ZIO<R, Option<E>, [A, ZStream<R, E, A>]>;
-};
-type Merge<R, E, A> = {
-    readonly _tag: "Merge";
-    readonly left: ZStream<R, E, A>;
-    readonly right: ZStream<R, E, A>;
-    readonly flip: boolean;
-};
-type Scoped<R, E, A> = {
-    readonly _tag: "Scoped";
-    readonly acquire: ZIO<R, E, ZStream<R, E, A>>;
-    readonly release: (exit: Exit<any, any>) => Async<R, any, void>;
-};
-type Managed<R, E, A> = {
-    readonly _tag: "Managed";
-    readonly acquire: ZIO<R, E, {
-        stream: ZStream<R, E, A>;
-        release: (exit: Exit<any, any>) => Async<R, any, void>;
-    }>;
-};
-type ZStream<R, E, A> = Empty<R, E, A> | Emit<R, E, A> | Concat<R, E, A> | FromPull<R, E, A> | Flatten<R, E, A> | Merge<R, E, A> | Scoped<R, E, A> | Managed<R, E, A>;
-type Normalize<E> = (u: unknown) => E;
-declare const widenOpt: <E1, E2>(opt: Option<E1>) => Option<E1 | E2>;
-declare const fromPull: <R, E, A>(pull: ZIO<R, Option<E>, [A, ZStream<R, E, A>]>) => ZStream<R, E, A>;
-declare const unwrapScoped: <R, E, A>(acquire: ZIO<R, E, ZStream<R, E, A>>, release: (exit: Exit<any, any>) => Async<R, any, void>) => ZStream<R, E, A>;
-declare const managedStream: <R, E, A>(acquire: ZIO<R, E, {
-    stream: ZStream<R, E, A>;
-    release: (exit: Exit<any, any>) => Async<R, any, void>;
-}>) => ZStream<R, E, A>;
-declare const mergeStream: <R, E, A>(left: ZStream<R, E, A>, right: ZStream<R, E, A>, flip?: boolean) => ZStream<R, E, A>;
-declare const emptyStream: <R, E, A>() => ZStream<R, E, A>;
-declare const emitStream: <R, E, A>(value: ZIO<R, E, A>) => ZStream<R, E, A>;
-declare const concatStream: <R, E, A>(left: ZStream<R, E, A>, right: ZStream<R, E, A>) => ZStream<R, E, A>;
-declare const flattenStream: <R, E, A>(stream: ZStream<R, E, ZStream<R, E, A>>) => ZStream<R, E, A>;
-declare function merge<R, E, A>(left: ZStream<R, E, A>, right: ZStream<R, E, A>): ZStream<R, E, A>;
-declare function uncons<R, E, A>(self: ZStream<R, E, A>): ZIO<R, Option<E>, [A, ZStream<R, E, A>]>;
-declare function assertNever(x: never, msg?: string): never;
-declare function mapStream<R, E, A, B>(self: ZStream<R, E, A>, f: (a: A) => B): ZStream<R, E, B>;
-declare function rangeStream(start: number, end: number): ZStream<unknown, never, number>;
-declare function zip<R, E1, A, E2, B>(left: ZStream<R, E1, A>, right: ZStream<R, E2, B>): ZStream<R, E1 | E2, [A, B]>;
-declare function foreachStream<R, E, A, R2, E2>(stream: ZStream<R, E, A>, f: (a: A) => Async<R2, E2, void>): Async<R & R2, E | E2, void>;
-declare function fromArray<A>(values: readonly A[]): ZStream<unknown, never, A>;
-declare function collectStream<R, E, A>(stream: ZStream<R, E, A>): ZIO<R, E, A[]>;
-declare function streamFromReadableStream<E>(body: ReadableStream<Uint8Array> | null | undefined, normalizeError: Normalize<E>): ZStream<unknown, E, Uint8Array>;
-
-export { type Concat as C, type Emit as E, type Flatten as F, type Managed as M, type Normalize as N, type Scoped as S, type ZStream as Z, type Empty as a, type FromPull as b, type Merge as c, assertNever as d, collectStream as e, concatStream as f, emitStream as g, emptyStream as h, flattenStream as i, foreachStream as j, fromArray as k, fromPull as l, managedStream as m, mapStream as n, merge as o, mergeStream as p, unwrapScoped as q, rangeStream as r, streamFromReadableStream as s, uncons as u, widenOpt as w, zip as z };