@zlink-systems/stream-connector 0.22.0 → 0.24.0

package/dist/browser/index.mjs

@@ -120,7 +120,8 @@ var defaultHeaderFlags = {
   hasRequestSeq: 1,
   hasMetadata: 2,
   hasCorrelationId: 8,
-  hasFlowId: 16
+  hasFlowId: 16,
+  hasActorSlot: 32
 };
 var ZLINK_STREAM_FORMAT_MARKER = 242;
 var ZLINK_STREAM_RESPONSE_KIND = 3;
@@ -167,6 +168,7 @@ function encodeStreamWireHeader(header, flagOverrides) {
   }
   const hasCorrelation = correlationBytes !== void 0;
   const hasFlow = header.flowId !== void 0 || header.flowOrigin !== void 0;
+  const hasActorSlot = header.actorSlot !== void 0;
   if (hasFlow && (header.flowId === void 0 || header.flowOrigin === void 0)) {
     throw new Error("Stream flow id and origin must be provided together.");
   }
@@ -174,13 +176,17 @@ function encodeStreamWireHeader(header, flagOverrides) {
   if (header.flowOrigin !== void 0 && ![1, 2, 3, 4].includes(header.flowOrigin)) {
     throw new Error("Stream flow origin is invalid.");
   }
+  if (header.actorSlot !== void 0 && (!Number.isInteger(header.actorSlot) || header.actorSlot < 1 || header.actorSlot > 65535)) {
+    throw new Error("Stream actor slot is invalid.");
+  }
   let headerFlags = header.flags;
   headerFlags = hasRequestSeq ? headerFlags | flags.hasRequestSeq : headerFlags & ~flags.hasRequestSeq;
   headerFlags = hasMetadata ? headerFlags | flags.hasMetadata : headerFlags & ~flags.hasMetadata;
   headerFlags = hasCorrelation ? headerFlags | flags.hasCorrelationId : headerFlags & ~flags.hasCorrelationId;
   headerFlags = hasFlow ? headerFlags | flags.hasFlowId : headerFlags & ~flags.hasFlowId;
+  headerFlags = hasActorSlot ? headerFlags | flags.hasActorSlot : headerFlags & ~flags.hasActorSlot;
   const metadataBytes = hasMetadata ? encodeStreamWireMetadata(header.metadata) : new Uint8Array();
-  const size = 4 + (hasRequestSeq ? 8 : 0) + 1 + nameBytes.length + (hasMetadata ? 2 + metadataBytes.length : 0) + (hasCorrelation ? 1 + correlationBytes.length : 0) + (hasFlow ? 37 : 0);
+  const size = 4 + (hasRequestSeq ? 8 : 0) + 1 + nameBytes.length + (hasMetadata ? 2 + metadataBytes.length : 0) + (hasCorrelation ? 1 + correlationBytes.length : 0) + (hasFlow ? 37 : 0) + (hasActorSlot ? 2 : 0);
   const buffer = new Uint8Array(size);
   let offset = 0;
   buffer[offset++] = ZLINK_STREAM_FORMAT_MARKER;
@@ -213,6 +219,9 @@ function encodeStreamWireHeader(header, flagOverrides) {
     offset += 36;
     buffer[offset++] = header.flowOrigin;
   }
+  if (hasActorSlot) {
+    writeUInt16BE(buffer, offset, header.actorSlot);
+  }
   return buffer;
 }
 function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
@@ -231,7 +240,8 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
   const hasMetadata = (headerFlags & flags.hasMetadata) !== 0;
   const hasCorrelation = (headerFlags & flags.hasCorrelationId) !== 0;
   const hasFlow = (headerFlags & flags.hasFlowId) !== 0;
-  if ((headerFlags & ~31) !== 0) {
+  const hasActorSlot = (headerFlags & flags.hasActorSlot) !== 0;
+  if ((headerFlags & ~63) !== 0) {
     throw new Error("Unknown mandatory stream header flag.");
   }
   let requestSeq;
@@ -286,6 +296,17 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
     }
     flowOrigin = includeFlow ? decodedFlowOrigin : void 0;
   }
+  let actorSlot;
+  if (hasActorSlot) {
+    if (header.length - offset < 2) {
+      throw new Error("Stream actor slot is incomplete.");
+    }
+    actorSlot = readUInt16BE(header, offset);
+    if (actorSlot === 0) {
+      throw new Error("Stream actor slot must not be zero.");
+    }
+    offset += 2;
+  }
   if (offset !== header.length) {
     throw new Error("Stream header has trailing bytes.");
   }
@@ -298,7 +319,8 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
     metadata: decodedMetadata.metadata,
     correlationId,
     flowId,
