@zlink-systems/stream-connector 0.26.0 → 0.27.0

package/dist/browser/index.mjs

@@ -1,4 +1,8 @@
 // packages/stream-wire/src/lz4-pickle.ts
+var LZ4_MIN_MATCH_LENGTH = 4;
+var LZ4_MATCH_OFFSET_BYTES = 2;
+var LZ4_EXTENDED_LENGTH_NIBBLE = 15;
+var LZ4_EXTENDED_LENGTH_BYTE = 255;
 var defaultMaxDecompressedPayloadSize = 64 * 1024;
 function lz4PickleUncompressed(payload) {
   if (payload.length === 0) {
@@ -74,15 +78,15 @@ function decodeLz4Block(source, resultLength) {
     if (sourceOffset >= source.length) {
       break;
     }
-    if (source.length - sourceOffset < 2) {
+    if (source.length - sourceOffset < LZ4_MATCH_OFFSET_BYTES) {
       throw new Error("LZ4 match offset is incomplete.");
     }
     const matchOffset = source[sourceOffset] | source[sourceOffset + 1] << 8;
-    sourceOffset += 2;
+    sourceOffset += LZ4_MATCH_OFFSET_BYTES;
     if (matchOffset === 0 || matchOffset > targetOffset) {
       throw new Error("LZ4 match offset is invalid.");
     }
-    const matchLength = readLz4Length(source, token & 15, () => sourceOffset++) + 4;
+    const matchLength = readLz4Length(source, token & 15, () => sourceOffset++) + LZ4_MIN_MATCH_LENGTH;
     if (target.length - targetOffset < matchLength) {
       throw new Error("LZ4 match run exceeds output size.");
     }
@@ -98,7 +102,7 @@ function decodeLz4Block(source, resultLength) {
 }
 function readLz4Length(source, nibble, nextOffset) {
   let length = nibble;
-  if (length !== 15) {
+  if (length !== LZ4_EXTENDED_LENGTH_NIBBLE) {
     return length;
   }
   for (; ; ) {
@@ -108,7 +112,7 @@ function readLz4Length(source, nibble, nextOffset) {
     }
     const value = source[offset];
     length += value;
-    if (value !== 255) {
+    if (value !== LZ4_EXTENDED_LENGTH_BYTE) {
       return length;
     }
   }
@@ -122,54 +126,200 @@ var ZlinkStreamCodec = /* @__PURE__ */ ((ZlinkStreamCodec2) => {
   ZlinkStreamCodec2[ZlinkStreamCodec2["Protobuf"] = 3] = "Protobuf";
   return ZlinkStreamCodec2;
 })(ZlinkStreamCodec || {});
+var ZlinkStreamMessageKind = /* @__PURE__ */ ((ZlinkStreamMessageKind2) => {
+  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Send"] = 1] = "Send";
+  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Request"] = 2] = "Request";
+  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Response"] = 3] = "Response";
+  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Error"] = 4] = "Error";
+  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Control"] = 5] = "Control";
+  return ZlinkStreamMessageKind2;
+})(ZlinkStreamMessageKind || {});
+var ZlinkStreamHeaderFlags = /* @__PURE__ */ ((ZlinkStreamHeaderFlags2) => {
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["None"] = 0] = "None";
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasRequestSeq"] = 1] = "HasRequestSeq";
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasMetadata"] = 2] = "HasMetadata";
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["PayloadCompressed"] = 4] = "PayloadCompressed";
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasCorrelationId"] = 8] = "HasCorrelationId";
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasFlowId"] = 16] = "HasFlowId";
+  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasActorSlot"] = 32] = "HasActorSlot";
+  return ZlinkStreamHeaderFlags2;
+})(ZlinkStreamHeaderFlags || {});
+var ZlinkStreamCloseReasonCode = /* @__PURE__ */ ((ZlinkStreamCloseReasonCode2) => {
+  ZlinkStreamCloseReasonCode2[ZlinkStreamCloseReasonCode2["ClientClose"] = 1] = "ClientClose";
+  ZlinkStreamCloseReasonCode2[ZlinkStreamCloseReasonCode2["IdleTimeout"] = 2] = "IdleTimeout";
+  ZlinkStreamCloseReasonCode2[ZlinkStreamCloseReasonCode2["HeartbeatTimeout"] = 3] = "HeartbeatTimeout";
+  ZlinkStreamCloseReasonCode2[ZlinkStreamCloseReasonCode2["ServerDrain"] = 4] = "ServerDrain";
+  ZlinkStreamCloseReasonCode2[ZlinkStreamCloseReasonCode2["ProtocolError"] = 5] = "ProtocolError";
+  ZlinkStreamCloseReasonCode2[ZlinkStreamCloseReasonCode2["TransportError"] = 6] = "TransportError";
+  return ZlinkStreamCloseReasonCode2;
+})(ZlinkStreamCloseReasonCode || {});
+var unicodeWhiteSpaceOnly = /^\p{White_Space}*$/u;
+var validMessageKinds = new Set(
+  Object.values(ZlinkStreamMessageKind).filter((value) => typeof value === "number")
+);
+var validCodecs = new Set(
+  Object.values(ZlinkStreamCodec).filter((value) => typeof value === "number")
+);
+function isStreamWireMessageKind(value) {
+  return validMessageKinds.has(value);
+}
+function isStreamWireCodec(value) {
+  return validCodecs.has(value);
+}
+var UTF8_TWO_BYTE_MIN = 128;
+var UTF8_THREE_BYTE_MIN = 2048;
+var UTF16_HIGH_SURROGATE_MIN = 55296;
+var UTF16_HIGH_SURROGATE_MAX = 56319;
+var UTF16_LOW_SURROGATE_MIN = 56320;
+var UTF16_LOW_SURROGATE_MAX = 57343;
+var UINT8_MAX = 255;
+var UINT16_MAX = 65535;
+var UINT16_BYTES = 2;
+var UINT32_BYTES = 4;
+var UINT64_BYTES = 8;
+var UINT64_MAX = 0xffffffffffffffffn;
+var UINT32_MAX = 4294967295;
+var ZLINK_STREAM_FRAME_PREFIX_BYTES = UINT16_BYTES + UINT32_BYTES;
+var ZLINK_STREAM_MAX_PACKET_NAME_BYTES = UINT8_MAX;
+var ZLINK_STREAM_MAX_METADATA_BYTES = 1024;
+var FLOW_ID_BYTES = 36;
+var FLOW_FIELDS_BYTES = FLOW_ID_BYTES + 1;
+var HEADER_MIN_BYTES = 5;
+var HEADER_FLAG_MASK = 1 /* HasRequestSeq */ | 2 /* HasMetadata */ | 4 /* PayloadCompressed */ | 8 /* HasCorrelationId */ | 16 /* HasFlowId */ | 32 /* HasActorSlot */;
+var CONTROL_PAYLOAD_VERSION = 1;
+var ACTOR_SLOT_OFFSET = 1;
+var ACTOR_ID_LENGTH_OFFSET = ACTOR_SLOT_OFFSET + UINT16_BYTES;
+var ACTOR_BOUND_PREFIX_BYTES = ACTOR_ID_LENGTH_OFFSET + 1;
+var ACTOR_UNBOUND_BYTES = ACTOR_SLOT_OFFSET + UINT16_BYTES;
+var CLOSING_DIAGNOSTIC_LENGTH_OFFSET = 2;
+var CLOSING_PREFIX_BYTES = CLOSING_DIAGNOSTIC_LENGTH_OFFSET + UINT16_BYTES;
+var MAX_CLOSING_DIAGNOSTIC_BYTES = 512;
+function decodeStreamWireActorBoundPayload(payload) {
+  if (payload.length < ACTOR_BOUND_PREFIX_BYTES + 1 || payload[0] !== CONTROL_PAYLOAD_VERSION) {
+    throw new Error("Actor bound payload is invalid.");
+  }
+  const slot = readUInt16BE(payload, ACTOR_SLOT_OFFSET);
+  const idLength = payload[ACTOR_ID_LENGTH_OFFSET];
+  if (slot === 0 || idLength === 0 || payload.length !== ACTOR_BOUND_PREFIX_BYTES + idLength) {
+    throw new Error("Actor bound payload is invalid.");
+  }
+  try {
+    return { slot, actorId: decodeControlText(payload.subarray(ACTOR_BOUND_PREFIX_BYTES)) };
+  } catch (cause) {
+    throw new Error("Actor id is not valid UTF-8.", { cause });
+  }
+}
+function decodeStreamWireActorUnboundPayload(payload) {
+  if (payload.length !== ACTOR_UNBOUND_BYTES || payload[0] !== CONTROL_PAYLOAD_VERSION) {
+    throw new Error("Actor unbound payload is invalid.");
+  }
+  return readUInt16BE(payload, ACTOR_SLOT_OFFSET);
+}
+function decodeStreamWireSessionClosing(payload) {
+  if (payload.length < CLOSING_PREFIX_BYTES || payload[0] !== CONTROL_PAYLOAD_VERSION) {
+    throw new Error("Unsupported session-closing version.");
+  }
+  const closeReason = ZlinkStreamCloseReasonCode[payload[1]];
+  if (closeReason === void 0) throw new Error("Unknown session-closing reason.");
+  const length = readUInt16BE(payload, CLOSING_DIAGNOSTIC_LENGTH_OFFSET);
+  if (length > MAX_CLOSING_DIAGNOSTIC_BYTES || payload.length !== CLOSING_PREFIX_BYTES + length) {
+    throw new Error("Invalid session-closing diagnostic length.");
+  }
+  const diagnostic = length === 0 ? void 0 : decodeControlText(payload.subarray(CLOSING_PREFIX_BYTES));
+  return { closeReason, diagnostic };
+}
+function decodeControlText(value) {
+  return new TextDecoder("utf-8", { fatal: true }).decode(value);
+}
+function splitStreamWireFrames(chunk) {
+  if (chunk.length === 0) throw new Error("Stream frame prefix is incomplete.");
+  const frames = [];
+  let offset = 0;
+  while (offset < chunk.length) {
+    const remaining = chunk.length - offset;
+    if (remaining < ZLINK_STREAM_FRAME_PREFIX_BYTES) {
+      throw new Error("Stream frame prefix is incomplete.");
+    }
+    const headerLength = readUInt16BE(chunk, offset);
+    const payloadLength = readUInt32BE(chunk, offset + UINT16_BYTES);
+    const frameLength = ZLINK_STREAM_FRAME_PREFIX_BYTES + headerLength + payloadLength;
+    if (frameLength > remaining) throw new Error("Frame length does not match prefix.");
+    frames.push(chunk.subarray(offset, offset + frameLength));
+    offset += frameLength;
+  }
+  return frames;
+}
+var ZLINK_STREAM_RESERVED_PACKET_NAME_PREFIX = "$zlink.";
+var ZlinkStreamControlPacket = Object.freeze({
+  HeartbeatPing: `${ZLINK_STREAM_RESERVED_PACKET_NAME_PREFIX}heartbeat.ping`,
+  HeartbeatPong: `${ZLINK_STREAM_RESERVED_PACKET_NAME_PREFIX}heartbeat.pong`,
+  ActorBound: `${ZLINK_STREAM_RESERVED_PACKET_NAME_PREFIX}actor.bound`,
+  ActorUnbound: `${ZLINK_STREAM_RESERVED_PACKET_NAME_PREFIX}actor.unbound`,
+  SessionClosing: "session-closing"
+});
+var ZlinkStreamContentType = Object.freeze({
+  Raw: "application/octet-stream",
+  Json: "application/json",
+  MessagePack: "application/x-msgpack",
+  Protobuf: "application/x-protobuf"
+});
+var contentTypesByCodec = /* @__PURE__ */ new Map([
+  [0 /* Raw */, ZlinkStreamContentType.Raw],
+  [1 /* Json */, ZlinkStreamContentType.Json],
+  [2 /* MessagePack */, ZlinkStreamContentType.MessagePack],
+  [3 /* Protobuf */, ZlinkStreamContentType.Protobuf]
+]);
+var codecsByContentType = new Map(
+  Array.from(contentTypesByCodec, ([codec, contentType]) => [contentType, codec])
+);
 var defaultHeaderFlags = {
-  hasRequestSeq: 1,
-  hasMetadata: 2,
-  hasCorrelationId: 8,
-  hasFlowId: 16,
-  hasActorSlot: 32
+  hasRequestSeq: 1 /* HasRequestSeq */,
+  hasMetadata: 2 /* HasMetadata */,
+  hasCorrelationId: 8 /* HasCorrelationId */,
+  hasFlowId: 16 /* HasFlowId */,
+  hasActorSlot: 32 /* HasActorSlot */
 };
 var ZLINK_STREAM_FORMAT_MARKER = 242;
-var ZLINK_STREAM_RESPONSE_KIND = 3;
-var ZLINK_STREAM_ERROR_KIND = 4;
 function encodeStreamWireFrame(header, payload) {
-  if (header.length > 65535) {
+  if (header.length > UINT16_MAX) {
     throw new Error("Stream header is too large.");
   }
-  if (payload.length > 4294967295) {
+  if (payload.length > UINT32_MAX) {
     throw new Error("Stream payload is too large.");
   }
-  const frame = new Uint8Array(6 + header.length + payload.length);
+  const frame = new Uint8Array(ZLINK_STREAM_FRAME_PREFIX_BYTES + header.length + payload.length);
   writeUInt16BE(frame, 0, header.length);
-  writeUInt32BE(frame, 2, payload.length);
-  frame.set(header, 6);
-  frame.set(payload, 6 + header.length);
+  writeUInt32BE(frame, UINT16_BYTES, payload.length);
+  frame.set(header, ZLINK_STREAM_FRAME_PREFIX_BYTES);
+  frame.set(payload, ZLINK_STREAM_FRAME_PREFIX_BYTES + header.length);
   return frame;
 }
 function decodeStreamWireFrame(frame) {
-  if (frame.length < 6) {
+  if (frame.length < ZLINK_STREAM_FRAME_PREFIX_BYTES) {
     throw new Error("Stream frame prefix is incomplete.");
   }
   const headerLength = readUInt16BE(frame, 0);
-  const payloadLength = readUInt32BE(frame, 2);
-  if (frame.length !== 6 + headerLength + payloadLength) {
+  const payloadLength = readUInt32BE(frame, UINT16_BYTES);
+  if (frame.length !== ZLINK_STREAM_FRAME_PREFIX_BYTES + headerLength + payloadLength) {
     throw new Error("Stream frame length does not match prefix.");
   }
   return {
-    header: frame.slice(6, 6 + headerLength),
-    payload: frame.slice(6 + headerLength)
+    header: frame.slice(
+      ZLINK_STREAM_FRAME_PREFIX_BYTES,
+      ZLINK_STREAM_FRAME_PREFIX_BYTES + headerLength
+    ),
+    payload: frame.slice(ZLINK_STREAM_FRAME_PREFIX_BYTES + headerLength)
   };
 }
 function encodeStreamWireHeader(header, flagOverrides) {
   const flags = flagOverrides ?? defaultHeaderFlags;
   const reply = isReplyKind(header.kind);
   const packetName = reply ? "" : header.name;
-  if (!reply) validateStreamWirePacketName(packetName);
-  const nameBytes = utf8Encode(packetName);
+  const nameBytes = reply ? new Uint8Array() : validateStreamWirePacketName(packetName);
   const hasRequestSeq = header.requestSeq !== void 0;
   const hasMetadata = header.metadata.size > 0;
   const correlationBytes = header.correlationId !== void 0 && header.correlationId.length > 0 ? utf8Encode(header.correlationId) : void 0;
-  if (correlationBytes !== void 0 && correlationBytes.length > 255) {
+  if (correlationBytes !== void 0 && correlationBytes.length > UINT8_MAX) {
     throw new Error("Stream correlation id is too large.");
   }
   const hasCorrelation = correlationBytes !== void 0;
@@ -182,7 +332,7 @@ 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)) {
+  if (header.actorSlot !== void 0 && (!Number.isInteger(header.actorSlot) || header.actorSlot < 1 || header.actorSlot > UINT16_MAX)) {
     throw new Error("Stream actor slot is invalid.");
   }
   let headerFlags = header.flags;
@@ -192,7 +342,7 @@ function encodeStreamWireHeader(header, flagOverrides) {
   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) + (hasActorSlot ? 2 : 0);
+  const size = 4 + (hasRequestSeq ? UINT64_BYTES : 0) + 1 + nameBytes.length + (hasMetadata ? UINT16_BYTES + metadataBytes.length : 0) + (hasCorrelation ? 1 + correlationBytes.length : 0) + (hasFlow ? FLOW_FIELDS_BYTES : 0) + (hasActorSlot ? UINT16_BYTES : 0);
   const buffer = new Uint8Array(size);
   let offset = 0;
   buffer[offset++] = ZLINK_STREAM_FORMAT_MARKER;
@@ -204,14 +354,14 @@ function encodeStreamWireHeader(header, flagOverrides) {
       throw new Error("Request sequence must not be zero.");
     }
     writeBigUInt64BE(buffer, offset, header.requestSeq);
-    offset += 8;
+    offset += UINT64_BYTES;
   }
   buffer[offset++] = nameBytes.length;
   buffer.set(nameBytes, offset);
   offset += nameBytes.length;
   if (hasMetadata) {
     writeUInt16BE(buffer, offset, metadataBytes.length);
-    offset += 2;
+    offset += UINT16_BYTES;
     buffer.set(metadataBytes, offset);
     offset += metadataBytes.length;
   }
@@ -222,7 +372,7 @@ function encodeStreamWireHeader(header, flagOverrides) {
   }
   if (hasFlow) {
     buffer.set(asciiEncode(header.flowId), offset);
-    offset += 36;
+    offset += FLOW_ID_BYTES;
     buffer[offset++] = header.flowOrigin;
   }
   if (hasActorSlot) {
@@ -233,7 +383,7 @@ function encodeStreamWireHeader(header, flagOverrides) {
 function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
   const flags = flagOverrides ?? defaultHeaderFlags;
   let offset = 0;
-  if (header.length < 5) {
+  if (header.length < HEADER_MIN_BYTES) {
     throw new Error("Stream header is incomplete.");
   }
   if (header[offset++] !== ZLINK_STREAM_FORMAT_MARKER) {
@@ -247,29 +397,28 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
   const hasCorrelation = (headerFlags & flags.hasCorrelationId) !== 0;
   const hasFlow = (headerFlags & flags.hasFlowId) !== 0;
   const hasActorSlot = (headerFlags & flags.hasActorSlot) !== 0;
-  if ((headerFlags & ~63) !== 0) {
+  if ((headerFlags & ~HEADER_FLAG_MASK) !== 0) {
     throw new Error("Unknown mandatory stream header flag.");
   }
   let requestSeq;
   if (hasRequestSeq) {
-    if (header.length - offset < 8) {
+    if (header.length - offset < UINT64_BYTES) {
       throw new Error("Stream request sequence is incomplete.");
     }
     requestSeq = readBigUInt64BE(header, offset);
     if (requestSeq === 0n) {
       throw new Error("Request sequence must not be zero.");
     }
-    offset += 8;
+    offset += UINT64_BYTES;
   }
   if (header.length - offset < 1) {
     throw new Error("Stream packet name length is missing.");
   }
   const nameLength = header[offset++];
-  if (!isReplyKind(kind) && nameLength === 0 || header.length - offset < nameLength) {
+  if ((isReplyKind(kind) ? nameLength !== 0 : nameLength === 0) || header.length - offset < nameLength) {
     throw new Error("Stream packet name is invalid.");
   }
-  const decodedName = utf8Decode(header.subarray(offset, offset + nameLength));
-  const name = isReplyKind(kind) ? "" : decodedName;
+  const name = utf8Decode(header.subarray(offset, offset + nameLength));
   offset += nameLength;
   const decodedMetadata = hasMetadata ? decodeStreamWireHeaderMetadata(header, offset) : { metadata: /* @__PURE__ */ new Map(), offset };
   offset = decodedMetadata.offset;
@@ -288,14 +437,14 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
   let flowId;
   let flowOrigin;
   if (hasFlow) {
-    if (header.length - offset < 37) {
+    if (header.length - offset < FLOW_FIELDS_BYTES) {
       throw new Error("Stream flow fields are incomplete.");
     }
     if (includeFlow) {
-      flowId = asciiDecode(header.subarray(offset, offset + 36));
+      flowId = asciiDecode(header.subarray(offset, offset + FLOW_ID_BYTES));
       validateFlowId(flowId);
     }
-    offset += 36;
+    offset += FLOW_ID_BYTES;
     const decodedFlowOrigin = header[offset++];
     if (includeFlow && ![1, 2, 3, 4].includes(decodedFlowOrigin)) {
       throw new Error("Stream flow origin is invalid.");
@@ -304,14 +453,14 @@ function decodeStreamWireHeader(header, flagOverrides, includeFlow = true) {
   }
   let actorSlot;
   if (hasActorSlot) {
-    if (header.length - offset < 2) {
+    if (header.length - offset < UINT16_BYTES) {
       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;
+    offset += UINT16_BYTES;
   }
   if (offset !== header.length) {
     throw new Error("Stream header has trailing bytes.");
@@ -341,44 +490,41 @@ function asciiDecode(value) {
   if (value.some((byte) => byte > 127)) throw new Error("Stream flow id must be ASCII.");
   return String.fromCharCode(...value);
 }
-function encodeStreamWireMetadata(metadata) {
-  if (metadata.size > 255) {
+function streamWireMetadataSize(metadata) {
+  if (metadata.size > UINT8_MAX) {
     throw new Error("Metadata entry count must not exceed 255.");
   }
   let size = 1;
-  const encoded = [...metadata].map(([key, value]) => {
-    const keyBytes = utf8Encode(key);
-    const valueBytes = utf8Encode(value);
-    if (keyBytes.length === 0 || keyBytes.length > 255) {
+  for (const [key, value] of metadata) {
+    const keySize = utf8Size(key);
+    const valueSize = utf8Size(value);
+    if (keySize === 0 || keySize > UINT8_MAX) {
       throw new Error("Metadata key length is invalid.");
     }
-    if (valueBytes.length > 65535) {
+    if (valueSize > UINT16_MAX) {
       throw new Error("Metadata value is too large.");
     }
-    size += 1 + keyBytes.length + 2 + valueBytes.length;
-    return { keyBytes, valueBytes };
-  });
-  const buffer = new Uint8Array(size);
+    size += 1 + keySize + UINT16_BYTES + valueSize;
+  }
+  return size;
+}
+function encodeStreamWireMetadata(metadata) {
+  const buffer = new Uint8Array(streamWireMetadataSize(metadata));
   let offset = 0;
   buffer[offset++] = metadata.size;
-  for (const { keyBytes, valueBytes } of encoded) {
+  for (const [key, value] of metadata) {
+    const keyBytes = utf8Encode(key);
+    const valueBytes = utf8Encode(value);
     buffer[offset++] = keyBytes.length;
     buffer.set(keyBytes, offset);
     offset += keyBytes.length;
     writeUInt16BE(buffer, offset, valueBytes.length);
-    offset += 2;
+    offset += UINT16_BYTES;
     buffer.set(valueBytes, offset);
     offset += valueBytes.length;
   }
   return buffer;
 }
-function decodeStreamWireMetadata(metadata) {
-  const decoded = decodeStreamWireMetadataAt(metadata, 0, metadata.length);
-  if (decoded.offset !== metadata.length) {
-    throw new Error("Stream metadata payload has trailing bytes.");
-  }
-  return decoded.metadata;
-}
 function lz4PickleUncompressed2(payload) {
   return lz4PickleUncompressed(payload);
 }
@@ -395,11 +541,11 @@ function utf8Decode(value) {
   return new TextDecoder().decode(value);
 }
 function decodeStreamWireHeaderMetadata(header, offset) {
-  if (header.length - offset < 2) {
+  if (header.length - offset < UINT16_BYTES) {
     throw new Error("Stream metadata section is incomplete.");
   }
   const metadataLength = readUInt16BE(header, offset);
-  offset += 2;
+  offset += UINT16_BYTES;
   if (header.length - offset < metadataLength) {
     throw new Error("Stream metadata payload is incomplete.");
   }
@@ -425,7 +571,7 @@ function decodeStreamWireMetadataAt(source, offset, end) {
       throw new Error("Stream metadata value length is missing.");
     }
     const valueLength = readUInt16BE(source, offset);
-    offset += 2;
+    offset += UINT16_BYTES;
     if (end - offset < valueLength) {
       throw new Error("Stream metadata value is incomplete.");
     }
@@ -442,16 +588,17 @@ function decodeStreamWireMetadataAt(source, offset, end) {
 }
 function validateStreamWirePacketName(name) {
   const nameBytes = utf8Encode(name);
-  if (name.trim().length === 0 || nameBytes.length > 255) {
+  if (unicodeWhiteSpaceOnly.test(name) || nameBytes.length > ZLINK_STREAM_MAX_PACKET_NAME_BYTES) {
     throw new Error("Stream packet name is invalid.");
   }
+  return nameBytes;
 }
 function isReplyKind(kind) {
-  return kind === ZLINK_STREAM_RESPONSE_KIND || kind === ZLINK_STREAM_ERROR_KIND;
+  return kind === 3 /* Response */ || kind === 4 /* Error */;
 }
 function writeUInt16BE(buffer, offset, value) {
-  buffer[offset] = value >>> 8 & 255;
-  buffer[offset + 1] = value & 255;
+  buffer[offset] = value >>> 8 & UINT8_MAX;
+  buffer[offset + 1] = value & UINT8_MAX;
 }
 function readUInt16BE(buffer, offset) {
   return buffer[offset] << 8 | buffer[offset + 1];
@@ -460,10 +607,10 @@ function readUInt32BE(buffer, offset) {
   return buffer[offset] * 16777216 + (buffer[offset + 1] << 16 | buffer[offset + 2] << 8 | buffer[offset + 3]);
 }
 function writeUInt32BE(buffer, offset, value) {
-  buffer[offset] = value >>> 24 & 255;
-  buffer[offset + 1] = value >>> 16 & 255;
-  buffer[offset + 2] = value >>> 8 & 255;
-  buffer[offset + 3] = value & 255;
+  buffer[offset] = value >>> 24 & UINT8_MAX;
+  buffer[offset + 1] = value >>> 16 & UINT8_MAX;
+  buffer[offset + 2] = value >>> 8 & UINT8_MAX;
+  buffer[offset + 3] = value & UINT8_MAX;
 }
 function writeBigUInt64BE(buffer, offset, value) {
   for (let index = 7; index >= 0; index -= 1) {
@@ -478,6 +625,19 @@ function readBigUInt64BE(buffer, offset) {
   }
   return value;
 }
+function utf8Size(value) {
+  let size = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < UTF8_TWO_BYTE_MIN) size += 1;
+    else if (code < UTF8_THREE_BYTE_MIN) size += 2;
+    else if (code >= UTF16_HIGH_SURROGATE_MIN && code <= UTF16_HIGH_SURROGATE_MAX && index + 1 < value.length && value.charCodeAt(index + 1) >= UTF16_LOW_SURROGATE_MIN && value.charCodeAt(index + 1) <= UTF16_LOW_SURROGATE_MAX) {
+      size += 4;
+      index += 1;
+    } else size += 3;
+  }
+  return size;
+}
 
 // packages/stream-connector/src/Contracts/ZlinkStreamEnums.ts
 var ZlinkStreamTransport = /* @__PURE__ */ ((ZlinkStreamTransport2) => {
@@ -495,24 +655,6 @@ var ZlinkStreamDispatchMode = /* @__PURE__ */ ((ZlinkStreamDispatchMode2) => {
   ZlinkStreamDispatchMode2["Immediate"] = "immediate";
   return ZlinkStreamDispatchMode2;
 })(ZlinkStreamDispatchMode || {});
-var ZlinkStreamMessageKind = /* @__PURE__ */ ((ZlinkStreamMessageKind2) => {
-  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Send"] = 1] = "Send";
-  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Request"] = 2] = "Request";
-  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Response"] = 3] = "Response";
-  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Error"] = 4] = "Error";
-  ZlinkStreamMessageKind2[ZlinkStreamMessageKind2["Control"] = 5] = "Control";
-  return ZlinkStreamMessageKind2;
-})(ZlinkStreamMessageKind || {});
-var ZlinkStreamHeaderFlags = /* @__PURE__ */ ((ZlinkStreamHeaderFlags2) => {
-  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["None"] = 0] = "None";
-  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasRequestSeq"] = 1] = "HasRequestSeq";
-  ZlinkStreamHeaderFlags2[ZlinkStreamHeaderFlags2["HasMetadata"] = 2] = "HasMetadata";
-  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) => {
   ZlinkStreamErrorCode2["Disconnected"] = "disconnected";
   ZlinkStreamErrorCode2["ConfigurationError"] = "configurationError";
@@ -524,6 +666,7 @@ var ZlinkStreamErrorCode = /* @__PURE__ */ ((ZlinkStreamErrorCode2) => {
   ZlinkStreamErrorCode2["SendFailed"] = "sendFailed";
   ZlinkStreamErrorCode2["CompressionFailed"] = "compressionFailed";
   ZlinkStreamErrorCode2["DecompressionFailed"] = "decompressionFailed";
+  ZlinkStreamErrorCode2["TlsValidationFailed"] = "tlsValidationFailed";
   ZlinkStreamErrorCode2["UserCallbackFailed"] = "userCallbackFailed";
   ZlinkStreamErrorCode2["RemoteError"] = "remoteError";
   return ZlinkStreamErrorCode2;
@@ -538,6 +681,15 @@ var ZlinkStreamConnectionState = /* @__PURE__ */ ((ZlinkStreamConnectionState3)
   return ZlinkStreamConnectionState3;
 })(ZlinkStreamConnectionState || {});
 
+// packages/stream-connector/src/Contracts/ZlinkStreamModels.ts
+var ZlinkStreamException = class extends Error {
+  constructor(error) {
+    super(error.message);
+    this.error = error;
+    this.name = "ZlinkStreamException";
+  }
+};
+
 // packages/stream-connector/src/Contracts/ZlinkStreamMetadata.ts
 var ZlinkStreamMetadataMap = class _ZlinkStreamMetadataMap {
   constructor(values) {
@@ -570,25 +722,13 @@ var ZlinkStreamMetadataMap = class _ZlinkStreamMetadataMap {
 };
 function validateMetadataKey(key) {
   if (key.length === 0) {
-    throw new Error("Metadata key must not be empty.");
-  }
-  for (let index = 0; index < key.length; index++) {
-    const code = key.charCodeAt(index);
-    if (code < 32 || code > 126 || key[index] === "=") {
-      throw new Error('Metadata key must contain printable ASCII characters except "=".');
-    }
+    throw new ZlinkStreamException({
+      code: "validationFailed" /* ValidationFailed */,
+      message: "Metadata key must not be empty."
+    });
   }
 }
 
-// packages/stream-connector/src/Contracts/ZlinkStreamModels.ts
-var ZlinkStreamException = class extends Error {
-  constructor(error) {
-    super(error.message);
-    this.error = error;
-    this.name = "ZlinkStreamException";
-  }
-};
-
 // packages/stream-connector/src/Contracts/ZlinkStreamJsonCodec.ts
 var zlinkStreamJsonCodecName = "json";
 var codecOptions = {};
@@ -640,6 +780,10 @@ function isPrototypeKey(key) {
 }
 
 // packages/stream-connector/src/Runtime/ZlinkStreamSupport.ts
+var BACKING_ARRAY_COMPACTION_MIN_HEAD = 1024;
+function shouldCompactBackingArray(head, length) {
+  return head >= BACKING_ARRAY_COMPACTION_MIN_HEAD && head * 2 >= length;
+}
 function connectorError(code, message, cause) {
   return new ZlinkStreamException({ code, message, cause });
 }
@@ -653,15 +797,21 @@ function unwrapStreamError(error) {
   if (error instanceof ZlinkStreamException) {
     return error.error;
   }
-  return {
-    code: "remoteError" /* RemoteError */,
-    message: error instanceof Error ? error.message : String(error),
-    cause: error
-  };
+  throw error;
 }
 function subscription(dispose) {
   return { dispose };
 }
+function* currentRegistrations(registrations, snapshot = Array.from(registrations)) {
+  for (const registration of snapshot) {
+    if (registrations.has(registration)) yield registration;
+  }
+}
+function registerHandler(handlers, handler) {
+  const registration = { handler };
+  handlers.add(registration);
+  return subscription(() => handlers.delete(registration));
+}
 function throwIfAborted(signal) {
   if (signal?.aborted === true) {
     throw connectorError("disconnected" /* Disconnected */, "Operation canceled.");
@@ -681,9 +831,6 @@ function delay(delayMs, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
-function utf8Encode2(value) {
-  return new TextEncoder().encode(value);
-}
 function utf8Decode2(value) {
   return new TextDecoder().decode(value);
 }
@@ -702,59 +849,48 @@ var zlinkStreamAssert = {
     }
   },
   async expectFailure(action, errorKind) {
-    let failure;
     try {
       await action();
-    } catch (error) {
-      failure = error;
-    }
-    if (failure === void 0) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Expected action to fail.");
-    }
-    const streamError = unwrapStreamError(failure);
-    if (errorKind !== void 0 && streamError.code !== errorKind) {
-      throw connectorError(
-        "validationFailed" /* ValidationFailed */,
-        `Expected failure kind '${errorKind}', got '${streamError.code}'.`,
-        failure
-      );
+    } catch (failure) {
+      if (!(failure instanceof ZlinkStreamException)) throw failure;
+      const streamError = failure.error;
+      if (errorKind !== void 0 && streamError.code !== errorKind) {
+        throw connectorError(
+          "validationFailed" /* ValidationFailed */,
+          `Expected failure kind '${errorKind}', got '${streamError.code}'.`,
+          failure
+        );
+      }
+      return streamError;
     }
-    return streamError;
+    throw connectorError("validationFailed" /* ValidationFailed */, "Expected action to fail.");
   },
   async expectTimeout(action) {
-    let failure;
     try {
       await action();
-    } catch (error) {
-      failure = error;
-    }
-    if (failure === void 0) {
-      throw connectorError("validationFailed" /* ValidationFailed */, "Expected action to time out.");
-    }
-    const code = unwrapStreamError(failure).code;
-    if (code !== "requestTimeout" /* RequestTimeout */ && code !== "connectTimeout" /* ConnectTimeout */) {
-      throw failure;
+    } catch (failure) {
+      if (!(failure instanceof ZlinkStreamException) || failure.error.code !== "requestTimeout" /* RequestTimeout */ && failure.error.code !== "connectTimeout" /* ConnectTimeout */) {
+        throw failure;
+      }
+      return;
     }
+    throw connectorError("validationFailed" /* ValidationFailed */, "Expected action to time out.");
   }
 };
 
 // packages/stream-connector/src/Runtime/Protocol/ZlinkStreamPacketNameValidator.ts
 function validateName(name, allowReserved = false) {
-  if (name.length === 0) {
-    throw connectorError("validationFailed" /* ValidationFailed */, "Message name must not be empty.");
+  try {
+    validateStreamWirePacketName(name);
+  } catch (cause) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "Message name is invalid.", cause);
   }
-  if (!allowReserved && name.startsWith("$zlink.")) {
+  if (!allowReserved && name.startsWith(ZLINK_STREAM_RESERVED_PACKET_NAME_PREFIX)) {
     throw connectorError(
       "validationFailed" /* ValidationFailed */,
       "Message name uses a reserved zlink prefix."
     );
   }
-  if (utf8Encode2(name).length > 255) {
-    throw connectorError(
-      "validationFailed" /* ValidationFailed */,
-      "Message name must not exceed 255 UTF-8 bytes."
-    );
-  }
 }
 
 // packages/stream-connector/src/Runtime/Calls/ZlinkStreamCallBuilders.ts
@@ -1127,9 +1263,164 @@ function resolveCompressionCodec(compression, compressionCodec) {
   return compressionCodec ?? zlinkStreamLz4CompressionCodec;
 }
 
+// packages/stream-connector/src/Contracts/ZlinkStreamConnectorOptions.ts
+var ZLINK_STREAM_DEFAULT_PAYLOAD_BYTES = 64 * 1024;
+
+// packages/stream-connector/src/Runtime/Transport/ZlinkStreamEndpoint.ts
+function inferTransport(endpoint) {
+  const url = parseEndpoint(endpoint);
+  switch (url.protocol) {
+    case "ws:":
+      return "webSocket" /* WebSocket */;
+    case "wss:":
+      return "webSocketSecure" /* WebSocketSecure */;
+    default:
+      throw connectorError(
+        "configurationError" /* ConfigurationError */,
+        "The TypeScript Stream Connector supports only ws:// and wss:// endpoints."
+      );
+  }
+}
+function parseEndpoint(endpoint) {
+  try {
+    return new URL(endpoint);
+  } catch (cause) {
+    throw connectorError("configurationError" /* ConfigurationError */, "Endpoint is invalid.", cause);
+  }
+}
+
+// packages/stream-connector/src/Runtime/ZlinkStreamConnectorOptions.ts
+function normalizeOptions(options, defaultTransportFactory) {
+  const endpoint = options.endpoint;
+  if (endpoint.trim().length === 0) {
+    throw connectorError("configurationError" /* ConfigurationError */, "Endpoint must not be empty.");
+  }
+  const inferredTransport = inferTransport(endpoint);
+  if (options.transport !== void 0 && options.transport !== inferredTransport) {
+    throw connectorError(
+      "configurationError" /* ConfigurationError */,
+      "Configured transport conflicts with endpoint scheme."
+    );
+  }
+  const normalized = {
+    endpoint,
+    transport: inferredTransport,
+    connectTimeoutMs: options.connectTimeoutMs ?? 5e3,
+    requestTimeoutMs: options.requestTimeoutMs ?? 3e4,
+    waitTimeoutMs: options.waitTimeoutMs ?? 5e3,
+    heartbeat: {
+      enabled: options.heartbeat?.enabled ?? true,
+      intervalMs: options.heartbeat?.intervalMs ?? 1e3,
+      timeoutMs: options.heartbeat?.timeoutMs ?? 5e3
+    },
+    reconnect: {
+      enabled: options.reconnect?.enabled ?? true,
+      initialDelayMs: options.reconnect?.initialDelayMs ?? 250,
+      maxDelayMs: options.reconnect?.maxDelayMs ?? 5e3,
+      backoffFactor: options.reconnect?.backoffFactor ?? 2,
+      maxAttempts: options.reconnect?.maxAttempts === void 0 ? 3 : options.reconnect.maxAttempts
+    },
+    maxSendPayloadSize: options.maxSendPayloadSize ?? ZLINK_STREAM_DEFAULT_PAYLOAD_BYTES,
+    maxReceivePayloadSize: options.maxReceivePayloadSize ?? ZLINK_STREAM_DEFAULT_PAYLOAD_BYTES,
+    dispatchMode: options.dispatchMode ?? "manual" /* Manual */,
+    compression: options.compression ?? "lz4" /* Lz4 */,
+    compressionCodec: options.compressionCodec,
+    nameResolver: options.nameResolver ?? defaultPacketNameResolver,
+    transportFactory: options.transportFactory ?? defaultTransportFactory,
+    codec: options.codec
+  };
+  validatePositive(normalized.connectTimeoutMs, "ConnectTimeout");
+  validatePositive(normalized.requestTimeoutMs, "RequestTimeout");
+  validatePositive(normalized.waitTimeoutMs, "WaitTimeout");
+  validatePositive(normalized.maxSendPayloadSize, "MaxSendPayloadSize");
+  validatePositive(normalized.maxReceivePayloadSize, "MaxReceivePayloadSize");
+  validateHeartbeat(normalized.heartbeat);
+  validateReconnect(normalized.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(normalized.dispatchMode)) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "DispatchMode is invalid.");
+  }
+  if (!Object.values(ZlinkStreamCompression).includes(normalized.compression)) {
+    throw connectorError("validationFailed" /* ValidationFailed */, "Compression is invalid.");
+  }
+  validateCompressionCodec(normalized);
+  return normalized;
+}
+var defaultPacketNameResolver = {
+  resolve(payloadType) {
+    const declared = payloadType.packetName;
+    if (typeof declared === "string" && declared.length > 0) {
+      return declared;
+    }
+    return payloadType.name;
+  }
+};
+function validateCompressionCodec(options) {
+  const compression = options.compression;
+  if (compression === "none" /* None */) {
+    if (options.compressionCodec !== void 0) {
+      throw connectorError(
+        "configurationError" /* ConfigurationError */,
+        "compressionCodec cannot be set when compression is none."
+      );
+    }
+  }
+}
+function validatePositive(value, name) {
+  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 intervalMs = options.intervalMs;
+  const timeoutMs = options.timeoutMs;
+  validatePositive(intervalMs, "Heartbeat interval");
+  validatePositive(timeoutMs, "Heartbeat timeout");
+}
+function validateReconnect(options) {
+  validatePositive(options.initialDelayMs, "Reconnect InitialDelay");
+  validatePositive(options.maxDelayMs, "Reconnect MaxDelay");
+  validatePositive(options.backoffFactor, "Reconnect BackoffFactor");
+  const maxAttempts = options.maxAttempts;
+  if (maxAttempts !== null && !(Number.isFinite(maxAttempts) && maxAttempts > 0)) {
+    throw connectorError(
+      "validationFailed" /* ValidationFailed */,
+      "Reconnect MaxAttempts must be null or positive."
+    );
+  }
+}
+
 // packages/stream-connector/src/Runtime/Protocol/ZlinkStreamFrameCodec.ts
 var ZlinkStreamFrameCodec = class {
-  static encode(header, payload, maxPayloadSize = 64 * 1024) {
+  static encode(header, payload, maxPayloadSize = ZLINK_STREAM_DEFAULT_PAYLOAD_BYTES) {
     validatePayload(payload.length, maxPayloadSize);
     try {
       return encodeStreamWireFrame(header, payload);
@@ -1150,35 +1441,14 @@ var ZlinkStreamFrameCodec = class {
   }
 };
 function splitZlinkStreamFrames(chunk) {
-  if (chunk.length === 0) {
+  try {
+    return splitStreamWireFrames(chunk);
+  } catch (cause) {
     throw connectorError(
       "frameDecodeFailed" /* FrameDecodeFailed */,
-      "Stream frame prefix is incomplete."
+      cause instanceof Error ? cause.message : "Frame length does not match prefix."
     );
   }
-  const frames = [];
-  let offset = 0;
-  while (offset < chunk.length) {
-    const remaining = chunk.length - offset;
-    if (remaining < 6) {
-      throw connectorError(
-        "frameDecodeFailed" /* FrameDecodeFailed */,
-        "Stream frame prefix is incomplete."
-      );
-    }
-    const headerLength = chunk[offset] << 8 | chunk[offset + 1];
-    const payloadLength = chunk[offset + 2] * 16777216 + (chunk[offset + 3] << 16) + (chunk[offset + 4] << 8) + chunk[offset + 5];
-    const frameLength = 6 + headerLength + payloadLength;
-    if (frameLength > remaining) {
-      throw connectorError(
-        "frameDecodeFailed" /* FrameDecodeFailed */,
-        "Frame length does not match prefix."
-      );
-    }
-    frames.push(chunk.subarray(offset, offset + frameLength));
-    offset += frameLength;
-  }
-  return frames;
 }
 function validatePayload(payloadLength, maxPayloadSize) {
   if (payloadLength > maxPayloadSize) {
@@ -1190,59 +1460,34 @@ function validatePayload(payloadLength, maxPayloadSize) {
 }
 
 // packages/stream-connector/src/Runtime/Protocol/ZlinkStreamMetadataCodec.ts
-var ZLINK_STREAM_MAX_METADATA_BYTES = 1024;
 var ZlinkStreamMetadataCodec = class {
   static size(metadata) {
+    let size;
     try {
-      const size = metadata.count === 0 ? 0 : encodeStreamWireMetadata(metadata.values).length;
-      if (size > ZLINK_STREAM_MAX_METADATA_BYTES) {
-        throw connectorError(
-          "validationFailed" /* ValidationFailed */,
-          `Metadata must not exceed ${ZLINK_STREAM_MAX_METADATA_BYTES} bytes.`
-        );
-      }
-      return size;
+      size = metadata.count === 0 ? 0 : streamWireMetadataSize(metadata.values);
     } catch (cause) {
       throw connectorError(
         "validationFailed" /* ValidationFailed */,
-        streamWireErrorMessage(cause),
+        cause instanceof Error ? cause.message : "Metadata is invalid.",
         cause
       );
     }
-  }
-  static write(metadata, destination) {
-    try {
-      destination.set(encodeStreamWireMetadata(metadata.values));
-    } catch (cause) {
+    if (size > ZLINK_STREAM_MAX_METADATA_BYTES) {
       throw connectorError(
         "validationFailed" /* ValidationFailed */,
-        streamWireErrorMessage(cause),
-        cause
-      );
-    }
-  }
-  static decode(metadata) {
-    try {
-      const values = decodeStreamWireMetadata(metadata);
-      return values.size === 0 ? ZlinkStreamMetadataMap.empty : ZlinkStreamMetadataMap.from(values);
-    } catch (cause) {
-      throw connectorError(
-        "frameDecodeFailed" /* FrameDecodeFailed */,
-        streamWireErrorMessage(cause),
-        cause
+        `Metadata must not exceed ${ZLINK_STREAM_MAX_METADATA_BYTES} bytes.`
       );
     }
+    return size;
   }
 };
-function streamWireErrorMessage(cause) {
-  return cause instanceof Error ? cause.message : "Metadata is invalid.";
-}
 
 // packages/stream-connector/src/Runtime/Protocol/ZlinkStreamHeaderCodec.ts
 var ZlinkStreamHeaderCodec = class {
   static encode(header) {
     const reply = isReplyKind2(header.kind);
     if (!reply) validateName(header.name, header.kind === 5 /* Control */);
+    validateEncodeFlags(header.flags);
     validateHeaderSemantics(header);
     ZlinkStreamMetadataCodec.size(header.metadata);
     try {
@@ -1259,7 +1504,7 @@ var ZlinkStreamHeaderCodec = class {
     } catch (cause) {
       throw connectorError(
         "validationFailed" /* ValidationFailed */,
-        streamWireErrorMessage2(cause),
+        streamWireErrorMessage(cause),
         cause
       );
     }
@@ -1279,25 +1524,24 @@ var ZlinkStreamHeaderCodec = class {
         correlationId: wire.correlationId,
         actorSlot: wire.actorSlot
       };
+      if (!isReplyKind2(decoded.kind)) {
+        validateName(decoded.name, decoded.kind === 5 /* Control */);
+      }
+      validateHeaderSemantics(decoded);
     } catch (cause) {
       throw connectorError(
         "frameDecodeFailed" /* FrameDecodeFailed */,
-        streamWireErrorMessage2(cause),
+        streamWireErrorMessage(cause),
         cause
       );
     }
-    validateEnum(decoded.kind, decoded.codec, decoded.flags);
-    if (!isReplyKind2(decoded.kind)) {
-      validateName(decoded.name, decoded.kind === 5 /* Control */);
-    }
-    validateHeaderSemantics(decoded);
     return decoded;
   }
 };
 function isReplyKind2(kind) {
   return kind === 3 /* Response */ || kind === 4 /* Error */;
 }
-function streamWireErrorMessage2(cause) {
+function streamWireErrorMessage(cause) {
   return cause instanceof Error ? cause.message : "Stream header is invalid.";
 }
 function buildHeader(kind, name, codec, metadata, compress, requestSeq, correlationId, actorSlot) {
@@ -1327,7 +1571,7 @@ function buildHeader(kind, name, codec, metadata, compress, requestSeq, correlat
   };
 }
 function validateHeaderSemantics(header) {
-  validateEnum(header.kind, header.codec, header.flags);
+  validateEnum(header.kind, header.codec);
   const hasRequestSeq = header.requestSeq !== void 0 || (header.flags & 1 /* HasRequestSeq */) !== 0;
   const hasMetadata = header.metadata.count > 0 || (header.flags & 2 /* HasMetadata */) !== 0;
   if (header.kind === 1 /* Send */ && hasRequestSeq) {
@@ -1360,13 +1604,15 @@ function validateHeaderSemantics(header) {
     }
   }
 }
-function validateEnum(kind, codec, flags) {
-  if (![1, 2, 3, 4, 5].includes(kind)) {
+function validateEnum(kind, codec) {
+  if (!isStreamWireMessageKind(kind)) {
     throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Unknown stream message kind.");
   }
-  if (![0, 1, 2, 3].includes(codec)) {
+  if (!isStreamWireCodec(codec)) {
     throw connectorError("frameDecodeFailed" /* FrameDecodeFailed */, "Unknown stream codec.");
   }
+}
+function validateEncodeFlags(flags) {
   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.");
@@ -1374,8 +1620,8 @@ function validateEnum(kind, codec, flags) {
 }
 
 // packages/stream-connector/src/Runtime/Protocol/ZlinkStreamFrameProtocol.ts
-var ZLINK_STREAM_HEARTBEAT_PING = "$zlink.heartbeat.ping";
-var ZLINK_STREAM_HEARTBEAT_PONG = "$zlink.heartbeat.pong";
+var ZLINK_STREAM_HEARTBEAT_PING = ZlinkStreamControlPacket.HeartbeatPing;
+var ZLINK_STREAM_HEARTBEAT_PONG = ZlinkStreamControlPacket.HeartbeatPong;
 var ZlinkStreamFrameProtocol = class {
   constructor(options) {
     this.options = options;
@@ -1443,168 +1689,12 @@ var ZlinkStreamFrameProtocol = class {
   }
 };
 
-// packages/stream-connector/src/Runtime/Transport/ZlinkStreamEndpoint.ts
-function inferTransport(endpoint) {
-  const url = parseEndpoint(endpoint);
-  switch (url.protocol) {
-    case "ws:":
-      return "webSocket" /* WebSocket */;
-    case "wss:":
-      return "webSocketSecure" /* WebSocketSecure */;
-    default:
-      throw connectorError(
-        "configurationError" /* ConfigurationError */,
-        "The TypeScript Stream Connector supports only ws:// and wss:// endpoints."
-      );
-  }
-}
-function parseEndpoint(endpoint) {
-  try {
-    return new URL(endpoint);
-  } catch (cause) {
-    throw connectorError("configurationError" /* ConfigurationError */, "Endpoint is invalid.", cause);
-  }
-}
-
-// packages/stream-connector/src/Runtime/ZlinkStreamConnectorOptions.ts
-function normalizeOptions(options, defaultTransportFactory) {
-  const endpoint = options.endpoint;
-  if (endpoint.trim().length === 0) {
-    throw connectorError("configurationError" /* ConfigurationError */, "Endpoint must not be empty.");
-  }
-  const inferredTransport = inferTransport(endpoint);
-  if (options.transport !== void 0 && options.transport !== inferredTransport) {
-    throw connectorError(
-      "configurationError" /* ConfigurationError */,
-      "Configured transport conflicts with endpoint scheme."
-    );
-  }
-  validatePositive(options.connectTimeoutMs ?? 5e3, "ConnectTimeout");
-  validatePositive(options.requestTimeoutMs ?? 3e4, "RequestTimeout");
-  validatePositive(options.waitTimeoutMs ?? 5e3, "WaitTimeout");
-  validatePositive(options.maxSendPayloadSize ?? 64 * 1024, "MaxSendPayloadSize");
-  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,
-    connectTimeoutMs: options.connectTimeoutMs ?? 5e3,
-    requestTimeoutMs: options.requestTimeoutMs ?? 3e4,
-    waitTimeoutMs: options.waitTimeoutMs ?? 5e3,
-    heartbeat: {
-      enabled: options.heartbeat?.enabled ?? true,
-      intervalMs: options.heartbeat?.intervalMs ?? 1e3,
-      timeoutMs: options.heartbeat?.timeoutMs ?? 5e3
-    },
-    reconnect: {
-      enabled: options.reconnect?.enabled ?? true,
-      initialDelayMs: options.reconnect?.initialDelayMs ?? 250,
-      maxDelayMs: options.reconnect?.maxDelayMs ?? 5e3,
-      backoffFactor: options.reconnect?.backoffFactor ?? 2,
-      maxAttempts: options.reconnect?.maxAttempts === void 0 ? 3 : options.reconnect.maxAttempts
-    },
-    maxSendPayloadSize: options.maxSendPayloadSize ?? 64 * 1024,
-    maxReceivePayloadSize: options.maxReceivePayloadSize ?? 64 * 1024,
-    dispatchMode: options.dispatchMode ?? "manual" /* Manual */,
-    compression: options.compression ?? "lz4" /* Lz4 */,
-    compressionCodec: resolveCompressionCodec2(options),
-    nameResolver: options.nameResolver ?? defaultPacketNameResolver,
-    transportFactory: options.transportFactory ?? defaultTransportFactory,
-    codec: options.codec
-  };
-}
-var defaultPacketNameResolver = {
-  resolve(payloadType) {
-    const declared = payloadType.packetName;
-    if (typeof declared === "string" && declared.length > 0) {
-      return declared;
-    }
-    return payloadType.name;
-  }
-};
-function resolveCompressionCodec2(options) {
-  const compression = options.compression ?? "lz4" /* Lz4 */;
-  if (compression === "none" /* None */) {
-    if (options.compressionCodec !== void 0) {
-      throw connectorError(
-        "configurationError" /* ConfigurationError */,
-        "compressionCodec cannot be set when compression is none."
-      );
-    }
-    return void 0;
-  }
-  return options.compressionCodec;
-}
-function validatePositive(value, name) {
-  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 intervalMs = options?.intervalMs ?? 1e3;
-  const timeoutMs = options?.timeoutMs ?? 5e3;
-  validatePositive(intervalMs, "Heartbeat interval");
-  validatePositive(timeoutMs, "Heartbeat timeout");
-}
-function validateReconnect(options) {
-  validatePositive(options?.initialDelayMs ?? 250, "Reconnect InitialDelay");
-  validatePositive(options?.maxDelayMs ?? 5e3, "Reconnect MaxDelay");
-  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(
-      "validationFailed" /* ValidationFailed */,
-      "Reconnect MaxAttempts must be null or positive."
-    );
-  }
-}
-
 // packages/stream-connector/src/Runtime/ZlinkStreamPendingRequests.ts
 var ZlinkStreamPendingRequests = class {
   nextRequestSeq = 1n;
   active = /* @__PURE__ */ new Map();
   create(packetName, timeoutMs) {
-    if (this.nextRequestSeq > 0xffffffffffffffffn) {
+    if (this.nextRequestSeq > UINT64_MAX) {
       throw connectorError("sendFailed" /* SendFailed */, "Request sequence is exhausted.");
     }
     const requestSeq = this.nextRequestSeq++;
@@ -1688,8 +1778,8 @@ var ZlinkStreamPendingRequests = class {
 };
 
 // packages/stream-connector/src/Runtime/ZlinkStreamActors.ts
-var ACTOR_BOUND = "$zlink.actor.bound";
-var ACTOR_UNBOUND = "$zlink.actor.unbound";
+var ACTOR_BOUND = ZlinkStreamControlPacket.ActorBound;
+var ACTOR_UNBOUND = ZlinkStreamControlPacket.ActorUnbound;
 var zlinkStreamActorBinding = Symbol("zlink.stream.actorBinding");
 var DefaultZlinkStreamActor = class {
   constructor(connector, actorId, slot) {
@@ -1732,7 +1822,6 @@ var ZlinkStreamActors = class {
   }
   bySlot = /* @__PURE__ */ new Map();
   byId = /* @__PURE__ */ new Map();
-  issued = [];
   boundHandlers = /* @__PURE__ */ new Set();
   unboundHandlers = /* @__PURE__ */ new Set();
   get snapshot() {
@@ -1742,12 +1831,10 @@ var ZlinkStreamActors = class {
     return this.byId.get(actorId);
   }
   onBound(handler) {
-    this.boundHandlers.add(handler);
-    return subscription(() => this.boundHandlers.delete(handler));
+    return registerHandler(this.boundHandlers, handler);
   }
   onUnbound(handler) {
-    this.unboundHandlers.add(handler);
-    return subscription(() => this.unboundHandlers.delete(handler));
+    return registerHandler(this.unboundHandlers, handler);
   }
   processControl(name, payload, signal) {
     if (name === ACTOR_BOUND) {
@@ -1771,48 +1858,43 @@ var ZlinkStreamActors = class {
     return actor;
   }
   closeAll(signal) {
-    for (const actor of this.issued) {
-      if (!actor.isBound) continue;
+    for (const actor of this.bySlot.values()) {
       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;
+    let binding;
     try {
-      actorId = new TextDecoder("utf-8", { fatal: true }).decode(payload.subarray(4));
+      binding = decodeStreamWireActorBoundPayload(payload);
     } catch (cause) {
       throw connectorError(
         "frameDecodeFailed" /* FrameDecodeFailed */,
-        "Actor id is not valid UTF-8.",
-        cause
+        cause instanceof Error ? cause.message : "Actor bound payload is invalid.",
+        cause instanceof Error ? cause.cause : void 0
       );
     }
+    const { slot, actorId } = binding;
     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.");
+    let slot;
+    try {
+      slot = decodeStreamWireActorUnboundPayload(payload);
+    } catch (cause) {
+      throw connectorError(
+        "frameDecodeFailed" /* FrameDecodeFailed */,
+        cause instanceof Error ? cause.message : "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.`);
@@ -1825,7 +1907,7 @@ var ZlinkStreamActors = class {
   queue(handlers, actor, signal) {
     this.receivedMessages.enqueueCallback(
       () => {
-        for (const handler of Array.from(handlers)) {
+        for (const { handler } of currentRegistrations(handlers)) {
           this.events.runUserCallback(
             () => handler(actor, signal),
             "Actor lifecycle handler failed.",
@@ -1843,7 +1925,7 @@ function invalidControl(message) {
 
 // packages/stream-connector/src/Runtime/ZlinkStreamReceivedMessages.ts
 function receives(registration, message) {
-  return registration.actor === void 0 || registration.actor === message[zlinkStreamActorBinding];
+  return registration.actor === void 0 || registration.actor.isBound && registration.actor === message[zlinkStreamActorBinding];
 }
 var ZlinkStreamReceivedMessages = class {
   /**
@@ -2049,7 +2131,8 @@ var ZlinkStreamReceivedMessages = class {
         }
         const { message, signal } = queued;
         const handlers = this.receiversOf(message);
-        for (const handler of handlers) {
+        for (const handler of currentRegistrations(this.handlers.get(message.name), handlers)) {
+          if (!receives(handler, message)) continue;
           this.events.runUserCallback(
             () => handler.handle(message, signal),
             "Typed message handler failed.",
@@ -2164,8 +2247,14 @@ var ZlinkStreamReceivedMessages = class {
       this.deliverable.length = 0;
       return;
     }
-    if (this.queueHead >= 1024 && this.queueHead * 2 >= this.queue.length) {
-      this.queue.splice(0, this.queueHead);
+    const removed = this.queue.length - this.queuedCount;
+    if (shouldCompactBackingArray(removed, this.queue.length)) {
+      let destination = 0;
+      for (let source = this.queueHead; source < this.queue.length; source += 1) {
+        const queued = this.queue[source];
+        if (queued !== void 0) this.queue[destination++] = queued;
+      }
+      this.queue.length = destination;
       this.queueHead = 0;
       this.deliverable.length = 0;
       for (let index = 0; index < this.queue.length; index += 1) {
@@ -2196,7 +2285,7 @@ var ZlinkStreamConnectionWriteQueue = class {
     this.advance();
   }
   cancel(operation, error) {
-    if (this.queue.has(operation) || this.active === operation) operation.fail(error);
+    if (this.queue.delete(operation) || this.active === operation) operation.fail(error);
   }
   /**
    * Spec stream-connector 32 §7: when the connection ends, frames that have not
@@ -2204,7 +2293,8 @@ var ZlinkStreamConnectionWriteQueue = class {
    * waited for. The operations of both fail with `error`.
    */
   failAll(error) {
-    const operations = this.active === void 0 ? [...this.queue] : [this.active, ...this.queue];
+    const operations = Array.from(this.queue);
+    if (this.active !== void 0) operations.unshift(this.active);
     this.queue.clear();
     this.active = void 0;
     for (const operation of operations) operation.fail(error);
@@ -2343,26 +2433,7 @@ var ZlinkStreamFrameSender = class {
 };
 
 // packages/stream-connector/src/Runtime/Protocol/ZlinkSessionClosing.ts
-var ZLINK_SESSION_CLOSING = "session-closing";
-var reasons = {
-  1: "ClientClose",
-  2: "IdleTimeout",
-  3: "HeartbeatTimeout",
-  4: "ServerDrain",
-  5: "ProtocolError",
-  6: "TransportError"
-};
-function decodeSessionClosing(payload) {
-  if (payload.length < 4 || payload[0] !== 1)
-    throw new Error("Unsupported session-closing version.");
-  const closeReason = reasons[payload[1]];
-  if (closeReason === void 0) throw new Error("Unknown session-closing reason.");
-  const length = payload[2] << 8 | payload[3];
-  if (length > 512 || payload.length !== 4 + length)
-    throw new Error("Invalid session-closing diagnostic length.");
-  const diagnostic = length === 0 ? void 0 : new TextDecoder("utf-8", { fatal: true }).decode(payload.subarray(4));
-  return { closeReason, diagnostic };
-}
+var ZLINK_SESSION_CLOSING = ZlinkStreamControlPacket.SessionClosing;
 
 // packages/stream-connector/src/Runtime/ZlinkStreamReceiveDispatcher.ts
 function closeReasonFor(error) {
@@ -2488,27 +2559,21 @@ var ZlinkStreamReceiveDispatcher = class {
       }
       return;
     }
-    if (header.kind === 4 /* Error */ && header.requestSeq !== void 0) {
+    if (header.kind === 4 /* Error */) {
+      let error;
       try {
-        const remoteError = decodeRemoteError(this.decodePayload(header, payload));
-        if (!this.pendingRequests.reject(header.requestSeq, remoteError)) {
-          this.events.publishError(remoteError, signal);
-        }
+        error = decodeRemoteError(this.decodePayload(header, payload));
       } catch (cause) {
         if (cause instanceof ZlinkStreamConnectionEnd) throw cause;
-        const decodeError = toStreamError(
+        error = toStreamError(
           cause,
           "frameDecodeFailed" /* FrameDecodeFailed */,
           "Remote error payload is invalid."
         );
-        if (!this.pendingRequests.reject(header.requestSeq, decodeError)) {
-          this.events.publishError(decodeError, signal);
-        }
       }
-      return;
-    }
-    if (header.kind === 4 /* Error */) {
-      this.events.publishError(decodeRemoteError(this.decodePayload(header, payload)), signal);
+      if (header.requestSeq === void 0 || !this.pendingRequests.reject(header.requestSeq, error)) {
+        this.events.publishError(error, signal);
+      }
       return;
     }
     if (header.kind === 5 /* Control */) {
@@ -2533,7 +2598,7 @@ var ZlinkStreamReceiveDispatcher = class {
       return;
     }
     if (header.name === ZLINK_SESSION_CLOSING) {
-      const closing = decodeSessionClosing(payload);
+      const closing = decodeStreamWireSessionClosing(payload);
       await this.serverClosing?.(closing.closeReason);
       return;
     }
@@ -2574,8 +2639,11 @@ function decodeRemoteError(decodedPayload) {
 }
 
 // packages/stream-connector/src/Runtime/ZlinkStreamConnectorLifecycle.ts
+var RECONNECT_JITTER_FLOOR = 0.5;
 function randomizedDelay(baseDelayMs) {
-  return Math.round(baseDelayMs * (0.5 + Math.random() * 0.5));
+  return Math.round(
+    baseDelayMs * (RECONNECT_JITTER_FLOOR + Math.random() * (1 - RECONNECT_JITTER_FLOOR))
+  );
 }
 var ZlinkStreamConnectorLifecycle = class {
   constructor(options, pendingRequests, frameSender, receiveDispatcher, receivedMessages, actors, events) {
@@ -2604,7 +2672,6 @@ var ZlinkStreamConnectorLifecycle = class {
   closeRequested = false;
   disconnectedPublished = false;
   closeReasonValue;
-  lateConnectCleanupError;
   get isConnected() {
     return this.currentState === "connected" /* Connected */;
   }
@@ -2646,12 +2713,7 @@ var ZlinkStreamConnectorLifecycle = class {
     try {
       const connection = await this.connectWithReconnect(attempts.signal);
       if (this.closeRequested) {
-        try {
-          await connection.close(signal);
-        } catch (error) {
-          this.lateConnectCleanupError = error;
-          throw error;
-        }
+        await this.closeTransport(connection, void 0, signal);
         throw connectorError(
           "disconnected" /* Disconnected */,
           "Connector closed while connecting."
@@ -2729,23 +2791,10 @@ var ZlinkStreamConnectorLifecycle = class {
     this.connectAbort?.abort();
     await this.connectTask?.catch(() => void 0);
     await this.disconnectTask?.catch(() => void 0);
-    const errors = [];
-    if (this.lateConnectCleanupError !== void 0) {
-      errors.push(this.lateConnectCleanupError);
-      this.lateConnectCleanupError = void 0;
-    }
-    try {
-      await this.tearDownConnection(
-        { code: "disconnected" /* Disconnected */, message: "Connector closed." },
-        signal
-      );
-    } catch (error) {
-      errors.push(error);
-    }
-    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.");
+    await this.tearDownConnection(
+      { code: "disconnected" /* Disconnected */, message: "Connector closed." },
+      signal
+    );
   }
   /**
    * Spec stream-connector 32 §7: `dispatch` runs the callbacks the receive loop
@@ -2951,19 +3000,26 @@ var ZlinkStreamConnectorLifecycle = class {
     if (this.disconnectTask !== void 0) {
       return await this.disconnectTask;
     }
-    this.disconnectTask = this.tearDownConnection(error).catch(() => {
-    }).finally(() => {
-      this.disconnectTask = void 0;
+    let resolve;
+    let reject;
+    const pending = new Promise((complete, fail) => {
+      resolve = complete;
+      reject = fail;
+    });
+    const task = pending.finally(() => {
+      if (this.disconnectTask === task) this.disconnectTask = void 0;
     });
-    await this.disconnectTask;
-    await this.announceDisconnect(error);
+    this.disconnectTask = task;
+    void this.tearDownConnection(error).then(resolve, reject);
+    await task;
+    this.announceDisconnect();
   }
   isCurrentConnection(connection, generation) {
     return !this.closeRequested && this.currentConnection === connection && this.connectionGeneration === generation;
   }
   /**
    * Ends the current connection, for close and for transport loss alike. No
-   * application callback runs from here. Spec stream-connector 32 §7 and §9:
+   * application callback runs before terminal operations settle. 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.
@@ -2984,7 +3040,31 @@ var ZlinkStreamConnectorLifecycle = class {
     this.pendingRequests.failAll(disconnected);
     this.receivedMessages.connectionEnded();
     this.actors.closeAll(signal);
-    await connection?.close(signal);
+    await this.closeTransport(connection, error, signal);
+  }
+  async closeTransport(connection, error, signal) {
+    try {
+      try {
+        await connection?.close(signal);
+      } finally {
+        this.setState(
+          this.closeRequested ? "closed" /* Closed */ : "disconnected" /* Disconnected */,
+          this.closeRequested ? void 0 : error,
+          signal
+        );
+      }
+    } catch (cause) {
+      this.events.publishError(
+        {
+          code: "disconnected" /* Disconnected */,
+          message: `Transport close failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          cause
+        },
+        signal
+      );
+    } finally {
+      this.publishDisconnected(signal);
+    }
   }
   /**
    * Runs once the teardown promise has settled, so a handler reached from here
@@ -2994,10 +3074,7 @@ var ZlinkStreamConnectorLifecycle = class {
    * handler that is slow — or whose promise never settles at all — must not
    * cost the connector the attempt.
    */
-  async announceDisconnect(error) {
-    if (this.closeRequested) return;
-    this.setState("disconnected" /* Disconnected */, error);
-    this.publishDisconnected();
+  announceDisconnect() {
     if (this.shouldReconnect()) {
       queueMicrotask(() => {
         void this.connect().catch(() => void 0);
@@ -3041,16 +3118,13 @@ var ZlinkStreamConnectorEvents = class {
   disconnectedHandlers = /* @__PURE__ */ new Set();
   stateHandlers = /* @__PURE__ */ new Set();
   onError(handler) {
-    this.errorHandlers.add(handler);
-    return subscription(() => this.errorHandlers.delete(handler));
+    return registerHandler(this.errorHandlers, handler);
   }
   onDisconnected(handler) {
-    this.disconnectedHandlers.add(handler);
-    return subscription(() => this.disconnectedHandlers.delete(handler));
+    return registerHandler(this.disconnectedHandlers, handler);
   }
   onStateChanged(handler) {
-    this.stateHandlers.add(handler);
-    return subscription(() => this.stateHandlers.delete(handler));
+    return registerHandler(this.stateHandlers, handler);
   }
   publishError(error, signal) {
     this.publish(this.errorHandlers, (handler) => handler(error, signal), signal);
@@ -3078,13 +3152,13 @@ var ZlinkStreamConnectorEvents = class {
   publish(handlers, invoke, signal) {
     this.enqueueCallback(
       () => {
-        for (const handler of Array.from(handlers)) {
+        for (const handler of currentRegistrations(handlers)) {
           const report = (cause) => this.reportFailure(
             cause,
             signal,
             handlers === this.errorHandlers ? handler : void 0
           );
-          this.invoke(() => invoke(handler), report);
+          this.invoke(() => invoke(handler.handler), report);
         }
       },
       () => handlers.size
@@ -3107,15 +3181,22 @@ var ZlinkStreamConnectorEvents = class {
       (candidate) => !attempted.has(candidate)
     );
     if (remaining.length === 0) return;
-    const nextAttempted = /* @__PURE__ */ new Set([...attempted, ...remaining]);
+    const nextAttempted = new Set(attempted);
+    for (const handler of remaining) nextAttempted.add(handler);
     this.enqueueCallback(
       () => {
-        for (const handler of remaining) {
+        for (const handler of currentRegistrations(this.errorHandlers, remaining)) {
           const report = (cause) => this.reportToRemaining({ ...error, cause }, signal, nextAttempted);
-          this.invoke(() => handler(error, signal), report);
+          const callback = handler.handler;
+          this.invoke(() => callback(error, signal), report);
         }
       },
-      () => remaining.length
+      () => {
+        let count = 0;
+        const registrations = currentRegistrations(this.errorHandlers, remaining);
+        while (registrations.next().done !== true) count += 1;
+        return count;
+      }
     );
   }
   invoke(run, report) {
@@ -3262,7 +3343,7 @@ var BrowserWebSocketConnection = class {
     const message = this.messages[this.messageHead];
     this.messages[this.messageHead] = void 0;
     this.messageHead += 1;
-    if (this.messageHead >= 1024 && this.messageHead * 2 >= this.messages.length) {
+    if (shouldCompactBackingArray(this.messageHead, this.messages.length)) {
       this.messages.splice(0, this.messageHead);
       this.messageHead = 0;
     }
@@ -3277,8 +3358,8 @@ async function waitForOpen(socket, connectTimeoutMs, signal) {
       connectTimeoutMs
     );
     const onOpen = () => finish();
-    const onClose = () => finish(connectorError("connectTimeout" /* ConnectTimeout */, "Connect closed before opening."));
-    const onError = () => finish(connectorError("connectTimeout" /* ConnectTimeout */, "Connect failed."));
+    const onClose = () => finish(connectorError("disconnected" /* Disconnected */, "Connect closed before opening."));
+    const onError = () => finish(connectorError("disconnected" /* Disconnected */, "Connect failed."));
     const onAbort = () => finish(connectorError("disconnected" /* Disconnected */, "Connect canceled."));
     const finish = (error) => {
       clearTimeout(timeout);
@@ -3402,12 +3483,10 @@ var DefaultZlinkStreamConnector = class {
     return this.events.onStateChanged(handler);
   }
   onRequestSending(handler) {
-    this.requestSendingHandlers.add(handler);
-    return subscription(() => this.requestSendingHandlers.delete(handler));
+    return registerHandler(this.requestSendingHandlers, handler);
   }
   onReplyReceived(handler) {
-    this.replyReceivedHandlers.add(handler);
-    return subscription(() => this.replyReceivedHandlers.delete(handler));
+    return registerHandler(this.replyReceivedHandlers, handler);
   }
   async connect(signal) {
     await this.lifecycle.connect(signal);
@@ -3641,7 +3720,7 @@ var DefaultZlinkStreamConnector = class {
     let stopCancellation;
     try {
       throwIfAborted(signal);
-      for (const handler of Array.from(this.requestSendingHandlers)) {
+      for (const { handler } of currentRegistrations(this.requestSendingHandlers)) {
         try {
           handler(sendingContext);
         } catch (cause) {
@@ -3713,7 +3792,7 @@ var DefaultZlinkStreamConnector = class {
     if (this.replyReceivedHandlers.size === 0) return;
     this.receivedMessages.enqueueCallback(
       () => {
-        for (const handler of Array.from(this.replyReceivedHandlers)) {
+        for (const { handler } of currentRegistrations(this.replyReceivedHandlers)) {
           this.events.runUserCallback(
             () => handler(context, signal),
             "Reply received hook failed.",