@zlink-systems/stream-wire 0.10.0

package/LICENSE

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2026 ZLink Systems
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/dist/esm/index.d.ts

@@ -0,0 +1,40 @@
+export interface ZLinkStreamWireFrame {
+    readonly header: Uint8Array;
+    readonly payload: Uint8Array;
+}
+/** Numeric payload codec values shared by browser and server wire paths. */
+export declare enum ZlinkStreamCodec {
+    Raw = 0,
+    Json = 1,
+    MessagePack = 2,
+    Protobuf = 3
+}
+export interface ZLinkStreamWireHeader {
+    readonly kind: number;
+    readonly codec: number;
+    readonly flags: number;
+    readonly requestSeq?: bigint;
+    readonly name: string;
+    readonly metadata: ReadonlyMap<string, string>;
+    readonly correlationId?: string;
+    readonly flowId?: string;
+    readonly flowOrigin?: number;
+}
+export interface ZLinkStreamWireHeaderFlags {
+    readonly hasRequestSeq: number;
+    readonly hasMetadata: number;
+    readonly hasCorrelationId: number;
+    readonly hasFlowId: number;
+}
+export declare const ZLINK_STREAM_FORMAT_MARKER = 242;
+export declare function encodeStreamWireFrame(header: Uint8Array, payload: Uint8Array): Uint8Array;
+export declare function decodeStreamWireFrame(frame: Uint8Array): ZLinkStreamWireFrame;
+export declare function tryDecodeStreamWireFrame(frame: Uint8Array): ZLinkStreamWireFrame | undefined;
+export declare function encodeStreamWireHeader(header: ZLinkStreamWireHeader, flags?: ZLinkStreamWireHeaderFlags): Uint8Array;
+export declare function decodeStreamWireHeader(header: Uint8Array, flags?: ZLinkStreamWireHeaderFlags, includeFlow?: boolean): ZLinkStreamWireHeader;
+export declare function encodeStreamWireMetadata(metadata: ReadonlyMap<string, string>): Uint8Array;
+export declare function decodeStreamWireMetadata(metadata: Uint8Array): Map<string, string>;
+export declare function lz4PickleUncompressed(payload: Uint8Array): Uint8Array;
+export declare function lz4UnpicklePayload(payload: Uint8Array, maxDecompressedSize?: number): Uint8Array;
+export declare function utf8Encode(value: string): Uint8Array;
+export declare function utf8Decode(value: Uint8Array): string;

package/dist/esm/index.mjs