-    flowOrigin
+    flowOrigin,
+    actorSlot
   };
 }
 function validateFlowId(flowId) {
@@ -464,13 +486,6 @@ var ZlinkStreamDispatchMode = /* @__PURE__ */ ((ZlinkStreamDispatchMode2) => {
   ZlinkStreamDispatchMode2["Immediate"] = "immediate";
   return ZlinkStreamDispatchMode2;
 })(ZlinkStreamDispatchMode || {});
-var ZlinkStreamDiagnosticsLevel = /* @__PURE__ */ ((ZlinkStreamDiagnosticsLevel4) => {
-  ZlinkStreamDiagnosticsLevel4["Off"] = "off";
-  ZlinkStreamDiagnosticsLevel4["Errors"] = "errors";
-  ZlinkStreamDiagnosticsLevel4["Normal"] = "normal";
-  ZlinkStreamDiagnosticsLevel4["Detailed"] = "detailed";
-  return ZlinkStreamDiagnosticsLevel4;
-})(ZlinkStreamDiagnosticsLevel || {});
 var ZlinkStreamMessageKind = /* @__PURE__ */ ((ZlinkStreamMessageKind2) => {
   ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Send"] = 1] = "Send";
   ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Request"] = 2] = "Request";
@@ -486,6 +501,7 @@ var ZlinkStreamHeaderFlags = /* @__PURE__ */ ((ZlinkStreamHeaderFlags2) => {
   ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["PayloadCompressed"] = 4] = "PayloadCompressed";
   ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasCorrelationId"] = 8] = "HasCorrelationId";
   ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasFlowId"] = 16] = "HasFlowId";
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasActorSlot"] = 32] = "HasActorSlot";
   return ZlinkStreamHeaderFlags2;
 })(ZlinkStreamHeaderFlags || {});
 var ZlinkStreamErrorCode = /* @__PURE__ */ ((ZlinkStreamErrorCode2) => {
@@ -734,15 +750,16 @@ function validateName(name, allowReserved = false) {
 
 // packages/stream-connector/src/Runtime/Calls/ZlinkStreamCallBuilders.ts
 var ZlinkStreamCallBuilderState = class {
+  constructor(name, actorSlot, validateActor) {
+    this.actorSlot = actorSlot;
+    this.validateActor = validateActor;
+    this.name = name;
+  }
   executed = false;
   name;
   metadata = ZlinkStreamMetadataMap.empty;
   timeoutMs;
   compress = false;
-  flow;
-  constructor(name) {
-    this.name = name;
-  }
   ensureNotExecuted() {
     if (this.executed) {
       throw connectorError(
@@ -751,6 +768,7 @@ var ZlinkStreamCallBuilderState = class {
       );
     }
     this.executed = true;
+    this.validateActor?.();
   }
   resolveMessageName() {
     if (this.name === void 0) {
@@ -763,10 +781,10 @@ var ZlinkStreamCallBuilderState = class {
   }
 };
 var ZlinkStreamSendBuilder = class {
-  constructor(connector, name, payload) {
+  constructor(connector, name, payload, actorSlot, validateActor) {
     this.connector = connector;
     this.payload = payload;
-    this.state = new ZlinkStreamCallBuilderState(name);
+    this.state = new ZlinkStreamCallBuilderState(name, actorSlot, validateActor);
   }
   state;
   packetName(name) {
@@ -782,10 +800,6 @@ var ZlinkStreamSendBuilder = class {
     this.state.compress = true;
     return this;
   }
-  flowFrom(flow) {
-    this.state.flow = flow;
-    return this;
-  }
   async submit(signal) {
     throwIfAborted(signal);
     this.state.ensureNotExecuted();
@@ -797,15 +811,16 @@ var ZlinkStreamSendBuilder = class {
       this.state.compress,
       void 0,
       signal,
-      this.state.flow
+      void 0,
+      this.state.actorSlot
     );
   }
 };
 var ZlinkStreamRequestBuilder = class {
-  constructor(connector, name, payload) {
+  constructor(connector, name, payload, actorSlot, validateActor) {
     this.connector = connector;
     this.payload = payload;
-    this.state = new ZlinkStreamCallBuilderState(name);
+    this.state = new ZlinkStreamCallBuilderState(name, actorSlot, validateActor);
   }
   state;
   packetName(name) {
@@ -825,10 +840,6 @@ var ZlinkStreamRequestBuilder = class {
     this.state.compress = true;
     return this;
   }
-  flowFrom(flow) {
-    this.state.flow = flow;
-    return this;
-  }
   submit(signalOrCallback) {
     this.state.ensureNotExecuted();
     const operation = this.connector.requestEncoded(
@@ -838,7 +849,7 @@ var ZlinkStreamRequestBuilder = class {
       this.state.compress,
       this.state.timeoutMs ?? this.connector.options.requestTimeoutMs,
       typeof signalOrCallback === "function" ? void 0 : signalOrCallback,
-      this.state.flow
+      this.state.actorSlot
     );
     if (typeof signalOrCallback === "function") {
       operation.then(
@@ -860,7 +871,7 @@ var ZlinkStreamRequestBuilder = class {
       this.state.compress,
       this.state.timeoutMs ?? this.connector.options.requestTimeoutMs,
       signal,
-      this.state.flow
+      this.state.actorSlot
     );
   }
 };
@@ -1216,8 +1227,7 @@ var ZlinkStreamHeaderCodec = class {
         name: header.name,
         metadata: header.metadata.values,
         correlationId: header.correlationId,
-        flowId: header.flowId,
-        flowOrigin: encodeFlowOrigin(header.flowOrigin)
+        actorSlot: header.actorSlot
       });
     } catch (cause) {
       throw connectorError(
@@ -1227,15 +1237,10 @@ var ZlinkStreamHeaderCodec = class {
       );
     }
   }
-  /**
-   * `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,
@@ -1245,8 +1250,7 @@ var ZlinkStreamHeaderCodec = class {
         name: wire.name,
         metadata,
         correlationId: wire.correlationId,
-        flowId: wire.flowId,
-        flowOrigin: decodeFlowOrigin(wire.flowOrigin)
+        actorSlot: wire.actorSlot
       };
     } catch (cause) {
       throw connectorError(
@@ -1269,7 +1273,7 @@ function isReplyKind2(kind) {
 function streamWireErrorMessage2(cause) {
   return cause instanceof Error ? cause.message : "Stream header is invalid.";
 }
-function buildHeader(kind, name, codec, metadata, compress, requestSeq, correlationId, flowId, flowOrigin) {
+function buildHeader(kind, name, codec, metadata, compress, requestSeq, correlationId, actorSlot) {
   let flags = 0 /* None */;
   if (requestSeq !== void 0) {
     flags |= 1 /* HasRequestSeq */;
@@ -1283,8 +1287,17 @@ function buildHeader(kind, name, codec, metadata, compress, requestSeq, correlat
   if (correlationId !== void 0 && correlationId.length > 0) {
     flags |= 8 /* HasCorrelationId */;
   }
-  if (flowId !== void 0) flags |= 16 /* HasFlowId */;
-  return { kind, codec, flags, requestSeq, name, metadata, correlationId, flowId, flowOrigin };
+  if (actorSlot !== void 0) flags |= 32 /* HasActorSlot */;
+  return {
+    kind,
+    codec,
+    flags,
+    requestSeq,
+    name,
+    metadata,
+    correlationId,
+    actorSlot
+  };
 }
 function validateHeaderSemantics(header) {
   validateEnum(header.kind, header.codec, header.flags);
@@ -1310,8 +1323,9 @@ function validateHeaderSemantics(header) {
   }
   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."
@@ -1326,17 +1340,11 @@ function validateEnum(kind, codec, flags) {
   if (![0, 1, 2, 3].includes(codec)) {
     throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Unknown stream codec.");
   }
-  const known = 1 /* HasRequestSeq */ | 2 /* HasMetadata */ | 4 /* PayloadCompressed */ | 8 /* HasCorrelationId */ | 16 /* HasFlowId */;
+  const known = 1 /* HasRequestSeq */ | 2 /* HasMetadata */ | 4 /* PayloadCompressed */ | 8 /* HasCorrelationId */ | 16 /* HasFlowId */ | 32 /* HasActorSlot */;
   if ((flags & ~known) !== 0) {
     throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Unknown stream header flag.");
   }
 }
-function encodeFlowOrigin(origin) {
-  return origin === void 0 ? void 0 : { Inbound: 1, Timer: 2, Application: 3, Lifecycle: 4 }[origin];
-}
-function decodeFlowOrigin(origin) {
-  return origin === void 0 ? void 0 : { 1: "Inbound", 2: "Timer", 3: "Application", 4: "Lifecycle" }[origin];
-}
 
 // packages/stream-connector/src/Runtime/Protocol/ZlinkStreamFrameProtocol.ts
 var ZLINK_STREAM_HEARTBEAT_PING = "$zlink.heartbeat.ping";
@@ -1345,7 +1353,7 @@ var ZlinkStreamFrameProtocol = class {
   constructor(options) {
     this.options = options;
   }
-  encode(kind, name, payload, metadata, compress, requestSeq, correlationId, flowId, flowOrigin) {
+  encode(kind, name, payload, metadata, compress, requestSeq, correlationId, actorSlot) {
     const payloadBytes = compress ? compressPayload(payload.payload, this.options.compression, this.options.compressionCodec) : payload.payload;
     const header = buildHeader(
       kind,
@@ -1355,8 +1363,7 @@ var ZlinkStreamFrameProtocol = class {
       compress,
       requestSeq,
       correlationId,
-      flowId,
-      flowOrigin
+      actorSlot
     );
     return this.encodeFrame(header, payloadBytes);
   }
@@ -1372,21 +1379,16 @@ var ZlinkStreamFrameProtocol = class {
       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 */,
@@ -1438,12 +1440,6 @@ function parseEndpoint(endpoint) {
 }
 
 // packages/stream-connector/src/Runtime/ZlinkStreamConnectorOptions.ts
-var validDiagnosticsLevels = /* @__PURE__ */ new Set([
-  "off" /* Off */,
-  "errors" /* Errors */,
-  "normal" /* Normal */,
-  "detailed" /* Detailed */
-]);
 function normalizeOptions(options, defaultTransportFactory) {
   const endpoint = options.endpoint;
   if (endpoint.trim().length === 0) {
@@ -1463,7 +1459,6 @@ function normalizeOptions(options, defaultTransportFactory) {
   validatePositive(options.maxReceivePayloadSize ?? 64 * 1024, "MaxReceivePayloadSize");
   validateHeartbeat(options.heartbeat);
   validateReconnect(options.reconnect);
-  validateDiagnosticsLevel(options.diagnosticsLevel);
   return {
     endpoint,
     transport: inferredTransport,
@@ -1489,10 +1484,7 @@ function normalizeOptions(options, defaultTransportFactory) {
     compressionCodec: resolveCompressionCodec2(options),
     nameResolver: options.nameResolver ?? defaultPacketNameResolver,
     transportFactory: options.transportFactory ?? defaultTransportFactory,
-    codec: options.codec,
-    // Spec 26 §4: the default diagnostics level is Errors, which preserves
-    // the connector's established wire behavior.
-    diagnosticsLevel: options.diagnosticsLevel ?? "errors" /* Errors */
+    codec: options.codec
   };
 }
 var defaultPacketNameResolver = {
@@ -1517,11 +1509,6 @@ function resolveCompressionCodec2(options) {
   }
   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.`);
@@ -1565,25 +1552,6 @@ function validateReconnect(options) {
   }
 }
 
-// packages/stream-connector/src/Runtime/ZlinkStreamDiagnosticsLevelCell.ts
-var ZlinkStreamDiagnosticsLevelCell = class {
-  current;
-  constructor(initial) {
-    this.current = initial;
-  }
-  get level() {
-    return this.current;
-  }
-  set(level) {
-    const candidate = level;
-    if (candidate === void 0 || candidate === null) {
-      throw connectorError("configurationError" /* ConfigurationError */, "DiagnosticsLevel is invalid.");
-    }
-    validateDiagnosticsLevel(level);
-    this.current = level;
-  }
-};
-
 // packages/stream-connector/src/Runtime/ZlinkStreamPendingRequests.ts
 var ZlinkStreamPendingRequests = class {
   nextRequestSeq = 1n;
@@ -1596,16 +1564,21 @@ var ZlinkStreamPendingRequests = class {
     let timeout;
     let resolvePending;
     let rejectPending;
-    const promise = new Promise((resolve, reject) => {
-      timeout = setTimeout(() => {
-        this.active.delete(requestSeq);
-        reject(
-          connectorError("requestTimeout" /* RequestTimeout */, `Request '${packetName}' timed out.`)
-        );
-      }, timeoutMs);
-      resolvePending = resolve;
-      rejectPending = (error) => reject(connectorError(error.code, error.message, error.cause));
-    });
+    const promise = new Promise(
+      (resolve, reject) => {
+        timeout = setTimeout(() => {
+          this.active.delete(requestSeq);
+          reject(
+            connectorError(
+              "requestTimeout" /* RequestTimeout */,
+              `Request '${packetName}' timed out.`
+            )
+          );
+        }, timeoutMs);
+        resolvePending = resolve;
+        rejectPending = (error) => reject(connectorError(error.code, error.message, error.cause));
+      }
+    );
     this.active.set(requestSeq, {
       packetName,
       promise,
@@ -1629,15 +1602,14 @@ var ZlinkStreamPendingRequests = class {
     });
     return { requestSeq, promise };
   }
-  /* stream connector spec §5.2: a pending request is matched by request_seq alone. Diagnostics
-   * use the original request name retained by this registry, never a legacy reply name. */
-  resolve(requestSeq, value) {
+  /* stream connector spec §5.2: a pending request is matched by request_seq alone. */
+  resolve(requestSeq, value, metadata) {
     const pending = this.active.get(requestSeq);
     if (pending === void 0) {
       return false;
     }
     this.active.delete(requestSeq);
-    pending.resolve(value);
+    pending.resolve({ name: pending.packetName, metadata, payload: value });
     return true;
   }
   reject(requestSeq, error) {
@@ -1773,9 +1745,11 @@ var ZlinkStreamReceivedMessages = class {
    */
   resetForNewConnection() {
     this.receivedCounts.clear();
+    const submittedCallbacks = this.queue.slice(this.queueHead).filter((item) => item?.kind === "callback");
     this.queue.length = 0;
+    this.queue.push(...submittedCallbacks);
     this.queueHead = 0;
-    this.queuedCount = 0;
+    this.queuedCount = submittedCallbacks.length;
   }
   /**
    * Releases every registered wait surface because the connection it was
@@ -1791,7 +1765,7 @@ var ZlinkStreamReceivedMessages = class {
     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();
@@ -1799,12 +1773,19 @@ var ZlinkStreamReceivedMessages = class {
   }
   enqueue(message, signal) {
     this.receivedCounts.set(message.name, (this.receivedCounts.get(message.name) ?? 0) + 1);
-    for (const registration of [...this.observers.get(message.name) ?? []]) {
+    for (const registration of Array.from(this.observers.get(message.name) ?? [])) {
       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();
@@ -1831,7 +1812,7 @@ var ZlinkStreamReceivedMessages = class {
   offerQueued(name, registration) {
     for (let index = this.queueHead; index < this.queue.length; index += 1) {
       const queued = this.queue[index];
-      if (queued === void 0 || queued.message.name !== name) {
+      if (queued === void 0 || queued.kind !== "message" || queued.message.name !== name) {
         continue;
       }
       if (!registration.consume(queued.message)) {
@@ -1859,8 +1840,12 @@ var ZlinkStreamReceivedMessages = class {
         const queued = this.queue[index];
         if (queued === void 0) continue;
         this.removeAt(index);
+        if (queued.kind === "callback") {
+          await queued.callback();
+          continue;
+        }
         const { message, signal } = queued;
-        const handlers = [...this.handlers.get(message.name)];
+        const handlers = Array.from(this.handlers.get(message.name));
         for (const handler of handlers) {
           try {
             await handler(message, signal);
@@ -1889,7 +1874,7 @@ var ZlinkStreamReceivedMessages = class {
   findDeliverableIndex() {
     for (let index = this.queueHead; index < this.queue.length; index += 1) {
       const queued = this.queue[index];
-      if (queued !== void 0 && (this.handlers.get(queued.message.name)?.size ?? 0) > 0) {
+      if (queued !== void 0 && (queued.kind === "callback" || (this.handlers.get(queued.message.name)?.size ?? 0) > 0)) {
         return index;
       }
     }
@@ -1897,7 +1882,8 @@ var ZlinkStreamReceivedMessages = class {
   }
   hasQueuedMessage(name) {
     for (let index = this.queueHead; index < this.queue.length; index += 1) {
-      if (this.queue[index]?.message.name === name) return true;
+      const queued = this.queue[index];
+      if (queued?.kind === "message" && queued.message.name === name) return true;
     }
     return false;
   }
@@ -1921,14 +1907,12 @@ var ZlinkStreamReceivedMessages = class {
 
 // packages/stream-connector/src/Runtime/ZlinkStreamFrameSender.ts
 var ZlinkStreamFrameSender = class {
-  constructor(protocol, flowContext) {
+  constructor(protocol) {
     this.protocol = protocol;
-    this.flowContext = flowContext;
   }
   pendingWrites = /* @__PURE__ */ new Set();
-  async send(connection, kind, name, payload, metadata, compress, requestSeq, signal, correlationId, explicitFlow) {
+  async send(connection, kind, name, payload, metadata, compress, requestSeq, signal, correlationId, actorSlot) {
     throwIfAborted(signal);
-    const flow = this.protocol.flowEnabled() ? this.flowContext.currentOrCreate(explicitFlow) : void 0;
     await this.write(
       connection,
       this.protocol.encode(
@@ -1939,8 +1923,7 @@ var ZlinkStreamFrameSender = class {
         compress,
         requestSeq,
         correlationId,
-        flow?.flowId,
-        flow?.flowOrigin
+        actorSlot
       ),
       signal
     );
@@ -1951,7 +1934,7 @@ var ZlinkStreamFrameSender = class {
   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) {
@@ -1987,15 +1970,185 @@ function decodeSessionClosing(payload) {
   return { closeReason, diagnostic };
 }
 
+// packages/stream-connector/src/Runtime/ZlinkStreamActors.ts
+var ACTOR_BOUND = "$zlink.actor.bound";
+var ACTOR_UNBOUND = "$zlink.actor.unbound";
+var zlinkStreamActorBinding = Symbol("zlink.stream.actorBinding");
+var DefaultZlinkStreamActor = class {
+  constructor(connector, actorId, slot) {
+    this.connector = connector;
+    this.actorId = actorId;
+    this.slot = slot;
+  }
+  bound = true;
+  get isBound() {
+    return this.bound;
+  }
+  send(payload, messageType) {
+    this.ensureBound();
+    return this.connector.sendForActor(this, payload, messageType);
+  }
+  request(payload, messageType) {
+    this.ensureBound();
+    return this.connector.requestForActor(this, payload, messageType);
+  }
+  on(nameOrType, handler, messageType) {
+    return this.connector.onActorMessage(this, nameOrType, handler, messageType);
+  }
+  ensureBound() {
+    if (!this.bound) {
+      throw connectorError(
+        "validationFailed" /* ValidationFailed */,
+        `Actor '${this.actorId}' is no longer bound.`
+      );
+    }
+  }
+  close() {
+    this.bound = false;
+  }
+};
+var ZlinkStreamActors = class {
+  constructor(connector, receivedMessages, events) {
+    this.connector = connector;
+    this.receivedMessages = receivedMessages;
+    this.events = events;
+  }
+  bySlot = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  issued = [];
+  boundHandlers = /* @__PURE__ */ new Set();
+  unboundHandlers = /* @__PURE__ */ new Set();
+  get snapshot() {
+    return Object.freeze(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;
   }
   /**
@@ -2022,49 +2175,47 @@ var ZlinkStreamReceiveDispatcher = class {
     if (frameBytes === void 0) {
       return { available: false, inbound: false };
     }
-    const flowEnabled = this.protocol.flowEnabled();
     let frames;
     try {
-      frames = this.protocol.decodeFrames(frameBytes, flowEnabled);
+      frames = this.protocol.decodeFrames(frameBytes);
     } catch (cause) {
-      await this.events.publishError(
-        toStreamError(cause, "frameDecodeFailed" /* FrameDecodeFailed */, "Frame decode failed."),
-        signal
-      );
-      return { available: true, inbound: false };
+      throw cause;
     }
     for (const frame of frames) {
       if (isCurrent !== void 0 && !isCurrent()) {
         break;
       }
       try {
-        await this.dispatch(
-          connection,
-          frame.header,
-          frame.payload,
-          signal,
-          flowEnabled,
-          connectionForSend
-        );
+        await this.dispatch(connection, frame.header, frame.payload, signal, connectionForSend);
       } catch (cause) {
         if (frame.header.kind === 5 /* Control */ && frame.header.name === ZLINK_STREAM_HEARTBEAT_PING) {
           throw cause;
         }
-        await this.events.publishError(
-          toStreamError(cause, "frameDecodeFailed" /* FrameDecodeFailed */, "Frame dispatch failed."),
-          signal
+        const error = toStreamError(
+          cause,
+          "frameDecodeFailed" /* FrameDecodeFailed */,
+          "Frame dispatch failed."
         );
+        if (error.code === "frameDecodeFailed" /* FrameDecodeFailed */) {
+          throw cause;
+        }
+        await this.events.publishError(error, signal);
       }
     }
     return { available: true, inbound: true };
   }
-  async dispatch(connection, header, payload, signal, flowEnabled, connectionForSend) {
+  async dispatch(connection, header, payload, signal, connectionForSend) {
+    const actor = header.actorSlot === void 0 ? void 0 : this.actors.resolve(header.actorSlot);
     if (header.kind === 3 /* Response */ && header.requestSeq !== void 0) {
       try {
-        if (!this.pendingRequests.resolve(header.requestSeq, {
-          codec: header.codec,
-          payload: this.protocol.decodePayload(header, payload)
-        })) {
+        if (!this.pendingRequests.resolve(
+          header.requestSeq,
+          {
+            codec: header.codec,
+            payload: this.protocol.decodePayload(header, payload)
+          },
+          header.metadata
+        )) {
           await this.events.publishError(
             {
               code: "frameDecodeFailed" /* FrameDecodeFailed */,
@@ -2112,20 +2263,22 @@ var ZlinkStreamReceiveDispatcher = class {
       return;
     }
     if (header.kind === 1 /* Send */) {
-      const flow = flowEnabled ? this.flowContext.createInbound(header.flowId, header.flowOrigin) : void 0;
       this.receivedMessages.enqueue(
         {
           name: header.name,
           metadata: header.metadata,
           payload: { codec: header.codec, payload: this.protocol.decodePayload(header, payload) },
-          flowId: flow?.flowId,
-          flowOrigin: flow?.flowOrigin
+          actorId: actor?.actorId,
+          [zlinkStreamActorBinding]: actor
         },
         signal
       );
     }
   }
   async dispatchControl(connection, header, payload, signal, connectionForSend) {
+    if (this.actors.processControl(header.name, payload, signal)) {
+      return;
+    }
     if (header.name === ZLINK_SESSION_CLOSING) {
       const closing = decodeSessionClosing(payload);
       await this.serverClosing?.(closing.closeReason);
@@ -2184,12 +2337,13 @@ function randomizedDelay(baseDelayMs) {
   return Math.round(baseDelayMs * (0.5 + Math.random() * 0.5));
 }
 var ZlinkStreamConnectorLifecycle = class {
-  constructor(options, pendingRequests, frameSender, receiveDispatcher, receivedMessages, events) {
+  constructor(options, pendingRequests, frameSender, receiveDispatcher, receivedMessages, actors, events) {
     this.options = options;
     this.pendingRequests = pendingRequests;
     this.frameSender = frameSender;
     this.receiveDispatcher = receiveDispatcher;
     this.receivedMessages = receivedMessages;
+    this.actors = actors;
     this.events = events;
   }
   receiveLoopAbort;
@@ -2325,8 +2479,9 @@ var ZlinkStreamConnectorLifecycle = class {
       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.");
   }
@@ -2555,6 +2710,7 @@ var ZlinkStreamConnectorLifecycle = class {
     this.currentConnection = void 0;
     this.pendingRequests.failAll(error);
     this.receivedMessages.connectionEnded();
+    this.actors.closeAll();
     try {
       await connection?.close();
     } catch {
@@ -2570,11 +2726,8 @@ var ZlinkStreamConnectorLifecycle = class {
    */
   async announceDisconnect(error) {
     if (this.closeRequested) return;
-    const announce = this.claimDisconnectedPublish();
-    void this.setState("disconnected" /* Disconnected */, error);
-    if (announce) {
-      void this.events.publishDisconnected().catch(() => void 0);
-    }
+    this.queueState("disconnected" /* Disconnected */, error);
+    this.queueDisconnected();
     if (this.shouldReconnect()) {
       queueMicrotask(() => {
         void this.connect().catch(() => void 0);
@@ -2622,16 +2775,35 @@ var ZlinkStreamConnectorLifecycle = class {
   publishDisconnectedWithoutWaiting(signal) {
     void this.publishDisconnectedOnce(signal).catch(() => void 0);
   }
+  queueDisconnected(signal) {
+    if (!this.claimDisconnectedPublish()) return;
+    this.receivedMessages.enqueueCallback(() => {
+      void this.events.publishDisconnected(signal).catch(() => void 0);
+    });
+  }
+  queueState(current, error, signal) {
+    const change = this.transitionState(current, error);
+    if (change === void 0) return;
+    this.receivedMessages.enqueueCallback(() => {
+      void this.publishStateChange(change, signal).catch(() => void 0);
+    });
+  }
   async setState(current, error, signal) {
+    const change = this.transitionState(current, error);
+    if (change === void 0) return;
+    await this.publishStateChange(change, signal);
+  }
+  transitionState(current, error) {
     const previous = this.currentState;
     this.currentState = current;
     if (previous === current && error === void 0) {
-      return;
-    }
-    await this.events.publishStateChanged({ previous, current, error }, signal);
-    if (error !== void 0) {
-      await this.events.publishError(error, signal);
+      return void 0;
     }
+    return { previous, current, error };
+  }
+  async publishStateChange(change, signal) {
+    await this.events.publishStateChanged(change, signal);
+    if (change.error !== void 0) await this.events.publishError(change.error, signal);
   }
 };
 
@@ -2653,49 +2825,25 @@ var ZlinkStreamConnectorEvents = class {
     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 ?? { flowId: this.createUuidV7(), flowOrigin: "Application" };
-  }
-  createInbound(flowId, flowOrigin) {
-    return { flowId: flowId ?? this.createUuidV7(), flowOrigin: flowOrigin ?? "Inbound" };
-  }
-  createUuidV7() {
-    const crypto = globalThis.crypto;
-    if (crypto === void 0) {
-      throw connectorError(
-        "configurationError" /* ConfigurationError */,
-        "The browser entrypoint requires the platform Web Crypto API."
-      );
-    }
-    return formatUuidV7(crypto.getRandomValues(new Uint8Array(16)));
-  }
-};
-function formatUuidV7(bytes) {
-  const timestamp = BigInt(Date.now());
-  for (let index = 5; index >= 0; index -= 1) {
-    bytes[index] = Number(timestamp >> BigInt((5 - index) * 8) & 0xffn);
-  }
-  bytes[6] = 112 | bytes[6] & 15;
-  bytes[8] = 128 | bytes[8] & 63;
-  const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-
 // packages/stream-connector/src/Runtime/Transport/BrowserWebSocketConnection.ts
 var BrowserStreamTransportFactory = class {
   async connect(options, signal) {
@@ -2910,30 +3058,26 @@ var DefaultZlinkStreamConnector = class {
   pendingRequests = new ZlinkStreamPendingRequests();
   frameSender;
   receiveDispatcher;
-  diagnosticsLevelCell;
+  requestSendingHandlers = /* @__PURE__ */ new Set();
+  replyReceivedHandlers = /* @__PURE__ */ new Set();
+  boundActors;
   options;
   constructor(options) {
-    const flowContext = new BrowserZlinkFlowContext();
     this.options = normalizeOptions(options, new BrowserStreamTransportFactory());
-    this.diagnosticsLevelCell = new ZlinkStreamDiagnosticsLevelCell(this.options.diagnosticsLevel);
-    Object.defineProperty(this.options, "diagnosticsLevel", {
-      enumerable: true,
-      configurable: true,
-      get: () => this.diagnosticsLevelCell.level
-    });
     const protocol = new ZlinkStreamFrameProtocol(this.options);
-    this.frameSender = new ZlinkStreamFrameSender(protocol, flowContext);
+    this.frameSender = new ZlinkStreamFrameSender(protocol);
     this.receivedMessages = new ZlinkStreamReceivedMessages(
       this.events,
       this.options.dispatchMode === "immediate" /* Immediate */
     );
+    this.boundActors = new ZlinkStreamActors(this, this.receivedMessages, this.events);
     this.receiveDispatcher = new ZlinkStreamReceiveDispatcher(
       protocol,
       this.pendingRequests,
       this.receivedMessages,
       this.frameSender,
       this.events,
-      flowContext,
+      this.boundActors,
       (reason) => this.lifecycle.serverClosing(reason)
     );
     this.lifecycle = new ZlinkStreamConnectorLifecycle(
@@ -2942,6 +3086,7 @@ var DefaultZlinkStreamConnector = class {
       this.frameSender,
       this.receiveDispatcher,
       this.receivedMessages,
+      this.boundActors,
       this.events
     );
   }
@@ -2957,6 +3102,18 @@ var DefaultZlinkStreamConnector = class {
   get pendingDispatchCount() {
     return this.pendingRequests.count;
   }
+  get actors() {
+    return this.boundActors.snapshot;
+  }
+  actor(actorId) {
+    return this.boundActors.find(actorId);
+  }
+  onActorBound(handler) {
+    return this.boundActors.onBound(handler);
+  }
+  onActorUnbound(handler) {
+    return this.boundActors.onUnbound(handler);
+  }
   /**
    * Spec stream-connector 32 §10: how many packets carrying `name` arrived on
    * the current connection. Arrivals are what is counted, so a message a
@@ -2968,37 +3125,6 @@ var DefaultZlinkStreamConnector = class {
     validateName(name);
     return this.receivedMessages.receivedCount(name);
   }
-  /**
-   * Current diagnostics level (spec 26 §4.1, spec stream-connector 32 §13).
-   * Reflects the level set by the most recent {@link setDiagnosticsLevel}
-   * call, or the construction-time option (default
-   * {@link ZlinkStreamDiagnosticsLevel.Errors}) if it was never changed.
-   */
-  get diagnosticsLevel() {
-    return this.diagnosticsLevelCell.level;
-  }
-  /**
-   * Changes the diagnostics level in place without recreating the connector
-   * (spec 26 §4.1, spec stream-connector 32 §13). The change is an atomic
-   * state update: it applies to processing points that read the level after
-   * this call returns and is never applied retroactively to frames already
-   * built. Rejects unknown values with {@link ZlinkStreamErrorCode.ConfigurationError}.
-   * Spec stream-connector 32 §13: this surface changes the value without
-   * waiting for anything; it is not a blocking call over the asynchronous pair,
-   * which a receive callback would otherwise make wait for its own completion.
-   */
-  setDiagnosticsLevel(level) {
-    this.diagnosticsLevelCell.set(level);
-  }
-  /**
-   * Asynchronous counterpart of {@link setDiagnosticsLevel} (spec
-   * stream-connector 32 §13). It changes the same value; awaiting it is how a
-   * caller observes the change, and it never replaces the synchronous surface.
-   */
-  setDiagnosticsLevelAsync(level) {
-    this.setDiagnosticsLevel(level);
-    return Promise.resolve();
-  }
   onErrorReceived(handler) {
     return this.events.onError(handler);
   }
@@ -3008,6 +3134,14 @@ var DefaultZlinkStreamConnector = class {
   onConnectionStateChanged(handler) {
     return this.events.onStateChanged(handler);
   }
+  onRequestSending(handler) {
+    this.requestSendingHandlers.add(handler);
+    return subscription(() => this.requestSendingHandlers.delete(handler));
+  }
+  onReplyReceived(handler) {
+    this.replyReceivedHandlers.add(handler);
+    return subscription(() => this.replyReceivedHandlers.delete(handler));
+  }
   async connect(signal) {
     await this.lifecycle.connect(signal);
   }
@@ -3025,18 +3159,60 @@ var DefaultZlinkStreamConnector = class {
     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 ?? (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 ?? (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));
@@ -3119,8 +3295,7 @@ var DefaultZlinkStreamConnector = class {
               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;
@@ -3159,7 +3334,7 @@ var DefaultZlinkStreamConnector = class {
     }
     return payload;
   }
-  async sendEncoded(kind, name, payload, metadata, compress, requestSeq, signal, flow, correlationId) {
+  async sendEncoded(kind, name, payload, metadata, compress, requestSeq, signal, correlationId, actorSlot) {
     await this.frameSender.send(
       this.lifecycle.connectionForSend(),
       kind,
@@ -3170,37 +3345,105 @@ var DefaultZlinkStreamConnector = class {
       requestSeq,
       signal,
       correlationId,
-      flow
+      actorSlot
     );
   }
   /**
    * Per-connector monotonic correlation id (hex). The client generates it on each request
-   * and the server echoes it back on the reply, so flows can be joined across the wire.
+   * and the server echoes it back on the reply.
    */
   nextCorrelationId() {
     this.correlationCounter += 1n;
     return this.correlationCounter.toString(16);
   }
-  async requestEncoded(name, payload, metadata, compress, timeoutMs, signal, flow) {
-    const pending = this.pendingRequests.create(name, timeoutMs);
+  async requestEncoded(name, payload, metadata, compress, timeoutMs, signal, actorSlot) {
+    const startedAt = Date.now();
+    const actorId = actorSlot === void 0 ? void 0 : this.boundActors.resolve(actorSlot).actorId;
+    let requestMetadata = metadata;
+    const sendingContext = {
+      requestPacketName: name,
+      actorId,
+      setMetadata(key, value) {
+        requestMetadata = requestMetadata.with(key, value);
+      }
+    };
+    let pending;
     try {
+      throwIfAborted(signal);
+      for (const handler of 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;
@@ -3226,7 +3469,6 @@ export {
   ZlinkStreamCodec,
   ZlinkStreamCompression,
   ZlinkStreamConnectionState,
-  ZlinkStreamDiagnosticsLevel,
   ZlinkStreamDispatchMode,
   ZlinkStreamErrorCode,
   ZlinkStreamException,