@uzuhq/code-sdk 0.3.8

package/dist/index.js

@@ -0,0 +1,440 @@
+export { SERVER_TIME, DEFAULT_ICON_URLS } from './types.js';
+export { serverOnly, isServerOnlyAction } from './server-only.js';
+export { Room } from './room.js';
+export { ReconnectableWebSocket } from './reconnectable-ws.js';
+export { SeededRandomImpl } from './random.js';
+export { applyJsonMergePatch, applyJsonPatch } from './dev-state-patch.js';
+export { attachDevHooks, createDevHooks } from './dev-hooks.js';
+import { Room } from './room.js';
+import { ReconnectableWebSocket } from './reconnectable-ws.js';
+import { runOnlineServerAction } from './run/server-action.js';
+import { runLocalServerAction } from './run/local-server-action.js';
+import { syncLocal } from './sync/local.js';
+import { syncOnline } from './sync/online.js';
+import { attachDevHooks } from './dev-hooks.js';
+const gameHandlers = new Map();
+const _playersChangedHandlers = [];
+let _room = null;
+let _lastStateSnap = null;
+let _onRoomCallbacks = [];
+let _wsEndpoint = null;
+let _syncEndpoint = null;
+let _gameEndpoint = null;
+let _syncWs = null;
+let _initialized = false;
+let _usesRun = false;
+let _playerId = null;
+// ─── Dev hooks state (window.__uzu_dev 経由の外部 automation 用) ──────
+// Flutter native ホスト (= window.FlutterHost あり) では一切 attach されない。
+// 注意: `isHosted` は dev harness 子 iframe (parent !== window) も含むため、
+// dev hooks の本番判定は `isHosted` ではなく `window.FlutterHost` の有無で行う。
+// これにより Flutter native では非公開、 dev harness 子 iframe / Playwright iframe /
+// 単独 page では attach、 という挙動を両立させる。
+let _runHandle = null;
+let _syncHandle = null;
+const _snapshotListeners = new Set();
+function notifyDevSnapshot(snap) {
+    _snapshotListeners.forEach((cb) => {
+        try {
+            cb(snap);
+        }
+        catch (err) {
+            console.warn('[uzu_dev] snapshot listener threw:', err);
+        }
+    });
+}
+function attachDevHooksIfNotHosted() {
+    // Flutter native ホスト (本番) では attach しない。
+    if (window.FlutterHost)
+        return;
+    const ctx = {
+        getSnapshot: () => _lastStateSnap?.state ?? null,
+        getRawState: _runHandle?.getRawState ?? _syncHandle?.getRawState,
+        setRawState: _runHandle?.setRawState ?? _syncHandle?.setRawState,
+        mergeRawState: _runHandle?.mergeRawState ?? _syncHandle?.mergeRawState,
+        patchRawState: _runHandle?.patchRawState ?? _syncHandle?.patchRawState,
+        playerId: () => _lastStateSnap?.myId ?? _playerId,
+        subscribeSnapshot: (cb) => {
+            _snapshotListeners.add(cb);
+            return () => {
+                _snapshotListeners.delete(cb);
+            };
+        },
+    };
+    attachDevHooks(ctx);
+}
+// ─── Public API ─────────────────────────────────────────────
+export const isHosted = !!window.FlutterHost || window.parent !== window;
+export function getRoom() {
+    return _room;
+}
+export function onRoom(callback) {
+    if (_room) {
+        callback(_room);
+    }
+    else {
+        _onRoomCallbacks.push(callback);
+    }
+}
+export function init(opts) {
+    const params = new URLSearchParams(window.location.search);
+    // 送信元プレイヤー ID。 ホストが自分宛メッセージかを判定するために
+    // ブリッジメッセージのエンベロープへ含める (sendRaw 参照)。
+    // Flutter ホスト (QueryParamsBuilder) と dev ハーネスは必ず seatId を付与する。
+    // bridge envelope の key 名は playerId のまま (postMessage bridge の既存プロトコル)。
+    _playerId = params.get('seatId');
+    if (isHosted && !_playerId) {
+        console.warn('[UZU SDK] playerId is missing in the URL. ' +
+            'Host-side sender filtering will fall back to legacy behavior.');
+    }
+    // ?server=ws://host:port → エンドポイントのベースURLを外部注入
+    const serverParam = params.get('server');
+    if (serverParam && serverParam.length > 0) {
+        const base = serverParam.replace(/\/$/, '');
+        _wsEndpoint = `${base}/ws/rooms`;
+        _syncEndpoint = `${base}/ws/sync`;
+        // ServerAction: /ws/games/{revisionId}/{roomId} の形式で接続
+        const revisionId = params.get('revisionId');
+        if (!revisionId) {
+            throw new Error('[UZU SDK] revisionId is required when server is specified. Pass ?revisionId=xxx in the URL.');
+        }
+        _gameEndpoint = `${base}/ws/games/${revisionId}`;
+    }
+    // init() の引数は query parameter より優先
+    if (opts?.wsEndpoint)
+        _wsEndpoint = opts.wsEndpoint;
+    if (opts?.syncEndpoint)
+        _syncEndpoint = opts.syncEndpoint;
+    // 親 frame (= harness が立つ場所) では SDK runtime は何もしない。
+    // 子 iframe の生成は `uzu dev` CLI が配信する harness の責務に切り出している。
+    if (!isHosted)
+        return;
+    if (!_initialized) {
+        window.__ps = {
+            onMessage: (msg) => {
+                console.log(`[SDK] ⬅ recv __ps.onMessage channel=${msg.channel} type=${msg.type}`, JSON.stringify(msg));
+                handleMessage(msg);
+            },
+        };
+        // Web iframe モード: 親ウィンドウからの postMessage を受信
+        window.addEventListener('message', (event) => {
+            try {
+                const data = typeof event.data === 'string' ? JSON.parse(event.data) : event.data;
+                if (data && typeof data.channel === 'string' && typeof data.type === 'string') {
+                    console.log(`[SDK] ⬅ recv postMessage channel=${data.channel} type=${data.type}`, JSON.stringify(data));
+                    handleMessage(data);
+                }
+            }
+            catch {
+                // JSON でないメッセージは無視
+            }
+        });
+        // HUD 回避領域の CSS カスタムプロパティを設定
+        // クエリパラメータがあればその値を使用し、 なければ players 数から推定
+        const hudX = params.get('uzuHudInsetX');
+        const hudY = params.get('uzuHudInsetY');
+        const { x: fallbackX, y: fallbackY } = calcHudInsets(params);
+        document.documentElement.style.setProperty('--uzu-hud-inset-x', `${hudX ?? fallbackX}px`);
+        document.documentElement.style.setProperty('--uzu-hud-inset-y', `${hudY ?? fallbackY}px`);
+        sendRaw('sdk', 'ready', {});
+        _initialized = true;
+    }
+    // Relay 自動接続 (wsEndpoint 未設定時はスキップ)
+    if (!_usesRun) {
+        const roomIdParam = params.get('roomId');
+        if (roomIdParam) {
+            if (_wsEndpoint) {
+                connectRoom(roomIdParam);
+            }
+            else {
+                console.warn('[SDK] roomId is present but server is not configured — skipping Relay connection');
+            }
+        }
+    }
+    // run() / sync() を経由しない init() 単独ケースでも dev hooks を attach する
+    // (Relay モード等。 run/sync 経由なら呼び出し元で再 attach される)
+    if (!_usesRun) {
+        attachDevHooksIfNotHosted();
+    }
+}
+/** game channel でカスタムメッセージを送信する。 native コマンドには使用不可。 */
+export function send(type, payload) {
+    sendRaw('game', type, payload ?? {});
+}
+/** game channel のカスタムメッセージを受信する。 */
+export function on(type, handler) {
+    if (!gameHandlers.has(type))
+        gameHandlers.set(type, []);
+    gameHandlers.get(type).push(handler);
+}
+// ─── Native コマンド (sdk channel) ──────────────────────
+export function playSound(sound) {
+    sendRaw('sdk', 'playSound', { sound });
+}
+export function playBgm(sound) {
+    sendRaw('sdk', 'playBgm', { sound });
+}
+export function stopBgm() {
+    sendRaw('sdk', 'stopBgm', {});
+}
+export function setMicEnabled(enabled) {
+    sendRaw('sdk', 'setMicEnabled', { enabled });
+}
+export function changeRoom(roomId) {
+    sendRaw('sdk', 'changeRoom', { roomId });
+}
+/**
+ * splash 描画完了を Flutter ホストに通知する。
+ *
+ * YouTube Playables の `firstFrameReady()` 相当。 Flutter は受信時に splash overlay を
+ * 非表示にし WebView を可視化する。 **呼ばないと splash が出っぱなしになる**。
+ *
+ * 呼び出しタイミング: scenario が最初の絵 (splash / loading 画面) を画面に描いた直後。
+ * paint commit を保証するため `requestAnimationFrame` を 1 段挟むのが定石。
+ *
+ * @example
+ * ```ts
+ * init();
+ * drawSplash();
+ * requestAnimationFrame(() => firstFrameReady());
+ * ```
+ */
+export function firstFrameReady() {
+    sendRaw('sdk', 'firstFrameReady', {});
+}
+/**
+ * ユーザー操作受付可能を Flutter ホストに通知する。
+ *
+ * YouTube Playables の `gameReady()` 相当。 Flutter は受信時に入力受付を開始し、TTI
+ * (Time To Interactive) 計測を終了する。 将来の広告タイマー / leaderboard / analytics
+ * の発火点としても使われる予定。
+ *
+ * 呼び出しタイミング: asset load 完了、 ゲーム本体の setup 完了、 入力受付可能になった直後。
+ *
+ * @example
+ * ```ts
+ * await loadAssets();
+ * setupGame();
+ * gameReady();
+ * ```
+ */
+export function gameReady() {
+    sendRaw('sdk', 'gameReady', {});
+}
+/** Flutter からの playersChanged メッセージを受信するハンドラを登録する。 */
+export function onPlayersChanged(handler) {
+    _playersChangedHandlers.push(handler);
+}
+export function run(config) {
+    _usesRun = true;
+    const params = new URLSearchParams(window.location.search);
+    // 親 frame では SDK runtime は何もしない。 harness は uzu-cli の `uzu dev` が担当。
+    if (!isHosted)
+        return;
+    init();
+    // Wrap onState to capture latest state for dev hooks
+    const origOnState = config.onState;
+    const wrappedConfig = {
+        ...config,
+        onState(state, myPlayerId) {
+            _lastStateSnap = { state, serverTime: 0, myId: myPlayerId };
+            origOnState(state, myPlayerId);
+            notifyDevSnapshot(state);
+        },
+    };
+    const roomId = params.get('roomId');
+    if (!roomId) {
+        // ServerAction: ローカルで logic を直接実行 (ソロモード)
+        _runHandle = runLocalServerAction(wrappedConfig);
+    }
+    else if (_gameEndpoint) {
+        // ServerAction モード: GameRoom に接続 (本番 Cloudflare Worker DO / uzu dev の Node ws)
+        const { seatId, seats } = resolveSeatParams(params);
+        runOnlineServerAction(wrappedConfig, _gameEndpoint, roomId, seatId, seats);
+    }
+    else {
+        throw new Error('[UZU SDK] roomId is set but ?server= is missing. ' +
+            'Multiplayer requires a WebSocket server URL — pass ?server=ws://host:port in the URL.');
+    }
+    attachDevHooksIfNotHosted();
+}
+export function sync(config) {
+    _usesRun = true;
+    const params = new URLSearchParams(window.location.search);
+    // 親 frame では SDK runtime は何もしない。 harness は uzu-cli の `uzu dev` が担当。
+    if (!isHosted)
+        return;
+    init();
+    // Wrap onState to capture latest state for dev hooks
+    const origOnState = config.onState;
+    const wrappedConfig = {
+        ...config,
+        onState(state, myPlayerId, serverTime) {
+            _lastStateSnap = { state, serverTime, myId: myPlayerId };
+            origOnState(state, myPlayerId, serverTime);
+            notifyDevSnapshot(state);
+        },
+    };
+    const roomId = params.get('roomId');
+    if (!roomId) {
+        _syncHandle = syncLocal(wrappedConfig);
+    }
+    else if (_syncEndpoint) {
+        const { seatId, seats } = resolveSeatParams(params);
+        const { ws } = syncOnline(wrappedConfig, _syncEndpoint, roomId, seatId, seats);
+        _syncWs = ws;
+        // online sync: dev hooks は read-only (setRawState 未提供)
+    }
+    else {
+        throw new Error('[UZU SDK] roomId is set but ?server= is missing. ' +
+            'Multiplayer sync requires a WebSocket server URL — pass ?server=ws://host:port in the URL.');
+    }
+    attachDevHooksIfNotHosted();
+}
+// ─── Internal ───────────────────────────────────────────────
+function resolveSeatParams(params) {
+    const seatId = params.get('seatId');
+    if (!seatId) {
+        throw new Error('[UZU SDK] seatId is required. Pass ?seatId=xxx in the URL.');
+    }
+    const json = params.get('seats');
+    if (!json) {
+        throw new Error('[UZU SDK] seats is required. Pass ?seats=[...] in the URL.');
+    }
+    const raw = JSON.parse(json);
+    const seats = raw.map((p) => {
+        if (!p.kind) {
+            throw new Error(`[UZU SDK] seats entry ${p.id} is missing kind.`);
+        }
+        return {
+            id: p.id,
+            nickname: p.name,
+            iconUrl: p.iconUrl,
+            characterId: p.characterId,
+            kind: p.kind,
+        };
+    });
+    return { seatId, seats };
+}
+function requireEndpoint(endpoint, name) {
+    if (!endpoint) {
+        throw new Error(`[UZU SDK] ${name} is not configured. Pass ?server=ws://host:port or call init({ wsEndpoint, syncEndpoint }).`);
+    }
+    return endpoint;
+}
+function connectRoom(roomId) {
+    const params = new URLSearchParams(window.location.search);
+    const { seatId } = resolveSeatParams(params);
+    const wsParams = new URLSearchParams({ playerId: seatId });
+    const wsUrl = `${requireEndpoint(_wsEndpoint, 'wsEndpoint')}/${roomId}?${wsParams}`;
+    console.log(`[SDK] 🔗 connectRoom wsUrl=${wsUrl}`);
+    const ws = new ReconnectableWebSocket(wsUrl);
+    ws.addEventListener('message', (ev) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(ev.data);
+        }
+        catch {
+            return;
+        }
+        console.log(`[SDK] ⬅ recv ws type=${parsed.type}`, JSON.stringify(parsed));
+        if (parsed.type === '__room_init') {
+            const myId = parsed.myId;
+            console.log(`[SDK] ✅ Room initialized myId=${myId}`);
+            _room = new Room(ws, myId);
+            _onRoomCallbacks.forEach((cb) => cb(_room));
+            _onRoomCallbacks = [];
+        }
+        else if (parsed.type === '__reconnected') {
+            // 再接続: ws は同じ ReconnectableWebSocket インスタンスなので Room 再作成不要
+            console.log(`[SDK] 🔄 Room reconnected`);
+        }
+    });
+}
+/** 内部送信関数。 channel + type + payload のエンベロープで送信する。 */
+function sendRaw(channel, type, payload) {
+    const msg = {
+        channel,
+        type,
+        payload,
+        ...(_playerId ? { playerId: _playerId } : {}),
+    };
+    console.log(`[SDK] ➡ send channel=${channel} type=${type}`, JSON.stringify(msg));
+    if (window.FlutterHost) {
+        // Desktop/Mobile: webview_flutter の JavaScriptChannel 経由
+        window.FlutterHost.postMessage(JSON.stringify(msg));
+    }
+    else if (window.parent !== window) {
+        // Web iframe: 親ウィンドウへ postMessage 経由
+        window.parent.postMessage(JSON.stringify(msg), '*');
+    }
+}
+function handleMessage(msg) {
+    const { channel, type, payload } = msg;
+    if (channel === 'sdk') {
+        // SDK 内部メッセージの処理
+        switch (type) {
+            case 'getState':
+                console.log(`[SDK] 🔧 handleMessage sdk/getState → responding`);
+                sendRaw('sdk', 'stateResponse', { state: _lastStateSnap });
+                return;
+            case 'clearState':
+                console.log(`[SDK] 🗑 handleMessage sdk/clearState → forwarding to server`);
+                if (_syncWs && _syncWs.connectionState === 'connected') {
+                    _syncWs.send(JSON.stringify({ type: '__clear_state' }));
+                }
+                return;
+            case 'playersChanged': {
+                const players = (payload?.players ?? {});
+                _playersChangedHandlers.forEach((fn) => fn(players));
+                return;
+            }
+        }
+        return;
+    }
+    if (channel === 'game') {
+        const h = gameHandlers.get(type) || [];
+        console.log(`[SDK] 🔧 handleMessage game/${type} handlers=${h.length}`);
+        h.forEach((fn) => fn(payload ?? {}));
+        return;
+    }
+}
+// ─── HUD inset 計算 ─────────────────────────────────────────
+// Flutter 側の HudInsets と同じ定数・ロジック
+const HUD_TOP = 8;
+const HUD_LEFT = 12;
+const UZU_BUTTON_SIZE = 44;
+const GAP = 6;
+const ACTION_ITEM_WIDTH = 38;
+/**
+ * HUD 回避領域の右下座標を算出する。
+ * クエリパラメータに uzuHudInsetX/Y がない場合のフォールバック値として使用。
+ *
+ * 前提: UZU ボタンは常に表示される (onMenuPressed は常に非 null)。
+ * Dart 側の HudInsets.x() は hasMenu=false を扱えるが、
+ * フォールバック計算では安全側に倒して常に UZU ボタンありで算出する。
+ *
+ * - players が取得できる場合: 2人以上→アクション数2、1人→アクション数0
+ * - players が取得できない場合: アクション数2 (安全側に倒す)
+ */
+function calcHudInsets(params) {
+    const y = HUD_TOP + UZU_BUTTON_SIZE;
+    let actionCount = 2; // デフォルト: 安全側 (マイク + チャット想定)
+    const json = params.get('seats');
+    if (json) {
+        try {
+            // spectator / admin 席はゲームの player 数に数えない
+            const raw = JSON.parse(json);
+            const playerCount = raw.filter((p) => p.kind === 'player').length;
+            actionCount = playerCount >= 2 ? 2 : 0;
+        }
+        catch {
+            // パース失敗時はデフォルト値を使用
+        }
+    }
+    let x = HUD_LEFT + UZU_BUTTON_SIZE;
+    if (actionCount > 0) {
+        x += GAP + ACTION_ITEM_WIDTH * actionCount;
+    }
+    return { x, y };
+}

