@zlink-systems/stream-connector 0.21.0 → 0.22.0

package/dist/browser/index.mjs

@@ -628,7 +628,11 @@ function unwrapStreamError(error) {
   if (error instanceof ZlinkStreamException) {
     return error.error;
   }
-  return { code: "remoteError" /* RemoteError */, message: error instanceof Error ? error.message : String(error), cause: error };
+  return {
+    code: "remoteError" /* RemoteError */,
+    message: error instanceof Error ? error.message : String(error),
+    cause: error
+  };
 }
 function subscription(dispose) {
   return { dispose };
@@ -663,7 +667,10 @@ function utf8Decode2(value) {
 var zlinkStreamAssert = {
   ensure(condition, message) {
     if (typeof message !== "string" || message.trim().length === 0) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "zlinkStreamAssert.ensure requires a non-empty diagnostic message.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "zlinkStreamAssert.ensure requires a non-empty diagnostic message."
+      );
     }
     if (!condition) {
       throw connectorError("validationFailed" /* ValidationFailed */, message);
@@ -712,10 +719,16 @@ function validateName(name, allowReserved = false) {
     throw connectorError("validationFailed" /* ValidationFailed */, "Message name must not be empty.");
   }
   if (!allowReserved && name.startsWith("$zlink.")) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "Message name uses a reserved zlink prefix.");
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Message name uses a reserved zlink prefix."
+    );
   }
   if (utf8Encode2(name).length > 255) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "Message name must not exceed 255 UTF-8 bytes.");
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Message name must not exceed 255 UTF-8 bytes."
+    );
   }
 }
 
@@ -732,13 +745,19 @@ var ZlinkStreamCallBuilderState = class {
   }
   ensureNotExecuted() {
     if (this.executed) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Builder instances can be executed only once.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Builder instances can be executed only once."
+      );
     }
     this.executed = true;
   }
   resolveMessageName() {
     if (this.name === void 0) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Message name is required when the encoded stream payload has no message type.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Message name is required when the encoded stream payload has no message type."
+      );
     }
     return this.name;
   }
@@ -828,7 +847,9 @@ var ZlinkStreamRequestBuilder = class {
       );
       return;
     }
-    return operation.then((value) => (this.connector.options.codec ?? zlinkStreamJsonCodec).decode(value));
+    return operation.then(
+      (value) => (this.connector.options.codec ?? zlinkStreamJsonCodec).decode(value)
+    );
   }
   submitEncoded(signal) {
     this.state.ensureNotExecuted();
@@ -864,7 +885,12 @@ var ZlinkStreamWaitBuilder = class {
   async submit(signal) {
     this.markExecuted();
     const timeoutMs = this.timeoutMs ?? this.connector.options.waitTimeoutMs;
-    const message = await this.connector.waitForMessage(this.name, timeoutMs, this.predicate, signal);
+    const message = await this.connector.waitForMessage(
+      this.name,
+      timeoutMs,
+      this.predicate,
+      signal
+    );
     if (message === void 0) {
       throw connectorError(
         "validationFailed" /* ValidationFailed */,
@@ -875,7 +901,10 @@ var ZlinkStreamWaitBuilder = class {
   }
   ensureConfigurable() {
     if (this.executed) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Builder instances can be executed only once.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Builder instances can be executed only once."
+      );
     }
   }
   markExecuted() {
@@ -901,9 +930,17 @@ var ZlinkStreamExpectNoneBuilder = class {
   async run(signal) {
     this.markExecuted();
     if (this.windowMs === void 0) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "expectNone requires within(windowMs).");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "expectNone requires within(windowMs)."
+      );
     }
-    const message = await this.connector.waitForMessage(this.name, this.windowMs, () => true, signal);
+    const message = await this.connector.waitForMessage(
+      this.name,
+      this.windowMs,
+      () => true,
+      signal
+    );
     if (message === void 0) {
       return;
     }
@@ -914,7 +951,10 @@ var ZlinkStreamExpectNoneBuilder = class {
   }
   ensureConfigurable() {
     if (this.executed) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Builder instances can be executed only once.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Builder instances can be executed only once."
+      );
     }
   }
   markExecuted() {
@@ -947,7 +987,10 @@ var ZlinkStreamSequenceBuilder = class {
   async run(signal) {
     this.markExecuted();
     if (this.predicates.length === 0) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "waitForSequence requires at least one expectation.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "waitForSequence requires at least one expectation."
+      );
     }
     const timeoutMs = this.timeoutMs ?? this.connector.options.waitTimeoutMs;
     const deadline = Date.now() + timeoutMs;
@@ -979,7 +1022,10 @@ var ZlinkStreamSequenceBuilder = class {
   }
   ensureConfigurable() {
     if (this.executed) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Builder instances can be executed only once.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Builder instances can be executed only once."
+      );
     }
   }
   markExecuted() {
@@ -989,7 +1035,10 @@ var ZlinkStreamSequenceBuilder = class {
 };
 function validateTimeout(timeoutMs) {
   if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "Timeout must be a non-negative finite number.");
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Timeout must be a non-negative finite number."
+    );
   }
 }
 
