@uzuhq/code-sdk 0.7.6 → 0.8.0

package/dist/run/server-action.js

@@ -1,181 +0,0 @@
-import { ReconnectableWebSocket } from '../reconnectable-ws.js';
-import { createOptimisticActionClient } from './optimistic-action-client.js';
-export function runOnlineServerAction(config, gameEndpoint, roomId, seatId, players, seatKind) {
-    // `kind` は移行期の互換措置。旧 SDK / 旧 play-server が読む wire を変えないために
-    // 残す。roster は player だけになったので値は常に 'player'。
-    const toWire = (p) => ({
-        id: p.id,
-        name: p.nickname,
-        iconUrl: p.iconUrl,
-        characterId: p.characterId,
-        kind: 'player',
-    });
-    const roster = JSON.stringify(players.map(toWire));
-    const query = new URLSearchParams({
-        seatId,
-        nickname: 'Player',
-        players: roster,
-        // 移行期: play-server / dev-server が `players=` を読めるようになる前の revision へ
-        // 繋ぐ経路が残る (JIT 再デプロイ前の焼き込み済みテンプレなど)。旧名も併せて送る。
-        seats: roster,
-    });
-    const wsUrl = `${gameEndpoint}/${roomId}?${query}`;
-    console.log(`[SDK ServerAction] 🔗 Connecting wsUrl=${wsUrl}`);
-    const ws = new ReconnectableWebSocket(wsUrl, {
-        onConnectionStateChange: (state) => {
-            console.log(`[SDK ServerAction] 📡 Connection state: ${state}`);
-            config.onConnectionStateChange?.(state);
-        },
-        // state 系メッセージはバッファしない（即座に stale になるため）
-        shouldBuffer: (data) => {
-            try {
-                const parsed = JSON.parse(data);
-                return (parsed.type !== '__state' &&
-                    parsed.type !== '__tick' &&
-                    parsed.type !== '__action_result' &&
-                    parsed.type !== '__game_start' &&
-                    parsed.type !== '__tick_delta' &&
-                    parsed.type !== '__action_result_delta');
-            }
-            catch {
-                return true;
-            }
-        },
-    });
-    /** サーバー seq (delta の連続性チェック用) */
-    let serverSeq = 0;
-    /** フル state 再要求中フラグ (多重要求防止) */
-    let requestStatePending = false;
-    /** 楽観更新クライアント (transport は本ファイル内で WebSocket に bind) */
-    const client = createOptimisticActionClient({
-        logic: config.logic,
-        playerId: seatId,
-        // seatKind は接続ごとに固定なのでここで束ねる。楽観更新クライアント側は
-        // 席種別を一切見ない (state の再適用にしか関心が無い)。
-        onState: (state, playerId) => config.onState(state, playerId, seatKind),
-        events: config.events,
-        sendAction: ({ action, payload, seq }) => {
-            console.log(`[SDK ServerAction] ➡ send __action action=${action} seq=${seq}`);
-            ws.send(JSON.stringify({ type: '__action', action, payload, seq }));
-        },
-    });
-    /** サーバーにフル state の再送を要求する */
-    const requestFullState = () => {
-        if (requestStatePending)
-            return;
-        requestStatePending = true;
-        console.log(`[SDK ServerAction] 🔄 Requesting full state (seq gap or patch failure)`);
-        ws.send(JSON.stringify({ type: '__request_state' }));
-    };
-    // ─── inputs callback (楽観更新クライアントに委譲) ──────────
-    config.inputs((type, payload) => {
-        client.send(type, payload);
-    });
-    // ─── メッセージハンドラ ────────────────────────────────
-    ws.addEventListener('message', (ev) => {
-        let parsed;
-        try {
-            parsed = JSON.parse(ev.data);
-        }
-        catch {
-            return;
-        }
-        const msgType = parsed.type;
-        console.log(`[SDK ServerAction] ⬅ recv type=${msgType}`);
-        // サーバーは全ブロードキャストに実時刻を載せる。どのメッセージでもオフセットを
-        // 更新できるので、tick が回っている限り追加の往復は要らない。
-        client.observeServerTime(parsed.serverTime);
-        if (msgType === '__room_init') {
-            // サーバー (relay-room / sync-room / game-room) はいずれも接続 URL の playerId
-            // クエリをそのまま `myId` として echo する。つまり parsed.myId は常に引数 playerId と
-            // 一致するため、client には作成時に playerId を渡しておけば ack 判定 (isMyAck) は
-            // 正しく動作する。ここで client の playerId を更新する必要はない。
-            console.log(`[SDK ServerAction] ✅ Room init myId=${parsed.myId}`);
-            return;
-        }
-        if (msgType === '__game_start') {
-            const seq = parsed.seq ?? 0;
-            serverSeq = seq;
-            requestStatePending = false;
-            // __game_start は new game / reset のシグナル。 applyState だと pending
-            // actions が新 state に対して再適用され、 reset 直後に isReady=true
-            // 等の残骸が付いてしまう。 reset() を呼んで pending を明示的にクリアする。
-            client.reset(parsed.state);
-            console.log(`[SDK ServerAction] 🎮 Game started (pending cleared)`);
-            return;
-        }
-        // ─── Tick 更新 (フル state) ───────────────────────────
-        if (msgType === '__tick') {
-            const evts = parsed.events ?? [];
-            serverSeq = parsed.seq ?? serverSeq + 1;
-            requestStatePending = false;
-            client.applyState(parsed.state, { events: evts });
-            return;
-        }
-        // ─── Tick 更新 (差分パッチ) ──────────────────────────
-        if (msgType === '__tick_delta') {
-            const evts = parsed.events ?? [];
-            const newSeq = parsed.seq ?? serverSeq + 1;
-            if (newSeq !== serverSeq + 1) {
-                requestFullState();
-                return;
-            }
-            const ok = client.applyDelta(parsed.patches ?? [], { events: evts });
-            if (!ok) {
-                requestFullState();
-                return;
-            }
-            serverSeq = newSeq;
-            requestStatePending = false;
-            return;
-        }
-        // ─── Action 結果 (フル state) ────────────────────────
-        if (msgType === '__action_result') {
-            const ack = parsed.ack;
-            const from = parsed.from;
-            const evts = parsed.events ?? [];
-            serverSeq = parsed.seq ?? serverSeq + 1;
-            requestStatePending = false;
-            client.applyState(parsed.state, { ack, from, events: evts });
-            return;
-        }
-        // ─── Action 結果 (差分パッチ) ────────────────────────
-        if (msgType === '__action_result_delta') {
-            const ack = parsed.ack;
-            const from = parsed.from;
-            const evts = parsed.events ?? [];
-            const newSeq = parsed.seq ?? serverSeq + 1;
-            if (newSeq !== serverSeq + 1) {
-                requestFullState();
-                return;
-            }
-            const ok = client.applyDelta(parsed.patches ?? [], {
-                ack,
-                from,
-                events: evts,
-            });
-            if (!ok) {
-                requestFullState();
-                return;
-            }
-            serverSeq = newSeq;
-            requestStatePending = false;
-            return;
-        }
-        if (msgType === '__action_error') {
-            const errorSeq = parsed.seq;
-            console.warn(`[SDK ServerAction] ⚠️ Action error: ${parsed.error} (seq=${errorSeq})`);
-            if (errorSeq !== undefined)
-                client.rollback(errorSeq);
-            return;
-        }
-        // ─── State 復元 (再接続 / late join) ─────────────────
-        if (msgType === '__state') {
-            serverSeq = parsed.seq ?? 0;
-            requestStatePending = false;
-            console.log(`[SDK ServerAction] 🔄 State restored (reconnect/late join) seq=${serverSeq}`);
-            client.reset(parsed.state);
-            return;
-        }
-    });
-}