@@ -0,0 +1,475 @@
+// packages/stream-wire/src/lz4-pickle.ts
+var defaultMaxDecompressedPayloadSize = 64 * 1024;
+function lz4PickleUncompressed(payload) {
+  if (payload.length === 0) {
+    return new Uint8Array();
+  }
+  const pickled = new Uint8Array(payload.length + 1);
+  pickled[0] = 0;
+  pickled.set(payload, 1);
+  return pickled;
+}
+function lz4UnpicklePayload(payload, maxDecompressedSize = defaultMaxDecompressedPayloadSize) {
+  if (payload.length === 0) {
+    return new Uint8Array();
+  }
+  const header = payload[0];
+  if ((header & 7) !== 0) {
+    throw new Error("Unexpected LZ4 pickle version.");
+  }
+  const sizeOfDiff = decodeDiffSize(header >>> 6 & 3);
+  const dataOffset = 1 + sizeOfDiff;
+  if (payload.length < dataOffset) {
+    throw new Error("LZ4 pickle header is incomplete.");
+  }
+  const data = payload.subarray(dataOffset);
+  const resultDiff = sizeOfDiff === 0 ? 0 : readLittleEndian(payload, 1, sizeOfDiff);
+  const resultLength = data.length + resultDiff;
+  if (resultLength > maxDecompressedSize) {
+    throw new Error("LZ4 decoded payload exceeds maximum stream payload size.");
+  }
+  if (resultDiff === 0) {
+    return data.slice();
+  }
+  return decodeLz4Block(data, resultLength);
+}
+function decodeDiffSize(encoded) {
+  return encoded === 3 ? 4 : encoded;
+}
+function readLittleEndian(source, offset, size) {
+  if (size === 1) {
+    return source[offset];
+  }
+  if (size === 2) {
+    return source[offset] | source[offset + 1] << 8;
+  }
+  if (size === 4) {
+    return source[offset] | source[offset + 1] << 8 | source[offset + 2] << 16 | source[offset + 3] * 16777216;
+  }
+  throw new Error(`Unexpected LZ4 pickle field size: ${size}`);
+}
+function decodeLz4Block(source, resultLength) {
+  const target = new Uint8Array(resultLength);
+  let sourceOffset = 0;
+  let targetOffset = 0;
+  while (sourceOffset < source.length) {
+    const token = source[sourceOffset++];
+    const literalLength = readLz4Length(source, token >>> 4, () => sourceOffset++);
+    if (source.length - sourceOffset < literalLength) {
+      throw new Error("LZ4 literal run is incomplete.");
+    }
+    if (target.length - targetOffset < literalLength) {
+      throw new Error("LZ4 literal run exceeds output size.");
+    }
+    target.set(source.subarray(sourceOffset, sourceOffset + literalLength), targetOffset);
+    sourceOffset += literalLength;
+    targetOffset += literalLength;
+    if (sourceOffset >= source.length) {
+      break;
+    }
+    if (source.length - sourceOffset < 2) {
+      throw new Error("LZ4 match offset is incomplete.");
+    }
+    const matchOffset = source[sourceOffset] | source[sourceOffset + 1] << 8;
+    sourceOffset += 2;
+    if (matchOffset === 0 || matchOffset > targetOffset) {
+      throw new Error("LZ4 match offset is invalid.");
+    }
+    const matchLength = readLz4Length(source, token & 15, () => sourceOffset++) + 4;
+    if (target.length - targetOffset < matchLength) {
+      throw new Error("LZ4 match run exceeds output size.");
+    }
+    for (let index = 0; index < matchLength; index += 1) {
+      target[targetOffset + index] = target[targetOffset - matchOffset + index];
+    }
+    targetOffset += matchLength;
+  }
+  if (targetOffset !== resultLength) {
+    throw new Error("LZ4 decoded length does not match pickle header.");
+  }
+  return target;
+}
+function readLz4Length(source, nibble, nextOffset) {
+  let length = nibble;
+  if (length !== 15) {
+    return length;
+  }
+  for (; ; ) {
+    const offset = nextOffset();
+    if (offset >= source.length) {
+      throw new Error("LZ4 extended length is incomplete.");
+    }
+    const value = source[offset];
+    length += value;
+    if (value !== 255) {
+      return length;
+    }
+  }
+}
+
+// packages/stream-wire/src/index.ts
+var ZlinkStreamCodec = /* @__PURE__ */ ((ZlinkStreamCodec2) => {
+  ZlinkStreamCodec2[ZlinkStreamCodec2["Raw"] = 0] = "Raw";
+  ZlinkStreamCodec2[ZlinkStreamCodec2["Json"] = 1] = "Json";
+  ZlinkStreamCodec2[ZlinkStreamCodec2["MessagePack"] = 2] = "MessagePack";
+  ZlinkStreamCodec2[ZlinkStreamCodec2["Protobuf"] = 3] = "Protobuf";
+  return ZlinkStreamCodec2;
+})(ZlinkStreamCodec || {});
+var defaultHeaderFlags = {
+  hasRequestSeq: 1,
+  hasMetadata: 2,
+  hasCorrelationId: 8,
+  hasFlowId: 16
+};
+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) {
+    throw new Error("Stream header is too large.");
+  }
+  if (payload.length > 4294967295) {
+    throw new Error("Stream payload is too large.");
+  }
+  const frame = new Uint8Array(6 + header.length + payload.length);
+  writeUInt16BE(frame, 0, header.length);
+  writeUInt32BE(frame, 2, payload.length);
+  frame.set(header, 6);
+  frame.set(payload, 6 + header.length);
+  return frame;
+}
+function decodeStreamWireFrame(frame) {
+  if (frame.length < 6) {
+    throw new Error("Stream frame prefix is incomplete.");
+  }
+  const headerLength = readUInt16BE(frame, 0);
+  const payloadLength = readUInt32BE(frame, 2);
+  if (frame.length !== 6 + headerLength + payloadLength) {
+    throw new Error("Stream frame length does not match prefix.");
+  }
+  return {
+    header: frame.slice(6, 6 + headerLength),
+    payload: frame.slice(6 + headerLength)
+  };
+}
+function tryDecodeStreamWireFrame(frame) {
+  if (frame.length < 6) {
+    return void 0;
+  }
+  const headerLength = readUInt16BE(frame, 0);
+  const payloadLength = readUInt32BE(frame, 2);
+  if (frame.length !== 6 + headerLength + payloadLength) {
+    return void 0;
+  }
+  return {
+    header: frame.slice(6, 6 + headerLength),
+    payload: frame.slice(6 + headerLength)
+  };
+}
+function encodeStreamWireHeader(header, flags = defaultHeaderFlags) {
+  const reply = isReplyKind(header.kind);
+  const packetName = reply ? "" : header.name;
+  if (!reply) validateStreamWirePacketName(packetName);
+  const nameBytes = utf8Encode(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) {
+    throw new Error("Stream correlation id is too large.");
+  }
+  const hasCorrelation = correlationBytes !== void 0;
+  const hasFlow = header.flowId !== void 0 || header.flowOrigin !== void 0;
+  if (hasFlow && (header.flowId === void 0 || header.flowOrigin === void 0)) {
+    throw new Error("Stream flow id and origin must be provided together.");
+  }
+  if (header.flowId !== void 0) validateFlowId(header.flowId);
+  if (header.flowOrigin !== void 0 && ![1, 2, 3, 4].includes(header.flowOrigin)) {
+    throw new Error("Stream flow origin is invalid.");
+  }
+  let headerFlags = header.flags;
+  headerFlags = hasRequestSeq ? headerFlags | flags.hasRequestSeq : headerFlags & ~flags.hasRequestSeq;
+  headerFlags = hasMetadata ? headerFlags | flags.hasMetadata : headerFlags & ~flags.hasMetadata;
+  headerFlags = hasCorrelation ? headerFlags | flags.hasCorrelationId : headerFlags & ~flags.hasCorrelationId;
+  headerFlags = hasFlow ? headerFlags | flags.hasFlowId : headerFlags & ~flags.hasFlowId;
+  const metadataBytes = hasMetadata ? encodeStreamWireMetadata(header.metadata) : new Uint8Array();
+  const size = 4 + (hasRequestSeq ? 8 : 0) + 1 + nameBytes.length + (hasMetadata ? 2 + metadataBytes.length : 0) + (hasCorrelation ? 1 + correlationBytes.length : 0) + (hasFlow ? 37 : 0);
+  const buffer = new Uint8Array(size);
+  let offset = 0;
+  buffer[offset++] = ZLINK_STREAM_FORMAT_MARKER;
+  buffer[offset++] = header.kind;
+  buffer[offset++] = header.codec;
+  buffer[offset++] = headerFlags;
+  if (hasRequestSeq) {
+    if (header.requestSeq === 0n) {
+      throw new Error("Request sequence must not be zero.");
+    }
+    writeBigUInt64BE(buffer, offset, header.requestSeq);
+    offset += 8;
+  }
+  buffer[offset++] = nameBytes.length;
+  buffer.set(nameBytes, offset);
+  offset += nameBytes.length;
+  if (hasMetadata) {
+    writeUInt16BE(buffer, offset, metadataBytes.length);
+    offset += 2;
+    buffer.set(metadataBytes, offset);
+    offset += metadataBytes.length;
+  }
+  if (hasCorrelation) {
+    buffer[offset++] = correlationBytes.length;
+    buffer.set(correlationBytes, offset);
+    offset += correlationBytes.length;
+  }
+  if (hasFlow) {
+    buffer.set(asciiEncode(header.flowId), offset);
+    offset += 36;
+    buffer[offset++] = header.flowOrigin;
+  }
+  return buffer;
+}
+function decodeStreamWireHeader(header, flags = defaultHeaderFlags, includeFlow = true) {
+  let offset = 0;
+  if (header.length < 5) {
+    throw new Error("Stream header is incomplete.");
+  }
+  if (header[offset++] !== ZLINK_STREAM_FORMAT_MARKER) {
+    throw new Error("Stream header format marker is invalid.");
+  }
+  const kind = header[offset++];
+  const codec = header[offset++];
+  const headerFlags = header[offset++];
+  const hasRequestSeq = (headerFlags & flags.hasRequestSeq) !== 0;
+  const hasMetadata = (headerFlags & flags.hasMetadata) !== 0;
+  const hasCorrelation = (headerFlags & flags.hasCorrelationId) !== 0;
+  const hasFlow = (headerFlags & flags.hasFlowId) !== 0;
+  if ((headerFlags & ~31) !== 0) {
+    throw new Error("Unknown mandatory stream header flag.");
+  }
+  let requestSeq;
+  if (hasRequestSeq) {
+    if (header.length - offset < 8) {
+      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;
+  }
+  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) {
+    throw new Error("Stream packet name is invalid.");
+  }
+  const decodedName = utf8Decode(header.subarray(offset, offset + nameLength));
+  const name = isReplyKind(kind) ? "" : decodedName;
+  offset += nameLength;
+  const decodedMetadata = hasMetadata ? decodeStreamWireHeaderMetadata(header, offset) : { metadata: /* @__PURE__ */ new Map(), offset };
+  offset = decodedMetadata.offset;
+  let correlationId;
+  if (hasCorrelation) {
+    if (header.length - offset < 1) {
+      throw new Error("Stream correlation id is incomplete.");
+    }
+    const correlationLength = header[offset++];
+    if (header.length - offset < correlationLength) {
+      throw new Error("Stream correlation id is incomplete.");
+    }
+    correlationId = utf8Decode(header.subarray(offset, offset + correlationLength));
+    offset += correlationLength;
+  }
+  let flowId;
+  let flowOrigin;
+  if (hasFlow) {
+    if (header.length - offset < 37) {
+      throw new Error("Stream flow fields are incomplete.");
+    }
+    if (includeFlow) {
+      flowId = asciiDecode(header.subarray(offset, offset + 36));
+      validateFlowId(flowId);
+    }
+    offset += 36;
+    const decodedFlowOrigin = header[offset++];
+    if (includeFlow && ![1, 2, 3, 4].includes(decodedFlowOrigin)) {
+      throw new Error("Stream flow origin is invalid.");
+    }
+    flowOrigin = includeFlow ? decodedFlowOrigin : void 0;
+  }
+  if (offset !== header.length) {
+    throw new Error("Stream header has trailing bytes.");
+  }
+  return {
+    kind,
+    codec,
+    flags: headerFlags,
+    requestSeq,
+    name,
+    metadata: decodedMetadata.metadata,
+    correlationId,
+    flowId,
+    flowOrigin
+  };
+}
+function validateFlowId(flowId) {
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(flowId)) {
+    throw new Error("Stream flow id must be a lowercase UUIDv7.");
+  }
+}
+function asciiEncode(value) {
+  return Uint8Array.from(value, (character) => character.charCodeAt(0));
+}
+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) {
+    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) {
+      throw new Error("Metadata key length is invalid.");
+    }
+    if (valueBytes.length > 65535) {
+      throw new Error("Metadata value is too large.");
+    }
+    size += 1 + keyBytes.length + 2 + valueBytes.length;
+    return { keyBytes, valueBytes };
+  });
+  const buffer = new Uint8Array(size);
+  let offset = 0;
+  buffer[offset++] = metadata.size;
+  for (const { keyBytes, valueBytes } of encoded) {
+    buffer[offset++] = keyBytes.length;
+    buffer.set(keyBytes, offset);
+    offset += keyBytes.length;
+    writeUInt16BE(buffer, offset, valueBytes.length);
+    offset += 2;
+    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);
+}
+function lz4UnpicklePayload2(payload, maxDecompressedSize = defaultMaxDecompressedPayloadSize) {
+  return lz4UnpicklePayload(payload, maxDecompressedSize);
+}
+function utf8Encode(value) {
+  return new TextEncoder().encode(value);
+}
+function utf8Decode(value) {
+  return new TextDecoder().decode(value);
+}
+function decodeStreamWireHeaderMetadata(header, offset) {
+  if (header.length - offset < 2) {
+    throw new Error("Stream metadata section is incomplete.");
+  }
+  const metadataLength = readUInt16BE(header, offset);
+  offset += 2;
+  if (header.length - offset < metadataLength) {
+    throw new Error("Stream metadata payload is incomplete.");
+  }
+  return decodeStreamWireMetadataAt(header, offset, offset + metadataLength);
+}
+function decodeStreamWireMetadataAt(source, offset, end) {
+  if (offset >= end) {
+    throw new Error("Stream metadata entry count is missing.");
+  }
+  const count = source[offset++];
+  const metadata = /* @__PURE__ */ new Map();
+  for (let index = 0; index < count; index += 1) {
+    if (offset >= end) {
+      throw new Error("Stream metadata key length is missing.");
+    }
+    const keyLength = source[offset++];
+    if (keyLength === 0 || end - offset < keyLength) {
+      throw new Error("Stream metadata key is invalid.");
+    }
+    const key = utf8Decode(source.subarray(offset, offset + keyLength));
+    offset += keyLength;
+    if (end - offset < 2) {
+      throw new Error("Stream metadata value length is missing.");
+    }
+    const valueLength = readUInt16BE(source, offset);
+    offset += 2;
+    if (end - offset < valueLength) {
+      throw new Error("Stream metadata value is incomplete.");
+    }
+    if (metadata.has(key)) {
+      throw new Error("Duplicate metadata key is duplicated.");
+    }
+    metadata.set(key, utf8Decode(source.subarray(offset, offset + valueLength)));
+    offset += valueLength;
+  }
+  if (offset !== end) {
+    throw new Error("Stream metadata payload has trailing bytes.");
+  }
+  return { metadata, offset };
+}
+function validateStreamWirePacketName(name) {
+  const nameBytes = utf8Encode(name);
+  if (name.trim().length === 0 || nameBytes.length > 255) {
+    throw new Error("Stream packet name is invalid.");
+  }
+}
+function isReplyKind(kind) {
+  return kind === ZLINK_STREAM_RESPONSE_KIND || kind === ZLINK_STREAM_ERROR_KIND;
+}
+function writeUInt16BE(buffer, offset, value) {
+  buffer[offset] = value >>> 8 & 255;
+  buffer[offset + 1] = value & 255;
+}
+function readUInt16BE(buffer, offset) {
+  return buffer[offset] << 8 | buffer[offset + 1];
+}
+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;
+}
+function writeBigUInt64BE(buffer, offset, value) {
+  for (let index = 7; index >= 0; index -= 1) {
+    buffer[offset + index] = Number(value & 0xffn);
+    value >>= 8n;
+  }
+}
+function readBigUInt64BE(buffer, offset) {
+  let value = 0n;
+  for (let index = 0; index < 8; index += 1) {
+    value = value << 8n | BigInt(buffer[offset + index]);
+  }
+  return value;
+}
+export {
+  ZLINK_STREAM_FORMAT_MARKER,
+  ZlinkStreamCodec,
+  decodeStreamWireFrame,
+  decodeStreamWireHeader,
+  decodeStreamWireMetadata,
+  encodeStreamWireFrame,
+  encodeStreamWireHeader,
+  encodeStreamWireMetadata,
+  lz4PickleUncompressed2 as lz4PickleUncompressed,
+  lz4UnpicklePayload2 as lz4UnpicklePayload,
+  tryDecodeStreamWireFrame,
+  utf8Decode,
+  utf8Encode
+};