@@ -1005,7 +1054,10 @@ var zlinkStreamLz4CompressionCodec = {
 function compressPayload(payload, compression, compressionCodec) {
   const codec = resolveCompressionCodec(compression, compressionCodec);
   if (codec === void 0) {
-    throw connectorError("compressionFailed" /* CompressionFailed */, "Compression codec is not configured.");
+    throw connectorError(
+      "compressionFailed" /* CompressionFailed */,
+      "Compression codec is not configured."
+    );
   }
   return codec.compress(payload);
 }
@@ -1015,7 +1067,10 @@ function decompressIfNeeded(header, payload, compression, compressionCodec, maxD
   }
   const codec = resolveCompressionCodec(compression, compressionCodec);
   if (codec === void 0) {
-    throw connectorError("decompressionFailed" /* DecompressionFailed */, "Compression codec is not configured.");
+    throw connectorError(
+      "decompressionFailed" /* DecompressionFailed */,
+      "Compression codec is not configured."
+    );
   }
   try {
     const decompressed = codec.decompress(payload, maxDecompressedSize);
@@ -1048,26 +1103,39 @@ var ZlinkStreamFrameCodec = class {
     try {
       return decodeStreamWireFrame(frame);
     } catch (cause) {
-      throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Frame length does not match prefix.", cause);
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "Frame length does not match prefix.",
+        cause
+      );
     }
   }
 };
 function splitZlinkStreamFrames(chunk) {
   if (chunk.length === 0) {
-    throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Stream frame prefix is incomplete.");
+    throw connectorError(
+      "frameDecodeFailed" /* FrameDecodeFailed */,
+      "Stream frame prefix is incomplete."
+    );
   }
   const frames = [];
   let offset = 0;
   while (offset < chunk.length) {
     const remaining = chunk.length - offset;
     if (remaining < 6) {
-      throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Stream frame prefix is incomplete.");
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "Stream frame prefix is incomplete."
+      );
     }
     const headerLength = chunk[offset] << 8 | chunk[offset + 1];
     const payloadLength = chunk[offset + 2] * 16777216 + (chunk[offset + 3] << 16) + (chunk[offset + 4] << 8) + chunk[offset + 5];
     const frameLength = 6 + headerLength + payloadLength;
     if (frameLength > remaining) {
-      throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Frame length does not match prefix.");
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "Frame length does not match prefix."
+      );
     }
     frames.push(chunk.subarray(offset, offset + frameLength));
     offset += frameLength;
@@ -1076,7 +1144,10 @@ function splitZlinkStreamFrames(chunk) {
 }
 function validatePayload(payloadLength, maxPayloadSize) {
   if (payloadLength > maxPayloadSize) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "Payload exceeds MaxSendPayloadSize.");
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Payload exceeds MaxSendPayloadSize."
+    );
   }
 }
 