package/dist/run/server-action.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/run/server-action.test.js

@@ -1,105 +0,0 @@
-/**
- * server-action.ts (オンライン接続) の unit test。
- *
- * 検証対象は「自分の席種別 (`seatKind`) の扱い」に絞る。楽観的更新まわりは
- * `optimistic-action-client.test.ts` が持っている。
- *
- * `seatKind` は roster に載らない観測者が GM ビューと観戦ビューを出し分けるためだけの
- * 値で、**client 内で完結する**。サーバーは roster に居ない接続を通すだけで、その席が
- * admin か spectator かを知る必要が無い。ここではその 2 点を固定する。
- */
-import { describe, expect, it, vi, afterEach } from 'vitest';
-import { runOnlineServerAction } from './server-action.js';
-const logic = {
-    setup: () => ({ moves: 0 }),
-    actions: {},
-    update: () => { },
-};
-const players = [
-    { id: 'p1', nickname: 'P1', iconUrl: '' },
-    { id: 'p2', nickname: 'P2', iconUrl: '' },
-];
-const stubWebSocket = () => {
-    const sockets = [];
-    class FakeWebSocket {
-        constructor(url) {
-            this.url = url;
-            this.readyState = FakeWebSocket.OPEN;
-            this.onopen = null;
-            this.onclose = null;
-            this.onerror = null;
-            this.onmessage = null;
-            sockets.push({
-                url,
-                push: (msg) => this.onmessage?.({ data: JSON.stringify(msg) }),
-            });
-            // ReconnectableWebSocket は onopen 登録後に発火する必要がある。
-            setTimeout(() => this.onopen?.(), 0);
-        }
-        send() { }
-        close() {
-            this.readyState = FakeWebSocket.CLOSED;
-        }
-    }
-    FakeWebSocket.OPEN = 1;
-    FakeWebSocket.CLOSED = 3;
-    vi.stubGlobal('WebSocket', FakeWebSocket);
-    return { sockets };
-};
-const connect = (seatKind, seatId = 'p1') => {
-    const { sockets } = stubWebSocket();
-    const onState = vi.fn();
-    const config = {
-        logic,
-        playerCount: 2,
-        onState,
-        inputs: () => { },
-    };
-    runOnlineServerAction(config, 'ws://localhost:1234/ws/games/rev1', 'room1', seatId, players, seatKind);
-    return { sockets, onState };
-};
-afterEach(() => {
-    vi.unstubAllGlobals();
-});
-describe('runOnlineServerAction の seatKind', () => {
-    /**
-     * `seatKind` は iframe URL 限定。WebSocket に載せると「サーバーが席種別を知っている」
-     * ように見えるが、自己申告なので何も保証しない。プロトコルを増やさない。
-     */
-    it('WebSocket URL に seatKind を載せない', () => {
-        const { sockets } = connect('admin', 'admin_0');
-        expect(sockets).toHaveLength(1);
-        const url = new URL(sockets[0].url);
-        expect(url.searchParams.get('seatKind')).toBeNull();
-        expect(url.searchParams.get('seatId')).toBe('admin_0');
-    });
-    /**
-     * roster (`?players=`) は player 席だけ。観測者は自分が載っていない roster を送る。
-     */
-    it('roster には自分が居なくてよい', () => {
-        const { sockets } = connect('admin', 'admin_0');
-        const raw = JSON.parse(new URL(sockets[0].url).searchParams.get('players') ?? '[]');
-        expect(raw.map((s) => s.id)).toEqual(['p1', 'p2']);
-    });
-    /**
-     * 移行期の互換措置。`players=` しか送らないと、JIT 再デプロイ前の焼き込み済み
-     * テンプレを持つ部屋が roster を pin できず起動しない。旧名にも同じ JSON を載せる。
-     */
-    it('旧名 seats にも同じ roster を載せる', () => {
-        const { sockets } = connect('player');
-        const params = new URL(sockets[0].url).searchParams;
-        expect(params.get('seats')).toBe(params.get('players'));
-    });
-    /** シナリオが GM ビューと観戦ビューを分けられるよう、自分の席種別だけを渡す。 */
-    it('onState の第 3 引数に自分の seatKind を渡す', () => {
-        const { sockets, onState } = connect('admin', 'admin_0');
-        sockets[0].push({ type: '__game_start', state: { moves: 0 }, seq: 0 });
-        expect(onState).toHaveBeenCalledWith({ moves: 0 }, 'admin_0', 'admin');
-    });
-    /** player 席も同じ経路で自分の席種別を受け取る。 */
-    it('player 席には player が渡る', () => {
-        const { sockets, onState } = connect('player');
-        sockets[0].push({ type: '__game_start', state: { moves: 0 }, seq: 0 });
-        expect(onState).toHaveBeenCalledWith({ moves: 0 }, 'p1', 'player');
-    });
-});

