@zlink-systems/stream-connector 0.21.0 → 0.23.0

package/dist/browser/index.global.js

@@ -26,7 +26,6 @@ var ZlinkStreamConnectorBundle = (() => {
     ZlinkStreamCodec: () => ZlinkStreamCodec,
     ZlinkStreamCompression: () => ZlinkStreamCompression,
     ZlinkStreamConnectionState: () => ZlinkStreamConnectionState,
-    ZlinkStreamDiagnosticsLevel: () => ZlinkStreamDiagnosticsLevel,
     ZlinkStreamDispatchMode: () => ZlinkStreamDispatchMode,
     ZlinkStreamErrorCode: () => ZlinkStreamErrorCode,
     ZlinkStreamException: () => ZlinkStreamException,
@@ -165,7 +164,8 @@ var ZlinkStreamConnectorBundle = (() => {
     hasRequestSeq: 1,
     hasMetadata: 2,
     hasCorrelationId: 8,
-    hasFlowId: 16
+    hasFlowId: 16,
+    hasActorSlot: 32
   };
   var ZLINK_STREAM_FORMAT_MARKER = 242;
   var ZLINK_STREAM_RESPONSE_KIND = 3;
@@ -212,6 +212,7 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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.");
     }
@@ -219,13 +220,17 @@ var ZlinkStreamConnectorBundle = (() => {
     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;
@@ -258,6 +263,9 @@ var ZlinkStreamConnectorBundle = (() => {
       offset += 36;
       buffer[offset++] = header.flowOrigin;
     }
+    if (hasActorSlot) {
+      writeUInt16BE(buffer, offset, header.actorSlot);
+    }
     return buffer;
   }
   function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
@@ -276,7 +284,8 @@ var ZlinkStreamConnectorBundle = (() => {
     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;
@@ -331,6 +340,17 @@ var ZlinkStreamConnectorBundle = (() => {
       }
       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.");
     }
@@ -343,7 +363,8 @@ var ZlinkStreamConnectorBundle = (() => {
       metadata: decodedMetadata.metadata,
       correlationId,
       flowId,
-      flowOrigin
+      flowOrigin,
+      actorSlot
     };
   }
   function validateFlowId(flowId) {
@@ -509,13 +530,6 @@ var ZlinkStreamConnectorBundle = (() => {
     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";
@@ -531,6 +545,7 @@ var ZlinkStreamConnectorBundle = (() => {
     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) => {
@@ -675,7 +690,11 @@ var ZlinkStreamConnectorBundle = (() => {
     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 };
@@ -710,7 +729,10 @@ var ZlinkStreamConnectorBundle = (() => {
   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);
@@ -759,43 +781,58 @@ var ZlinkStreamConnectorBundle = (() => {
       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) {
+    constructor(name, actorSlot, validateActor) {
+      this.actorSlot = actorSlot;
+      this.validateActor = validateActor;
       __publicField(this, "executed", false);
       __publicField(this, "name");
       __publicField(this, "metadata", ZlinkStreamMetadataMap.empty);
       __publicField(this, "timeoutMs");
       __publicField(this, "compress", false);
-      __publicField(this, "flow");
       this.name = name;
     }
     ensureNotExecuted() {
+      var _a;
       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;
+      (_a = this.validateActor) == null ? void 0 : _a.call(this);
     }
     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;
       __publicField(this, "state");
-      this.state = new ZlinkStreamCallBuilderState(name);
+      this.state = new ZlinkStreamCallBuilderState(name, actorSlot, validateActor);
     }
     packetName(name) {
       validateName(name);
@@ -810,10 +847,6 @@ var ZlinkStreamConnectorBundle = (() => {
       this.state.compress = true;
       return this;
     }
-    flowFrom(flow) {
-      this.state.flow = flow;
-      return this;
-    }
     async submit(signal) {
       throwIfAborted(signal);
       this.state.ensureNotExecuted();
@@ -825,16 +858,17 @@ var ZlinkStreamConnectorBundle = (() => {
         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;
       __publicField(this, "state");
-      this.state = new ZlinkStreamCallBuilderState(name);
+      this.state = new ZlinkStreamCallBuilderState(name, actorSlot, validateActor);
     }
     packetName(name) {
       validateName(name);
@@ -853,10 +887,6 @@ var ZlinkStreamConnectorBundle = (() => {
       this.state.compress = true;
       return this;
     }
-    flowFrom(flow) {
-      this.state.flow = flow;
-      return this;
-    }
     submit(signalOrCallback) {
       var _a;
       this.state.ensureNotExecuted();
@@ -867,7 +897,7 @@ var ZlinkStreamConnectorBundle = (() => {
         this.state.compress,
         (_a = this.state.timeoutMs) != null ? _a : this.connector.options.requestTimeoutMs,
         typeof signalOrCallback === "function" ? void 0 : signalOrCallback,
-        this.state.flow
+        this.state.actorSlot
       );
       if (typeof signalOrCallback === "function") {
         operation.then(
@@ -876,10 +906,12 @@ var ZlinkStreamConnectorBundle = (() => {
         );
         return;
       }
-      return operation.then((value) => {
-        var _a2;
-        return ((_a2 = this.connector.options.codec) != null ? _a2 : zlinkStreamJsonCodec).decode(value);
-      });
+      return operation.then(
+        (value) => {
+          var _a2;
+          return ((_a2 = this.connector.options.codec) != null ? _a2 : zlinkStreamJsonCodec).decode(value);
+        }
+      );
     }
     submitEncoded(signal) {
       var _a;
@@ -891,7 +923,7 @@ var ZlinkStreamConnectorBundle = (() => {
         this.state.compress,
         (_a = this.state.timeoutMs) != null ? _a : this.connector.options.requestTimeoutMs,
         signal,
-        this.state.flow
+        this.state.actorSlot
       );
     }
   };
@@ -917,7 +949,12 @@ var ZlinkStreamConnectorBundle = (() => {
       var _a;
       this.markExecuted();
       const timeoutMs = (_a = this.timeoutMs) != null ? _a : 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 */,
@@ -928,7 +965,10 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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() {
@@ -954,9 +994,17 @@ var ZlinkStreamConnectorBundle = (() => {
     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;
       }
@@ -967,7 +1015,10 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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() {
@@ -1001,7 +1052,10 @@ var ZlinkStreamConnectorBundle = (() => {
       var _a;
       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 = (_a = this.timeoutMs) != null ? _a : this.connector.options.waitTimeoutMs;
       const deadline = Date.now() + timeoutMs;
@@ -1033,7 +1087,10 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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() {
@@ -1043,7 +1100,10 @@ var ZlinkStreamConnectorBundle = (() => {
   };
   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."
+      );
     }
   }
 
@@ -1059,7 +1119,10 @@ var ZlinkStreamConnectorBundle = (() => {
   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);
   }
@@ -1069,7 +1132,10 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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);
@@ -1102,26 +1168,39 @@ var ZlinkStreamConnectorBundle = (() => {
       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;
@@ -1130,7 +1209,10 @@ var ZlinkStreamConnectorBundle = (() => {
   }
   function validatePayload(payloadLength, maxPayloadSize) {
     if (payloadLength > maxPayloadSize) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Payload exceeds MaxSendPayloadSize.");
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        "Payload exceeds MaxSendPayloadSize."
+      );
     }
   }
 
@@ -1148,14 +1230,22 @@ var ZlinkStreamConnectorBundle = (() => {
         }
         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) {
@@ -1163,7 +1253,11 @@ var ZlinkStreamConnectorBundle = (() => {
         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
+        );
       }
     }
   };
@@ -1187,22 +1281,20 @@ var ZlinkStreamConnectorBundle = (() => {
           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,
@@ -1212,11 +1304,14 @@ var ZlinkStreamConnectorBundle = (() => {
           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)) {
@@ -1232,7 +1327,7 @@ var ZlinkStreamConnectorBundle = (() => {
   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 */;
@@ -1246,27 +1341,49 @@ var ZlinkStreamConnectorBundle = (() => {
     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."
+        );
       }
     }
   }
@@ -1277,17 +1394,11 @@ var ZlinkStreamConnectorBundle = (() => {
     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";
@@ -1296,37 +1407,47 @@ var ZlinkStreamConnectorBundle = (() => {
     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;
       });
@@ -1373,21 +1494,18 @@ var ZlinkStreamConnectorBundle = (() => {
   }
 
   // packages/stream-connector/src/Runtime/ZlinkStreamConnectorOptions.ts
-  var validDiagnosticsLevels = /* @__PURE__ */ new Set([
-    "off" /* Off */,
-    "errors" /* Errors */,
-    "normal" /* Normal */,
-    "detailed" /* Detailed */
-  ]);
   function normalizeOptions(options, defaultTransportFactory) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C;
     const endpoint = options.endpoint;
     if (endpoint.trim().length === 0) {
       throw connectorError("configurationError" /* ConfigurationError */, "Endpoint must not be empty.");
     }
     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((_a = options.connectTimeoutMs) != null ? _a : 5e3, "ConnectTimeout");
     validatePositive((_b = options.requestTimeoutMs) != null ? _b : 3e4, "RequestTimeout");
@@ -1396,7 +1514,6 @@ var ZlinkStreamConnectorBundle = (() => {
     validatePositive((_e = options.maxReceivePayloadSize) != null ? _e : 64 * 1024, "MaxReceivePayloadSize");
     validateHeartbeat(options.heartbeat);
     validateReconnect(options.reconnect);
-    validateDiagnosticsLevel(options.diagnosticsLevel);
     return {
       endpoint,
       transport: inferredTransport,
@@ -1422,10 +1539,7 @@ var ZlinkStreamConnectorBundle = (() => {
       compressionCodec: resolveCompressionCodec2(options),
       nameResolver: (_B = options.nameResolver) != null ? _B : defaultPacketNameResolver,
       transportFactory: (_C = options.transportFactory) != null ? _C : defaultTransportFactory,
-      codec: options.codec,
-      // Spec 26 §4: the default diagnostics level is Errors, which preserves
-      // the connector's established wire behavior.
-      diagnosticsLevel: (_D = options.diagnosticsLevel) != null ? _D : "errors" /* Errors */
+      codec: options.codec
     };
   }
   var defaultPacketNameResolver = {
@@ -1442,17 +1556,15 @@ var ZlinkStreamConnectorBundle = (() => {
     const compression = (_a = options.compression) != null ? _a : "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.`);
@@ -1469,7 +1581,10 @@ var ZlinkStreamConnectorBundle = (() => {
     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) {
@@ -1481,33 +1596,20 @@ var ZlinkStreamConnectorBundle = (() => {
     validatePositive((_b = options == null ? void 0 : options.initialDelayMs) != null ? _b : 250, "Reconnect InitialDelay");
     validatePositive((_c = options == null ? void 0 : options.maxDelayMs) != null ? _c : 5e3, "Reconnect MaxDelay");
     if (((_d = options == null ? void 0 : options.backoffFactor) != null ? _d : 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 == null ? void 0 : 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 {
-    constructor(initial) {
-      __publicField(this, "current");
-      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 {
     constructor() {
@@ -1522,14 +1624,21 @@ var ZlinkStreamConnectorBundle = (() => {
       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,
@@ -1553,15 +1662,14 @@ var ZlinkStreamConnectorBundle = (() => {
       });
       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) {
@@ -1699,9 +1807,11 @@ var ZlinkStreamConnectorBundle = (() => {
      */
     resetForNewConnection() {
       this.receivedCounts.clear();
+      const submittedCallbacks = this.queue.slice(this.queueHead).filter((item) => (item == null ? void 0 : 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
@@ -1731,7 +1841,14 @@ var ZlinkStreamConnectorBundle = (() => {
           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();
@@ -1758,7 +1875,7 @@ var ZlinkStreamConnectorBundle = (() => {
     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)) {
@@ -1786,17 +1903,24 @@ var ZlinkStreamConnectorBundle = (() => {
           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
+              );
             }
           }
         }
@@ -1814,16 +1938,16 @@ var ZlinkStreamConnectorBundle = (() => {
       var _a, _b;
       for (let index = this.queueHead; index < this.queue.length; index += 1) {
         const queued = this.queue[index];
-        if (queued !== void 0 && ((_b = (_a = this.handlers.get(queued.message.name)) == null ? void 0 : _a.size) != null ? _b : 0) > 0) {
+        if (queued !== void 0 && (queued.kind === "callback" || ((_b = (_a = this.handlers.get(queued.message.name)) == null ? void 0 : _a.size) != null ? _b : 0) > 0)) {
           return index;
         }
       }
       return -1;
     }
     hasQueuedMessage(name) {
-      var _a;
       for (let index = this.queueHead; index < this.queue.length; index += 1) {
-        if (((_a = this.queue[index]) == null ? void 0 : _a.message.name) === name) return true;
+        const queued = this.queue[index];
+        if ((queued == null ? void 0 : queued.kind) === "message" && queued.message.name === name) return true;
       }
       return false;
     }
@@ -1847,17 +1971,24 @@ var ZlinkStreamConnectorBundle = (() => {
 
   // packages/stream-connector/src/Runtime/ZlinkStreamFrameSender.ts
   var ZlinkStreamFrameSender = class {
-    constructor(protocol, flowContext) {
+    constructor(protocol) {
       this.protocol = protocol;
-      this.flowContext = flowContext;
       __publicField(this, "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 == null ? void 0 : flow.flowId, flow == null ? void 0 : flow.flowOrigin),
+        this.protocol.encode(
+          kind,
+          name,
+          payload,
+          metadata,
+          compress,
+          requestSeq,
+          correlationId,
+          actorSlot
+        ),
         signal
       );
     }
@@ -1892,24 +2023,196 @@ var ZlinkStreamConnectorBundle = (() => {
     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;
+      __publicField(this, "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;
+      __publicField(this, "bySlot", /* @__PURE__ */ new Map());
+      __publicField(this, "byId", /* @__PURE__ */ new Map());
+      __publicField(this, "issued", []);
+      __publicField(this, "boundHandlers", /* @__PURE__ */ new Set());
+      __publicField(this, "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;
     }
     /**
@@ -1936,46 +2239,54 @@ var ZlinkStreamConnectorBundle = (() => {
       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(
@@ -1983,10 +2294,7 @@ var ZlinkStreamConnectorBundle = (() => {
             "decompressionFailed" /* DecompressionFailed */,
             "Decompression failed."
           );
-          if (!this.pendingRequests.reject(
-            header.requestSeq,
-            decodeError
-          )) {
+          if (!this.pendingRequests.reject(header.requestSeq, decodeError)) {
             await this.events.publishError(decodeError, signal);
           }
         }
@@ -2004,10 +2312,7 @@ var ZlinkStreamConnectorBundle = (() => {
             "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);
           }
         }
@@ -2022,25 +2327,33 @@ var ZlinkStreamConnectorBundle = (() => {
         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 == null ? void 0 : flow.flowId,
-          flowOrigin: flow == null ? void 0 : flow.flowOrigin
-        }, signal);
+        this.receivedMessages.enqueue(
+          {
+            name: header.name,
+            metadata: header.metadata,
+            payload: { codec: header.codec, payload: this.protocol.decodePayload(header, payload) },
+            actorId: actor == null ? void 0 : actor.actorId,
+            [zlinkStreamActorBinding]: actor
+          },
+          signal
+        );
       }
     }
     async dispatchControl(connection, header, payload, signal, connectionForSend) {
       var _a, _b;
+      if (this.actors.processControl(header.name, payload, signal)) {
+        return;
+      }
       if (header.name === ZLINK_SESSION_CLOSING) {
         const closing = decodeSessionClosing(payload);
         await ((_a = this.serverClosing) == null ? void 0 : _a.call(this, 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 {
@@ -2068,7 +2381,11 @@ var ZlinkStreamConnectorBundle = (() => {
     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(
@@ -2085,12 +2402,13 @@ var ZlinkStreamConnectorBundle = (() => {
     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;
       __publicField(this, "receiveLoopAbort");
       __publicField(this, "receiveLoopSleeping", false);
@@ -2149,7 +2467,10 @@ var ZlinkStreamConnectorBundle = (() => {
             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;
@@ -2188,8 +2509,15 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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) {
       var _a, _b;
@@ -2214,10 +2542,14 @@ var ZlinkStreamConnectorBundle = (() => {
       } 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.");
     }
@@ -2341,7 +2673,11 @@ var ZlinkStreamConnectorBundle = (() => {
         }
       } 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;
@@ -2401,7 +2737,11 @@ var ZlinkStreamConnectorBundle = (() => {
       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;
@@ -2442,6 +2782,7 @@ var ZlinkStreamConnectorBundle = (() => {
       this.currentConnection = void 0;
       this.pendingRequests.failAll(error);
       this.receivedMessages.connectionEnded();
+      this.actors.closeAll();
       try {
         await (connection == null ? void 0 : connection.close());
       } catch {
@@ -2457,11 +2798,8 @@ var ZlinkStreamConnectorBundle = (() => {
      */
     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);
@@ -2509,16 +2847,35 @@ var ZlinkStreamConnectorBundle = (() => {
     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);
     }
   };
 
@@ -2555,36 +2912,6 @@ var ZlinkStreamConnectorBundle = (() => {
     }
   };
 
-  // packages/stream-connector/src/Runtime/ZlinkFlowContext.ts
-  var BrowserZlinkFlowContext = class {
-    currentOrCreate(explicit) {
-      return explicit != null ? explicit : { flowId: this.createUuidV7(), flowOrigin: "Application" };
-    }
-    createInbound(flowId, flowOrigin) {
-      return { flowId: flowId != null ? flowId : this.createUuidV7(), flowOrigin: flowOrigin != null ? 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) {
@@ -2615,7 +2942,11 @@ var ZlinkStreamConnectorBundle = (() => {
           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();
         }
@@ -2623,13 +2954,19 @@ var ZlinkStreamConnectorBundle = (() => {
       });
       __publicField(this, "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();
       });
       __publicField(this, "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();
       });
@@ -2679,7 +3016,10 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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 = () => {
@@ -2736,9 +3076,10 @@ var ZlinkStreamConnectorBundle = (() => {
   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."));
@@ -2769,7 +3110,10 @@ var ZlinkStreamConnectorBundle = (() => {
     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
@@ -2782,29 +3126,25 @@ var ZlinkStreamConnectorBundle = (() => {
       __publicField(this, "pendingRequests", new ZlinkStreamPendingRequests());
       __publicField(this, "frameSender");
       __publicField(this, "receiveDispatcher");
-      __publicField(this, "diagnosticsLevelCell");
+      __publicField(this, "requestSendingHandlers", /* @__PURE__ */ new Set());
+      __publicField(this, "replyReceivedHandlers", /* @__PURE__ */ new Set());
+      __publicField(this, "boundActors");
       __publicField(this, "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(
@@ -2813,6 +3153,7 @@ var ZlinkStreamConnectorBundle = (() => {
         this.frameSender,
         this.receiveDispatcher,
         this.receivedMessages,
+        this.boundActors,
         this.events
       );
     }
@@ -2828,6 +3169,18 @@ var ZlinkStreamConnectorBundle = (() => {
     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
@@ -2839,37 +3192,6 @@ var ZlinkStreamConnectorBundle = (() => {
       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);
     }
@@ -2879,6 +3201,14 @@ var ZlinkStreamConnectorBundle = (() => {
     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);
     }
@@ -2896,15 +3226,60 @@ var ZlinkStreamConnectorBundle = (() => {
       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 != null ? 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 != null ? 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));
@@ -2924,7 +3299,10 @@ var ZlinkStreamConnectorBundle = (() => {
     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;
@@ -2944,7 +3322,10 @@ var ZlinkStreamConnectorBundle = (() => {
     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) => {
@@ -2970,30 +3351,35 @@ var ZlinkStreamConnectorBundle = (() => {
         };
         timer = setTimeout(() => finish(), timeoutMs);
         signal == null ? void 0 : 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) {
@@ -3018,7 +3404,7 @@ var ZlinkStreamConnectorBundle = (() => {
       }
       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,
@@ -3029,37 +3415,105 @@ var ZlinkStreamConnectorBundle = (() => {
         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;