brass-runtime 1.14.0 → 1.16.0

package/dist/{effect-DM56H743.d.ts → effect-CGNl5Rqp.d.ts}

@@ -92,6 +92,7 @@ declare function makeBoundedRingBuffer<T>(initialCapacity: number, maxCapacity?:
 
 type Task = () => void;
 type ScheduleResult = "accepted" | "dropped";
+type SchedulerLaneMode = "fair" | "single";
 type SchedulerEngine = "ts" | "wasm";
 type LaneStatsData = {
     key: string;
@@ -116,6 +117,8 @@ type SchedulerStatsData = {
 type SchedulerStats = EngineStats<SchedulerStatsData>;
 type SchedulerOptions = RingBufferOptions & {
     engine?: SchedulerEngine;
+    /** fair keeps per-lane round-robin scheduling; single uses one direct TS queue for maximum throughput. */
+    laneMode?: SchedulerLaneMode;
     initialCapacity?: number;
     maxCapacity?: number;
     flushBudget?: number;
@@ -138,6 +141,7 @@ declare function inferCallerLaneFromStack(stack?: string | undefined, fallback?:
 declare class Scheduler {
     private readonly engine;
     private readonly js?;
+    private readonly jsSingle?;
     private readonly wasm?;
     private readonly flushBudget;
     private readonly microThreshold;
@@ -146,6 +150,7 @@ declare class Scheduler {
     private readonly maxLanes;
     private readonly fallbackUsed;
     private readonly boundFlush;
+    private shiftedTag;
     constructor(options?: SchedulerOptions);
     schedule(task: Task, tag?: string): ScheduleResult;
     scheduleBatch(tasks: Array<{
@@ -157,10 +162,13 @@ declare class Scheduler {
     private scheduleBatchWasm;
     private getOrCreateLane;
     private createLane;
+    private scheduleJsSingle;
+    private scheduleBatchJsSingle;
     private scheduleJs;
     private requestFlush;
     private flush;
     private flushWasm;
+    private flushJsSingle;
     private shiftFromNextLane;
     private flushJs;
 }
@@ -193,17 +201,73 @@ type RuntimeEvent = {
     scopeId: number;
     status: "success" | "failure" | "interrupted";
     error?: unknown;
+} | {
+    type: "supervisor.child.start";
+    supervisorId: number;
+    childId: number;
+    name?: string;
+    restartCount: number;
+} | {
+    type: "supervisor.child.end";
+    supervisorId: number;
+    childId: number;
+    name?: string;
+    status: "success" | "failure" | "interrupted";
+    error?: unknown;
+} | {
+    type: "supervisor.child.restart";
+    supervisorId: number;
+    childId: number;
+    name?: string;
+    restartCount: number;
+    delayMs: number;
+    reason?: string;
+} | {
+    type: "supervisor.child.escalate";
+    supervisorId: number;
+    childId: number;
+    name?: string;
+    reason?: string;
+    error?: unknown;
+} | {
+    type: "supervisor.shutdown";
+    supervisorId: number;
 } | {
     type: "log";
     level: "debug" | "info" | "warn" | "error";
     message: string;
     fields?: Record<string, unknown>;
+} | {
+    type: "span.start";
+    name: string;
+    attributes?: Record<string, unknown>;
+    links?: RuntimeSpanLink[];
+} | {
+    type: "span.event";
+    name: string;
+    attributes?: Record<string, unknown>;
+} | {
+    type: "span.end";
+    name?: string;
+    status: "success" | "failure" | "interrupted";
+    error?: unknown;
+    attributes?: Record<string, unknown>;
 };
 type RuntimeEmitContext = {
     fiberId?: number;
     scopeId?: number;
     traceId?: string;
     spanId?: string;
+    parentSpanId?: string;
+    traceState?: string;
+    baggage?: Record<string, string>;
+    sampled?: boolean;
+};
+type RuntimeSpanLink = {
+    traceId: string;
+    spanId: string;
+    traceState?: string;
+    attributes?: Record<string, string | number | boolean>;
 };
 interface RuntimeHooks {
     emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
@@ -212,6 +276,13 @@ type RuntimeEventRecord = RuntimeEvent & RuntimeEmitContext & {
     seq: number;
     wallTs: number;
     ts: number;
+    /**
+     * The ambient fiber/scope from RuntimeEmitContext. Event payload fields
+     * keep priority in the merged record, so these preserve the context when
+     * an event also has a fiberId/scopeId of its own.
+     */
+    contextFiberId?: number;
+    contextScopeId?: number;
     /**
      * Convenience fields for generic event consumers. They are present for
      * log events and absent for fiber/scope events, but keeping them optional
@@ -222,6 +293,8 @@ type RuntimeEventRecord = RuntimeEvent & RuntimeEmitContext & {
     message?: string;
     fields?: Record<string, unknown>;
 };
+declare function makeRuntimeEventRecord(ev: RuntimeEvent, ctx: RuntimeEmitContext, seq: number): RuntimeEventRecord;
+declare function runtimeEventRecordContext(record: RuntimeEventRecord): RuntimeEmitContext;
 
 type FiberRunState = "Queued" | "Running" | "Suspended" | "Done";
 type FiberInfo = {
@@ -528,9 +601,36 @@ interface WasmBridge {
 }
 type Joiner<E, A> = (exit: Exit<E, A>) => void;
 
+type ReadyQueueScheduleKind = "micro" | "macro" | "none" | "dropped";
+type FiberReadyQueueStats = {
+    readonly engine: "ts" | "wasm";
+    readonly fallbackUsed: boolean;
+    readonly data: unknown;
+};
+interface FiberReadyQueue {
+    readonly engine: "ts" | "wasm";
+    enqueue(fiberId: FiberId$1, tag: string): ReadyQueueScheduleKind;
+    beginFlush(): number;
+    shift(): FiberId$1 | undefined;
+    endFlush(ran: number): ReadyQueueScheduleKind;
+    len(): number;
+    clear(): void;
+    stats(): FiberReadyQueueStats;
+}
+type FiberReadyQueueOptions = {
+    readonly engine?: "ts" | "wasm";
+    readonly flushBudget?: number;
+    readonly microThreshold?: number;
+    readonly laneCapacity?: number;
+    readonly laneBudget?: number;
+    readonly maxLanes?: number;
+};
+declare function makeFiberReadyQueue(options?: FiberReadyQueueOptions): FiberReadyQueue;
+
 type WasmFiberEngineOptions = {
     readonly bridge?: WasmBridge;
     readonly modulePath?: string;
+    readonly readyQueue?: Omit<FiberReadyQueueOptions, "engine">;
 };
 declare class WasmFiberEngine<R> implements FiberEngine<R> {
     private readonly runtime;
@@ -726,11 +826,17 @@ type ContextNode = {
     parent: ContextNode | null;
     patch: Record<string, JSONValue>;
 };
+declare const emptyContext: ContextNode;
+declare function ctxExtend(parent: ContextNode, patch: Record<string, JSONValue>): ContextNode;
+declare function ctxToObject(ctx: ContextNode): Record<string, JSONValue>;
+type Baggage = Record<string, string>;
 type TraceContext = {
     traceId: string;
     spanId: string;
     parentSpanId?: string;
     sampled?: boolean;
+    traceState?: string;
+    baggage?: Baggage;
 };
 type FiberContext = {
     log: ContextNode;
@@ -878,16 +984,16 @@ type Async<R, E, A> = {
     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 first: Async<any, any, any>;
+    readonly andThen: (a: any) => Async<any, any, 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 first: Async<any, any, any>;
+    readonly onFailure: (e: any) => Async<any, any, A>;
+    readonly onSuccess: (a: any) => Async<any, any, A>;
 } | {
     readonly _tag: "Fork";
-    readonly effect: Async<R, E, any>;
+    readonly effect: Async<any, any, any>;
     readonly scopeId?: number;
 };
 declare const Async: {
@@ -896,7 +1002,7 @@ declare const Async: {
     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 asyncFold<R, E, A, RFail, EFail, B, RSuccess, ESuccess, C>(fa: Async<R, E, A>, onFailure: (e: E) => Async<RFail, EFail, B>, onSuccess: (a: A) => Async<RSuccess, ESuccess, C>): Async<R & RFail & RSuccess, EFail | ESuccess, B | C>;
 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>;
@@ -904,9 +1010,10 @@ 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 const asyncEffect: <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 asyncFlatMap<R, E, A, R2, E2, B>(fa: Async<R, E, A>, f: (a: A) => Async<R2, E2, B>): Async<R & R2, E | E2, 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> & {
@@ -959,9 +1066,9 @@ 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 mapError: <R, E, E2, A>(fa: ZIO<R, E, A>, f: (e: E) => E2) => ZIO<R, E2, A>;
 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>;
 
-export { type Interrupted as $, Async as A, DefaultHostExecutor as B, type CancelToken as C, type DbHostAction as D, Exit as E, type FiberEngine as F, type EngineKind as G, type EngineSelection as H, type EngineSelectionMode as I, type FiberEngineKind as J, type FlatMapRef as K, type FoldFailureRef as L, type FoldSuccessRef as M, type NodeId as N, type Option as O, type HostAction as P, type HostActionKind as Q, Runtime as R, Scope as S, type HostActionResult as T, type HostExecutionContext as U, type HostExecutor as V, type WasmEngineRuntime as W, HostRegistry as X, type HostRegistryStats as Y, type ZIO as Z, type HttpHostAction as _, type AsyncWithPromise as a, sanitizeLaneKey as a$, type Joiner as a0, type LaneStatsData as a1, type None as a2, NoopHooks as a3, ProgramBuilder as a4, type ProgramPatch as a5, PushStatus as a6, type QueueHostAction as a7, RingBuffer as a8, type RingBufferEngine as a9, asyncSucceed as aA, asyncSync as aB, asyncTotal as aC, catchAll as aD, end as aE, engineStats as aF, fail as aG, flatMap as aH, fork as aI, fromPromiseAbortable as aJ, getBenchmarkBudget as aK, getCurrentFiber as aL, globalScheduler as aM, inferCallerLaneFromStack as aN, laneTag as aO, linkAbortController as aP, makeBoundedRingBuffer as aQ, makeCancelToken as aR, map as aS, mapAsync as aT, mapError as aU, mapTryAsync as aV, none as aW, orElseOptional as aX, resetAbortablePromiseStats as aY, runtimeCapabilities as aZ, runtimeForCaller as a_, type RingBufferStatsData as aa, type RuntimeCapabilities as ab, type RuntimeEngineMode as ac, type RuntimeOptions as ad, type ScheduleResult as ae, Scheduler as af, type SchedulerEngine as ag, type SchedulerOptions as ah, type SchedulerStats as ai, type SchedulerStatsData as aj, type ScopeId as ak, type Some as al, type SyncRef as am, type Task as an, WasmFiberEngine as ao, type WasmFiberEngineOptions as ap, abortablePromiseStats as aq, acquireRelease as ar, async as as, asyncCatchAll as at, asyncFail as au, asyncFlatMap as av, asyncFold as aw, asyncInterruptible as ax, asyncMap as ay, asyncMapError as az, RuntimeFiber as b, selectedEngineStats as b0, setBenchmarkBudget as b1, some as b2, succeed as b3, sync as b4, toPromise as b5, toPromiseByCaller as b6, unit as b7, unsafeGetCurrentRuntime as b8, unsafeRunAsync as b9, unsafeRunFoldWithEnv as ba, withAsyncPromise as bb, withCurrentFiber as bc, withScope as bd, withScopeAsync as be, type FiberEngineStats as c, type Fiber as d, type FiberId as e, type FiberStatus as f, type RuntimeEvent as g, type WasmBridge as h, type OpcodeProgram as i, type FiberId$1 as j, type EngineEvent as k, type RefId as l, type OpcodeNode as m, type RingBufferOptions as n, type EngineStats as o, type AbortablePromiseFinish as p, type AbortablePromiseLabelStats as q, type AbortablePromiseOptions as r, type AbortablePromiseOutcome as s, type AbortablePromiseStats as t, type AsyncRegisterRef as u, type RingLike as v, type Canceler as w, Cause as x, type CustomHostAction as y, type DecodeRef as z };
+export { type FiberInfo as $, Async as A, type Baggage as B, type AsyncWithPromise as C, type RingLike as D, Exit as E, type FiberEngine as F, type CancelToken as G, type Canceler as H, Cause as I, type JSONValue as J, type ContextNode as K, type CustomHostAction as L, type DbHostAction as M, type NodeId as N, type Option as O, type DecodeRef as P, DefaultHostExecutor as Q, type RuntimeHooks as R, Scope as S, type TraceContext as T, type EngineKind as U, type EngineSelection as V, type WasmEngineRuntime as W, type EngineSelectionMode as X, type FiberContext as Y, type ZIO as Z, type FiberEngineKind as _, type RingBufferOptions as a, fail as a$, type FiberReadyQueue as a0, type FiberReadyQueueOptions as a1, type FiberReadyQueueStats as a2, type FiberRunState as a3, type FlatMapRef as a4, type FoldFailureRef as a5, type FoldSuccessRef as a6, type HostAction as a7, type HostActionKind as a8, type HostActionResult as a9, type SchedulerStatsData as aA, type ScopeId as aB, type ScopeInfo as aC, type Some as aD, type SyncRef as aE, type Task as aF, WasmFiberEngine as aG, type WasmFiberEngineOptions as aH, abortablePromiseStats as aI, acquireRelease as aJ, asyncEffect as aK, asyncCatchAll as aL, asyncFail as aM, asyncFlatMap as aN, asyncFold as aO, asyncInterruptible as aP, asyncMap as aQ, asyncMapError as aR, asyncSucceed as aS, asyncSync as aT, asyncTotal as aU, catchAll as aV, ctxExtend as aW, ctxToObject as aX, emptyContext as aY, end as aZ, engineStats as a_, type HostExecutionContext as aa, type HostExecutor as ab, HostRegistry as ac, type HostRegistryStats as ad, type HttpHostAction as ae, type Interrupted as af, type Joiner as ag, type LaneStatsData as ah, type None as ai, NoopHooks as aj, ProgramBuilder as ak, type ProgramPatch as al, PushStatus as am, type QueueHostAction as an, type ReadyQueueScheduleKind as ao, RingBuffer as ap, type RingBufferEngine as aq, type RingBufferStatsData as ar, type RuntimeCapabilities as as, type RuntimeEngineMode as at, type ScheduleResult as au, Scheduler as av, type SchedulerEngine as aw, type SchedulerLaneMode as ax, type SchedulerOptions as ay, type SchedulerStats as az, type RuntimeEvent as b, flatMap as b0, fork as b1, fromPromiseAbortable as b2, getBenchmarkBudget as b3, getCurrentFiber as b4, globalScheduler as b5, inferCallerLaneFromStack as b6, laneTag as b7, linkAbortController as b8, makeBoundedRingBuffer as b9, withCurrentFiber as bA, withScope as bB, withScopeAsync as bC, makeCancelToken as ba, makeFiberReadyQueue as bb, makeRuntimeEventRecord as bc, map as bd, mapAsync as be, mapError as bf, mapTryAsync as bg, none as bh, orElseOptional as bi, resetAbortablePromiseStats as bj, runtimeCapabilities as bk, runtimeEventRecordContext as bl, runtimeForCaller as bm, sanitizeLaneKey as bn, selectedEngineStats as bo, setBenchmarkBudget as bp, some as bq, succeed as br, sync as bs, toPromise as bt, toPromiseByCaller as bu, unit as bv, unsafeGetCurrentRuntime as bw, unsafeRunAsync as bx, unsafeRunFoldWithEnv as by, withAsyncPromise as bz, type RuntimeEmitContext as c, type RuntimeEventRecord as d, type RuntimeSpanLink as e, Runtime as f, RuntimeRegistry as g, type RuntimeOptions as h, RuntimeFiber as i, type FiberEngineStats as j, type Fiber as k, type FiberId as l, type FiberStatus as m, type WasmBridge as n, type OpcodeProgram as o, type FiberId$1 as p, type EngineEvent as q, type RefId as r, type OpcodeNode as s, type EngineStats as t, type AbortablePromiseFinish as u, type AbortablePromiseLabelStats as v, type AbortablePromiseOptions as w, type AbortablePromiseOutcome as x, type AbortablePromiseStats as y, type AsyncRegisterRef as z };

package/dist/effectRunner-3ZHAD3LE.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkIJT6RRQ5cjs = require('./chunk-IJT6RRQ5.cjs');
+require('./chunk-DJQ7OMMB.cjs');
+require('./chunk-OBGZSXTJ.cjs');
+
+
+exports.registerHttpEffect = _chunkIJT6RRQ5cjs.registerHttpEffect;

package/dist/effectRunner-A4CHJXJI.js

@@ -0,0 +1,8 @@
+import {
+  registerHttpEffect
+} from "./chunk-H55LI6WY.js";
+import "./chunk-PNVFW245.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  registerHttpEffect
+};

package/dist/effectRunner-OPUF6QRN.mjs

@@ -0,0 +1,8 @@
+import {
+  registerHttpEffect
+} from "./chunk-K2T3DV26.mjs";
+import "./chunk-NOYZIMUJ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  registerHttpEffect
+};