package/dist/server-clock.d.ts

@@ -1,29 +0,0 @@
-/**
- * @docs
- * - ServerAction仕様: docs/docs/uzu_code/connection-method/arch3-authority.md
- *
- * サーバー時刻の推定値をクライアント全体へ配る。
- *
- * state に入っている `endsAt` のような絶対時刻はサーバーの時計で打たれている。
- * それを端末の `Date.now()` と引き算すると、端末の時計ズレがそのまま表示のズレになる
- * (残り時間が恒久的に狂う / 期限判定がサーバーと食い違う)。読み取り側も同じ時計に
- * 揃えるための関数。
- *
- * ```ts
- * const remain = Math.ceil((state.game.timerEndsAt - serverNow()) / 1000);
- * ```
- *
- * オフセットは transport がサーバーからのメッセージを受けるたびに更新する。
- * 未接続 / 未観測ならローカル時刻をそのまま返す (オフラインでも壊れない)。
- */
-/** transport から呼ぶ内部関数。サーバーが打刻した時刻を観測してオフセットを更新する。 */
-export declare function observeServerTime(serverTime: number | undefined): void;
-/**
- * サーバー時刻の推定値 (ms)。
- *
- * カウントダウン描画のように毎秒/毎フレーム呼ぶ用途を想定しているので、
- * state の到着とは無関係にいつでも呼べる。
- */
-export declare function serverNow(): number;
-/** ソロモードなど「自分自身がサーバー」の経路で使う。 */
-export declare function resetServerTimeOffset(): void;