package/dist/json-patch.d.ts

@@ -0,0 +1,7 @@
+export interface Operation {
+    op: 'replace' | 'add' | 'remove';
+    path: string;
+    value?: unknown;
+}
+export declare function compare(oldObj: any, newObj: any, basePath?: string): Operation[];
+export declare function applyPatch(doc: any, ops: Operation[]): boolean;

package/dist/json-patch.js

@@ -0,0 +1,78 @@
+function escapePointer(key) {
+    return key.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function unescapePointer(token) {
+    return token.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+export function compare(oldObj, newObj, basePath = '') {
+    if (oldObj === newObj)
+        return [];
+    // Handle nulls / primitives
+    if (oldObj === null ||
+        newObj === null ||
+        typeof oldObj !== 'object' ||
+        typeof newObj !== 'object') {
+        return [{ op: 'replace', path: basePath || '/', value: newObj }];
+    }
+    // Arrays: compare as whole (no element-level diff)
+    if (Array.isArray(oldObj) || Array.isArray(newObj)) {
+        if (JSON.stringify(oldObj) === JSON.stringify(newObj))
+            return [];
+        return [{ op: 'replace', path: basePath || '/', value: newObj }];
+    }
+    // Objects: recurse
+    const ops = [];
+    const oldKeys = Object.keys(oldObj);
+    const newKeys = Object.keys(newObj);
+    // Removed keys
+    for (const key of oldKeys) {
+        if (!(key in newObj)) {
+            ops.push({ op: 'remove', path: `${basePath}/${escapePointer(key)}` });
+        }
+    }
+    // Added or changed keys
+    for (const key of newKeys) {
+        const childPath = `${basePath}/${escapePointer(key)}`;
+        if (!(key in oldObj)) {
+            ops.push({ op: 'add', path: childPath, value: newObj[key] });
+        }
+        else {
+            const childOps = compare(oldObj[key], newObj[key], childPath);
+            ops.push(...childOps);
+        }
+    }
+    return ops;
+}
+export function applyPatch(doc, ops) {
+    for (const op of ops) {
+        const tokens = op.path.split('/').slice(1).map(unescapePointer);
+        if (tokens.length === 0)
+            return false;
+        if (op.op === 'replace' || op.op === 'add') {
+            let target = doc;
+            for (let i = 0; i < tokens.length - 1; i++) {
+                target = target?.[tokens[i]];
+                if (target === undefined || target === null)
+                    return false;
+            }
+            const lastKey = tokens[tokens.length - 1];
+            target[lastKey] = op.value;
+        }
+        else if (op.op === 'remove') {
+            let target = doc;
+            for (let i = 0; i < tokens.length - 1; i++) {
+                target = target?.[tokens[i]];
+                if (target === undefined || target === null)
+                    return false;
+            }
+            const lastKey = tokens[tokens.length - 1];
+            if (Array.isArray(target)) {
+                target.splice(Number(lastKey), 1);
+            }
+            else {
+                delete target[lastKey];
+            }
+        }
+    }
+    return true;
+}

package/dist/random.d.ts

@@ -0,0 +1,11 @@
+import type { SeededRandom } from './types.js';
+export declare class SeededRandomImpl implements SeededRandom {
+    private _state;
+    constructor(seed: number);
+    get state(): number;
+    static fromState(state: number): SeededRandomImpl;
+    float(): number;
+    int(max: number): number;
+    pick<T>(array: T[]): T;
+    shuffle<T>(array: T[]): T[];
+}

package/dist/random.js

@@ -0,0 +1,34 @@
+export class SeededRandomImpl {
+    constructor(seed) {
+        this._state = seed | 0;
+    }
+    get state() {
+        return this._state;
+    }
+    static fromState(state) {
+        const r = new SeededRandomImpl(0);
+        r._state = state;
+        return r;
+    }
+    float() {
+        this._state |= 0;
+        this._state = (this._state + 0x6d2b79f5) | 0;
+        let t = Math.imul(this._state ^ (this._state >>> 15), 1 | this._state);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+    int(max) {
+        return Math.floor(this.float() * max);
+    }
+    pick(array) {
+        return array[this.int(array.length)];
+    }
+    shuffle(array) {
+        const a = [...array];
+        for (let i = a.length - 1; i > 0; i--) {
+            const j = this.int(i + 1);
+            [a[i], a[j]] = [a[j], a[i]];
+        }
+        return a;
+    }
+}

package/dist/reconnectable-ws.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 自動再接続 WebSocket ラッパー
+ *
+ * - Exponential backoff + jitter 付き自動再接続
+ * - Heartbeat (__ping / __pong) による接続生存確認
+ * - 再接続中のメッセージバッファリング
+ */
+export type ConnectionState = 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
+export interface ReconnectableWSOptions {
+    /** 最大再接続試行回数 (default: 15) */
+    maxReconnectAttempts?: number;
+    /** Backoff の基準遅延 ms (default: 1000) */
+    baseDelay?: number;
+    /** Backoff の最大遅延 ms (default: 30000) */
+    maxDelay?: number;
+    /** Jitter 係数 0〜1 (default: 0.5) */
+    jitterFactor?: number;
+    /** Heartbeat 送信間隔 ms (default: 25000) */
+    heartbeatInterval?: number;
+    /** Pong 待ちタイムアウト ms (default: 10000) */
+    heartbeatTimeout?: number;
+    /** 再接続中のバッファ上限 (default: 50) */
+    maxBufferSize?: number;
+    /** バッファ対象判定。false を返すとドロップ */
+    shouldBuffer?: (data: string) => boolean;
+    /** 接続状態変更コールバック */
+    onConnectionStateChange?: (state: ConnectionState) => void;
+}
+export declare class ReconnectableWebSocket {
+    private ws;
+    private readonly url;
+    private readonly opts;
+    private _state;
+    private reconnectAttempt;
+    private messageBuffer;
+    private messageHandlers;
+    private heartbeatTimer;
+    private heartbeatTimeoutTimer;
+    private reconnectTimer;
+    private disposed;
+    constructor(url: string, options?: ReconnectableWSOptions);
+    get connectionState(): ConnectionState;
+    /** WebSocket.readyState 互換 (既存コードとの互換用) */
+    get readyState(): number;
+    send(data: string): void;
+    addEventListener(type: 'message', handler: (ev: MessageEvent) => void): void;
+    removeEventListener(type: 'message', handler: (ev: MessageEvent) => void): void;
+    /** バッファをクリア（権威的 state 受信時に呼ぶ） */
+    clearBuffer(): void;
+    /** 全リソース解放 */
+    dispose(): void;
+    private connect;
+    private setState;
+    private scheduleReconnect;
+    private getReconnectDelay;
+    private flushBuffer;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private handlePong;
+}