@erinjs/core 1.0.0 → 1.2.4

package/core/packages/voice/src/mp4box.d.ts

@@ -1,32 +0,0 @@
-declare module 'mp4box' {
-  export interface MP4File {
-    onReady?: (info: {
-      tracks?: Array<{
-        id: number;
-        type: string;
-        codec: string;
-        video?: { width: number; height: number };
-        timescale?: number;
-      }>;
-    }) => void;
-    onError?: (e: Error) => void;
-    onSamples?: (
-      trackId: number,
-      user: unknown,
-      samples: Array<{
-        data: ArrayBuffer;
-        is_sync?: boolean;
-        is_rap?: boolean;
-        timescale: number;
-        dts: number;
-        duration: number;
-      }>,
-    ) => void;
-    appendBuffer(data: ArrayBuffer): number;
-    flush(): void;
-    setExtractionOptions(trackId: number, user: unknown, options: { nbSamples?: number }): void;
-    start(): void;
-  }
-
-  export function createFile(): MP4File;
-}

package/core/packages/voice/src/opusUtils.test.ts

@@ -1,29 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseOpusPacketBoundaries } from './opusUtils.js';
-
-describe('parseOpusPacketBoundaries', () => {
-  it('returns null for buffer shorter than 2 bytes', () => {
-    expect(parseOpusPacketBoundaries(new Uint8Array([]))).toBeNull();
-    expect(parseOpusPacketBoundaries(new Uint8Array([0]))).toBeNull();
-  });
-
-  it('returns single frame for c=0 (one frame)', () => {
-    const buf = new Uint8Array([0x78, 0x01, 0x02, 0x03]); // c=0
-    const result = parseOpusPacketBoundaries(buf);
-    expect(result).not.toBeNull();
-    expect(result!.frames).toHaveLength(1);
-    expect(result!.consumed).toBe(4);
-  });
-
-  it('returns null for c=1 when not enough data', () => {
-    const buf = new Uint8Array([0x79, 0x05]); // c=1, L1=5, need 2+5+1=8 min
-    expect(parseOpusPacketBoundaries(buf)).toBeNull();
-  });
-
-  it('handles c=2 (two frames CBR)', () => {
-    const buf = new Uint8Array([0x7a, 0x00, 0x01, 0x02, 0x03, 0x04]); // c=2, 4 bytes data -> 2 per frame
-    const result = parseOpusPacketBoundaries(buf);
-    expect(result).not.toBeNull();
-    expect(result!.frames).toHaveLength(2);
-  });
-});

package/core/packages/voice/src/opusUtils.ts

