brass-runtime 1.11.1 → 1.12.1

package/dist/stream-hTHRKq88.d.ts

@@ -1,355 +0,0 @@
-type Canceler = () => void;
-type CancelToken = {
-    /** true si ya fue cancelado */
-    readonly isCancelled: () => boolean;
-    /**
-     * Registra un callback que se ejecuta cuando se cancela.
-     * Si ya estaba cancelado, lo ejecuta inmediatamente.
-     * Devuelve un "unsubscribe" para desregistrar.
-     */
-    readonly onCancel: (f: Canceler) => Canceler;
-};
-/** Implementación simple de CancelToken */
-declare function makeCancelToken(): CancelToken & {
-    cancel: Canceler;
-};
-/**
- * Helper: conecta un AbortController a un CancelToken.
- * Devuelve una función para desenganchar (unsubscribe).
- */
-declare function linkAbortController(token: CancelToken, ac: AbortController): Canceler;
-
-type Task = () => void;
-declare class Scheduler {
-    private queue;
-    private flushing;
-    private scheduled;
-    schedule(task: Task, tag?: string): void;
-    private requestFlush;
-    private flush;
-}
-declare const globalScheduler: Scheduler;
-
-type RuntimeEvent = {
-    type: "fiber.start";
-    fiberId: number;
-    parentFiberId?: number;
-    scopeId?: number;
-    name?: string;
-} | {
-    type: "fiber.end";
-    fiberId: number;
-    status: "success" | "failure" | "interrupted";
-    error?: unknown;
-} | {
-    type: "fiber.suspend";
-    fiberId: number;
-    reason?: string;
-} | {
-    type: "fiber.resume";
-    fiberId: number;
-} | {
-    type: "scope.open";
-    scopeId: number;
-    parentScopeId?: number;
-} | {
-    type: "scope.close";
-    scopeId: number;
-    status: "success" | "failure" | "interrupted";
-    error?: unknown;
-} | {
-    type: "log";
-    level: "debug" | "info" | "warn" | "error";
-    message: string;
-    fields?: Record<string, unknown>;
-};
-interface RuntimeHooks {
-    emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
-}
-type RuntimeEmitContext = {
-    fiberId?: number;
-    scopeId?: number;
-    traceId?: string;
-    spanId?: string;
-};
-
-type NodeCallback<A> = (err: Error | null, result: A) => void;
-/**
- * --- Runtime como objeto único (ZIO-style) ---
- * Un valor que representa "cómo" se ejecutan los efectos: scheduler + environment + hooks.
- */
-declare class Runtime<R> {
-    readonly env: R;
-    readonly scheduler: Scheduler;
-    readonly hooks: RuntimeHooks;
-    readonly forkPolicy: {
-        initChild(fiber: RuntimeFiber<any, any, any> & any, parent?: (RuntimeFiber<any, any, any> & any) | null): void;
-    };
-    constructor(args: {
-        env: R;
-        scheduler?: Scheduler;
-        hooks?: RuntimeHooks;
-    });
-    fork<E, A>(effect: Async<R, E, A>): Fiber<E, A>;
-    unsafeRunAsync<E, A>(effect: Async<R, E, A>, cb: (exit: Exit<E | Interrupted, A>) => void): void;
-    toPromise<E, A>(effect: Async<R, E, A>): Promise<A>;
-    log(level: "debug" | "info" | "warn" | "error", message: string, fields?: Record<string, unknown>): void;
-    withHooks(hooks: RuntimeHooks): Runtime<R>;
-    emit(ev: RuntimeEvent): void;
-    static make<R>(env: R, scheduler?: Scheduler): Runtime<R>;
-}
-/**
- * ---------------------------------------------------------------------------
- * Helpers existentes (los dejo igual) + wrappers que usan Runtime por debajo
- * ---------------------------------------------------------------------------
- */
-declare function from<A>(f: (cb: NodeCallback<A>) => void): Async<{}, Error, A>;
-declare function from<A>(thunk: () => Promise<A>): Async<{}, Error, A>;
-type BrassError = {
-    _tag: "Abort";
-} | {
-    _tag: "PromiseRejected";
-    reason: unknown;
-};
-/**
- * --- Wrappers legacy (mantienen tu API actual) ---
- * Internamente crean un Runtime ad-hoc con env + scheduler.
- */
-declare function fork<R, E, A>(effect: Async<R, E, A>, env: R, scheduler?: Scheduler): Fiber<E, A>;
-declare function unsafeRunAsync<R, E, A>(effect: Async<R, E, A>, env: R, cb: (exit: Exit<E | Interrupted, A>) => void): void;
-declare function toPromise<R, E, A>(eff: Async<R, E, A>, env: R): Promise<A>;
-declare function fromPromise<R, E, A>(thunk: (env: R) => Promise<A>, onError: (e: unknown) => E): Async<R, E, A>;
-declare function fromCallback<A>(f: (cb: NodeCallback<A>) => void): Async<{}, Error, A>;
-declare function tryPromiseAbortable<A>(thunk: (signal: AbortSignal) => Promise<A>): Async<unknown, BrassError, A>;
-declare function tryPromiseAbortable<R, A>(thunk: (env: R, signal: AbortSignal) => Promise<A>): Async<R, BrassError, A>;
-declare function fromPromiseAbortable<E, A>(thunk: (signal: AbortSignal) => Promise<A>, onError: (e: unknown) => E): Async<unknown, E, A>;
-declare function fromPromiseAbortable<R, E, A>(thunk: (env: R, signal: AbortSignal) => Promise<A>, onError: (e: unknown) => E): Async<R, E, A>;
-declare function getCurrentRuntime<R>(): Runtime<R>;
-
-type JSONValue = null | boolean | number | string | JSONValue[] | {
-    [k: string]: JSONValue;
-};
-type ContextNode = {
-    parent: ContextNode | null;
-    patch: Record<string, JSONValue>;
-};
-type TraceContext = {
-    traceId: string;
-    spanId: string;
-    parentSpanId?: string;
-    sampled?: boolean;
-};
-type FiberContext = {
-    log: ContextNode;
-    trace: TraceContext | null;
-};
-
-type FiberId = number;
-type Interrupted = {
-    readonly _tag: "Interrupted";
-};
-type FiberStatus = "Running" | "Done" | "Interrupted";
-type StepDecision = "Continue" | "Suspend" | "Done";
-type Fiber<E, A> = {
-    readonly id: FiberId;
-    readonly status: () => FiberStatus;
-    readonly join: (cb: (exit: Exit<E | Interrupted, A>) => void) => void;
-    readonly interrupt: () => void;
-    readonly addFinalizer: (f: (exit: Exit<E | Interrupted, A>) => void) => void;
-};
-declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
-    readonly id: FiberId;
-    readonly runtime: Runtime<R>;
-    private closing;
-    private finishing;
-    private runState;
-    private interrupted;
-    private result;
-    private readonly joiners;
-    private current;
-    private readonly stack;
-    private readonly fiberFinalizers;
-    private finalizersDrained;
-    fiberContext: FiberContext;
-    name?: string;
-    scopeId?: number;
-    constructor(runtime: Runtime<R>, effect: Async<R, E, A>);
-    private get env();
-    private get scheduler();
-    addFinalizer(f: (exit: Exit<E | Interrupted, A>) => void): void;
-    status(): FiberStatus;
-    join(cb: (exit: Exit<E | Interrupted, A>) => void): void;
-    interrupt(): void;
-    schedule(tag?: string): void;
-    private runFinalizersOnce;
-    private notify;
-    private onSuccess;
-    private onFailure;
-    step(): StepDecision;
-}
-declare function getCurrentFiber(): RuntimeFiber<any, any, any> | null;
-declare function withCurrentFiber<T>(fiber: RuntimeFiber<any, any, any>, f: () => T): T;
-
-type ScopeId = number;
-type CloseOptions = {
-    awaitChildren?: boolean;
-};
-declare class Scope<R> {
-    private readonly runtime;
-    readonly id: ScopeId;
-    private closed;
-    private readonly children;
-    private readonly subScopes;
-    private readonly finalizers;
-    constructor(runtime: Runtime<R>);
-    /** Acceso al env del runtime (conserva tu modelo actual) */
-    private get env();
-    /** registra un finalizer (LIFO) */
-    addFinalizer(f: (exit: Exit<any, any>) => Async<R, any, any>): void;
-    /** crea un sub scope (mismo runtime) */
-    subScope(): Scope<R>;
-    /** fork en este scope */
-    fork<E, A>(eff: Async<R, E, A>): Fiber<E | Interrupted, A>;
-    /** close fire-and-forget (no bloquea) */
-    close(exit?: Exit<any, any>): void;
-    closeAsync(exit?: Exit<any, any>, options?: CloseOptions): Async<R, never, void>;
-}
-/**
- * Ejecuta una función dentro de un scope estructurado (sync).
- * NOTA: En sync no tenés env real; por eso recibimos Runtime explícito.
- */
-declare function withScope<R, A>(runtime: Runtime<R>, body: (scope: Scope<R>) => A): A;
-/**
- * Versión async: crea scope, corre el efecto, cierra el scope con el Exit.
- */
-declare function withScopeAsync<R, E, A>(runtime: Runtime<R>, use: (scope: Scope<R>) => Async<R, E, A>): Async<R, E | Interrupted, A>;
-
-type Async<R, E, A> = {
-    _tag: "Succeed";
-    value: A;
-} | {
-    _tag: "Fail";
-    error: E;
-} | {
-    _tag: "Sync";
-    thunk: (env: R) => A;
-} | {
-    _tag: "Async";
-    register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler;
-} | {
-    _tag: "FlatMap";
-    first: Async<R, E, any>;
-    andThen: (a: any) => Async<R, E, A>;
-} | {
-    _tag: "Fold";
-    first: Async<R, E, any>;
-    onFailure: (e: any) => Async<R, E, A>;
-    onSuccess: (a: any) => Async<R, E, A>;
-};
-declare function asyncFold<R, E, A, B>(fa: Async<R, E, A>, onFailure: (e: E) => Async<R, E, B>, onSuccess: (a: A) => Async<R, E, B>): Async<R, E, B>;
-declare function asyncCatchAll<R, E, A, R2, E2, B>(fa: Async<R, E, A>, handler: (e: E) => Async<R2, E2, B>): Async<R & R2, E2, A | B>;
-declare function asyncMapError<R, E, E2, A>(fa: Async<R, E, A>, f: (e: E) => E2): Async<R, E2, A>;
-declare const unit: <R>() => Async<R, never, void>;
-declare const asyncSucceed: <A>(value: A) => Async<unknown, never, A>;
-declare const asyncFail: <E>(error: E) => Async<unknown, E, never>;
-declare const asyncSync: <R, A>(thunk: (env: R) => A) => Async<R, unknown, A>;
-declare const asyncTotal: <A>(thunk: () => A) => Async<unknown, unknown, A>;
-declare const async: <R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler) => Async<R, E, A>;
-declare function asyncMap<R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => B): Async<R, E, B>;
-declare function asyncFlatMap<R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => Async<R, E, B>): Async<R, E, B>;
-declare function acquireRelease<R, E, A>(acquire: Async<R, E, A>, release: (res: A, exit: Exit<E, any>) => Async<R, any, any>, scope: Scope<R>): Async<R, E, A>;
-declare function asyncInterruptible<R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler): Async<R, E, A>;
-type AsyncWithPromise<R, E, A> = Async<R, E, A> & {
-    toPromise: (env: R) => Promise<A>;
-    unsafeRunPromise: () => Promise<A>;
-};
-declare const withAsyncPromise: <R, E, A>(run: (eff: Async<R, E, A>, env: R) => Promise<A>) => (eff: Async<R, E, A>) => AsyncWithPromise<R, E, A>;
-declare const mapAsync: <R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => B) => Async<R, E, B>;
-declare const mapTryAsync: <R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => B) => Async<R, E, B>;
-
-type None = {
-    readonly _tag: "None";
-};
-type Some<A> = {
-    readonly _tag: "Some";
-    readonly value: A;
-};
-type Option<A> = None | Some<A>;
-declare const none: Option<never>;
-declare const some: <A>(value: A) => Option<A>;
-
-type Exit<E, A> = {
-    readonly _tag: "Success";
-    readonly value: A;
-} | {
-    readonly _tag: "Failure";
-    readonly error: E;
-};
-type ZIO<R, E, A> = Async<R, E, A>;
-declare const succeed: <A>(value: A) => ZIO<unknown, never, A>;
-declare const fail: <E>(error: E) => ZIO<unknown, E, never>;
-declare const sync: <R, A>(thunk: (env: R) => A) => ZIO<R, unknown, A>;
-declare const map: <R, E, A, B>(fa: ZIO<R, E, A>, f: (a: A) => B) => Async<R, E, B>;
-declare const flatMap: <R, E, A, R2, E2, B>(fa: ZIO<R, E, A>, f: (a: A) => ZIO<R2, E2, B>) => ZIO<R & R2, E | E2, B>;
-declare const mapError: <R, E, E2, A>(fa: ZIO<R, E, A>, f: (e: E) => E2) => any;
-declare const catchAll: <R, E, A, R2, E2, B>(fa: ZIO<R, E, A>, handler: (e: E) => ZIO<R2, E2, B>) => ZIO<R & R2, E2, A | B>;
-declare function orElseOptional<R, E, A, R2, A2>(fa: ZIO<R, Option<E>, A>, that: () => ZIO<R2, Option<E>, A2>): ZIO<R & R2, Option<E>, A | A2>;
-declare const end: <E>() => ZIO<unknown, Option<E>, never>;
-
-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 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>;
-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: Async<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 FiberId as $, type Async as A, mapTryAsync as B, type Some as C, none as D, type Exit as E, type Fiber as F, some as G, type Canceler as H, type Interrupted as I, type CancelToken as J, makeCancelToken as K, linkAbortController as L, from as M, type None as N, type Option as O, type BrassError as P, fork as Q, Runtime as R, Scope as S, unsafeRunAsync as T, toPromise as U, fromPromise as V, fromCallback as W, tryPromiseAbortable as X, fromPromiseAbortable as Y, type ZStream as Z, getCurrentRuntime as _, type ZIO as a, type FiberStatus as a0, RuntimeFiber as a1, getCurrentFiber as a2, withCurrentFiber as a3, type ScopeId as a4, withScope as a5, withScopeAsync as a6, type Task as a7, Scheduler as a8, globalScheduler as a9, streamFromReadableStream as aA, type Empty as aa, type Emit as ab, type Concat as ac, type Flatten as ad, type FromPull as ae, type Merge as af, type Scoped as ag, type Normalize as ah, widenOpt as ai, fromPull as aj, unwrapScoped as ak, managedStream as al, mergeStream as am, emptyStream as an, emitStream as ao, concatStream as ap, flattenStream as aq, merge as ar, uncons as as, assertNever as at, mapStream as au, rangeStream as av, zip as aw, foreachStream as ax, fromArray as ay, collectStream as az, sync as b, flatMap as c, mapError as d, catchAll as e, fail as f, end as g, asyncFold as h, asyncCatchAll as i, asyncMapError as j, asyncSucceed as k, asyncFail as l, map as m, asyncSync as n, orElseOptional as o, asyncTotal as p, async as q, asyncMap as r, succeed as s, asyncFlatMap as t, unit as u, acquireRelease as v, asyncInterruptible as w, type AsyncWithPromise as x, withAsyncPromise as y, mapAsync as z };