package/dist/esm/lz4-pickle.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultMaxDecompressedPayloadSize: number;
+export declare function lz4PickleUncompressed(payload: Uint8Array): Uint8Array;
+export declare function lz4UnpicklePayload(payload: Uint8Array, maxDecompressedSize?: number): Uint8Array;

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+export interface ZLinkStreamWireFrame {
+    readonly header: Uint8Array;
+    readonly payload: Uint8Array;
+}
+/** Numeric payload codec values shared by browser and server wire paths. */
+export declare enum ZlinkStreamCodec {
+    Raw = 0,
+    Json = 1,
+    MessagePack = 2,
+    Protobuf = 3
+}
+export interface ZLinkStreamWireHeader {
+    readonly kind: number;
+    readonly codec: number;
+    readonly flags: number;
+    readonly requestSeq?: bigint;
+    readonly name: string;
+    readonly metadata: ReadonlyMap<string, string>;
+    readonly correlationId?: string;
+    readonly flowId?: string;
+    readonly flowOrigin?: number;
+}
+export interface ZLinkStreamWireHeaderFlags {
+    readonly hasRequestSeq: number;
+    readonly hasMetadata: number;
+    readonly hasCorrelationId: number;
+    readonly hasFlowId: number;
+}
+export declare const ZLINK_STREAM_FORMAT_MARKER = 242;
+export declare function encodeStreamWireFrame(header: Uint8Array, payload: Uint8Array): Uint8Array;
+export declare function decodeStreamWireFrame(frame: Uint8Array): ZLinkStreamWireFrame;
+export declare function tryDecodeStreamWireFrame(frame: Uint8Array): ZLinkStreamWireFrame | undefined;
+export declare function encodeStreamWireHeader(header: ZLinkStreamWireHeader, flags?: ZLinkStreamWireHeaderFlags): Uint8Array;
+export declare function decodeStreamWireHeader(header: Uint8Array, flags?: ZLinkStreamWireHeaderFlags, includeFlow?: boolean): ZLinkStreamWireHeader;
+export declare function encodeStreamWireMetadata(metadata: ReadonlyMap<string, string>): Uint8Array;
+export declare function decodeStreamWireMetadata(metadata: Uint8Array): Map<string, string>;
+export declare function lz4PickleUncompressed(payload: Uint8Array): Uint8Array;
+export declare function lz4UnpicklePayload(payload: Uint8Array, maxDecompressedSize?: number): Uint8Array;
+export declare function utf8Encode(value: string): Uint8Array;
+export declare function utf8Decode(value: Uint8Array): string;

