@zlink-systems/stream-connector 0.25.0 → 0.26.0

package/dist/browser/index.mjs

@@ -9,11 +9,7 @@ function lz4PickleUncompressed(payload) {
   pickled.set(payload, 1);
   return pickled;
 }
-function lz4UnpicklePayload(payload, maxSize) {
-  const maxDecompressedSize = maxSize ?? defaultMaxDecompressedPayloadSize;
-  if (payload.length === 0) {
-    return new Uint8Array();
-  }
+function readLz4Pickle(payload) {
   const header = payload[0];
   if ((header & 7) !== 0) {
     throw new Error("Unexpected LZ4 pickle version.");
@@ -25,7 +21,17 @@ function lz4UnpicklePayload(payload, maxSize) {
   }
   const data = payload.subarray(dataOffset);
   const resultDiff = sizeOfDiff === 0 ? 0 : readLittleEndian(payload, 1, sizeOfDiff);
-  const resultLength = data.length + resultDiff;
+  return { data, resultDiff, resultLength: data.length + resultDiff };
+}
+function lz4PickledLength(payload) {
+  return payload.length === 0 ? 0 : readLz4Pickle(payload).resultLength;
+}
+function lz4UnpicklePayload(payload, maxSize) {
+  const maxDecompressedSize = maxSize ?? defaultMaxDecompressedPayloadSize;
+  if (payload.length === 0) {
+    return new Uint8Array();
+  }
+  const { data, resultDiff, resultLength } = readLz4Pickle(payload);
   if (resultLength > maxDecompressedSize) {
     throw new Error("LZ4 decoded payload exceeds maximum stream payload size.");
   }
@@ -376,6 +382,9 @@ function decodeStreamWireMetadata(metadata) {
 function lz4PickleUncompressed2(payload) {
   return lz4PickleUncompressed(payload);
 }
+function lz4PickledLength2(payload) {
+  return lz4PickledLength(payload);
+}
 function lz4UnpicklePayload2(payload, maxDecompressedSize) {
   return lz4UnpicklePayload(payload, maxDecompressedSize ?? defaultMaxDecompressedPayloadSize);
 }
@@ -817,9 +826,10 @@ var ZlinkStreamSendBuilder = class {
   }
 };
 var ZlinkStreamRequestBuilder = class {
-  constructor(connector, name, payload, actorSlot, validateActor) {
+  constructor(connector, name, payload, enqueueCallback, actorSlot, validateActor) {
     this.connector = connector;
     this.payload = payload;
+    this.enqueueCallback = enqueueCallback;
     this.state = new ZlinkStreamCallBuilderState(name, actorSlot, validateActor);
   }
   state;
@@ -853,8 +863,10 @@ var ZlinkStreamRequestBuilder = class {
     );
     if (typeof signalOrCallback === "function") {
       operation.then(
-        (value) => signalOrCallback({ isSuccess: true, value }),
-        (error) => signalOrCallback({ isSuccess: false, error: unwrapStreamError(error) })
+        (value) => this.enqueueCallback(() => signalOrCallback({ isSuccess: true, value })),
+        (error) => this.enqueueCallback(
+          () => signalOrCallback({ isSuccess: false, error: unwrapStreamError(error) })
+        )
       );
       return;
     }
@@ -1059,6 +1071,12 @@ var zlinkStreamLz4CompressionCodec = {
     return lz4PickleUncompressed2(payload);
   },
   decompress(payload, maxDecompressedSize) {
+    if (lz4PickledLength2(payload) > maxDecompressedSize) {
+      throw connectorError(
+        "frameTooLarge" /* FrameTooLarge */,
+        "LZ4 decoded payload exceeds MaxReceivePayloadSize."
+      );
+    }
     return lz4UnpicklePayload2(payload, maxDecompressedSize);
   }
 };
@@ -1070,7 +1088,11 @@ function compressPayload(payload, compression, compressionCodec) {
       "Compression codec is not configured."
     );
   }
-  return codec.compress(payload);
+  try {
+    return codec.compress(payload);
+  } catch (cause) {
+    throw connectorError("compressionFailed" /* CompressionFailed */, "Compression failed.", cause);
+  }
 }
 function decompressIfNeeded(header, payload, compression, compressionCodec, maxDecompressedSize) {
   if ((header.flags & 4 /* PayloadCompressed */) === 0) {
@@ -1083,15 +1105,20 @@ function decompressIfNeeded(header, payload, compression, compressionCodec, maxD
       "Compression codec is not configured."
     );
   }
+  let decompressed;
   try {
-    const decompressed = codec.decompress(payload, maxDecompressedSize);
-    if (decompressed.length > maxDecompressedSize) {
-      throw new Error("Decoded payload exceeds MaxReceivePayloadSize.");
-    }
-    return decompressed;
+    decompressed = codec.decompress(payload, maxDecompressedSize);
   } catch (cause) {
+    if (cause instanceof ZlinkStreamException) throw cause;
     throw connectorError("decompressionFailed" /* DecompressionFailed */, "Decompression failed.", cause);
   }
+  if (decompressed.length > maxDecompressedSize) {
+    throw connectorError(
+      "frameTooLarge" /* FrameTooLarge */,
+      "Decompressed payload exceeds MaxReceivePayloadSize."
+    );
+  }
+  return decompressed;
 }
 function resolveCompressionCodec(compression, compressionCodec) {
   if (compression === "none" /* None */) {
@@ -1459,6 +1486,40 @@ function normalizeOptions(options, defaultTransportFactory) {
   validatePositive(options.maxReceivePayloadSize ?? 64 * 1024, "MaxReceivePayloadSize");
   validateHeartbeat(options.heartbeat);
   validateReconnect(options.reconnect);
+  if (options.heartbeat?.enabled !== void 0 && typeof options.heartbeat.enabled !== "boolean") {
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Heartbeat enabled must be boolean."
+    );
+  }
+  if (options.reconnect?.enabled !== void 0 && typeof options.reconnect.enabled !== "boolean") {
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Reconnect enabled must be boolean."
+    );
+  }
+  if (options.compressionCodec !== void 0 && !hasMethods(options.compressionCodec, "compress", "decompress")) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "Compression codec is invalid.");
+  }
+  if (options.codec !== void 0 && !hasMethods(options.codec, "encode", "decode")) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "Payload codec is invalid.");
+  }
+  if (options.nameResolver !== void 0 && !hasMethods(options.nameResolver, "resolve")) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "Packet name resolver is invalid.");
+  }
+  if (options.transportFactory !== void 0 && !hasMethods(options.transportFactory, "connect")) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "Transport factory is invalid.");
+  }
+  if (!Object.values(ZlinkStreamDispatchMode).includes(
+    options.dispatchMode ?? "manual" /* Manual */
+  )) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "DispatchMode is invalid.");
+  }
+  if (!Object.values(ZlinkStreamCompression).includes(
+    options.compression ?? "lz4" /* Lz4 */
+  )) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "Compression is invalid.");
+  }
   return {
     endpoint,
     transport: inferredTransport,
@@ -1510,39 +1571,25 @@ function resolveCompressionCodec2(options) {
   return options.compressionCodec;
 }
 function validatePositive(value, name) {
-  if (value <= 0) {
+  if (!Number.isFinite(value) || value <= 0) {
     throw connectorError("validationFailed" /* ValidationFailed */, `${name} must be positive.`);
   }
 }
+function hasMethods(value, ...names) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return names.every((name) => typeof candidate[name] === "function");
+}
 function validateHeartbeat(options) {
-  const enabled = options?.enabled ?? true;
   const intervalMs = options?.intervalMs ?? 1e3;
   const timeoutMs = options?.timeoutMs ?? 5e3;
-  if (!enabled) {
-    return;
-  }
   validatePositive(intervalMs, "Heartbeat interval");
   validatePositive(timeoutMs, "Heartbeat timeout");
-  if (timeoutMs <= intervalMs) {
-    throw connectorError(
-      "validationFailed" /* ValidationFailed */,
-      "Heartbeat timeout must be greater than the heartbeat interval."
-    );
-  }
 }
 function validateReconnect(options) {
-  const enabled = options?.enabled ?? true;
-  if (!enabled) {
-    return;
-  }
   validatePositive(options?.initialDelayMs ?? 250, "Reconnect InitialDelay");
   validatePositive(options?.maxDelayMs ?? 5e3, "Reconnect MaxDelay");
-  if ((options?.backoffFactor ?? 2) < 1) {
-    throw connectorError(
-      "validationFailed" /* ValidationFailed */,
-      "Reconnect BackoffFactor must be at least 1.0."
-    );
-  }
+  validatePositive(options?.backoffFactor ?? 2, "Reconnect BackoffFactor");
   const maxAttempts = options?.maxAttempts === void 0 ? 3 : options.maxAttempts;
   if (maxAttempts !== null && !(Number.isFinite(maxAttempts) && maxAttempts > 0)) {
     throw connectorError(
@@ -1556,32 +1603,33 @@ function validateReconnect(options) {
 var ZlinkStreamPendingRequests = class {
   nextRequestSeq = 1n;
   active = /* @__PURE__ */ new Map();
-  get count() {
-    return this.active.size;
-  }
   create(packetName, timeoutMs) {
+    if (this.nextRequestSeq > 0xffffffffffffffffn) {
+      throw connectorError("sendFailed" /* SendFailed */, "Request sequence is exhausted.");
+    }
     const requestSeq = this.nextRequestSeq++;
     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));
       }
     );
-    this.active.set(requestSeq, {
+    const tracked = {
       packetName,
       promise,
+      startTimeout: () => {
+        if (timeout !== void 0 || this.active.get(requestSeq) !== tracked) return;
+        timeout = setTimeout(() => {
+          this.active.delete(requestSeq);
+          rejectPending({
+            code: "requestTimeout" /* RequestTimeout */,
+            message: `Request '${packetName}' timed out.`
+          });
+        }, timeoutMs);
+      },
       resolve: (value) => {
         if (timeout !== void 0) {
           clearTimeout(timeout);
@@ -1599,8 +1647,9 @@ var ZlinkStreamPendingRequests = class {
           clearTimeout(timeout);
         }
       }
-    });
-    return { requestSeq, promise };
+    };
+    this.active.set(requestSeq, tracked);
+    return { requestSeq, promise, startTimeout: tracked.startTimeout };
   }
   /* stream connector spec §5.2: a pending request is matched by request_seq alone. */
   resolve(requestSeq, value, metadata) {
@@ -1608,8 +1657,9 @@ var ZlinkStreamPendingRequests = class {
     if (pending === void 0) {
       return false;
     }
+    const payload = value();
     this.active.delete(requestSeq);
-    pending.resolve({ name: pending.packetName, metadata, payload: value });
+    pending.resolve({ name: pending.packetName, metadata, payload });
     return true;
   }
   reject(requestSeq, error) {
@@ -1637,7 +1687,164 @@ var ZlinkStreamPendingRequests = class {
   }
 };
 
+// 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.events.runUserCallback(
+            () => handler(actor, signal),
+            "Actor lifecycle handler failed.",
+            signal
+          );
+        }
+      },
+      () => handlers.size
+    );
+  }
+};
+function invalidControl(message) {
+  return connectorError("frameDecodeFailed" /* FrameDecodeFailed */, message);
+}
+
 // packages/stream-connector/src/Runtime/ZlinkStreamReceivedMessages.ts