@@ -1094,14 +1165,22 @@ var ZlinkStreamMetadataCodec = class {
       }
       return size;
     } catch (cause) {
-      throw connectorError("validationFailed" /* ValidationFailed */, streamWireErrorMessage(cause), cause);
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        streamWireErrorMessage(cause),
+        cause
+      );
     }
   }
   static write(metadata, destination) {
     try {
       destination.set(encodeStreamWireMetadata(metadata.values));
     } catch (cause) {
-      throw connectorError("validationFailed" /* ValidationFailed */, streamWireErrorMessage(cause), cause);
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        streamWireErrorMessage(cause),
+        cause
+      );
     }
   }
   static decode(metadata) {
@@ -1109,7 +1188,11 @@ var ZlinkStreamMetadataCodec = class {
       const values = decodeStreamWireMetadata(metadata);
       return values.size === 0 ? ZlinkStreamMetadataMap.empty : ZlinkStreamMetadataMap.from(values);
     } catch (cause) {
-      throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, streamWireErrorMessage(cause), cause);
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        streamWireErrorMessage(cause),
+        cause
+      );
     }
   }
 };
@@ -1137,7 +1220,11 @@ var ZlinkStreamHeaderCodec = class {
         flowOrigin: encodeFlowOrigin(header.flowOrigin)
       });
     } catch (cause) {
-      throw connectorError("validationFailed" /* ValidationFailed */, streamWireErrorMessage2(cause), cause);
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        streamWireErrorMessage2(cause),
+        cause
+      );
     }
   }
   /**
@@ -1162,7 +1249,11 @@ var ZlinkStreamHeaderCodec = class {
         flowOrigin: decodeFlowOrigin(wire.flowOrigin)
       };
     } catch (cause) {
-      throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, streamWireErrorMessage2(cause), cause);
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        streamWireErrorMessage2(cause),
+        cause
+      );
     }
     validateEnum(decoded.kind, decoded.codec, decoded.flags);
     if (!isReplyKind2(decoded.kind)) {
@@ -1200,19 +1291,31 @@ function validateHeaderSemantics(header) {
   const hasRequestSeq = header.requestSeq !== void 0 || (header.flags & 1 /* HasRequestSeq */) !== 0;
   const hasMetadata = header.metadata.count > 0 || (header.flags & 2 /* HasMetadata */) !== 0;
   if (header.kind === 1 /* Send */ && hasRequestSeq) {
-    throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Send packet must not contain a request sequence.");
+    throw connectorError(
+      "frameDecodeFailed" /* FrameDecodeFailed */,
+      "Send packet must not contain a request sequence."
+    );
   }
   if ((header.kind === 2 /* Request */ || header.kind === 3 /* Response */) && !hasRequestSeq) {
-    throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Request and response packets must contain a request sequence.");
+    throw connectorError(
+      "frameDecodeFailed" /* FrameDecodeFailed */,
+      "Request and response packets must contain a request sequence."
+    );
   }
   if (header.kind === 4 /* Error */ && header.codec !== 1 /* Json */) {
-    throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Error packet must use the JSON codec.");
+    throw connectorError(
+      "frameDecodeFailed" /* FrameDecodeFailed */,
+      "Error packet must use the JSON codec."
+    );
   }
   if (header.kind === 5 /* Control */) {
     const hasCorrelation = header.correlationId !== void 0 && header.correlationId.length > 0 || (header.flags & 8 /* HasCorrelationId */) !== 0;
     const hasFlow = header.flowId !== void 0 || header.flowOrigin !== void 0 || (header.flags & 16 /* HasFlowId */) !== 0;
     if (header.flags !== 0 /* None */ || hasRequestSeq || hasMetadata || hasCorrelation || hasFlow || header.codec !== 0 /* Raw */) {
-      throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Control packet must use raw codec and must not contain flags.");
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "Control packet must use raw codec and must not contain flags."
+      );
     }
   }
 }
