@zlink-systems/stream-connector 0.13.0 → 0.14.0

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

@@ -1,7 +1,7 @@
 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, ZlinkStreamInboundObservation, ZlinkStreamMessage } from './ZlinkStreamModels';
+import type { ZlinkStreamConnectionStateChanged, ZlinkStreamEncodedPayload, ZlinkStreamError, ZlinkStreamMessage } from './ZlinkStreamModels';
 import type { ZlinkStreamCloseReason, ZlinkStreamConnectionState, ZlinkStreamDiagnosticsLevel } from './ZlinkStreamEnums';
 export interface ZlinkStreamConnector {
     readonly isConnected: boolean;
@@ -30,7 +30,6 @@ export interface ZlinkStreamConnector {
     dispatch(signal?: AbortSignal): Promise<void>;
     send(payload: unknown, messageType?: Function): ZlinkStreamSendCall;
     request(payload: unknown, messageType?: Function): ZlinkStreamRequestCall;
-    observeInbound(observer: (observation: ZlinkStreamInboundObservation, signal?: AbortSignal) => Promise<void> | void): Disposable;
     on<TPayload = ZlinkStreamEncodedPayload>(name: string, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
     waitFor<TPayload = ZlinkStreamEncodedPayload>(name: string): ZlinkStreamWaitCall<TPayload>;
     expectNone<TPayload = ZlinkStreamEncodedPayload>(name: string): ZlinkStreamExpectNoneCall<TPayload>;

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

@@ -12,9 +12,6 @@ export interface ZlinkStreamConnectorOptions {
     readonly reconnect?: ZlinkStreamReconnectOptions;
     readonly maxSendPayloadSize?: number;
     readonly maxReceivePayloadSize?: number;
-    readonly maxReceivedMessages?: number;
-    readonly maxInboundObserverNotifications?: number;
-    readonly maxInboundObserverPayloadPreviewBytes?: number;
     readonly dispatchMode?: ZlinkStreamDispatchMode;
     readonly compression?: ZlinkStreamCompression;
     readonly compressionCodec?: ZlinkStreamCompressionCodec;
@@ -85,9 +82,6 @@ export interface RequiredZlinkStreamConnectorOptions {
     readonly reconnect: Required<ZlinkStreamReconnectOptions>;
     readonly maxSendPayloadSize: number;
     readonly maxReceivePayloadSize: number;
-    readonly maxReceivedMessages: number;
-    readonly maxInboundObserverNotifications: number;
-    readonly maxInboundObserverPayloadPreviewBytes: number;
     readonly dispatchMode: ZlinkStreamDispatchMode;
     readonly compression: ZlinkStreamCompression;
     readonly compressionCodec?: ZlinkStreamCompressionCodec;

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

@@ -54,9 +54,6 @@ export declare enum ZlinkStreamErrorCode {
     CompressionFailed = "compressionFailed",
     DecompressionFailed = "decompressionFailed",
     UserCallbackFailed = "userCallbackFailed",
-    ObserverFailed = "observer-failed",
-    ObserverDropped = "observer-dropped",
-    ReceivedMessageDropped = "received-message-dropped",
     RemoteError = "remoteError"
 }
 export declare enum ZlinkStreamConnectionState {

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

@@ -42,19 +42,6 @@ export interface ZlinkStreamConnectionStateChanged {
     readonly current: ZlinkStreamConnectionState;
     readonly error?: ZlinkStreamError;
 }
-export interface ZlinkStreamInboundObservation {
-    readonly kind: ZlinkStreamMessageKind;
-    readonly name: string;
-    readonly codec: ZlinkStreamCodec;
-    readonly requestSeq?: bigint;
-    readonly flowId?: string;
-    readonly flowOrigin?: ZlinkFlowOrigin;
-    readonly metadata: ZlinkStreamMetadata;
-    readonly payloadLength: number;
-    readonly isCompressed: boolean;
-    readonly receivedAt: Date;
-    readonly payloadPreview: Uint8Array;
-}
 export interface ZlinkStreamResult {
     readonly isSuccess: boolean;
     readonly error?: ZlinkStreamError;

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

@@ -3,7 +3,7 @@ export type { ZlinkFlowOrigin, ZlinkStreamCloseReason } from './ZlinkStreamEnums
 export * from './ZlinkStreamConnectorOptions';
 export * from './ZlinkStreamInterfaces';
 export * from './ZlinkStreamMetadata';
-export type { ZlinkStreamEncodedPayload, ZlinkStreamFlow, ZlinkStreamMessage, ZlinkStreamError, ZlinkStreamConnectionStateChanged, ZlinkStreamInboundObservation, ZlinkStreamResult, ZlinkStreamResultOf } from './ZlinkStreamModels';
+export type { ZlinkStreamEncodedPayload, ZlinkStreamFlow, ZlinkStreamMessage, ZlinkStreamError, ZlinkStreamConnectionStateChanged, ZlinkStreamResult, ZlinkStreamResultOf } from './ZlinkStreamModels';
 export { ZlinkStreamException } from './ZlinkStreamModels';
 export * from './ZlinkStreamJsonCodec';
 export * from './IZlinkStreamConnector';

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

@@ -1,4 +1,4 @@
-import { Disposable, RequiredZlinkStreamConnectorOptions, ZlinkStreamConnectionState, ZlinkStreamConnectionStateChanged, ZlinkStreamConnector, ZlinkStreamConnectorOptions, ZlinkStreamDiagnosticsLevel, ZlinkStreamEncodedPayload, ZlinkStreamError, ZlinkStreamExpectNoneCall, ZlinkStreamFlow, ZlinkStreamInboundObservation, ZlinkStreamMessage, ZlinkStreamMessageKind, ZlinkStreamMetadata, ZlinkStreamRequestCall, ZlinkStreamSendCall, ZlinkStreamSequenceCall, ZlinkStreamWaitCall } from '../Contracts';
+import { Disposable, RequiredZlinkStreamConnectorOptions, ZlinkStreamConnectionState, ZlinkStreamConnectionStateChanged, ZlinkStreamConnector, ZlinkStreamConnectorOptions, ZlinkStreamDiagnosticsLevel, ZlinkStreamEncodedPayload, ZlinkStreamError, ZlinkStreamExpectNoneCall, ZlinkStreamFlow, ZlinkStreamMessage, ZlinkStreamMessageKind, ZlinkStreamMetadata, ZlinkStreamRequestCall, ZlinkStreamSendCall, ZlinkStreamSequenceCall, ZlinkStreamWaitCall } from '../Contracts';
 export declare class DefaultZlinkStreamConnector implements ZlinkStreamConnector {
     static readonly heartbeatPingName = "$zlink.heartbeat.ping";
     static readonly heartbeatPongName = "$zlink.heartbeat.pong";
@@ -9,7 +9,6 @@ export declare class DefaultZlinkStreamConnector implements ZlinkStreamConnector
     private readonly pendingRequests;
     private readonly frameSender;
     private readonly receiveDispatcher;
-    private readonly inboundObservers;
     private readonly diagnosticsLevelCell;
     readonly options: RequiredZlinkStreamConnectorOptions;
     constructor(options: ZlinkStreamConnectorOptions);
@@ -43,7 +42,6 @@ export declare class DefaultZlinkStreamConnector implements ZlinkStreamConnector
     dispatch(signal?: AbortSignal): Promise<void>;
     send(payload: unknown, messageType?: Function): ZlinkStreamSendCall;
     request(payload: unknown, messageType?: Function): ZlinkStreamRequestCall;
-    observeInbound(observer: (observation: ZlinkStreamInboundObservation, signal?: AbortSignal) => Promise<void> | void): Disposable;
     on<TPayload = ZlinkStreamEncodedPayload>(name: string, handler: (message: ZlinkStreamMessage<TPayload>, signal?: AbortSignal) => Promise<void> | void, messageType?: Function): Disposable;
     waitFor<TPayload = ZlinkStreamEncodedPayload>(name: string): ZlinkStreamWaitCall<TPayload>;
     expectNone<TPayload = ZlinkStreamEncodedPayload>(name: string): ZlinkStreamExpectNoneCall<TPayload>;

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

@@ -2,7 +2,6 @@ import type { ZlinkStreamConnection } from '../Contracts';
 import type { ZlinkStreamFrameProtocol } from './Protocol/ZlinkStreamFrameProtocol';
 import type { ZlinkStreamConnectorEvents } from './ZlinkStreamConnectorEvents';
 import type { ZlinkStreamFrameSender } from './ZlinkStreamFrameSender';
-import type { ZlinkStreamInboundObservers } from './ZlinkStreamInboundObservers';
 import type { ZlinkStreamPendingRequests } from './ZlinkStreamPendingRequests';
 import type { ZlinkStreamReceivedMessages } from './ZlinkStreamReceivedMessages';
 import type { ZlinkFlowContext } from './ZlinkFlowContext';
@@ -15,14 +14,13 @@ export interface ZlinkStreamReceiveResult {
 export declare class ZlinkStreamReceiveDispatcher {
     private readonly protocol;
     private readonly pendingRequests;
-    private readonly inboundObservers;
     private readonly receivedMessages;
     private readonly frameSender;
     private readonly events;
     private readonly flowContext;
     private readonly metrics;
     private readonly serverClosing?;
-    constructor(protocol: ZlinkStreamFrameProtocol, pendingRequests: ZlinkStreamPendingRequests, inboundObservers: ZlinkStreamInboundObservers, receivedMessages: ZlinkStreamReceivedMessages, frameSender: ZlinkStreamFrameSender, events: ZlinkStreamConnectorEvents, flowContext: ZlinkFlowContext, metrics: ZlinkStreamRuntimeMetrics, serverClosing?: ((reason: ZlinkStreamCloseReason) => Promise<void>) | undefined);
+    constructor(protocol: ZlinkStreamFrameProtocol, pendingRequests: ZlinkStreamPendingRequests, receivedMessages: ZlinkStreamReceivedMessages, frameSender: ZlinkStreamFrameSender, events: ZlinkStreamConnectorEvents, flowContext: ZlinkFlowContext, metrics: ZlinkStreamRuntimeMetrics, serverClosing?: ((reason: ZlinkStreamCloseReason) => Promise<void>) | undefined);
     readAndDispatch(connection: ZlinkStreamConnection | undefined, signal?: AbortSignal, isCurrent?: () => boolean): Promise<ZlinkStreamReceiveResult>;
     private dispatch;
     private dispatchControl;

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

@@ -2,15 +2,13 @@ import { Disposable, ZlinkStreamEncodedPayload, ZlinkStreamMessage } from '../Co
 import type { ZlinkStreamConnectorEvents } from './ZlinkStreamConnectorEvents';
 type EncodedMessageHandler = (message: ZlinkStreamMessage<ZlinkStreamEncodedPayload>, signal?: AbortSignal) => Promise<void> | void;
 export declare class ZlinkStreamReceivedMessages {
-    private readonly capacity;
     private readonly events;
     private readonly handlers;
     private readonly queue;
     private queueHead;
     private queuedCount;
     private drainTask;
-    private dropReportPending;
-    constructor(capacity: number, events: ZlinkStreamConnectorEvents);
+    constructor(events: ZlinkStreamConnectorEvents);
     on(name: string, handler: EncodedMessageHandler): Disposable;
     enqueue(message: ZlinkStreamMessage<ZlinkStreamEncodedPayload>, signal?: AbortSignal): void;
     private scheduleDrain;
@@ -19,6 +17,5 @@ export declare class ZlinkStreamReceivedMessages {
     private hasQueuedMessage;
     private advanceHead;
     private compactQueue;
-    private reportDropped;
 }
 export {};

package/dist/browser/index.mjs

@@ -497,20 +497,17 @@ var ZlinkStreamErrorCode = /* @__PURE__ */ ((ZlinkStreamErrorCode2) => {
   ZlinkStreamErrorCode2["CompressionFailed"] = "compressionFailed";
   ZlinkStreamErrorCode2["DecompressionFailed"] = "decompressionFailed";
   ZlinkStreamErrorCode2["UserCallbackFailed"] = "userCallbackFailed";
-  ZlinkStreamErrorCode2["ObserverFailed"] = "observer-failed";
-  ZlinkStreamErrorCode2["ObserverDropped"] = "observer-dropped";
-  ZlinkStreamErrorCode2["ReceivedMessageDropped"] = "received-message-dropped";
   ZlinkStreamErrorCode2["RemoteError"] = "remoteError";
   return ZlinkStreamErrorCode2;
 })(ZlinkStreamErrorCode || {});
-var ZlinkStreamConnectionState = /* @__PURE__ */ ((ZlinkStreamConnectionState2) => {
-  ZlinkStreamConnectionState2["Created"] = "created";
-  ZlinkStreamConnectionState2["Connecting"] = "connecting";
-  ZlinkStreamConnectionState2["Connected"] = "connected";
-  ZlinkStreamConnectionState2["Reconnecting"] = "reconnecting";
-  ZlinkStreamConnectionState2["Disconnected"] = "disconnected";
-  ZlinkStreamConnectionState2["Closed"] = "closed";
-  return ZlinkStreamConnectionState2;
+var ZlinkStreamConnectionState = /* @__PURE__ */ ((ZlinkStreamConnectionState3) => {
+  ZlinkStreamConnectionState3["Created"] = "created";
+  ZlinkStreamConnectionState3["Connecting"] = "connecting";
+  ZlinkStreamConnectionState3["Connected"] = "connected";
+  ZlinkStreamConnectionState3["Reconnecting"] = "reconnecting";
+  ZlinkStreamConnectionState3["Disconnected"] = "disconnected";
+  ZlinkStreamConnectionState3["Closed"] = "closed";
+  return ZlinkStreamConnectionState3;
 })(ZlinkStreamConnectionState || {});
 
 // packages/stream-connector/src/Contracts/ZlinkStreamMetadata.ts
@@ -1284,11 +1281,6 @@ function normalizeOptions(options, defaultTransportFactory) {
   validatePositive(options.waitTimeoutMs ?? 5e3, "WaitTimeout");
   validatePositive(options.maxSendPayloadSize ?? 64 * 1024, "MaxSendPayloadSize");
   validatePositive(options.maxReceivePayloadSize ?? 64 * 1024, "MaxReceivePayloadSize");
-  validatePositive(options.maxReceivedMessages ?? 1024, "MaxReceivedMessages");
-  validatePositive(options.maxInboundObserverNotifications ?? 1024, "MaxInboundObserverNotifications");
-  if ((options.maxInboundObserverPayloadPreviewBytes ?? 0) < 0) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "MaxInboundObserverPayloadPreviewBytes must not be negative.");
-  }
   validateHeartbeat(options.heartbeat);
   validateReconnect(options.reconnect);
   validateDiagnosticsLevel(options.diagnosticsLevel);
@@ -1312,9 +1304,6 @@ function normalizeOptions(options, defaultTransportFactory) {
     },
     maxSendPayloadSize: options.maxSendPayloadSize ?? 64 * 1024,
     maxReceivePayloadSize: options.maxReceivePayloadSize ?? 64 * 1024,
-    maxReceivedMessages: options.maxReceivedMessages ?? 1024,
-    maxInboundObserverNotifications: options.maxInboundObserverNotifications ?? 1024,
-    maxInboundObserverPayloadPreviewBytes: options.maxInboundObserverPayloadPreviewBytes ?? 0,
     dispatchMode: options.dispatchMode ?? "manual" /* Manual */,
     compression: options.compression ?? "lz4" /* Lz4 */,
     compressionCodec: resolveCompressionCodec2(options),
@@ -1475,8 +1464,7 @@ var ZlinkStreamPendingRequests = class {
 
 // packages/stream-connector/src/Runtime/ZlinkStreamReceivedMessages.ts
 var ZlinkStreamReceivedMessages = class {
-  constructor(capacity, events) {
-    this.capacity = capacity;
+  constructor(events) {
     this.events = events;
   }
   handlers = /* @__PURE__ */ new Map();
@@ -1487,7 +1475,6 @@ var ZlinkStreamReceivedMessages = class {
   queueHead = 0;
   queuedCount = 0;
   drainTask;
-  dropReportPending = false;
   on(name, handler) {
     validateName(name);
     let set = this.handlers.get(name);
@@ -1507,10 +1494,6 @@ var ZlinkStreamReceivedMessages = class {
     });
   }
   enqueue(message, signal) {
-    if (this.queuedCount >= this.capacity) {
-      this.reportDropped(signal);
-      return;
-    }
     this.queue.push({ message, signal });
     this.queuedCount += 1;
     this.scheduleDrain();
@@ -1580,144 +1563,6 @@ var ZlinkStreamReceivedMessages = class {
       this.queueHead = 0;
     }
   }
-  reportDropped(signal) {
-    if (this.dropReportPending) {
-      return;
-    }
-    this.dropReportPending = true;
-    queueMicrotask(() => {
-      void this.events.publishError({
-        code: "received-message-dropped" /* ReceivedMessageDropped */,
-        message: "Received stream message was dropped because the received-message queue is full."
-      }, signal).finally(() => {
-        this.dropReportPending = false;
-      }).catch(() => {
-      });
-    });
-  }
-};
-
-// packages/stream-connector/src/Runtime/ZlinkStreamInboundObservers.ts
-var ZlinkStreamInboundObservers = class {
-  constructor(maxNotifications, maxPayloadPreviewBytes, events) {
-    this.maxNotifications = maxNotifications;
-    this.maxPayloadPreviewBytes = maxPayloadPreviewBytes;
-    this.events = events;
-  }
-  observers = /* @__PURE__ */ new Set();
-  queue = [];
-  queueHead = 0;
-  queuedCount = 0;
-  draining = false;
-  dropReportPending = false;
-  add(observer) {
-    this.observers.add(observer);
-    return subscription(() => this.observers.delete(observer));
-  }
-  enqueue(header, payload, signal) {
-    if (this.observers.size === 0) {
-      return;
-    }
-    if (this.queuedCount >= this.maxNotifications) {
-      this.reportDropped(signal);
-      return;
-    }
-    this.queue.push(this.createObservation(header, payload));
-    this.queuedCount += 1;
-    this.scheduleDrain(signal);
-  }
-  createObservation(header, payload) {
-    const previewLength = Math.min(this.maxPayloadPreviewBytes, payload.length);
-    return Object.freeze({
-      kind: header.kind,
-      name: header.name,
-      codec: header.codec,
-      requestSeq: header.requestSeq,
-      flowId: header.flowId,
-      flowOrigin: header.flowOrigin,
-      metadata: ZlinkStreamMetadataMap.from(header.metadata.values),
-      payloadLength: payload.length,
-      isCompressed: (header.flags & 4 /* PayloadCompressed */) !== 0,
-      receivedAt: /* @__PURE__ */ new Date(),
-      payloadPreview: previewLength === 0 ? new Uint8Array() : payload.slice(0, previewLength)
-    });
-  }
-  scheduleDrain(signal) {
-    if (this.draining) {
-      return;
-    }
-    this.draining = true;
-    queueMicrotask(() => {
-      void this.drain(signal);
-    });
-  }
-  async drain(signal) {
-    try {
-      while (this.queuedCount > 0) {
-        const observation = this.takeObservation();
-        if (observation === void 0) continue;
-        const observers = [...this.observers];
-        for (const observer of observers) {
-          if (!this.observers.has(observer)) {
-            continue;
-          }
-          try {
-            await observer(observation, signal);
-          } catch (cause) {
-            await this.reportObserverFailed(cause, signal);
-          }
-        }
-      }
-    } finally {
-      this.draining = false;
-      if (this.queuedCount > 0) {
-        this.scheduleDrain(signal);
-      }
-    }
-  }
-  reportDropped(signal) {
-    if (this.dropReportPending) {
-      return;
-    }
-    this.dropReportPending = true;
-    queueMicrotask(() => {
-      void this.events.publishError({
-        code: "observer-dropped" /* ObserverDropped */,
-        message: "Inbound observer notification was dropped because the observer queue is full."
-      }, signal).finally(() => {
-        this.dropReportPending = false;
-      }).catch(() => {
-      });
-    });
-  }
-  async reportObserverFailed(cause, signal) {
-    try {
-      await this.events.publishError({
-        code: "observer-failed" /* ObserverFailed */,
-        message: "Inbound observer callback failed.",
-        cause
-      }, signal);
-    } catch {
-    }
-  }
-  takeObservation() {
-    while (this.queueHead < this.queue.length && this.queue[this.queueHead] === void 0) {
-      this.queueHead += 1;
-    }
-    const observation = this.queue[this.queueHead];
-    if (observation === void 0) return void 0;
-    this.queue[this.queueHead] = void 0;
-    this.queueHead += 1;
-    this.queuedCount -= 1;
-    if (this.queuedCount === 0) {
-      this.queue.length = 0;
-      this.queueHead = 0;
-    } else if (this.queueHead >= 1024 && this.queueHead * 2 >= this.queue.length) {
-      this.queue.splice(0, this.queueHead);
-      this.queueHead = 0;
-    }
-    return observation;
-  }
 };
 
 // packages/stream-connector/src/Runtime/ZlinkStreamFrameSender.ts
@@ -1780,10 +1625,9 @@ function decodeSessionClosing(payload) {
 
 // packages/stream-connector/src/Runtime/ZlinkStreamReceiveDispatcher.ts
 var ZlinkStreamReceiveDispatcher = class {
-  constructor(protocol, pendingRequests, inboundObservers, receivedMessages, frameSender, events, flowContext, metrics, serverClosing) {
+  constructor(protocol, pendingRequests, receivedMessages, frameSender, events, flowContext, metrics, serverClosing) {
     this.protocol = protocol;
     this.pendingRequests = pendingRequests;
-    this.inboundObservers = inboundObservers;
     this.receivedMessages = receivedMessages;
     this.frameSender = frameSender;
     this.events = events;
@@ -1830,7 +1674,6 @@ var ZlinkStreamReceiveDispatcher = class {
     return { available: true, inbound: true };
   }
   async dispatch(connection, header, payload, signal, flowEnabled) {
-    this.inboundObservers.enqueue(header, payload, signal);
     if (header.kind === 3 /* Response */ && header.requestSeq !== void 0) {
       try {
         if (!this.pendingRequests.resolve(header.requestSeq, {
@@ -2560,7 +2403,6 @@ var DefaultZlinkStreamConnector = class {
   pendingRequests = new ZlinkStreamPendingRequests();
   frameSender;
   receiveDispatcher;
-  inboundObservers;
   diagnosticsLevelCell;
   options;
   constructor(options) {
@@ -2575,19 +2417,10 @@ var DefaultZlinkStreamConnector = class {
     const metrics = new ZlinkStreamRuntimeMetrics(this.options);
     const protocol = new ZlinkStreamFrameProtocol(this.options);
     this.frameSender = new ZlinkStreamFrameSender(protocol, flowContext, metrics);
-    this.inboundObservers = new ZlinkStreamInboundObservers(
-      this.options.maxInboundObserverNotifications,
-      this.options.maxInboundObserverPayloadPreviewBytes,
-      this.events
-    );
-    this.receivedMessages = new ZlinkStreamReceivedMessages(
-      this.options.maxReceivedMessages,
-      this.events
-    );
+    this.receivedMessages = new ZlinkStreamReceivedMessages(this.events);
     this.receiveDispatcher = new ZlinkStreamReceiveDispatcher(
       protocol,
       this.pendingRequests,
-      this.inboundObservers,
       this.receivedMessages,
       this.frameSender,
       this.events,
@@ -2667,12 +2500,6 @@ var DefaultZlinkStreamConnector = class {
     const encoded = this.encodePayload(payload, messageType);
     return new ZlinkStreamRequestBuilder(this, this.resolveNameOrDefault(encoded), encoded);
   }
-  observeInbound(observer) {
-    if (this.lifecycle.state !== "created" /* Created */) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Inbound observers must be registered before connecting.");
-    }
-    return this.inboundObservers.add(observer);
-  }
   on(name, handler, messageType) {
     const encodedHandler = (message, signal) => handler({
       name: message.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/stream-connector",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -21,6 +21,6 @@
     }
   },
   "dependencies": {
-    "@zlink-systems/stream-wire": "0.13.0"
+    "@zlink-systems/stream-wire": "0.14.0"
   }
 }

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

@@ -1,25 +0,0 @@
-import { Disposable, ZlinkStreamInboundObservation } from '../Contracts';
-import type { ZlinkStreamHeader } from '../Contracts/ZlinkStreamModels';
-import type { ZlinkStreamConnectorEvents } from './ZlinkStreamConnectorEvents';
-type InboundObserver = (observation: ZlinkStreamInboundObservation, signal?: AbortSignal) => Promise<void> | void;
-export declare class ZlinkStreamInboundObservers {
-    private readonly maxNotifications;
-    private readonly maxPayloadPreviewBytes;
-    private readonly events;
-    private readonly observers;
-    private readonly queue;
-    private queueHead;
-    private queuedCount;
-    private draining;
-    private dropReportPending;
-    constructor(maxNotifications: number, maxPayloadPreviewBytes: number, events: ZlinkStreamConnectorEvents);
-    add(observer: InboundObserver): Disposable;
-    enqueue(header: ZlinkStreamHeader, payload: Uint8Array, signal?: AbortSignal): void;
-    private createObservation;
-    private scheduleDrain;
-    private drain;
-    private reportDropped;
-    private reportObserverFailed;
-    private takeObservation;
-}
-export {};