@zlink-systems/stream-wire 0.26.0 → 0.28.0

package/dist/esm/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,68 +126,257 @@ 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 encodeStreamWireActorBoundPayload(actorSlot, actorId) {
+  const actorIdBytes = utf8Encode(actorId);
+  if (actorIdBytes.length < 1 || actorIdBytes.length > UINT8_MAX) {
+    throw new Error("Actor id length is invalid for a STREAM binding control packet.");
+  }
+  const payload = new Uint8Array(ACTOR_BOUND_PREFIX_BYTES + actorIdBytes.length);
+  payload[0] = CONTROL_PAYLOAD_VERSION;
+  writeUInt16BE(payload, ACTOR_SLOT_OFFSET, actorSlot);
+  payload[ACTOR_ID_LENGTH_OFFSET] = actorIdBytes.length;
+  payload.set(actorIdBytes, ACTOR_BOUND_PREFIX_BYTES);
+  return payload;
+}
+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 encodeStreamWireActorUnboundPayload(actorSlot) {
+  const payload = new Uint8Array(ACTOR_UNBOUND_BYTES);
+  payload[0] = CONTROL_PAYLOAD_VERSION;
+  writeUInt16BE(payload, ACTOR_SLOT_OFFSET, actorSlot);
+  return payload;
+}
+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 encodeStreamWireSessionClosingPayload(reasonCode, diagnostic = "") {
+  const bytes = utf8Encode(diagnostic);
+  if (bytes.length > MAX_CLOSING_DIAGNOSTIC_BYTES) {
+    throw new Error("Session-closing diagnostic is too large.");
+  }
+  const payload = new Uint8Array(CLOSING_PREFIX_BYTES + bytes.length);
+  payload[0] = CONTROL_PAYLOAD_VERSION;
+  payload[1] = reasonCode;
+  writeUInt16BE(payload, CLOSING_DIAGNOSTIC_LENGTH_OFFSET, bytes.length);
+  payload.set(bytes, CLOSING_PREFIX_BYTES);
+  return payload;
+}
+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])
+);
+function streamCodecContentType(codec) {
+  const contentType = contentTypesByCodec.get(codec);
+  if (contentType === void 0) throw new TypeError(`Unsupported STREAM codec '${codec}'.`);
+  return contentType;
+}
+function streamCodecForContentType(contentType) {
+  const codec = codecsByContentType.get(contentType);
+  if (codec === void 0) throw new TypeError(`Unsupported STREAM content type '${contentType}'.`);
+  return 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 tryDecodeStreamWireFrame(frame) {
-  if (frame.length < 6) {
+  if (frame.length < ZLINK_STREAM_FRAME_PREFIX_BYTES) {
     return void 0;
   }
   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) {
     return void 0;
   }
   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;
@@ -196,7 +389,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;
@@ -206,7 +399,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;
@@ -218,14 +411,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;
   }
@@ -236,7 +429,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) {
@@ -247,7 +440,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) {
@@ -261,29 +454,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;
@@ -302,14 +494,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.");
@@ -318,14 +510,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.");
@@ -355,32 +547,36 @@ 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;
   }
@@ -409,11 +605,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.");
   }
@@ -439,7 +635,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.");
     }
@@ -456,16 +652,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];
@@ -474,10 +671,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) {
@@ -492,19 +689,58 @@ 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;
+}
 export {
+  UINT32_MAX,
+  UINT64_BYTES,
+  UINT64_MAX,
   ZLINK_STREAM_FORMAT_MARKER,
+  ZLINK_STREAM_FRAME_PREFIX_BYTES,
+  ZLINK_STREAM_MAX_METADATA_BYTES,
+  ZLINK_STREAM_MAX_PACKET_NAME_BYTES,
+  ZLINK_STREAM_RESERVED_PACKET_NAME_PREFIX,
+  ZlinkStreamCloseReasonCode,
   ZlinkStreamCodec,
+  ZlinkStreamContentType,
+  ZlinkStreamControlPacket,
+  ZlinkStreamHeaderFlags,
+  ZlinkStreamMessageKind,
+  decodeStreamWireActorBoundPayload,
+  decodeStreamWireActorUnboundPayload,
   decodeStreamWireFrame,
   decodeStreamWireHeader,
   decodeStreamWireMetadata,
+  decodeStreamWireSessionClosing,
+  defaultMaxDecompressedPayloadSize,
+  encodeStreamWireActorBoundPayload,
+  encodeStreamWireActorUnboundPayload,
   encodeStreamWireFrame,
   encodeStreamWireHeader,
   encodeStreamWireMetadata,
+  encodeStreamWireSessionClosingPayload,
+  isStreamWireCodec,
+  isStreamWireMessageKind,
   lz4PickleUncompressed2 as lz4PickleUncompressed,
   lz4PickledLength2 as lz4PickledLength,
   lz4UnpicklePayload2 as lz4UnpicklePayload,
+  splitStreamWireFrames,
+  streamCodecContentType,
+  streamCodecForContentType,
+  streamWireMetadataSize,
   tryDecodeStreamWireFrame,
   utf8Decode,
-  utf8Encode
+  utf8Encode,
+  validateStreamWirePacketName
 };