@bruch/max-client 0.1.0

package/src/formatting/markdown.ts

@@ -0,0 +1,123 @@
+export interface TextElement {
+  type: string;
+  from: number;
+  length: number;
+  attributes?: { url?: string };
+}
+
+const markers = new Map([
+  ["```", "CODE"],
+  ["**", "STRONG"],
+  ["__", "UNDERLINE"],
+  ["~~", "STRIKETHROUGH"],
+  ["`", "MONOSPACED"],
+  ["_", "EMPHASIZED"],
+  ["*", "EMPHASIZED"],
+]);
+
+export function formatMarkdown(text: string): { text: string; elements: TextElement[] } {
+  let clean = "";
+  let index = 0;
+  let cleanPosition = 0;
+  let lineStart = true;
+  const active = new Map<string, number>();
+  const elements: TextElement[] = [];
+
+  while (index < text.length) {
+    const link = parseLink(text, index);
+    if (link) {
+      const length = utf16Length(link.label);
+      elements.push({ type: "LINK", from: cleanPosition, length, attributes: { url: link.url } });
+      clean += link.label;
+      cleanPosition += length;
+      index = link.next;
+      lineStart = false;
+      continue;
+    }
+
+    const current = text[index] as string;
+    if (lineStart && (current === "#" || current === ">")) {
+      const result = parseLineEntity(text, index, current === "#" ? "HEADING" : "QUOTE");
+      if (result) {
+        clean += result.value;
+        const length = utf16Length(result.value);
+        elements.push({ type: result.type, from: cleanPosition, length });
+        cleanPosition += length;
+        index = result.next;
+        lineStart = false;
+        continue;
+      }
+    }
+
+    let handled = false;
+    for (const [marker, type] of markers) {
+      if (!text.startsWith(marker, index)) continue;
+      const open = active.get(marker);
+      if (open === undefined) {
+        const closing = text.indexOf(marker, index + marker.length);
+        const newline = text.indexOf("\n", index + marker.length);
+        if (
+          closing <= index + marker.length ||
+          (marker !== "```" && newline !== -1 && closing > newline)
+        ) {
+          clean += marker;
+          cleanPosition += utf16Length(marker);
+        } else {
+          active.set(marker, cleanPosition);
+        }
+      } else {
+        const length = cleanPosition - open;
+        if (length > 0) elements.push({ type, from: open, length });
+        active.delete(marker);
+      }
+      index += marker.length;
+      handled = true;
+      break;
+    }
+    if (handled) {
+      lineStart = false;
+      continue;
+    }
+
+    clean += current;
+    cleanPosition += utf16Length(current);
+    index += 1;
+    lineStart = current === "\n";
+  }
+  return { text: clean, elements };
+}
+
+function parseLink(
+  text: string,
+  index: number,
+): { label: string; url: string; next: number } | null {
+  if (text[index] !== "[") return null;
+  const labelEnd = text.indexOf("]", index + 1);
+  if (labelEnd < 0 || text[labelEnd + 1] !== "(") return null;
+  const urlEnd = text.indexOf(")", labelEnd + 2);
+  if (urlEnd < 0) return null;
+  const label = text.slice(index + 1, labelEnd);
+  const url = text.slice(labelEnd + 2, urlEnd);
+  return label && url ? { label, url, next: urlEnd + 1 } : null;
+}
+
+function parseLineEntity(
+  text: string,
+  index: number,
+  type: "HEADING" | "QUOTE",
+): { type: string; value: string; next: number } | null {
+  let contentStart = index + 1;
+  if (type === "HEADING") {
+    while (text[contentStart] === "#") contentStart += 1;
+    if (text[contentStart] !== " ") return null;
+  }
+  if (text[contentStart] === " ") contentStart += 1;
+  const newline = text.indexOf("\n", contentStart);
+  const next = newline < 0 ? text.length : newline;
+  const value = text.slice(contentStart, next);
+  return value ? { type, value, next } : null;
+}
+
+function utf16Length(value: string): number {
+  return value.length;
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export const VERSION = "0.1.0";
+
+export * from "./api/index.ts";
+export * from "./auth/index.ts";
+export * from "./client.ts";
+export * from "./config.ts";
+export * from "./dispatch/index.ts";
+export * from "./errors.ts";
+export * from "./files/index.ts";
+export * from "./formatting/index.ts";
+export * from "./logging.ts";
+export * from "./protocol/index.ts";
+export * from "./session/index.ts";
+export * from "./telemetry/index.ts";
+export * from "./types/index.ts";

package/src/logging.ts

@@ -0,0 +1,67 @@
+export type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR" | "SILENT";
+
+export interface Logger {
+  debug(message: string, context?: Record<string, unknown>): void;
+  info(message: string, context?: Record<string, unknown>): void;
+  warn(message: string, context?: Record<string, unknown>): void;
+  error(message: string, context?: Record<string, unknown>): void;
+}
+
+const priorities: Record<LogLevel, number> = {
+  DEBUG: 10,
+  INFO: 20,
+  WARN: 30,
+  ERROR: 40,
+  SILENT: 100,
+};
+
+class ConsoleLogger implements Logger {
+  constructor(private readonly level: LogLevel) {}
+
+  debug(message: string, context?: Record<string, unknown>): void {
+    this.write("DEBUG", message, context);
+  }
+  info(message: string, context?: Record<string, unknown>): void {
+    this.write("INFO", message, context);
+  }
+  warn(message: string, context?: Record<string, unknown>): void {
+    this.write("WARN", message, context);
+  }
+  error(message: string, context?: Record<string, unknown>): void {
+    this.write("ERROR", message, context);
+  }
+
+  private write(
+    level: Exclude<LogLevel, "SILENT">,
+    message: string,
+    context?: Record<string, unknown>,
+  ): void {
+    if (priorities[level] < priorities[this.level]) return;
+    const suffix = context ? ` ${JSON.stringify(redact(context))}` : "";
+    const line = `[tsmax] ${level.toLowerCase()} ${message}${suffix}`;
+    if (level === "ERROR") console.error(line);
+    else if (level === "WARN") console.warn(line);
+    else console.log(line);
+  }
+}
+
+let activeLogger: Logger = new ConsoleLogger("INFO");
+
+export function configureLogging(level: LogLevel = "INFO", logger?: Logger): Logger {
+  activeLogger = logger ?? new ConsoleLogger(level);
+  return activeLogger;
+}
+
+export function getLogger(): Logger {
+  return activeLogger;
+}
+
+function redact(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(redact);
+  if (value === null || typeof value !== "object") return value;
+  const result: Record<string, unknown> = {};
+  for (const [key, item] of Object.entries(value)) {
+    result[key] = /token|password|phone|code/i.test(key) ? "[redacted]" : redact(item);
+  }
+  return result;
+}

package/src/protocol/compression.ts

@@ -0,0 +1,69 @@
+const DEFAULT_MAX_OUTPUT = 5 * 1024 * 1024;
+
+export class Lz4BlockCompression {
+  decompress(source: Uint8Array, maxOutput = DEFAULT_MAX_OUTPUT): Uint8Array {
+    const output: number[] = [];
+    let position = 0;
+
+    while (position < source.length) {
+      const token = source[position++];
+      if (token === undefined) break;
+
+      let literalLength = token >>> 4;
+      if (literalLength === 15) {
+        while (position < source.length) {
+          const byte = source[position++];
+          if (byte === undefined) break;
+          literalLength += byte;
+          if (byte !== 255) break;
+        }
+      }
+
+      if (position + literalLength > source.length) {
+        throw new RangeError("LZ4: literal length out of bounds");
+      }
+      for (let index = 0; index < literalLength; index += 1) {
+        output.push(source[position + index] as number);
+      }
+      position += literalLength;
+      this.ensureSize(output.length, maxOutput);
+      if (position >= source.length) break;
+
+      if (position + 1 >= source.length) throw new RangeError("LZ4: incomplete offset");
+      const offset = (source[position] as number) | ((source[position + 1] as number) << 8);
+      position += 2;
+      if (offset === 0) throw new RangeError("LZ4: zero offset");
+
+      let matchLength = (token & 0x0f) + 4;
+      if ((token & 0x0f) === 0x0f) {
+        while (position < source.length) {
+          const byte = source[position++];
+          if (byte === undefined) break;
+          matchLength += byte;
+          if (byte !== 255) break;
+        }
+      }
+
+      const matchPosition = output.length - offset;
+      if (matchPosition < 0) throw new RangeError("LZ4: match out of bounds");
+      for (let index = 0; index < matchLength; index += 1) {
+        output.push(output[matchPosition + (index % offset)] as number);
+      }
+      this.ensureSize(output.length, maxOutput);
+    }
+
+    return Uint8Array.from(output);
+  }
+
+  private ensureSize(size: number, maximum: number): void {
+    if (size > maximum) throw new RangeError("LZ4: output too large");
+  }
+}
+
+export class ZstdCompression {
+  decompress(source: Uint8Array, maxOutput = DEFAULT_MAX_OUTPUT): Uint8Array {
+    const output = Bun.zstdDecompressSync(source);
+    if (output.byteLength > maxOutput) throw new RangeError("Zstd: output too large");
+    return output;
+  }
+}

package/src/protocol/enums.ts

@@ -0,0 +1,175 @@
+export const Command = {
+  REQUEST: 0,
+  RESPONSE: 1,
+  EVENT: 2,
+  ERROR: 3,
+} as const;
+export type Command = (typeof Command)[keyof typeof Command];
+
+export const Opcode = {
+  PING: 1,
+  DEBUG: 2,
+  RECONNECT: 3,
+  LOG: 5,
+  SESSION_INIT: 6,
+  PROFILE: 16,
+  AUTH_REQUEST: 17,
+  AUTH: 18,
+  LOGIN: 19,
+  LOGOUT: 20,
+  SYNC: 21,
+  CONFIG: 22,
+  AUTH_CONFIRM: 23,
+  PRESET_AVATARS: 25,
+  ASSETS_GET: 26,
+  ASSETS_UPDATE: 27,
+  ASSETS_GET_BY_IDS: 28,
+  ASSETS_ADD: 29,
+  SEARCH_FEEDBACK: 31,
+  CONTACT_INFO: 32,
+  CONTACT_ADD: 33,
+  CONTACT_UPDATE: 34,
+  CONTACT_PRESENCE: 35,
+  CONTACT_LIST: 36,
+  CONTACT_SEARCH: 37,
+  CONTACT_MUTUAL: 38,
+  CONTACT_PHOTOS: 39,
+  CONTACT_SORT: 40,
+  CONTACT_VERIFY: 42,
+  REMOVE_CONTACT_PHOTO: 43,
+  CONTACT_INFO_BY_PHONE: 46,
+  CHAT_INFO: 48,
+  CHAT_HISTORY: 49,
+  CHAT_MARK: 50,
+  CHAT_MEDIA: 51,
+  CHAT_DELETE: 52,
+  CHATS_LIST: 53,
+  CHAT_CLEAR: 54,
+  CHAT_UPDATE: 55,
+  CHAT_CHECK_LINK: 56,
+  CHAT_JOIN: 57,
+  CHAT_LEAVE: 58,
+  CHAT_MEMBERS: 59,
+  PUBLIC_SEARCH: 60,
+  CHAT_PERSONAL_CONFIG: 61,
+  CHAT_LIVESTREAM_INFO: 62,
+  CHAT_CREATE: 63,
+  MSG_SEND: 64,
+  MSG_TYPING: 65,
+  MSG_DELETE: 66,
+  MSG_EDIT: 67,
+  CHAT_SEARCH: 68,
+  MSG_SHARE_PREVIEW: 70,
+  MSG_GET: 71,
+  MSG_SEARCH_TOUCH: 72,
+  MSG_SEARCH: 73,
+  MSG_GET_STAT: 74,
+  CHAT_SUBSCRIBE: 75,
+  VIDEO_CHAT_START: 76,
+  CHAT_MEMBERS_UPDATE: 77,
+  VIDEO_CHAT_START_ACTIVE: 78,
+  VIDEO_CHAT_HISTORY: 79,
+  PHOTO_UPLOAD: 80,
+  STICKER_UPLOAD: 81,
+  VIDEO_UPLOAD: 82,
+  VIDEO_PLAY: 83,
+  VIDEO_CHAT_CREATE_JOIN_LINK: 84,
+  CHAT_PIN_SET_VISIBILITY: 86,
+  FILE_UPLOAD: 87,
+  FILE_DOWNLOAD: 88,
+  LINK_INFO: 89,
+  MSG_DELETE_RANGE: 92,
+  SESSIONS_INFO: 96,
+  SESSIONS_CLOSE: 97,
+  PHONE_BIND_REQUEST: 98,
+  PHONE_BIND_CONFIRM: 99,
+  AUTH_LOGIN_RESTORE_PASSWORD: 101,
+  GET_INBOUND_CALLS: 103,
+  AUTH_2FA_DETAILS: 104,
+  EXTERNAL_CALLBACK: 105,
+  AUTH_VALIDATE_PASSWORD: 107,
+  AUTH_VALIDATE_HINT: 108,
+  AUTH_VERIFY_EMAIL: 109,
+  AUTH_CHECK_EMAIL: 110,
+  AUTH_SET_2FA: 111,
+  AUTH_CREATE_TRACK: 112,
+  AUTH_CHECK_PASSWORD: 113,
+  AUTH_LOGIN_CHECK_PASSWORD: 115,
+  AUTH_LOGIN_PROFILE_DELETE: 116,
+  CHAT_COMPLAIN: 117,
+  MSG_SEND_CALLBACK: 118,
+  SUSPEND_BOT: 119,
+  LOCATION_STOP: 124,
+  LOCATION_SEND: 125,
+  LOCATION_REQUEST: 126,
+  GET_LAST_MENTIONS: 127,
+  NOTIF_MESSAGE: 128,
+  NOTIF_TYPING: 129,
+  NOTIF_MARK: 130,
+  NOTIF_CONTACT: 131,
+  NOTIF_PRESENCE: 132,
+  NOTIF_CONFIG: 134,
+  NOTIF_CHAT: 135,
+  NOTIF_ATTACH: 136,
+  NOTIF_CALL_START: 137,
+  NOTIF_CONTACT_SORT: 139,
+  NOTIF_MSG_DELETE_RANGE: 140,
+  NOTIF_MSG_DELETE: 142,
+  NOTIF_CALLBACK_ANSWER: 143,
+  CHAT_BOT_COMMANDS: 144,
+  BOT_INFO: 145,
+  NOTIF_LOCATION: 147,
+  NOTIF_LOCATION_REQUEST: 148,
+  NOTIF_ASSETS_UPDATE: 150,
+  NOTIF_DRAFT: 152,
+  NOTIF_DRAFT_DISCARD: 153,
+  NOTIF_MSG_DELAYED: 154,
+  NOTIF_MSG_REACTIONS_CHANGED: 155,
+  NOTIF_MSG_YOU_REACTED: 156,
+  CALLS_TOKEN: 158,
+  NOTIF_PROFILE: 159,
+  WEB_APP_INIT_DATA: 160,
+  COMPLAIN: 161,
+  COMPLAIN_REASONS_GET: 162,
+  VIDEO_CHAT_JOIN: 166,
+  DRAFT_SAVE: 176,
+  DRAFT_DISCARD: 177,
+  MSG_REACTION: 178,
+  MSG_CANCEL_REACTION: 179,
+  MSG_GET_REACTIONS: 180,
+  MSG_GET_DETAILED_REACTIONS: 181,
+  STICKER_CREATE: 193,
+  STICKER_SUGGEST: 194,
+  VIDEO_CHAT_MEMBERS: 195,
+  CHAT_HIDE: 196,
+  CHAT_SEARCH_COMMON_PARTICIPANTS: 198,
+  PROFILE_DELETE: 199,
+  PROFILE_DELETE_TIME: 200,
+  TRANSCRIBE_MEDIA: 202,
+  ORG_INFO: 256,
+  CHAT_REACTIONS_SETTINGS_SET: 257,
+  REACTIONS_SETTINGS_GET_BY_CHAT_ID: 258,
+  ASSETS_REMOVE: 259,
+  ASSETS_MOVE: 260,
+  ASSETS_LIST_MODIFY: 261,
+  FOLDERS_GET: 272,
+  FOLDERS_GET_BY_ID: 273,
+  FOLDERS_UPDATE: 274,
+  FOLDERS_REORDER: 275,
+  FOLDERS_DELETE: 276,
+  NOTIF_FOLDERS: 277,
+  GET_QR: 288,
+  GET_QR_STATUS: 289,
+  AUTH_QR_APPROVE: 290,
+  LOGIN_BY_QR: 291,
+  NOTIF_BANNERS: 292,
+  NOTIF_TRANSCRIPTION: 293,
+  CHAT_SUGGEST: 300,
+  AUDIO_PLAY: 301,
+  BANNERS_GET: 302,
+  MSG_DELIVERY: 303,
+  SEND_VOTE: 304,
+  VOTERS_LIST_BY_ANSWER: 305,
+  GET_POLL_UPDATES: 306,
+} as const;
+export type Opcode = (typeof Opcode)[keyof typeof Opcode];

package/src/protocol/index.ts

@@ -0,0 +1,5 @@
+export * from "./compression.ts";
+export * from "./enums.ts";
+export * from "./tcp.ts";
+export * from "./types.ts";
+export * from "./websocket.ts";

package/src/protocol/tcp.ts

@@ -0,0 +1,139 @@
+import { decode, encode } from "@msgpack/msgpack";
+
+import { Lz4BlockCompression, ZstdCompression } from "./compression.ts";
+import type { InboundFrame, OutboundFrame, PackedPacket, Payload, Protocol } from "./types.ts";
+
+export const TCP_HEADER_SIZE = 10;
+
+export class TcpPacketFramer {
+  pack(options: {
+    ver: number;
+    cmd: number;
+    seq: number;
+    opcode: number;
+    flags: number;
+    payloadBytes: Uint8Array;
+  }): Uint8Array {
+    if (options.payloadBytes.byteLength > 0x00ff_ffff) {
+      throw new RangeError("TCP payload exceeds the 24-bit length field");
+    }
+    const result = new Uint8Array(TCP_HEADER_SIZE + options.payloadBytes.byteLength);
+    const view = new DataView(result.buffer);
+    view.setUint8(0, options.ver);
+    view.setUint8(1, options.cmd);
+    view.setUint16(2, options.seq, false);
+    view.setUint16(4, options.opcode, false);
+    const packedLength = ((options.flags & 0xff) << 24) | options.payloadBytes.byteLength;
+    view.setUint32(6, packedLength >>> 0, false);
+    result.set(options.payloadBytes, TCP_HEADER_SIZE);
+    return result;
+  }
+
+  unpack(data: Uint8Array): PackedPacket | null {
+    if (data.byteLength < TCP_HEADER_SIZE) return null;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const packedLength = view.getUint32(6, false);
+    const payloadLength = packedLength & 0x00ff_ffff;
+    if (data.byteLength < TCP_HEADER_SIZE + payloadLength) return null;
+    return {
+      header: {
+        ver: view.getUint8(0),
+        cmd: view.getUint8(1),
+        seq: view.getUint16(2, false),
+        opcode: view.getUint16(4, false),
+        flags: packedLength >>> 24,
+        payloadLength,
+      },
+      payloadBytes: data.slice(TCP_HEADER_SIZE, TCP_HEADER_SIZE + payloadLength),
+    };
+  }
+
+  unpackPayloadLength(data: Uint8Array): number | null {
+    if (data.byteLength < TCP_HEADER_SIZE) return null;
+    return (
+      new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(6, false) & 0x00ff_ffff
+    );
+  }
+}
+
+export class MsgpackPayloadCodec {
+  encode(payload: unknown): Uint8Array {
+    if (payload === null || payload === undefined) return new Uint8Array();
+    return encode(payload, { useBigInt64: true, ignoreUndefined: true });
+  }
+
+  decode(payload: Uint8Array): Payload {
+    if (payload.byteLength === 0) return {};
+    return normalizeKeys(decode(payload, { useBigInt64: true })) as Payload;
+  }
+}
+
+export class TcpPayloadDecoder {
+  constructor(
+    private readonly serializer = new MsgpackPayloadCodec(),
+    private readonly lz4 = new Lz4BlockCompression(),
+    private readonly zstd = new ZstdCompression(),
+  ) {}
+
+  decode(payload: Uint8Array, flags = 0): Payload {
+    if (payload.byteLength === 0) return {};
+    let decoded = payload;
+    if (flags === 0xff) decoded = this.zstd.decompress(payload);
+    else if (flags > 0x7f) throw new RangeError(`Invalid TCP compression factor: ${flags}`);
+    else if (flags > 0) decoded = this.lz4.decompress(payload);
+    return this.serializer.decode(decoded);
+  }
+}
+
+export class TcpProtocol implements Protocol<Uint8Array> {
+  readonly version = 10;
+  readonly framer = new TcpPacketFramer();
+  readonly serializer = new MsgpackPayloadCodec();
+  readonly payloadDecoder = new TcpPayloadDecoder(this.serializer);
+
+  encode(frame: OutboundFrame): Uint8Array {
+    const payloadBytes = this.serializer.encode(frame.payload);
+    return this.framer.pack({
+      ver: this.version,
+      cmd: frame.cmd ?? 0,
+      seq: frame.seq,
+      opcode: frame.opcode,
+      flags: 0,
+      payloadBytes,
+    });
+  }
+
+  decode(raw: Uint8Array): InboundFrame {
+    const packet = this.framer.unpack(raw);
+    if (!packet) return { opcode: 0, cmd: 0, seq: null, payload: null, raw: null };
+    const payload = this.payloadDecoder.decode(packet.payloadBytes, packet.header.flags);
+    return {
+      opcode: packet.header.opcode,
+      cmd: packet.header.cmd,
+      seq: packet.header.seq,
+      payload,
+      raw: payload,
+    };
+  }
+}
+
+function normalizeKeys(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(normalizeKeys);
+  if (value instanceof Map) {
+    const result: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (const [key, item] of value) result[normalizeKey(key)] = normalizeKeys(item);
+    return result;
+  }
+  if (value !== null && typeof value === "object" && !(value instanceof Uint8Array)) {
+    const result: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (const [key, item] of Object.entries(value))
+      result[normalizeKey(key)] = normalizeKeys(item);
+    return result;
+  }
+  return value;
+}
+
+function normalizeKey(value: unknown): string {
+  if (value instanceof Uint8Array) return new TextDecoder().decode(value);
+  return String(value);
+}

package/src/protocol/types.ts

@@ -0,0 +1,45 @@
+export type WirePrimitive = null | boolean | number | bigint | string | Uint8Array;
+export type WireValue =
+  | WirePrimitive
+  | WireValue[]
+  | { readonly [key: string]: WireValue }
+  | ReadonlyMap<WirePrimitive, WireValue>;
+
+export type Payload = Record<string, unknown>;
+
+export interface OutboundFrame {
+  readonly ver: number;
+  readonly opcode: number;
+  readonly cmd?: number;
+  readonly seq: number;
+  readonly payload?: Payload | null;
+  readonly compress?: boolean;
+}
+
+export interface InboundFrame {
+  readonly opcode: number;
+  readonly cmd: number;
+  readonly seq: number | null;
+  readonly payload: Payload | null;
+  readonly raw: Payload | null;
+}
+
+export interface TcpPacketHeader {
+  readonly ver: number;
+  readonly cmd: number;
+  readonly seq: number;
+  readonly opcode: number;
+  readonly flags: number;
+  readonly payloadLength: number;
+}
+
+export interface PackedPacket {
+  readonly header: TcpPacketHeader;
+  readonly payloadBytes: Uint8Array;
+}
+
+export interface Protocol<Encoded extends string | Uint8Array = string | Uint8Array> {
+  readonly version: number;
+  encode(frame: OutboundFrame): Encoded;
+  decode(raw: Encoded): InboundFrame;
+}

package/src/protocol/websocket.ts

@@ -0,0 +1,47 @@
+import { isInteger, isSafeNumber, parse, stringify } from "lossless-json";
+
+import type { InboundFrame, OutboundFrame, Payload, Protocol } from "./types.ts";
+
+export class WsProtocol implements Protocol<string> {
+  readonly version = 11;
+
+  encode(frame: OutboundFrame): string {
+    return stringify({ ...frame, cmd: frame.cmd ?? 0, ver: this.version }) as string;
+  }
+
+  decode(raw: string): InboundFrame {
+    try {
+      const value = parse(raw, undefined, {
+        parseNumber: (text) => {
+          if (isInteger(text) && !isSafeNumber(text)) return BigInt(text);
+          return Number(text);
+        },
+      });
+      if (!isRecord(value)) return emptyFrame();
+      const opcode = safeHeaderNumber(value.opcode);
+      const cmd = safeHeaderNumber(value.cmd ?? 0);
+      const seq =
+        value.seq === null || value.seq === undefined ? null : safeHeaderNumber(value.seq);
+      const payload = isRecord(value.payload) ? value.payload : null;
+      return { opcode, cmd, seq, payload, raw: payload };
+    } catch {
+      return emptyFrame();
+    }
+  }
+}
+
+function safeHeaderNumber(value: unknown): number {
+  const result = typeof value === "bigint" ? Number(value) : value;
+  if (typeof result !== "number" || !Number.isSafeInteger(result)) {
+    throw new TypeError("Invalid WebSocket frame header");
+  }
+  return result;
+}
+
+function isRecord(value: unknown): value is Payload {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function emptyFrame(): InboundFrame {
+  return { opcode: 0, cmd: 0, seq: null, payload: null, raw: null };
+}

package/src/session/index.ts

@@ -0,0 +1,2 @@
+export * from "./store.ts";
+export * from "./types.ts";