@zlink-systems/stream-connector 0.22.0 → 0.23.0

package/dist/browser/Contracts/Calls/ZlinkStreamCalls.d.ts

@@ -1,11 +1,10 @@
 import type { ZlinkStreamMetadata } from '../ZlinkStreamMetadata';
-import type { ZlinkStreamEncodedPayload, ZlinkStreamFlow, ZlinkStreamMessage, ZlinkStreamResultOf } from '../ZlinkStreamModels';
+import type { ZlinkStreamEncodedPayload, ZlinkStreamMessage, ZlinkStreamResultOf } from '../ZlinkStreamModels';
 export interface ZlinkStreamSendCall {
     packetName(name: string): ZlinkStreamSendCall;
     metadata(key: string, value: string): ZlinkStreamSendCall;
     metadata(metadata: ZlinkStreamMetadata): ZlinkStreamSendCall;
     compress(): ZlinkStreamSendCall;
-    flowFrom(flow: ZlinkStreamFlow): ZlinkStreamSendCall;
     submit(): Promise<void>;
 }
 export interface ZlinkStreamRequestCall {
@@ -14,7 +13,6 @@ export interface ZlinkStreamRequestCall {
     metadata(metadata: ZlinkStreamMetadata): ZlinkStreamRequestCall;
     timeout(timeoutMs: number): ZlinkStreamRequestCall;
     compress(): ZlinkStreamRequestCall;
-    flowFrom(flow: ZlinkStreamFlow): ZlinkStreamRequestCall;
     submit<TReply = unknown>(signal?: AbortSignal): Promise<TReply>;
     submitEncoded(signal?: AbortSignal): Promise<ZlinkStreamEncodedPayload>;
     submit(callback: (result: ZlinkStreamResultOf<ZlinkStreamEncodedPayload>) => void): void;

package/dist/browser/Contracts/IZlinkStreamConnector.d.ts

@@ -1,35 +1,19 @@
 import type { Disposable } from './ZlinkStreamInterfaces';
 import type { RequiredZlinkStreamConnectorOptions } from './ZlinkStreamConnectorOptions';
 import type { ZlinkStreamRequestCall, ZlinkStreamSendCall, ZlinkStreamExpectNoneCall, ZlinkStreamSequenceCall, ZlinkStreamWaitCall } from './Calls/ZlinkStreamCalls';
-import type { ZlinkStreamConnectionStateChanged, ZlinkStreamEncodedPayload, ZlinkStreamError, ZlinkStreamMessage } from './ZlinkStreamModels';
-import type { ZlinkStreamCloseReason, ZlinkStreamConnectionState, ZlinkStreamDiagnosticsLevel } from './ZlinkStreamEnums';
+import type { ZlinkStreamConnectionStateChanged, ZlinkStreamEncodedPayload, ZlinkStreamError, ZlinkStreamMessage, ZlinkStreamRequestSendingContext, ZlinkStreamReplyReceivedContext } from './ZlinkStreamModels';
+import type { ZlinkStreamCloseReason, ZlinkStreamConnectionState } from './ZlinkStreamEnums';
+import type { ZlinkStreamActor } from './ZlinkStreamActor';
 export interface ZlinkStreamConnector {
     readonly isConnected: boolean;
     readonly state: ZlinkStreamConnectionState;
     readonly closeReason?: ZlinkStreamCloseReason;
     readonly options: RequiredZlinkStreamConnectorOptions;
     readonly pendingDispatchCount: number;
-    /**
-     * Current diagnostics level (spec 26 §4.1, spec stream-connector 32 §13).
-     * Always equal to `options.diagnosticsLevel`.
-     */
-    readonly diagnosticsLevel: ZlinkStreamDiagnosticsLevel;
-    /**
-     * Changes the diagnostics level at runtime without recreating the
-     * connector (spec 26 §4.1, spec stream-connector 32 §13). Applies to
-     * processing points that read the level after this call returns; never
-     * applied retroactively to frames already built. Rejects unknown values
-     * with {@link import('./ZlinkStreamEnums').ZlinkStreamErrorCode.ConfigurationError}.
-     */
-    setDiagnosticsLevel(level: ZlinkStreamDiagnosticsLevel): void;
-    /**
-     * Asynchronous counterpart of {@link setDiagnosticsLevel} (spec
-     * stream-connector 32 §13). Both surfaces change the same value, and this
-     * one never replaces the synchronous surface: the synchronous call does not
-     * wait for a completion, so a caller whose idiom is an awaited completion
-     * uses this one instead. Rejects unknown values the same way.
-     */
-    setDiagnosticsLevelAsync(level: ZlinkStreamDiagnosticsLevel): Promise<void>;
+    readonly actors: readonly ZlinkStreamActor[];
+    actor(actorId: string): ZlinkStreamActor | undefined;
+    onActorBound(handler: (actor: ZlinkStreamActor, signal?: AbortSignal) => Promise<void> | void): Disposable;
+    onActorUnbound(handler: (actor: ZlinkStreamActor, signal?: AbortSignal) => Promise<void> | void): Disposable;
     /**
      * Number of packets received under `name` on the current connection (spec
      * stream-connector 32 §10). Counts arrivals, so consuming a message through
@@ -40,12 +24,14 @@ export interface ZlinkStreamConnector {
     onErrorReceived(handler: (error: ZlinkStreamError, signal?: AbortSignal) => Promise<void> | void): Disposable;
     onDisconnected(handler: (signal?: AbortSignal) => Promise<void> | void): Disposable;
     onConnectionStateChanged(handler: (change: ZlinkStreamConnectionStateChanged, signal?: AbortSignal) => Promise<void> | void): Disposable;
+    onRequestSending(handler: (context: ZlinkStreamRequestSendingContext) => void): Disposable;
+    onReplyReceived(handler: (context: ZlinkStreamReplyReceivedContext, signal?: AbortSignal) => Promise<void> | void): Disposable;
     connect(signal?: AbortSignal): Promise<void>;
     close(signal?: AbortSignal): Promise<void>;
     dispatch(signal?: AbortSignal): Promise<void>;
     send(payload: unknown, messageType?: Function): ZlinkStreamSendCall;
     request(payload: unknown, messageType?: Function): ZlinkStreamRequestCall;
-    on<TPayload = ZlinkStreamEncodedPayload>(name: string, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
+    on<TPayload = ZlinkStreamEncodedPayload>(nameOrType: string | Function, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
     /**
      * Wait surfaces (spec stream-connector 32 §10.1). Each takes the packet name
      * the caller states explicitly, or the payload constructor the options'

package/dist/browser/Contracts/ZlinkStreamActor.d.ts

@@ -0,0 +1,10 @@
+import type { Disposable } from './ZlinkStreamInterfaces';
+import type { ZlinkStreamRequestCall, ZlinkStreamSendCall } from './Calls/ZlinkStreamCalls';
+import type { ZlinkStreamEncodedPayload, ZlinkStreamMessage } from './ZlinkStreamModels';
+export interface ZlinkStreamActor {
+    readonly actorId: string;
+    readonly isBound: boolean;
+    send(payload: unknown, messageType?: Function): ZlinkStreamSendCall;
+    request(payload: unknown, messageType?: Function): ZlinkStreamRequestCall;
+    on<TPayload = ZlinkStreamEncodedPayload>(nameOrType: string | Function, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
+}

package/dist/browser/Contracts/ZlinkStreamConnectorOptions.d.ts

@@ -1,4 +1,4 @@
-import type { ZlinkStreamCompression, ZlinkStreamDiagnosticsLevel, ZlinkStreamDispatchMode, ZlinkStreamTransport } from './ZlinkStreamEnums';
+import type { ZlinkStreamCompression, ZlinkStreamDispatchMode, ZlinkStreamTransport } from './ZlinkStreamEnums';
 import type { ZlinkStreamEncodedPayload } from './ZlinkStreamModels';
 export interface ZlinkStreamConnectorOptions {
     readonly endpoint: string;
@@ -16,15 +16,6 @@ export interface ZlinkStreamConnectorOptions {
     readonly compression?: ZlinkStreamCompression;
     readonly compressionCodec?: ZlinkStreamCompressionCodec;
     readonly nameResolver?: ZlinkStreamPacketNameResolver;
-    /**
-     * Initial diagnostics level (spec 26 §4); defaults to
-     * {@link ZlinkStreamDiagnosticsLevel.Errors}, which preserves the current
-     * wire behavior. `Off` suppresses all observation-only flow handling
-     * (spec 27 §4). This is only the level at construction time — spec 26
-     * §4.1 / spec stream-connector 32 §13 require runtime read/write, provided
-     * by `ZlinkStreamConnector.diagnosticsLevel` / `setDiagnosticsLevel(...)`.
-     */
-    readonly diagnosticsLevel?: ZlinkStreamDiagnosticsLevel;
 }
 export interface ZlinkStreamHeartbeatOptions {
     readonly enabled?: boolean;
@@ -77,5 +68,4 @@ export interface RequiredZlinkStreamConnectorOptions {
     readonly nameResolver: ZlinkStreamPacketNameResolver;
     readonly transportFactory: ZlinkStreamTransportFactory;
     readonly codec?: ZlinkStreamPayloadCodec;
-    readonly diagnosticsLevel: ZlinkStreamDiagnosticsLevel;
 }

package/dist/browser/Contracts/ZlinkStreamEnums.d.ts

@@ -11,20 +11,6 @@ export declare enum ZlinkStreamDispatchMode {
     Manual = "manual",
     Immediate = "immediate"
 }
-/**
- * Connector diagnostics level (spec 26 §4). `Errors` is the default and
- * preserves the connector's established wire behavior (outbound frames carry
- * the flow pair). `Off` applies spec 27 §4: no flow id is generated or
- * attached to outbound frames (header flag 0x10 stays clear), inbound flow
- * fields are neither validated nor installed into received messages
- * (structural length checks are kept), and no trace-only work runs.
- */
-export declare enum ZlinkStreamDiagnosticsLevel {
-    Off = "off",
-    Errors = "errors",
-    Normal = "normal",
-    Detailed = "detailed"
-}
 export declare enum ZlinkStreamMessageKind {
     Send = 1,
     Request = 2,
@@ -38,9 +24,9 @@ export declare enum ZlinkStreamHeaderFlags {
     HasMetadata = 2,
     PayloadCompressed = 4,
     HasCorrelationId = 8,
-    HasFlowId = 16
+    HasFlowId = 16,
+    HasActorSlot = 32
 }
-export type ZlinkFlowOrigin = 'Inbound' | 'Timer' | 'Application' | 'Lifecycle';
 export type ZlinkStreamCloseReason = 'ClientClose' | 'IdleTimeout' | 'HeartbeatTimeout' | 'ServerDrain' | 'ProtocolError' | 'TransportError';
 export declare enum ZlinkStreamErrorCode {
     Disconnected = "disconnected",

package/dist/browser/Contracts/ZlinkStreamModels.d.ts

@@ -1,25 +1,28 @@
-import type { ZlinkStreamCodec, ZlinkStreamConnectionState, ZlinkStreamErrorCode, ZlinkStreamHeaderFlags, ZlinkStreamMessageKind, ZlinkFlowOrigin } from './ZlinkStreamEnums';
+import type { ZlinkStreamCodec, ZlinkStreamConnectionState, ZlinkStreamErrorCode, ZlinkStreamHeaderFlags, ZlinkStreamMessageKind } from './ZlinkStreamEnums';
 import type { ZlinkStreamMetadata } from './ZlinkStreamMetadata';
 export interface ZlinkStreamEncodedPayload {
     readonly codec: ZlinkStreamCodec;
     readonly payload: Uint8Array;
     readonly messageType?: Function;
 }
-export interface ZlinkStreamFlow {
-    readonly flowId: string;
-    readonly flowOrigin: ZlinkFlowOrigin;
-}
 export interface ZlinkStreamMessage<TPayload = unknown> {
     readonly name: string;
     readonly metadata: ZlinkStreamMetadata;
     readonly payload: TPayload;
-    /**
-     * Present while diagnostics are enabled (the default). With
-     * `diagnosticsLevel: Off` inbound flow fields are neither read nor
-     * installed (spec 27 §4), so delivered messages carry no flow pair.
-     */
-    readonly flowId?: string;
-    readonly flowOrigin?: ZlinkFlowOrigin;
+    readonly actorId?: string;
+}
+export interface ZlinkStreamRequestSendingContext {
+    readonly requestPacketName: string;
+    readonly actorId?: string;
+    setMetadata(key: string, value: string): void;
+}
+export interface ZlinkStreamReplyReceivedContext {
+    readonly requestPacketName: string;
+    readonly actorId?: string;
+    readonly succeeded: boolean;
+    readonly reply?: ZlinkStreamMessage<ZlinkStreamEncodedPayload>;
+    readonly error?: ZlinkStreamError;
+    readonly elapsed: number;
 }
 export interface ZlinkStreamHeader {
     readonly kind: ZlinkStreamMessageKind;
@@ -29,8 +32,7 @@ export interface ZlinkStreamHeader {
     readonly name: string;
     readonly metadata: ZlinkStreamMetadata;
     readonly correlationId?: string;
-    readonly flowId?: string;
-    readonly flowOrigin?: ZlinkFlowOrigin;
+    readonly actorSlot?: number;
 }
 export interface ZlinkStreamError {
     readonly code: ZlinkStreamErrorCode;

package/dist/browser/Contracts/index.d.ts

@@ -1,10 +1,11 @@
-export { ZlinkStreamTransport, ZlinkStreamCodec, ZlinkStreamCompression, ZlinkStreamDiagnosticsLevel, ZlinkStreamDispatchMode, ZlinkStreamMessageKind, ZlinkStreamHeaderFlags, ZlinkStreamErrorCode, ZlinkStreamConnectionState } from './ZlinkStreamEnums';
-export type { ZlinkFlowOrigin, ZlinkStreamCloseReason } from './ZlinkStreamEnums';
+export { ZlinkStreamTransport, ZlinkStreamCodec, ZlinkStreamCompression, ZlinkStreamDispatchMode, ZlinkStreamMessageKind, ZlinkStreamHeaderFlags, ZlinkStreamErrorCode, ZlinkStreamConnectionState } from './ZlinkStreamEnums';
+export type { ZlinkStreamCloseReason } from './ZlinkStreamEnums';
 export * from './ZlinkStreamConnectorOptions';
 export * from './ZlinkStreamInterfaces';
 export * from './ZlinkStreamMetadata';
-export type { ZlinkStreamEncodedPayload, ZlinkStreamFlow, ZlinkStreamMessage, ZlinkStreamError, ZlinkStreamConnectionStateChanged, ZlinkStreamResult, ZlinkStreamResultOf } from './ZlinkStreamModels';
+export type { ZlinkStreamEncodedPayload, ZlinkStreamMessage, ZlinkStreamRequestSendingContext, ZlinkStreamReplyReceivedContext, ZlinkStreamError, ZlinkStreamConnectionStateChanged, ZlinkStreamResult, ZlinkStreamResultOf } from './ZlinkStreamModels';
 export { ZlinkStreamException } from './ZlinkStreamModels';
 export * from './ZlinkStreamJsonCodec';
 export * from './IZlinkStreamConnector';
+export * from './ZlinkStreamActor';
 export * from './Calls/ZlinkStreamCalls';

package/dist/browser/Runtime/Calls/ZlinkStreamCallBuilders.d.ts

@@ -1,33 +1,31 @@
-import { RequiredZlinkStreamConnectorOptions, ZlinkStreamEncodedPayload, ZlinkStreamFlow, ZlinkStreamMessage, ZlinkStreamMessageKind, ZlinkStreamMetadata, type ZlinkStreamRequestCall, type ZlinkStreamResultOf, type ZlinkStreamSendCall, type ZlinkStreamWaitCall } from '../../Contracts';
+import { RequiredZlinkStreamConnectorOptions, ZlinkStreamEncodedPayload, ZlinkStreamMessage, ZlinkStreamMessageKind, ZlinkStreamMetadata, type ZlinkStreamRequestCall, type ZlinkStreamResultOf, type ZlinkStreamSendCall, type ZlinkStreamWaitCall } from '../../Contracts';
 interface ZlinkStreamConnectorSubmitter {
     readonly options: RequiredZlinkStreamConnectorOptions;
-    sendEncoded(kind: ZlinkStreamMessageKind, name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, signal?: AbortSignal, flow?: ZlinkStreamFlow): Promise<void>;
-    requestEncoded(name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, timeoutMs: number, signal?: AbortSignal, flow?: ZlinkStreamFlow): Promise<ZlinkStreamEncodedPayload>;
+    sendEncoded(kind: ZlinkStreamMessageKind, name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, signal?: AbortSignal, correlationId?: string, actorSlot?: number): Promise<void>;
+    requestEncoded(name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, timeoutMs: number, signal?: AbortSignal, actorSlot?: number): Promise<ZlinkStreamEncodedPayload>;
     waitForMessage<TPayload>(name: string, timeoutMs: number, predicate: (message: ZlinkStreamMessage<TPayload>) => boolean, signal?: AbortSignal): Promise<ZlinkStreamMessage<TPayload> | undefined>;
 }
 export declare class ZlinkStreamSendBuilder implements ZlinkStreamSendCall {
     private readonly connector;
     private readonly payload;
     private readonly state;
-    constructor(connector: ZlinkStreamConnectorSubmitter, name: string | undefined, payload: ZlinkStreamEncodedPayload);
+    constructor(connector: ZlinkStreamConnectorSubmitter, name: string | undefined, payload: ZlinkStreamEncodedPayload, actorSlot?: number, validateActor?: () => void);
     packetName(name: string): this;
     metadata(key: string, value: string): this;
     metadata(metadata: ZlinkStreamMetadata): this;
     compress(): this;
-    flowFrom(flow: ZlinkStreamFlow): this;
     submit(signal?: AbortSignal): Promise<void>;
 }
 export declare class ZlinkStreamRequestBuilder implements ZlinkStreamRequestCall {
     private readonly connector;
     private readonly payload;
     private readonly state;
-    constructor(connector: ZlinkStreamConnectorSubmitter, name: string | undefined, payload: ZlinkStreamEncodedPayload);
+    constructor(connector: ZlinkStreamConnectorSubmitter, name: string | undefined, payload: ZlinkStreamEncodedPayload, actorSlot?: number, validateActor?: () => void);
     packetName(name: string): this;
     metadata(key: string, value: string): this;
     metadata(metadata: ZlinkStreamMetadata): this;
     timeout(timeoutMs: number): this;
     compress(): this;
-    flowFrom(flow: ZlinkStreamFlow): this;
     submit<TReply = unknown>(signal?: AbortSignal): Promise<TReply>;
     submit(callback: (result: ZlinkStreamResultOf<ZlinkStreamEncodedPayload>) => void): void;
     submitEncoded(signal?: AbortSignal): Promise<ZlinkStreamEncodedPayload>;

package/dist/browser/Runtime/Protocol/ZlinkStreamFrameProtocol.d.ts

@@ -1,20 +1,18 @@
 import type { RequiredZlinkStreamConnectorOptions, ZlinkStreamEncodedPayload, ZlinkStreamMetadata } from '../../Contracts';
 import { ZlinkStreamMessageKind } from '../../Contracts';
 import type { ZlinkStreamHeader } from '../../Contracts/ZlinkStreamModels';
-import type { ZlinkFlowOrigin } from '../../Contracts';
 export declare const ZLINK_STREAM_HEARTBEAT_PING = "$zlink.heartbeat.ping";
 export declare const ZLINK_STREAM_HEARTBEAT_PONG = "$zlink.heartbeat.pong";
 export declare class ZlinkStreamFrameProtocol {
     private readonly options;
     constructor(options: RequiredZlinkStreamConnectorOptions);
-    encode(kind: ZlinkStreamMessageKind, name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, correlationId?: string, flowId?: string, flowOrigin?: ZlinkFlowOrigin): Uint8Array;
+    encode(kind: ZlinkStreamMessageKind, name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, correlationId?: string, actorSlot?: number): Uint8Array;
     encodeControl(name: string, payload?: Uint8Array<ArrayBuffer>): Uint8Array;
-    decode(frameBytes: Uint8Array, flowEnabled?: boolean): {
+    decode(frameBytes: Uint8Array): {
         readonly header: ZlinkStreamHeader;
         readonly payload: Uint8Array;
     };
-    flowEnabled(): boolean;
-    decodeFrames(chunk: Uint8Array, flowEnabled?: boolean): readonly {
+    decodeFrames(chunk: Uint8Array): readonly {
         readonly header: ZlinkStreamHeader;
         readonly payload: Uint8Array;
     }[];

package/dist/browser/Runtime/Protocol/ZlinkStreamHeaderCodec.d.ts

@@ -2,11 +2,6 @@ import { ZlinkStreamCodec, ZlinkStreamMessageKind, ZlinkStreamMetadata } from '.
 import type { ZlinkStreamHeader } from '../../Contracts/ZlinkStreamModels';
 export declare class ZlinkStreamHeaderCodec {
     static encode(header: ZlinkStreamHeader): Uint8Array;
-    /**
-     * `includeFlow=false` (diagnostics Off, spec 27 §4) skips reading and
-     * validating the inbound flow fields while the structural length checks in
-     * the wire decoder are preserved.
-     */
-    static decode(header: Uint8Array, includeFlow?: boolean): ZlinkStreamHeader;
+    static decode(header: Uint8Array): ZlinkStreamHeader;
 }
-export declare function buildHeader(kind: ZlinkStreamMessageKind, name: string, codec: ZlinkStreamCodec, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, correlationId?: string, flowId?: string, flowOrigin?: import('../../Contracts').ZlinkFlowOrigin): ZlinkStreamHeader;
+export declare function buildHeader(kind: ZlinkStreamMessageKind, name: string, codec: ZlinkStreamCodec, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, correlationId?: string, actorSlot?: number): ZlinkStreamHeader;

package/dist/browser/Runtime/ZlinkStreamActors.d.ts

@@ -0,0 +1,45 @@
+import type { Disposable, ZlinkStreamActor, ZlinkStreamEncodedPayload, ZlinkStreamMessage, ZlinkStreamRequestCall, ZlinkStreamSendCall } from '../Contracts';
+import type { ZlinkStreamReceivedMessages } from './ZlinkStreamReceivedMessages';
+import type { ZlinkStreamConnectorEvents } from './ZlinkStreamConnectorEvents';
+export declare const zlinkStreamActorBinding: unique symbol;
+interface ActorConnector {
+    sendForActor(actor: DefaultZlinkStreamActor, payload: unknown, messageType?: Function): ZlinkStreamSendCall;
+    requestForActor(actor: DefaultZlinkStreamActor, payload: unknown, messageType?: Function): ZlinkStreamRequestCall;
+    onActorMessage<TPayload>(actor: DefaultZlinkStreamActor, nameOrType: string | Function, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
+}
+export declare class DefaultZlinkStreamActor implements ZlinkStreamActor {
+    private readonly connector;
+    readonly actorId: string;
+    readonly slot: number;
+    private bound;
+    constructor(connector: ActorConnector, actorId: string, slot: number);
+    get isBound(): boolean;
+    send(payload: unknown, messageType?: Function): ZlinkStreamSendCall;
+    request(payload: unknown, messageType?: Function): ZlinkStreamRequestCall;
+    on<TPayload = ZlinkStreamEncodedPayload>(nameOrType: string | Function, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
+    ensureBound(): void;
+    close(): void;
+}
+export declare class ZlinkStreamActors {
+    private readonly connector;
+    private readonly receivedMessages;
+    private readonly events;
+    private readonly bySlot;
+    private readonly byId;
+    private readonly issued;
+    private readonly boundHandlers;
+    private readonly unboundHandlers;
+    constructor(connector: ActorConnector, receivedMessages: ZlinkStreamReceivedMessages, events: ZlinkStreamConnectorEvents);
+    get snapshot(): readonly ZlinkStreamActor[];
+    find(actorId: string): ZlinkStreamActor | undefined;
+    onBound(handler: (actor: ZlinkStreamActor, signal?: AbortSignal) => Promise<void> | void): Disposable;
+    onUnbound(handler: (actor: ZlinkStreamActor, signal?: AbortSignal) => Promise<void> | void): Disposable;
+    processControl(name: string, payload: Uint8Array, signal?: AbortSignal): boolean;
+    resolve(slot: number): DefaultZlinkStreamActor;
+    closeAll(signal?: AbortSignal): void;
+    private bind;
+    private unbind;
+    private queue;
+    private invoke;
+}
+export {};

package/dist/browser/Runtime/ZlinkStreamConnector.d.ts

@@ -1,4 +1,5 @@
-import { Disposable, RequiredZlinkStreamConnectorOptions, ZlinkStreamConnectionState, ZlinkStreamConnectionStateChanged, ZlinkStreamConnector, ZlinkStreamConnectorOptions, ZlinkStreamDiagnosticsLevel, ZlinkStreamEncodedPayload, ZlinkStreamError, ZlinkStreamExpectNoneCall, ZlinkStreamFlow, ZlinkStreamMessage, ZlinkStreamMessageKind, ZlinkStreamMetadata, ZlinkStreamRequestCall, ZlinkStreamSendCall, ZlinkStreamSequenceCall, ZlinkStreamWaitCall } from '../Contracts';
+import { Disposable, RequiredZlinkStreamConnectorOptions, ZlinkStreamConnectionState, ZlinkStreamConnectionStateChanged, ZlinkStreamConnector, ZlinkStreamConnectorOptions, ZlinkStreamEncodedPayload, ZlinkStreamError, ZlinkStreamExpectNoneCall, ZlinkStreamMessage, ZlinkStreamRequestSendingContext, ZlinkStreamReplyReceivedContext, ZlinkStreamMessageKind, ZlinkStreamMetadata, ZlinkStreamRequestCall, ZlinkStreamActor, ZlinkStreamSendCall, ZlinkStreamSequenceCall, ZlinkStreamWaitCall } from '../Contracts';
+import { DefaultZlinkStreamActor } from './ZlinkStreamActors';
 export declare class DefaultZlinkStreamConnector implements ZlinkStreamConnector {
     static readonly heartbeatPingName = "$zlink.heartbeat.ping";
     static readonly heartbeatPongName = "$zlink.heartbeat.pong";
@@ -9,13 +10,19 @@ export declare class DefaultZlinkStreamConnector implements ZlinkStreamConnector
     private readonly pendingRequests;
     private readonly frameSender;
     private readonly receiveDispatcher;
-    private readonly diagnosticsLevelCell;
+    private readonly requestSendingHandlers;
+    private readonly replyReceivedHandlers;
+    private readonly boundActors;
     readonly options: RequiredZlinkStreamConnectorOptions;
     constructor(options: ZlinkStreamConnectorOptions);
     get isConnected(): boolean;
     get closeReason(): import("..").ZlinkStreamCloseReason | undefined;
     get state(): ZlinkStreamConnectionState;
     get pendingDispatchCount(): number;
+    get actors(): readonly ZlinkStreamActor[];
+    actor(actorId: string): ZlinkStreamActor | undefined;
+    onActorBound(handler: (actor: ZlinkStreamActor, signal?: AbortSignal) => Promise<void> | void): Disposable;
+    onActorUnbound(handler: (actor: ZlinkStreamActor, signal?: AbortSignal) => Promise<void> | void): Disposable;
     /**
      * Spec stream-connector 32 §10: how many packets carrying `name` arrived on
      * the current connection. Arrivals are what is counted, so a message a
@@ -24,39 +31,20 @@ export declare class DefaultZlinkStreamConnector implements ZlinkStreamConnector
      * the count to 0, a reconnect included.
      */
     receivedCount(name: string): number;
-    /**
-     * Current diagnostics level (spec 26 §4.1, spec stream-connector 32 §13).
-     * Reflects the level set by the most recent {@link setDiagnosticsLevel}
-     * call, or the construction-time option (default
-     * {@link ZlinkStreamDiagnosticsLevel.Errors}) if it was never changed.
-     */
-    get diagnosticsLevel(): ZlinkStreamDiagnosticsLevel;
-    /**
-     * Changes the diagnostics level in place without recreating the connector
-     * (spec 26 §4.1, spec stream-connector 32 §13). The change is an atomic
-     * state update: it applies to processing points that read the level after
-     * this call returns and is never applied retroactively to frames already
-     * built. Rejects unknown values with {@link ZlinkStreamErrorCode.ConfigurationError}.
-     * Spec stream-connector 32 §13: this surface changes the value without
-     * waiting for anything; it is not a blocking call over the asynchronous pair,
-     * which a receive callback would otherwise make wait for its own completion.
-     */
-    setDiagnosticsLevel(level: ZlinkStreamDiagnosticsLevel): void;
-    /**
-     * Asynchronous counterpart of {@link setDiagnosticsLevel} (spec
-     * stream-connector 32 §13). It changes the same value; awaiting it is how a
-     * caller observes the change, and it never replaces the synchronous surface.
-     */
-    setDiagnosticsLevelAsync(level: ZlinkStreamDiagnosticsLevel): Promise<void>;
     onErrorReceived(handler: (error: ZlinkStreamError, signal?: AbortSignal) => Promise<void> | void): Disposable;
     onDisconnected(handler: (signal?: AbortSignal) => Promise<void> | void): Disposable;
     onConnectionStateChanged(handler: (change: ZlinkStreamConnectionStateChanged, signal?: AbortSignal) => Promise<void> | void): Disposable;
+    onRequestSending(handler: (context: ZlinkStreamRequestSendingContext) => void): Disposable;
+    onReplyReceived(handler: (context: ZlinkStreamReplyReceivedContext, signal?: AbortSignal) => Promise<void> | void): Disposable;
     connect(signal?: AbortSignal): Promise<void>;
     close(signal?: AbortSignal): Promise<void>;
     dispatch(signal?: AbortSignal): Promise<void>;
     send(payload: unknown, messageType?: Function): ZlinkStreamSendCall;
     request(payload: unknown, messageType?: Function): ZlinkStreamRequestCall;
-    on<TPayload = ZlinkStreamEncodedPayload>(name: string, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
+    on<TPayload = ZlinkStreamEncodedPayload>(nameOrType: string | Function, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
+    sendForActor(actor: DefaultZlinkStreamActor, payload: unknown, messageType?: Function): ZlinkStreamSendCall;
+    requestForActor(actor: DefaultZlinkStreamActor, payload: unknown, messageType?: Function): ZlinkStreamRequestCall;
+    onActorMessage<TPayload>(actor: DefaultZlinkStreamActor, nameOrType: string | Function, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
     waitFor<TPayload = ZlinkStreamEncodedPayload>(nameOrType: string | Function): ZlinkStreamWaitCall<TPayload>;
     expectNone<TPayload = ZlinkStreamEncodedPayload>(nameOrType: string | Function): ZlinkStreamExpectNoneCall<TPayload>;
     waitForSequence<TPayload = ZlinkStreamEncodedPayload>(nameOrType: string | Function): ZlinkStreamSequenceCall<TPayload>;
@@ -83,12 +71,13 @@ export declare class DefaultZlinkStreamConnector implements ZlinkStreamConnector
     private encodePayload;
     private decodePayload;
     private decodeWaitPayload;
-    sendEncoded(kind: ZlinkStreamMessageKind, name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, signal?: AbortSignal, flow?: ZlinkStreamFlow, correlationId?: string): Promise<void>;
+    sendEncoded(kind: ZlinkStreamMessageKind, name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, signal?: AbortSignal, correlationId?: string, actorSlot?: number): Promise<void>;
     /**
      * Per-connector monotonic correlation id (hex). The client generates it on each request
-     * and the server echoes it back on the reply, so flows can be joined across the wire.
+     * and the server echoes it back on the reply.
      */
     private nextCorrelationId;
-    requestEncoded(name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, timeoutMs: number, signal?: AbortSignal, flow?: ZlinkStreamFlow): Promise<ZlinkStreamEncodedPayload>;
+    requestEncoded(name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, timeoutMs: number, signal?: AbortSignal, actorSlot?: number): Promise<ZlinkStreamEncodedPayload>;
+    private publishReplyReceived;
     private resolveNameOrDefault;
 }

package/dist/browser/Runtime/ZlinkStreamConnectorLifecycle.d.ts

@@ -6,12 +6,14 @@ import type { ZlinkStreamFrameSender } from './ZlinkStreamFrameSender';
 import type { ZlinkStreamPendingRequests } from './ZlinkStreamPendingRequests';
 import type { ZlinkStreamReceiveDispatcher } from './ZlinkStreamReceiveDispatcher';
 import type { ZlinkStreamReceivedMessages } from './ZlinkStreamReceivedMessages';
+import type { ZlinkStreamActors } from './ZlinkStreamActors';
 export declare class ZlinkStreamConnectorLifecycle {
     private readonly options;
     private readonly pendingRequests;
     private readonly frameSender;
     private readonly receiveDispatcher;
     private readonly receivedMessages;
+    private readonly actors;
     private readonly events;
     private receiveLoopAbort;
     private receiveLoopSleeping;
@@ -30,7 +32,7 @@ export declare class ZlinkStreamConnectorLifecycle {
     private disconnectedPublished;
     private closeReasonValue?;
     private lateConnectCleanupError;
-    constructor(options: RequiredZlinkStreamConnectorOptions, pendingRequests: ZlinkStreamPendingRequests, frameSender: ZlinkStreamFrameSender, receiveDispatcher: ZlinkStreamReceiveDispatcher, receivedMessages: ZlinkStreamReceivedMessages, events: ZlinkStreamConnectorEvents);
+    constructor(options: RequiredZlinkStreamConnectorOptions, pendingRequests: ZlinkStreamPendingRequests, frameSender: ZlinkStreamFrameSender, receiveDispatcher: ZlinkStreamReceiveDispatcher, receivedMessages: ZlinkStreamReceivedMessages, actors: ZlinkStreamActors, events: ZlinkStreamConnectorEvents);
     get isConnected(): boolean;
     get state(): ZlinkStreamConnectionState;
     get closeReason(): ZlinkStreamCloseReason | undefined;
@@ -102,5 +104,9 @@ export declare class ZlinkStreamConnectorLifecycle {
      * reporting the same failure a second time on the error surface.
      */
     private publishDisconnectedWithoutWaiting;
+    private queueDisconnected;
+    private queueState;
     private setState;
+    private transitionState;
+    private publishStateChange;
 }

package/dist/browser/Runtime/ZlinkStreamConnectorOptions.d.ts

@@ -1,4 +1,4 @@
-import { RequiredZlinkStreamConnectorOptions, ZlinkStreamConnectorOptions, ZlinkStreamDiagnosticsLevel, ZlinkStreamPacketNameResolver } from '../Contracts';
+import { RequiredZlinkStreamConnectorOptions, ZlinkStreamConnectorOptions, ZlinkStreamPacketNameResolver } from '../Contracts';
 export declare function normalizeOptions(options: ZlinkStreamConnectorOptions, defaultTransportFactory: RequiredZlinkStreamConnectorOptions['transportFactory']): RequiredZlinkStreamConnectorOptions;
 /**
  * Spec stream-connector 32 §5 and the TypeScript projection §4: a payload type
@@ -14,4 +14,3 @@ export declare function normalizeOptions(options: ZlinkStreamConnectorOptions, d
  * bundle keeps class names.
  */
 export declare const defaultPacketNameResolver: ZlinkStreamPacketNameResolver;
-export declare function validateDiagnosticsLevel(level: ZlinkStreamDiagnosticsLevel | undefined): void;

package/dist/browser/Runtime/ZlinkStreamFrameSender.d.ts

@@ -1,12 +1,10 @@
-import type { ZlinkStreamConnection, ZlinkStreamEncodedPayload, ZlinkStreamFlow, ZlinkStreamMetadata, ZlinkStreamMessageKind } from '../Contracts';
+import type { ZlinkStreamConnection, ZlinkStreamEncodedPayload, ZlinkStreamMetadata, ZlinkStreamMessageKind } from '../Contracts';
 import type { ZlinkStreamFrameProtocol } from './Protocol/ZlinkStreamFrameProtocol';
-import type { ZlinkFlowContext } from './ZlinkFlowContext';
 export declare class ZlinkStreamFrameSender {
     private readonly protocol;
-    private readonly flowContext;
     private readonly pendingWrites;
-    constructor(protocol: ZlinkStreamFrameProtocol, flowContext: ZlinkFlowContext);
-    send(connection: ZlinkStreamConnection, kind: ZlinkStreamMessageKind, name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, signal?: AbortSignal, correlationId?: string, explicitFlow?: ZlinkStreamFlow): Promise<void>;
+    constructor(protocol: ZlinkStreamFrameProtocol);
+    send(connection: ZlinkStreamConnection, kind: ZlinkStreamMessageKind, name: string, payload: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata, compress: boolean, requestSeq: bigint | undefined, signal?: AbortSignal, correlationId?: string, actorSlot?: number): Promise<void>;
     sendControl(connection: ZlinkStreamConnection, name: string, signal?: AbortSignal): Promise<void>;
     drain(signal?: AbortSignal): Promise<void>;
     private write;

package/dist/browser/Runtime/ZlinkStreamPendingRequests.d.ts

@@ -1,14 +1,14 @@
-import { ZlinkStreamEncodedPayload, ZlinkStreamError } from '../Contracts';
+import { ZlinkStreamEncodedPayload, ZlinkStreamError, ZlinkStreamMessage, ZlinkStreamMetadata } from '../Contracts';
 export interface PendingZlinkStreamRequest {
     readonly requestSeq: bigint;
-    readonly promise: Promise<ZlinkStreamEncodedPayload>;
+    readonly promise: Promise<ZlinkStreamMessage<ZlinkStreamEncodedPayload>>;
 }
 export declare class ZlinkStreamPendingRequests {
     private nextRequestSeq;
     private readonly active;
     get count(): number;
     create(packetName: string, timeoutMs: number): PendingZlinkStreamRequest;
-    resolve(requestSeq: bigint, value: ZlinkStreamEncodedPayload): boolean;
+    resolve(requestSeq: bigint, value: ZlinkStreamEncodedPayload, metadata: ZlinkStreamMetadata): boolean;
     reject(requestSeq: bigint, error: ZlinkStreamError): boolean;
     cancel(requestSeq: bigint): void;
     failAll(error: ZlinkStreamError): void;

package/dist/browser/Runtime/ZlinkStreamReceiveDispatcher.d.ts

@@ -4,8 +4,8 @@ import type { ZlinkStreamConnectorEvents } from './ZlinkStreamConnectorEvents';
 import type { ZlinkStreamFrameSender } from './ZlinkStreamFrameSender';
 import type { ZlinkStreamPendingRequests } from './ZlinkStreamPendingRequests';
 import type { ZlinkStreamReceivedMessages } from './ZlinkStreamReceivedMessages';
-import type { ZlinkFlowContext } from './ZlinkFlowContext';
 import type { ZlinkStreamCloseReason } from '../Contracts';
+import { type ZlinkStreamActors } from './ZlinkStreamActors';
 export interface ZlinkStreamReceiveResult {
     readonly available: boolean;
     readonly inbound: boolean;
@@ -16,9 +16,9 @@ export declare class ZlinkStreamReceiveDispatcher {
     private readonly receivedMessages;
     private readonly frameSender;
     private readonly events;
-    private readonly flowContext;
+    private readonly actors;
     private readonly serverClosing?;
-    constructor(protocol: ZlinkStreamFrameProtocol, pendingRequests: ZlinkStreamPendingRequests, receivedMessages: ZlinkStreamReceivedMessages, frameSender: ZlinkStreamFrameSender, events: ZlinkStreamConnectorEvents, flowContext: ZlinkFlowContext, serverClosing?: ((reason: ZlinkStreamCloseReason) => Promise<void>) | undefined);
+    constructor(protocol: ZlinkStreamFrameProtocol, pendingRequests: ZlinkStreamPendingRequests, receivedMessages: ZlinkStreamReceivedMessages, frameSender: ZlinkStreamFrameSender, events: ZlinkStreamConnectorEvents, actors: ZlinkStreamActors, serverClosing?: ((reason: ZlinkStreamCloseReason) => Promise<void>) | undefined);
     /**
      * @param isCurrent Tells whether the connection this batch was read from is
      *   still the connector's connection. It is asked again at the head of every

package/dist/browser/Runtime/ZlinkStreamReceivedMessages.d.ts

@@ -74,6 +74,7 @@ export declare class ZlinkStreamReceivedMessages {
      */
     connectionEnded(): void;
     enqueue(message: ZlinkStreamMessage<ZlinkStreamEncodedPayload>, signal?: AbortSignal): void;
+    enqueueCallback(callback: () => Promise<void> | void): void;
     /**
      * Runs the registered handlers the receive path left queued. `Manual` calls
      * this from `dispatch`; `Immediate` has already drained on arrival.