@@ -1244,17 +1347,30 @@ var ZlinkStreamFrameProtocol = class {
   }
   encode(kind, name, payload, metadata, compress, requestSeq, correlationId, flowId, flowOrigin) {
     const payloadBytes = compress ? compressPayload(payload.payload, this.options.compression, this.options.compressionCodec) : payload.payload;
-    const header = buildHeader(kind, name, payload.codec, metadata, compress, requestSeq, correlationId, flowId, flowOrigin);
+    const header = buildHeader(
+      kind,
+      name,
+      payload.codec,
+      metadata,
+      compress,
+      requestSeq,
+      correlationId,
+      flowId,
+      flowOrigin
+    );
     return this.encodeFrame(header, payloadBytes);
   }
   encodeControl(name, payload = new Uint8Array()) {
-    return this.encodeFrame({
-      kind: 5 /* Control */,
-      codec: 0 /* Raw */,
-      flags: 0 /* None */,
-      name,
-      metadata: ZlinkStreamMetadataMap.empty
-    }, payload);
+    return this.encodeFrame(
+      {
+        kind: 5 /* Control */,
+        codec: 0 /* Raw */,
+        flags: 0 /* None */,
+        name,
+        metadata: ZlinkStreamMetadataMap.empty
+      },
+      payload
+    );
   }
   decode(frameBytes, flowEnabled = this.flowEnabled()) {
     const frame = ZlinkStreamFrameCodec.decode(frameBytes);
@@ -1272,7 +1388,10 @@ var ZlinkStreamFrameProtocol = class {
     return splitZlinkStreamFrames(chunk).map((frame) => {
       const decoded = this.decode(frame, flowEnabled);
       if (decoded.payload.length > this.options.maxReceivePayloadSize) {
-        throw connectorError("frameTooLarge" /* FrameTooLarge */, "Payload exceeds MaxReceivePayloadSize.");
+        throw connectorError(
+          "frameTooLarge" /* FrameTooLarge */,
+          "Payload exceeds MaxReceivePayloadSize."
+        );
       }
       return decoded;
     });
@@ -1332,7 +1451,10 @@ function normalizeOptions(options, defaultTransportFactory) {
   }
   const inferredTransport = inferTransport(endpoint);
   if (options.transport !== void 0 && options.transport !== inferredTransport) {
-    throw connectorError("configurationError" /* ConfigurationError */, "Configured transport conflicts with endpoint scheme.");
+    throw connectorError(
+      "configurationError" /* ConfigurationError */,
+      "Configured transport conflicts with endpoint scheme."
+    );
   }
   validatePositive(options.connectTimeoutMs ?? 5e3, "ConnectTimeout");
   validatePositive(options.requestTimeoutMs ?? 3e4, "RequestTimeout");
@@ -1386,7 +1508,10 @@ function resolveCompressionCodec2(options) {
   const compression = options.compression ?? "lz4" /* Lz4 */;
   if (compression === "none" /* None */) {
     if (options.compressionCodec !== void 0) {
-      throw connectorError("configurationError" /* ConfigurationError */, "compressionCodec cannot be set when compression is none.");
+      throw connectorError(
+        "configurationError" /* ConfigurationError */,
+        "compressionCodec cannot be set when compression is none."
+      );
     }
     return void 0;
   }
@@ -1412,7 +1537,10 @@ function validateHeartbeat(options) {
   validatePositive(intervalMs, "Heartbeat interval");
   validatePositive(timeoutMs, "Heartbeat timeout");
   if (timeoutMs <= intervalMs) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "Heartbeat timeout must be greater than the heartbeat interval.");
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Heartbeat timeout must be greater than the heartbeat interval."
+    );
   }
 }
 function validateReconnect(options) {
@@ -1423,11 +1551,17 @@ function validateReconnect(options) {
   validatePositive(options?.initialDelayMs ?? 250, "Reconnect InitialDelay");
   validatePositive(options?.maxDelayMs ?? 5e3, "Reconnect MaxDelay");
   if ((options?.backoffFactor ?? 2) < 1) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "Reconnect BackoffFactor must be at least 1.0.");
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Reconnect BackoffFactor must be at least 1.0."
+    );
   }
   const maxAttempts = options?.maxAttempts === void 0 ? 3 : options.maxAttempts;
   if (maxAttempts !== null && !(Number.isFinite(maxAttempts) && maxAttempts > 0)) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "Reconnect MaxAttempts must be null or positive.");
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Reconnect MaxAttempts must be null or positive."
+    );
   }
 }
 