@@ -1,86 +0,0 @@
-/**
- * Shared Opus parsing utilities for voice connections.
- */
-
-/**
- * Parse Opus packet (RFC 6716) and return single-frame packets for decodeFrame().
- * TOC byte: config (0-4), s (5), c (6-7). c=0: 1 frame; c=1: 2 frames + 1 length byte; c=2: 2 frames CBR + padding; c=3: N frames + (N-1) length bytes.
- * Returns { frames: Uint8Array[], consumed } or null if not enough data.
- */
-export function parseOpusPacketBoundaries(
-  buffer: Uint8Array,
-): { frames: Uint8Array[]; consumed: number } | null {
-  if (buffer.length < 2) return null;
-  const toc = buffer[0];
-  const c = toc & 3; // frame count code
-  const tocSingle = (toc & 0xfc) | 0; // same config/s, one frame
-
-  if (c === 0) {
-    return { frames: [buffer.slice()], consumed: buffer.length };
-  }
-
-  if (c === 1) {
-    if (buffer.length < 2) return null;
-    const L1 = buffer[1] + 1;
-    if (buffer.length < 2 + L1) return null;
-    const L2 = buffer.length - 2 - L1;
-    const frame0 = new Uint8Array(1 + L1);
-    frame0[0] = tocSingle;
-    frame0.set(buffer.subarray(2, 2 + L1), 1);
-    const frame1 = new Uint8Array(1 + L2);
-    frame1[0] = tocSingle;
-    frame1.set(buffer.subarray(2 + L1), 1);
-    return { frames: [frame0, frame1], consumed: buffer.length };
-  }
-
-  if (c === 2) {
-    if (buffer.length < 3) return null;
-    const frameLen = Math.floor((buffer.length - 2) / 2);
-    if (frameLen < 1) return null;
-    const frame0 = new Uint8Array(1 + frameLen);
-    frame0[0] = tocSingle;
-    frame0.set(buffer.subarray(2, 2 + frameLen), 1);
-    const frame1 = new Uint8Array(1 + frameLen);
-    frame1[0] = tocSingle;
-    frame1.set(buffer.subarray(2 + frameLen, 2 + 2 * frameLen), 1);
-    return { frames: [frame0, frame1], consumed: 2 + 2 * frameLen };
-  }
-
-  if (c === 3) {
-    if (buffer.length < 2) return null;
-    const N = buffer[1];
-    if (N < 1 || N > 255) return null;
-    const numLengthBytes = N - 1;
-    if (buffer.length < 2 + numLengthBytes) return null;
-    const lengths: number[] = [];
-    for (let i = 0; i < numLengthBytes; i++) {
-      lengths.push(buffer[2 + i] + 1);
-    }
-    const headerLen = 2 + numLengthBytes;
-    let offset = headerLen;
-    const sumKnown = lengths.reduce((a, b) => a + b, 0);
-    const lastLen = buffer.length - headerLen - sumKnown;
-    if (lastLen < 0) return null;
-    lengths.push(lastLen);
-    const frames: Uint8Array[] = [];
-    for (let i = 0; i < lengths.length; i++) {
-      const L = lengths[i];
-      if (offset + L > buffer.length) return null;
-      const frame = new Uint8Array(1 + L);
-      frame[0] = tocSingle;
-      frame.set(buffer.subarray(offset, offset + L), 1);
-      frames.push(frame);
-      offset += L;
-    }
-    return { frames, consumed: offset };
-  }
-
-  return null;
-}
-
-export function concatUint8Arrays(a: Uint8Array, b: Uint8Array): Uint8Array {
-  const out = new Uint8Array(a.length + b.length);
-  out.set(a);
-  out.set(b, a.length);
-  return out;
-}

package/core/packages/voice/src/streamPreviewPlaceholder.test.ts

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { thumbnail } from './streamPreviewPlaceholder.js';
-
-describe('streamPreviewPlaceholder', () => {
-  it('exports valid base64 string', () => {
-    expect(typeof thumbnail).toBe('string');
-    expect(thumbnail.length).toBeGreaterThan(0);
-  });
-
-  it('decodes to valid PNG header', () => {
-    const decoded = Buffer.from(thumbnail, 'base64');
-    expect(decoded[0]).toBe(0x89);
-    expect(decoded[1]).toBe(0x50);
-    expect(decoded[2]).toBe(0x4e);
-  });
-});

package/core/packages/voice/src/streamPreviewPlaceholder.ts

@@ -1,8 +0,0 @@
-/**
- * Minimal 1x1 grey PNG as base64 for stream preview placeholder.
- * Used when uploading preview before actual frames are available.
- */
-const MINIMAL_PNG_BASE64 =
-  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
-
-export const thumbnail = MINIMAL_PNG_BASE64;

package/core/packages/voice/src/ws.d.ts

@@ -1 +0,0 @@
-declare module 'ws';

package/core/packages/voice/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": { "outDir": "./dist", "rootDir": "./src", "noEmit": false },
-  "include": ["src/**/*"]
-}

package/core/packages/voice/tsup.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['cjs', 'esm'],
-  dts: true,
-  splitting: false,
-  clean: true,
-  external: ['node-webcodecs'],
-});

package/core/packages/voice/vitest.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-});

package/core/packages/ws/package.json

