brass-runtime 1.11.0 → 1.12.0

package/dist/{stream-hTHRKq88.d.mts → stream-DVfZWtYZ.d.mts}

@@ -63,17 +63,64 @@ type RuntimeEvent = {
     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 RuntimeEmitContext = {
-    fiberId?: number;
+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[];
+}
 
-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.
@@ -83,48 +130,41 @@ declare class Runtime<R> {
     readonly scheduler: Scheduler;
     readonly hooks: RuntimeHooks;
     readonly forkPolicy: {
-        initChild(fiber: RuntimeFiber<any, any, any> & any, parent?: (RuntimeFiber<any, any, any> & any) | null): void;
+        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;
     });
-    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>;
+    /** 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>;
 /**
- * ---------------------------------------------------------------------------
- * Helpers existentes (los dejo igual) + wrappers que usan Runtime por debajo
- * ---------------------------------------------------------------------------
+ * Create an Async from an abortable Promise.
+ * Type params are ordered as `<E, A, R = unknown>` to match call-sites.
  */
-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>;
+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;
@@ -145,17 +185,16 @@ type FiberContext = {
 };
 
 type FiberId = number;
+type FiberStatus = "Running" | "Done" | "Interrupted";
 type Interrupted = {
-    readonly _tag: "Interrupted";
+    readonly _tag: "Interrupt";
 };
-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 join: (cb: (exit: Exit<E, A>) => void) => void;
     readonly interrupt: () => void;
-    readonly addFinalizer: (f: (exit: Exit<E | Interrupted, A>) => void) => void;
+    readonly addFinalizer: (f: (exit: Exit<E, A>) => void) => void;
 };
 declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
     readonly id: FiberId;
@@ -176,18 +215,25 @@ declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
     constructor(runtime: Runtime<R>, effect: Async<R, E, A>);
     private get env();
     private get scheduler();
-    addFinalizer(f: (exit: Exit<E | Interrupted, A>) => void): void;
+    private emit;
+    addFinalizer(f: (exit: Exit<E, A>) => void): void;
     status(): FiberStatus;
-    join(cb: (exit: Exit<E | Interrupted, A>) => void): void;
+    join(cb: (exit: Exit<E, A>) => void): void;
     interrupt(): void;
     schedule(tag?: string): void;
     private runFinalizersOnce;
     private notify;
     private onSuccess;
     private onFailure;
-    step(): StepDecision;
+    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;
@@ -196,55 +242,59 @@ type CloseOptions = {
 };
 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>);
-    /** Acceso al env del runtime (conserva tu modelo actual) */
-    private get env();
+    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 | Interrupted, A>;
+    /** ✅ 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>, options?: CloseOptions): Async<R, never, void>;
+    closeAsync(exit?: Exit<any, any>, opts?: CloseOptions): Async<R, any, 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>;
+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> = {
-    _tag: "Succeed";
-    value: A;
+    readonly _tag: "Succeed";
+    readonly value: A;
 } | {
-    _tag: "Fail";
-    error: E;
+    readonly _tag: "Fail";
+    readonly error: E;
+} | {
+    readonly _tag: "Sync";
+    readonly thunk: (env: R) => A;
 } | {
-    _tag: "Sync";
-    thunk: (env: R) => A;
+    readonly _tag: "Async";
+    readonly register: (env: R, cb: (exit: Exit<E, A>) => void) => void | (() => void);
 } | {
-    _tag: "Async";
-    register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler;
+    readonly _tag: "FlatMap";
+    readonly first: Async<R, E, any>;
+    readonly andThen: (a: any) => Async<R, E, A>;
 } | {
-    _tag: "FlatMap";
-    first: Async<R, E, any>;
-    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>;
 } | {
-    _tag: "Fold";
-    first: Async<R, E, any>;
-    onFailure: (e: any) => Async<R, E, A>;
-    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>;
@@ -278,12 +328,30 @@ 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> = {
-    readonly _tag: "Success";
-    readonly value: A;
+    _tag: "Success";
+    value: A;
 } | {
-    readonly _tag: "Failure";
-    readonly error: E;
+    _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>;
@@ -327,12 +395,19 @@ type Scoped<R, E, A> = {
     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 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: Async<R, E, {
+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>;
@@ -352,4 +427,4 @@ 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 };
+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 };