@quake2ts/shared 0.0.1

package/src/bsp/contents.ts

@@ -0,0 +1,108 @@
+/**
+ * Bitflag constants mirroring the Quake II rerelease `contents_t` and
+ * `surfflags_t` enumerations from `game.h`. The helpers here operate purely on
+ * numeric bitmasks so both the authoritative game simulation and the client can
+ * share the same semantic checks.
+ */
+export type ContentsFlag = number;
+export type SurfaceFlag = number;
+
+export const CONTENTS_NONE: ContentsFlag = 0;
+export const CONTENTS_SOLID: ContentsFlag = 1 << 0;
+export const CONTENTS_WINDOW: ContentsFlag = 1 << 1;
+export const CONTENTS_AUX: ContentsFlag = 1 << 2;
+export const CONTENTS_LAVA: ContentsFlag = 1 << 3;
+export const CONTENTS_SLIME: ContentsFlag = 1 << 4;
+export const CONTENTS_WATER: ContentsFlag = 1 << 5;
+export const CONTENTS_MIST: ContentsFlag = 1 << 6;
+export const CONTENTS_TRIGGER: ContentsFlag = 0x40000000;
+export const CONTENTS_NO_WATERJUMP: ContentsFlag = 1 << 13;
+export const CONTENTS_PROJECTILECLIP: ContentsFlag = 1 << 14;
+export const CONTENTS_AREAPORTAL: ContentsFlag = 1 << 15;
+export const CONTENTS_PLAYERCLIP: ContentsFlag = 1 << 16;
+export const CONTENTS_MONSTERCLIP: ContentsFlag = 1 << 17;
+export const CONTENTS_CURRENT_0: ContentsFlag = 1 << 18;
+export const CONTENTS_CURRENT_90: ContentsFlag = 1 << 19;
+export const CONTENTS_CURRENT_180: ContentsFlag = 1 << 20;
+export const CONTENTS_CURRENT_270: ContentsFlag = 1 << 21;
+export const CONTENTS_CURRENT_UP: ContentsFlag = 1 << 22;
+export const CONTENTS_CURRENT_DOWN: ContentsFlag = 1 << 23;
+export const CONTENTS_ORIGIN: ContentsFlag = 1 << 24;
+export const CONTENTS_MONSTER: ContentsFlag = 1 << 25;
+export const CONTENTS_DEADMONSTER: ContentsFlag = 1 << 26;
+export const CONTENTS_DETAIL: ContentsFlag = 1 << 27;
+export const CONTENTS_TRANSLUCENT: ContentsFlag = 1 << 28;
+export const CONTENTS_LADDER: ContentsFlag = 1 << 29;
+export const CONTENTS_PLAYER: ContentsFlag = 1 << 30;
+export const CONTENTS_PROJECTILE: ContentsFlag = 1 << 31;
+
+export const LAST_VISIBLE_CONTENTS: ContentsFlag = CONTENTS_MIST;
+
+export const SURF_NONE: SurfaceFlag = 0;
+export const SURF_LIGHT: SurfaceFlag = 1 << 0;
+export const SURF_SLICK: SurfaceFlag = 1 << 1;
+export const SURF_SKY: SurfaceFlag = 1 << 2;
+export const SURF_WARP: SurfaceFlag = 1 << 3;
+export const SURF_TRANS33: SurfaceFlag = 1 << 4;
+export const SURF_TRANS66: SurfaceFlag = 1 << 5;
+export const SURF_FLOWING: SurfaceFlag = 1 << 6;
+export const SURF_NODRAW: SurfaceFlag = 1 << 7;
+export const SURF_ALPHATEST: SurfaceFlag = 1 << 25;
+export const SURF_N64_UV: SurfaceFlag = 1 << 28;
+export const SURF_N64_SCROLL_X: SurfaceFlag = 1 << 29;
+export const SURF_N64_SCROLL_Y: SurfaceFlag = 1 << 30;
+export const SURF_N64_SCROLL_FLIP: SurfaceFlag = 1 << 31;
+
+export const MASK_ALL: ContentsFlag = 0xffffffff;
+export const MASK_SOLID: ContentsFlag = CONTENTS_SOLID | CONTENTS_WINDOW;
+export const MASK_PLAYERSOLID: ContentsFlag =
+  CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+export const MASK_DEADSOLID: ContentsFlag = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+export const MASK_MONSTERSOLID: ContentsFlag =
+  CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+export const MASK_WATER: ContentsFlag = CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME;
+export const MASK_OPAQUE: ContentsFlag = CONTENTS_SOLID | CONTENTS_SLIME | CONTENTS_LAVA;
+export const MASK_SHOT: ContentsFlag =
+  CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_WINDOW | CONTENTS_DEADMONSTER;
+export const MASK_CURRENT: ContentsFlag =
+  CONTENTS_CURRENT_0 |
+  CONTENTS_CURRENT_90 |
+  CONTENTS_CURRENT_180 |
+  CONTENTS_CURRENT_270 |
+  CONTENTS_CURRENT_UP |
+  CONTENTS_CURRENT_DOWN;
+export const MASK_BLOCK_SIGHT: ContentsFlag =
+  CONTENTS_SOLID | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_MONSTER | CONTENTS_PLAYER;
+export const MASK_NAV_SOLID: ContentsFlag = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+export const MASK_LADDER_NAV_SOLID: ContentsFlag = CONTENTS_SOLID | CONTENTS_WINDOW;
+export const MASK_WALK_NAV_SOLID: ContentsFlag =
+  CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTERCLIP;
+export const MASK_PROJECTILE: ContentsFlag = MASK_SHOT | CONTENTS_PROJECTILECLIP;
+
+export function hasAllContents(mask: ContentsFlag, flags: ContentsFlag): boolean {
+  return (mask & flags) === flags;
+}
+
+export function hasAnyContents(mask: ContentsFlag, flags: ContentsFlag): boolean {
+  return (mask & flags) !== 0;
+}
+
+export function addContents(mask: ContentsFlag, flags: ContentsFlag): ContentsFlag {
+  return mask | flags;
+}
+
+export function removeContents(mask: ContentsFlag, flags: ContentsFlag): ContentsFlag {
+  return mask & ~flags;
+}
+
+export function hasSurfaceFlags(surface: SurfaceFlag, flags: SurfaceFlag): boolean {
+  return (surface & flags) === flags;
+}
+
+export function combineSurfaceFlags(...flags: SurfaceFlag[]): SurfaceFlag {
+  let mask = SURF_NONE;
+  for (const flag of flags) {
+    mask |= flag;
+  }
+  return mask;
+}

