@zlink-systems/stream-connector 0.22.0 → 0.24.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) => {
@@ -781,16 +796,18 @@ var ZlinkStreamConnectorBundle = (() => {
 
   // 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 */,
@@ -798,6 +815,7 @@ var ZlinkStreamConnectorBundle = (() => {
         );
       }
       this.executed = true;
+      (_a = this.validateActor) == null ? void 0 : _a.call(this);
     }
     resolveMessageName() {
       if (this.name === void 0) {
@@ -810,11 +828,11 @@ var ZlinkStreamConnectorBundle = (() => {
     }
   };
   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);
@@ -829,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();
@@ -844,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);
@@ -872,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();
@@ -886,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(
@@ -912,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
       );
     }
   };
@@ -1270,8 +1281,7 @@ 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(
@@ -1281,15 +1291,10 @@ var ZlinkStreamConnectorBundle = (() => {
         );
       }
     }
-    /**
-     * `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,
@@ -1299,8 +1304,7 @@ var ZlinkStreamConnectorBundle = (() => {
           name: wire.name,
           metadata,
           correlationId: wire.correlationId,
-          flowId: wire.flowId,
-          flowOrigin: decodeFlowOrigin(wire.flowOrigin)
+          actorSlot: wire.actorSlot
         };
       } catch (cause) {
         throw connectorError(
@@ -1323,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 */;
@@ -1337,8 +1341,17 @@ 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);
@@ -1364,8 +1377,9 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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 */) {
+      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."
@@ -1380,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";
@@ -1399,7 +1407,7 @@ 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,
@@ -1409,8 +1417,7 @@ var ZlinkStreamConnectorBundle = (() => {
         compress,
         requestSeq,
         correlationId,
-        flowId,
-        flowOrigin
+        actorSlot
       );
       return this.encodeFrame(header, payloadBytes);
     }
@@ -1426,21 +1433,16 @@ var ZlinkStreamConnectorBundle = (() => {
         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 */,
@@ -1492,14 +1494,8 @@ 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.");
@@ -1518,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,
@@ -1544,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 = {
@@ -1573,11 +1565,6 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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.`);
@@ -1623,25 +1610,6 @@ var ZlinkStreamConnectorBundle = (() => {
     }
   }
 
-  // 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() {
@@ -1656,16 +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,
@@ -1689,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) {
@@ -1835,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
@@ -1853,7 +1827,7 @@ var ZlinkStreamConnectorBundle = (() => {
       if (this.observers.size === 0) {
         return;
       }
-      const abandoned = [...this.observers.values()].flatMap((set) => [...set]);
+      const abandoned = Array.from(this.observers.values()).flatMap((set) => Array.from(set));
       this.observers.clear();
       for (const registration of abandoned) {
         registration.onConnectionEnded();
@@ -1862,12 +1836,19 @@ var ZlinkStreamConnectorBundle = (() => {
     enqueue(message, signal) {
       var _a, _b;
       this.receivedCounts.set(message.name, ((_a = this.receivedCounts.get(message.name)) != null ? _a : 0) + 1);
-      for (const registration of [...(_b = this.observers.get(message.name)) != null ? _b : []]) {
+      for (const registration of Array.from((_b = this.observers.get(message.name)) != null ? _b : [])) {
         if (registration.consume(message)) {
           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();
@@ -1894,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)) {
@@ -1922,8 +1903,12 @@ 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)];
+          const handlers = Array.from(this.handlers.get(message.name));
           for (const handler of handlers) {
             try {
               await handler(message, signal);
@@ -1953,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;
     }
@@ -1986,14 +1971,12 @@ 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(
@@ -2004,8 +1987,7 @@ var ZlinkStreamConnectorBundle = (() => {
           compress,
           requestSeq,
           correlationId,
-          flow == null ? void 0 : flow.flowId,
-          flow == null ? void 0 : flow.flowOrigin
+          actorSlot
         ),
         signal
       );
@@ -2016,7 +1998,7 @@ var ZlinkStreamConnectorBundle = (() => {
     async drain(signal) {
       while (this.pendingWrites.size > 0) {
         throwIfAborted(signal);
-        await Promise.allSettled([...this.pendingWrites]);
+        await Promise.allSettled(Array.from(this.pendingWrites));
       }
     }
     async write(connection, frame, signal) {
@@ -2052,15 +2034,185 @@ var ZlinkStreamConnectorBundle = (() => {
     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(Array.from(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 Array.from(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;
     }
     /**
@@ -2087,49 +2239,47 @@ 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)
-          })) {
+          if (!this.pendingRequests.resolve(
+            header.requestSeq,
+            {
+              codec: header.codec,
+              payload: this.protocol.decodePayload(header, payload)
+            },
+            header.metadata
+          )) {
             await this.events.publishError(
               {
                 code: "frameDecodeFailed" /* FrameDecodeFailed */,
@@ -2177,14 +2327,13 @@ 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
+            actorId: actor == null ? void 0 : actor.actorId,
+            [zlinkStreamActorBinding]: actor
           },
           signal
         );
@@ -2192,6 +2341,9 @@ var ZlinkStreamConnectorBundle = (() => {
     }
     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));
@@ -2250,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);
@@ -2394,8 +2547,9 @@ var ZlinkStreamConnectorBundle = (() => {
         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.");
     }
@@ -2628,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 {
@@ -2643,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);
@@ -2695,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);
     }
   };
 
@@ -2728,49 +2899,25 @@ var ZlinkStreamConnectorBundle = (() => {
       return subscription(() => this.stateHandlers.delete(handler));
     }
     async publishError(error, signal) {
-      await this.publish([...this.errorHandlers].map((handler) => () => handler(error, signal)));
+      await this.publish(
+        Array.from(this.errorHandlers).map((handler) => () => handler(error, signal))
+      );
     }
     async publishDisconnected(signal) {
-      await this.publish([...this.disconnectedHandlers].map((handler) => () => handler(signal)));
+      await this.publish(
+        Array.from(this.disconnectedHandlers).map((handler) => () => handler(signal))
+      );
     }
     async publishStateChanged(change, signal) {
-      await this.publish([...this.stateHandlers].map((handler) => () => handler(change, signal)));
+      await this.publish(
+        Array.from(this.stateHandlers).map((handler) => () => handler(change, signal))
+      );
     }
     async publish(handlers) {
       await Promise.allSettled(handlers.map(async (handler) => handler()));
     }
   };
 
-  // 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) {
@@ -2985,29 +3132,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(
@@ -3016,6 +3159,7 @@ var ZlinkStreamConnectorBundle = (() => {
         this.frameSender,
         this.receiveDispatcher,
         this.receivedMessages,
+        this.boundActors,
         this.events
       );
     }
@@ -3031,6 +3175,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
@@ -3042,37 +3198,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);
     }
@@ -3082,6 +3207,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);
     }
@@ -3099,18 +3232,60 @@ var ZlinkStreamConnectorBundle = (() => {
       const encoded = this.encodePayload(payload, messageType);
       return new ZlinkStreamRequestBuilder(this, this.resolveNameOrDefault(encoded), encoded);
     }
-    on(name, handler, messageType) {
+    on(nameOrType, 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
+          payload: this.decodePayload(
+            message.payload,
+            messageType != null ? messageType : typeof nameOrType === "function" ? nameOrType : void 0
+          ),
+          actorId: message.actorId
         },
         signal
       );
-      return this.receivedMessages.on(name, encodedHandler);
+      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));
@@ -3193,8 +3368,7 @@ var ZlinkStreamConnectorBundle = (() => {
                 name: message.name,
                 metadata: message.metadata,
                 payload: this.decodeWaitPayload(message.payload),
-                flowId: message.flowId,
-                flowOrigin: message.flowOrigin
+                actorId: message.actorId
               };
               if (!predicate(decoded)) {
                 return false;
@@ -3236,7 +3410,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,
@@ -3247,37 +3421,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 Array.from(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
+        );
+        const reply = await pending.promise;
+        this.publishReplyReceived(
+          {
+            requestPacketName: name,
+            actorId,
+            succeeded: true,
+            reply: { ...reply, actorId },
+            elapsed: Date.now() - startedAt
+          },
+          signal
         );
-        return await pending.promise;
+        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 Array.from(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;