@crowdedkingdoms/crowdyjs 13.0.2 → 13.1.0

package/dist/binary-relay.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Binary realtime relay transport (`crowdy-relay-v1`).
+ *
+ * Connects to the game-api's raw-WebSocket relay endpoint and exchanges
+ * complete Buddy wire datagrams as BINARY frames — no GraphQL, JSON, or
+ * base64 on the wire. Owned by {@link RealtimeClient}, which keeps the public
+ * handler/dispatch surface identical across transports.
+ *
+ * Auth: the app token rides as a `bearer.<base64url(token)>` subprotocol
+ * entry (browsers cannot set WebSocket headers). The server replies with one
+ * TEXT `ready` frame carrying the session's `gameTokenId`, which becomes the
+ * client-side HMAC signing context.
+ */
+import type { CrowdyLogger } from './logger.js';
+import { CrowdyRealtimeError } from './errors.js';
+import type { UdpNotification } from './realtime.js';
+import { type RelaySignContext } from './binary-wire.js';
+export declare const RELAY_SUBPROTOCOL = "crowdy-relay-v1";
+export interface BinaryRelayCallbacks {
+    getToken(): string | null;
+    onNotification(notification: UdpNotification): void;
+    onError(error: CrowdyRealtimeError): void;
+    onStatus(status: 'connecting' | 'connected' | 'reconnecting' | 'disconnected'): void;
+    /**
+     * The relay endpoint looks permanently unavailable (older server, blocked
+     * upgrade). The owner should fall back to the GraphQL transport.
+     */
+    onUnavailable(): void;
+}
+export interface BinaryRelayConfig {
+    /** Absolute ws(s) URL of the relay endpoint (e.g. `wss://host/realtime`). */
+    url: string;
+    retryAttempts?: number;
+    retryInitialDelayMs?: number;
+    retryMaxDelayMs?: number;
+    logger?: CrowdyLogger;
+}
+export declare class BinaryRelayTransport {
+    private readonly callbacks;
+    private readonly url;
+    private readonly logger;
+    private readonly retryAttempts;
+    private readonly retryInitialDelayMs;
+    private readonly retryMaxDelayMs;
+    private ws;
+    private signContext;
+    private desired;
+    private appId;
+    private retries;
+    private preReadyFailures;
+    private everReady;
+    private retryTimer;
+    private generation;
+    constructor(config: BinaryRelayConfig, callbacks: BinaryRelayCallbacks);
+    /** True when the socket is open and the `ready` handshake completed. */
+    isReady(): boolean;
+    /** The session signing context (gameTokenId + HMAC key), once ready. */
+    getSignContext(): RelaySignContext | null;
+    connect(appId: string): void;
+    disconnect(): void;
+    /** Restart (e.g. after a token refresh) while remaining desired. */
+    restart(): void;
+    /** Send one pre-serialized Buddy datagram as a BINARY frame. */
+    sendFrame(frame: Uint8Array): void;
+    private open;
+    private handleControlFrame;
+    private maybeRetry;
+}
+//# sourceMappingURL=binary-relay.d.ts.map

package/dist/binary-relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-relay.d.ts","sourceRoot":"","sources":["../src/binary-relay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,iBAAiB,oBAAoB,CAAC;AAMnD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,IAAI,MAAM,GAAG,IAAI,CAAC;IAC1B,cAAc,CAAC,YAAY,EAAE,eAAe,GAAG,IAAI,CAAC;IACpD,OAAO,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC1C,QAAQ,CACN,MAAM,EAAE,YAAY,GAAG,WAAW,GAAG,cAAc,GAAG,cAAc,GACnE,IAAI,CAAC;IACR;;;OAGG;IACH,aAAa,IAAI,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,6EAA6E;IAC7E,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAMD,qBAAa,oBAAoB;IAmB7B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAlB5B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IAEzC,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,UAAU,CAAK;gBAGrB,MAAM,EAAE,iBAAiB,EACR,SAAS,EAAE,oBAAoB;IASlD,wEAAwE;IACxE,OAAO,IAAI,OAAO;IAQlB,wEAAwE;IACxE,cAAc,IAAI,gBAAgB,GAAG,IAAI;IAIzC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAO5B,UAAU,IAAI,IAAI;IAoBlB,oEAAoE;IACpE,OAAO,IAAI,IAAI;IASf,gEAAgE;IAChE,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAUlC,OAAO,CAAC,IAAI;YA6FE,kBAAkB;IAwBhC,OAAO,CAAC,UAAU;CAyBnB"}

