@zlink-systems/stream-connector 0.13.0 → 0.15.0

package/dist/browser/index.mjs

@@ -9,7 +9,8 @@ function lz4PickleUncompressed(payload) {
   pickled.set(payload, 1);
   return pickled;
 }
-function lz4UnpicklePayload(payload, maxDecompressedSize = defaultMaxDecompressedPayloadSize) {
+function lz4UnpicklePayload(payload, maxSize) {
+  const maxDecompressedSize = maxSize ?? defaultMaxDecompressedPayloadSize;
   if (payload.length === 0) {
     return new Uint8Array();
   }
@@ -152,7 +153,8 @@ function decodeStreamWireFrame(frame) {
     payload: frame.slice(6 + headerLength)
   };
 }
-function encodeStreamWireHeader(header, flags = defaultHeaderFlags) {
+function encodeStreamWireHeader(header, flagOverrides) {
+  const flags = flagOverrides ?? defaultHeaderFlags;
   const reply = isReplyKind(header.kind);
   const packetName = reply ? "" : header.name;
   if (!reply) validateStreamWirePacketName(packetName);
@@ -213,7 +215,8 @@ function encodeStreamWireHeader(header, flags = defaultHeaderFlags) {
   }
   return buffer;
 }
-function decodeStreamWireHeader(header, flags = defaultHeaderFlags, includeFlow = true) {
+function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
+  const flags = flagOverrides ?? defaultHeaderFlags;
   let offset = 0;
   if (header.length < 5) {
     throw new Error("Stream header is incomplete.");
@@ -351,8 +354,8 @@ function decodeStreamWireMetadata(metadata) {
 function lz4PickleUncompressed2(payload) {
   return lz4PickleUncompressed(payload);
 }
-function lz4UnpicklePayload2(payload, maxDecompressedSize = defaultMaxDecompressedPayloadSize) {
-  return lz4UnpicklePayload(payload, maxDecompressedSize);
+function lz4UnpicklePayload2(payload, maxDecompressedSize) {
+  return lz4UnpicklePayload(payload, maxDecompressedSize ?? defaultMaxDecompressedPayloadSize);
 }
 function utf8Encode(value) {
   return new TextEncoder().encode(value);
@@ -497,20 +500,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 +1284,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 +1307,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,11 +1467,18 @@ var ZlinkStreamPendingRequests = class {
 
 // packages/stream-connector/src/Runtime/ZlinkStreamReceivedMessages.ts
 var ZlinkStreamReceivedMessages = class {
-  constructor(capacity, events) {
-    this.capacity = capacity;
+  /**
+   * @param deliverOnArrival `Immediate` runs registered handlers on the receive
+   *   path; `Manual` leaves them queued until {@link pump} runs them on the
+   *   caller's thread (spec stream-connector 32 §7). Wait surfaces observe the
+   *   queue in both modes, so they never depend on this flag.
+   */
+  constructor(events, deliverOnArrival) {
     this.events = events;
+    this.deliverOnArrival = deliverOnArrival;
   }
   handlers = /* @__PURE__ */ new Map();
+  observers = /* @__PURE__ */ new Map();
   // A handler can be registered after messages for another name arrive, so the
   // queue is not a simple FIFO. Tombstones let us remove a deliverable entry
   // without shifting every later message on the hot receive path.
@@ -1487,7 +1486,6 @@ var ZlinkStreamReceivedMessages = class {
   queueHead = 0;
   queuedCount = 0;
   drainTask;
-  dropReportPending = false;
   on(name, handler) {
     validateName(name);
     let set = this.handlers.get(name);
@@ -1496,7 +1494,7 @@ var ZlinkStreamReceivedMessages = class {
       this.handlers.set(name, set);
     }
     set.add(handler);
-    if (this.hasQueuedMessage(name)) {
+    if (this.deliverOnArrival && this.hasQueuedMessage(name)) {
       queueMicrotask(() => this.scheduleDrain());
     }
     return subscription(() => {
@@ -1506,14 +1504,66 @@ var ZlinkStreamReceivedMessages = class {
       }
     });
   }
+  /**
+   * Registers a wait surface over the receive queue. Spec stream-connector 32
+   * §7: these are not registered callbacks — they observe and consume the
+   * packets the queue has not delivered yet, in both dispatch modes, so
+   * `Manual` needs no dispatch pump to complete a wait. The queue is scanned in
+   * a microtask so a message that arrived before the wait started is still
+   * observed, and so the caller has its subscription in hand by then.
+   */
+  observe(name, observer) {
+    validateName(name);
+    let set = this.observers.get(name);
+    if (set === void 0) {
+      set = /* @__PURE__ */ new Set();
+      this.observers.set(name, set);
+    }
+    set.add(observer);
+    queueMicrotask(() => {
+      if (this.observers.get(name)?.has(observer) === true) {
+        this.offerQueued(name, observer);
+      }
+    });
+    return subscription(() => {
+      set.delete(observer);
+      if (set.size === 0 && this.observers.get(name) === set) {
+        this.observers.delete(name);
+      }
+    });
+  }
   enqueue(message, signal) {
-    if (this.queuedCount >= this.capacity) {
-      this.reportDropped(signal);
-      return;
+    for (const observer of [...this.observers.get(message.name) ?? []]) {
+      if (observer(message)) {
+        return;
+      }
     }
     this.queue.push({ message, signal });
     this.queuedCount += 1;
+    if (this.deliverOnArrival) {
+      this.scheduleDrain();
+    }
+  }
+  /**
+   * Runs the registered handlers the receive path left queued. `Manual` calls
+   * this from `dispatch`; `Immediate` has already drained on arrival.
+   */
+  async pump() {
     this.scheduleDrain();
+    await this.drainTask;
+  }
+  offerQueued(name, observer) {
+    for (let index = this.queueHead; index < this.queue.length; index += 1) {
+      const queued = this.queue[index];
+      if (queued === void 0 || queued.message.name !== name) {
+        continue;
+      }
+      if (!observer(queued.message)) {
+        continue;
+      }
+      this.removeAt(index);
+      return;
+    }
   }
   scheduleDrain() {
     if (this.drainTask !== void 0) {
@@ -1521,7 +1571,7 @@ var ZlinkStreamReceivedMessages = class {
     }
     this.drainTask = this.drain().finally(() => {
       this.drainTask = void 0;
-      if (this.findDeliverableIndex() >= 0) {
+      if (this.deliverOnArrival && this.findDeliverableIndex() >= 0) {
         this.scheduleDrain();
       }
     });
@@ -1530,10 +1580,7 @@ var ZlinkStreamReceivedMessages = class {
     for (let index = this.findDeliverableIndex(); index >= 0; index = this.findDeliverableIndex()) {
       const queued = this.queue[index];
       if (queued === void 0) continue;
-      this.queue[index] = void 0;
-      this.queuedCount -= 1;
-      this.advanceHead();
-      this.compactQueue();
+      this.removeAt(index);
       const { message, signal } = queued;
       const handlers = [...this.handlers.get(message.name)];
       for (const handler of handlers) {
@@ -1549,6 +1596,12 @@ var ZlinkStreamReceivedMessages = class {
       }
     }
   }
+  removeAt(index) {
+    this.queue[index] = void 0;
+    this.queuedCount -= 1;
+    this.advanceHead();
+    this.compactQueue();
+  }
   findDeliverableIndex() {
     for (let index = this.queueHead; index < this.queue.length; index += 1) {
       const queued = this.queue[index];
@@ -1580,144 +1633,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 +1695,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 +1744,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, {
@@ -1942,15 +1855,19 @@ function decodeRemoteError(protocol, header, payload) {
 
 // packages/stream-connector/src/Runtime/ZlinkStreamConnectorLifecycle.ts
 var ZlinkStreamConnectorLifecycle = class {
-  constructor(options, pendingRequests, frameSender, receiveDispatcher, events, metrics) {
+  constructor(options, pendingRequests, frameSender, receiveDispatcher, receivedMessages, events, metrics) {
     this.options = options;
     this.pendingRequests = pendingRequests;
     this.frameSender = frameSender;
     this.receiveDispatcher = receiveDispatcher;
+    this.receivedMessages = receivedMessages;
     this.events = events;
     this.metrics = metrics;
   }
   receiveLoopAbort;
+  receiveLoopSleeping = false;
+  receiveLoopWake;
+  receiveLoopSettled = [];
   currentConnection;
   connectionGeneration = 0;
   currentState = "created" /* Created */;
@@ -2067,16 +1984,21 @@ var ZlinkStreamConnectorLifecycle = class {
     if (errors.length === 1) throw errors[0];
     if (errors.length > 1) throw new AggregateError(errors, "Stream connector close failed.");
   }
+  /**
+   * Spec stream-connector 32 §7: `dispatch` runs the callbacks the receive loop
+   * queued, it does not drive the transport. Receiving is the receive loop's
+   * job in both dispatch modes, which is what lets a `Manual` consumer complete
+   * a `waitFor` without pumping, and what keeps this call from blocking on an
+   * idle connection. In `Manual` it first lets the loop settle whatever has
+   * already arrived, so a packet the transport is holding is delivered by this
+   * pump rather than the next one.
+   */
   async dispatch(signal) {
-    const connection = this.currentConnection;
-    const generation = this.connectionGeneration;
-    try {
-      await this.dispatchAvailable(connection, generation, signal);
-    } catch (cause) {
-      const error = toStreamError(cause, "frameDecodeFailed" /* FrameDecodeFailed */, "Stream dispatch failed.");
-      await this.disconnectForTransportFailure(error, connection, generation);
-      throw new ZlinkStreamException(error);
+    throwIfAborted(signal);
+    if (this.options.dispatchMode !== "immediate" /* Immediate */) {
+      await this.settleReceiveLoop();
     }
+    await this.receivedMessages.pump();
   }
   connectionForSend() {
     if (this.currentConnection === void 0 || this.currentState !== "connected" /* Connected */) {
@@ -2145,8 +2067,12 @@ var ZlinkStreamConnectorLifecycle = class {
       this.heartbeatTimer = void 0;
     }
   }
+  // Spec stream-connector 32 §7: the receive loop runs in both dispatch modes.
+  // `Manual` only changes what the loop does with a frame — it queues the
+  // registered callbacks instead of running them — never whether frames are
+  // read off the transport.
   startReceiveLoop() {
-    if (this.options.dispatchMode !== "immediate" /* Immediate */ || this.currentConnection?.read === void 0) {
+    if (this.currentConnection?.read === void 0) {
       return;
     }
     this.stopReceiveLoop();
@@ -2159,19 +2085,66 @@ var ZlinkStreamConnectorLifecycle = class {
   stopReceiveLoop() {
     this.receiveLoopAbort?.abort();
     this.receiveLoopAbort = void 0;
+    this.receiveLoopSleeping = false;
+    this.releaseReceiveLoopSettled();
   }
   async runReceiveLoop(connection, generation, signal) {
     try {
       while (this.shouldContinueReceiveLoop(connection, generation, signal)) {
         const dispatched = await this.dispatchAvailable(connection, generation, signal);
         if (!dispatched && this.shouldContinueReceiveLoop(connection, generation, signal)) {
-          await delay(1, signal);
+          await this.sleepUntilWork(signal);
         }
       }
     } catch (cause) {
       if (signal.aborted) return;
       const error = toStreamError(cause, "frameDecodeFailed" /* FrameDecodeFailed */, "Receive loop failed.");
       await this.disconnectForTransportFailure(error, connection, generation);
+    } finally {
+      this.receiveLoopSleeping = false;
+      this.releaseReceiveLoopSettled();
+    }
+  }
+  // A transport whose read resolves only when a frame arrives parks the loop
+  // inside that read; one that reports "nothing available" instead parks it
+  // here. Both are the loop waiting for new data, and `dispatch` treats them
+  // the same way.
+  async sleepUntilWork(signal) {
+    this.receiveLoopSleeping = true;
+    this.releaseReceiveLoopSettled();
+    try {
+      await new Promise((resolve) => {
+        const finish = () => {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", onAbort);
+          this.receiveLoopWake = void 0;
+          resolve();
+        };
+        const onAbort = () => finish();
+        const timer = setTimeout(finish, 1);
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.receiveLoopWake = finish;
+      });
+    } finally {
+      this.receiveLoopSleeping = false;
+    }
+  }
+  // Returns once the loop has consumed everything the transport already had.
+  // A loop that is mid-batch, or parked inside a read that has not produced a
+  // frame, is already caught up, so only a sleeping loop is woken and awaited.
+  async settleReceiveLoop() {
+    if (this.receiveLoopAbort === void 0 || !this.receiveLoopSleeping) {
+      return;
+    }
+    const settled = new Promise((resolve) => {
+      this.receiveLoopSettled.push(resolve);
+    });
+    this.receiveLoopWake?.();
+    await settled;
+  }
+  releaseReceiveLoopSettled() {
+    for (const resolve of this.receiveLoopSettled.splice(0)) {
+      resolve();
     }
   }
   shouldContinueReceiveLoop(connection, generation, signal) {
@@ -2560,7 +2533,6 @@ var DefaultZlinkStreamConnector = class {
   pendingRequests = new ZlinkStreamPendingRequests();
   frameSender;
   receiveDispatcher;
-  inboundObservers;
   diagnosticsLevelCell;
   options;
   constructor(options) {
@@ -2575,19 +2547,13 @@ 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.events,
+      this.options.dispatchMode === "immediate" /* Immediate */
     );
     this.receiveDispatcher = new ZlinkStreamReceiveDispatcher(
       protocol,
       this.pendingRequests,
-      this.inboundObservers,
       this.receivedMessages,
       this.frameSender,
       this.events,
@@ -2600,6 +2566,7 @@ var DefaultZlinkStreamConnector = class {
       this.pendingRequests,
       this.frameSender,
       this.receiveDispatcher,
+      this.receivedMessages,
       this.events,
       metrics
     );
@@ -2667,12 +2634,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,
@@ -2726,7 +2687,10 @@ var DefaultZlinkStreamConnector = class {
         finish(connectorError("requestTimeout" /* RequestTimeout */, "Wait for stream message timed out."));
       }, timeoutMs);
       signal?.addEventListener("abort", onAbort, { once: true });
-      disposable = this.receivedMessages.on(name, (message) => {
+      disposable = this.receivedMessages.observe(name, (message) => {
+        if (done) {
+          return false;
+        }
         try {
           const decoded = {
             name: message.name,
@@ -2735,12 +2699,14 @@ var DefaultZlinkStreamConnector = class {
             flowId: message.flowId,
             flowOrigin: message.flowOrigin
           };
-          if (predicate(decoded)) {
-            finish(void 0, decoded);
+          if (!predicate(decoded)) {
+            return false;
           }
+          finish(void 0, decoded);
         } catch (cause) {
           finish(cause);
         }
+        return true;
       });
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/stream-connector",
-  "version": "0.13.0",
+  "version": "0.15.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.15.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 {};