@zlink-systems/stream-connector 0.21.0 → 0.23.0

package/dist/browser/index.mjs

@@ -120,7 +120,8 @@ var defaultHeaderFlags = {
   hasRequestSeq: 1,
   hasMetadata: 2,
   hasCorrelationId: 8,
-  hasFlowId: 16
+  hasFlowId: 16,
+  hasActorSlot: 32
 };
 var ZLINK_STREAM_FORMAT_MARKER = 242;
 var ZLINK_STREAM_RESPONSE_KIND = 3;
@@ -167,6 +168,7 @@ function encodeStreamWireHeader(header, flagOverrides) {
   }
   const hasCorrelation = correlationBytes !== void 0;
   const hasFlow = header.flowId !== void 0 || header.flowOrigin !== void 0;
+  const hasActorSlot = header.actorSlot !== void 0;
   if (hasFlow && (header.flowId === void 0 || header.flowOrigin === void 0)) {
     throw new Error("Stream flow id and origin must be provided together.");
   }
@@ -174,13 +176,17 @@ function encodeStreamWireHeader(header, flagOverrides) {
   if (header.flowOrigin !== void 0 && ![1, 2, 3, 4].includes(header.flowOrigin)) {
     throw new Error("Stream flow origin is invalid.");
   }
+  if (header.actorSlot !== void 0 && (!Number.isInteger(header.actorSlot) || header.actorSlot < 1 || header.actorSlot > 65535)) {
+    throw new Error("Stream actor slot is invalid.");
+  }
   let headerFlags = header.flags;
   headerFlags = hasRequestSeq ? headerFlags | flags.hasRequestSeq : headerFlags & ~flags.hasRequestSeq;
   headerFlags = hasMetadata ? headerFlags | flags.hasMetadata : headerFlags & ~flags.hasMetadata;
   headerFlags = hasCorrelation ? headerFlags | flags.hasCorrelationId : headerFlags & ~flags.hasCorrelationId;
   headerFlags = hasFlow ? headerFlags | flags.hasFlowId : headerFlags & ~flags.hasFlowId;
+  headerFlags = hasActorSlot ? headerFlags | flags.hasActorSlot : headerFlags & ~flags.hasActorSlot;
   const metadataBytes = hasMetadata ? encodeStreamWireMetadata(header.metadata) : new Uint8Array();
-  const size = 4 + (hasRequestSeq ? 8 : 0) + 1 + nameBytes.length + (hasMetadata ? 2 + metadataBytes.length : 0) + (hasCorrelation ? 1 + correlationBytes.length : 0) + (hasFlow ? 37 : 0);
+  const size = 4 + (hasRequestSeq ? 8 : 0) + 1 + nameBytes.length + (hasMetadata ? 2 + metadataBytes.length : 0) + (hasCorrelation ? 1 + correlationBytes.length : 0) + (hasFlow ? 37 : 0) + (hasActorSlot ? 2 : 0);
   const buffer = new Uint8Array(size);
   let offset = 0;
   buffer[offset++] = ZLINK_STREAM_FORMAT_MARKER;
@@ -213,6 +219,9 @@ function encodeStreamWireHeader(header, flagOverrides) {
     offset += 36;
     buffer[offset++] = header.flowOrigin;
   }
+  if (hasActorSlot) {
+    writeUInt16BE(buffer, offset, header.actorSlot);
+  }
   return buffer;
 }
 function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
@@ -231,7 +240,8 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
   const hasMetadata = (headerFlags & flags.hasMetadata) !== 0;
   const hasCorrelation = (headerFlags & flags.hasCorrelationId) !== 0;
   const hasFlow = (headerFlags & flags.hasFlowId) !== 0;
-  if ((headerFlags & ~31) !== 0) {
+  const hasActorSlot = (headerFlags & flags.hasActorSlot) !== 0;
+  if ((headerFlags & ~63) !== 0) {
     throw new Error("Unknown mandatory stream header flag.");
   }
   let requestSeq;
@@ -286,6 +296,17 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
     }
     flowOrigin = includeFlow ? decodedFlowOrigin : void 0;
   }
+  let actorSlot;
+  if (hasActorSlot) {
+    if (header.length - offset < 2) {
+      throw new Error("Stream actor slot is incomplete.");
+    }
+    actorSlot = readUInt16BE(header, offset);
+    if (actorSlot === 0) {
+      throw new Error("Stream actor slot must not be zero.");
+    }
+    offset += 2;
+  }
   if (offset !== header.length) {
     throw new Error("Stream header has trailing bytes.");
   }
@@ -298,7 +319,8 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
     metadata: decodedMetadata.metadata,
     correlationId,
     flowId,
