brass-runtime 1.12.0 → 1.13.2

package/dist/stream-DVfZWtYZ.d.ts

@@ -1,430 +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>;
-};
-type RuntimeEmitContext = {
-    fiberId?: number;
-    scopeId?: number;
-    traceId?: string;
-    spanId?: string;
-};
-interface RuntimeHooks {
-    emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
-}
-type RuntimeEventRecord = RuntimeEvent & RuntimeEmitContext & {
-    seq: number;
-    wallTs: number;
-    ts: number;
-};
-
-type FiberRunState = "Queued" | "Running" | "Suspended" | "Done";
-type FiberInfo = {
-    fiberId: number;
-    parentFiberId?: number;
-    name?: string;
-    runState: FiberRunState;
-    status: "Running" | "Done" | "Interrupted";
-    createdAt: number;
-    lastActiveAt: number;
-    scopeId?: number;
-    traceId?: string;
-    spanId?: string;
-    awaiting?: {
-        reason: string;
-        detail?: string;
-    };
-    lastEnd?: {
-        status: string;
-        error?: string;
-    };
-};
-type ScopeInfo = {
-    scopeId: number;
-    parentScopeId?: number;
-    ownerFiberId?: number;
-    openAt: number;
-    closedAt?: number;
-    finalizers: Array<{
-        id: number;
-        label?: string;
-        status: "added" | "running" | "done";
-    }>;
-};
-declare class RuntimeRegistry implements RuntimeHooks {
-    fibers: Map<number, FiberInfo>;
-    scopes: Map<number, ScopeInfo>;
-    private seq;
-    private recent;
-    private recentCap;
-    emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
-    getRecentEvents(): RuntimeEventRecord[];
-}
-
-/**
- * --- 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, scopeId?: number): void;
-    };
-    registry?: RuntimeRegistry;
-    constructor(args: {
-        env: R;
-        scheduler?: Scheduler;
-        hooks?: RuntimeHooks;
-    });
-    /** Deriva un runtime con env extendido (estilo provide/locally) */
-    provide<R2>(env: R2): Runtime<R & R2>;
-    emit(ev: RuntimeEvent): void;
-    /**
-     * ✅ CAMBIO: fork(effect, scopeId?) y pasa scopeId a forkPolicy
-     */
-    fork<E, A>(effect: Async<R, E, A>, scopeId?: number): Fiber<E, A>;
-    unsafeRunAsync<E, A>(effect: Async<R, E, A>, cb: (exit: Exit<E, A>) => void): void;
-    toPromise<E, A>(effect: Async<R, E, A>): Promise<A>;
-    unsafeRun<E, A>(effect: Async<R, E, A>): void;
-    delay<E, A>(ms: number, eff: Async<R, E, A>): Async<R, E, A>;
-    static make<R>(env: R, scheduler?: Scheduler): Runtime<R>;
-    /** Convenience logger: emits a RuntimeEvent of type "log". */
-    log(level: "debug" | "info" | "warn" | "error", message: string, fields?: Record<string, unknown>): void;
-}
-/** Create a runtime from `env` and fork the given effect. */
-declare function fork<R, E, A>(effect: Async<R, E, A>, env?: R): Fiber<E, A>;
-/** Run an effect with `env` and invoke `cb` with the final Exit. */
-declare function unsafeRunAsync<R, E, A>(effect: Async<R, E, A>, env: R | undefined, cb: (exit: Exit<E, A>) => void): void;
-/** Run an effect with `env` and return a Promise of its success value. */
-declare function toPromise<R, E, A>(effect: Async<R, E, A>, env?: R): Promise<A>;
-/**
- * Create an Async from an abortable Promise.
- * Type params are ordered as `<E, A, R = unknown>` to match call-sites.
- */
-declare function fromPromiseAbortable<E, A, R = unknown>(make: (signal: AbortSignal, env: R) => Promise<A>, onReject: (u: unknown) => E): Async<R, E, A>;
-declare function unsafeRunFoldWithEnv<R, E, A>(eff: Async<R, E, A>, env: R, onFailure: (cause: Cause<E>) => void, onSuccess: (value: A) => void): void;
-
-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 FiberStatus = "Running" | "Done" | "Interrupted";
-type Interrupted = {
-    readonly _tag: "Interrupt";
-};
-type Fiber<E, A> = {
-    readonly id: FiberId;
-    readonly status: () => FiberStatus;
-    readonly join: (cb: (exit: Exit<E, A>) => void) => void;
-    readonly interrupt: () => void;
-    readonly addFinalizer: (f: (exit: Exit<E, 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();
-    private emit;
-    addFinalizer(f: (exit: Exit<E, A>) => void): void;
-    status(): FiberStatus;
-    join(cb: (exit: Exit<E, A>) => void): void;
-    interrupt(): void;
-    schedule(tag?: string): void;
-    private runFinalizersOnce;
-    private notify;
-    private onSuccess;
-    private onFailure;
-    private budget;
-    private step;
-}
-declare function getCurrentFiber(): RuntimeFiber<any, any, any> | null;
-/**
- * Unsafe (but convenient) access to the runtime that is currently executing.
- * Throws if called outside of a running fiber.
- */
-declare function unsafeGetCurrentRuntime<R>(): Runtime<R>;
-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;
-    private readonly parentScopeId?;
-    readonly id: ScopeId;
-    private closed;
-    private readonly children;
-    private readonly subScopes;
-    private readonly finalizers;
-    constructor(runtime: Runtime<R>, parentScopeId?: ScopeId | undefined);
-    /** 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, A>;
-    /** close fire-and-forget (no bloquea) */
-    close(exit?: Exit<any, any>): void;
-    closeAsync(exit?: Exit<any, any>, opts?: CloseOptions): Async<R, any, void>;
-}
-declare function withScopeAsync<R, E, A>(runtime: Runtime<R>, f: (scope: Scope<R>) => Async<R, E, A>): Async<R, E, A>;
-
-declare function withScope<R>(runtime: Runtime<R>, f: (scope: Scope<R>) => void): Async<R, never, void>;
-declare function withScope<R, E, A>(runtime: Runtime<R>, f: (scope: Scope<R>) => Async<R, E, A>): Async<R, E, A>;
-
-type Async<R, E, A> = {
-    readonly _tag: "Succeed";
-    readonly value: A;
-} | {
-    readonly _tag: "Fail";
-    readonly error: E;
-} | {
-    readonly _tag: "Sync";
-    readonly thunk: (env: R) => A;
-} | {
-    readonly _tag: "Async";
-    readonly register: (env: R, cb: (exit: Exit<E, A>) => void) => void | (() => void);
-} | {
-    readonly _tag: "FlatMap";
-    readonly first: Async<R, E, any>;
-    readonly andThen: (a: any) => Async<R, E, A>;
-} | {
-    readonly _tag: "Fold";
-    readonly first: Async<R, E, any>;
-    readonly onFailure: (e: any) => Async<R, E, A>;
-    readonly onSuccess: (a: any) => Async<R, E, A>;
-} | {
-    readonly _tag: "Fork";
-    readonly effect: Async<R, E, any>;
-    readonly scopeId?: number;
-};
-declare const Async: {
-    succeed: <R, E, A>(value: A) => Async<R, E, A>;
-    fail: <R, E, A = never>(error: E) => Async<R, E, A>;
-    sync: <R, E, A>(thunk: (env: R) => A) => Async<R, E, A>;
-    async: <R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | (() => void)) => 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 Cause<E> = {
-    readonly _tag: "Fail";
-    readonly error: E;
-} | {
-    readonly _tag: "Interrupt";
-} | {
-    readonly _tag: "Die";
-    readonly defect: unknown;
-};
-declare const Cause: {
-    fail: <E>(error: E) => Cause<E>;
-    interrupt: <E = never>() => Cause<E>;
-    die: <E = never>(defect: unknown) => Cause<E>;
-};
-type Exit<E, A> = {
-    _tag: "Success";
-    value: A;
-} | {
-    _tag: "Failure";
-    cause: Cause<E>;
-};
-declare const Exit: {
-    succeed: <E = never, A = never>(value: A) => Exit<E, A>;
-    failCause: <E = never, A = never>(cause: Cause<E>) => Exit<E, A>;
-};
-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 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 { unsafeGetCurrentRuntime as $, Async as A, mapTryAsync as B, Cause as C, type Some as D, Exit as E, type Fiber as F, none as G, some as H, type Canceler as I, type CancelToken as J, makeCancelToken as K, linkAbortController as L, fork as M, type None as N, type Option as O, unsafeRunAsync as P, toPromise as Q, Runtime as R, Scope as S, fromPromiseAbortable as T, unsafeRunFoldWithEnv as U, type FiberId as V, type FiberStatus as W, type Interrupted as X, RuntimeFiber as Y, type ZStream as Z, getCurrentFiber as _, type ZIO as a, withCurrentFiber as a0, type ScopeId as a1, withScopeAsync as a2, withScope as a3, type Task as a4, Scheduler as a5, globalScheduler as a6, type Empty as a7, type Emit as a8, type Concat as a9, type Flatten as aa, type FromPull as ab, type Merge as ac, type Scoped as ad, type Managed as ae, type Normalize as af, widenOpt as ag, fromPull as ah, unwrapScoped as ai, managedStream as aj, mergeStream as ak, emptyStream as al, emitStream as am, concatStream as an, flattenStream as ao, merge as ap, uncons as aq, assertNever as ar, mapStream as as, rangeStream as at, zip as au, foreachStream as av, fromArray as aw, collectStream as ax, streamFromReadableStream as ay, 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 };