@uzuhq/code-sdk 0.3.8

package/dist/run/server-action.js

@@ -0,0 +1,170 @@
+import { ReconnectableWebSocket } from '../reconnectable-ws.js';
+import { createOptimisticActionClient } from './optimistic-action-client.js';
+export function runOnlineServerAction(config, gameEndpoint, roomId, seatId, seats) {
+    const toWire = (p) => ({
+        id: p.id,
+        name: p.nickname,
+        iconUrl: p.iconUrl,
+        characterId: p.characterId,
+        kind: p.kind,
+    });
+    const query = new URLSearchParams({
+        seatId,
+        nickname: 'Player',
+        seats: JSON.stringify(seats.map(toWire)),
+    });
+    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,
+        onState: config.onState,
+        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}`);
+        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/server-only.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @docs
+ * - ServerAction仕様: docs/docs/play_screen_v3/connection-method/arch3-authority.md
+ * - 開発パターン: docs/docs/play_screen_v3/sdk-guide/patterns.md
+ *
+ * serverOnly() で wrap した handler はクライアント側の楽観的更新（先行実行）を
+ * スキップし、サーバー側でだけ実行される。fetch などの副作用付き処理を安全に
+ * 書ける。
+ */
+import type { ActionHandler, ServerOnlyAction, ServerOnlyActionHandlerFn } from './types.js';
+/**
+ * server-only action handler を作る。
+ *
+ * 例:
+ * ```ts
+ * actions: {
+ *   notifyExternal: serverOnly(async (state, payload, playerId) => {
+ *     await fetch('https://example.com/notify', { ... });
+ *     state.notifiedAt = Date.now();
+ *   }),
+ * }
+ * ```
+ */
+export declare function serverOnly<S>(handler: ServerOnlyActionHandlerFn<S>): ServerOnlyAction<S>;
+/** handler が serverOnly() で wrap されているか判定する。 */
+export declare function isServerOnlyAction<S>(handler: ActionHandler<S> | ServerOnlyAction<S> | undefined): handler is ServerOnlyAction<S>;

package/dist/server-only.js

@@ -0,0 +1,20 @@
+/**
+ * server-only action handler を作る。
+ *
+ * 例:
+ * ```ts
+ * actions: {
+ *   notifyExternal: serverOnly(async (state, payload, playerId) => {
+ *     await fetch('https://example.com/notify', { ... });
+ *     state.notifiedAt = Date.now();
+ *   }),
+ * }
+ * ```
+ */
+export function serverOnly(handler) {
+    return Object.assign(handler, { __serverOnly: true });
+}
+/** handler が serverOnly() で wrap されているか判定する。 */
+export function isServerOnlyAction(handler) {
+    return (typeof handler === 'function' && '__serverOnly' in handler && handler.__serverOnly === true);
+}

package/dist/sync/local.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @docs
+ * - SDK仕様: docs/docs/play_screen_v3/play-screen-sdk.md
+ * - 開発パターン: docs/docs/play_screen_v3/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

@@ -0,0 +1,51 @@
+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],
+            kind: 'player',
+        });
+    }
+    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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,165 @@
+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 };
+}

package/dist/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * @docs
+ * - SDK仕様: docs/docs/play_screen_v3/play-screen-sdk.md
+ * - APIリファレンス: docs/docs/play_screen_v3/sdk-guide/api-reference.md
+ * - 開発パターン: docs/docs/play_screen_v3/sdk-guide/patterns.md
+ * - 外部 automation API: docs/docs/play_screen_v3/sdk-guide/dev-hooks.md
+ */
+/** @deprecated 旧フラット形式。新コードでは BridgeMessage を使用 */
+export type PlayScreenMessage = {
+    type: string;
+    [key: string]: unknown;
+};
+/** ブリッジメッセージのチャンネル */
+export type BridgeChannel = 'sdk' | 'game';
+/** ワイヤーフォーマット: { channel, type, payload, playerId? } */
+export interface BridgeMessage {
+    channel: BridgeChannel;
+    type: string;
+    payload: Record<string, unknown>;
+    /**
+     * 送信元プレイヤーの ID（ゲーム → ホスト方向のみ）。
+     * Web エミュレータでは複数プレイヤーの iframe が同一オリジンになり
+     * postMessage の送信元 iframe を区別できないため、ホストはこの値で
+     * 自分宛メッセージかを判定する。
+     *
+     * Flutter ホスト（QueryParamsBuilder）と dev ハーネスは URL に必ず
+     * playerId を付与するため、ゲーム → ホスト方向では常に存在する。
+     * optional なのはホスト → ゲーム方向のメッセージが持たないため
+     * （受信側は playerId 無し = 旧 SDK ビルドとして扱う）。
+     */
+    playerId?: string;
+}
+/**
+ * セッションの席種。
+ * - player: ゲームの参加者 (キャラクターを担当する)
+ * - spectator: 観戦者 (state を閲覧するだけで、ゲームの席は占めない)
+ * - admin: 進行管理席 (観戦 + GM 操作。dev harness のテストプレイ用)
+ */
+export type SeatKind = 'player' | 'spectator' | 'admin';
+export interface Seat {
+    id: string;
+    nickname: string;
+    iconUrl: string;
+    /** ホスト（mobile / emulator）から渡される、選択済みキャラクターの ID。未選択時は undefined。 */
+    characterId?: string;
+    /** 席種。 */
+    kind: SeatKind;
+}
+/** プレイヤーごとのリアルタイム状態 */
+export interface PlayerVoiceState {
+    /** 音声状態。音声通話に未接続の場合は null */
+    audioStatus: 'speaking' | 'listening' | 'muted' | 'unstable' | null;
+}
+/** @deprecated 旧形式。新コードでは onPlayersChanged() と PlayerVoiceState を使用 */
+export interface PlayersChangedMessage {
+    players: Record<string, PlayerVoiceState>;
+}
+export type Emit = (eventName: string, data?: Record<string, unknown>) => void;
+/** dev harness で観測される 1 件の emit。`data` は `emit(name)` 省略時に空 object になる。 */
+export interface ServerEvent {
+    name: string;
+    data: Record<string, unknown>;
+}
+export interface SeededRandom {
+    float(): number;
+    int(max: number): number;
+    pick<T>(array: T[]): T;
+    shuffle<T>(array: T[]): T[];
+}
+export type ActionHandler<S> = (state: S, payload: any, playerId: string, emit: Emit, ctx: {
+    tick: number;
+}) => void;
+export type ServerOnlyActionHandlerFn<S> = (state: S, payload: any, playerId: string, emit: Emit, ctx: {
+    tick: number;
+}) => Promise<void> | void;
+/** serverOnly() で wrap された handler。`__serverOnly` brand で識別する。 */
+export type ServerOnlyAction<S> = ServerOnlyActionHandlerFn<S> & {
+    readonly __serverOnly: true;
+};
+export interface GameLogic<S> {
+    /**
+     * seats には kind !== 'player' の席 (spectator / admin) も含まれる。
+     * ゲームの配役は kind === 'player' (または kind 省略) だけを対象にすること。
+     */
+    setup(seats: Seat[], random: SeededRandom): S;
+    actions: Record<string, ActionHandler<S> | ServerOnlyAction<S>>;
+    update(state: S, ctx: {
+        random: SeededRandom;
+        tick: number;
+        emit: Emit;
+        playerInputs: Record<string, Record<string, any>>;
+    }): void;
+    tickRate?: number;
+}
+export interface GameConfig<S> extends ConnectionCallbacks {
+    logic: GameLogic<S>;
+    onState: (state: S, myPlayerId: string) => void;
+    inputs: (sendAction: (type: string, payload?: any) => void) => void;
+    events?: Record<string, (data: Record<string, unknown>) => void>;
+    playerCount: number;
+    /** Dev harness のデフォルト向き。manifest.json の `orientation` を渡す。 */
+    orientation?: 'portrait' | 'landscape';
+    /**
+     * Dev harness で各 iframe inner viewport 短辺の下限 (CSS px)。
+     * default 360。狭い viewport では親 frame に `body { zoom: N }` を当てて
+     * iframe 内部の `window.innerWidth/Height` を保証する。
+     */
+    devMinIframeShortEdge?: number;
+}
+export type PatchFn = (ops: Operation[]) => void;
+export type SetFn = (path: string, value: unknown) => void;
+export interface SyncConfig<S = any> extends ConnectionCallbacks {
+    initialState: (seats: Seat[]) => S;
+    onState: (state: S, myPlayerId: string, serverTime: number) => void;
+    inputs: (patch: PatchFn, set: SetFn) => void;
+    events?: Record<string, (data: Record<string, unknown>) => void>;
+    playerCount: number;
+    /** Dev harness のデフォルト向き。manifest.json の `orientation` を渡す。 */
+    orientation?: 'portrait' | 'landscape';
+    /**
+     * Dev harness で各 iframe inner viewport 短辺の下限 (CSS px)。
+     * default 360。狭い viewport では親 frame に `body { zoom: N }` を当てて
+     * iframe 内部の `window.innerWidth/Height` を保証する。
+     */
+    devMinIframeShortEdge?: number;
+}
+export interface Operation {
+    op: 'replace' | 'add' | 'remove';
+    path: string;
+    value?: unknown;
+}
+/** Sentinel value — patch の value にセットすると、サーバーが Date.now() に置換する */
+export declare const SERVER_TIME: "__SERVER_TIME__";
+/** デフォルトのプレイヤーアイコン URL 一覧（dev / local モード用） */
+export declare const DEFAULT_ICON_URLS: readonly ["https://imagedelivery.net/htp-D7B2hJT5XtdWYN9e7Q/4d0da24d-bcf2-4f7b-d1a0-f1bb8c747300/original", "https://imagedelivery.net/htp-D7B2hJT5XtdWYN9e7Q/8c75fccb-41d6-429d-e943-06c728a72a00/original", "https://imagedelivery.net/htp-D7B2hJT5XtdWYN9e7Q/43f45d11-da38-4d6e-637d-3df78e583500/original"];
+export type ConnectionState = 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
+export interface ConnectionCallbacks {
+    /** WebSocket 接続状態が変化した時に呼ばれる */
+    onConnectionStateChange?: (state: ConnectionState) => void;
+    /** サーバーで patch 適用が失敗した時に呼ばれる (sync モード専用) */
+    onPatchFailed?: (reason: string) => void;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+/** Sentinel value — patch の value にセットすると、サーバーが Date.now() に置換する */
+export const SERVER_TIME = '__SERVER_TIME__';
+/** デフォルトのプレイヤーアイコン URL 一覧（dev / local モード用） */
+export const DEFAULT_ICON_URLS = [
+    'https://imagedelivery.net/htp-D7B2hJT5XtdWYN9e7Q/4d0da24d-bcf2-4f7b-d1a0-f1bb8c747300/original',
+    'https://imagedelivery.net/htp-D7B2hJT5XtdWYN9e7Q/8c75fccb-41d6-429d-e943-06c728a72a00/original',
+    'https://imagedelivery.net/htp-D7B2hJT5XtdWYN9e7Q/43f45d11-da38-4d6e-637d-3df78e583500/original',
+];

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@uzuhq/code-sdk",
+  "version": "0.3.8",
+  "description": "UZU PlayScreen SDK - Flutter ↔ JS ゲーム通信ライブラリ",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./dev-globals": {
+      "types": "./dist/dev-globals.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "homepage": "https://uzu-app.com",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "devDependencies": {
+    "happy-dom": "^20.10.6",
+    "typescript": "^6.0.0",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "test": "vitest run"
+  }
+}