package/dist/server-clock.js

@@ -1,40 +0,0 @@
-/**
- * @docs
- * - ServerAction仕様: docs/docs/uzu_code/connection-method/arch3-authority.md
- *
- * サーバー時刻の推定値をクライアント全体へ配る。
- *
- * state に入っている `endsAt` のような絶対時刻はサーバーの時計で打たれている。
- * それを端末の `Date.now()` と引き算すると、端末の時計ズレがそのまま表示のズレになる
- * (残り時間が恒久的に狂う / 期限判定がサーバーと食い違う)。読み取り側も同じ時計に
- * 揃えるための関数。
- *
- * ```ts
- * const remain = Math.ceil((state.game.timerEndsAt - serverNow()) / 1000);
- * ```
- *
- * オフセットは transport がサーバーからのメッセージを受けるたびに更新する。
- * 未接続 / 未観測ならローカル時刻をそのまま返す (オフラインでも壊れない)。
- */
-let offset = 0;
-/** transport から呼ぶ内部関数。サーバーが打刻した時刻を観測してオフセットを更新する。 */
-export function observeServerTime(serverTime) {
-    if (typeof serverTime !== 'number' || !Number.isFinite(serverTime))
-        return;
-    // 下り片道遅延を無視するので推定は実サーバー時刻より僅かに遅れる。
-    // 表示用途では無視できる誤差なので、精度より単純さを取る。
-    offset = serverTime - Date.now();
-}
-/**
- * サーバー時刻の推定値 (ms)。
- *
- * カウントダウン描画のように毎秒/毎フレーム呼ぶ用途を想定しているので、
- * state の到着とは無関係にいつでも呼べる。
- */
-export function serverNow() {
-    return Date.now() + offset;
-}
-/** ソロモードなど「自分自身がサーバー」の経路で使う。 */
-export function resetServerTimeOffset() {
-    offset = 0;
-}

package/dist/server-only.d.ts