@@ -1465,7 +1599,9 @@ var ZlinkStreamPendingRequests = class {
     const promise = new Promise((resolve, reject) => {
       timeout = setTimeout(() => {
         this.active.delete(requestSeq);
-        reject(connectorError("requestTimeout" /* RequestTimeout */, `Request '${packetName}' timed out.`));
+        reject(
+          connectorError("requestTimeout" /* RequestTimeout */, `Request '${packetName}' timed out.`)
+        );
       }, timeoutMs);
       resolvePending = resolve;
       rejectPending = (error) => reject(connectorError(error.code, error.message, error.cause));
@@ -1729,11 +1865,14 @@ var ZlinkStreamReceivedMessages = class {
           try {
             await handler(message, signal);
           } catch (cause) {
-            await this.events.publishError({
-              code: "userCallbackFailed" /* UserCallbackFailed */,
-              message: "Typed message handler failed.",
-              cause
-            }, signal);
+            await this.events.publishError(
+              {
+                code: "userCallbackFailed" /* UserCallbackFailed */,
+                message: "Typed message handler failed.",
+                cause
+              },
+              signal
+            );
           }
         }
       }
@@ -1792,7 +1931,17 @@ var ZlinkStreamFrameSender = class {
     const flow = this.protocol.flowEnabled() ? this.flowContext.currentOrCreate(explicitFlow) : void 0;
     await this.write(
       connection,
-      this.protocol.encode(kind, name, payload, metadata, compress, requestSeq, correlationId, flow?.flowId, flow?.flowOrigin),
+      this.protocol.encode(
+        kind,
+        name,
+        payload,
+        metadata,
+        compress,
+        requestSeq,
+        correlationId,
+        flow?.flowId,
+        flow?.flowOrigin
+      ),
       signal
     );
   }
@@ -1827,11 +1976,13 @@ var reasons = {
   6: "TransportError"
 };
 function decodeSessionClosing(payload) {
-  if (payload.length < 4 || payload[0] !== 1) throw new Error("Unsupported session-closing version.");
+  if (payload.length < 4 || payload[0] !== 1)
+    throw new Error("Unsupported session-closing version.");
   const closeReason = reasons[payload[1]];
   if (closeReason === void 0) throw new Error("Unknown session-closing reason.");
   const length = payload[2] << 8 | payload[3];
-  if (length > 512 || payload.length !== 4 + length) throw new Error("Invalid session-closing diagnostic length.");
+  if (length > 512 || payload.length !== 4 + length)
+    throw new Error("Invalid session-closing diagnostic length.");
   const diagnostic = length === 0 ? void 0 : new TextDecoder("utf-8", { fatal: true }).decode(payload.subarray(4));
   return { closeReason, diagnostic };
 }
@@ -1887,7 +2038,14 @@ var ZlinkStreamReceiveDispatcher = class {
         break;
       }
       try {
-        await this.dispatch(connection, frame.header, frame.payload, signal, flowEnabled, connectionForSend);
+        await this.dispatch(
+          connection,
+          frame.header,
+          frame.payload,
+          signal,
+          flowEnabled,
+          connectionForSend
+        );
       } catch (cause) {
         if (frame.header.kind === 5 /* Control */ && frame.header.name === ZLINK_STREAM_HEARTBEAT_PING) {
           throw cause;
@@ -1907,10 +2065,13 @@ var ZlinkStreamReceiveDispatcher = class {
           codec: header.codec,
           payload: this.protocol.decodePayload(header, payload)
         })) {
-          await this.events.publishError({
-            code: "frameDecodeFailed" /* FrameDecodeFailed */,
-            message: `Response request sequence '${header.requestSeq}' has no pending request.`
-          }, signal);
+          await this.events.publishError(
+            {
+              code: "frameDecodeFailed" /* FrameDecodeFailed */,
+              message: `Response request sequence '${header.requestSeq}' has no pending request.`
+            },
+            signal
+          );
         }
       } catch (cause) {
         const decodeError = toStreamError(
@@ -1918,10 +2079,7 @@ var ZlinkStreamReceiveDispatcher = class {
           "decompressionFailed" /* DecompressionFailed */,
           "Decompression failed."
         );
-        if (!this.pendingRequests.reject(
-          header.requestSeq,
-          decodeError
-        )) {
+        if (!this.pendingRequests.reject(header.requestSeq, decodeError)) {
           await this.events.publishError(decodeError, signal);
         }
       }
@@ -1939,10 +2097,7 @@ var ZlinkStreamReceiveDispatcher = class {
           "frameDecodeFailed" /* FrameDecodeFailed */,
           "Remote error payload is invalid."
         );
-        if (!this.pendingRequests.reject(
-          header.requestSeq,
-          decodeError
-        )) {
+        if (!this.pendingRequests.reject(header.requestSeq, decodeError)) {
           await this.events.publishError(decodeError, signal);
         }
       }
@@ -1958,13 +2113,16 @@ var ZlinkStreamReceiveDispatcher = class {
     }
     if (header.kind === 1 /* Send */) {
       const flow = flowEnabled ? this.flowContext.createInbound(header.flowId, header.flowOrigin) : void 0;
-      this.receivedMessages.enqueue({
-        name: header.name,
-        metadata: header.metadata,
-        payload: { codec: header.codec, payload: this.protocol.decodePayload(header, payload) },
-        flowId: flow?.flowId,
-        flowOrigin: flow?.flowOrigin
-      }, signal);
+      this.receivedMessages.enqueue(
+        {
+          name: header.name,
+          metadata: header.metadata,
+          payload: { codec: header.codec, payload: this.protocol.decodePayload(header, payload) },
+          flowId: flow?.flowId,
+          flowOrigin: flow?.flowOrigin
+        },
+        signal
+      );
     }
   }
   async dispatchControl(connection, header, payload, signal, connectionForSend) {
@@ -1974,7 +2132,10 @@ var ZlinkStreamReceiveDispatcher = class {
       return;
     }
     if (payload.length !== 0) {
-      throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Control packet payload must be empty.");
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "Control packet payload must be empty."
+      );
     }
     if (header.name === ZLINK_STREAM_HEARTBEAT_PING) {
       try {
@@ -2002,7 +2163,11 @@ function decodeRemoteError(protocol, header, payload) {
   try {
     decoded = JSON.parse(utf8Decode2(decodedPayload));
   } catch (cause) {
-    throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Remote error payload must be a JSON object.", cause);
+    throw connectorError(
+      "frameDecodeFailed" /* FrameDecodeFailed */,
+      "Remote error payload must be a JSON object.",
+      cause
+    );
   }
   if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded) || typeof decoded.code !== "string" || typeof decoded.message !== "string") {
     throw connectorError(
@@ -2081,7 +2246,10 @@ var ZlinkStreamConnectorLifecycle = class {
           this.lateConnectCleanupError = error;
           throw error;
         }
-        throw connectorError("disconnected" /* Disconnected */, "Connector closed while connecting.");
+        throw connectorError(
+          "disconnected" /* Disconnected */,
+          "Connector closed while connecting."
+        );
       }
       this.currentConnection = connection;
       this.connectionGeneration += 1;
@@ -2120,8 +2288,15 @@ var ZlinkStreamConnectorLifecycle = class {
   }
   async serverClosing(reason) {
     this.closeReasonValue = reason;
-    const error = { code: "disconnected" /* Disconnected */, message: `Server closed the session: ${reason}.` };
-    await this.disconnectForTransportFailure(error, this.currentConnection, this.connectionGeneration);
+    const error = {
+      code: "disconnected" /* Disconnected */,
+      message: `Server closed the session: ${reason}.`
+    };
+    await this.disconnectForTransportFailure(
+      error,
+      this.currentConnection,
+      this.connectionGeneration
+    );
   }
   async closeOnce(signal) {
     await this.connectTask?.catch(() => void 0);
@@ -2145,7 +2320,10 @@ var ZlinkStreamConnectorLifecycle = class {
     } catch (error) {
       errors.push(error);
     }
-    this.pendingRequests.failAll({ code: "disconnected" /* Disconnected */, message: "Connector closed." });
+    this.pendingRequests.failAll({
+      code: "disconnected" /* Disconnected */,
+      message: "Connector closed."
+    });
     this.receivedMessages.connectionEnded();
     void this.setState("closed" /* Closed */, void 0, signal);
     this.publishDisconnectedWithoutWaiting(signal);
@@ -2270,7 +2448,11 @@ var ZlinkStreamConnectorLifecycle = class {
       }
     } catch (cause) {
       if (signal.aborted) return;
-      const error = toStreamError(cause, "frameDecodeFailed" /* FrameDecodeFailed */, "Receive loop failed.");
+      const error = toStreamError(
+        cause,
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "Receive loop failed."
+      );
       await this.disconnectForTransportFailure(error, connection, generation);
     } finally {
       this.receiveLoopSleeping = false;
@@ -2329,7 +2511,11 @@ var ZlinkStreamConnectorLifecycle = class {
     if (Date.now() - this.lastInboundAt > this.options.heartbeat.timeoutMs) {
       this.closeReasonValue = "HeartbeatTimeout";
       const error = { code: "disconnected" /* Disconnected */, message: "Heartbeat timed out." };
-      await this.disconnectForTransportFailure(error, this.currentConnection, this.connectionGeneration);
+      await this.disconnectForTransportFailure(
+        error,
+        this.currentConnection,
+        this.connectionGeneration
+      );
       return;
     }
     const connection = this.currentConnection;
@@ -2584,7 +2770,11 @@ var BrowserWebSocketConnection = class {
       const message = toUint8Array(event.data);
       this.messages.push(message);
     } catch (cause) {
-      this.error = cause instanceof Error ? cause : connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "WebSocket message decode failed.", cause);
+      this.error = cause instanceof Error ? cause : connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "WebSocket message decode failed.",
+        cause
+      );
       this.closed = true;
       this.socket.close();
     }
@@ -2592,19 +2782,28 @@ var BrowserWebSocketConnection = class {
   };
   onClose = () => {
     if (!this.closed) {
-      this.error = connectorError("disconnected" /* Disconnected */, "Remote stream closed the WebSocket connection.");
+      this.error = connectorError(
+        "disconnected" /* Disconnected */,
+        "Remote stream closed the WebSocket connection."
+      );
     }
     this.closed = true;
     this.wakeReader();
   };
   onError = () => {
-    this.error = connectorError("disconnected" /* Disconnected */, "Remote stream closed after a WebSocket error.");
+    this.error = connectorError(
+      "disconnected" /* Disconnected */,
+      "Remote stream closed after a WebSocket error."
+    );
     this.closed = true;
     this.wakeReader();
   };
   waitForMessage(signal) {
     if (this.readWaiter !== void 0) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Only one pending stream read is supported.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Only one pending stream read is supported."
+      );
     }
     return new Promise((resolve, reject) => {
       const onAbort = () => {
@@ -2660,9 +2859,10 @@ function waitForClose(socket, signal) {
 async function waitForOpen(socket, connectTimeoutMs, signal) {
   throwIfAborted(signal);
   await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => finish(
-      connectorError("connectTimeout" /* ConnectTimeout */, "Connect timed out.")
-    ), connectTimeoutMs);
+    const timeout = setTimeout(
+      () => finish(connectorError("connectTimeout" /* ConnectTimeout */, "Connect timed out.")),
+      connectTimeoutMs
+    );
     const onOpen = () => finish();
     const onClose = () => finish(connectorError("connectTimeout" /* ConnectTimeout */, "Connect closed before opening."));
     const onError = () => finish(connectorError("connectTimeout" /* ConnectTimeout */, "Connect failed."));
@@ -2693,7 +2893,10 @@ function toUint8Array(data) {
   if (ArrayBuffer.isView(data)) {
     return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
   }
-  throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "WebSocket text messages are not supported.");
+  throw connectorError(
+    "frameDecodeFailed" /* FrameDecodeFailed */,
+    "WebSocket text messages are not supported."
+  );
 }
 
 // packages/stream-connector/src/Runtime/ZlinkStreamConnector.ts
@@ -2823,13 +3026,16 @@ var DefaultZlinkStreamConnector = class {
     return new ZlinkStreamRequestBuilder(this, this.resolveNameOrDefault(encoded), encoded);
   }
   on(name, handler, messageType) {
-    const encodedHandler = (message, signal) => handler({
-      name: message.name,
-      metadata: message.metadata,
-      payload: this.decodePayload(message.payload, messageType),
-      flowId: message.flowId,
-      flowOrigin: message.flowOrigin
-    }, signal);
+    const encodedHandler = (message, signal) => handler(
+      {
+        name: message.name,
+        metadata: message.metadata,
+        payload: this.decodePayload(message.payload, messageType),
+        flowId: message.flowId,
+        flowOrigin: message.flowOrigin
+      },
+      signal
+    );
     return this.receivedMessages.on(name, encodedHandler);
   }
   waitFor(nameOrType) {
@@ -2850,7 +3056,10 @@ var DefaultZlinkStreamConnector = class {
   observedName(nameOrType) {
     const name = typeof nameOrType === "function" ? this.options.nameResolver.resolve(nameOrType) : nameOrType;
     if (typeof name !== "string") {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Packet name must be a string or a payload constructor.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Packet name must be a string or a payload constructor."
+      );
     }
     validateName(name);
     return name;
@@ -2870,7 +3079,10 @@ var DefaultZlinkStreamConnector = class {
   waitForMessage(name, timeoutMs, predicate, signal) {
     validateName(name);
     if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Timeout must be a non-negative finite number.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Timeout must be a non-negative finite number."
+      );
     }
     throwIfAborted(signal);
     return new Promise((resolve, reject) => {
@@ -2896,30 +3108,36 @@ var DefaultZlinkStreamConnector = class {
       };
       timer = setTimeout(() => finish(), timeoutMs);
       signal?.addEventListener("abort", onAbort, { once: true });
-      disposable = this.receivedMessages.observe(name, (message) => {
-        if (done) {
-          return false;
-        }
-        try {
-          const decoded = {
-            name: message.name,
-            metadata: message.metadata,
-            payload: this.decodeWaitPayload(message.payload),
-            flowId: message.flowId,
-            flowOrigin: message.flowOrigin
-          };
-          if (!predicate(decoded)) {
+      disposable = this.receivedMessages.observe(
+        name,
+        (message) => {
+          if (done) {
             return false;
           }
-          finish(void 0, decoded);
-        } catch (cause) {
-          finish(cause);
-        }
-        return true;
-      }, () => finish(connectorError(
-        "disconnected" /* Disconnected */,
-        `The connection this wait for '${name}' observed has ended.`
-      )));
+          try {
+            const decoded = {
+              name: message.name,
+              metadata: message.metadata,
+              payload: this.decodeWaitPayload(message.payload),
+              flowId: message.flowId,
+              flowOrigin: message.flowOrigin
+            };
+            if (!predicate(decoded)) {
+              return false;
+            }
+            finish(void 0, decoded);
+          } catch (cause) {
+            finish(cause);
+          }
+          return true;
+        },
+        () => finish(
+          connectorError(
+            "disconnected" /* Disconnected */,
+            `The connection this wait for '${name}' observed has ended.`
+          )
+        )
+      );
     });
   }
   encodePayload(payload, messageType) {