package/src/bsp/spatial.ts

@@ -0,0 +1,116 @@
+import type { Vec3 } from '../math/vec3.js';
+
+export const AREA_DEPTH = 4;
+export const WORLD_SIZE = 8192; // Standard Q2 world extent
+
+export interface SpatialNode {
+  axis: number; // 0=X, 1=Y, -1=Leaf
+  dist: number;
+  children: [SpatialNode, SpatialNode] | null;
+  items: Set<number>;
+}
+
+export function createSpatialTree(
+  depth = 0,
+  mins: Vec3 = { x: -WORLD_SIZE, y: -WORLD_SIZE, z: -WORLD_SIZE },
+  maxs: Vec3 = { x: WORLD_SIZE, y: WORLD_SIZE, z: WORLD_SIZE }
+): SpatialNode {
+  if (depth >= AREA_DEPTH) {
+    return {
+      axis: -1,
+      dist: 0,
+      children: null,
+      items: new Set(),
+    };
+  }
+
+  const axis = depth % 2; // Alternates X (0) and Y (1)
+  const dist = 0.5 * (axis === 0 ? mins.x + maxs.x : mins.y + maxs.y);
+
+  const mins1 = { ...mins };
+  const maxs1 = { ...maxs };
+  const mins2 = { ...mins };
+  const maxs2 = { ...maxs };
+
+  if (axis === 0) {
+    maxs1.x = dist;
+    mins2.x = dist;
+  } else {
+    maxs1.y = dist;
+    mins2.y = dist;
+  }
+
+  const child1 = createSpatialTree(depth + 1, mins1, maxs1);
+  const child2 = createSpatialTree(depth + 1, mins2, maxs2);
+
+  return {
+    axis,
+    dist,
+    children: [child1, child2],
+    items: new Set(),
+  };
+}
+
+export function linkEntityToSpatialTree(
+  node: SpatialNode,
+  id: number,
+  absmin: Vec3,
+  absmax: Vec3
+): SpatialNode {
+  let current = node;
+
+  while (current.axis !== -1 && current.children) {
+    const axis = current.axis;
+    const dist = current.dist;
+
+    const min = axis === 0 ? absmin.x : absmin.y;
+    const max = axis === 0 ? absmax.x : absmax.y;
+
+    if (min > dist) {
+      current = current.children[1];
+    } else if (max < dist) {
+      current = current.children[0];
+    } else {
+      break; // Straddles the plane, resides in this node
+    }
+  }
+
+  current.items.add(id);
+  return current;
+}
+
+export function querySpatialTree(
+  node: SpatialNode,
+  absmin: Vec3,
+  absmax: Vec3,
+  results: Set<number>
+): void {
+  // Add all items in the current node (because if we are here, we overlap this node's space
+  // and straddling items definitely overlap us or are at least in the parent region)
+  // Actually, strictly speaking, items in this node straddle the split plane.
+  // Since we are traversing down, we are within the node's volume.
+  // The items in this node are those that couldn't be pushed further down.
+  // So we must check them.
+
+  // NOTE: This collects candidates. Precise collision check still needed.
+  for (const id of node.items) {
+    results.add(id);
+  }
+
+  if (node.axis === -1 || !node.children) {
+    return;
+  }
+
+  const axis = node.axis;
+  const dist = node.dist;
+
+  const min = axis === 0 ? absmin.x : absmin.y;
+  const max = axis === 0 ? absmax.x : absmax.y;
+
+  if (max > dist) {
+    querySpatialTree(node.children[1], absmin, absmax, results);
+  }
+  if (min < dist) {
+    querySpatialTree(node.children[0], absmin, absmax, results);
+  }
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+export * from './math/vec3.js';
+export * from './math/angles.js';
+export * from './math/anorms.js';
+export * from './math/color.js';
+export * from './math/random.js';
+export * from './math/mat4.js';
+export * from './bsp/contents.js';
+export * from './bsp/collision.js';
+export * from './protocol/cvar.js';
+export * from './protocol/configstrings.js';
+export * as Replay from './replay/index.js';
+export * from './protocol/contracts.js';
+export * from './pmove/types.js';
+export * from './pmove/constants.js';
+export * from './pmove/pmove.js';
+export * from './pmove/slide.js';
+export * from './pmove/stuck.js';
+export * from './pmove/currents.js';
+export * from './pmove/fly.js';
+export * from './pmove/water.js';
+export * from './pmove/jump.js';
+export * from './pmove/dimensions.js';
+export * from './pmove/duck.js';
+export * from './pmove/categorize.js';
+export * from './pmove/move.js';
+export * from './pmove/special.js';
+export * from './pmove/snap.js';
+export * from './pmove/view.js';
+export * from './protocol/index.js';
+export * from './protocol/entityState.js';
+export * from './pmove/apply.js';
+export * from './io/index.js';
+export * from './net/index.js';
+export * from './items/index.js';
+export * from './audio/constants.js';
+export * from './inventory-helpers.js';
+export * from './testing.js';

package/src/inventory-helpers.ts

@@ -0,0 +1,81 @@
+import { PlayerState } from './protocol/index.js';
+import { AmmoItemId, AmmoType, WeaponId } from './items/index.js';
+import { G_GetAmmoStat } from './protocol/stats.js';
+import { WEAPON_AMMO_MAP } from './items/index.js';
+import { ConfigStringIndex } from './protocol/configstrings.js';
+
+// Blaster uses no ammo in standard Q2.
+// We handle mapping `AmmoItemId` (string) to `AmmoType` (enum).
+export const AMMO_ITEM_MAP: Record<AmmoItemId, AmmoType> = {
+  [AmmoItemId.Shells]: AmmoType.Shells,
+  [AmmoItemId.Bullets]: AmmoType.Bullets,
+  [AmmoItemId.Rockets]: AmmoType.Rockets,
+  [AmmoItemId.Grenades]: AmmoType.Grenades,
+  [AmmoItemId.Cells]: AmmoType.Cells,
+  [AmmoItemId.Slugs]: AmmoType.Slugs,
+  [AmmoItemId.MagSlugs]: AmmoType.MagSlugs,
+  [AmmoItemId.Flechettes]: AmmoType.Flechettes,
+  [AmmoItemId.Disruptor]: AmmoType.Disruptor,
+  [AmmoItemId.Tesla]: AmmoType.Tesla,
+  [AmmoItemId.Trap]: AmmoType.Trap,
+  [AmmoItemId.Prox]: AmmoType.Prox,
+};
+
+/**
+ * Retrieves the ammo count for a given item (Weapon or Ammo).
+ * @param playerState The current player state.
+ * @param item The item identifier (WeaponId or AmmoItemId).
+ * @returns The ammo count, or 0 if not found/applicable. Returns -1 for infinite ammo (e.g. Blaster).
+ */
+export function getAmmoCount(playerState: PlayerState, item: WeaponId | AmmoItemId): number {
+  let ammoType: AmmoType | null | undefined;
+
+  // Check if it's an Ammo Item ID
+  if (Object.values(AmmoItemId).includes(item as AmmoItemId)) {
+    ammoType = AMMO_ITEM_MAP[item as AmmoItemId];
+  }
+  // Check if it's a Weapon ID
+  else if (Object.values(WeaponId).includes(item as WeaponId)) {
+    ammoType = WEAPON_AMMO_MAP[item as WeaponId];
+
+    // Existing map has null for Blaster, Grapple, etc.
+    if (ammoType === null) {
+        return -1;
+    }
+  }
+
+  if (ammoType === undefined || ammoType === null) {
+    return 0;
+  }
+
+  return G_GetAmmoStat(playerState.stats, ammoType);
+}
+
+/**
+ * Resolves the icon path for a given stat index (e.g. STAT_SELECTED_ICON).
+ * @param statIndex The index in the stats array to read (e.g. PlayerStat.STAT_SELECTED_ICON).
+ * @param playerState The player state containing the stats.
+ * @param configStrings The array of configuration strings (from client state).
+ * @returns The path to the icon image, or undefined if invalid.
+ */
+export function getIconPath(
+  statIndex: number,
+  playerState: PlayerState,
+  configStrings: string[]
+): string | undefined {
+  const iconIndex = playerState.stats[statIndex];
+
+  // 0 usually means no icon or null
+  if (iconIndex === undefined || iconIndex <= 0) {
+    return undefined;
+  }
+
+  // The value in the stat is the index into the Config Strings relative to ConfigStringIndex.Images.
+  const configIndex = ConfigStringIndex.Images + iconIndex;
+
+  if (configIndex < 0 || configIndex >= configStrings.length) {
+    return undefined;
+  }
+
+  return configStrings[configIndex];
+}

package/src/io/binaryStream.ts

@@ -0,0 +1,159 @@
+import { Vec3 } from '../math/vec3.js';
+import { ANORMS } from '../math/anorms.js';
+
+export class BinaryStream {
+  private view: DataView;
+  private offset: number;
+  private length: number;
+
+  constructor(buffer: ArrayBuffer | Uint8Array) {
+    if (buffer instanceof Uint8Array) {
+      this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    } else {
+      this.view = new DataView(buffer);
+    }
+    this.offset = 0;
+    this.length = this.view.byteLength;
+  }
+
+  public getPosition(): number {
+    return this.offset;
+  }
+
+  public getReadPosition(): number {
+    return this.offset;
+  }
+
+  public getLength(): number {
+    return this.length;
+  }
+
+  public getRemaining(): number {
+    return this.length - this.offset;
+  }
+
+  public seek(position: number): void {
+    if (position < 0 || position > this.length) {
+      throw new Error(`Seek out of bounds: ${position} (length: ${this.length})`);
+    }
+    this.offset = position;
+  }
+
+  public setReadPosition(position: number): void {
+    this.seek(position);
+  }
+
+  public hasMore(): boolean {
+    return this.offset < this.length;
+  }
+
+  public hasBytes(count: number): boolean {
+    return this.offset + count <= this.length;
+  }
+
+  public readChar(): number {
+    const value = this.view.getInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+
+  public readByte(): number {
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+
+  public readShort(): number {
+    const value = this.view.getInt16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+
+  public readUShort(): number {
+    const value = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+
+  public readLong(): number {
+    const value = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+
+  public readULong(): number {
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+
+  public readFloat(): number {
+    const value = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+
+  public readString(): string {
+    let str = '';
+    while (this.offset < this.length) {
+      const charCode = this.readChar();
+      if (charCode === -1 || charCode === 0) {
+        break;
+      }
+      str += String.fromCharCode(charCode);
+    }
+    return str;
+  }
+
+  public readStringLine(): string {
+    let str = '';
+    while (this.offset < this.length) {
+      const charCode = this.readChar();
+      if (charCode === -1 || charCode === 0 || charCode === 10) { // 10 is \n
+        break;
+      }
+      str += String.fromCharCode(charCode);
+    }
+    return str;
+  }
+
+  public readCoord(): number {
+    return this.readShort() * (1.0 / 8.0);
+  }
+
+  public readAngle(): number {
+    return this.readChar() * (360.0 / 256.0);
+  }
+
+  public readAngle16(): number {
+    return (this.readShort() * 360.0) / 65536.0;
+  }
+
+  public readData(length: number): Uint8Array {
+    if (this.offset + length > this.length) {
+       throw new Error(`Read out of bounds: ${this.offset + length} (length: ${this.length})`);
+    }
+    const data = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length);
+    this.offset += length;
+    // Return a copy to avoid side effects if the original buffer is modified or reused
+    return new Uint8Array(data);
+  }
+
+  public readPos(out: { x: number, y: number, z: number }): void {
+    out.x = this.readCoord();
+    out.y = this.readCoord();
+    out.z = this.readCoord();
+  }
+
+  public readDir(out: { x: number, y: number, z: number }): void {
+    const b = this.readByte();
+    if (b >= 162) { // NUMVERTEXNORMALS
+      out.x = 0; out.y = 0; out.z = 0;
+      return;
+    }
+    const norm = ANORMS[b];
+    out.x = norm[0];
+    out.y = norm[1];
+    out.z = norm[2];
+  }
+}

package/src/io/binaryWriter.ts

@@ -0,0 +1,146 @@
+import { ANORMS } from '../math/anorms.js';
+import { Vec3 } from '../math/vec3.js';
+
+export class BinaryWriter {
+  private buffer: Uint8Array;
+  private view: DataView;
+  private offset: number;
+  private readonly fixed: boolean;
+
+  constructor(sizeOrBuffer: number | Uint8Array = 1400) {
+    if (typeof sizeOrBuffer === 'number') {
+      this.buffer = new Uint8Array(sizeOrBuffer);
+      this.fixed = false;
+    } else {
+      this.buffer = sizeOrBuffer;
+      this.fixed = true;
+    }
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    this.offset = 0;
+  }
+
+  private ensureSpace(bytes: number) {
+    if (this.offset + bytes > this.buffer.byteLength) {
+      if (this.fixed) {
+        throw new Error(`Buffer overflow: capacity ${this.buffer.byteLength}, needed ${this.offset + bytes}`);
+      }
+      // Expand buffer (double size)
+      const newSize = Math.max(this.buffer.byteLength * 2, this.offset + bytes);
+      const newBuffer = new Uint8Array(newSize);
+      newBuffer.set(this.buffer);
+      this.buffer = newBuffer;
+      this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    }
+  }
+
+  public writeByte(value: number): void {
+    this.ensureSpace(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+
+  public writeBytes(data: Uint8Array): void {
+      this.ensureSpace(data.byteLength);
+      this.buffer.set(data, this.offset);
+      this.offset += data.byteLength;
+  }
+
+  public writeChar(value: number): void {
+    this.ensureSpace(1);
+    this.view.setInt8(this.offset, value);
+    this.offset += 1;
+  }
+
+  public writeShort(value: number): void {
+    this.ensureSpace(2);
+    // Use setUint16 to allow writing 0xFFFF as a valid pattern even if it represents -1
+    // But value might be negative (-1). setUint16(-1) wraps to 65535.
+    // So setInt16 is fine if value is in range.
+    // If value is 65535 (from bit manipulation), setInt16 might throw?
+    // Let's safe cast.
+    this.view.setInt16(this.offset, value, true);
+    this.offset += 2;
+  }
+
+  public writeLong(value: number): void {
+    this.ensureSpace(4);
+    this.view.setInt32(this.offset, value, true);
+    this.offset += 4;
+  }
+
+  public writeFloat(value: number): void {
+    this.ensureSpace(4);
+    this.view.setFloat32(this.offset, value, true);
+    this.offset += 4;
+  }
+
+  public writeString(value: string): void {
+    // UTF-8 encoding of string + null terminator
+    // We iterate manually to match readString behavior (ASCII/Latin1 mostly)
+    // and avoid TextEncoder overhead if simple
+    const len = value.length;
+    this.ensureSpace(len + 1);
+    for (let i = 0; i < len; i++) {
+      this.view.setUint8(this.offset + i, value.charCodeAt(i));
+    }
+    this.view.setUint8(this.offset + len, 0);
+    this.offset += len + 1;
+  }
+
+  public writeCoord(value: number): void {
+    this.writeShort(Math.trunc(value * 8));
+  }
+
+  public writeAngle(value: number): void {
+    this.writeByte(Math.trunc(value * 256.0 / 360.0) & 255);
+  }
+
+  public writeAngle16(value: number): void {
+    this.writeShort(Math.trunc(value * 65536.0 / 360.0) & 65535);
+  }
+
+  public writePos(pos: Vec3): void {
+    this.writeCoord(pos.x);
+    this.writeCoord(pos.y);
+    this.writeCoord(pos.z);
+  }
+
+  public writeDir(dir: Vec3): void {
+      // Find closest normal
+      let maxDot = -1.0;
+      let bestIndex = 0;
+
+      // Check for zero vector
+      if (dir.x === 0 && dir.y === 0 && dir.z === 0) {
+        this.writeByte(0);
+        return;
+      }
+
+      for (let i = 0; i < ANORMS.length; i++) {
+        const norm = ANORMS[i];
+        const dot = dir.x * norm[0] + dir.y * norm[1] + dir.z * norm[2];
+        if (dot > maxDot) {
+          maxDot = dot;
+          bestIndex = i;
+        }
+      }
+
+      this.writeByte(bestIndex);
+  }
+
+  public getData(): Uint8Array {
+      return this.buffer.slice(0, this.offset);
+  }
+
+  public getBuffer(): Uint8Array {
+      return this.buffer;
+  }
+
+  public getOffset(): number {
+      return this.offset;
+  }
+
+  public reset(): void {
+      this.offset = 0;
+  }
+}

package/src/io/index.ts

@@ -0,0 +1,3 @@
+export * from './binaryStream.js';
+export * from './binaryWriter.js';
+export * from './messageBuilder.js';