package/dist/index.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLINK_STREAM_FORMAT_MARKER = exports.ZlinkStreamCodec = void 0;
+exports.encodeStreamWireFrame = encodeStreamWireFrame;
+exports.decodeStreamWireFrame = decodeStreamWireFrame;
+exports.tryDecodeStreamWireFrame = tryDecodeStreamWireFrame;
+exports.encodeStreamWireHeader = encodeStreamWireHeader;
+exports.decodeStreamWireHeader = decodeStreamWireHeader;
+exports.encodeStreamWireMetadata = encodeStreamWireMetadata;
+exports.decodeStreamWireMetadata = decodeStreamWireMetadata;
+exports.lz4PickleUncompressed = lz4PickleUncompressed;
+exports.lz4UnpicklePayload = lz4UnpicklePayload;
+exports.utf8Encode = utf8Encode;
+exports.utf8Decode = utf8Decode;
+const lz4_pickle_1 = require("./lz4-pickle");
+/** Numeric payload codec values shared by browser and server wire paths. */
+var ZlinkStreamCodec;
+(function (ZlinkStreamCodec) {
+    ZlinkStreamCodec[ZlinkStreamCodec["Raw"] = 0] = "Raw";
+    ZlinkStreamCodec[ZlinkStreamCodec["Json"] = 1] = "Json";
+    ZlinkStreamCodec[ZlinkStreamCodec["MessagePack"] = 2] = "MessagePack";
+    ZlinkStreamCodec[ZlinkStreamCodec["Protobuf"] = 3] = "Protobuf";
+})(ZlinkStreamCodec || (exports.ZlinkStreamCodec = ZlinkStreamCodec = {}));
+const defaultHeaderFlags = {
+    hasRequestSeq: 0x01,
+    hasMetadata: 0x02,
+    hasCorrelationId: 0x08,
+    hasFlowId: 0x10
+};
+exports.ZLINK_STREAM_FORMAT_MARKER = 0xf2;
+const ZLINK_STREAM_RESPONSE_KIND = 3;
+const ZLINK_STREAM_ERROR_KIND = 4;
+function encodeStreamWireFrame(header, payload) {
+    if (header.length > 0xffff) {
+        throw new Error('Stream header is too large.');
+    }
+    if (payload.length > 0xffffffff) {
+        throw new Error('Stream payload is too large.');
+    }
+    const frame = new Uint8Array(6 + header.length + payload.length);
+    writeUInt16BE(frame, 0, header.length);
+    writeUInt32BE(frame, 2, payload.length);
+    frame.set(header, 6);
+    frame.set(payload, 6 + header.length);
+    return frame;
+}
+function decodeStreamWireFrame(frame) {
+    if (frame.length < 6) {
+        throw new Error('Stream frame prefix is incomplete.');
+    }
+    const headerLength = readUInt16BE(frame, 0);
+    const payloadLength = readUInt32BE(frame, 2);
+    if (frame.length !== 6 + headerLength + payloadLength) {
+        throw new Error('Stream frame length does not match prefix.');
+    }
+    return {
+        header: frame.slice(6, 6 + headerLength),
+        payload: frame.slice(6 + headerLength)
+    };
+}
+function tryDecodeStreamWireFrame(frame) {
+    if (frame.length < 6) {
+        return undefined;
+    }
+    const headerLength = readUInt16BE(frame, 0);
+    const payloadLength = readUInt32BE(frame, 2);
+    if (frame.length !== 6 + headerLength + payloadLength) {
+        return undefined;
+    }
+    return {
+        header: frame.slice(6, 6 + headerLength),
+        payload: frame.slice(6 + headerLength)
+    };
+}
+function encodeStreamWireHeader(header, flags = defaultHeaderFlags) {
+    const reply = isReplyKind(header.kind);
+    const packetName = reply ? '' : header.name;
+    if (!reply)
+        validateStreamWirePacketName(packetName);
+    const nameBytes = utf8Encode(packetName);
+    const hasRequestSeq = header.requestSeq !== undefined;
+    const hasMetadata = header.metadata.size > 0;
+    const correlationBytes = header.correlationId !== undefined && header.correlationId.length > 0
+        ? utf8Encode(header.correlationId)
+        : undefined;
+    if (correlationBytes !== undefined && correlationBytes.length > 0xff) {
+        throw new Error('Stream correlation id is too large.');
+    }
+    const hasCorrelation = correlationBytes !== undefined;
+    const hasFlow = header.flowId !== undefined || header.flowOrigin !== undefined;
+    if (hasFlow && (header.flowId === undefined || header.flowOrigin === undefined)) {
+        throw new Error('Stream flow id and origin must be provided together.');
+    }
+    if (header.flowId !== undefined)
+        validateFlowId(header.flowId);
+    if (header.flowOrigin !== undefined && ![1, 2, 3, 4].includes(header.flowOrigin)) {
+        throw new Error('Stream flow origin is invalid.');
+    }
+    let headerFlags = header.flags;
+    headerFlags = hasRequestSeq ? headerFlags | flags.hasRequestSeq : headerFlags & ~flags.hasRequestSeq;
+    headerFlags = hasMetadata ? headerFlags | flags.hasMetadata : headerFlags & ~flags.hasMetadata;
+    headerFlags = hasCorrelation ? headerFlags | flags.hasCorrelationId : headerFlags & ~flags.hasCorrelationId;
+    headerFlags = hasFlow ? headerFlags | flags.hasFlowId : headerFlags & ~flags.hasFlowId;
+    const metadataBytes = hasMetadata ? encodeStreamWireMetadata(header.metadata) : new Uint8Array();
+    const size = 4 + (hasRequestSeq ? 8 : 0) + 1 + nameBytes.length
+        + (hasMetadata ? 2 + metadataBytes.length : 0)
+        + (hasCorrelation ? 1 + correlationBytes.length : 0)
+        + (hasFlow ? 37 : 0);
+    const buffer = new Uint8Array(size);
+    let offset = 0;
+    buffer[offset++] = exports.ZLINK_STREAM_FORMAT_MARKER;
+    buffer[offset++] = header.kind;
+    buffer[offset++] = header.codec;
+    buffer[offset++] = headerFlags;
+    if (hasRequestSeq) {
+        if (header.requestSeq === 0n) {
+            throw new Error('Request sequence must not be zero.');
+        }
+        writeBigUInt64BE(buffer, offset, header.requestSeq);
+        offset += 8;
+    }
+    buffer[offset++] = nameBytes.length;
+    buffer.set(nameBytes, offset);
+    offset += nameBytes.length;
+    if (hasMetadata) {
+        writeUInt16BE(buffer, offset, metadataBytes.length);
+        offset += 2;
+        buffer.set(metadataBytes, offset);
+        offset += metadataBytes.length;
+    }
+    if (hasCorrelation) {
+        buffer[offset++] = correlationBytes.length;
+        buffer.set(correlationBytes, offset);
+        offset += correlationBytes.length;
+    }
+    if (hasFlow) {
+        buffer.set(asciiEncode(header.flowId), offset);
+        offset += 36;
+        buffer[offset++] = header.flowOrigin;
+    }
+    return buffer;
+}
+function decodeStreamWireHeader(header, flags = defaultHeaderFlags, includeFlow = true) {
+    let offset = 0;
+    if (header.length < 5) {
+        throw new Error('Stream header is incomplete.');
+    }
+    if (header[offset++] !== exports.ZLINK_STREAM_FORMAT_MARKER) {
+        throw new Error('Stream header format marker is invalid.');
+    }
+    const kind = header[offset++];
+    const codec = header[offset++];
+    const headerFlags = header[offset++];
+    const hasRequestSeq = (headerFlags & flags.hasRequestSeq) !== 0;
+    const hasMetadata = (headerFlags & flags.hasMetadata) !== 0;
+    const hasCorrelation = (headerFlags & flags.hasCorrelationId) !== 0;
+    const hasFlow = (headerFlags & flags.hasFlowId) !== 0;
+    if ((headerFlags & ~0x1f) !== 0) {
+        throw new Error('Unknown mandatory stream header flag.');
+    }
+    let requestSeq;
+    if (hasRequestSeq) {
+        if (header.length - offset < 8) {
+            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;
+    }
+    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) {
+        throw new Error('Stream packet name is invalid.');
+    }
+    const decodedName = utf8Decode(header.subarray(offset, offset + nameLength));
+    const name = isReplyKind(kind) ? '' : decodedName;
+    offset += nameLength;
+    const decodedMetadata = hasMetadata
+        ? decodeStreamWireHeaderMetadata(header, offset)
+        : { metadata: new Map(), offset };
+    offset = decodedMetadata.offset;
+    let correlationId;
+    if (hasCorrelation) {
+        if (header.length - offset < 1) {
+            throw new Error('Stream correlation id is incomplete.');
+        }
+        const correlationLength = header[offset++];
+        if (header.length - offset < correlationLength) {
+            throw new Error('Stream correlation id is incomplete.');
+        }
+        correlationId = utf8Decode(header.subarray(offset, offset + correlationLength));
+        offset += correlationLength;
+    }
+    let flowId;
+    let flowOrigin;
+    if (hasFlow) {
+        if (header.length - offset < 37) {
+            throw new Error('Stream flow fields are incomplete.');
+        }
+        if (includeFlow) {
+            flowId = asciiDecode(header.subarray(offset, offset + 36));
+            validateFlowId(flowId);
+        }
+        offset += 36;
+        const decodedFlowOrigin = header[offset++];
+        if (includeFlow && ![1, 2, 3, 4].includes(decodedFlowOrigin)) {
+            throw new Error('Stream flow origin is invalid.');
+        }
+        flowOrigin = includeFlow ? decodedFlowOrigin : undefined;
+    }
+    if (offset !== header.length) {
+        throw new Error('Stream header has trailing bytes.');
+    }
+    return {
+        kind,
+        codec,
+        flags: headerFlags,
+        requestSeq,
+        name,
+        metadata: decodedMetadata.metadata,
+        correlationId,
+        flowId,
+        flowOrigin
+    };
+}
+function validateFlowId(flowId) {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(flowId)) {
+        throw new Error('Stream flow id must be a lowercase UUIDv7.');
+    }
+}
+function asciiEncode(value) {
+    return Uint8Array.from(value, (character) => character.charCodeAt(0));
+}
+function asciiDecode(value) {
+    if (value.some((byte) => byte > 0x7f))
+        throw new Error('Stream flow id must be ASCII.');
+    return String.fromCharCode(...value);
+}
+function encodeStreamWireMetadata(metadata) {
+    if (metadata.size > 255) {
+        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) {
+            throw new Error('Metadata key length is invalid.');
+        }
+        if (valueBytes.length > 0xffff) {
+            throw new Error('Metadata value is too large.');
+        }
+        size += 1 + keyBytes.length + 2 + valueBytes.length;
+        return { keyBytes, valueBytes };
+    });
+    const buffer = new Uint8Array(size);
+    let offset = 0;
+    buffer[offset++] = metadata.size;
+    for (const { keyBytes, valueBytes } of encoded) {
+        buffer[offset++] = keyBytes.length;
+        buffer.set(keyBytes, offset);
+        offset += keyBytes.length;
+        writeUInt16BE(buffer, offset, valueBytes.length);
+        offset += 2;
+        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 lz4PickleUncompressed(payload) {
+    return (0, lz4_pickle_1.lz4PickleUncompressed)(payload);
+}
+function lz4UnpicklePayload(payload, maxDecompressedSize = lz4_pickle_1.defaultMaxDecompressedPayloadSize) {
+    return (0, lz4_pickle_1.lz4UnpicklePayload)(payload, maxDecompressedSize);
+}
+function utf8Encode(value) {
+    return new TextEncoder().encode(value);
+}
+function utf8Decode(value) {
+    return new TextDecoder().decode(value);
+}
+function decodeStreamWireHeaderMetadata(header, offset) {
+    if (header.length - offset < 2) {
+        throw new Error('Stream metadata section is incomplete.');
+    }
+    const metadataLength = readUInt16BE(header, offset);
+    offset += 2;
+    if (header.length - offset < metadataLength) {
+        throw new Error('Stream metadata payload is incomplete.');
+    }
+    return decodeStreamWireMetadataAt(header, offset, offset + metadataLength);
+}
+function decodeStreamWireMetadataAt(source, offset, end) {
+    if (offset >= end) {
+        throw new Error('Stream metadata entry count is missing.');
+    }
+    const count = source[offset++];
+    const metadata = new Map();
+    for (let index = 0; index < count; index += 1) {
+        if (offset >= end) {
+            throw new Error('Stream metadata key length is missing.');
+        }
+        const keyLength = source[offset++];
+        if (keyLength === 0 || end - offset < keyLength) {
+            throw new Error('Stream metadata key is invalid.');
+        }
+        const key = utf8Decode(source.subarray(offset, offset + keyLength));
+        offset += keyLength;
+        if (end - offset < 2) {
+            throw new Error('Stream metadata value length is missing.');
+        }
+        const valueLength = readUInt16BE(source, offset);
+        offset += 2;
+        if (end - offset < valueLength) {
+            throw new Error('Stream metadata value is incomplete.');
+        }
+        if (metadata.has(key)) {
+            throw new Error('Duplicate metadata key is duplicated.');
+        }
+        metadata.set(key, utf8Decode(source.subarray(offset, offset + valueLength)));
+        offset += valueLength;
+    }
+    if (offset !== end) {
+        throw new Error('Stream metadata payload has trailing bytes.');
+    }
+    return { metadata, offset };
+}
+function validateStreamWirePacketName(name) {
+    const nameBytes = utf8Encode(name);
+    if (name.trim().length === 0 || nameBytes.length > 255) {
+        throw new Error('Stream packet name is invalid.');
+    }
+}
+function isReplyKind(kind) {
+    return kind === ZLINK_STREAM_RESPONSE_KIND || kind === ZLINK_STREAM_ERROR_KIND;
+}
+function writeUInt16BE(buffer, offset, value) {
+    buffer[offset] = (value >>> 8) & 0xff;
+    buffer[offset + 1] = value & 0xff;
+}
+function readUInt16BE(buffer, offset) {
+    return (buffer[offset] << 8) | buffer[offset + 1];
+}
+function readUInt32BE(buffer, offset) {
+    return (buffer[offset] * 0x1000000
+        + ((buffer[offset + 1] << 16) | (buffer[offset + 2] << 8) | buffer[offset + 3]));
+}
+function writeUInt32BE(buffer, offset, value) {
+    buffer[offset] = (value >>> 24) & 0xff;
+    buffer[offset + 1] = (value >>> 16) & 0xff;
+    buffer[offset + 2] = (value >>> 8) & 0xff;
+    buffer[offset + 3] = value & 0xff;
+}
+function writeBigUInt64BE(buffer, offset, value) {
+    for (let index = 7; index >= 0; index -= 1) {
+        buffer[offset + index] = Number(value & 0xffn);
+        value >>= 8n;
+    }
+}
+function readBigUInt64BE(buffer, offset) {
+    let value = 0n;
+    for (let index = 0; index < 8; index += 1) {
+        value = (value << 8n) | BigInt(buffer[offset + index]);
+    }
+    return value;
+}

package/dist/lz4-pickle.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultMaxDecompressedPayloadSize: number;
+export declare function lz4PickleUncompressed(payload: Uint8Array): Uint8Array;
+export declare function lz4UnpicklePayload(payload: Uint8Array, maxDecompressedSize?: number): Uint8Array;

package/dist/lz4-pickle.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMaxDecompressedPayloadSize = void 0;
+exports.lz4PickleUncompressed = lz4PickleUncompressed;
+exports.lz4UnpicklePayload = lz4UnpicklePayload;
+exports.defaultMaxDecompressedPayloadSize = 64 * 1024;
+function lz4PickleUncompressed(payload) {
+    if (payload.length === 0) {
+        return new Uint8Array();
+    }
+    const pickled = new Uint8Array(payload.length + 1);
+    pickled[0] = 0;
+    pickled.set(payload, 1);
+    return pickled;
+}
+function lz4UnpicklePayload(payload, maxDecompressedSize = exports.defaultMaxDecompressedPayloadSize) {
+    if (payload.length === 0) {
+        return new Uint8Array();
+    }
+    const header = payload[0];
+    if ((header & 0x07) !== 0) {
+        throw new Error('Unexpected LZ4 pickle version.');
+    }
+    const sizeOfDiff = decodeDiffSize((header >>> 6) & 0x03);
+    const dataOffset = 1 + sizeOfDiff;
+    if (payload.length < dataOffset) {
+        throw new Error('LZ4 pickle header is incomplete.');
+    }
+    const data = payload.subarray(dataOffset);
+    const resultDiff = sizeOfDiff === 0 ? 0 : readLittleEndian(payload, 1, sizeOfDiff);
+    const resultLength = data.length + resultDiff;
+    if (resultLength > maxDecompressedSize) {
+        throw new Error('LZ4 decoded payload exceeds maximum stream payload size.');
+    }
+    if (resultDiff === 0) {
+        return data.slice();
+    }
+    return decodeLz4Block(data, resultLength);
+}
+function decodeDiffSize(encoded) {
+    return encoded === 3 ? 4 : encoded;
+}
+function readLittleEndian(source, offset, size) {
+    if (size === 1) {
+        return source[offset];
+    }
+    if (size === 2) {
+        return source[offset] | (source[offset + 1] << 8);
+    }
+    if (size === 4) {
+        return (source[offset]
+            | (source[offset + 1] << 8)
+            | (source[offset + 2] << 16)
+            | (source[offset + 3] * 0x1000000));
+    }
+    throw new Error(`Unexpected LZ4 pickle field size: ${size}`);
+}
+function decodeLz4Block(source, resultLength) {
+    const target = new Uint8Array(resultLength);
+    let sourceOffset = 0;
+    let targetOffset = 0;
+    while (sourceOffset < source.length) {
+        const token = source[sourceOffset++];
+        const literalLength = readLz4Length(source, token >>> 4, () => sourceOffset++);
+        if (source.length - sourceOffset < literalLength) {
+            throw new Error('LZ4 literal run is incomplete.');
+        }
+        if (target.length - targetOffset < literalLength) {
+            throw new Error('LZ4 literal run exceeds output size.');
+        }
+        target.set(source.subarray(sourceOffset, sourceOffset + literalLength), targetOffset);
+        sourceOffset += literalLength;
+        targetOffset += literalLength;
+        if (sourceOffset >= source.length) {
+            break;
+        }
+        if (source.length - sourceOffset < 2) {
+            throw new Error('LZ4 match offset is incomplete.');
+        }
+        const matchOffset = source[sourceOffset] | (source[sourceOffset + 1] << 8);
+        sourceOffset += 2;
+        if (matchOffset === 0 || matchOffset > targetOffset) {
+            throw new Error('LZ4 match offset is invalid.');
+        }
+        const matchLength = readLz4Length(source, token & 0x0f, () => sourceOffset++) + 4;
+        if (target.length - targetOffset < matchLength) {
+            throw new Error('LZ4 match run exceeds output size.');
+        }
+        for (let index = 0; index < matchLength; index += 1) {
+            target[targetOffset + index] = target[targetOffset - matchOffset + index];
+        }
+        targetOffset += matchLength;
+    }
+    if (targetOffset !== resultLength) {
+        throw new Error('LZ4 decoded length does not match pickle header.');
+    }
+    return target;
+}
+function readLz4Length(source, nibble, nextOffset) {
+    let length = nibble;
+    if (length !== 15) {
+        return length;
+    }
+    for (;;) {
+        const offset = nextOffset();
+        if (offset >= source.length) {
+            throw new Error('LZ4 extended length is incomplete.');
+        }
+        const value = source[offset];
+        length += value;
+        if (value !== 255) {
+            return length;
+        }
+    }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@zlink-systems/stream-wire",
+  "version": "0.10.0",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/esm",
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/lz4-pickle.js",
+    "dist/lz4-pickle.d.ts",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/esm/index.mjs"
+    }
+  }
+}