+function receives(registration, message) {
+  return registration.actor === void 0 || registration.actor === message[zlinkStreamActorBinding];
+}
 var ZlinkStreamReceivedMessages = class {
   /**
    * @param deliverOnArrival `Immediate` runs registered handlers on the receive
@@ -1655,10 +1862,10 @@ var ZlinkStreamReceivedMessages = class {
   // queue is not a simple FIFO. Tombstones let us remove a deliverable entry
   // without shifting every later message on the hot receive path.
   queue = [];
+  deliverable = [];
   queueHead = 0;
   queuedCount = 0;
-  drainTask;
-  // True for as long as `drain` is on the stack, handler awaits included. It
+  // True for as long as `pump` is on the stack. It
   // marks the execution context a registered handler runs in, so a `dispatch`
   // made from inside a handler is recognised as re-entry rather than a fresh
   // pump. It is not a lock: a single event loop admits no second thread, and
@@ -1668,19 +1875,32 @@ var ZlinkStreamReceivedMessages = class {
   // connection. It is raised where a packet arrives, never where one is taken,
   // so consuming does not lower it and the dispatch mode does not change it.
   receivedCounts = /* @__PURE__ */ new Map();
-  on(name, handler) {
+  /**
+   * @param actor The Actor handle that registers the handler, if any. Its
+   *   handler receives only that Actor's packets.
+   */
+  on(name, handler, actor) {
     validateName(name);
     let set = this.handlers.get(name);
     if (set === void 0) {
       set = /* @__PURE__ */ new Set();
       this.handlers.set(name, set);
     }
-    set.add(handler);
-    if (this.deliverOnArrival && this.hasQueuedMessage(name)) {
-      queueMicrotask(() => this.scheduleDrain());
+    const registration = { handle: handler, actor };
+    set.add(registration);
+    let newlyDeliverable = false;
+    for (let index = this.queueHead; index < this.queue.length; index += 1) {
+      const queued = this.queue[index];
+      if (queued?.kind === "message" && queued.indexed !== true && queued.message.name === name && receives(registration, queued.message)) {
+        this.indexDeliverable(index);
+        newlyDeliverable = true;
+      }
+    }
+    if (this.deliverOnArrival && newlyDeliverable) {
+      queueMicrotask(() => this.pump());
     }
     return subscription(() => {
-      set.delete(handler);
+      set.delete(registration);
       if (set.size === 0 && this.handlers.get(name) === set) {
         this.handlers.delete(name);
       }
@@ -1750,6 +1970,11 @@ var ZlinkStreamReceivedMessages = class {
     this.queue.push(...submittedCallbacks);
     this.queueHead = 0;
     this.queuedCount = submittedCallbacks.length;
+    this.deliverable.length = 0;
+    for (let index = 0; index < this.queue.length; index += 1) {
+      this.queue[index].indexed = false;
+      this.indexDeliverable(index);
+    }
   }
   /**
    * Releases every registered wait surface because the connection it was
@@ -1780,60 +2005,38 @@ var ZlinkStreamReceivedMessages = class {
     }
     this.queue.push({ kind: "message", message, signal });
     this.queuedCount += 1;
+    this.indexDeliverable(this.queue.length - 1);
     if (this.deliverOnArrival) {
-      this.scheduleDrain();
+      this.pump();
     }
   }
-  enqueueCallback(callback) {
-    this.queue.push({ kind: "callback", callback });
+  /**
+   * @param callbacks The number of handler calls `callback` makes when it runs
+   *   with the handlers registered at that moment; a callback that runs a set
+   *   of handlers reads the set's size. One callback by default.
+   */
+  enqueueCallback(callback, callbacks = () => 1) {
+    this.queue.push({ kind: "callback", callback, callbacks });
     this.queuedCount += 1;
+    this.indexDeliverable(this.queue.length - 1);
     if (this.deliverOnArrival) {
-      this.scheduleDrain();
+      this.pump();
     }
   }
   /**
    * Runs the registered handlers the receive path left queued. `Manual` calls
-   * this from `dispatch`; `Immediate` has already drained on arrival.
+   * this from `dispatch`; `Immediate` drains on arrival.
    *
-   * A handler that calls `dispatch` arrives back here from inside the drain it
-   * was started by. `scheduleDrain` would find `drainTask` already set and
-   * return, and the await below would then be the drain waiting on itself —
-   * a deadlock with neither timeout nor error. The drain loop already takes
-   * every message a handler exists for, so there is nothing a second drain
-   * would deliver and returning is the whole of the correct behaviour.
+   * The drain is synchronous: the connector does not wait for a handler
+   * (spec stream-connector 32 §7), so nothing inside it awaits. A handler that
+   * calls `dispatch` arrives back here from inside the drain it was started by;
+   * the running loop already takes every deliverable entry, so returning is the
+   * whole of the correct behaviour.
    */
-  async pump() {
+  pump() {
     if (this.draining) {
       return;
     }
-    this.scheduleDrain();
-    await this.drainTask;
-  }
-  offerQueued(name, registration) {
-    for (let index = this.queueHead; index < this.queue.length; index += 1) {
-      const queued = this.queue[index];
-      if (queued === void 0 || queued.kind !== "message" || queued.message.name !== name) {
-        continue;
-      }
-      if (!registration.consume(queued.message)) {
-        continue;
-      }
-      this.removeAt(index);
-      return;
-    }
-  }
-  scheduleDrain() {
-    if (this.drainTask !== void 0) {
-      return;
-    }
-    this.drainTask = this.drain().finally(() => {
-      this.drainTask = void 0;
-      if (this.deliverOnArrival && this.findDeliverableIndex() >= 0) {
-        this.scheduleDrain();
-      }
-    });
-  }
-  async drain() {
     this.draining = true;
     try {
       for (let index = this.findDeliverableIndex(); index >= 0; index = this.findDeliverableIndex()) {
@@ -1841,51 +2044,113 @@ var ZlinkStreamReceivedMessages = class {
         if (queued === void 0) continue;
         this.removeAt(index);
         if (queued.kind === "callback") {
-          await queued.callback();
+          this.events.runUserCallback(queued.callback, "Connector callback failed.");
           continue;
         }
         const { message, signal } = queued;
-        const handlers = Array.from(this.handlers.get(message.name));
+        const handlers = this.receiversOf(message);
         for (const handler of handlers) {
-          try {
-            await handler(message, signal);
-          } catch (cause) {
-            await this.events.publishError(
-              {
-                code: "userCallbackFailed" /* UserCallbackFailed */,
-                message: "Typed message handler failed.",
-                cause
-              },
-              signal
-            );
-          }
+          this.events.runUserCallback(
+            () => handler.handle(message, signal),
+            "Typed message handler failed.",
+            signal
+          );
         }
       }
     } finally {
       this.draining = false;
     }
   }
-  removeAt(index) {
-    this.queue[index] = void 0;
-    this.queuedCount -= 1;
-    this.advanceHead();
-    this.compactQueue();
+  /**
+   * True while a registered callback runs from {@link pump}: the execution
+   * context spec stream-connector 32 §7 calls "inside a handler".
+   */
+  get dispatching() {
+    return this.draining;
   }
-  findDeliverableIndex() {
+  get pendingCallbacks() {
+    let count = 0;
     for (let index = this.queueHead; index < this.queue.length; index += 1) {
       const queued = this.queue[index];
-      if (queued !== void 0 && (queued.kind === "callback" || (this.handlers.get(queued.message.name)?.size ?? 0) > 0)) {
+      if (queued?.kind === "callback" && queued.callbacks() > 0) count += 1;
+      if (queued?.kind === "message" && this.receiversOf(queued.message).length > 0) count += 1;
+    }
+    return count;
+  }
+  offerQueued(name, registration) {
+    for (let index = this.queueHead; index < this.queue.length; index += 1) {
+      const queued = this.queue[index];
+      if (queued === void 0 || queued.kind !== "message" || queued.message.name !== name) {
+        continue;
+      }
+      if (!registration.consume(queued.message)) {
+        continue;
+      }
+      this.removeAt(index);
+      return;
+    }
+  }
+  removeAt(index) {
+    this.queue[index] = void 0;
+    this.queuedCount -= 1;
+    this.advanceHead();
+    this.compactQueue();
+  }
+  findDeliverableIndex() {
+    while (this.deliverable.length > 0) {
+      const index = this.deliverable[0];
+      const queued = this.queue[index];
+      if (this.isDeliverable(queued)) {
         return index;
       }
+      if (queued !== void 0) queued.indexed = false;
+      this.removeDeliverable();
     }
     return -1;
   }
-  hasQueuedMessage(name) {
-    for (let index = this.queueHead; index < this.queue.length; index += 1) {
-      const queued = this.queue[index];
-      if (queued?.kind === "message" && queued.message.name === name) return true;
+  indexDeliverable(index) {
+    const queued = this.queue[index];
+    if (queued === void 0 || !this.isDeliverable(queued) || queued.indexed === true) return;
+    queued.indexed = true;
+    let position = this.deliverable.length;
+    this.deliverable.push(index);
+    while (position > 0) {
+      const parent = Math.floor((position - 1) / 2);
+      if (this.deliverable[parent] <= index) break;
+      this.deliverable[position] = this.deliverable[parent];
+      position = parent;
     }
-    return false;
+    this.deliverable[position] = index;
+  }
+  isDeliverable(queued) {
+    return queued?.kind === "callback" || queued?.kind === "message" && this.receiversOf(queued.message).length > 0;
+  }
+  /**
+   * Spec stream-connector 32 §7 and §10: the handlers that receive `message`
+   * are the connector handlers for its name and the handle handlers of the
+   * Actor it carries. A packet no handler receives stays in the queue for the
+   * wait surfaces. This is the one place that decides it.
+   */
+  receiversOf(message) {
+    const set = this.handlers.get(message.name);
+    if (set === void 0) return [];
+    return Array.from(set).filter((registration) => receives(registration, message));
+  }
+  removeDeliverable() {
+    if (this.deliverable.length === 0) return;
+    const last = this.deliverable.pop();
+    if (this.deliverable.length === 0) return;
+    let position = 0;
+    for (; ; ) {
+      const left = position * 2 + 1;
+      if (left >= this.deliverable.length) break;
+      const right = left + 1;
+      const child = right < this.deliverable.length && this.deliverable[right] < this.deliverable[left] ? right : left;
+      if (this.deliverable[child] >= last) break;
+      this.deliverable[position] = this.deliverable[child];
+      position = child;
+    }
+    this.deliverable[position] = last;
   }
   advanceHead() {
     while (this.queueHead < this.queue.length && this.queue[this.queueHead] === void 0) {
@@ -1896,22 +2161,99 @@ var ZlinkStreamReceivedMessages = class {
     if (this.queuedCount === 0) {
       this.queue.length = 0;
       this.queueHead = 0;
+      this.deliverable.length = 0;
       return;
     }
     if (this.queueHead >= 1024 && this.queueHead * 2 >= this.queue.length) {
       this.queue.splice(0, this.queueHead);
       this.queueHead = 0;
+      this.deliverable.length = 0;
+      for (let index = 0; index < this.queue.length; index += 1) {
+        const queued = this.queue[index];
+        if (queued === void 0) continue;
+        queued.indexed = false;
+        this.indexDeliverable(index);
+      }
     }
   }
 };
 
 // packages/stream-connector/src/Runtime/ZlinkStreamFrameSender.ts
+var ZlinkStreamConnectionWriteQueue = class {
+  /**
+   * @param writeFailed Ends the connection whose transport write failed (spec
+   *   stream-connector 32 §9: a transport write failure ends the connection as
+   *   `TransportError`).
+   */
+  constructor(connection, writeFailed) {
+    this.connection = connection;
+    this.writeFailed = writeFailed;
+  }
+  queue = /* @__PURE__ */ new Set();
+  active;
+  enqueue(operation) {
+    this.queue.add(operation);
+    this.advance();
+  }
+  cancel(operation, error) {
+    if (this.queue.has(operation) || this.active === operation) operation.fail(error);
+  }
+  /**
+   * Spec stream-connector 32 §7: when the connection ends, frames that have not
+   * reached the transport are not written and the frame being written is not
+   * waited for. The operations of both fail with `error`.
+   */
+  failAll(error) {
+    const operations = this.active === void 0 ? [...this.queue] : [this.active, ...this.queue];
+    this.queue.clear();
+    this.active = void 0;
+    for (const operation of operations) operation.fail(error);
+  }
+  advance() {
+    if (this.active !== void 0) return;
+    const next = this.queue.values().next().value;
+    if (next === void 0) return;
+    this.queue.delete(next);
+    this.active = next;
+    let write;
+    try {
+      write = Promise.resolve(this.connection.write(next.frame));
+    } catch (error) {
+      write = Promise.reject(error);
+    }
+    void write.then(
+      () => next.complete(),
+      (cause) => this.failWrite(next, cause)
+    ).finally(() => {
+      if (this.active !== next) return;
+      this.active = void 0;
+      this.advance();
+    });
+  }
+  /**
+   * Spec stream-connector 32 §9: a transport write failure is `SendFailed` for
+   * the operation of that write, and it ends the connection. The ending fails
+   * every other operation of the connection with `Disconnected`. A write that
+   * fails after the connection already ended belongs to that ending, which has
+   * already failed its operation with `Disconnected`.
+   */
+  failWrite(operation, cause) {
+    if (this.active !== operation) return;
+    const error = {
+      code: "sendFailed" /* SendFailed */,
+      message: `Frame write failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      cause
+    };
+    operation.fail(new ZlinkStreamException(error));
+    this.writeFailed(error);
+  }
+};
 var ZlinkStreamFrameSender = class {
   constructor(protocol) {
     this.protocol = protocol;
   }
-  pendingWrites = /* @__PURE__ */ new Set();
-  async send(connection, kind, name, payload, metadata, compress, requestSeq, signal, correlationId, actorSlot) {
+  queues = /* @__PURE__ */ new Map();
+  async send(connection, kind, name, payload, metadata, compress, requestSeq, signal, correlationId, actorSlot, expiry, onAccepted) {
     throwIfAborted(signal);
     await this.write(
       connection,
@@ -1925,26 +2267,78 @@ var ZlinkStreamFrameSender = class {
         correlationId,
         actorSlot
       ),
-      signal
+      signal,
+      expiry,
+      onAccepted
     );
   }
-  async sendControl(connection, name, signal) {
-    await this.write(connection, this.protocol.encodeControl(name), signal);
+  /**
+   * Writes a control frame (heartbeat ping or pong). A control frame belongs to
+   * no operation: its write failure ends the connection through the write
+   * queue like any other write (spec stream-connector 32 §9), and a connection
+   * that has already ended does not write it. The promise settles when the
+   * write has ended either way.
+   */
+  sendControl(connection, name) {
+    const queue = this.queues.get(connection);
+    if (queue === void 0) return Promise.resolve();
+    const frame = this.protocol.encodeControl(name);
+    return new Promise((resolve) => {
+      queue.enqueue({ frame, complete: resolve, fail: () => resolve() });
+    });
   }
-  async drain(signal) {
-    while (this.pendingWrites.size > 0) {
-      throwIfAborted(signal);
-      await Promise.allSettled(Array.from(this.pendingWrites));
-    }
+  /**
+   * Gives a connection that has just been established its own write queue.
+   * `writeFailed` ends that connection when one of its transport writes fails.
+   */
+  open(connection, writeFailed) {
+    this.queues.set(connection, new ZlinkStreamConnectionWriteQueue(connection, writeFailed));
   }
-  async write(connection, frame, signal) {
-    const write = connection.write(frame, signal);
-    this.pendingWrites.add(write);
-    try {
-      await write;
-    } finally {
-      this.pendingWrites.delete(write);
+  /**
+   * Ends the write queue of a connection that has ended, by close and by
+   * transport loss alike. Every operation still in it fails with `error`.
+   */
+  failUnwritten(connection, error) {
+    const queue = this.queues.get(connection);
+    if (queue === void 0) return;
+    this.queues.delete(connection);
+    queue.failAll(error);
+  }
+  write(connection, frame, signal, expiry, onAccepted) {
+    throwIfAborted(signal);
+    const queue = this.queues.get(connection);
+    if (queue === void 0) {
+      throw connectorError("disconnected" /* Disconnected */, "Connector is not connected.");
     }
+    let operation;
+    let settled = false;
+    const promise = new Promise((resolve, reject) => {
+      const cleanup = () => signal?.removeEventListener("abort", onAbort);
+      const onAbort = () => queue.cancel(
+        operation,
+        connectorError("disconnected" /* Disconnected */, "Operation canceled.")
+      );
+      operation = {
+        frame,
+        complete: () => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve();
+        },
+        fail: (error) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(error);
+        }
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      onAccepted?.();
+      expiry?.then(void 0, (error) => queue.cancel(operation, error));
+      queue.enqueue(operation);
+    });
+    return promise;
   }
 };
 
@@ -1970,177 +2364,16 @@ 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
-      );
-    }
+// packages/stream-connector/src/Runtime/ZlinkStreamReceiveDispatcher.ts
+function closeReasonFor(error) {
+  return error.code === "frameDecodeFailed" /* FrameDecodeFailed */ || error.code === "frameTooLarge" /* FrameTooLarge */ ? "ProtocolError" : "TransportError";
+}
+var ZlinkStreamConnectionEnd = class extends Error {
+  constructor(error) {
+    super(error.message);
+    this.error = error;
   }
 };
-function invalidControl(message) {
-  return connectorError("frameDecodeFailed" /* FrameDecodeFailed */, message);
-}
-
-// packages/stream-connector/src/Runtime/ZlinkStreamReceiveDispatcher.ts
 var ZlinkStreamReceiveDispatcher = class {
   constructor(protocol, pendingRequests, receivedMessages, frameSender, events, actors, serverClosing) {
     this.protocol = protocol;
@@ -2160,15 +2393,20 @@ var ZlinkStreamReceiveDispatcher = class {
    *   the recheck the rest of a dead connection's batch lands on the new
    *   connection's state, and the §10 arrival counts, which start at 0 when a
    *   connection is established, take the stale frames on top.
-   * @param connectionForSend Resolves the connection a reply belongs on at the
-   *   moment it is written. The captured `connection` is the one the batch was
-   *   read from, which a reconnect may already have replaced.
    */
-  async readAndDispatch(connection, signal, isCurrent, connectionForSend) {
+  async readAndDispatch(connection, signal, isCurrent) {
     if (connection?.read === void 0) {
       return { available: false, inbound: false };
     }
-    const frameBytes = await connection.read(signal);
+    let frameBytes;
+    try {
+      frameBytes = await connection.read(signal);
+    } catch (cause) {
+      if (signal?.aborted === true) throw cause;
+      throw new ZlinkStreamConnectionEnd(
+        toStreamError(cause, "disconnected" /* Disconnected */, "Transport read failed.")
+      );
+    }
     if (isCurrent !== void 0 && !isCurrent()) {
       return { available: false, inbound: false };
     }
@@ -2179,87 +2417,102 @@ var ZlinkStreamReceiveDispatcher = class {
     try {
       frames = this.protocol.decodeFrames(frameBytes);
     } catch (cause) {
-      throw cause;
+      throw new ZlinkStreamConnectionEnd(
+        toStreamError(cause, "frameDecodeFailed" /* FrameDecodeFailed */, "Frame decode failed.")
+      );
     }
     for (const frame of frames) {
       if (isCurrent !== void 0 && !isCurrent()) {
         break;
       }
       try {
-        await this.dispatch(connection, frame.header, frame.payload, signal, connectionForSend);
+        await this.dispatch(connection, frame.header, frame.payload, signal);
       } catch (cause) {
-        if (frame.header.kind === 5 /* Control */ && frame.header.name === ZLINK_STREAM_HEARTBEAT_PING) {
-          throw cause;
-        }
+        if (cause instanceof ZlinkStreamConnectionEnd) throw cause;
         const error = toStreamError(
           cause,
           "frameDecodeFailed" /* FrameDecodeFailed */,
           "Frame dispatch failed."
         );
         if (error.code === "frameDecodeFailed" /* FrameDecodeFailed */) {
-          throw cause;
+          throw new ZlinkStreamConnectionEnd(error);
         }
-        await this.events.publishError(error, signal);
+        this.events.publishError(error, signal);
       }
     }
     return { available: true, inbound: true };
   }
-  async dispatch(connection, header, payload, signal, connectionForSend) {
+  /**
+   * Spec stream-connector 32 §4.7 and §9: a decompressed payload over the
+   * receive limit is `FrameTooLarge` and ends the connection as a protocol
+   * error, like a wire payload over the limit. A payload that does not
+   * decompress fails only its packet.
+   */
+  decodePayload(header, payload) {
+    try {
+      return this.protocol.decodePayload(header, payload);
+    } catch (cause) {
+      const error = toStreamError(
+        cause,
+        "decompressionFailed" /* DecompressionFailed */,
+        "Decompression failed."
+      );
+      if (error.code === "frameTooLarge" /* FrameTooLarge */) {
+        throw new ZlinkStreamConnectionEnd(error);
+      }
+      throw cause;
+    }
+  }
+  async dispatch(connection, header, payload, signal) {
     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(
+        this.pendingRequests.resolve(
           header.requestSeq,
-          {
+          () => ({
             codec: header.codec,
-            payload: this.protocol.decodePayload(header, payload)
-          },
+            payload: this.decodePayload(header, payload)
+          }),
           header.metadata
-        )) {
-          await this.events.publishError(
-            {
-              code: "frameDecodeFailed" /* FrameDecodeFailed */,
-              message: `Response request sequence '${header.requestSeq}' has no pending request.`
-            },
-            signal
-          );
-        }
+        );
       } catch (cause) {
+        if (cause instanceof ZlinkStreamConnectionEnd) throw cause;
         const decodeError = toStreamError(
           cause,
           "decompressionFailed" /* DecompressionFailed */,
           "Decompression failed."
         );
         if (!this.pendingRequests.reject(header.requestSeq, decodeError)) {
-          await this.events.publishError(decodeError, signal);
+          this.events.publishError(decodeError, signal);
         }
       }
       return;
     }
     if (header.kind === 4 /* Error */ && header.requestSeq !== void 0) {
       try {
-        const remoteError = decodeRemoteError(this.protocol, header, payload);
+        const remoteError = decodeRemoteError(this.decodePayload(header, payload));
         if (!this.pendingRequests.reject(header.requestSeq, remoteError)) {
-          await this.events.publishError(remoteError, signal);
+          this.events.publishError(remoteError, signal);
         }
       } catch (cause) {
+        if (cause instanceof ZlinkStreamConnectionEnd) throw cause;
         const decodeError = toStreamError(
           cause,
           "frameDecodeFailed" /* FrameDecodeFailed */,
           "Remote error payload is invalid."
         );
         if (!this.pendingRequests.reject(header.requestSeq, decodeError)) {
-          await this.events.publishError(decodeError, signal);
+          this.events.publishError(decodeError, signal);
         }
       }
       return;
     }
     if (header.kind === 4 /* Error */) {
-      await this.events.publishError(decodeRemoteError(this.protocol, header, payload), signal);
+      this.events.publishError(decodeRemoteError(this.decodePayload(header, payload)), signal);
       return;
     }
     if (header.kind === 5 /* Control */) {
-      await this.dispatchControl(connection, header, payload, signal, connectionForSend);
+      await this.dispatchControl(connection, header, payload, signal);
       return;
     }
     if (header.kind === 1 /* Send */) {
@@ -2267,7 +2520,7 @@ var ZlinkStreamReceiveDispatcher = class {
         {
           name: header.name,
           metadata: header.metadata,
-          payload: { codec: header.codec, payload: this.protocol.decodePayload(header, payload) },
+          payload: { codec: header.codec, payload: this.decodePayload(header, payload) },
           actorId: actor?.actorId,
           [zlinkStreamActorBinding]: actor
         },
@@ -2275,7 +2528,7 @@ var ZlinkStreamReceiveDispatcher = class {
       );
     }
   }
-  async dispatchControl(connection, header, payload, signal, connectionForSend) {
+  async dispatchControl(connection, header, payload, signal) {
     if (this.actors.processControl(header.name, payload, signal)) {
       return;
     }
@@ -2291,18 +2544,7 @@ var ZlinkStreamReceiveDispatcher = class {
       );
     }
     if (header.name === ZLINK_STREAM_HEARTBEAT_PING) {
-      try {
-        await this.frameSender.sendControl(
-          connectionForSend?.() ?? connection,
-          ZLINK_STREAM_HEARTBEAT_PONG,
-          signal
-        );
-      } catch (cause) {
-        throw connectorError(
-          "sendFailed" /* SendFailed */,
-          cause instanceof Error ? cause.message : "Heartbeat pong send failed."
-        );
-      }
+      await this.frameSender.sendControl(connection, ZLINK_STREAM_HEARTBEAT_PONG);
       return;
     }
     if (header.name !== ZLINK_STREAM_HEARTBEAT_PONG) {
@@ -2310,8 +2552,7 @@ var ZlinkStreamReceiveDispatcher = class {
     }
   }
 };
-function decodeRemoteError(protocol, header, payload) {
-  const decodedPayload = protocol.decodePayload(header, payload);
+function decodeRemoteError(decodedPayload) {
   let decoded;
   try {
     decoded = JSON.parse(utf8Decode2(decodedPayload));
@@ -2358,6 +2599,7 @@ var ZlinkStreamConnectorLifecycle = class {
   lastInboundAt = 0;
   closeTask;
   connectTask;
+  connectAbort;
   disconnectTask;
   closeRequested = false;
   disconnectedPublished = false;
@@ -2389,10 +2631,20 @@ var ZlinkStreamConnectorLifecycle = class {
     });
     return await this.connectTask;
   }
+  /**
+   * Spec stream-connector 32 §7: close does not wait for a connect attempt or a
+   * reconnect delay to run its course. The attempts listen to one controller
+   * the lifecycle owns; close aborts it, and the caller's signal is forwarded
+   * to it.
+   */
   async connectOnce(signal) {
-    await this.setState("connecting" /* Connecting */, void 0, signal);
+    const attempts = new AbortController();
+    const forwardAbort = () => attempts.abort();
+    signal?.addEventListener("abort", forwardAbort, { once: true });
+    this.connectAbort = attempts;
+    this.setState("connecting" /* Connecting */, void 0, signal);
     try {
-      const connection = await this.connectWithReconnect(signal);
+      const connection = await this.connectWithReconnect(attempts.signal);
       if (this.closeRequested) {
         try {
           await connection.close(signal);
@@ -2407,41 +2659,61 @@ var ZlinkStreamConnectorLifecycle = class {
       }
       this.currentConnection = connection;
       this.connectionGeneration += 1;
+      const generation = this.connectionGeneration;
+      this.frameSender.open(connection, (error) => {
+        void this.disconnectForTransportFailure(error, connection, generation);
+      });
       this.disconnectedPublished = false;
       this.receivedMessages.resetForNewConnection();
       this.lastInboundAt = Date.now();
-      await this.setState("connected" /* Connected */, void 0, signal);
+      this.setState("connected" /* Connected */, void 0, signal);
       this.startHeartbeat();
       this.startReceiveLoop();
     } catch (cause) {
       if (this.closeRequested) {
         const message = cause instanceof Error ? cause.message : "Connector closed while connecting.";
-        const error2 = toStreamError(cause, "disconnected" /* Disconnected */, message);
-        throw new ZlinkStreamException(error2);
+        throw connectorError("disconnected" /* Disconnected */, message, cause);
+      }
+      if (signal?.aborted === true) {
+        this.setState("disconnected" /* Disconnected */, void 0, signal);
+        throwIfAborted(signal);
       }
       const error = toStreamError(cause, "connectTimeout" /* ConnectTimeout */, "Connect failed.");
-      this.closeReasonValue ??= "TransportError";
-      void this.setState("disconnected" /* Disconnected */, error, signal);
-      this.publishDisconnectedWithoutWaiting(signal);
+      this.closeReasonValue = "TransportError";
+      this.setState("disconnected" /* Disconnected */, error, signal);
+      this.disconnectedPublished = false;
+      this.publishDisconnected(signal);
       throw new ZlinkStreamException(error);
+    } finally {
+      signal?.removeEventListener("abort", forwardAbort);
+      this.connectAbort = void 0;
     }
   }
+  /**
+   * Spec stream-connector 32 §7: a `close` called outside the registered
+   * handlers and callbacks returns once the close work has ended. One called
+   * from inside them returns right after starting it; the result goes to the
+   * outside caller, so a callback never waits for the close of the path that
+   * is running it.
+   */
   async close(signal) {
-    this.closeReasonValue = "ClientClose";
-    this.closeRequested = true;
-    if (this.closeTask !== void 0) {
-      return await this.closeTask;
+    if (this.currentConnection !== void 0 || this.closeReasonValue === void 0) {
+      this.closeReasonValue = "ClientClose";
     }
-    if (this.currentState === "closed" /* Closed */) {
+    this.closeRequested = true;
+    if (this.closeTask === void 0 && this.currentState === "closed" /* Closed */) {
       return;
     }
-    this.closeTask = this.closeOnce(signal).finally(() => {
+    const closeTask = this.closeTask ??= this.closeOnce(signal).finally(() => {
       this.closeTask = void 0;
     });
-    return await this.closeTask;
+    if (this.receivedMessages.dispatching) {
+      void closeTask.catch(() => void 0);
+      return;
+    }
+    return await closeTask;
   }
   async serverClosing(reason) {
-    this.closeReasonValue = reason;
     const error = {
       code: "disconnected" /* Disconnected */,
       message: `Server closed the session: ${reason}.`
@@ -2449,39 +2721,29 @@ var ZlinkStreamConnectorLifecycle = class {
     await this.disconnectForTransportFailure(
       error,
       this.currentConnection,
-      this.connectionGeneration
+      this.connectionGeneration,
+      reason
     );
   }
   async closeOnce(signal) {
+    this.connectAbort?.abort();
     await this.connectTask?.catch(() => void 0);
     await this.disconnectTask?.catch(() => void 0);
-    const connection = this.currentConnection;
-    this.stopHeartbeat();
-    this.stopReceiveLoop();
-    this.currentConnection = void 0;
     const errors = [];
     if (this.lateConnectCleanupError !== void 0) {
       errors.push(this.lateConnectCleanupError);
       this.lateConnectCleanupError = void 0;
     }
     try {
-      await this.frameSender.drain(signal);
-    } catch (error) {
-      errors.push(error);
-    }
-    try {
-      await connection?.close(signal);
+      await this.tearDownConnection(
+        { code: "disconnected" /* Disconnected */, message: "Connector closed." },
+        signal
+      );
     } catch (error) {
       errors.push(error);
     }
-    this.pendingRequests.failAll({
-      code: "disconnected" /* Disconnected */,
-      message: "Connector closed."
-    });
-    this.receivedMessages.connectionEnded();
-    this.actors.closeAll(signal);
-    this.queueState("closed" /* Closed */, void 0, signal);
-    this.queueDisconnected(signal);
+    this.setState("closed" /* Closed */, void 0, signal);
+    this.publishDisconnected(signal);
     if (errors.length === 1) throw errors[0];
     if (errors.length > 1) throw new AggregateError(errors, "Stream connector close failed.");
   }
@@ -2499,7 +2761,7 @@ var ZlinkStreamConnectorLifecycle = class {
     if (this.options.dispatchMode !== "immediate" /* Immediate */) {
       await this.settleReceiveLoop();
     }
-    await this.receivedMessages.pump();
+    this.receivedMessages.pump();
   }
   connectionForSend() {
     if (this.currentConnection === void 0 || this.currentState !== "connected" /* Connected */) {
@@ -2512,8 +2774,7 @@ var ZlinkStreamConnectorLifecycle = class {
     const result = await this.receiveDispatcher.readAndDispatch(
       connection,
       signal,
-      () => this.isCurrentConnection(connection, generation),
-      () => this.connectionForSend()
+      () => this.isCurrentConnection(connection, generation)
     );
     if (result.inbound && this.isCurrentConnection(connection, generation)) {
       this.lastInboundAt = Date.now();
@@ -2522,7 +2783,10 @@ var ZlinkStreamConnectorLifecycle = class {
   }
   async connectWithReconnect(signal) {
     let attempt = 0;
-    let delayMs = this.options.reconnect.initialDelayMs;
+    let delayMs = Math.min(
+      this.options.reconnect.initialDelayMs,
+      this.options.reconnect.maxDelayMs
+    );
     let lastError;
     const maxAttempts = this.options.reconnect.enabled ? this.options.reconnect.maxAttempts : 1;
     const unlimited = maxAttempts === null;
@@ -2532,10 +2796,10 @@ var ZlinkStreamConnectorLifecycle = class {
         return await this.options.transportFactory.connect(this.options, signal);
       } catch (cause) {
         lastError = toStreamError(cause, "connectTimeout" /* ConnectTimeout */, "Connect failed.");
-        if (!this.options.reconnect.enabled || !unlimited && attempt >= maxAttempts) {
+        if (this.closeRequested || !this.options.reconnect.enabled || !unlimited && attempt >= maxAttempts) {
           break;
         }
-        await this.setState("reconnecting" /* Reconnecting */, lastError, signal);
+        this.setState("reconnecting" /* Reconnecting */, lastError, signal);
         await delay(randomizedDelay(delayMs), signal);
         delayMs = Math.min(
           this.options.reconnect.maxDelayMs,
@@ -2603,12 +2867,8 @@ var ZlinkStreamConnectorLifecycle = class {
       }
     } catch (cause) {
       if (signal.aborted) return;
-      const error = toStreamError(
-        cause,
-        "frameDecodeFailed" /* FrameDecodeFailed */,
-        "Receive loop failed."
-      );
-      await this.disconnectForTransportFailure(error, connection, generation);
+      if (!(cause instanceof ZlinkStreamConnectionEnd)) throw cause;
+      await this.disconnectForTransportFailure(cause.error, connection, generation);
     } finally {
       this.receiveLoopSleeping = false;
       this.releaseReceiveLoopSettled();
@@ -2664,36 +2924,35 @@ var ZlinkStreamConnectorLifecycle = class {
       return;
     }
     if (Date.now() - this.lastInboundAt > this.options.heartbeat.timeoutMs) {
-      this.closeReasonValue = "HeartbeatTimeout";
       const error = { code: "disconnected" /* Disconnected */, message: "Heartbeat timed out." };
       await this.disconnectForTransportFailure(
         error,
         this.currentConnection,
-        this.connectionGeneration
+        this.connectionGeneration,
+        "HeartbeatTimeout"
       );
       return;
     }
-    const connection = this.currentConnection;
-    const generation = this.connectionGeneration;
-    try {
-      await this.frameSender.sendControl(this.connectionForSend(), ZLINK_STREAM_HEARTBEAT_PING);
-    } catch (cause) {
-      const error = toStreamError(cause, "sendFailed" /* SendFailed */, "Heartbeat send failed.");
-      await this.disconnectForTransportFailure(error, connection, generation);
-    }
+    await this.frameSender.sendControl(this.connectionForSend(), ZLINK_STREAM_HEARTBEAT_PING);
   }
-  async disconnectForTransportFailure(error, origin, generation) {
-    this.closeReasonValue ??= "TransportError";
+  /**
+   * @param reason Given only where the reason is not read from `error`: a
+   *   server `session-closing` and the heartbeat timeout. Every other ending
+   *   takes it from {@link closeReasonFor}.
+   */
+  async disconnectForTransportFailure(error, origin, generation, reason = closeReasonFor(error)) {
     if (this.closeRequested || this.currentState === "closed" /* Closed */) {
       return;
     }
     if (origin !== void 0 && !this.isCurrentConnection(origin, generation)) {
       return;
     }
+    this.closeReasonValue = reason;
     if (this.disconnectTask !== void 0) {
       return await this.disconnectTask;
     }
-    this.disconnectTask = this.tearDownConnection(error).finally(() => {
+    this.disconnectTask = this.tearDownConnection(error).catch(() => {
+    }).finally(() => {
       this.disconnectTask = void 0;
     });
     await this.disconnectTask;
@@ -2702,19 +2961,30 @@ var ZlinkStreamConnectorLifecycle = class {
   isCurrentConnection(connection, generation) {
     return !this.closeRequested && this.currentConnection === connection && this.connectionGeneration === generation;
   }
-  /** Transport teardown only — no application callback runs from here. */
-  async tearDownConnection(error) {
+  /**
+   * Ends the current connection, for close and for transport loss alike. No
+   * application callback runs from here. Spec stream-connector 32 §7 and §9:
+   * every operation the ending connection fails (the frames it has not
+   * written, the one it is writing and the pending requests) fails with
+   * `Disconnected`, whatever ended it; the cause stays in the close reason.
+   * The transport is closed without waiting for the frames.
+   */
+  async tearDownConnection(error, signal) {
     this.stopHeartbeat();
     this.stopReceiveLoop();
     const connection = this.currentConnection;
     this.currentConnection = void 0;
-    this.pendingRequests.failAll(error);
-    this.receivedMessages.connectionEnded();
-    this.actors.closeAll();
-    try {
-      await connection?.close();
-    } catch {
+    const disconnected = { code: "disconnected" /* Disconnected */, message: error.message };
+    if (connection !== void 0) {
+      this.frameSender.failUnwritten(
+        connection,
+        connectorError(disconnected.code, disconnected.message)
+      );
     }
+    this.pendingRequests.failAll(disconnected);
+    this.receivedMessages.connectionEnded();
+    this.actors.closeAll(signal);
+    await connection?.close(signal);
   }
   /**
    * Runs once the teardown promise has settled, so a handler reached from here
@@ -2726,8 +2996,8 @@ var ZlinkStreamConnectorLifecycle = class {
    */
   async announceDisconnect(error) {
     if (this.closeRequested) return;
-    this.queueState("disconnected" /* Disconnected */, error);
-    this.queueDisconnected();
+    this.setState("disconnected" /* Disconnected */, error);
+    this.publishDisconnected();
     if (this.shouldReconnect()) {
       queueMicrotask(() => {
         void this.connect().catch(() => void 0);
@@ -2737,78 +3007,36 @@ var ZlinkStreamConnectorLifecycle = class {
   shouldReconnect() {
     return this.options.reconnect.enabled && !this.closeRequested;
   }
-  // Synchronous test-and-set, taken before any await, so the single disconnect
-  // notification the spec promises is claimed by exactly one caller even when
-  // the publishing itself is deferred.
-  claimDisconnectedPublish() {
-    if (this.disconnectedPublished) return false;
-    this.disconnectedPublished = true;
-    return true;
-  }
-  async publishDisconnectedOnce(signal) {
-    if (!this.claimDisconnectedPublish()) return;
-    await this.events.publishDisconnected(signal);
-  }
   /**
-   * Spec stream-connector 32 §7: the connector runs the registered handler, it
-   * does not wait for it to finish. `close` returns once its own work is done —
-   * the drain, the transport close, the pending requests — having run the
-   * disconnect handler but without looking at whether that handler has ended.
-   *
-   * Starting the publish without awaiting it still runs every handler right
-   * here: an `async` function body runs synchronously up to its first `await`,
-   * and `publishDisconnected` reaches each handler before that point. So the
-   * handler has run by the time `close` returns, which is what the spec asks
-   * for, while a handler that calls `close` no longer waits for the very
-   * `closeTask` it is running inside. Java and C++ hand the handler to a queue
-   * and return the same way.
-   *
-   * `claimDisconnectedPublish` is taken by the same call and before any await,
-   * so deferring the completion never turns the one notification into two.
-   *
-   * Nothing awaits the promise, so a rejection would reach the process as an
-   * unhandled rejection and kill it. Handler failures are already contained
-   * where they were before this call stopped waiting — the `Promise.allSettled`
-   * in `publishDisconnected` — and this `catch` covers what is left rather than
-   * reporting the same failure a second time on the error surface.
+   * Spec stream-connector 32 §6 and §7: one disconnect notification per
+   * lifecycle event, handed to the dispatch queue. The connector does not wait
+   * for the handler; `Manual` runs it when the application pumps dispatch.
+   * The flag is tested and set synchronously, so concurrent callers for the
+   * same event claim it once.
    */
-  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);
+  publishDisconnected(signal) {
+    if (this.disconnectedPublished) return;
+    this.disconnectedPublished = true;
+    this.events.publishDisconnected(signal);
   }
-  transitionState(current, error) {
+  setState(current, error, signal) {
     const previous = this.currentState;
     this.currentState = current;
-    if (previous === current && error === void 0) {
-      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);
+    if (previous === current && error === void 0) return;
+    this.events.publishStateChanged({ previous, current, error }, signal);
+    if (error !== void 0) this.events.publishError(error, signal);
   }
 };
 
 // packages/stream-connector/src/Runtime/ZlinkStreamConnectorEvents.ts
 var ZlinkStreamConnectorEvents = class {
+  /**
+   * @param enqueueCallback Queues a callback that calls the number of handlers
+   *   `callbacks` reports for the handlers registered at that moment.
+   */
+  constructor(enqueueCallback) {
+    this.enqueueCallback = enqueueCallback;
+  }
   errorHandlers = /* @__PURE__ */ new Set();
   disconnectedHandlers = /* @__PURE__ */ new Set();
   stateHandlers = /* @__PURE__ */ new Set();
@@ -2824,23 +3052,78 @@ var ZlinkStreamConnectorEvents = class {
     this.stateHandlers.add(handler);
     return subscription(() => this.stateHandlers.delete(handler));
   }
-  async publishError(error, signal) {
-    await this.publish(
-      Array.from(this.errorHandlers).map((handler) => () => handler(error, signal))
+  publishError(error, signal) {
+    this.publish(this.errorHandlers, (handler) => handler(error, signal), signal);
+  }
+  publishDisconnected(signal) {
+    this.publish(this.disconnectedHandlers, (handler) => handler(signal), signal);
+  }
+  publishStateChanged(change, signal) {
+    this.publish(this.stateHandlers, (handler) => handler(change, signal), signal);
+  }
+  /**
+   * Spec stream-connector 32 §7: the connector runs a registered callback and
+   * does not wait for it to finish. A thrown or rejected failure reaches the
+   * error handlers as `UserCallbackFailed`.
+   */
+  runUserCallback(run, failureMessage, signal) {
+    this.invoke(
+      run,
+      (cause) => this.publishError(
+        { code: "userCallbackFailed" /* UserCallbackFailed */, message: failureMessage, cause },
+        signal
+      )
     );
   }
-  async publishDisconnected(signal) {
-    await this.publish(
-      Array.from(this.disconnectedHandlers).map((handler) => () => handler(signal))
+  publish(handlers, invoke, signal) {
+    this.enqueueCallback(
+      () => {
+        for (const handler of Array.from(handlers)) {
+          const report = (cause) => this.reportFailure(
+            cause,
+            signal,
+            handlers === this.errorHandlers ? handler : void 0
+          );
+          this.invoke(() => invoke(handler), report);
+        }
+      },
+      () => handlers.size
     );
   }
-  async publishStateChanged(change, signal) {
-    await this.publish(
-      Array.from(this.stateHandlers).map((handler) => () => handler(change, signal))
+  reportFailure(cause, signal, failedHandler) {
+    const error = {
+      code: "userCallbackFailed" /* UserCallbackFailed */,
+      message: "Connector event handler failed.",
+      cause
+    };
+    if (failedHandler === void 0) {
+      this.publishError(error, signal);
+      return;
+    }
+    this.reportToRemaining(error, signal, /* @__PURE__ */ new Set([failedHandler]));
+  }
+  reportToRemaining(error, signal, attempted) {
+    const remaining = Array.from(this.errorHandlers).filter(
+      (candidate) => !attempted.has(candidate)
+    );
+    if (remaining.length === 0) return;
+    const nextAttempted = /* @__PURE__ */ new Set([...attempted, ...remaining]);
+    this.enqueueCallback(
+      () => {
+        for (const handler of remaining) {
+          const report = (cause) => this.reportToRemaining({ ...error, cause }, signal, nextAttempted);
+          this.invoke(() => handler(error, signal), report);
+        }
+      },
+      () => remaining.length
     );
   }
-  async publish(handlers) {
-    await Promise.allSettled(handlers.map(async (handler) => handler()));
+  invoke(run, report) {
+    try {
+      Promise.resolve(run()).catch(report);
+    } catch (cause) {
+      report(cause);
+    }
   }
 };
 
@@ -2878,11 +3161,7 @@ var BrowserWebSocketConnection = class {
     if (this.closed || this.socket.readyState !== 1) {
       throw connectorError("disconnected" /* Disconnected */, "Remote stream is not connected.");
     }
-    try {
-      this.socket.send(frame);
-    } catch (cause) {
-      throw connectorError("sendFailed" /* SendFailed */, "Send failed.", cause);
-    }
+    this.socket.send(frame);
   }
   async read(signal) {
     throwIfAborted(signal);
@@ -2900,18 +3179,19 @@ var BrowserWebSocketConnection = class {
       await this.waitForMessage(signal);
     }
   }
+  /**
+   * Spec stream-connector 32 §7: closing does not wait for the peer to read or
+   * answer. `WebSocket.close` sends the close frame after the data already
+   * handed to `send`, so a frame whose write completed is not torn.
+   */
   async close(signal) {
     throwIfAborted(signal);
+    this.removeListeners();
     if (!this.closed) {
       this.closed = true;
       this.socket.close();
-      this.wakeReader();
-    }
-    try {
-      await waitForClose(this.socket, signal);
-    } finally {
-      this.removeListeners();
     }
+    this.wakeReader();
   }
   onMessage = (event) => {
     try {
@@ -2989,21 +3269,6 @@ var BrowserWebSocketConnection = class {
     return message;
   }
 };
-function waitForClose(socket, signal) {
-  if (socket.readyState === 3) return Promise.resolve();
-  return new Promise((resolve, reject) => {
-    const onClose = () => finish();
-    const onAbort = () => finish(connectorError("disconnected" /* Disconnected */, "Close canceled."));
-    const finish = (error) => {
-      socket.removeEventListener("close", onClose);
-      signal?.removeEventListener("abort", onAbort);
-      if (error === void 0) resolve();
-      else reject(error);
-    };
-    socket.addEventListener("close", onClose, { once: true });
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
 async function waitForOpen(socket, connectTimeoutMs, signal) {
   throwIfAborted(signal);
   await new Promise((resolve, reject) => {
@@ -3053,7 +3318,9 @@ var DefaultZlinkStreamConnector = class {
   static heartbeatPongName = ZLINK_STREAM_HEARTBEAT_PONG;
   receivedMessages;
   lifecycle;
-  events = new ZlinkStreamConnectorEvents();
+  events = new ZlinkStreamConnectorEvents(
+    (callback, callbacks) => this.receivedMessages.enqueueCallback(callback, callbacks)
+  );
   correlationCounter = 0n;
   pendingRequests = new ZlinkStreamPendingRequests();
   frameSender;
@@ -3100,7 +3367,7 @@ var DefaultZlinkStreamConnector = class {
     return this.lifecycle.state;
   }
   get pendingDispatchCount() {
-    return this.pendingRequests.count;
+    return this.receivedMessages.pendingCallbacks;
   }
   get actors() {
     return this.boundActors.snapshot;
@@ -3157,7 +3424,12 @@ var DefaultZlinkStreamConnector = class {
   }
   request(payload, messageType) {
     const encoded = this.encodePayload(payload, messageType);
-    return new ZlinkStreamRequestBuilder(this, this.resolveNameOrDefault(encoded), encoded);
+    return new ZlinkStreamRequestBuilder(
+      this,
+      this.resolveNameOrDefault(encoded),
+      encoded,
+      (callback) => this.receivedMessages.enqueueCallback(callback)
+    );
   }
   on(nameOrType, handler, messageType) {
     const encodedHandler = (message, signal) => handler(
@@ -3190,29 +3462,25 @@ var DefaultZlinkStreamConnector = class {
       this,
       this.resolveNameOrDefault(encoded),
       encoded,
+      (callback) => this.receivedMessages.enqueueCallback(callback),
       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);
+    const encodedHandler = (message, signal) => handler(
+      {
+        name: message.name,
+        metadata: message.metadata,
+        payload: this.decodePayload(
+          message.payload,
+          messageType ?? (typeof nameOrType === "function" ? nameOrType : void 0)
+        ),
+        actorId: message.actorId
+      },
+      signal
+    );
+    return this.receivedMessages.on(this.observedName(nameOrType), encodedHandler, actor);
   }
   waitFor(nameOrType) {
     return new ZlinkStreamWaitBuilder(this, this.observedName(nameOrType));
@@ -3334,7 +3602,7 @@ var DefaultZlinkStreamConnector = class {
     }
     return payload;
   }
-  async sendEncoded(kind, name, payload, metadata, compress, requestSeq, signal, correlationId, actorSlot) {
+  async sendEncoded(kind, name, payload, metadata, compress, requestSeq, signal, correlationId, actorSlot, expiry, onAccepted) {
     await this.frameSender.send(
       this.lifecycle.connectionForSend(),
       kind,
@@ -3345,7 +3613,9 @@ var DefaultZlinkStreamConnector = class {
       requestSeq,
       signal,
       correlationId,
-      actorSlot
+      actorSlot,
+      expiry,
+      onAccepted
     );
   }
   /**
@@ -3368,37 +3638,48 @@ var DefaultZlinkStreamConnector = class {
       }
     };
     let pending;
+    let stopCancellation;
     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
-            );
-          });
+          this.events.publishError(
+            {
+              code: "userCallbackFailed" /* UserCallbackFailed */,
+              message: "Request sending hook failed.",
+              cause
+            },
+            signal
+          );
         }
       }
       pending = this.pendingRequests.create(name, timeoutMs);
-      await this.sendEncoded(
+      const accepted = pending;
+      const write = this.sendEncoded(
         2 /* Request */,
         name,
         payload,
         requestMetadata,
         compress,
-        pending.requestSeq,
+        accepted.requestSeq,
         signal,
         this.nextCorrelationId(),
-        actorSlot
+        actorSlot,
+        accepted.promise,
+        accepted.startTimeout
       );
-      const reply = await pending.promise;
+      const canceled = new Promise((_, reject) => {
+        const onAbort = () => reject(connectorError("disconnected" /* Disconnected */, "Operation canceled."));
+        signal?.addEventListener("abort", onAbort, { once: true });
+        stopCancellation = () => signal?.removeEventListener("abort", onAbort);
+      });
+      const reply = await Promise.race([
+        write.then(() => accepted.promise),
+        accepted.promise,
+        canceled
+      ]);
       this.publishReplyReceived(
         {
           requestPacketName: name,
@@ -3412,6 +3693,7 @@ var DefaultZlinkStreamConnector = class {
       return reply.payload;
     } catch (error) {
       if (pending !== void 0) this.pendingRequests.cancel(pending.requestSeq);
+      if (signal?.aborted === true) throw error;
       this.publishReplyReceived(
         {
           requestPacketName: name,
@@ -3423,26 +3705,24 @@ var DefaultZlinkStreamConnector = class {
         signal
       );
       throw error;
+    } finally {
+      stopCancellation?.();
     }
   }
   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."
-            ),
+    this.receivedMessages.enqueueCallback(
+      () => {
+        for (const handler of Array.from(this.replyReceivedHandlers)) {
+          this.events.runUserCallback(
+            () => handler(context, signal),
+            "Reply received hook failed.",
             signal
           );
         }
-      }
-    });
+      },
+      () => this.replyReceivedHandlers.size
+    );
   }
   resolveNameOrDefault(payload) {
     if (payload.messageType === void 0) {