brass-runtime 1.15.0 → 1.16.1

package/dist/index.d.ts

@@ -1,9 +1,11 @@
-import { F as FiberEngine, W as WasmEngineRuntime, A as Async, R as RuntimeFiber, a as FiberEngineStats, b as Fiber, c as FiberId, d as FiberStatus, E as Exit, e as RuntimeEvent, f as WasmBridge, g as OpcodeProgram, h as FiberId$1, i as EngineEvent, j as RefId, N as NodeId, k as OpcodeNode, S as Scope, l as RingBufferOptions, m as EngineStats, O as Option } from './effect-CMOQKX8y.js';
-export { n as AbortablePromiseFinish, o as AbortablePromiseLabelStats, p as AbortablePromiseOptions, q as AbortablePromiseOutcome, r as AbortablePromiseStats, s as AsyncRegisterRef, t as AsyncWithPromise, u as BoundedRingBuffer, C as CancelToken, v as Canceler, w as Cause, x as CustomHostAction, D as DbHostAction, y as DecodeRef, z as DefaultHostExecutor, B as EngineKind, G as EngineSelection, H as EngineSelectionMode, I as FiberEngineKind, J as FlatMapRef, K as FoldFailureRef, L as FoldSuccessRef, M as HostAction, P as HostActionKind, Q as HostActionResult, T as HostExecutionContext, U as HostExecutor, V as HostRegistry, X as HostRegistryStats, Y as HttpHostAction, _ as Interrupted, $ as Joiner, a0 as LaneStatsData, a1 as None, a2 as NoopHooks, a3 as ProgramBuilder, a4 as ProgramPatch, a5 as PushStatus, a6 as QueueHostAction, a7 as RingBuffer, a8 as RingBufferEngine, a9 as RingBufferStatsData, aa as Runtime, ab as RuntimeCapabilities, ac as RuntimeEngineMode, ad as RuntimeOptions, ae as ScheduleResult, af as Scheduler, ag as SchedulerEngine, ah as SchedulerOptions, ai as SchedulerStats, aj as SchedulerStatsData, ak as ScopeId, al as Some, am as SyncRef, an as Task, ao as WasmFiberEngine, ap as WasmFiberEngineOptions, Z as ZIO, aq as abortablePromiseStats, ar as acquireRelease, as as async, at as asyncCatchAll, au as asyncFail, av as asyncFlatMap, aw as asyncFold, ax as asyncInterruptible, ay as asyncMap, az as asyncMapError, aA as asyncSucceed, aB as asyncSync, aC as asyncTotal, aD as catchAll, aE as end, aF as engineStats, aG as fail, aH as flatMap, aI as fork, aJ as fromPromiseAbortable, aK as getBenchmarkBudget, aL as getCurrentFiber, aM as globalScheduler, aN as inferCallerLaneFromStack, aO as laneTag, aP as linkAbortController, aQ as makeBoundedRingBuffer, aR as makeCancelToken, aS as map, aT as mapAsync, aU as mapError, aV as mapTryAsync, aW as none, aX as orElseOptional, aY as resetAbortablePromiseStats, aZ as runtimeCapabilities, a_ as runtimeForCaller, a$ as sanitizeLaneKey, b0 as selectedEngineStats, b1 as setBenchmarkBudget, b2 as some, b3 as succeed, b4 as sync, b5 as toPromise, b6 as toPromiseByCaller, b7 as unit, b8 as unsafeGetCurrentRuntime, b9 as unsafeRunAsync, ba as unsafeRunFoldWithEnv, bb as withAsyncPromise, bc as withCurrentFiber, bd as withScope, be as withScopeAsync } from './effect-CMOQKX8y.js';
-export { Counter, Gauge, Histogram, HistogramBuckets, Layer, ManagedResource, MetricSnapshot, MetricType, MetricValue, MetricsRegistry, Ref, RetryPolicy, RetryState, Schedule, ScheduleDecision, Semaphore, SemaphoreStats, ShutdownConfig, ShutdownStats, TaggedError, TestRuntimeOptions, TimeoutError, WorkerPool, WorkerPoolConfig, WorkerPoolError, WorkerPoolStats, andThenSchedule, assertCompletesWithin, assertFails, assertFailsWith, assertSucceeds, bracket, catchTag, catchTags, composeLayer, delayedEffect, derivedRef, elapsed, ensuring, exponential, fixed, flakyEffect, gracefulShutdown, intersect, jittered, layer, layerFail, layerFrom, layerSucceed, makeMetrics, makeRef, makeSemaphore, makeTestRuntime, makeWorkerPool, managed, managedAll, mapErrorTyped, mapLayer, mergeLayer, neverEffect, orElse, provideLayer, recurs, registerShutdownHooks, repeatWithSchedule, retry, retryN, retryWithBackoff, retryWithSchedule, sleep, tagError, takeSchedule, timeout, union, useManaged, whileInput } from './core/index.js';
-export { C as CircuitBreaker, a as CircuitBreakerConfig, b as CircuitBreakerError, c as CircuitBreakerState, d as CircuitBreakerStats, S as Span, e as SpanContext, f as SpanEvent, g as SpanStatus, T as Tracer, h as TracerConfig, m as makeCircuitBreaker, i as makeTracer } from './tracing-DNT9jEbr.js';
-import { Z as ZStream } from './stream-FQm9h4Mg.js';
-export { C as Concat, E as Emit, a as Empty, F as Flatten, b as FromArray, c as FromPull, M as Managed, d as Merge, N as Normalize, R as ReadableStreamOptions, S as Scoped, e as assertNever, f as collectStream, g as concatStream, h as emitStream, i as emptyStream, j as flattenStream, k as foreachStream, l as fromArray, m as fromPull, n as managedStream, o as mapStream, p as merge, q as mergeStream, r as rangeStream, s as streamFromReadableStream, u as uncons, t as unwrapScoped, w as widenOpt, z as zip } from './stream-FQm9h4Mg.js';
+import { F as FiberEngine, W as WasmEngineRuntime, A as Async, i as RuntimeFiber, j as FiberEngineStats, k as Fiber, l as FiberId, m as FiberStatus, E as Exit, c as RuntimeEvent, n as WasmBridge, o as OpcodeProgram, p as FiberId$1, q as EngineEvent, r as RefId, N as NodeId, s as OpcodeNode, t as EngineStats, O as Option, f as Runtime, S as Scope, b as RingBufferOptions } from './effect-DIUHZ9IN.js';
+export { u as AbortablePromiseFinish, v as AbortablePromiseLabelStats, w as AbortablePromiseOptions, x as AbortablePromiseOutcome, y as AbortablePromiseStats, z as AsyncRegisterRef, C as AsyncWithPromise, D as BoundedRingBuffer, G as CancelToken, H as Canceler, I as Cause, K as CausePrettyOptions, L as ContextNode, M as CustomHostAction, P as DbHostAction, Q as DecodeRef, U as DefaultHostExecutor, V as EngineKind, X as EngineSelection, Y as EngineSelectionMode, _ as FiberContext, $ as FiberEngineKind, a0 as FiberInfo, a1 as FiberReadyQueue, a2 as FiberReadyQueueOptions, a3 as FiberReadyQueueStats, a4 as FiberRunState, a5 as FlatMapRef, a6 as FoldFailureRef, a7 as FoldSuccessRef, a8 as HostAction, a9 as HostActionKind, aa as HostActionResult, ab as HostExecutionContext, ac as HostExecutor, ad as HostRegistry, ae as HostRegistryStats, af as HttpHostAction, ag as Interrupted, ah as InterruptibilityMode, J as JSONValue, ai as Joiner, aj as LaneStatsData, ak as None, al as NoopHooks, am as ProgramBuilder, an as ProgramPatch, ao as PushStatus, ap as QueueHostAction, aq as ReadyQueueScheduleKind, ar as RestoreInterruptibility, as as RingBuffer, at as RingBufferEngine, au as RingBufferStatsData, av as RuntimeCapabilities, a as RuntimeEmitContext, aw as RuntimeEngineMode, d as RuntimeEventRecord, R as RuntimeHooks, h as RuntimeOptions, g as RuntimeRegistry, e as RuntimeSpanLink, ax as ScheduleResult, ay as Scheduler, az as SchedulerEngine, aA as SchedulerLaneMode, aB as SchedulerOptions, aC as SchedulerStats, aD as SchedulerStatsData, aE as ScopeId, aF as ScopeInfo, aG as Some, aH as SyncRef, aI as Task, T as TraceContext, aJ as WasmFiberEngine, aK as WasmFiberEngineOptions, Z as ZIO, aL as abortablePromiseStats, aM as acquireRelease, aN as async, aO as asyncCatchAll, aP as asyncFail, aQ as asyncFlatMap, aR as asyncFold, aS as asyncInterruptible, aT as asyncMap, aU as asyncMapError, aV as asyncSucceed, aW as asyncSync, aX as asyncTotal, aY as catchAll, aZ as ctxExtend, a_ as ctxToObject, a$ as emptyContext, b0 as end, b1 as engineStats, b2 as fail, b3 as flatMap, b4 as fork, b5 as formatCause, b6 as fromPromiseAbortable, b7 as getBenchmarkBudget, b8 as getCurrentFiber, b9 as globalScheduler, ba as inferCallerLaneFromStack, bb as interruptible, bc as isCause, bd as laneTag, be as linkAbortController, bf as makeBoundedRingBuffer, bg as makeCancelToken, bh as makeFiberReadyQueue, bi as makeRuntimeEventRecord, bj as map, bk as mapAsync, bl as mapError, bm as mapTryAsync, bn as none, bo as orElseOptional, bp as prettyCause, bq as resetAbortablePromiseStats, br as runtimeCapabilities, bs as runtimeEventRecordContext, bt as runtimeForCaller, bu as sanitizeLaneKey, bv as selectedEngineStats, bw as setBenchmarkBudget, bx as some, by as succeed, bz as sync, bA as toPromise, bB as toPromiseByCaller, bC as uninterruptible, bD as uninterruptibleMask, bE as unit, bF as unsafeGetCurrentRuntime, bG as unsafeRunAsync, bH as unsafeRunFoldWithEnv, bI as withAsyncPromise, bJ as withCurrentFiber, bK as withScope, bL as withScopeAsync } from './effect-DIUHZ9IN.js';
+export { BuiltLayer, EffectEnvironment, EffectFailure, EffectSuccess, FiberRef, Layer, LayerContext, LayerScope, LogLevel, MakeRuntimeOptions, MissingLayerServiceError, Ref, RetryPolicy, RetryState, RuntimeRecorder, RuntimeRecorderExplainOptions, RuntimeRecorderOptions, RuntimeRecorderStats, Semaphore, SemaphoreStats, ServiceTag, ShutdownConfig, ShutdownStats, SupervisedChildSpec, SupervisedChildStatus, SupervisedFiber, Supervisor, SupervisorConfig, SupervisorEscalation, SupervisorEvent, SupervisorRestartContext, SupervisorRestartMode, SupervisorRestartPolicy, SupervisorStrategy, TaggedError, TestClock, TestClockTimerSnapshot, TestRuntime, TestRuntimeOptions, TestScheduledTask, TestScheduler, TimeoutError, WorkerPool, WorkerPoolConfig, WorkerPoolError, WorkerPoolStats, assertCompletesWithin, assertFails, assertFailsWith, assertSucceeds, buildLayer, catchTag, catchTags, composeLayer, consoleJsonLogger, defineLayer, defineService, delayedEffect, derivedRef, dumpAllFibers, fiberRefSnapshot, flakyEffect, formatLayerError, getFiberRef, getService, gracefulShutdown, joinSupervised, layer, layerEffect, layerFail, layerFrom, layerFromContext, layerSucceed, layerValue, locallyFiberRef, locallyFiberRefWith, makeFiberRef, makeLayerScope, makeRef, makeRuntime, makeRuntimeRecorder, makeSemaphore, makeServiceTag, makeSupervisor, makeTestRuntime, makeWorkerPool, mapErrorTyped, mapLayer, mergeLayer, modifyFiberRef, neverEffect, orElse, provide, provideContext, provideLayer, provideLayerContext, registerShutdownHooks, retry, retryN, retryWithBackoff, runEffect, runExit, runPromise, serviceTag, setFiberRef, sleep, supervise, tagError, timeout, unsafeGetFiberRef, unsafeSetFiberRef, updateFiberRef } from './core/index.js';
+export { M as ManagedResource, R as Resource, R as ResourceDescriptor, S as Span, a as SpanContext, b as SpanEvent, c as SpanStatus, T as Tracer, d as TracerConfig, e as bracket, f as ensuring, m as makeResource, g as makeTracer, h as managed, i as managedAll, r as resource, j as resourceAll, k as resourceFromManaged, l as resourceSucceed, u as useManaged, n as useResource } from './tracing-DqbTKGcf.js';
+export { c as CircuitBreaker, d as CircuitBreakerConfig, C as CircuitBreakerError, e as CircuitBreakerState, b as CircuitBreakerStats, R as RuntimeClock, f as RuntimeClockEnv, g as RuntimeTimerId, S as Schedule, h as ScheduleDecision, i as ScheduleDriver, j as ScheduleDriverDecision, k as ScheduleDriverOptions, l as ScheduleDriverSnapshot, a as ScheduleObserver, m as ScheduleObserverEvent, n as ScheduleStepContext, o as andThenSchedule, p as contramapSchedule, q as elapsed, r as exponential, s as fibonacci, t as fixed, u as forever, v as intersect, w as jitter, x as jittered, y as jitteredSchedule, z as linear, A as liveClock, B as makeCircuitBreaker, D as makeScheduleDriver, E as mapSchedule, F as maxDelay, G as maxElapsed, H as namedSchedule, I as never, J as once, K as pollWithSchedule, L as recurs, M as repeatWithSchedule, N as repeatWithScheduleAlias, O as retryWithSchedule, P as retryWithScheduleAlias, Q as runSchedule, T as runtimeClockFromEnv, U as scheduleDriver, V as spaced, W as takeSchedule, X as tapDecision, Y as union, Z as untilInput, _ as untilOutput, $ as upTo, a0 as whileInput, a1 as whileOutput, a2 as windowed } from './schedule-CK3Ml_7p.js';
+export { B as BrassEnv, C as Counter, E as EventBus, f as EventBusOptions, g as EventHandler, G as Gauge, H as Histogram, h as HistogramBuckets, I as InMemoryTracer, e as InMemoryTracerOptions, i as InMemoryTracerStats, a as MetricExemplar, b as MetricSnapshot, j as MetricType, k as MetricValue, M as MetricsRegistry, R as RuntimeSpan, l as RuntimeSpanEvent, d as RuntimeTraceIdGenerator, m as defaultTracer, n as makeMetrics, r as runtimeHooksToEventHandler } from './tracer-Hwt1cl7h.js';
+import { Z as ZStream } from './stream-B4oK9JFP.js';
+export { C as Concat, E as Emit, a as Empty, F as Flatten, b as FromArray, c as FromPull, M as Managed, d as Merge, N as Normalize, R as ReadableStreamOptions, S as Scoped, e as assertNever, f as collectStream, g as concatStream, h as emitStream, i as emptyStream, j as flattenStream, k as foreachStream, l as fromArray, m as fromPull, n as managedStream, o as mapStream, p as merge, q as mergeStream, r as rangeStream, s as streamFromReadableStream, u as uncons, t as unwrapScoped, w as widenOpt, z as zip } from './stream-B4oK9JFP.js';
 
 declare class JsFiberEngine<R> implements FiberEngine<R> {
     private readonly runtime;
@@ -87,8 +89,6 @@ declare class WasmPackFiberBridge implements WasmBridge {
     stats(): unknown;
     private assertStrictWasmHotPath;
     private decodeZeroCopy;
-    private decodeBinary;
-    private decodeJson;
     private memory;
     private readU32;
     private readF64;
@@ -130,32 +130,6 @@ declare class WasmFiberRegistryBridge {
     stats(): WasmFiberRegistryStats;
 }
 
-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;
-
 declare const ABI_VERSION = 1;
 declare const EVENT_WORDS = 5;
 declare const NONE_U32 = 4294967295;
@@ -187,66 +161,6 @@ declare function encodeOpcodeNodes(nodes: readonly OpcodeNode[]): Uint32Array;
 declare function decodeEvent(words: ArrayLike<number>, offset?: number): EngineEvent;
 declare function decodeEventBatch(words: ArrayLike<number> | null | undefined): EngineEvent[];
 
-declare function buffer<R, E, A>(stream: ZStream<{} & R, E, A>, capacity: number, strategy?: "backpressure" | "dropping" | "sliding"): ZStream<{} & R, E, A>;
-
-/**
- * race(A, B):
- *   - corre A y B en paralelo
- *   - el primero que termine gana
- *   - el otro es cancelado
- */
-declare function race<R, E, A>(left: Async<R, E, A>, right: Async<R, E, A>, parentScope: Scope<R>): Async<R, E, A>;
-/**
- * zipPar(A, B):
- *   - corre A y B en paralelo
- *   - si ambas terminan bien → éxito con (A, B)
- *   - si una falla → cancelar todo y devolver fallo
- */
-declare function zipPar<R, E, A, B>(left: Async<R, E, A>, right: Async<R, E, B>, parentScope: Scope<R>): Async<R, E, [A, B]>;
-/**
- * collectAllPar:
- *   - corre todos en paralelo
- *   - si uno falla → cancela todos
- *   - si todos terminan bien → devuelve array de resultados
- */
-declare function collectAllPar<R, E, A>(effects: ReadonlyArray<Async<R, E, A>>, parentScope: Scope<R>): Async<R, E, A[]>;
-declare function raceWith<R, E, A, B, C>(left: Async<R, E, A>, right: Async<R, E, B>, parentScope: Scope<R>, onLeft: (exit: Exit<E, A>, rightFiber: Fiber<E, B>, scope: Scope<R>) => Async<R, E, C>, onRight: (exit: Exit<E, B>, leftFiber: Fiber<E, A>, scope: Scope<R>) => Async<R, E, C>): Async<R, E, C>;
-
-type Strategy = "backpressure" | "dropping" | "sliding";
-type QueueClosed = {
-    _tag: "QueueClosed";
-};
-type Queue<A> = {
-    offer: (a: A) => Async<unknown, never, boolean>;
-    take: () => Async<unknown, QueueClosed, A>;
-    /** Offer multiple values in a single effect. Returns array of success flags. */
-    offerBatch: (values: readonly A[]) => Async<unknown, never, boolean[]>;
-    /** Take up to N values in a single effect. Returns available values (may be fewer than N). */
-    takeBatch: (n: number) => Async<unknown, QueueClosed, A[]>;
-    size: () => number;
-    shutdown: () => void;
-};
-type QueueOptions = RingBufferOptions;
-declare function bounded<A>(capacity: number, strategy?: Strategy, options?: QueueOptions): Async<unknown, unknown, Queue<A>>;
-
-type HubStrategy = "BackPressure" | "Dropping" | "Sliding";
-type HubClosed = {
-    _tag: "HubClosed";
-};
-type Subscription<A> = Queue<A> & {
-    unsubscribe: () => void;
-};
-type Hub<A> = {
-    publish: (a: A) => Async<unknown, never, boolean>;
-    publishAll: (as: Iterable<A>) => Async<unknown, never, boolean>;
-    subscribe: () => Async<unknown, HubClosed, Subscription<A>>;
-    shutdown: () => Async<unknown, any, any>;
-};
-declare function makeHub<A>(capacity: number, strategy?: HubStrategy): Hub<A>;
-declare const broadcast: typeof makeHub;
-declare function broadcastToHub<R, E, A>(stream: ZStream<R, E, A>, hub: Hub<A>): Async<R, E, void>;
-declare function fromHub<A>(hub: Hub<A>): ZStream<unknown, HubClosed, A>;
-
 type StreamChunkEngine = "ts" | "wasm";
 type StreamChunkOptions = {
     /**
@@ -332,6 +246,84 @@ declare function bufferP<A>(capacity: number, strategy?: "backpressure" | "dropp
  */
 declare function groupedP<A>(n: number): ZPipeline<unknown, never, A, A[]>;
 
+type Stream<A, R = unknown, E = never> = ZStream<R, E, A> & {
+    readonly pipe: <Rp, Ep, B>(pipeline: ZPipeline<Rp, Ep, A, B>) => Stream<B, R & Rp, E | Ep>;
+    readonly map: <B>(f: (value: A) => B) => Stream<B, R, E>;
+    readonly filter: (predicate: (value: A) => boolean) => Stream<A, R, E>;
+    readonly collect: (runtime: Runtime<R>) => Promise<A[]>;
+};
+declare const Stream: Readonly<{
+    from: <A>(values: readonly A[]) => Stream<A>;
+    empty: <A = never>() => Stream<A>;
+    range: (start: number, end: number) => Stream<number>;
+    wrap: typeof asStream;
+}>;
+declare const Pipeline: Readonly<{
+    map: typeof mapP;
+    filter: typeof filterP;
+}>;
+declare function asStream<R, E, A>(stream: ZStream<R, E, A>): Stream<A, R, E>;
+
+declare function buffer<R, E, A>(stream: ZStream<{} & R, E, A>, capacity: number, strategy?: "backpressure" | "dropping" | "sliding"): ZStream<{} & R, E, A>;
+
+/**
+ * race(A, B):
+ *   - corre A y B en paralelo
+ *   - el primero que termine gana
+ *   - el otro es cancelado
+ */
+declare function race<R, E, A>(left: Async<R, E, A>, right: Async<R, E, A>, parentScope: Scope<R>): Async<R, E, A>;
+/**
+ * zipPar(A, B):
+ *   - corre A y B en paralelo
+ *   - si ambas terminan bien → éxito con (A, B)
+ *   - si una falla → cancelar todo y devolver fallo
+ */
+declare function zipPar<R, E, A, B>(left: Async<R, E, A>, right: Async<R, E, B>, parentScope: Scope<R>): Async<R, E, [A, B]>;
+/**
+ * collectAllPar:
+ *   - corre todos en paralelo
+ *   - si uno falla → cancela todos
+ *   - si todos terminan bien → devuelve array de resultados
+ */
+declare function collectAllPar<R, E, A>(effects: ReadonlyArray<Async<R, E, A>>, parentScope: Scope<R>): Async<R, E, A[]>;
+declare function raceWith<R, E, A, B, C>(left: Async<R, E, A>, right: Async<R, E, B>, parentScope: Scope<R>, onLeft: (exit: Exit<E, A>, rightFiber: Fiber<E, B>, scope: Scope<R>) => Async<R, E, C>, onRight: (exit: Exit<E, B>, leftFiber: Fiber<E, A>, scope: Scope<R>) => Async<R, E, C>): Async<R, E, C>;
+
+type Strategy = "backpressure" | "dropping" | "sliding";
+type QueueClosed = {
+    _tag: "QueueClosed";
+};
+type Queue<A> = {
+    offer: (a: A) => Async<unknown, never, boolean>;
+    take: () => Async<unknown, QueueClosed, A>;
+    /** Offer multiple values in a single effect. Returns array of success flags. */
+    offerBatch: (values: readonly A[]) => Async<unknown, never, boolean[]>;
+    /** Take up to N values in a single effect. Returns available values (may be fewer than N). */
+    takeBatch: (n: number) => Async<unknown, QueueClosed, A[]>;
+    size: () => number;
+    shutdown: () => void;
+};
+type QueueOptions = RingBufferOptions;
+declare function bounded<A>(capacity: number, strategy?: Strategy, options?: QueueOptions): Async<unknown, unknown, Queue<A>>;
+
+type HubStrategy = "BackPressure" | "Dropping" | "Sliding";
+type HubClosed = {
+    _tag: "HubClosed";
+};
+type Subscription<A> = Queue<A> & {
+    unsubscribe: () => void;
+};
+type Hub<A> = {
+    publish: (a: A) => Async<unknown, never, boolean>;
+    publishAll: (as: Iterable<A>) => Async<unknown, never, boolean>;
+    subscribe: () => Async<unknown, HubClosed, Subscription<A>>;
+    shutdown: () => Async<unknown, any, any>;
+};
+declare function makeHub<A>(capacity: number, strategy?: HubStrategy): Hub<A>;
+declare const broadcast: typeof makeHub;
+declare function broadcastToHub<R, E, A>(stream: ZStream<R, E, A>, hub: Hub<A>): Async<R, E, void>;
+declare function fromHub<A>(hub: Hub<A>): ZStream<unknown, HubClosed, A>;
+
 /** Serialized representation of a single step in a fused pipeline */
 type SerializedStep = {
     kind: "map";
@@ -532,4 +524,4 @@ declare function take<R, E, A>(stream: ZStream<R, E, A>, n: number): ZStream<R,
  */
 declare function drop<R, E, A>(stream: ZStream<R, E, A>, n: number): ZStream<R, E, A>;
 
-export { ABI_VERSION, Async, EVENT_WORDS, EngineEvent, EngineFiberHandle, EngineStats, EventKindCode, Exit, Fiber, FiberEngine, FiberEngineStats, FiberId, type FiberReadyQueue, type FiberReadyQueueOptions, type FiberReadyQueueStats, FiberStatus, type FuseResult, type FuseState, type FusedPipelineRepr, type FusedPipelineStats, type FusedStep, type FusionOptions, type Hub, type HubClosed, type HubStrategy, type InternalFiberStatus, JsFiberEngine, NONE_U32, NodeId, OpcodeNode, OpcodeProgram, OpcodeTagCode, Option, PURE_PIPELINE_TAG, type PurePipelineMetadata, type PurePipelineTag, type Queue, type QueueClosed, type QueueOptions, type ReadyQueueScheduleKind, RefId, RingBufferOptions, RuntimeFiber, Scope, type SerializedFusedPipeline, type SerializedStep, type Strategy, type StreamChunkEngine, type StreamChunkOptions, type StreamChunkStats, type Subscription, WasmBridge, WasmEngineRuntime, WasmFiberRegistryBridge, type WasmFiberRegistryStats, WasmPackFiberBridge, type ZPipeline, ZStream, andThen, applyFused, bounded, broadcast, broadcastToHub, buffer, bufferP, chunks, chunksP, collectAllPar, compose, debounce, decodeEvent, decodeEventBatch, deserializeFusedPipeline, dropP, drop as dropStream, encodeOpcodeNodes, encodeOpcodeProgram, filterMapP, filterP, fromHub, fuse, getStats, groupedP, identity, initState, interleave, isFusionEnabled, isFusionVerbose, makeFiberReadyQueue, makeHub, makeStreamChunker, mapChunks, mapChunksEffect, mapChunksEffectP, mapEffectP, mapP, race, raceWith, runFusedArray, scan, serializeFusedPipeline, setFusionEnabled, setFusionVerbose, takeP, take as takeStream, tapEffectP, throttle, via, zipPar, zip as zipStream, zipWith };
+export { ABI_VERSION, Async, EVENT_WORDS, EngineEvent, EngineFiberHandle, EngineStats, EventKindCode, Exit, Fiber, FiberEngine, FiberEngineStats, FiberId, FiberStatus, type FuseResult, type FuseState, type FusedPipelineRepr, type FusedPipelineStats, type FusedStep, type FusionOptions, type Hub, type HubClosed, type HubStrategy, type InternalFiberStatus, JsFiberEngine, NONE_U32, NodeId, OpcodeNode, OpcodeProgram, OpcodeTagCode, Option, PURE_PIPELINE_TAG, Pipeline, type PurePipelineMetadata, type PurePipelineTag, type Queue, type QueueClosed, type QueueOptions, RefId, RingBufferOptions, Runtime, RuntimeEvent, RuntimeFiber, Scope, type SerializedFusedPipeline, type SerializedStep, type Strategy, Stream, type StreamChunkEngine, type StreamChunkOptions, type StreamChunkStats, type Subscription, WasmBridge, WasmEngineRuntime, WasmFiberRegistryBridge, type WasmFiberRegistryStats, WasmPackFiberBridge, type ZPipeline, ZStream, andThen, applyFused, asStream, bounded, broadcast, broadcastToHub, buffer, bufferP, chunks, chunksP, collectAllPar, compose, debounce, decodeEvent, decodeEventBatch, deserializeFusedPipeline, dropP, drop as dropStream, encodeOpcodeNodes, encodeOpcodeProgram, filterMapP, filterP, fromHub, fuse, getStats, groupedP, identity, initState, interleave, isFusionEnabled, isFusionVerbose, makeHub, makeStreamChunker, mapChunks, mapChunksEffect, mapChunksEffectP, mapEffectP, mapP, race, raceWith, runFusedArray, scan, serializeFusedPipeline, setFusionEnabled, setFusionVerbose, takeP, take as takeStream, tapEffectP, throttle, via, zipPar, zip as zipStream, zipWith };