@zlink-systems/stream-connector 0.26.0 → 0.28.0

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

@@ -1,5 +1,6 @@
 import type { ZlinkStreamCompression, ZlinkStreamDispatchMode, ZlinkStreamTransport } from './ZlinkStreamEnums';
 import type { ZlinkStreamEncodedPayload } from './ZlinkStreamModels';
+export declare const ZLINK_STREAM_DEFAULT_PAYLOAD_BYTES: number;
 export interface ZlinkStreamConnectorOptions {
     readonly endpoint: string;
     readonly codec?: ZlinkStreamPayloadCodec;

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

@@ -1,3 +1,4 @@
+export { ZlinkStreamMessageKind, ZlinkStreamHeaderFlags } from '@zlink-systems/stream-wire';
 export declare enum ZlinkStreamTransport {
     WebSocket = "webSocket",
     WebSocketSecure = "webSocketSecure"
@@ -11,23 +12,7 @@ export declare enum ZlinkStreamDispatchMode {
     Manual = "manual",
     Immediate = "immediate"
 }
-export declare enum ZlinkStreamMessageKind {
-    Send = 1,
-    Request = 2,
-    Response = 3,
-    Error = 4,
-    Control = 5
-}
-export declare enum ZlinkStreamHeaderFlags {
-    None = 0,
-    HasRequestSeq = 1,
-    HasMetadata = 2,
-    PayloadCompressed = 4,
-    HasCorrelationId = 8,
-    HasFlowId = 16,
-    HasActorSlot = 32
-}
-export type ZlinkStreamCloseReason = 'ClientClose' | 'IdleTimeout' | 'HeartbeatTimeout' | 'ServerDrain' | 'ProtocolError' | 'TransportError';
+export type { ZlinkStreamCloseReason } from '@zlink-systems/stream-wire';
 export declare enum ZlinkStreamErrorCode {
     Disconnected = "disconnected",
     ConfigurationError = "configurationError",
@@ -39,6 +24,7 @@ export declare enum ZlinkStreamErrorCode {
     SendFailed = "sendFailed",
     CompressionFailed = "compressionFailed",
     DecompressionFailed = "decompressionFailed",
+    TlsValidationFailed = "tlsValidationFailed",
     UserCallbackFailed = "userCallbackFailed",
     RemoteError = "remoteError"
 }

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

@@ -1,6 +1,6 @@
 export { ZlinkStreamTransport, ZlinkStreamCodec, ZlinkStreamCompression, ZlinkStreamDispatchMode, ZlinkStreamMessageKind, ZlinkStreamHeaderFlags, ZlinkStreamErrorCode, ZlinkStreamConnectionState } from './ZlinkStreamEnums';
 export type { ZlinkStreamCloseReason } from './ZlinkStreamEnums';
-export * from './ZlinkStreamConnectorOptions';
+export type { ZlinkStreamConnectorOptions, ZlinkStreamHeartbeatOptions, ZlinkStreamReconnectOptions, ZlinkStreamPacketNameResolver, ZlinkStreamPayloadCodec, ZlinkStreamCompressionCodec, ZlinkStreamTransportFactory, ZlinkStreamConnection, RequiredZlinkStreamConnectorOptions } from './ZlinkStreamConnectorOptions';
 export * from './ZlinkStreamInterfaces';
 export * from './ZlinkStreamMetadata';
 export type { ZlinkStreamEncodedPayload, ZlinkStreamMessage, ZlinkStreamRequestSendingContext, ZlinkStreamReplyReceivedContext, ZlinkStreamError, ZlinkStreamConnectionStateChanged, ZlinkStreamResult, ZlinkStreamResultOf } from './ZlinkStreamModels';

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

@@ -1,7 +1,2 @@
-import type { ZlinkStreamCloseReason } from '../../Contracts';
-export declare const ZLINK_SESSION_CLOSING = "session-closing";
-export declare function decodeSessionClosing(payload: Uint8Array): {
-    readonly closeReason: ZlinkStreamCloseReason;
-    readonly diagnostic?: string;
-};
-export declare function encodeSessionClosing(reason: ZlinkStreamCloseReason, diagnostic?: string): Uint8Array;
+export { decodeStreamWireSessionClosing as decodeSessionClosing } from '@zlink-systems/stream-wire';
+export declare const ZLINK_SESSION_CLOSING: "session-closing";

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

@@ -1,8 +1,7 @@
-import type { RequiredZlinkStreamConnectorOptions, ZlinkStreamEncodedPayload, ZlinkStreamMetadata } from '../../Contracts';
-import { ZlinkStreamMessageKind } from '../../Contracts';
+import { type RequiredZlinkStreamConnectorOptions, type ZlinkStreamEncodedPayload, type ZlinkStreamMetadata, ZlinkStreamMessageKind } from '../../Contracts';
 import type { ZlinkStreamHeader } from '../../Contracts/ZlinkStreamModels';
-export declare const ZLINK_STREAM_HEARTBEAT_PING = "$zlink.heartbeat.ping";
-export declare const ZLINK_STREAM_HEARTBEAT_PONG = "$zlink.heartbeat.pong";
+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);

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

@@ -1,7 +1,5 @@
 import { ZlinkStreamMetadata } from '../../Contracts';
-export declare const ZLINK_STREAM_MAX_METADATA_BYTES = 1024;
+export { ZLINK_STREAM_MAX_METADATA_BYTES } from '@zlink-systems/stream-wire';
 export declare class ZlinkStreamMetadataCodec {
     static size(metadata: ZlinkStreamMetadata): number;
-    static write(metadata: ZlinkStreamMetadata, destination: Uint8Array): void;
-    static decode(metadata: Uint8Array): ZlinkStreamMetadata;
 }

package/dist/browser/Runtime/Transport/BrowserWebSocketConnection.d.ts

@@ -1,5 +1,4 @@
-import { ZlinkStreamConnection, ZlinkStreamTransportFactory } from '../../Contracts';
-import type { RequiredZlinkStreamConnectorOptions } from '../../Contracts';
+import { type RequiredZlinkStreamConnectorOptions, ZlinkStreamConnection, ZlinkStreamTransportFactory } from '../../Contracts';
 interface BrowserWebSocketEventMap {
     open: unknown;
     close: unknown;

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

@@ -1,6 +1,6 @@
-import type { Disposable, ZlinkStreamActor, ZlinkStreamEncodedPayload, ZlinkStreamMessage, ZlinkStreamRequestCall, ZlinkStreamSendCall } from '../Contracts';
-import type { ZlinkStreamReceivedMessages } from './ZlinkStreamReceivedMessages';
+import { type Disposable, type ZlinkStreamActor, type ZlinkStreamEncodedPayload, type ZlinkStreamMessage, type ZlinkStreamRequestCall, type ZlinkStreamSendCall } from '../Contracts';
 import type { ZlinkStreamConnectorEvents } from './ZlinkStreamConnectorEvents';
+import type { ZlinkStreamReceivedMessages } from './ZlinkStreamReceivedMessages';
 export declare const zlinkStreamActorBinding: unique symbol;
 interface ActorConnector {
     sendForActor(actor: DefaultZlinkStreamActor, payload: unknown, messageType?: Function): ZlinkStreamSendCall;
@@ -26,7 +26,6 @@ export declare class ZlinkStreamActors {
     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);

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

@@ -1,8 +1,8 @@
 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";
+    static readonly heartbeatPingName: "$zlink.heartbeat.ping";
+    static readonly heartbeatPongName: "$zlink.heartbeat.pong";
     private readonly receivedMessages;
     private readonly lifecycle;
     private readonly events;
@@ -16,7 +16,7 @@ export declare class DefaultZlinkStreamConnector implements ZlinkStreamConnector
     readonly options: RequiredZlinkStreamConnectorOptions;
     constructor(options: ZlinkStreamConnectorOptions);
     get isConnected(): boolean;
-    get closeReason(): import("..").ZlinkStreamCloseReason | undefined;
+    get closeReason(): "ClientClose" | "IdleTimeout" | "HeartbeatTimeout" | "ServerDrain" | "ProtocolError" | "TransportError" | undefined;
     get state(): ZlinkStreamConnectionState;
     get pendingDispatchCount(): number;
     get actors(): readonly ZlinkStreamActor[];

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

@@ -1,12 +1,10 @@
-import type { RequiredZlinkStreamConnectorOptions, ZlinkStreamConnection } from '../Contracts';
-import { ZlinkStreamConnectionState } from '../Contracts';
-import type { ZlinkStreamCloseReason } from '../Contracts';
+import { type RequiredZlinkStreamConnectorOptions, type ZlinkStreamCloseReason, type ZlinkStreamConnection, ZlinkStreamConnectionState } from '../Contracts';
+import type { ZlinkStreamActors } from './ZlinkStreamActors';
 import type { ZlinkStreamConnectorEvents } from './ZlinkStreamConnectorEvents';
 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;
@@ -32,7 +30,6 @@ export declare class ZlinkStreamConnectorLifecycle {
     private closeRequested;
     private disconnectedPublished;
     private closeReasonValue?;
-    private lateConnectCleanupError;
     constructor(options: RequiredZlinkStreamConnectorOptions, pendingRequests: ZlinkStreamPendingRequests, frameSender: ZlinkStreamFrameSender, receiveDispatcher: ZlinkStreamReceiveDispatcher, receivedMessages: ZlinkStreamReceivedMessages, actors: ZlinkStreamActors, events: ZlinkStreamConnectorEvents);
     get isConnected(): boolean;
     get state(): ZlinkStreamConnectionState;
@@ -87,13 +84,14 @@ export declare class ZlinkStreamConnectorLifecycle {
     private isCurrentConnection;
     /**
      * Ends the current connection, for close and for transport loss alike. No
-     * application callback runs from here. Spec stream-connector 32 §7 and §9:
+     * application callback runs before terminal operations settle. Spec stream-connector 32 §7 and §9:
      * every operation the ending connection fails (the frames it has not
      * written, the one it is writing and the pending requests) fails with
      * `Disconnected`, whatever ended it; the cause stays in the close reason.
      * The transport is closed without waiting for the frames.
      */
     private tearDownConnection;
+    private closeTransport;
     /**
      * Runs once the teardown promise has settled, so a handler reached from here
      * may call `connect` without waiting for a task its own caller still holds.

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

@@ -1,4 +1,5 @@
 import { RequiredZlinkStreamConnectorOptions, ZlinkStreamConnectorOptions, ZlinkStreamPacketNameResolver } from '../Contracts';
+export { ZLINK_STREAM_DEFAULT_PAYLOAD_BYTES as ZLINK_STREAM_DEFAULT_PAYLOAD_SIZE } from '../Contracts/ZlinkStreamConnectorOptions';
 export declare function normalizeOptions(options: ZlinkStreamConnectorOptions, defaultTransportFactory: RequiredZlinkStreamConnectorOptions['transportFactory']): RequiredZlinkStreamConnectorOptions;
 /**
  * Spec stream-connector 32 §5 and the TypeScript projection §4: a payload type

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

@@ -1,5 +1,6 @@
 import { Disposable, ZlinkStreamEncodedPayload, ZlinkStreamMessage } from '../Contracts';
 import type { ZlinkStreamConnectorEvents } from './ZlinkStreamConnectorEvents';
+import { type DefaultZlinkStreamActor } from './ZlinkStreamActors';
 type EncodedMessageHandler = (message: ZlinkStreamMessage<ZlinkStreamEncodedPayload>, signal?: AbortSignal) => Promise<void> | void;
 /**
  * A wait surface (`waitFor`, `expectNone`, `waitForSequence`) reading the queue
@@ -29,7 +30,7 @@ export declare class ZlinkStreamReceivedMessages {
      * @param actor The Actor handle that registers the handler, if any. Its
      *   handler receives only that Actor's packets.
      */
-    on(name: string, handler: EncodedMessageHandler, actor?: object): Disposable;
+    on(name: string, handler: EncodedMessageHandler, actor?: DefaultZlinkStreamActor): Disposable;
     /**
      * Registers a wait surface over the receive queue. Spec stream-connector 32
      * §7: these are not registered callbacks — they observe and consume the

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

@@ -1,16 +1,17 @@
 import { Disposable, ZlinkStreamError, ZlinkStreamErrorCode, ZlinkStreamException } from '../Contracts';
+/** Returns whether the consumed prefix should compact the backing array. */
+export declare function shouldCompactBackingArray(head: number, length: number): boolean;
 export declare function connectorError(code: ZlinkStreamErrorCode, message: string, cause?: unknown): ZlinkStreamException;
 export declare function toStreamError(cause: unknown, code: ZlinkStreamErrorCode, message: string): ZlinkStreamError;
 export declare function unwrapStreamError(error: unknown): ZlinkStreamError;
 export declare function subscription(dispose: () => void): Disposable;
+/** Snapshot order is preserved; membership owns each registration's lifetime. */
+export declare function currentRegistrations<T>(registrations: ReadonlySet<T>, snapshot?: readonly T[]): IterableIterator<T>;
+export interface HandlerRegistration<T> {
+    readonly handler: T;
+}
+export declare function registerHandler<T>(handlers: Set<HandlerRegistration<T>>, handler: T): Disposable;
 export declare function throwIfAborted(signal: AbortSignal | undefined): void;
 export declare function delay(delayMs: number, signal: AbortSignal | undefined): Promise<void>;
-export declare function readLength(source: Uint8Array, offset: number, bytes: 1 | 2, label: string): number;
-export declare function writeUInt16BE(destination: Uint8Array, offset: number, value: number): void;
-export declare function writeUInt32BE(destination: Uint8Array, offset: number, value: number): void;
-export declare function readUInt16BE(source: Uint8Array, offset: number): number;
-export declare function readUInt32BE(source: Uint8Array, offset: number): number;
-export declare function writeBigUInt64BE(destination: Uint8Array, offset: number, value: bigint): void;
-export declare function readBigUInt64BE(source: Uint8Array, offset: number): bigint;
 export declare function utf8Encode(value: string): Uint8Array;
 export declare function utf8Decode(value: Uint8Array): string;