@ekmanss/5eplay 20260716.0.0

package/dist/mqtt.js

@@ -0,0 +1,285 @@
+import { FiveEPlayError } from './errors.js';
+import { record, text } from './value.js';
+const BROKER_URL = 'wss://post-cn-7mz2e5hc90i.mqtt.aliyuncs.com/:443/mqtt';
+const CREDENTIAL_URL = 'https://www.5eplay.com/api/restrict/matchscore';
+function concatBytes(parts) {
+    const total = parts.reduce((sum, part) => sum + part.byteLength, 0);
+    const output = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        output.set(part, offset);
+        offset += part.byteLength;
+    }
+    return output;
+}
+function mqttString(value) {
+    const encoded = new TextEncoder().encode(value);
+    if (encoded.byteLength > 65_535)
+        throw new Error('MQTT string is too long');
+    return concatBytes([
+        Uint8Array.of(encoded.byteLength >> 8, encoded.byteLength & 0xff),
+        encoded,
+    ]);
+}
+function remainingLength(value) {
+    const bytes = [];
+    let remaining = value;
+    do {
+        let digit = remaining % 128;
+        remaining = Math.floor(remaining / 128);
+        if (remaining > 0)
+            digit |= 0x80;
+        bytes.push(digit);
+    } while (remaining > 0);
+    return Uint8Array.from(bytes);
+}
+function packet(header, body) {
+    return concatBytes([Uint8Array.of(header), remainingLength(body.byteLength), body]);
+}
+export function encodeConnectPacket(credentials, keepAliveSeconds = 30) {
+    const variableHeader = concatBytes([
+        mqttString('MQTT'),
+        Uint8Array.of(4, 0xc2, keepAliveSeconds >> 8, keepAliveSeconds & 0xff),
+    ]);
+    const payload = concatBytes([
+        mqttString(credentials.clientId),
+        mqttString(credentials.username),
+        mqttString(credentials.password),
+    ]);
+    return packet(0x10, concatBytes([variableHeader, payload]));
+}
+export function encodeSubscribePacket(topic, packetId = 1) {
+    return packet(0x82, concatBytes([
+        Uint8Array.of(packetId >> 8, packetId & 0xff),
+        mqttString(topic),
+        Uint8Array.of(0),
+    ]));
+}
+export function decodeMqttPackets(bytes) {
+    const packets = [];
+    let offset = 0;
+    while (offset < bytes.byteLength) {
+        const first = bytes[offset++];
+        if (first === undefined)
+            break;
+        let multiplier = 1;
+        let length = 0;
+        let digit;
+        do {
+            digit = bytes[offset++] ?? 0;
+            length += (digit & 0x7f) * multiplier;
+            multiplier *= 128;
+            if (multiplier > 128 * 128 * 128 * 128)
+                throw new Error('invalid MQTT remaining length');
+        } while ((digit & 0x80) !== 0);
+        const end = offset + length;
+        if (end > bytes.byteLength)
+            throw new Error('incomplete MQTT packet');
+        const type = first >> 4;
+        const flags = first & 0x0f;
+        let payload = bytes.subarray(offset, end);
+        let topic;
+        if (type === 3) {
+            const topicLength = (payload[0] ?? 0) * 256 + (payload[1] ?? 0);
+            const topicEnd = 2 + topicLength;
+            if (topicEnd > payload.byteLength)
+                throw new Error('invalid MQTT topic length');
+            topic = new TextDecoder().decode(payload.subarray(2, topicEnd));
+            const qos = (flags >> 1) & 0x03;
+            payload = payload.subarray(topicEnd + (qos > 0 ? 2 : 0));
+        }
+        packets.push({ type, flags, payload, ...(topic === undefined ? {} : { topic }) });
+        offset = end;
+    }
+    return packets;
+}
+async function eventBytes(data) {
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (ArrayBuffer.isView(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    if (data instanceof Blob)
+        return new Uint8Array(await data.arrayBuffer());
+    if (typeof data === 'string')
+        return new TextEncoder().encode(data);
+    throw new Error('unsupported WebSocket message type');
+}
+function defaultWebSocketFactory(url, protocols) {
+    if (typeof globalThis.WebSocket !== 'function') {
+        throw new FiveEPlayError('global WebSocket is unavailable; Node.js 22 or newer is required', {
+            code: 'REALTIME_CONNECTION_FAILED', operation: 'match-realtime',
+            stage: 'connecting-realtime', retryable: false,
+        });
+    }
+    return new globalThis.WebSocket(url, protocols);
+}
+async function credentialsFor(fetchImpl, signal, topic) {
+    let response;
+    try {
+        response = await fetchImpl(CREDENTIAL_URL, {
+            method: 'POST',
+            signal,
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ topic }),
+        });
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw signal.reason;
+        throw new FiveEPlayError('could not obtain 5EPlay realtime credentials', {
+            code: 'REALTIME_CONNECTION_FAILED', operation: 'match-realtime',
+            stage: 'connecting-realtime', retryable: true, cause: error,
+        });
+    }
+    if (!response.ok) {
+        throw new FiveEPlayError(`5EPlay realtime credential request returned HTTP ${response.status}`, {
+            code: 'REALTIME_CONNECTION_FAILED', operation: 'match-realtime',
+            stage: 'connecting-realtime', retryable: response.status === 429 || response.status >= 500,
+            details: { status: response.status },
+        });
+    }
+    let value;
+    try {
+        value = JSON.parse(await response.text());
+    }
+    catch (error) {
+        throw new FiveEPlayError('5EPlay realtime credential response was invalid', {
+            code: 'REALTIME_CONNECTION_FAILED', operation: 'match-realtime',
+            stage: 'connecting-realtime', retryable: true, cause: error,
+        });
+    }
+    const envelope = record(value);
+    const data = record(envelope.data);
+    const clientId = text(data.client_id);
+    const username = text(data.username);
+    const password = text(data.password);
+    if (envelope.success !== true || !clientId || !username || !password) {
+        throw new FiveEPlayError('5EPlay realtime credentials were incomplete', {
+            code: 'REALTIME_CONNECTION_FAILED', operation: 'match-realtime',
+            stage: 'connecting-realtime', retryable: true,
+        });
+    }
+    return { clientId, username, password };
+}
+export class MqttTopicConnection {
+    #topic;
+    #fetch;
+    #signal;
+    #factory;
+    #onPayload;
+    #socket = null;
+    #keepAlive;
+    #reconnect;
+    #attempt = 0;
+    #closed = false;
+    constructor(options) {
+        this.#topic = options.topic;
+        this.#fetch = options.fetch;
+        this.#signal = options.signal;
+        this.#factory = options.webSocketFactory ?? defaultWebSocketFactory;
+        this.#onPayload = options.onPayload;
+    }
+    async start() {
+        if (this.#closed)
+            throw new FiveEPlayError('realtime connection is closed', {
+                code: 'SESSION_CLOSED', operation: 'match-realtime',
+                stage: 'connecting-realtime', retryable: false,
+            });
+        await this.#connectOnce();
+    }
+    close() {
+        this.#closed = true;
+        if (this.#keepAlive)
+            clearInterval(this.#keepAlive);
+        if (this.#reconnect)
+            clearTimeout(this.#reconnect);
+        this.#socket?.close(1000, 'session closed');
+        this.#socket = null;
+    }
+    async #connectOnce() {
+        const credentials = await credentialsFor(this.#fetch, this.#signal, this.#topic);
+        if (this.#closed || this.#signal.aborted)
+            throw this.#signal.reason;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const socket = this.#factory(BROKER_URL, ['mqtt']);
+            this.#socket = socket;
+            socket.binaryType = 'arraybuffer';
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(new FiveEPlayError('5EPlay MQTT connection failed', {
+                    code: 'REALTIME_CONNECTION_FAILED', operation: 'match-realtime',
+                    stage: 'connecting-realtime', retryable: true, cause: error,
+                }));
+            };
+            const onOpen = () => {
+                try {
+                    socket.send(encodeConnectPacket(credentials));
+                }
+                catch (error) {
+                    fail(error);
+                }
+            };
+            const onMessage = (event) => {
+                void (async () => {
+                    const bytes = await eventBytes(event.data);
+                    for (const mqttPacket of decodeMqttPackets(bytes)) {
+                        if (mqttPacket.type === 2) {
+                            if ((mqttPacket.payload[1] ?? 1) !== 0) {
+                                fail(new Error(`MQTT CONNACK ${mqttPacket.payload[1] ?? -1}`));
+                                return;
+                            }
+                            socket.send(encodeSubscribePacket(this.#topic));
+                        }
+                        else if (mqttPacket.type === 9) {
+                            if (!settled) {
+                                settled = true;
+                                this.#attempt = 0;
+                                this.#keepAlive = setInterval(() => {
+                                    if (socket.readyState === 1)
+                                        socket.send(Uint8Array.of(0xc0, 0));
+                                }, 20_000);
+                                resolve();
+                            }
+                        }
+                        else if (mqttPacket.type === 3 && mqttPacket.topic === this.#topic) {
+                            try {
+                                this.#onPayload(JSON.parse(new TextDecoder().decode(mqttPacket.payload)));
+                            }
+                            catch {
+                                // Ignore malformed provider messages; the connection remains usable.
+                            }
+                        }
+                    }
+                })().catch(fail);
+            };
+            const onError = () => fail(new Error('WebSocket error'));
+            const onClose = () => {
+                if (this.#keepAlive)
+                    clearInterval(this.#keepAlive);
+                this.#keepAlive = undefined;
+                if (!settled)
+                    fail(new Error('WebSocket closed before MQTT subscription'));
+                else if (!this.#closed && !this.#signal.aborted)
+                    this.#scheduleReconnect();
+            };
+            socket.addEventListener('open', onOpen);
+            socket.addEventListener('message', onMessage);
+            socket.addEventListener('error', onError);
+            socket.addEventListener('close', onClose);
+        });
+    }
+    #scheduleReconnect() {
+        if (this.#closed || this.#signal.aborted || this.#reconnect)
+            return;
+        const delay = Math.min(5_000, 250 * 2 ** this.#attempt);
+        this.#attempt += 1;
+        this.#reconnect = setTimeout(() => {
+            this.#reconnect = undefined;
+            void this.#connectOnce().catch(() => this.#scheduleReconnect());
+        }, delay);
+    }
+}

package/dist/session.d.ts

@@ -0,0 +1,2 @@
+import type { CreateFiveEPlayMatchSessionOptions, FiveEPlayMatchSession } from './types.js';
+export declare function createFiveEPlayMatchSession(input: string, options?: CreateFiveEPlayMatchSessionOptions): Promise<FiveEPlayMatchSession>;

package/dist/session.js

@@ -0,0 +1,169 @@
+import { AsyncQueue } from './async_queue.js';
+import { captureFiveEPlayMatch } from './capture.js';
+import { FiveEPlayError } from './errors.js';
+import { transformLogRecord } from './log.js';
+import { MqttTopicConnection } from './mqtt.js';
+import { buildFiveEPlayMatch, mergeDetailData } from './transform.js';
+import { record, text } from './value.js';
+class FiveEPlayMatchSessionImpl {
+    id;
+    initial;
+    #capture;
+    #controller;
+    #queue = new AsyncQueue();
+    #connections = [];
+    #externalSignal;
+    #onExternalAbort;
+    #current;
+    #closed = false;
+    constructor(capture, controller, externalSignal) {
+        this.id = capture.identity.id;
+        this.initial = capture.result;
+        this.#capture = capture;
+        this.#controller = controller;
+        this.#externalSignal = externalSignal;
+        this.#current = capture.result.data;
+        this.#onExternalAbort = () => { void this.close(); };
+        externalSignal?.addEventListener('abort', this.#onExternalAbort, { once: true });
+        this.#queue.push({
+            type: 'snapshot',
+            capturedAt: this.#current.capturedAt,
+            snapshot: structuredClone(this.#current),
+        });
+    }
+    addConnection(connection) {
+        this.#connections.push(connection);
+    }
+    snapshot() {
+        if (this.#closed) {
+            throw new FiveEPlayError('5EPlay realtime session is closed', {
+                code: 'SESSION_CLOSED', operation: 'match-realtime',
+                stage: 'streaming-realtime', retryable: false, matchId: this.id,
+            });
+        }
+        return structuredClone(this.#current);
+    }
+    handleState(payload) {
+        if (this.#closed)
+            return;
+        const root = record(payload);
+        if (text(root.event_name) !== 'csgo-detail')
+            return;
+        const data = record(root.data);
+        this.#capture.detailData = mergeDetailData(this.#capture.detailData, data);
+        const capturedAt = new Date().toISOString();
+        this.#current = buildFiveEPlayMatch({
+            identity: this.#capture.identity,
+            capturedAt,
+            detailData: this.#capture.detailData,
+            analysisData: this.#capture.analysisData,
+            logs: this.#capture.logs,
+            community: this.#capture.community,
+        });
+        this.#queue.push({
+            type: 'state',
+            capturedAt,
+            stateVersion: this.#current.stateVersion,
+            snapshot: structuredClone(this.#current),
+        });
+    }
+    handleLog(payload) {
+        if (this.#closed)
+            return;
+        const root = record(payload);
+        if (text(root.event_name) !== 'csgo-event-log')
+            return;
+        const data = record(root.data);
+        const info = record(data.info);
+        const event = transformLogRecord(info);
+        if (!event.mapNumber)
+            return;
+        const existing = this.#capture.logs.get(event.mapNumber) ?? {
+            complete: false,
+            fromVersion: text(data.from_ver),
+            toVersion: null,
+            rows: [],
+        };
+        existing.rows.push(info);
+        existing.toVersion = text(data.to_ver) ?? existing.toVersion;
+        this.#capture.logs.set(event.mapNumber, existing);
+        const capturedAt = new Date().toISOString();
+        this.#current = buildFiveEPlayMatch({
+            identity: this.#capture.identity,
+            capturedAt,
+            detailData: this.#capture.detailData,
+            analysisData: this.#capture.analysisData,
+            logs: this.#capture.logs,
+            community: this.#capture.community,
+        });
+        this.#queue.push({
+            type: 'log',
+            capturedAt,
+            event,
+            snapshot: structuredClone(this.#current),
+        });
+    }
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#externalSignal?.removeEventListener('abort', this.#onExternalAbort);
+        this.#controller.abort(new FiveEPlayError('5EPlay realtime session was closed', {
+            code: 'SESSION_CLOSED', operation: 'match-realtime',
+            stage: 'streaming-realtime', retryable: false, matchId: this.id,
+        }));
+        for (const connection of this.#connections)
+            connection.close();
+        this.#queue.close();
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+    [Symbol.asyncIterator]() {
+        return this.#queue[Symbol.asyncIterator]();
+    }
+}
+function emit(options, stage, message) {
+    options.onProgress?.({
+        operation: 'match-realtime',
+        stage,
+        message,
+        timestamp: new Date().toISOString(),
+    });
+}
+export async function createFiveEPlayMatchSession(input, options = {}) {
+    const capture = await captureFiveEPlayMatch(input, options, options);
+    const controller = new AbortController();
+    if (options.signal?.aborted)
+        controller.abort(options.signal.reason);
+    const session = new FiveEPlayMatchSessionImpl(capture, controller, options.signal);
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const stateTopic = `csgo/product/detail/${capture.identity.id}`;
+    const logTopic = `csgo/product/event/log/${capture.identity.id}`;
+    const state = new MqttTopicConnection({
+        topic: stateTopic,
+        fetch: fetchImpl,
+        signal: controller.signal,
+        webSocketFactory: options.webSocketFactory,
+        onPayload: (payload) => session.handleState(payload),
+    });
+    const log = new MqttTopicConnection({
+        topic: logTopic,
+        fetch: fetchImpl,
+        signal: controller.signal,
+        webSocketFactory: options.webSocketFactory,
+        onPayload: (payload) => session.handleLog(payload),
+    });
+    session.addConnection(state);
+    session.addConnection(log);
+    emit(options, 'connecting-realtime', 'Connecting 5EPlay score and event topics');
+    try {
+        await Promise.all([state.start(), log.start()]);
+    }
+    catch (error) {
+        await session.close();
+        throw error;
+    }
+    emit(options, 'streaming-realtime', '5EPlay realtime session connected');
+    return session;
+}

package/dist/transform.d.ts

@@ -0,0 +1,21 @@
+import type { FiveEPlayMatch, FiveEPlayMatchIdentity } from './types.js';
+export interface LogCapture {
+    complete: boolean;
+    fromVersion: string | null;
+    toVersion: string | null;
+    rows: unknown[];
+}
+export interface CommunityCapture {
+    tabs: unknown[];
+    cardsByTab: Map<string, unknown[]>;
+}
+export interface BuildMatchInput {
+    identity: FiveEPlayMatchIdentity;
+    capturedAt: string;
+    detailData: unknown;
+    analysisData: unknown | null;
+    logs: Map<number, LogCapture>;
+    community: CommunityCapture | null;
+}
+export declare function buildFiveEPlayMatch(input: BuildMatchInput): FiveEPlayMatch;
+export declare function mergeDetailData(base: unknown, update: unknown): unknown;