@@ -1,52 +0,0 @@
-{
-  "name": "@erinjs/ws",
-  "publishConfig": {
-    "access": "public"
-  },
-  "version": "1.2.4",
-  "description": "WebSocket manager for the Fluxer Gateway",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/blstmo-abandoned-us-for-the-milk/core.git",
-    "directory": "packages/ws"
-  },
-  "bugs": "https://github.com/blstmo-abandoned-us-for-the-milk/core/issues",
-  "homepage": "https://github.com/blstmo-abandoned-us-for-the-milk/core#readme",
-  "keywords": [
-    "fluxer",
-    "websocket",
-    "gateway",
-    "sdk"
-  ],
-  "license": "Apache-2.0",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "clean": "rm -rf dist",
-    "lint": "eslint src --max-warnings 0 --config ../../eslint.config.js",
-    "lint:fix": "eslint src --fix --config ../../eslint.config.js",
-    "test": "vitest run --passWithNoTests",
-    "test:coverage": "vitest run --coverage --passWithNoTests"
-  },
-  "dependencies": {
-    "@erinjs/types": "workspace:*",
-    "ws": "^8.18.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "tsup": "^8.3.0",
-    "typescript": "^5.6.0"
-  }
-}

package/core/packages/ws/src/WebSocketManager.ts

@@ -1,130 +0,0 @@
-import { EventEmitter } from 'events';
-import { APIGatewayBotResponse, GatewayPresenceUpdateData } from '@erinjs/types';
-import { WebSocketShard } from './WebSocketShard.js';
-import { getDefaultWebSocket } from './utils/getWebSocket.js';
-
-import { WebSocketConstructor as WSConstructor } from './WebSocketShard';
-
-export type WebSocketConstructor = WSConstructor;
-
-const RETRY_INITIAL_MS = 1000;
-const RETRY_MAX_MS = 45000;
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export interface WebSocketManagerOptions {
-  token: string;
-  intents: number;
-  rest: { get: (route: string) => Promise<unknown> };
-  version?: string;
-  presence?: GatewayPresenceUpdateData;
-  shardIds?: number[];
-  shardCount?: number;
-  WebSocket?: WebSocketConstructor;
-}
-
-export class WebSocketManager extends EventEmitter {
-  private readonly options: WebSocketManagerOptions;
-  private shards = new Map<number, WebSocketShard>();
-  private gatewayUrl: string | null = null;
-  private shardCount = 1;
-  private _aborted = false;
-
-  constructor(options: WebSocketManagerOptions) {
-    super();
-    this.options = options;
-  }
-
-  async connect(): Promise<void> {
-    this._aborted = false;
-
-    let WS = this.options.WebSocket;
-    let delayMs = RETRY_INITIAL_MS;
-
-    if (!WS) {
-      while (!this._aborted) {
-        try {
-          WS = await getDefaultWebSocket();
-          break;
-        } catch (err) {
-          const e = err instanceof Error ? err : new Error(String(err));
-          this.emit('error', { shardId: -1, error: e });
-          await sleep(delayMs);
-          delayMs = Math.min(RETRY_MAX_MS, Math.floor(delayMs * 1.5));
-        }
-      }
-      if (this._aborted) throw new Error('Connection aborted');
-      if (!WS) throw new Error('Failed to load WebSocket');
-    }
-
-    let gateway: APIGatewayBotResponse | null = null;
-    while (!this._aborted) {
-      try {
-        gateway = (await this.options.rest.get('/gateway/bot')) as APIGatewayBotResponse;
-        break;
-      } catch (err) {
-        const e = err instanceof Error ? err : new Error(String(err));
-        this.emit('error', { shardId: -1, error: e });
-        await sleep(delayMs);
-        delayMs = Math.min(RETRY_MAX_MS, Math.floor(delayMs * 1.5));
-      }
-    }
-
-    if (this._aborted) throw new Error('Connection aborted');
-    if (!gateway) throw new Error('Failed to fetch gateway');
-
-    this.gatewayUrl = gateway.url;
-    this.shardCount = this.options.shardCount ?? gateway.shards;
-
-    const ids = this.options.shardIds ?? [...Array(this.shardCount).keys()];
-
-    const version = this.options.version ?? '1';
-
-    for (const id of ids) {
-      const shard = new WebSocketShard({
-        url: this.gatewayUrl ?? gateway.url,
-        token: this.options.token,
-        intents: this.options.intents,
-        presence: this.options.presence,
-        shardId: id,
-        numShards: this.shardCount,
-        version,
-        WebSocket: WS,
-      });
-
-      shard.on('ready', (data) => this.emit('ready', { shardId: id, data }));
-      shard.on('resumed', () => this.emit('resumed', id));
-      shard.on('dispatch', (payload) => this.emit('dispatch', { shardId: id, payload }));
-      shard.on('close', (code) => this.emit('close', { shardId: id, code }));
-      shard.on('error', (err) => this.emit('error', { shardId: id, error: err }));
-      shard.on('debug', (msg) => this.emit('debug', msg));
-
-      this.shards.set(id, shard);
-      try {
-        shard.connect();
-      } catch (err) {
-        this.emit('error', {
-          shardId: id,
-          error: err instanceof Error ? err : new Error(String(err)),
-        });
-      }
-    }
-  }
-
-  send(shardId: number, payload: Parameters<WebSocketShard['send']>[0]): void {
-    this.shards.get(shardId)?.send(payload);
-  }
-
-  destroy(): void {
-    this._aborted = true;
-    for (const shard of this.shards.values()) shard.destroy();
-    this.shards.clear();
-    this.gatewayUrl = null;
-  }
-
-  getShardCount(): number {
-    return this.shardCount;
-  }
-}

