brass-runtime 1.15.0 → 1.16.1

package/dist/{effect-CMOQKX8y.d.ts → effect-DIUHZ9IN.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,83 @@ 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: "schedule.decision";
+    name?: string;
+    attempt: number;
+    elapsedMs: number;
+    delayMs: number;
+    continue: boolean;
+    reason?: string;
+    input?: unknown;
+    output?: unknown;
 } | {
     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 +286,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 +303,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 +611,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;
@@ -569,6 +679,7 @@ declare class WasmFiberEngine<R> implements FiberEngine<R> {
     private scheduleHostAction;
     private onTimerExpired;
     private resumeWithExit;
+    private completeCause;
     private resumeWithValue;
     private resumeWithError;
     private schedulerTag;
@@ -649,6 +760,7 @@ declare class Runtime<R> {
     shutdown(): Promise<void> | void;
     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>;
+    private tryRunNativeTopLevel;
     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>;
@@ -726,15 +838,22 @@ 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;
     trace: TraceContext | null;
+    fiberRefs?: Map<number, unknown>;
 };
 
 type FiberId = number;
@@ -764,6 +883,7 @@ declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
     private readonly stack;
     private readonly fiberFinalizers;
     private finalizersDrained;
+    private interruptibilityDepth;
     fiberContext: FiberContext;
     name?: string;
     scopeId?: number;
@@ -797,8 +917,15 @@ declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
     schedule(tag?: string): void;
     private runFinalizersOnce;
     private notify;
+    private isInterruptible;
+    private shouldInterruptNow;
+    private enterInterruptibility;
+    private restoreInterruptibility;
+    private fiberRefs;
+    private restoreFiberRef;
     private onSuccess;
     private onFailure;
+    private onCause;
     private budget;
     private step;
     /**
@@ -864,6 +991,8 @@ declare function withScopeAsync<R, E, A>(runtime: Runtime<R>, f: (scope: Scope<R
 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 InterruptibilityMode = "uninterruptible" | "interruptible";
+type RestoreInterruptibility = <R, E, A>(effect: Async<R, E, A>) => Async<R, E, A>;
 type Async<R, E, A> = {
     readonly _tag: "Succeed";
     readonly value: A;
@@ -889,12 +1018,29 @@ type Async<R, E, A> = {
     readonly _tag: "Fork";
     readonly effect: Async<any, any, any>;
     readonly scopeId?: number;
+} | {
+    readonly _tag: "Interruptibility";
+    readonly mode: InterruptibilityMode;
+    readonly effect: Async<any, any, A>;
+} | {
+    readonly _tag: "InterruptibilityMask";
+    readonly body: (restore: RestoreInterruptibility) => Async<any, any, A>;
+} | {
+    readonly _tag: "InterruptibilityRestore";
+    readonly depth: number;
+    readonly effect: Async<any, any, A>;
+} | {
+    readonly _tag: "FiberRefLocally";
+    readonly refId: number;
+    readonly value: unknown;
+    readonly effect: Async<any, any, A>;
 };
 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>;
+    interruptibility: <R, E, A>(mode: InterruptibilityMode, effect: Async<R, E, A>) => Async<R, E, A>;
 };
 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>;
@@ -929,6 +1075,12 @@ type Option<A> = None | Some<A>;
 declare const none: Option<never>;
 declare const some: <A>(value: A) => Option<A>;
 
+type CausePrettyOptions<E = unknown> = {
+    readonly renderError?: (error: E) => string;
+    readonly renderDefect?: (defect: unknown) => string;
+    readonly indent?: string;
+    readonly singleLine?: boolean;
+};
 type Cause<E> = {
     readonly _tag: "Fail";
     readonly error: E;
@@ -937,12 +1089,51 @@ type Cause<E> = {
 } | {
     readonly _tag: "Die";
     readonly defect: unknown;
+} | {
+    readonly _tag: "Then";
+    readonly left: Cause<E>;
+    readonly right: Cause<E>;
+} | {
+    readonly _tag: "Both";
+    readonly left: Cause<E>;
+    readonly right: Cause<E>;
 };
 declare const Cause: {
     fail: <E>(error: E) => Cause<E>;
     interrupt: <E = never>() => Cause<E>;
     die: <E = never>(defect: unknown) => Cause<E>;
+    then: <E, E2>(left: Cause<E>, right: Cause<E2>) => Cause<E | E2>;
+    both: <E, E2>(left: Cause<E>, right: Cause<E2>) => Cause<E | E2>;
+    isCause: typeof isCauseValue;
+    failures: typeof causeFailures;
+    defects: typeof causeDefects;
+    firstFailure: typeof firstCauseFailure;
+    firstDefect: typeof firstCauseDefect;
+    containsFailure: typeof causeContainsFailure;
+    containsDefect: typeof causeContainsDefect;
+    containsInterrupt: typeof causeContainsInterrupt;
+    isInterruptedOnly: typeof causeIsInterruptedOnly;
+    isFailureOnly: typeof causeIsFailureOnly;
+    squash: typeof squashCause;
+    toError: typeof causeToError;
+    pretty: typeof prettyCause;
+    format: typeof prettyCause;
 };
+declare function isCause(value: unknown): value is Cause<unknown>;
+declare function prettyCause<E>(cause: Cause<E>, options?: CausePrettyOptions<E>): string;
+declare const formatCause: typeof prettyCause;
+declare function isCauseValue(value: unknown): value is Cause<unknown>;
+declare function causeFailures<E>(cause: Cause<E>): readonly E[];
+declare function causeDefects<E>(cause: Cause<E>): readonly unknown[];
+declare function firstCauseFailure<E>(cause: Cause<E>): Option<E>;
+declare function firstCauseDefect<E>(cause: Cause<E>): Option<unknown>;
+declare function causeContainsFailure<E>(cause: Cause<E>): boolean;
+declare function causeContainsDefect<E>(cause: Cause<E>): boolean;
+declare function causeContainsInterrupt<E>(cause: Cause<E>): boolean;
+declare function causeIsInterruptedOnly<E>(cause: Cause<E>): boolean;
+declare function causeIsFailureOnly<E>(cause: Cause<E>): boolean;
+declare function squashCause<E>(cause: Cause<E>): unknown;
+declare function causeToError<E>(cause: Cause<E>): Error;
 type Exit<E, A> = {
     _tag: "Success";
     value: A;
@@ -962,7 +1153,10 @@ declare const map: <R, E, A, B>(fa: ZIO<R, E, A>, f: (a: A) => B) => Async<R, E,
 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) => 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 const uninterruptible: <R, E, A>(effect: ZIO<R, E, A>) => ZIO<R, E, A>;
+declare const interruptible: <R, E, A>(effect: ZIO<R, E, A>) => ZIO<R, E, A>;
+declare function uninterruptibleMask<R, E, A>(body: (restore: RestoreInterruptibility) => ZIO<R, E, A>): ZIO<R, E, A>;
 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 Joiner as $, Async as A, type EngineKind as B, type CancelToken as C, type DbHostAction as D, Exit as E, type FiberEngine as F, type EngineSelection as G, type EngineSelectionMode as H, type FiberEngineKind as I, type FlatMapRef as J, type FoldFailureRef as K, type FoldSuccessRef as L, type HostAction as M, type NodeId as N, type Option as O, type HostActionKind as P, type HostActionResult as Q, RuntimeFiber as R, Scope as S, type HostExecutionContext as T, type HostExecutor as U, HostRegistry as V, type WasmEngineRuntime as W, type HostRegistryStats as X, type HttpHostAction as Y, type ZIO as Z, type Interrupted as _, type FiberEngineStats as a, sanitizeLaneKey as a$, type LaneStatsData as a0, type None as a1, NoopHooks as a2, ProgramBuilder as a3, type ProgramPatch as a4, PushStatus as a5, type QueueHostAction as a6, RingBuffer as a7, type RingBufferEngine as a8, type RingBufferStatsData 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_, Runtime 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, asyncEffect as as, asyncCatchAll as at, asyncFail as au, asyncFlatMap as av, asyncFold as aw, asyncInterruptible as ax, asyncMap as ay, asyncMapError as az, type Fiber 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 FiberId as c, type FiberStatus as d, type RuntimeEvent as e, type WasmBridge as f, type OpcodeProgram as g, type FiberId$1 as h, type EngineEvent as i, type RefId as j, type OpcodeNode as k, type RingBufferOptions as l, type EngineStats as m, type AbortablePromiseFinish as n, type AbortablePromiseLabelStats as o, type AbortablePromiseOptions as p, type AbortablePromiseOutcome as q, type AbortablePromiseStats as r, type AsyncRegisterRef as s, type AsyncWithPromise as t, type RingLike as u, type Canceler as v, Cause as w, type CustomHostAction as x, type DecodeRef as y, DefaultHostExecutor as z };
+export { type FiberEngineKind 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 CausePrettyOptions as K, type ContextNode as L, type CustomHostAction as M, type NodeId as N, type Option as O, type DbHostAction as P, type DecodeRef as Q, type RuntimeHooks as R, Scope as S, type TraceContext as T, DefaultHostExecutor as U, type EngineKind as V, type WasmEngineRuntime as W, type EngineSelection as X, type EngineSelectionMode as Y, type ZIO as Z, type FiberContext as _, type RuntimeEmitContext as a, emptyContext as a$, type FiberInfo as a0, type FiberReadyQueue as a1, type FiberReadyQueueOptions as a2, type FiberReadyQueueStats as a3, type FiberRunState as a4, type FlatMapRef as a5, type FoldFailureRef as a6, type FoldSuccessRef as a7, type HostAction as a8, type HostActionKind as a9, type SchedulerLaneMode as aA, type SchedulerOptions as aB, type SchedulerStats as aC, type SchedulerStatsData as aD, type ScopeId as aE, type ScopeInfo as aF, type Some as aG, type SyncRef as aH, type Task as aI, WasmFiberEngine as aJ, type WasmFiberEngineOptions as aK, abortablePromiseStats as aL, acquireRelease as aM, asyncEffect as aN, asyncCatchAll as aO, asyncFail as aP, asyncFlatMap as aQ, asyncFold as aR, asyncInterruptible as aS, asyncMap as aT, asyncMapError as aU, asyncSucceed as aV, asyncSync as aW, asyncTotal as aX, catchAll as aY, ctxExtend as aZ, ctxToObject as a_, type HostActionResult as aa, type HostExecutionContext as ab, type HostExecutor as ac, HostRegistry as ad, type HostRegistryStats as ae, type HttpHostAction as af, type Interrupted as ag, type InterruptibilityMode as ah, type Joiner as ai, type LaneStatsData as aj, type None as ak, NoopHooks as al, ProgramBuilder as am, type ProgramPatch as an, PushStatus as ao, type QueueHostAction as ap, type ReadyQueueScheduleKind as aq, type RestoreInterruptibility as ar, RingBuffer as as, type RingBufferEngine as at, type RingBufferStatsData as au, type RuntimeCapabilities as av, type RuntimeEngineMode as aw, type ScheduleResult as ax, Scheduler as ay, type SchedulerEngine as az, type RingBufferOptions as b, end as b0, engineStats as b1, fail as b2, flatMap as b3, fork as b4, formatCause as b5, fromPromiseAbortable as b6, getBenchmarkBudget as b7, getCurrentFiber as b8, globalScheduler as b9, toPromise as bA, toPromiseByCaller as bB, uninterruptible as bC, uninterruptibleMask as bD, unit as bE, unsafeGetCurrentRuntime as bF, unsafeRunAsync as bG, unsafeRunFoldWithEnv as bH, withAsyncPromise as bI, withCurrentFiber as bJ, withScope as bK, withScopeAsync as bL, inferCallerLaneFromStack as ba, interruptible as bb, isCause as bc, laneTag as bd, linkAbortController as be, makeBoundedRingBuffer as bf, makeCancelToken as bg, makeFiberReadyQueue as bh, makeRuntimeEventRecord as bi, map as bj, mapAsync as bk, mapError as bl, mapTryAsync as bm, none as bn, orElseOptional as bo, prettyCause as bp, resetAbortablePromiseStats as bq, runtimeCapabilities as br, runtimeEventRecordContext as bs, runtimeForCaller as bt, sanitizeLaneKey as bu, selectedEngineStats as bv, setBenchmarkBudget as bw, some as bx, succeed as by, sync as bz, type RuntimeEvent 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-CFLC32IK.cjs

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

package/dist/effectRunner-L4S7IPT3.js

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

package/dist/effectRunner-NNGG75QA.mjs

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