@@ -1,33 +0,0 @@
-/**
- * @docs
- * - ServerAction仕様: docs/docs/uzu_code/connection-method/arch3-authority.md
- * - 開発パターン: docs/docs/uzu_code/sdk-guide/patterns.md
- *
- * `serverOnly()` は `logic.serverActions` に置き換わった互換 API。
- *
- * 新しく書くコードでは `serverActions` フィールドへ直接置く。`actions` の型からは
- * ユニオンが外れたため、`serverOnly()` で wrap した handler を `actions` に入れることは
- * できない (型エラーになる)。
- *
- * `isServerOnlyAction()` はサーバー側テンプレが残す必要がある。R2 に保存済みの古い
- * logic.js は `serverOnly()` の brand を持ったまま `actions` に入っており、新しい
- * テンプレと組み合わさるため、brand を見ないと先読み対象として扱ってしまう。
- */
-import type { ActionHandler, ServerActionHandler, ServerOnlyAction } from './types.js';
-/**
- * @deprecated `logic.serverActions` に直接書く。
- *
- * ```ts
- * // before
- * actions: { notifyExternal: serverOnly(async (state) => { ... }) }
- * // after
- * serverActions: { notifyExternal: async (state) => { ... } }
- * ```
- */
-export declare function serverOnly<S>(handler: ServerActionHandler<S>): ServerOnlyAction<S>;
-/**
- * handler が `serverOnly()` で wrap されているか判定する。
- *
- * 移行期の互換用。`serverActions` へ移行済みの logic では常に false になる。
- */
-export declare function isServerOnlyAction<S>(handler: ActionHandler<S> | ServerActionHandler<S> | ServerOnlyAction<S> | undefined): handler is ServerOnlyAction<S>;

package/dist/server-only.js

@@ -1,21 +0,0 @@
-/**
- * @deprecated `logic.serverActions` に直接書く。
- *
- * ```ts
- * // before
- * actions: { notifyExternal: serverOnly(async (state) => { ... }) }
- * // after
- * serverActions: { notifyExternal: async (state) => { ... } }
- * ```
- */
-export function serverOnly(handler) {
-    return Object.assign(handler, { __serverOnly: true });
-}
-/**
- * handler が `serverOnly()` で wrap されているか判定する。
- *
- * 移行期の互換用。`serverActions` へ移行済みの logic では常に false になる。
- */
-export function isServerOnlyAction(handler) {
-    return (typeof handler === 'function' && '__serverOnly' in handler && handler.__serverOnly === true);
-}

package/dist/sync/local.d.ts

@@ -1,8 +0,0 @@
-/**
- * @docs
- * - SDK仕様: docs/docs/uzu_code/play-screen-sdk.md
- * - 開発パターン: docs/docs/uzu_code/sdk-guide/patterns.md
- */
-import type { SyncConfig } from '../types.js';
-import type { SyncHandle } from '../dev-hooks.js';
-export declare function syncLocal<S>(config: SyncConfig<S>): SyncHandle<S>;

package/dist/sync/local.js

@@ -1,50 +0,0 @@
-import { DEFAULT_ICON_URLS } from '../types.js';
-import { SERVER_TIME } from '../types.js';
-import { applyPatch } from '../json-patch.js';
-import { applyJsonMergePatch, applyJsonPatch } from '../dev-state-patch.js';
-function resolveLocalTime(ops) {
-    const now = Date.now();
-    return ops.map((op) => (op.value === SERVER_TIME ? { ...op, value: now } : op));
-}
-export function syncLocal(config) {
-    const { initialState, onState, inputs, events: _events } = config;
-    const localCount = config.playerCount;
-    const players = [];
-    for (let i = 0; i < localCount; i++) {
-        players.push({
-            id: `local_${i}`,
-            nickname: `Player ${i + 1}`,
-            iconUrl: DEFAULT_ICON_URLS[i % DEFAULT_ICON_URLS.length],
-        });
-    }
-    let state = initialState(players);
-    const myId = players[0].id;
-    const patchFn = (ops) => {
-        applyPatch(state, resolveLocalTime(ops));
-        onState(state, myId, Date.now());
-    };
-    const setFn = (path, value) => {
-        patchFn([{ op: 'replace', path, value }]);
-    };
-    inputs(patchFn, setFn);
-    onState(state, myId, Date.now());
-    // Periodic tick to keep serverTime flowing
-    setInterval(() => {
-        onState(state, myId, Date.now());
-    }, 100);
-    return {
-        getRawState: () => state,
-        setRawState: async (next) => {
-            state = next;
-            onState(state, myId, Date.now());
-        },
-        mergeRawState: async (patch) => {
-            applyJsonMergePatch(state, patch);
-            onState(state, myId, Date.now());
-        },
-        patchRawState: async (ops) => {
-            applyJsonPatch(state, ops);
-            onState(state, myId, Date.now());
-        },
-    };
-}