package/core/packages/ws/src/WebSocketShard.ts

@@ -1,296 +0,0 @@
-import { EventEmitter } from 'events';
-import {
-  GatewaySendPayload,
-  GatewayHelloData,
-  GatewayReceivePayload,
-  GatewayIdentifyData,
-  GatewayResumeData,
-  GatewayPresenceUpdateData,
-} from '@erinjs/types';
-import { GatewayOpcodes } from '@erinjs/types';
-import { getDefaultWebSocketSync } from './utils/getWebSocket.js';
-
-export type WebSocketLike = {
-  send(data: string | ArrayBufferLike): void;
-  close(code?: number): void;
-  readyState: number;
-  addEventListener?(type: string, listener: (e: unknown) => void): void;
-  on?(event: string, cb: (data?: unknown) => void): void;
-};
-export type WebSocketConstructor = new (url: string) => WebSocketLike;
-
-export interface WebSocketShardOptions {
-  url: string;
-  token: string;
-  intents: number;
-  presence?: GatewayPresenceUpdateData;
-  shardId: number;
-  numShards: number;
-  /** Gateway API version (e.g. "1" for Fluxer). Defaults to "1" when not set. */
-  version?: string;
-  WebSocket?: WebSocketConstructor;
-}
-
-export interface WebSocketShardEvents {
-  ready: [payload: unknown];
-  resumed: [];
-  dispatch: [payload: GatewayReceivePayload];
-  close: [code: number];
-  error: [error: Error];
-  debug: [message: string];
-}
-
-const RECONNECT_INITIAL_MS = 1000;
-const RECONNECT_MAX_MS = 45000;
-
-export class WebSocketShard extends EventEmitter {
-  private ws: WebSocketLike | null = null;
-  private readonly options: WebSocketShardOptions;
-  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
-  private heartbeatAt = 0;
-  /** True until we send a heartbeat; then false until we get HeartbeatAck. Avoids closing before first heartbeat. */
-  private lastHeartbeatAck = true;
-  private sessionId: string | null = null;
-  private seq: number | null = null;
-  private destroying = false;
-  private readonly url: string;
-  private readonly WS: WebSocketConstructor;
-  /** Current reconnect delay in ms; resets on successful connect. */
-  private reconnectDelayMs = RECONNECT_INITIAL_MS;
-  private reconnectTimeout: ReturnType<typeof setTimeout> | null = null;
-
-  private scheduleReconnect(): void {
-    if (this.destroying) return;
-    if (this.reconnectTimeout !== null) return;
-    const delay = Math.min(RECONNECT_MAX_MS, this.reconnectDelayMs * (0.75 + Math.random() * 0.5));
-    this.reconnectDelayMs = Math.min(RECONNECT_MAX_MS, this.reconnectDelayMs * 1.5);
-    this.debug(`Reconnecting in ${Math.round(delay)}ms…`);
-    this.reconnectTimeout = setTimeout(() => {
-      this.reconnectTimeout = null;
-      this.connect();
-    }, delay);
-  }
-
-  constructor(options: WebSocketShardOptions) {
-    super();
-    this.options = options;
-    this.WS = options.WebSocket ?? (getDefaultWebSocketSync() as unknown as WebSocketConstructor);
-    const version = options.version ?? '1';
-    const params = new URLSearchParams({ v: version, encoding: 'json' });
-    this.url = `${options.url}?${params}`;
-  }
-
-  get id(): number {
-    return this.options.shardId;
-  }
-
-  get status(): number {
-    if (!this.ws) return 0; // Idle
-    switch (this.ws.readyState) {
-      case 0:
-        return 1; // Connecting
-      case 1:
-        return 2; // Ready
-      case 2:
-        return 3; // Closing
-      case 3:
-        return 0;
-      default:
-        return 0;
-    }
-  }
-
-  connect(): void {
-    if (this.ws?.readyState === 1) return;
-    this.destroying = false;
-    this.debug('Connecting');
-    const ws = new this.WS(this.url);
-    this.ws = ws;
-
-    const handleMessage = (data: string | Buffer) => {
-      try {
-        const str = typeof data === 'string' ? data : (data as Buffer).toString();
-        this.handlePayload(JSON.parse(str) as GatewayReceivePayload);
-      } catch (err) {
-        this.emit('error', err instanceof Error ? err : new Error(String(err)));
-      }
-    };
-
-    const handleClose = (code: number) => {
-      this.ws = null;
-      this.stopHeartbeat();
-      this.emit('close', code);
-      this.debug(`Closed: ${code}`);
-      if (!this.destroying && shouldReconnectOnClose(code)) {
-        this.scheduleReconnect();
-      }
-    };
-
-    const handleError = (err?: unknown) => {
-      const error = err instanceof Error ? err : new Error('WebSocket error');
-      this.emit('error', error);
-      if (!this.destroying && this.ws) {
-        this.ws = null;
-        this.stopHeartbeat();
-        this.debug('Connection error; will retry…');
-        this.scheduleReconnect();
-      }
-    };
-
-    const handleOpen = () => {
-      this.debug('Socket open');
-      this.reconnectDelayMs = RECONNECT_INITIAL_MS;
-    };
-
-    if (typeof ws.addEventListener === 'function') {
-      ws.addEventListener('open', handleOpen);
-      ws.addEventListener('message', (e: unknown) =>
-        handleMessage((e as MessageEvent).data as string),
-      );
-      ws.addEventListener('close', (e: unknown) => handleClose((e as CloseEvent).code));
-      ws.addEventListener('error', () => handleError(new Error('WebSocket error')));
-    } else if (typeof ws.on === 'function') {
-      ws.on('open', handleOpen);
-      ws.on('message', (d: unknown) => handleMessage(d as Buffer | string));
-      ws.on('close', (code?: unknown) => handleClose((code as number) ?? 1006));
-      ws.on('error', (err?: unknown) => handleError(err));
-    }
-  }
-
-  private debug(message: string): void {
-    this.emit('debug', `[Shard ${this.id}] ${message}`);
-  }
-
-  private handlePayload(payload: GatewayReceivePayload): void {
-    switch (payload.op) {
-      case GatewayOpcodes.Hello:
-        this.handleHello(payload.d as GatewayHelloData);
-        break;
-      case GatewayOpcodes.HeartbeatAck:
-        this.lastHeartbeatAck = true;
-        break;
-      case GatewayOpcodes.Dispatch:
-        if (payload.t === 'READY') {
-          const d = payload.d as { session_id: string };
-          this.sessionId = d.session_id;
-          this.reconnectDelayMs = RECONNECT_INITIAL_MS;
-          this.emit('ready', payload.d);
-        } else if (payload.t === 'RESUMED') {
-          this.reconnectDelayMs = RECONNECT_INITIAL_MS;
-          this.emit('resumed');
-        }
-        if (payload.s !== undefined) this.seq = payload.s;
-        this.emit('dispatch', payload);
-        break;
-      case GatewayOpcodes.InvalidSession:
-        this.debug(`Invalid session (d=${payload.d}), reconnecting`);
-        this.sessionId = null;
-        this.seq = null;
-        this.ws?.close(1000);
-        // Let handleClose() own reconnect scheduling for this close.
-        break;
-      case GatewayOpcodes.Reconnect:
-        this.debug('Reconnect requested');
-        this.ws?.close(1000);
-        setTimeout(() => this.connect(), 100);
-        break;
-      default:
-        break;
-    }
-  }
-
-  private handleHello(data: GatewayHelloData): void {
-    const jitter = Math.random() * data.heartbeat_interval;
-    this.heartbeatAt = Date.now() + jitter;
-    this.startHeartbeat(data.heartbeat_interval);
-
-    if (this.sessionId && this.seq !== null) {
-      this.send({
-        op: GatewayOpcodes.Resume,
-        d: {
-          token: this.options.token,
-          session_id: this.sessionId,
-          seq: this.seq,
-        } as GatewayResumeData,
-      });
-    } else {
-      const identify: GatewayIdentifyData = {
-        token: this.options.token,
-        intents: this.options.intents,
-        properties: {
-          os: process.platform ?? 'unknown',
-          browser: 'erin.js',
-          device: 'erin.js',
-        },
-      };
-      if (this.options.presence) identify.presence = this.options.presence;
-      this.send({ op: GatewayOpcodes.Identify, d: identify });
-    }
-  }
-
-  private startHeartbeat(interval: number): void {
-    this.stopHeartbeat();
-    this.lastHeartbeatAck = true; // no heartbeat sent yet → don't treat as missed ack
-    this.heartbeatInterval = setInterval(() => {
-      if (!this.lastHeartbeatAck && this.seq !== null) {
-        this.debug('Heartbeat ack missed; reconnecting');
-        this.ws?.close(1000);
-        if (!this.destroying) this.scheduleReconnect();
-        return;
-      }
-      this.lastHeartbeatAck = false;
-      this.send({ op: GatewayOpcodes.Heartbeat, d: this.seq ?? null });
-    }, interval);
-  }
-
-  private stopHeartbeat(): void {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-  }
-
-  send(payload: GatewaySendPayload): void {
-    if (this.ws?.readyState !== 1) return;
-    this.ws.send(JSON.stringify(payload));
-  }
-
-  destroy(): void {
-    this.destroying = true;
-    if (this.reconnectTimeout) {
-      clearTimeout(this.reconnectTimeout);
-      this.reconnectTimeout = null;
-    }
-    this.stopHeartbeat();
-    this.ws?.close(1000);
-    this.ws = null;
-    this.sessionId = null;
-    this.seq = null;
-  }
-}
-
-/** Close codes after which we should reconnect (normal closure, server ask, or transient/network issues). */
-function shouldReconnectOnClose(code: number): boolean {
-  switch (code) {
-    case 1000: // Normal Closure (server may close with this to ask for reconnect)
-    case 1001: // Going Away
-    case 1011: // Internal Error (server hit unexpected condition; often transient)
-    case 1005: // No Status Received
-    case 1006: // Abnormal Closure (network drop, server crash)
-    case 1012: // Service Restart
-    case 1013: // Try Again Later
-    case 1014: // Bad Gateway
-    case 1015: // TLS Handshake Failed
-      return true;
-    case 4000: // Unknown error
-    case 4007: // Invalid seq
-    case 4009: // Session timeout
-    case 4010: // Invalid shard
-    case 4011: // Sharding required
-    case 4012: // Invalid API version (after fix, reconnect is safe)
-    case 4013: // Ack backpressure (server event buffer full; transient, safe to retry)
-      return true;
-    default:
-      return false;
-  }
-}