-    flowOrigin
+    flowOrigin,
+    actorSlot
   };
 }
 function validateFlowId(flowId) {
@@ -464,13 +486,6 @@ var ZlinkStreamDispatchMode = /* @__PURE__ */ ((ZlinkStreamDispatchMode2) => {
   ZlinkStreamDispatchMode2["Immediate"] = "immediate";
   return ZlinkStreamDispatchMode2;
 })(ZlinkStreamDispatchMode || {});
-var ZlinkStreamDiagnosticsLevel = /* @__PURE__ */ ((ZlinkStreamDiagnosticsLevel4) => {
-  ZlinkStreamDiagnosticsLevel4["Off"] = "off";
-  ZlinkStreamDiagnosticsLevel4["Errors"] = "errors";
-  ZlinkStreamDiagnosticsLevel4["Normal"] = "normal";
-  ZlinkStreamDiagnosticsLevel4["Detailed"] = "detailed";
-  return ZlinkStreamDiagnosticsLevel4;
-})(ZlinkStreamDiagnosticsLevel || {});
 var ZlinkStreamMessageKind = /* @__PURE__ */ ((ZlinkStreamMessageKind2) => {
   ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Send"] = 1] = "Send";
   ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Request"] = 2] = "Request";
@@ -486,6 +501,7 @@ var ZlinkStreamHeaderFlags = /* @__PURE__ */ ((ZlinkStreamHeaderFlags2) => {
   ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["PayloadCompressed"] = 4] = "PayloadCompressed";
   ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasCorrelationId"] = 8] = "HasCorrelationId";
   ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasFlowId"] = 16] = "HasFlowId";
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasActorSlot"] = 32] = "HasActorSlot";
   return ZlinkStreamHeaderFlags2;
 })(ZlinkStreamHeaderFlags || {});
 var ZlinkStreamErrorCode = /* @__PURE__ */ ((ZlinkStreamErrorCode2) => {
@@ -628,7 +644,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 +683,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,42 +735,56 @@ 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."
+    );
   }
 }
 
 // packages/stream-connector/src/Runtime/Calls/ZlinkStreamCallBuilders.ts
 var ZlinkStreamCallBuilderState = class {
+  constructor(name, actorSlot, validateActor) {
+    this.actorSlot = actorSlot;
+    this.validateActor = validateActor;
+    this.name = name;
+  }
   executed = false;
   name;
   metadata = ZlinkStreamMetadataMap.empty;
   timeoutMs;
   compress = false;
-  flow;
-  constructor(name) {
-    this.name = name;
-  }
   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;
+    this.validateActor?.();
   }
   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;
   }
 };
 var ZlinkStreamSendBuilder = class {
-  constructor(connector, name, payload) {
+  constructor(connector, name, payload, actorSlot, validateActor) {
     this.connector = connector;
     this.payload = payload;
-    this.state = new ZlinkStreamCallBuilderState(name);
+    this.state = new ZlinkStreamCallBuilderState(name, actorSlot, validateActor);
   }
   state;
   packetName(name) {
@@ -763,10 +800,6 @@ var ZlinkStreamSendBuilder = class {
     this.state.compress = true;
     return this;
   }
-  flowFrom(flow) {
-    this.state.flow = flow;
-    return this;
-  }
   async submit(signal) {
     throwIfAborted(signal);
     this.state.ensureNotExecuted();
@@ -778,15 +811,16 @@ var ZlinkStreamSendBuilder = class {
       this.state.compress,
       void 0,
       signal,
-      this.state.flow
+      void 0,
+      this.state.actorSlot
     );
   }
 };
 var ZlinkStreamRequestBuilder = class {
-  constructor(connector, name, payload) {
+  constructor(connector, name, payload, actorSlot, validateActor) {
     this.connector = connector;
     this.payload = payload;
-    this.state = new ZlinkStreamCallBuilderState(name);
+    this.state = new ZlinkStreamCallBuilderState(name, actorSlot, validateActor);
   }
   state;
   packetName(name) {
@@ -806,10 +840,6 @@ var ZlinkStreamRequestBuilder = class {
     this.state.compress = true;
     return this;
   }
-  flowFrom(flow) {
-    this.state.flow = flow;
-    return this;
-  }
   submit(signalOrCallback) {
     this.state.ensureNotExecuted();
     const operation = this.connector.requestEncoded(
@@ -819,7 +849,7 @@ var ZlinkStreamRequestBuilder = class {
       this.state.compress,
       this.state.timeoutMs ?? this.connector.options.requestTimeoutMs,
       typeof signalOrCallback === "function" ? void 0 : signalOrCallback,
-      this.state.flow
+      this.state.actorSlot
     );
     if (typeof signalOrCallback === "function") {
       operation.then(
@@ -828,7 +858,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();
@@ -839,7 +871,7 @@ var ZlinkStreamRequestBuilder = class {
       this.state.compress,
       this.state.timeoutMs ?? this.connector.options.requestTimeoutMs,
       signal,
-      this.state.flow
+      this.state.actorSlot
     );
   }
 };
@@ -864,7 +896,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 +912,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 +941,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 +962,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 +998,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 +1033,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 +1046,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 +1065,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 +1078,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 +1114,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 +1155,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 +1176,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 +1199,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
+      );
     }
   }
 };
@@ -1133,22 +1227,20 @@ var ZlinkStreamHeaderCodec = class {
         name: header.name,
         metadata: header.metadata.values,
         correlationId: header.correlationId,
-        flowId: header.flowId,
-        flowOrigin: encodeFlowOrigin(header.flowOrigin)
+        actorSlot: header.actorSlot
       });
     } catch (cause) {
-      throw connectorError("validationFailed" /* ValidationFailed */, streamWireErrorMessage2(cause), cause);
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        streamWireErrorMessage2(cause),
+        cause
+      );
     }
   }