package/dist/binary-relay.js

@@ -0,0 +1,226 @@
+/**
+ * Binary realtime relay transport (`crowdy-relay-v1`).
+ *
+ * Connects to the game-api's raw-WebSocket relay endpoint and exchanges
+ * complete Buddy wire datagrams as BINARY frames — no GraphQL, JSON, or
+ * base64 on the wire. Owned by {@link RealtimeClient}, which keeps the public
+ * handler/dispatch surface identical across transports.
+ *
+ * Auth: the app token rides as a `bearer.<base64url(token)>` subprotocol
+ * entry (browsers cannot set WebSocket headers). The server replies with one
+ * TEXT `ready` frame carrying the session's `gameTokenId`, which becomes the
+ * client-side HMAC signing context.
+ */
+import { silentLogger } from './logger.js';
+import { CrowdyRealtimeError } from './errors.js';
+import { createSignContext, parseRelayFrame, } from './binary-wire.js';
+export const RELAY_SUBPROTOCOL = 'crowdy-relay-v1';
+const BEARER_PREFIX = 'bearer.';
+/** Consecutive pre-ready failures before we declare the relay unavailable. */
+const UNAVAILABLE_AFTER_FAILURES = 2;
+function base64UrlEncode(value) {
+    return btoa(value).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+export class BinaryRelayTransport {
+    constructor(config, callbacks) {
+        this.callbacks = callbacks;
+        this.ws = null;
+        this.signContext = null;
+        this.desired = false;
+        this.appId = null;
+        this.retries = 0;
+        this.preReadyFailures = 0;
+        this.everReady = false;
+        this.retryTimer = null;
+        this.generation = 0;
+        this.url = config.url;
+        this.logger = config.logger ?? silentLogger;
+        this.retryAttempts = config.retryAttempts ?? 8;
+        this.retryInitialDelayMs = config.retryInitialDelayMs ?? 250;
+        this.retryMaxDelayMs = config.retryMaxDelayMs ?? 5000;
+    }
+    /** True when the socket is open and the `ready` handshake completed. */
+    isReady() {
+        return (this.ws != null &&
+            this.ws.readyState === WebSocket.OPEN &&
+            this.signContext != null);
+    }
+    /** The session signing context (gameTokenId + HMAC key), once ready. */
+    getSignContext() {
+        return this.signContext;
+    }
+    connect(appId) {
+        this.desired = true;
+        this.appId = appId;
+        if (this.ws)
+            return;
+        this.open();
+    }
+    disconnect() {
+        this.desired = false;
+        if (this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+        }
+        this.generation += 1;
+        const ws = this.ws;
+        this.ws = null;
+        this.signContext = null;
+        if (ws) {
+            try {
+                ws.close(1000, 'client-disconnect');
+            }
+            catch {
+                /* already closed */
+            }
+        }
+        this.callbacks.onStatus('disconnected');
+    }
+    /** Restart (e.g. after a token refresh) while remaining desired. */
+    restart() {
+        if (!this.desired || this.appId == null)
+            return;
+        const appId = this.appId;
+        this.disconnect();
+        this.desired = true;
+        this.appId = appId;
+        this.open();
+    }
+    /** Send one pre-serialized Buddy datagram as a BINARY frame. */
+    sendFrame(frame) {
+        if (!this.isReady() || !this.ws) {
+            throw new CrowdyRealtimeError('Binary relay is not connected', {
+                code: 'BINARY_RELAY_UNAVAILABLE',
+                retryable: true,
+            });
+        }
+        this.ws.send(frame);
+    }
+    open() {
+        const token = this.callbacks.getToken();
+        if (!token) {
+            this.callbacks.onError(new CrowdyRealtimeError('Must be authenticated to open the binary relay', {
+                code: 'AUTH_REQUIRED',
+                retryable: false,
+            }));
+            return;
+        }
+        if (typeof WebSocket === 'undefined') {
+            this.logger.warn?.('No global WebSocket implementation; binary relay unavailable');
+            this.callbacks.onUnavailable();
+            return;
+        }
+        const generation = ++this.generation;
+        this.callbacks.onStatus(this.retries > 0 ? 'reconnecting' : 'connecting');
+        const separator = this.url.includes('?') ? '&' : '?';
+        const url = `${this.url}${separator}appId=${encodeURIComponent(this.appId ?? '')}`;
+        let ws;
+        try {
+            ws = new WebSocket(url, [
+                RELAY_SUBPROTOCOL,
+                `${BEARER_PREFIX}${base64UrlEncode(token)}`,
+            ]);
+        }
+        catch (error) {
+            this.logger.error?.('Binary relay socket construction failed', error);
+            this.preReadyFailures += 1;
+            this.maybeRetry(generation);
+            return;
+        }
+        ws.binaryType = 'arraybuffer';
+        this.ws = ws;
+        this.signContext = null;
+        let sawReady = false;
+        ws.onmessage = (event) => {
+            if (generation !== this.generation)
+                return;
+            const data = event.data;
+            if (typeof data === 'string') {
+                this.handleControlFrame(data, generation).catch((error) => {
+                    this.logger.error?.('Binary relay handshake failed', error);
+                });
+                if (!sawReady)
+                    sawReady = true;
+                return;
+            }
+            if (data instanceof ArrayBuffer) {
+                for (const notification of parseRelayFrame(new Uint8Array(data))) {
+                    this.callbacks.onNotification(notification);
+                }
+            }
+        };
+        ws.onerror = () => {
+            if (generation !== this.generation)
+                return;
+            this.logger.warn?.('Binary relay socket error');
+        };
+        ws.onclose = (event) => {
+            if (generation !== this.generation)
+                return;
+            this.ws = null;
+            const hadReady = this.signContext != null || sawReady;
+            this.signContext = null;
+            if (!this.desired) {
+                this.callbacks.onStatus('disconnected');
+                return;
+            }
+            if (!hadReady) {
+                this.preReadyFailures += 1;
+                if (!this.everReady && this.preReadyFailures >= UNAVAILABLE_AFTER_FAILURES) {
+                    this.logger.warn?.(`Binary relay unavailable after ${this.preReadyFailures} failed handshakes (close ${event.code}); falling back`);
+                    this.desired = false;
+                    this.callbacks.onUnavailable();
+                    return;
+                }
+            }
+            else {
+                this.retries = 0;
+            }
+            this.maybeRetry(generation);
+        };
+    }
+    async handleControlFrame(data, generation) {
+        let frame;
+        try {
+            frame = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        if (frame.type !== 'ready' || !frame.gameTokenId)
+            return;
+        const token = this.callbacks.getToken();
+        if (!token)
+            return;
+        const ctx = await createSignContext(BigInt(frame.gameTokenId), token);
+        if (generation !== this.generation)
+            return;
+        this.signContext = ctx;
+        this.everReady = true;
+        this.preReadyFailures = 0;
+        this.retries = 0;
+        this.callbacks.onStatus('connected');
+    }
+    maybeRetry(generation) {
+        if (!this.desired || generation !== this.generation)
+            return;
+        if (this.retries >= this.retryAttempts) {
+            this.desired = false;
+            this.callbacks.onError(new CrowdyRealtimeError('Binary relay reconnect attempts exhausted', {
+                code: 'BINARY_RELAY_RECONNECT_EXHAUSTED',
+                retryable: false,
+            }));
+            this.callbacks.onStatus('disconnected');
+            return;
+        }
+        const delay = Math.min(this.retryMaxDelayMs, this.retryInitialDelayMs * 2 ** this.retries);
+        const jitter = Math.floor(Math.random() * this.retryInitialDelayMs);
+        this.retries += 1;
+        this.callbacks.onStatus('reconnecting');
+        this.retryTimer = setTimeout(() => {
+            this.retryTimer = null;
+            if (this.desired && generation === this.generation)
+                this.open();
+        }, delay + jitter);
+    }
+}

package/dist/binary-wire.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Buddy client wire-format codec for the binary realtime relay
+ * (`crowdy-relay-v1`).
+ *
+ * Mirrors the game-api's `UdpMessageParserService` byte-for-byte: uplink
+ * serializers build the complete client→Buddy datagram (spatial header +
+ * payload + HMAC + gameTokenId + sequence) and downlink parsing produces the
+ * same `__typename`-tagged notification objects the GraphQL
+ * `udpNotifications` subscription delivers, so handler code is transport
+ * agnostic.
+ *
+ * The per-message HMAC key is the 64-octet game token string itself — the
+ * same bearer token the SDK already holds — computed with WebCrypto
+ * (HMAC-SHA256). Buddy verifies it server-side; the relay does not.
+ */
+import type { UdpNotification } from './realtime.js';
+export declare const RELAY_MAX_DATAGRAM_BYTES = 1232;
+/** Wire opcodes (mirror of game-api / Buddy `UdpMessageType`). */
+export declare const WireMessageType: {
+    readonly MESSAGE_BUNDLE: 2;
+    readonly GENERIC_ERROR_MESSAGE: 3;
+    readonly CHANNEL_MESSAGE_REQUEST: 17;
+    readonly CHANNEL_MESSAGE_NOTIFICATION: 18;
+    readonly ACTOR_UPDATE_REQUEST_2: 128;
+    readonly ACTOR_UPDATE_RESPONSE_2: 129;
+    readonly ACTOR_UPDATE_NOTIFICATION_2: 130;
+    readonly VOXEL_UPDATE_REQUEST_2: 131;
+    readonly VOXEL_UPDATE_RESPONSE_2: 132;
+    readonly VOXEL_UPDATE_NOTIFICATION_2: 133;
+    readonly CLIENT_AUDIO_PACKET_2: 134;
+    readonly CLIENT_AUDIO_NOTIFICATION_2: 135;
+    readonly CLIENT_TEXT_PACKET_2: 136;
+    readonly CLIENT_TEXT_NOTIFICATION_2: 137;
+    readonly CLIENT_EVENT_NOTIFICATION_2: 138;
+    readonly SERVER_EVENT_NOTIFICATION_2: 139;
+    readonly SINGLE_ACTOR_MESSAGE: 142;
+};
+/**
+ * Per-session signing context: the game token id (from the relay `ready`
+ * frame) plus the token bytes and imported WebCrypto HMAC key.
+ */
+export interface RelaySignContext {
+    gameTokenId: bigint;
+    tokenBytes: Uint8Array;
+    key: CryptoKey;
+}
+/** Import the game token as an HMAC-SHA256 WebCrypto key (once per session). */
+export declare function createSignContext(gameTokenId: bigint, gameTokenString: string): Promise<RelaySignContext>;
+export interface SpatialSendBase {
+    appId: string;
+    chunk: {
+        x: string;
+        y: string;
+        z: string;
+    };
+    uuid: string;
+    distance?: number | null;
+    decayRate?: number | null;
+    sequenceNumber?: number | null;
+}
+export declare function serializeActorUpdate(ctx: RelaySignContext, input: SpatialSendBase & {
+    state: string;
+}): Promise<Uint8Array>;
+export declare function serializeVoxelUpdate(ctx: RelaySignContext, input: SpatialSendBase & {
+    voxel: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    voxelType: number;
+    voxelState: string;
+}): Promise<Uint8Array>;
+export declare function serializeAudioPacket(ctx: RelaySignContext, input: SpatialSendBase & {
+    audioData: string;
+}): Promise<Uint8Array>;
+export declare function serializeTextPacket(ctx: RelaySignContext, input: SpatialSendBase & {
+    text: string;
+}): Promise<Uint8Array>;
+export declare function serializeClientEvent(ctx: RelaySignContext, input: SpatialSendBase & {
+    eventType: number;
+    state: string;
+}): Promise<Uint8Array>;
+export declare function serializeSingleActorMessage(ctx: RelaySignContext, input: {
+    appId: string;
+    chunk: {
+        x: string;
+        y: string;
+        z: string;
+    };
+    targetUuid: string;
+    payload?: string | null;
+    sequenceNumber?: number | null;
+}): Promise<Uint8Array>;
+/**
+ * CHANNEL_MESSAGE_REQUEST:
+ * `[1B type=17][8B channelId][32B uuid][2B payloadLen][payload][1B containsAuth]
+ *  [32B HMAC][8B gameTokenId][1B seq]` — HMAC over everything before it.
+ */
+export declare function serializeChannelMessage(ctx: RelaySignContext, input: {
+    channelId: string;
+    uuid: string;
+    payload?: string | null;
+    sequenceNumber?: number | null;
+}): Promise<Uint8Array>;
+/**
+ * Parse one relay BINARY frame (one Buddy datagram, possibly a
+ * MESSAGE_BUNDLE) into notification objects. Unparseable inner messages are
+ * skipped, mirroring the server-side bundle behavior.
+ */
+export declare function parseRelayFrame(bytes: Uint8Array): UdpNotification[];
+//# sourceMappingURL=binary-wire.d.ts.map

package/dist/binary-wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-wire.d.ts","sourceRoot":"","sources":["../src/binary-wire.ts"],"names":[],"mappings":"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"}