package/dist/sync/online.d.ts

@@ -1,5 +0,0 @@
-import type { SyncConfig, Seat } from '../types.js';
-import { ReconnectableWebSocket } from '../reconnectable-ws.js';
-export declare function syncOnline<S>(config: SyncConfig<S>, syncEndpoint: string, roomId: string, playerId: string, hostPlayers: Seat[]): {
-    ws: ReconnectableWebSocket;
-};

package/dist/sync/online.js

@@ -1,165 +0,0 @@
-import { SERVER_TIME } from '../types.js';
-import { applyPatch } from '../json-patch.js';
-import { ReconnectableWebSocket } from '../reconnectable-ws.js';
-export function syncOnline(config, syncEndpoint, roomId, playerId, hostPlayers) {
-    const { initialState, onState, inputs, events: _events } = config;
-    const wsUrl = `${syncEndpoint}/${roomId}?playerId=${encodeURIComponent(playerId)}`;
-    console.log(`[SDK Sync] 🔗 Connecting wsUrl=${wsUrl}`);
-    const ws = new ReconnectableWebSocket(wsUrl, {
-        onConnectionStateChange: (state) => {
-            console.log(`[SDK Sync] 📡 Connection state: ${state}`);
-            config.onConnectionStateChange?.(state);
-        },
-        // sync patch / patch_ack はバッファしない（再接続後にサーバーから権威的 state が来るため stale）
-        shouldBuffer: (data) => {
-            try {
-                const parsed = JSON.parse(data);
-                return parsed.type !== '__patch' && parsed.type !== '__patch_ack';
-            }
-            catch {
-                return true;
-            }
-        },
-    });
-    const myId = playerId;
-    const players = hostPlayers;
-    let state = null;
-    let gameInitSent = false;
-    // Server time offset: serverTime ≈ Date.now() + offset
-    let serverTimeOffset = 0;
-    // seq ベース整合性管理: サーバーからの patch_ack の連続性を追跡
-    let localSeq = 0;
-    // __request_state の連続送信を防ぐフラグ（__state 受信でリセット）
-    let requestStatePending = false;
-    const estimateServerTime = () => Date.now() + serverTimeOffset;
-    const resolveToServerTime = (ops) => {
-        const now = estimateServerTime();
-        return ops.map((op) => (op.value === SERVER_TIME ? { ...op, value: now } : op));
-    };
-    const sendPatch = (ops) => {
-        if (!ops || ops.length === 0)
-            return;
-        // Optimistic local apply (resolve sentinels to estimated server time)
-        if (state) {
-            applyPatch(state, resolveToServerTime(ops));
-            onState(state, myId, estimateServerTime());
-        }
-        // Send original ops (with sentinels) to server — server resolves with its own time
-        console.log(`[SDK Sync] ➡ send __patch ops=${ops.length}`, JSON.stringify(ops));
-        ws.send(JSON.stringify({ type: '__patch', ops }));
-    };
-    const sendSet = (path, value) => {
-        sendPatch([{ op: 'replace', path, value }]);
-    };
-    inputs(sendPatch, sendSet);
-    // Periodic tick — estimated server time を使って時間を進める
-    setInterval(() => {
-        if (state) {
-            onState(state, myId, estimateServerTime());
-        }
-    }, 100);
-    const tryInitState = () => {
-        if (gameInitSent)
-            return;
-        gameInitSent = true;
-        const initState = initialState(players);
-        console.log(`[SDK Sync] ➡ send __init_state players=${players.length}`);
-        ws.send(JSON.stringify({ type: '__init_state', state: initState }));
-    };
-    ws.addEventListener('message', (ev) => {
-        let parsed;
-        try {
-            parsed = JSON.parse(ev.data);
-        }
-        catch {
-            return;
-        }
-        const msgType = parsed.type;
-        console.log(`[SDK Sync] ⬅ recv type=${msgType}`, JSON.stringify(parsed));
-        if (msgType === '__room_init') {
-            console.log(`[SDK Sync] ✅ Room init myId=${myId} players=${players.length}`);
-            tryInitState();
-            return;
-        }
-        if (msgType === '__reconnected') {
-            // 再接続成功 — サーバーから __state が後続で届くので再初期化はスキップ
-            console.log(`[SDK Sync] 🔄 Reconnected myId=${myId}`);
-            // state が未初期化の場合のみ再送（初回接続中に切断→再接続した場合）
-            if (!gameInitSent) {
-                tryInitState();
-            }
-            return;
-        }
-        if (msgType === '__state_cleared') {
-            // サーバーで state がクリアされた → ローカルもリセットして再初期化
-            console.log(`[SDK Sync] 🗑 State cleared, reinitializing`);
-            state = null;
-            localSeq = 0;
-            requestStatePending = false;
-            gameInitSent = false;
-            tryInitState();
-            return;
-        }
-        if (msgType === '__patch_failed') {
-            console.log(`[SDK Sync] ⚠️ Patch failed: ${parsed.reason}`);
-            config.onPatchFailed?.(parsed.reason);
-            // サーバーから __state が後続で届く → そちらで state を上書き
-            return;
-        }
-        if (msgType === '__patch_ack') {
-            if (!state)
-                return;
-            const ackSeq = parsed.seq ?? 0;
-            const ackSenderId = parsed.senderId;
-            const ackOps = parsed.ops;
-            const serverTime = parsed.serverTime;
-            // 送信元が自分の場合は楽観的更新済みなので patch 適用はスキップ、seq と時刻のみ同期
-            if (ackSenderId === myId) {
-                localSeq = ackSeq;
-                serverTimeOffset = serverTime - Date.now();
-                return;
-            }
-            // full state 再要求中は patch 適用をスキップ（壊れた state への追加適用を防止）
-            if (requestStatePending)
-                return;
-            // seq の連続性チェック
-            if (ackSeq === localSeq + 1) {
-                // 正常: 差分をローカル state に適用
-                const ok = applyPatch(state, ackOps);
-                if (!ok) {
-                    // 楽観的更新でローカル state が diverge → full state でリカバリ
-                    console.log(`[SDK Sync] ⚠️ Local applyPatch failed, requesting full state`);
-                    requestStatePending = true;
-                    ws.send(JSON.stringify({ type: '__request_state' }));
-                    return;
-                }
-                localSeq = ackSeq;
-                serverTimeOffset = serverTime - Date.now();
-                onState(state, myId, serverTime);
-            }
-            else if (ackSeq > localSeq + 1) {
-                // 欠損検知: full state を再要求
-                console.log(`[SDK Sync] ⚠️ Seq gap detected: expected=${localSeq + 1} received=${ackSeq}, requesting full state`);
-                requestStatePending = true;
-                ws.send(JSON.stringify({ type: '__request_state' }));
-            }
-            // ackSeq <= localSeq: 過去の重複 → 無視
-            return;
-        }
-        if (msgType === '__state') {
-            // Server authoritative state — overwrite local + seq 同期
-            state = parsed.state;
-            const serverTime = parsed.serverTime;
-            localSeq = parsed.seq ?? 0;
-            requestStatePending = false;
-            // Calibrate offset from server time
-            serverTimeOffset = serverTime - Date.now();
-            console.log(`[SDK Sync] ✅ State received serverTime=${serverTime} offset=${serverTimeOffset} seq=${localSeq}`);
-            // 再接続後のバッファをクリア（stale patch を破棄）
-            ws.clearBuffer();
-            onState(state, myId, serverTime);
-            return;
-        }
-    });
-    return { ws };
-}