-  /**
-   * `includeFlow=false` (diagnostics Off, spec 27 §4) skips reading and
-   * validating the inbound flow fields while the structural length checks in
-   * the wire decoder are preserved.
-   */
-  static decode(header, includeFlow = true) {
+  static decode(header) {
     let decoded;
     try {
-      const wire = decodeStreamWireHeader(header, void 0, includeFlow);
+      const wire = decodeStreamWireHeader(header, void 0, false);
       const metadata = wire.metadata.size === 0 ? ZlinkStreamMetadataMap.empty : ZlinkStreamMetadataMap.from(wire.metadata);
       decoded = {
         kind: wire.kind,
@@ -1158,11 +1250,14 @@ var ZlinkStreamHeaderCodec = class {
         name: wire.name,
         metadata,
         correlationId: wire.correlationId,
-        flowId: wire.flowId,
-        flowOrigin: decodeFlowOrigin(wire.flowOrigin)
+        actorSlot: wire.actorSlot
       };
     } 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)) {
@@ -1178,7 +1273,7 @@ function isReplyKind2(kind) {
 function streamWireErrorMessage2(cause) {
   return cause instanceof Error ? cause.message : "Stream header is invalid.";
 }
-function buildHeader(kind, name, codec, metadata, compress, requestSeq, correlationId, flowId, flowOrigin) {
+function buildHeader(kind, name, codec, metadata, compress, requestSeq, correlationId, actorSlot) {
   let flags = 0 /* None */;
   if (requestSeq !== void 0) {
     flags |= 1 /* HasRequestSeq */;
@@ -1192,27 +1287,49 @@ function buildHeader(kind, name, codec, metadata, compress, requestSeq, correlat
   if (correlationId !== void 0 && correlationId.length > 0) {
     flags |= 8 /* HasCorrelationId */;
   }
-  if (flowId !== void 0) flags |= 16 /* HasFlowId */;
-  return { kind, codec, flags, requestSeq, name, metadata, correlationId, flowId, flowOrigin };
+  if (actorSlot !== void 0) flags |= 32 /* HasActorSlot */;
+  return {
+    kind,
+    codec,
+    flags,
+    requestSeq,
+    name,
+    metadata,
+    correlationId,
+    actorSlot
+  };
 }
 function validateHeaderSemantics(header) {
   validateEnum(header.kind, header.codec, header.flags);
   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.");
+    const hasFlow = (header.flags & 16 /* HasFlowId */) !== 0;
+    const hasActorSlot = header.actorSlot !== void 0 || (header.flags & 32 /* HasActorSlot */) !== 0;
+    if (header.flags !== 0 /* None */ || hasRequestSeq || hasMetadata || hasCorrelation || hasFlow || hasActorSlot || header.codec !== 0 /* Raw */) {
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "Control packet must use raw codec and must not contain flags."
+      );
     }
   }
 }
@@ -1223,17 +1340,11 @@ function validateEnum(kind, codec, flags) {
   if (![0, 1, 2, 3].includes(codec)) {
     throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Unknown stream codec.");
   }
-  const known = 1 /* HasRequestSeq */ | 2 /* HasMetadata */ | 4 /* PayloadCompressed */ | 8 /* HasCorrelationId */ | 16 /* HasFlowId */;
+  const known = 1 /* HasRequestSeq */ | 2 /* HasMetadata */ | 4 /* PayloadCompressed */ | 8 /* HasCorrelationId */ | 16 /* HasFlowId */ | 32 /* HasActorSlot */;
   if ((flags & ~known) !== 0) {
     throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Unknown stream header flag.");
   }
 }
-function encodeFlowOrigin(origin) {
-  return origin === void 0 ? void 0 : { Inbound: 1, Timer: 2, Application: 3, Lifecycle: 4 }[origin];
-}
-function decodeFlowOrigin(origin) {
-  return origin === void 0 ? void 0 : { 1: "Inbound", 2: "Timer", 3: "Application", 4: "Lifecycle" }[origin];
-}
 
 // packages/stream-connector/src/Runtime/Protocol/ZlinkStreamFrameProtocol.ts
 var ZLINK_STREAM_HEARTBEAT_PING = "$zlink.heartbeat.ping";
@@ -1242,37 +1353,47 @@ var ZlinkStreamFrameProtocol = class {
   constructor(options) {
     this.options = options;
   }
-  encode(kind, name, payload, metadata, compress, requestSeq, correlationId, flowId, flowOrigin) {
+  encode(kind, name, payload, metadata, compress, requestSeq, correlationId, actorSlot) {
     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,
+      actorSlot
+    );
     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()) {
+  decode(frameBytes) {
     const frame = ZlinkStreamFrameCodec.decode(frameBytes);
     return {
-      // Spec 27 §4: with diagnostics Off the inbound flow fields are neither
-      // read nor validated (structural length checks are preserved).
-      header: ZlinkStreamHeaderCodec.decode(frame.header, flowEnabled),
+      header: ZlinkStreamHeaderCodec.decode(frame.header),
       payload: frame.payload
     };
   }
-  flowEnabled() {
-    return this.options.diagnosticsLevel !== "off" /* Off */;
-  }
-  decodeFrames(chunk, flowEnabled = this.flowEnabled()) {
+  decodeFrames(chunk) {
     return splitZlinkStreamFrames(chunk).map((frame) => {
-      const decoded = this.decode(frame, flowEnabled);
+      const decoded = this.decode(frame);
       if (decoded.payload.length > this.options.maxReceivePayloadSize) {
-        throw connectorError("frameTooLarge" /* FrameTooLarge */, "Payload exceeds MaxReceivePayloadSize.");
+        throw connectorError(
+          "frameTooLarge" /* FrameTooLarge */,
+          "Payload exceeds MaxReceivePayloadSize."
+        );
       }
       return decoded;
     });
@@ -1319,12 +1440,6 @@ function parseEndpoint(endpoint) {
 }
 
 // packages/stream-connector/src/Runtime/ZlinkStreamConnectorOptions.ts
-var validDiagnosticsLevels = /* @__PURE__ */ new Set([
-  "off" /* Off */,
-  "errors" /* Errors */,
-  "normal" /* Normal */,
-  "detailed" /* Detailed */
-]);
 function normalizeOptions(options, defaultTransportFactory) {
   const endpoint = options.endpoint;
   if (endpoint.trim().length === 0) {
@@ -1332,7 +1447,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");
@@ -1341,7 +1459,6 @@ function normalizeOptions(options, defaultTransportFactory) {
   validatePositive(options.maxReceivePayloadSize ?? 64 * 1024, "MaxReceivePayloadSize");
   validateHeartbeat(options.heartbeat);
   validateReconnect(options.reconnect);
-  validateDiagnosticsLevel(options.diagnosticsLevel);
   return {
     endpoint,
     transport: inferredTransport,
@@ -1367,10 +1484,7 @@ function normalizeOptions(options, defaultTransportFactory) {
     compressionCodec: resolveCompressionCodec2(options),
     nameResolver: options.nameResolver ?? defaultPacketNameResolver,
     transportFactory: options.transportFactory ?? defaultTransportFactory,
-    codec: options.codec,
-    // Spec 26 §4: the default diagnostics level is Errors, which preserves
-    // the connector's established wire behavior.
-    diagnosticsLevel: options.diagnosticsLevel ?? "errors" /* Errors */
+    codec: options.codec
   };
 }
 var defaultPacketNameResolver = {
@@ -1386,17 +1500,15 @@ 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;
   }
   return options.compressionCodec;
 }
-function validateDiagnosticsLevel(level) {
-  if (level !== void 0 && !validDiagnosticsLevels.has(level)) {
-    throw connectorError("configurationError" /* ConfigurationError */, "DiagnosticsLevel is invalid.");
-  }
-}
 function validatePositive(value, name) {
   if (value <= 0) {
     throw connectorError("validationFailed" /* ValidationFailed */, `${name} must be positive.`);
@@ -1412,7 +1524,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,33 +1538,20 @@ 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."
+    );
   }
 }
 
-// packages/stream-connector/src/Runtime/ZlinkStreamDiagnosticsLevelCell.ts
-var ZlinkStreamDiagnosticsLevelCell = class {
-  current;
-  constructor(initial) {
-    this.current = initial;
-  }
-  get level() {
-    return this.current;
-  }
-  set(level) {
-    const candidate = level;
-    if (candidate === void 0 || candidate === null) {
-      throw connectorError("configurationError" /* ConfigurationError */, "DiagnosticsLevel is invalid.");
-    }
-    validateDiagnosticsLevel(level);
-    this.current = level;
-  }
-};
-
 // packages/stream-connector/src/Runtime/ZlinkStreamPendingRequests.ts
 var ZlinkStreamPendingRequests = class {
   nextRequestSeq = 1n;
@@ -1462,14 +1564,21 @@ var ZlinkStreamPendingRequests = class {
     let timeout;
     let resolvePending;
     let rejectPending;
-    const promise = new Promise((resolve, reject) => {
-      timeout = setTimeout(() => {
-        this.active.delete(requestSeq);
-        reject(connectorError("requestTimeout" /* RequestTimeout */, `Request '${packetName}' timed out.`));
-      }, timeoutMs);
-      resolvePending = resolve;
-      rejectPending = (error) => reject(connectorError(error.code, error.message, error.cause));
-    });
+    const promise = new Promise(
+      (resolve, reject) => {
+        timeout = setTimeout(() => {
+          this.active.delete(requestSeq);
+          reject(
+            connectorError(
+              "requestTimeout" /* RequestTimeout */,
+              `Request '${packetName}' timed out.`
+            )
+          );
+        }, timeoutMs);
+        resolvePending = resolve;
+        rejectPending = (error) => reject(connectorError(error.code, error.message, error.cause));
+      }
+    );
     this.active.set(requestSeq, {
       packetName,
       promise,
@@ -1493,15 +1602,14 @@ var ZlinkStreamPendingRequests = class {
     });
     return { requestSeq, promise };
   }
-  /* stream connector spec §5.2: a pending request is matched by request_seq alone. Diagnostics
-   * use the original request name retained by this registry, never a legacy reply name. */
-  resolve(requestSeq, value) {
+  /* stream connector spec §5.2: a pending request is matched by request_seq alone. */
+  resolve(requestSeq, value, metadata) {
     const pending = this.active.get(requestSeq);
     if (pending === void 0) {
       return false;
     }
     this.active.delete(requestSeq);
-    pending.resolve(value);
+    pending.resolve({ name: pending.packetName, metadata, payload: value });
     return true;
   }
   reject(requestSeq, error) {
@@ -1637,9 +1745,11 @@ var ZlinkStreamReceivedMessages = class {
    */
   resetForNewConnection() {
     this.receivedCounts.clear();
+    const submittedCallbacks = this.queue.slice(this.queueHead).filter((item) => item?.kind === "callback");
     this.queue.length = 0;
+    this.queue.push(...submittedCallbacks);
     this.queueHead = 0;
-    this.queuedCount = 0;
+    this.queuedCount = submittedCallbacks.length;
   }
   /**
    * Releases every registered wait surface because the connection it was
@@ -1668,7 +1778,14 @@ var ZlinkStreamReceivedMessages = class {
         return;
       }
     }
-    this.queue.push({ message, signal });
+    this.queue.push({ kind: "message", message, signal });
+    this.queuedCount += 1;
+    if (this.deliverOnArrival) {
+      this.scheduleDrain();
+    }
+  }
+  enqueueCallback(callback) {
+    this.queue.push({ kind: "callback", callback });
     this.queuedCount += 1;
     if (this.deliverOnArrival) {
       this.scheduleDrain();
@@ -1695,7 +1812,7 @@ var ZlinkStreamReceivedMessages = class {
   offerQueued(name, registration) {
     for (let index = this.queueHead; index < this.queue.length; index += 1) {
       const queued = this.queue[index];
-      if (queued === void 0 || queued.message.name !== name) {
+      if (queued === void 0 || queued.kind !== "message" || queued.message.name !== name) {
         continue;
       }
       if (!registration.consume(queued.message)) {
@@ -1723,17 +1840,24 @@ var ZlinkStreamReceivedMessages = class {
         const queued = this.queue[index];
         if (queued === void 0) continue;
         this.removeAt(index);
+        if (queued.kind === "callback") {
+          await queued.callback();
+          continue;
+        }
         const { message, signal } = queued;
         const handlers = [...this.handlers.get(message.name)];
         for (const handler of handlers) {
           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
+            );
           }
         }
       }
@@ -1750,7 +1874,7 @@ var ZlinkStreamReceivedMessages = class {
   findDeliverableIndex() {
     for (let index = this.queueHead; index < this.queue.length; index += 1) {
       const queued = this.queue[index];
-      if (queued !== void 0 && (this.handlers.get(queued.message.name)?.size ?? 0) > 0) {
+      if (queued !== void 0 && (queued.kind === "callback" || (this.handlers.get(queued.message.name)?.size ?? 0) > 0)) {
         return index;
       }
     }
@@ -1758,7 +1882,8 @@ var ZlinkStreamReceivedMessages = class {
   }
   hasQueuedMessage(name) {
     for (let index = this.queueHead; index < this.queue.length; index += 1) {
-      if (this.queue[index]?.message.name === name) return true;
+      const queued = this.queue[index];
+      if (queued?.kind === "message" && queued.message.name === name) return true;
     }
     return false;
   }
@@ -1782,17 +1907,24 @@ var ZlinkStreamReceivedMessages = class {
 
 // packages/stream-connector/src/Runtime/ZlinkStreamFrameSender.ts
 var ZlinkStreamFrameSender = class {
-  constructor(protocol, flowContext) {
+  constructor(protocol) {
     this.protocol = protocol;
-    this.flowContext = flowContext;
   }
   pendingWrites = /* @__PURE__ */ new Set();
-  async send(connection, kind, name, payload, metadata, compress, requestSeq, signal, correlationId, explicitFlow) {
+  async send(connection, kind, name, payload, metadata, compress, requestSeq, signal, correlationId, actorSlot) {
     throwIfAborted(signal);
-    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,
+        actorSlot
+      ),
       signal
     );
   }
@@ -1827,24 +1959,196 @@ 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 };
 }
 
+// packages/stream-connector/src/Runtime/ZlinkStreamActors.ts
+var ACTOR_BOUND = "$zlink.actor.bound";
+var ACTOR_UNBOUND = "$zlink.actor.unbound";
+var zlinkStreamActorBinding = Symbol("zlink.stream.actorBinding");
+var DefaultZlinkStreamActor = class {
+  constructor(connector, actorId, slot) {
+    this.connector = connector;
+    this.actorId = actorId;
+    this.slot = slot;
+  }
+  bound = true;
+  get isBound() {
+    return this.bound;
+  }
+  send(payload, messageType) {
+    this.ensureBound();
+    return this.connector.sendForActor(this, payload, messageType);
+  }
+  request(payload, messageType) {
+    this.ensureBound();
+    return this.connector.requestForActor(this, payload, messageType);
+  }
+  on(nameOrType, handler, messageType) {
+    return this.connector.onActorMessage(this, nameOrType, handler, messageType);
+  }
+  ensureBound() {
+    if (!this.bound) {
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        `Actor '${this.actorId}' is no longer bound.`
+      );
+    }
+  }
+  close() {
+    this.bound = false;
+  }
+};
+var ZlinkStreamActors = class {
+  constructor(connector, receivedMessages, events) {
+    this.connector = connector;
+    this.receivedMessages = receivedMessages;
+    this.events = events;
+  }
+  bySlot = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  issued = [];
+  boundHandlers = /* @__PURE__ */ new Set();
+  unboundHandlers = /* @__PURE__ */ new Set();
+  get snapshot() {
+    return Object.freeze([...this.bySlot.values()]);
+  }
+  find(actorId) {
+    return this.byId.get(actorId);
+  }
+  onBound(handler) {
+    this.boundHandlers.add(handler);
+    return subscription(() => this.boundHandlers.delete(handler));
+  }
+  onUnbound(handler) {
+    this.unboundHandlers.add(handler);
+    return subscription(() => this.unboundHandlers.delete(handler));
+  }
+  processControl(name, payload, signal) {
+    if (name === ACTOR_BOUND) {
+      this.bind(payload, signal);
+      return true;
+    }
+    if (name === ACTOR_UNBOUND) {
+      this.unbind(payload, signal);
+      return true;
+    }
+    return false;
+  }
+  resolve(slot) {
+    const actor = this.bySlot.get(slot);
+    if (actor === void 0) {
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        `Actor slot '${slot}' is not bound.`
+      );
+    }
+    return actor;
+  }
+  closeAll(signal) {
+    for (const actor of this.issued) {
+      if (!actor.isBound) continue;
+      this.bySlot.delete(actor.slot);
+      this.byId.delete(actor.actorId);
+      actor.close();
+      this.queue(this.unboundHandlers, actor, signal);
+    }
+    this.issued.length = 0;
+  }
+  bind(payload, signal) {
+    if (payload.length < 5 || payload[0] !== 1) {
+      throw invalidControl("Actor bound payload is invalid.");
+    }
+    const slot = payload[1] << 8 | payload[2];
+    const idLength = payload[3];
+    if (slot === 0 || idLength === 0 || payload.length !== 4 + idLength) {
+      throw invalidControl("Actor bound payload is invalid.");
+    }
+    let actorId;
+    try {
+      actorId = new TextDecoder("utf-8", { fatal: true }).decode(payload.subarray(4));
+    } catch (cause) {
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        "Actor id is not valid UTF-8.",
+        cause
+      );
+    }
+    if (actorId.length === 0 || this.bySlot.has(slot) || this.byId.has(actorId)) {
+      throw invalidControl("Actor bound identity is already in use.");
+    }
+    const actor = new DefaultZlinkStreamActor(this.connector, actorId, slot);
+    this.bySlot.set(slot, actor);
+    this.byId.set(actorId, actor);
+    this.issued.push(actor);
+    this.queue(this.boundHandlers, actor, signal);
+  }
+  unbind(payload, signal) {
+    if (payload.length !== 3 || payload[0] !== 1) {
+      throw invalidControl("Actor unbound payload is invalid.");
+    }
+    const slot = payload[1] << 8 | payload[2];
+    const actor = this.bySlot.get(slot);
+    if (slot === 0 || actor === void 0) {
+      throw invalidControl(`Actor slot '${slot}' is not bound.`);
+    }
+    this.bySlot.delete(slot);
+    this.byId.delete(actor.actorId);
+    actor.close();
+    this.queue(this.unboundHandlers, actor, signal);
+  }
+  queue(handlers, actor, signal) {
+    this.receivedMessages.enqueueCallback(() => {
+      for (const handler of [...handlers]) {
+        this.invoke(handler, actor, signal);
+      }
+    });
+  }
+  invoke(handler, actor, signal) {
+    try {
+      Promise.resolve(handler(actor, signal)).catch((cause) => {
+        void this.events.publishError(
+          {
+            code: "userCallbackFailed" /* UserCallbackFailed */,
+            message: "Actor lifecycle handler failed.",
+            cause
+          },
+          signal
+        );
+      });
+    } catch (cause) {
+      void this.events.publishError(
+        {
+          code: "userCallbackFailed" /* UserCallbackFailed */,
+          message: "Actor lifecycle handler failed.",
+          cause
+        },
+        signal
+      );
+    }
+  }
+};
+function invalidControl(message) {
+  return connectorError("frameDecodeFailed" /* FrameDecodeFailed */, message);
+}
+
 // packages/stream-connector/src/Runtime/ZlinkStreamReceiveDispatcher.ts
 var ZlinkStreamReceiveDispatcher = class {
-  constructor(protocol, pendingRequests, receivedMessages, frameSender, events, flowContext, serverClosing) {
+  constructor(protocol, pendingRequests, receivedMessages, frameSender, events, actors, serverClosing) {
     this.protocol = protocol;
     this.pendingRequests = pendingRequests;
     this.receivedMessages = receivedMessages;
     this.frameSender = frameSender;
     this.events = events;
-    this.flowContext = flowContext;
+    this.actors = actors;
     this.serverClosing = serverClosing;
   }
   /**
@@ -1871,46 +2175,54 @@ var ZlinkStreamReceiveDispatcher = class {
     if (frameBytes === void 0) {
       return { available: false, inbound: false };
     }
-    const flowEnabled = this.protocol.flowEnabled();
     let frames;
     try {
-      frames = this.protocol.decodeFrames(frameBytes, flowEnabled);
+      frames = this.protocol.decodeFrames(frameBytes);
     } catch (cause) {
-      await this.events.publishError(
-        toStreamError(cause, "frameDecodeFailed" /* FrameDecodeFailed */, "Frame decode failed."),
-        signal
-      );
-      return { available: true, inbound: false };
+      throw cause;
     }
     for (const frame of frames) {
       if (isCurrent !== void 0 && !isCurrent()) {
         break;
       }
       try {
-        await this.dispatch(connection, frame.header, frame.payload, signal, flowEnabled, connectionForSend);
+        await this.dispatch(connection, frame.header, frame.payload, signal, connectionForSend);
       } catch (cause) {
         if (frame.header.kind === 5 /* Control */ && frame.header.name === ZLINK_STREAM_HEARTBEAT_PING) {
           throw cause;
         }
-        await this.events.publishError(
-          toStreamError(cause, "frameDecodeFailed" /* FrameDecodeFailed */, "Frame dispatch failed."),
-          signal
+        const error = toStreamError(
+          cause,
+          "frameDecodeFailed" /* FrameDecodeFailed */,
+          "Frame dispatch failed."
         );
+        if (error.code === "frameDecodeFailed" /* FrameDecodeFailed */) {
+          throw cause;
+        }
+        await this.events.publishError(error, signal);
       }
     }
     return { available: true, inbound: true };
   }
-  async dispatch(connection, header, payload, signal, flowEnabled, connectionForSend) {
+  async dispatch(connection, header, payload, signal, connectionForSend) {
+    const actor = header.actorSlot === void 0 ? void 0 : this.actors.resolve(header.actorSlot);
     if (header.kind === 3 /* Response */ && header.requestSeq !== void 0) {
       try {
-        if (!this.pendingRequests.resolve(header.requestSeq, {
-          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);
+        if (!this.pendingRequests.resolve(
+          header.requestSeq,
+          {
+            codec: header.codec,
+            payload: this.protocol.decodePayload(header, payload)
+          },
+          header.metadata
+        )) {
+          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 +2230,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 +2248,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);
         }
       }
@@ -1957,24 +2263,32 @@ var ZlinkStreamReceiveDispatcher = class {
       return;
     }
     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) },
+          actorId: actor?.actorId,
+          [zlinkStreamActorBinding]: actor
+        },
+        signal
+      );
     }
   }
   async dispatchControl(connection, header, payload, signal, connectionForSend) {
+    if (this.actors.processControl(header.name, payload, signal)) {
+      return;
+    }
     if (header.name === ZLINK_SESSION_CLOSING) {
       const closing = decodeSessionClosing(payload);
       await this.serverClosing?.(closing.closeReason);
       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 +2316,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(
@@ -2019,12 +2337,13 @@ function randomizedDelay(baseDelayMs) {
   return Math.round(baseDelayMs * (0.5 + Math.random() * 0.5));
 }
 var ZlinkStreamConnectorLifecycle = class {
-  constructor(options, pendingRequests, frameSender, receiveDispatcher, receivedMessages, events) {
+  constructor(options, pendingRequests, frameSender, receiveDispatcher, receivedMessages, actors, events) {
     this.options = options;
     this.pendingRequests = pendingRequests;
     this.frameSender = frameSender;
     this.receiveDispatcher = receiveDispatcher;
     this.receivedMessages = receivedMessages;
+    this.actors = actors;
     this.events = events;
   }
   receiveLoopAbort;
@@ -2081,7 +2400,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 +2442,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,10 +2474,14 @@ 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);
+    this.actors.closeAll(signal);
+    this.queueState("closed" /* Closed */, void 0, signal);
+    this.queueDisconnected(signal);
     if (errors.length === 1) throw errors[0];
     if (errors.length > 1) throw new AggregateError(errors, "Stream connector close failed.");
   }
@@ -2270,7 +2603,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 +2666,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;
@@ -2369,6 +2710,7 @@ var ZlinkStreamConnectorLifecycle = class {
     this.currentConnection = void 0;
     this.pendingRequests.failAll(error);
     this.receivedMessages.connectionEnded();
+    this.actors.closeAll();
     try {
       await connection?.close();
     } catch {
@@ -2384,11 +2726,8 @@ var ZlinkStreamConnectorLifecycle = class {
    */
   async announceDisconnect(error) {
     if (this.closeRequested) return;
-    const announce = this.claimDisconnectedPublish();
-    void this.setState("disconnected" /* Disconnected */, error);
-    if (announce) {
-      void this.events.publishDisconnected().catch(() => void 0);
-    }
+    this.queueState("disconnected" /* Disconnected */, error);
+    this.queueDisconnected();
     if (this.shouldReconnect()) {
       queueMicrotask(() => {
         void this.connect().catch(() => void 0);
@@ -2436,16 +2775,35 @@ var ZlinkStreamConnectorLifecycle = class {
   publishDisconnectedWithoutWaiting(signal) {
     void this.publishDisconnectedOnce(signal).catch(() => void 0);
   }
+  queueDisconnected(signal) {
+    if (!this.claimDisconnectedPublish()) return;
+    this.receivedMessages.enqueueCallback(() => {
+      void this.events.publishDisconnected(signal).catch(() => void 0);
+    });
+  }
+  queueState(current, error, signal) {
+    const change = this.transitionState(current, error);
+    if (change === void 0) return;
+    this.receivedMessages.enqueueCallback(() => {
+      void this.publishStateChange(change, signal).catch(() => void 0);
+    });
+  }
   async setState(current, error, signal) {
+    const change = this.transitionState(current, error);
+    if (change === void 0) return;
+    await this.publishStateChange(change, signal);
+  }
+  transitionState(current, error) {
     const previous = this.currentState;
     this.currentState = current;
     if (previous === current && error === void 0) {
-      return;
-    }
-    await this.events.publishStateChanged({ previous, current, error }, signal);
-    if (error !== void 0) {
-      await this.events.publishError(error, signal);
+      return void 0;
     }
+    return { previous, current, error };
+  }
+  async publishStateChange(change, signal) {
+    await this.events.publishStateChanged(change, signal);
+    if (change.error !== void 0) await this.events.publishError(change.error, signal);
   }
 };
 
@@ -2480,36 +2838,6 @@ var ZlinkStreamConnectorEvents = class {
   }
 };
 
-// packages/stream-connector/src/Runtime/ZlinkFlowContext.ts
-var BrowserZlinkFlowContext = class {
-  currentOrCreate(explicit) {
-    return explicit ?? { flowId: this.createUuidV7(), flowOrigin: "Application" };
-  }
-  createInbound(flowId, flowOrigin) {
-    return { flowId: flowId ?? this.createUuidV7(), flowOrigin: flowOrigin ?? "Inbound" };
-  }
-  createUuidV7() {
-    const crypto = globalThis.crypto;
-    if (crypto === void 0) {
-      throw connectorError(
-        "configurationError" /* ConfigurationError */,
-        "The browser entrypoint requires the platform Web Crypto API."
-      );
-    }
-    return formatUuidV7(crypto.getRandomValues(new Uint8Array(16)));
-  }
-};
-function formatUuidV7(bytes) {
-  const timestamp = BigInt(Date.now());
-  for (let index = 5; index >= 0; index -= 1) {
-    bytes[index] = Number(timestamp >> BigInt((5 - index) * 8) & 0xffn);
-  }
-  bytes[6] = 112 | bytes[6] & 15;
-  bytes[8] = 128 | bytes[8] & 63;
-  const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-
 // packages/stream-connector/src/Runtime/Transport/BrowserWebSocketConnection.ts
 var BrowserStreamTransportFactory = class {
   async connect(options, signal) {
@@ -2584,7 +2912,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 +2924,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 +3001,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 +3035,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
@@ -2707,30 +3052,26 @@ var DefaultZlinkStreamConnector = class {
   pendingRequests = new ZlinkStreamPendingRequests();
   frameSender;
   receiveDispatcher;
-  diagnosticsLevelCell;
+  requestSendingHandlers = /* @__PURE__ */ new Set();
+  replyReceivedHandlers = /* @__PURE__ */ new Set();
+  boundActors;
   options;
   constructor(options) {
-    const flowContext = new BrowserZlinkFlowContext();
     this.options = normalizeOptions(options, new BrowserStreamTransportFactory());
-    this.diagnosticsLevelCell = new ZlinkStreamDiagnosticsLevelCell(this.options.diagnosticsLevel);
-    Object.defineProperty(this.options, "diagnosticsLevel", {
-      enumerable: true,
-      configurable: true,
-      get: () => this.diagnosticsLevelCell.level
-    });
     const protocol = new ZlinkStreamFrameProtocol(this.options);
-    this.frameSender = new ZlinkStreamFrameSender(protocol, flowContext);
+    this.frameSender = new ZlinkStreamFrameSender(protocol);
     this.receivedMessages = new ZlinkStreamReceivedMessages(
       this.events,
       this.options.dispatchMode === "immediate" /* Immediate */
     );
+    this.boundActors = new ZlinkStreamActors(this, this.receivedMessages, this.events);
     this.receiveDispatcher = new ZlinkStreamReceiveDispatcher(
       protocol,
       this.pendingRequests,
       this.receivedMessages,
       this.frameSender,
       this.events,
-      flowContext,
+      this.boundActors,
       (reason) => this.lifecycle.serverClosing(reason)
     );
     this.lifecycle = new ZlinkStreamConnectorLifecycle(
@@ -2739,6 +3080,7 @@ var DefaultZlinkStreamConnector = class {
       this.frameSender,
       this.receiveDispatcher,
       this.receivedMessages,
+      this.boundActors,
       this.events
     );
   }
@@ -2754,6 +3096,18 @@ var DefaultZlinkStreamConnector = class {
   get pendingDispatchCount() {
     return this.pendingRequests.count;
   }
+  get actors() {
+    return this.boundActors.snapshot;
+  }
+  actor(actorId) {
+    return this.boundActors.find(actorId);
+  }
+  onActorBound(handler) {
+    return this.boundActors.onBound(handler);
+  }
+  onActorUnbound(handler) {
+    return this.boundActors.onUnbound(handler);
+  }
   /**
    * Spec stream-connector 32 §10: how many packets carrying `name` arrived on
    * the current connection. Arrivals are what is counted, so a message a
@@ -2765,37 +3119,6 @@ var DefaultZlinkStreamConnector = class {
     validateName(name);
     return this.receivedMessages.receivedCount(name);
   }
-  /**
-   * Current diagnostics level (spec 26 §4.1, spec stream-connector 32 §13).
-   * Reflects the level set by the most recent {@link setDiagnosticsLevel}
-   * call, or the construction-time option (default
-   * {@link ZlinkStreamDiagnosticsLevel.Errors}) if it was never changed.
-   */
-  get diagnosticsLevel() {
-    return this.diagnosticsLevelCell.level;
-  }
-  /**
-   * Changes the diagnostics level in place without recreating the connector
-   * (spec 26 §4.1, spec stream-connector 32 §13). The change is an atomic
-   * state update: it applies to processing points that read the level after
-   * this call returns and is never applied retroactively to frames already
-   * built. Rejects unknown values with {@link ZlinkStreamErrorCode.ConfigurationError}.
-   * Spec stream-connector 32 §13: this surface changes the value without
-   * waiting for anything; it is not a blocking call over the asynchronous pair,
-   * which a receive callback would otherwise make wait for its own completion.
-   */
-  setDiagnosticsLevel(level) {
-    this.diagnosticsLevelCell.set(level);
-  }
-  /**
-   * Asynchronous counterpart of {@link setDiagnosticsLevel} (spec
-   * stream-connector 32 §13). It changes the same value; awaiting it is how a
-   * caller observes the change, and it never replaces the synchronous surface.
-   */
-  setDiagnosticsLevelAsync(level) {
-    this.setDiagnosticsLevel(level);
-    return Promise.resolve();
-  }
   onErrorReceived(handler) {
     return this.events.onError(handler);
   }
@@ -2805,6 +3128,14 @@ var DefaultZlinkStreamConnector = class {
   onConnectionStateChanged(handler) {
     return this.events.onStateChanged(handler);
   }
+  onRequestSending(handler) {
+    this.requestSendingHandlers.add(handler);
+    return subscription(() => this.requestSendingHandlers.delete(handler));
+  }
+  onReplyReceived(handler) {
+    this.replyReceivedHandlers.add(handler);
+    return subscription(() => this.replyReceivedHandlers.delete(handler));
+  }
   async connect(signal) {
     await this.lifecycle.connect(signal);
   }
@@ -2822,15 +3153,60 @@ var DefaultZlinkStreamConnector = class {
     const encoded = this.encodePayload(payload, messageType);
     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);
-    return this.receivedMessages.on(name, encodedHandler);
+  on(nameOrType, handler, messageType) {
+    const encodedHandler = (message, signal) => handler(
+      {
+        name: message.name,
+        metadata: message.metadata,
+        payload: this.decodePayload(
+          message.payload,
+          messageType ?? (typeof nameOrType === "function" ? nameOrType : void 0)
+        ),
+        actorId: message.actorId
+      },
+      signal
+    );
+    return this.receivedMessages.on(this.observedName(nameOrType), encodedHandler);
+  }
+  sendForActor(actor, payload, messageType) {
+    const encoded = this.encodePayload(payload, messageType);
+    return new ZlinkStreamSendBuilder(
+      this,
+      this.resolveNameOrDefault(encoded),
+      encoded,
+      actor.slot,
+      () => actor.ensureBound()
+    );
+  }
+  requestForActor(actor, payload, messageType) {
+    const encoded = this.encodePayload(payload, messageType);
+    return new ZlinkStreamRequestBuilder(
+      this,
+      this.resolveNameOrDefault(encoded),
+      encoded,
+      actor.slot,
+      () => actor.ensureBound()
+    );
+  }
+  onActorMessage(actor, nameOrType, handler, messageType) {
+    const encodedHandler = (message, signal) => {
+      if (message[zlinkStreamActorBinding] !== actor) {
+        return;
+      }
+      return handler(
+        {
+          name: message.name,
+          metadata: message.metadata,
+          payload: this.decodePayload(
+            message.payload,
+            messageType ?? (typeof nameOrType === "function" ? nameOrType : void 0)
+          ),
+          actorId: message.actorId
+        },
+        signal
+      );
+    };
+    return this.receivedMessages.on(this.observedName(nameOrType), encodedHandler);
   }
   waitFor(nameOrType) {
     return new ZlinkStreamWaitBuilder(this, this.observedName(nameOrType));
@@ -2850,7 +3226,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 +3249,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 +3278,35 @@ 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),
+              actorId: message.actorId
+            };
+            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) {
@@ -2941,7 +3328,7 @@ var DefaultZlinkStreamConnector = class {
     }
     return payload;
   }
-  async sendEncoded(kind, name, payload, metadata, compress, requestSeq, signal, flow, correlationId) {
+  async sendEncoded(kind, name, payload, metadata, compress, requestSeq, signal, correlationId, actorSlot) {
     await this.frameSender.send(
       this.lifecycle.connectionForSend(),
       kind,
@@ -2952,37 +3339,105 @@ var DefaultZlinkStreamConnector = class {
       requestSeq,
       signal,
       correlationId,
-      flow
+      actorSlot
     );
   }
   /**
    * Per-connector monotonic correlation id (hex). The client generates it on each request
-   * and the server echoes it back on the reply, so flows can be joined across the wire.
+   * and the server echoes it back on the reply.
    */
   nextCorrelationId() {
     this.correlationCounter += 1n;
     return this.correlationCounter.toString(16);
   }
-  async requestEncoded(name, payload, metadata, compress, timeoutMs, signal, flow) {
-    const pending = this.pendingRequests.create(name, timeoutMs);
+  async requestEncoded(name, payload, metadata, compress, timeoutMs, signal, actorSlot) {
+    const startedAt = Date.now();
+    const actorId = actorSlot === void 0 ? void 0 : this.boundActors.resolve(actorSlot).actorId;
+    let requestMetadata = metadata;
+    const sendingContext = {
+      requestPacketName: name,
+      actorId,
+      setMetadata(key, value) {
+        requestMetadata = requestMetadata.with(key, value);
+      }
+    };
+    let pending;
     try {
+      throwIfAborted(signal);
+      for (const handler of [...this.requestSendingHandlers]) {
+        try {
+          handler(sendingContext);
+        } catch (cause) {
+          queueMicrotask(() => {
+            void this.events.publishError(
+              toStreamError(
+                cause,
+                "userCallbackFailed" /* UserCallbackFailed */,
+                "Request sending hook failed."
+              ),
+              signal
+            );
+          });
+        }
+      }
+      pending = this.pendingRequests.create(name, timeoutMs);
       await this.sendEncoded(
         2 /* Request */,
         name,
         payload,
-        metadata,
+        requestMetadata,
         compress,
         pending.requestSeq,
         signal,
-        flow,
-        this.nextCorrelationId()
+        this.nextCorrelationId(),
+        actorSlot
       );
-      return await pending.promise;
+      const reply = await pending.promise;
+      this.publishReplyReceived(
+        {
+          requestPacketName: name,
+          actorId,
+          succeeded: true,
+          reply: { ...reply, actorId },
+          elapsed: Date.now() - startedAt
+        },
+        signal
+      );
+      return reply.payload;
     } catch (error) {
-      this.pendingRequests.cancel(pending.requestSeq);
+      if (pending !== void 0) this.pendingRequests.cancel(pending.requestSeq);
+      this.publishReplyReceived(
+        {
+          requestPacketName: name,
+          actorId,
+          succeeded: false,
+          error: unwrapStreamError(error),
+          elapsed: Date.now() - startedAt
+        },
+        signal
+      );
       throw error;
     }
   }
+  publishReplyReceived(context, signal) {
+    if (this.replyReceivedHandlers.size === 0) return;
+    this.receivedMessages.enqueueCallback(async () => {
+      for (const handler of [...this.replyReceivedHandlers]) {
+        try {
+          await handler(context, signal);
+        } catch (cause) {
+          await this.events.publishError(
+            toStreamError(
+              cause,
+              "userCallbackFailed" /* UserCallbackFailed */,
+              "Reply received hook failed."
+            ),
+            signal
+          );
+        }
+      }
+    });
+  }
   resolveNameOrDefault(payload) {
     if (payload.messageType === void 0) {
       return void 0;
@@ -3008,7 +3463,6 @@ export {
   ZlinkStreamCodec,
   ZlinkStreamCompression,
   ZlinkStreamConnectionState,
-  ZlinkStreamDiagnosticsLevel,
   ZlinkStreamDispatchMode,
   ZlinkStreamErrorCode,
   ZlinkStreamException,