@uzuhq/code-sdk 0.7.6 → 0.8.0

package/dist/index.js

@@ -1,20 +1,1864 @@
-export { SERVER_TIME, DEFAULT_ICON_URLS } from './types.js';
-export { serverOnly, isServerOnlyAction } from './server-only.js';
-export { serverNow } from './server-clock.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';
-export { getPredictionWarnings } from './dev-prediction-traps.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();
+//#region ../engine-core/src/types.ts
+/** Sentinel value — patch の value にセットすると、サーバーが Date.now() に置換する */
+const SERVER_TIME = "__SERVER_TIME__";
+/** デフォルトのプレイヤーアイコン URL 一覧（dev / local モード用） */
+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"
+];
+//#endregion
+//#region ../engine-core/src/game-time.ts
+/**
+* `GameTime` に長さを足す。
+*
+* 算術をすると brand が落ちる (`number + number = number`) ので、`GameTime` を
+* 作り直す道はこの関数と `ctx.after` に限られる。
+*/
+const plus = (t, d) => t + d;
+/** 2 つの `GameTime` の差 (ms)。 */
+const minus = (a, b) => a - b;
+/**
+* エンジン内部専用。作家コードから呼ばない。
+*
+* 時計の実装 (play-server の facet / dev-server / ソロ / SDK の補間) だけがここを通る。
+*/
+const asGameTime = (ms) => ms;
+//#endregion
+//#region ../engine-core/src/game-clock.ts
+/**
+* @docs
+* - 緊急停止とゲーム内時計: docs/docs/uzu_code/emergency-stop.md
+*
+* ゲーム内時計の実体。3 つのサーバー実装 (play-server の facet / cli の dev-server /
+* SDK のソロ) が同じ挙動になるよう、時計の算術と凍結の出入りをここ 1 箇所に置く。
+*
+* ここに置かないもの: 永続化・tick ループ・broadcast・無人凍結の発火条件。
+* それらはランタイムごとに手段が違うので、各実装が持つ。
+*/
+/**
+* ゲーム開始からの経過時間を数える時計。停止中は進まない。
+*
+* 実体はスカラー 3 本。シナリオの state は 1 バイトも書き換えない (どのフィールドが
+* 時刻かエンジンは知らないので書き換えられない)。
+*/
+var GameClock = class {
+	constructor() {
+		this.startedAtWall = 0;
+		this.pausedTotalMs = 0;
+		this.pausedAtWall = null;
+		this.frozenBy = /* @__PURE__ */ new Set();
+	}
+	/** 時計を 0 から始め直す。`setup()` を呼ぶ直前に通す。 */
+	restart() {
+		this.startedAtWall = Date.now();
+		this.pausedTotalMs = 0;
+		this.pausedAtWall = null;
+		this.frozenBy.clear();
+	}
+	get frozen() {
+		return this.frozenBy.size > 0;
+	}
+	isFrozenBy(reason) {
+		return this.frozenBy.has(reason);
+	}
+	/**
+	* 現在のゲーム内時刻。停止中は `pausedAtWall` で凍るので同じ値を返し続ける。
+	*
+	* IMPORTANT: [withGameClock] の中で呼んではいけない。実装が `Date.now()` を読むので、
+	* 差し替え済みの時刻を実時刻として引き算し、大きく負の値になる。
+	* ハンドラへ渡す時刻は必ず外で 1 回取ってから渡すこと。
+	*/
+	now() {
+		return asGameTime((this.pausedAtWall ?? Date.now()) - this.startedAtWall - this.pausedTotalMs);
+	}
+	/** ゲーム内時刻を、alarm / setTimeout が使う実時刻へ直す。 */
+	toWall(at) {
+		return at + this.startedAtWall + this.pausedTotalMs;
+	}
+	/** 実際に理由を足したら true。呼び出し側が永続化や tick 停止の要否に使う。 */
+	freeze(reason) {
+		if (this.frozenBy.has(reason)) return false;
+		const wasFrozen = this.frozen;
+		this.frozenBy.add(reason);
+		if (!wasFrozen) this.pausedAtWall = Date.now();
+		return true;
+	}
+	/** 実際に理由を外したら true。 */
+	unfreeze(reason) {
+		if (!this.frozenBy.delete(reason)) return false;
+		if (!this.frozen && this.pausedAtWall !== null) {
+			this.pausedTotalMs += Date.now() - this.pausedAtWall;
+			this.pausedAtWall = null;
+		}
+		return true;
+	}
+	snapshot() {
+		return {
+			startedAtWall: this.startedAtWall,
+			pausedTotalMs: this.pausedTotalMs,
+			pausedAtWall: this.pausedAtWall,
+			frozenBy: [...this.frozenBy]
+		};
+	}
+	/**
+	* 永続化した内容から復元する。欠損は「未停止」に倒す。
+	*
+	* 読めなかったせいで世界が止まったままになる方が、動き出すより悪い。
+	*/
+	restore(saved) {
+		this.startedAtWall = saved.startedAtWall ?? 0;
+		this.pausedTotalMs = saved.pausedTotalMs ?? 0;
+		this.pausedAtWall = saved.pausedAtWall ?? null;
+		this.frozenBy.clear();
+		for (const reason of saved.frozenBy ?? []) this.frozenBy.add(reason);
+		if (this.frozen && this.pausedAtWall === null) this.frozenBy.clear();
+	}
+};
+/**
+* 作家の**同期**ハンドラを、時刻 API を差し替えた状態で走らせる。
+*
+* `sdk/src/dev-prediction-traps.ts` の runPredicted と同じ形。あちらは dev で警告を
+* 出すための差し替えだが、こちらはゲーム内時計を返すための差し替え。
+* `await` を挟まないので、JS が単一スレッドである以上ほかの部屋と混ざらない。
+*
+* IMPORTANT: 3 実装すべてで通すこと。ここが片方だけだと、生 `Date.now()` を書いた
+* シナリオが「dev では壊れるのに本番では動く」(あるいはその逆) になる。
+*
+* 適用しないもの:
+* - `serverActions` — async なので `await` をまたぐと復元が効かない
+* - `deadlines[].at()` — state だけの純関数という契約があり、毎 state 変更で呼ばれる
+*
+* IMPORTANT: `fn` は**同期で完結すること**。`await` をまたぐと差し替えたまま制御が
+* 抜け、無関係な処理まで偽の `Date.now` を読む。`fn` が Promise を返す形にしたく
+* なったら、それは `serverActions` 側へ寄せるべき処理という合図。
+*
+* IMPORTANT: `fn` の中で [GameClock.now] を呼ばないこと。差し替えた `Date.now` を
+* 実時刻として引き算してしまう。ハンドラへ渡す ctx は呼び出す前に組み立てる。
+*/
+function withGameClock(time, fn) {
+	const realNow = Date.now;
+	const RealDate = Date;
+	Date.now = () => time;
+	globalThis.Date = new Proxy(RealDate, { construct: (target, args) => Reflect.construct(target, args.length === 0 ? [time] : args) });
+	try {
+		return fn();
+	} finally {
+		globalThis.Date = RealDate;
+		Date.now = realNow;
+	}
+}
+/**
+* `deadlines[].at()` が返した値を締切として使えるかに正規化する。使えなければ null。
+*
+* `null` / `undefined` は「締切なし」で正常なので黙って捨てる。**数値だが有限でない
+* (NaN / Infinity) 場合だけは記録に残す。** これはほぼ確実に `undefined` を含む算術の
+* 結果で、旧 `ctx.now` を読んでいるシナリオを新エンジンで動かすと
+* `undefined + 尺 = NaN` になり、締切が「二度と来ない」形で静かに死ぬ。
+* 黙って捨てるとログにも例外にも出ないので、key ごとに 1 回だけ必ず出す。
+*
+* `report` を受け取るのは、engine-core が `console` を含むどのランタイム API にも
+* 依存できないため (3 ランタイムが lib ES2022 だけでこのファイルを共有している)。
+*
+* @param warned 既に警告した key。呼び出し側がインスタンスごとに持つ。
+*/
+function resolveDeadline(at, key, warned, report) {
+	if (at === null || at === void 0) return null;
+	if (typeof at === "number" && Number.isFinite(at)) return asGameTime(at);
+	if (!warned.has(key)) {
+		warned.add(key);
+		report(`deadline "${key}" の at() が締切に使えない値を返した: ${String(at)}。この締切は二度と発火しない。廃止された ctx.now を読んでいないか確認すること`);
+	}
+	return null;
+}
+//#endregion
+//#region ../engine-core/src/json-patch.ts
+function unescapePointer(token) {
+	return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+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 === void 0 || 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 === void 0 || 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;
+}
+//#endregion
+//#region ../engine-core/src/random.ts
+var SeededRandomImpl = 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 + 1831565813 | 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;
+	}
+};
+//#endregion
+//#region ../engine-core/src/server-only.ts
+/**
+* @deprecated `logic.serverActions` に直接書く。
+*
+* ```ts
+* // before
+* actions: { notifyExternal: serverOnly(async (state) => { ... }) }
+* // after
+* serverActions: { notifyExternal: async (state) => { ... } }
+* ```
+*/
+function serverOnly(handler) {
+	return Object.assign(handler, { __serverOnly: true });
+}
+/**
+* handler が `serverOnly()` で wrap されているか判定する。
+*
+* 移行期の互換用。`serverActions` へ移行済みの logic では常に false になる。
+*/
+function isServerOnlyAction(handler) {
+	return typeof handler === "function" && "__serverOnly" in handler && handler.__serverOnly === true;
+}
+//#endregion
+//#region src/server-clock.ts
+/**
+* @docs
+* - ServerAction仕様: docs/docs/uzu_code/connection-method/arch3-authority.md
+* - 緊急停止とゲーム内時計: docs/docs/uzu_code/emergency-stop.md
+*
+* サーバーのゲーム内時計の推定値をクライアント全体へ配る。
+*
+* state に入っている `endsAt` のような締切はサーバーのゲーム内時計で打たれている。
+* 読み取り側も同じ時計に揃えないと、残り時間が恒久的に狂う。
+*
+* ```ts
+* const remain = Math.ceil(minus(state.game.timerEndsAt, gameTime()) / 1000);
+* ```
+*
+* 基準は `performance.now()` (単調時計)。`Date.now()` を長さの計算に使うと、端末の時計が
+* NTP やユーザー操作でずれた瞬間に全部のカウントダウンが飛ぶ。POSIX / Rust / C++ が
+* 揃って禁じている形なので、ここでも採らない。
+*
+* オフセットは transport がサーバーからのメッセージを受けるたびに更新する。
+* 未接続 / 未観測ならオフセット 0 のまま (オフラインでも壊れない)。
+*/
+let offset = 0;
+/** 停止中に凍らせた値。null なら進んでいる。 */
+let frozenAt = null;
+/**
+* transport から呼ぶ内部関数。サーバーが打刻したゲーム内時刻を観測してオフセットを更新する。
+*
+* 下り片道遅延を無視するので推定は実サーバー時刻より僅かに遅れる。
+* 表示用途では無視できる誤差なので、精度より単純さを取る。
+*/
+function observeGameTime(t) {
+	if (typeof t !== "number" || !Number.isFinite(t)) return;
+	offset = t - performance.now();
+}
+/**
+* ゲーム内時刻の推定値。停止中は凍る。
+*
+* カウントダウン描画のように毎秒/毎フレーム呼ぶ用途を想定しているので、
+* state の到着とは無関係にいつでも呼べる。
+*/
+function gameTime() {
+	return asGameTime(frozenAt ?? performance.now() + offset);
+}
+/**
+* 時計を凍らせる。
+*
+* 停止中はサーバーの broadcast が止まって打刻が来ないので、`__pause_state` を受けた
+* 時点の値で明示的に止める。解除後は通常の打刻でオフセットが入れ替わるため、
+* 特別な補正は要らない。
+*/
+function freezeGameTime() {
+	frozenAt = gameTime();
+}
+function unfreezeGameTime() {
+	frozenAt = null;
+}
+//#endregion
+//#region src/pause-state.ts
+/**
+* @docs
+* - 緊急停止とゲーム内時計: docs/docs/uzu_code/emergency-stop.md
+*
+* 緊急停止の状態を SDK 全体で 1 箇所に持つ。
+*
+* 停止は state ではない。シナリオの state に持ち込むと「停止中は state を変えるコードが
+* 1 行も走らない」という不変条件が崩れるので、`GameLogic` へは渡さず読み取り専用の
+* 関数として出す。用途は演出の停止 (rAF ループを止める等) に限る。
+*
+* ゲーム内時計の凍結もここから駆動する。停止フラグと時計の凍結が別々に動くと、
+* 「止まっているのにカウントダウンだけ進む」がいつか必ず起きる。
+*/
+let paused = false;
+let pausedBy = null;
+const listeners = /* @__PURE__ */ new Set();
+/** transport から呼ぶ内部関数。停止状態が変わったときだけ通知する。 */
+function setPauseState(next, by) {
+	pausedBy = next ? by : null;
+	if (next === paused) return;
+	paused = next;
+	if (paused) freezeGameTime();
+	else unfreezeGameTime();
+	for (const cb of listeners) try {
+		cb(paused);
+	} catch (err) {
+		console.warn("[uzu] onPauseChange listener threw:", err);
+	}
+}
+/** 緊急停止中か。 */
+function isPaused() {
+	return paused;
+}
+/** 停止を要求した playerId。停止していなければ null。 */
+function getPausedBy() {
+	return pausedBy;
+}
+/** 停止状態の変化を購読する。 */
+function onPauseChange(cb) {
+	listeners.add(cb);
+}
+let requester = null;
+function setPauseRequester(fn) {
+	requester = fn;
+}
+function requestPause() {
+	if (!requester) {
+		console.warn("[uzu] requestPause: サーバーへ接続していないので停止できません");
+		return;
+	}
+	requester(true);
+}
+function requestResume() {
+	if (!requester) {
+		console.warn("[uzu] requestResume: サーバーへ接続していないので解除できません");
+		return;
+	}
+	requester(false);
+}
+//#endregion
+//#region src/room.ts
+var Room = class {
+	constructor(ws, myId) {
+		this.handlers = /* @__PURE__ */ new Map();
+		this.ws = ws;
+		this.myId = myId;
+		this.ws.addEventListener("message", (ev) => {
+			let parsed;
+			try {
+				parsed = JSON.parse(ev.data);
+			} catch {
+				return;
+			}
+			const type = parsed.type;
+			if (!type) return;
+			const from = parsed.__from;
+			console.log(`[SDK Room] ⬅ recv type=${type} from=${from}`, JSON.stringify(parsed));
+			(this.handlers.get(type) || []).forEach((h) => h({
+				...parsed,
+				__from: from
+			}));
+		});
+	}
+	broadcast(msg) {
+		console.log(`[SDK Room] ➡ broadcast type=${msg.type}`, JSON.stringify(msg));
+		this.ws.send(JSON.stringify(msg));
+	}
+	send(id, msg) {
+		console.log(`[SDK Room] ➡ send to=${id} type=${msg.type}`, JSON.stringify(msg));
+		this.ws.send(JSON.stringify({
+			...msg,
+			__to: id
+		}));
+	}
+	on(type, handler) {
+		if (!this.handlers.has(type)) this.handlers.set(type, []);
+		this.handlers.get(type).push(handler);
+	}
+};
+//#endregion
+//#region src/reconnectable-ws.ts
+const DEFAULTS = {
+	maxReconnectAttempts: 15,
+	baseDelay: 1e3,
+	maxDelay: 3e4,
+	jitterFactor: .5,
+	heartbeatInterval: 25e3,
+	heartbeatTimeout: 1e4,
+	maxBufferSize: 50
+};
+var ReconnectableWebSocket = class {
+	constructor(url, options = {}) {
+		this.ws = null;
+		this._state = "connecting";
+		this.reconnectAttempt = 0;
+		this.messageBuffer = [];
+		this.messageHandlers = [];
+		this.heartbeatTimer = null;
+		this.heartbeatTimeoutTimer = null;
+		this.reconnectTimer = null;
+		this.disposed = false;
+		this.url = url;
+		this.opts = {
+			maxReconnectAttempts: options.maxReconnectAttempts ?? DEFAULTS.maxReconnectAttempts,
+			baseDelay: options.baseDelay ?? DEFAULTS.baseDelay,
+			maxDelay: options.maxDelay ?? DEFAULTS.maxDelay,
+			jitterFactor: options.jitterFactor ?? DEFAULTS.jitterFactor,
+			heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
+			heartbeatTimeout: options.heartbeatTimeout ?? DEFAULTS.heartbeatTimeout,
+			maxBufferSize: options.maxBufferSize ?? DEFAULTS.maxBufferSize,
+			shouldBuffer: options.shouldBuffer,
+			onConnectionStateChange: options.onConnectionStateChange
+		};
+		this.connect();
+	}
+	get connectionState() {
+		return this._state;
+	}
+	/** WebSocket.readyState 互換 (既存コードとの互換用) */
+	get readyState() {
+		return this.ws?.readyState ?? WebSocket.CLOSED;
+	}
+	send(data) {
+		if (this._state === "connected" && this.ws?.readyState === WebSocket.OPEN) this.ws.send(data);
+		else if (this._state === "reconnecting") {
+			if (this.opts.shouldBuffer && !this.opts.shouldBuffer(data)) return;
+			if (this.messageBuffer.length < this.opts.maxBufferSize) this.messageBuffer.push(data);
+		}
+	}
+	addEventListener(type, handler) {
+		if (type === "message") this.messageHandlers.push(handler);
+	}
+	removeEventListener(type, handler) {
+		if (type === "message") {
+			const index = this.messageHandlers.indexOf(handler);
+			if (index !== -1) this.messageHandlers.splice(index, 1);
+		}
+	}
+	/** バッファをクリア（権威的 state 受信時に呼ぶ） */
+	clearBuffer() {
+		this.messageBuffer = [];
+	}
+	/** 全リソース解放 */
+	dispose() {
+		this.disposed = true;
+		this.stopHeartbeat();
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.ws) {
+			this.ws.onopen = null;
+			this.ws.onclose = null;
+			this.ws.onerror = null;
+			this.ws.onmessage = null;
+			try {
+				if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) this.ws.close();
+			} catch (e) {
+				console.warn("[ReconnectableWS] Error closing WebSocket:", e);
+			}
+			this.ws = null;
+		}
+	}
+	connect() {
+		if (this.disposed) return;
+		console.log(`[ReconnectableWS] 🔗 Connecting to ${this.url} (attempt=${this.reconnectAttempt})`);
+		const ws = new WebSocket(this.url);
+		ws.onopen = () => {
+			if (this.disposed) return;
+			console.log(`[ReconnectableWS] ✅ Connected`);
+			this.reconnectAttempt = 0;
+			this.setState("connected");
+			this.startHeartbeat();
+			this.flushBuffer();
+		};
+		ws.onclose = (ev) => {
+			if (this.disposed) return;
+			if (ev.code === 1e3) {
+				console.log(`[ReconnectableWS] 🔒 Closed cleanly (code=${ev.code})`);
+				return;
+			}
+			console.log(`[ReconnectableWS] ❌ Closed (code=${ev.code} reason=${ev.reason})`);
+			this.stopHeartbeat();
+			this.scheduleReconnect();
+		};
+		ws.onerror = () => {
+			if (this.disposed) return;
+			console.log(`[ReconnectableWS] ⚠️ Error`);
+		};
+		ws.onmessage = (ev) => {
+			if (this.disposed) return;
+			if (ev.data === "__pong") {
+				this.handlePong();
+				return;
+			}
+			for (const handler of this.messageHandlers) handler(ev);
+		};
+		this.ws = ws;
+	}
+	setState(state) {
+		if (this._state === state) return;
+		this._state = state;
+		console.log(`[ReconnectableWS] 📡 State: ${state}`);
+		this.opts.onConnectionStateChange?.(state);
+	}
+	scheduleReconnect() {
+		if (this.disposed) return;
+		if (this.reconnectAttempt >= this.opts.maxReconnectAttempts) {
+			console.log(`[ReconnectableWS] 🚫 Max reconnect attempts reached (${this.opts.maxReconnectAttempts})`);
+			this.setState("disconnected");
+			return;
+		}
+		this.setState("reconnecting");
+		const delay = this.getReconnectDelay();
+		console.log(`[ReconnectableWS] ⏳ Reconnecting in ${Math.round(delay)}ms (attempt=${this.reconnectAttempt + 1})`);
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectAttempt++;
+			this.connect();
+		}, delay);
+	}
+	getReconnectDelay() {
+		const { baseDelay, maxDelay, jitterFactor } = this.opts;
+		const exponentialDelay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempt), maxDelay);
+		const jitter = exponentialDelay * jitterFactor * (Math.random() * 2 - 1);
+		return Math.max(0, exponentialDelay + jitter);
+	}
+	flushBuffer() {
+		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+		const buffer = this.messageBuffer;
+		this.messageBuffer = [];
+		for (const data of buffer) try {
+			this.ws.send(data);
+		} catch (e) {
+			console.warn(`[ReconnectableWS] ⚠️ Failed to flush buffered message:`, e);
+		}
+		if (buffer.length > 0) console.log(`[ReconnectableWS] 📤 Flushed ${buffer.length} buffered messages`);
+	}
+	startHeartbeat() {
+		this.stopHeartbeat();
+		this.heartbeatTimer = setInterval(() => {
+			if (this.ws?.readyState === WebSocket.OPEN) {
+				this.ws.send("__ping");
+				this.heartbeatTimeoutTimer = setTimeout(() => {
+					console.log(`[ReconnectableWS] 💔 Heartbeat timeout`);
+					this.ws?.close(4001, "heartbeat_timeout");
+				}, this.opts.heartbeatTimeout);
+			}
+		}, this.opts.heartbeatInterval);
+	}
+	stopHeartbeat() {
+		if (this.heartbeatTimer) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = null;
+		}
+		if (this.heartbeatTimeoutTimer) {
+			clearTimeout(this.heartbeatTimeoutTimer);
+			this.heartbeatTimeoutTimer = null;
+		}
+	}
+	handlePong() {
+		if (this.heartbeatTimeoutTimer) {
+			clearTimeout(this.heartbeatTimeoutTimer);
+			this.heartbeatTimeoutTimer = null;
+		}
+	}
+};
+//#endregion
+//#region src/dev-state-patch.ts
+/**
+* RFC 7396 (Merge Patch) を target に in-place 適用する。
+*
+* 規則:
+* - `undefined` は no-op (key 自体を patch から落としたのと同じ)
+* - `null` は **null をセット** (RFC 7396 strict と異なる、deletion はしない)
+* - patch が object かつ target も object → 再帰 merge
+* - patch が array → atomic replace (要素単位 merge なし、RFC 7396 spec 通り)
+* - patch が primitive → overwrite
+* - **target が array で patch が non-array object** → throw (silent な
+*   `[..., ...]` → `{ "0": ..., "1": ... }` 化を防ぐ)
+*
+* 型 mismatch (例: object → primitive) は overwrite で許可する。
+*/
+function applyJsonMergePatch(target, patch) {
+	if (Array.isArray(target)) throw new TypeError("[uzu_dev] mergeRawState: cannot deep-merge into an array field. Use patchRawState ({ op: \"replace\", path: \"/.../<index>\" }) for element-level writes, or pass a full array to atomic-replace it.");
+	for (const key of Object.keys(patch)) {
+		const value = patch[key];
+		if (value === void 0) continue;
+		if (value === null) {
+			target[key] = null;
+			continue;
+		}
+		const current = target[key];
+		if (typeof value === "object" && !Array.isArray(value) && current !== null && typeof current === "object") {
+			if (Array.isArray(current)) throw new TypeError(`[uzu_dev] mergeRawState: refusing to merge a plain object into array field "${key}". Use patchRawState ({ op: "replace", path: "/${key}/<index>" }) for element-level writes, or pass a full array to atomic-replace it.`);
+			applyJsonMergePatch(current, value);
+		} else target[key] = value;
+	}
+}
+/**
+* JSON Pointer (RFC 6901) を tokens に分解する。
+* `/board/1/~04` → `['board', '1', '~4']`
+*
+* RFC 6901 のエスケープ:
+* - `~1` → `/`
+* - `~0` → `~`
+*
+* 復号順は ~1 → ~0。逆順で解くと `~01` が `/` に化けるので注意。
+*/
+function parseJsonPointer(pointer) {
+	if (pointer === "") return [];
+	if (!pointer.startsWith("/")) throw new TypeError(`[uzu_dev] invalid JSON Pointer: ${pointer} (must start with "/")`);
+	return pointer.slice(1).split("/").map((token) => token.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+/**
+* JSON Pointer の **親 container** と **末端 key** に解決する。
+* root pointer (`''`) は対応外: 呼び出し側で別途扱う。
+*/
+function resolveParent(doc, tokens) {
+	if (tokens.length === 0) throw new TypeError("[uzu_dev] root pointer (\"\") is not addressable by this helper");
+	let current = doc;
+	for (let i = 0; i < tokens.length - 1; i++) {
+		const token = tokens[i];
+		if (current === null || typeof current !== "object") throw new TypeError(`[uzu_dev] JSON Pointer path "${tokens.slice(0, i + 1).join("/")}" goes through a non-container`);
+		if (Array.isArray(current)) {
+			const idx = parseArrayIndex(token, current.length, false);
+			current = current[idx];
+		} else current = current[token];
+	}
+	if (current === null || typeof current !== "object") throw new TypeError(`[uzu_dev] JSON Pointer parent "${tokens.slice(0, -1).join("/")}" is not a container`);
+	return {
+		parent: current,
+		key: tokens[tokens.length - 1]
+	};
+}
+/**
+* JSON Pointer から値を取得する。root pointer は doc 自体。
+* 存在しない path は throw する。
+*/
+function getByPointer(doc, pointer) {
+	const tokens = parseJsonPointer(pointer);
+	let current = doc;
+	for (const token of tokens) {
+		if (current === null || typeof current !== "object") throw new TypeError(`[uzu_dev] JSON Pointer path "${pointer}" goes through a non-container`);
+		if (Array.isArray(current)) {
+			const idx = parseArrayIndex(token, current.length, false);
+			current = current[idx];
+		} else {
+			const obj = current;
+			if (!(token in obj)) throw new TypeError(`[uzu_dev] JSON Pointer path "${pointer}" does not exist`);
+			current = obj[token];
+		}
+	}
+	return current;
+}
+/**
+* Array index token を numeric index に解決する。
+* `'-'` は append (RFC 6902 仕様、`add` 操作のみ許可) で `length` を返す。
+*/
+function parseArrayIndex(token, length, allowAppend) {
+	if (token === "-") {
+		if (!allowAppend) throw new TypeError("[uzu_dev] array append (\"-\") is only valid for `add` operations");
+		return length;
+	}
+	if (!/^(?:0|[1-9][0-9]*)$/.test(token)) throw new TypeError(`[uzu_dev] invalid array index "${token}"`);
+	const idx = Number(token);
+	if (idx < 0 || idx > length) throw new RangeError(`[uzu_dev] array index ${idx} out of range (length=${length})`);
+	return idx;
+}
+/**
+* 値の深い等価判定 (RFC 6902 `test` 用)。`JSON.stringify` ベース。
+* `undefined` を含む値や key 順序差まで真面目に見るほどには使わないので十分。
+*/
+function deepEqual(a, b) {
+	if (a === b) return true;
+	try {
+		return JSON.stringify(a) === JSON.stringify(b);
+	} catch {
+		return false;
+	}
+}
+/**
+* RFC 6902 (JSON Patch) operations を target に in-place 適用する。
+*
+* 1 op でも失敗したら **その時点で throw** する (RFC 6902 spec: operations は
+* sequentially evaluate、失敗時の rollback は規定なし)。caller が atomic に
+* したいなら state を事前に snapshot しておく。
+*
+* root pointer (`''`) は本実装では `add` / `replace` のみ許可し、
+* doc のフィールドを丸ごと差し替える形で動く (= 結局 `setRawState` で十分な
+* ケースなので、わざわざ `patchRawState` で使うことはほぼない)。
+*/
+function applyJsonPatch(target, ops) {
+	for (const op of ops) applyOne(target, op);
+}
+function applyOne(doc, op) {
+	switch (op.op) {
+		case "add": {
+			const tokens = parseJsonPointer(op.path);
+			if (tokens.length === 0) {
+				replaceRoot(doc, op.value);
+				return;
+			}
+			const { parent, key } = resolveParent(doc, tokens);
+			if (Array.isArray(parent)) {
+				const idx = parseArrayIndex(key, parent.length, true);
+				parent.splice(idx, 0, op.value);
+			} else parent[key] = op.value;
+			return;
+		}
+		case "remove": {
+			const tokens = parseJsonPointer(op.path);
+			if (tokens.length === 0) throw new TypeError("[uzu_dev] cannot remove the root document");
+			const { parent, key } = resolveParent(doc, tokens);
+			if (Array.isArray(parent)) {
+				const idx = parseArrayIndex(key, parent.length - 1, false);
+				parent.splice(idx, 1);
+			} else {
+				if (!(key in parent)) throw new TypeError(`[uzu_dev] cannot remove non-existent path "${op.path}"`);
+				delete parent[key];
+			}
+			return;
+		}
+		case "replace": {
+			const tokens = parseJsonPointer(op.path);
+			if (tokens.length === 0) {
+				replaceRoot(doc, op.value);
+				return;
+			}
+			const { parent, key } = resolveParent(doc, tokens);
+			if (Array.isArray(parent)) {
+				const idx = parseArrayIndex(key, parent.length - 1, false);
+				parent[idx] = op.value;
+			} else {
+				if (!(key in parent)) throw new TypeError(`[uzu_dev] cannot replace non-existent path "${op.path}"`);
+				parent[key] = op.value;
+			}
+			return;
+		}
+		case "move": {
+			if (op.from === op.path) return;
+			if (isProperPrefixPointer(op.from, op.path)) throw new TypeError(`[uzu_dev] cannot move into own descendant: from="${op.from}" path="${op.path}"`);
+			const value = getByPointer(doc, op.from);
+			applyOne(doc, {
+				op: "remove",
+				path: op.from
+			});
+			applyOne(doc, {
+				op: "add",
+				path: op.path,
+				value
+			});
+			return;
+		}
+		case "copy": {
+			const value = getByPointer(doc, op.from);
+			const cloned = structuredClone(value);
+			applyOne(doc, {
+				op: "add",
+				path: op.path,
+				value: cloned
+			});
+			return;
+		}
+		case "test":
+			if (!deepEqual(getByPointer(doc, op.path), op.value)) throw new Error(`[uzu_dev] test failed at "${op.path}"`);
+			return;
+		default: throw new TypeError(`[uzu_dev] unknown JSON Patch op: ${JSON.stringify(op)}`);
+	}
+}
+function isProperPrefixPointer(prefix, path) {
+	if (prefix === "") return path !== "";
+	return path === prefix || path.startsWith(`${prefix}/`);
+}
+/**
+* root pointer (`''`) への add / replace 用。doc を in-place で空にして
+* value の中身を流し込む。value が object でない場合は Record の形に
+* 入らないので throw する (root を primitive / array に置換はサポート対象外、
+* setRawState を使うべき)。
+*/
+function replaceRoot(doc, value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("[uzu_dev] root replace requires a plain object value; use setRawState for full state replacement");
+	for (const key of Object.keys(doc)) delete doc[key];
+	Object.assign(doc, value);
+}
+//#endregion
+//#region src/dev-prediction-traps.ts
+/** 描画経路の警告に使う擬似 action 名。 */
+const RENDER_CONTEXT = "(render)";
+const CLOCK_TRAPS = [{ install: (report) => {
+	const RealDate = Date;
+	const realNow = Date.now;
+	globalThis.Date = new Proxy(RealDate, { construct: (target, args) => {
+		if (args.length === 0) report("new Date()");
+		return Reflect.construct(target, args);
+	} });
+	Date.now = () => {
+		report("Date.now()");
+		return realNow();
+	};
+	return () => {
+		Date.now = realNow;
+		globalThis.Date = RealDate;
+	};
+} }, { install: (report) => {
+	const real = globalThis.performance?.now;
+	if (!real) return () => {};
+	const bound = real.bind(globalThis.performance);
+	globalThis.performance.now = () => {
+		report("performance.now()");
+		return bound();
+	};
+	return () => {
+		globalThis.performance.now = real;
+	};
+} }];
+/** 乱数系。先読みでだけ問題になるので描画経路には張らない。 */
+const RANDOM_TRAPS = [{ install: (report) => {
+	const real = Math.random;
+	Math.random = () => {
+		report("Math.random()");
+		return real();
+	};
+	return () => {
+		Math.random = real;
+	};
+} }, { install: (report) => {
+	const real = globalThis.crypto?.randomUUID;
+	if (!real) return () => {};
+	const bound = real.bind(globalThis.crypto);
+	globalThis.crypto.randomUUID = () => {
+		report("crypto.randomUUID()");
+		return bound();
+	};
+	return () => {
+		globalThis.crypto.randomUUID = real;
+	};
+} }];
+const TRAPS = [...CLOCK_TRAPS, ...RANDOM_TRAPS];
+const warnings = [];
+const reported = /* @__PURE__ */ new Set();
+const printWarning = (action, api) => {
+	if (action === RENDER_CONTEXT) {
+		console.groupCollapsed(`⚠️ [uzu-code] 描画中に ${api} を呼びました`);
+		console.log([
+			`${api} は Unix epoch の実時刻を返します。state に入っている締切は`,
+			"ゲーム内時刻 (ゲーム開始からの経過 ms) なので、引き算すると桁が合いません。",
+			"また実時刻は緊急停止中も進むので、止まっているのにカウントダウンだけ動きます。",
+			"",
+			"直し方: 時刻は gameTime() から取る。",
+			"  import { gameTime, minus } from '@uzuhq/code-sdk';",
+			"  const remain = Math.ceil(minus(state.timerEndsAt, gameTime()) / 1000);"
+		].join("\n"));
+		console.groupEnd();
+		return;
+	}
+	console.groupCollapsed(`⚠️ [uzu-code] action "${action}" が先読み中に ${api} を呼びました`);
+	console.log([
+		"先読み (楽観的更新) は「サーバーと同じコードを同じ入力で走らせれば同じ結果になる」",
+		`ことが前提です。${api} はクライアント側の値を読むため、サーバーの実行結果とズレます。`,
+		"ズレた state は一瞬表示されたあと ack で上書きされ、画面が飛びます。",
+		"",
+		"直し方:",
+		`  A. action "${action}" を serverOnly() で wrap する (先読みしなくなる)`,
+		"  B. 値を state に書かず、クライアント側の描画だけで使う",
+		"",
+		"https://docs.code.uzu-app.com/reference/api#serveronly-handler"
+	].join("\n"));
+	console.groupEnd();
+};
+/**
+* dev harness の HUD にバッジを出すため親フレームへ通知する。
+* 単独 page (親が自分自身) では送り先が無いので何もしない。
+*/
+const notifyParent = (action, api) => {
+	if (window.parent === window) return;
+	try {
+		window.parent.postMessage(JSON.stringify({
+			channel: "sdk",
+			type: "predictionWarning",
+			payload: {
+				action,
+				api
+			}
+		}), "*");
+	} catch {}
+};
+/**
+* 素の action handler の先読み実行を計装して走らせる。
+*
+* Flutter native ホスト (本番) では計装せず素通しする。判定基準は dev hooks と同じ。
+*/
+const runPredicted = (action, run) => {
+	runInstrumented(action, run);
+};
+/**
+* `onState` から同期で走る描画を計装する。
+*
+* 乱数は描画で使ってよいので、時刻の罠だけ張る。ここで拾えるのは同期の描画だけで、
+* `requestAnimationFrame` の中は原理的に拾えない。
+*/
+const runRendered = (run) => {
+	runInstrumented(RENDER_CONTEXT, run);
+};
+const runInstrumented = (action, run) => {
+	if (typeof window === "undefined" || window.FlutterHost) {
+		run();
+		return;
+	}
+	const report = (api) => {
+		const key = `${action}\u0000${api}`;
+		if (reported.has(key)) return;
+		reported.add(key);
+		warnings.push({
+			action,
+			api
+		});
+		printWarning(action, api);
+		notifyParent(action, api);
+	};
+	const restores = (action === RENDER_CONTEXT ? CLOCK_TRAPS : TRAPS).map((trap) => trap.install(report));
+	try {
+		run();
+	} finally {
+		for (let i = restores.length - 1; i >= 0; i--) restores[i]();
+	}
+};
+/** 検出済みの警告一覧。`__uzu_dev.getPredictionWarnings()` から E2E で assert する用。 */
+const getPredictionWarnings = () => warnings;
+//#endregion
+//#region src/dev-hooks.ts
+function createDevHooks(ctx) {
+	const getRawState = () => ctx.getRawState ? ctx.getRawState() : null;
+	const waitForSnapshot = (predicate, options) => {
+		const timeoutMs = options?.timeoutMs ?? 1e4;
+		return new Promise((resolve, reject) => {
+			const current = ctx.getSnapshot();
+			if (current != null) {
+				let ok = false;
+				try {
+					ok = predicate(current);
+				} catch (err) {
+					reject(err);
+					return;
+				}
+				if (ok) {
+					resolve(current);
+					return;
+				}
+			}
+			const timer = setTimeout(() => {
+				unsubscribe();
+				reject(/* @__PURE__ */ new Error(`[uzu_dev] waitForSnapshot timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+			const unsubscribe = ctx.subscribeSnapshot((snap) => {
+				let ok;
+				try {
+					ok = predicate(snap);
+				} catch (err) {
+					clearTimeout(timer);
+					unsubscribe();
+					reject(err);
+					return;
+				}
+				if (ok) {
+					clearTimeout(timer);
+					unsubscribe();
+					resolve(snap);
+				}
+			});
+		});
+	};
+	const hooks = {
+		getSnapshot: () => ctx.getSnapshot(),
+		getRawState,
+		playerId: () => ctx.playerId(),
+		subscribeSnapshot: (cb) => ctx.subscribeSnapshot(cb),
+		waitForSnapshot,
+		getPredictionWarnings: () => getPredictionWarnings()
+	};
+	if (ctx.sendAction) {
+		const sendAction = ctx.sendAction;
+		hooks.send = (args) => sendAction(args);
+	}
+	if (ctx.setRawState) {
+		const setRawState = ctx.setRawState;
+		hooks.setRawState = (state) => setRawState(state);
+	}
+	if (ctx.mergeRawState) {
+		const mergeRawState = ctx.mergeRawState;
+		hooks.mergeRawState = (patch) => mergeRawState(patch);
+	}
+	if (ctx.patchRawState) {
+		const patchRawState = ctx.patchRawState;
+		hooks.patchRawState = (ops) => patchRawState(ops);
+	}
+	if (ctx.getSeed) {
+		const getSeed = ctx.getSeed;
+		hooks.getSeed = () => getSeed();
+	}
+	if (ctx.pauseTick) {
+		const pauseTick = ctx.pauseTick;
+		hooks.pauseTick = () => pauseTick();
+	}
+	if (ctx.resumeTick) {
+		const resumeTick = ctx.resumeTick;
+		hooks.resumeTick = () => resumeTick();
+	}
+	if (ctx.stepTick) {
+		const stepTick = ctx.stepTick;
+		hooks.stepTick = (n) => stepTick(n);
+	}
+	if (ctx.getCurrentTick) {
+		const getCurrentTick = ctx.getCurrentTick;
+		hooks.getCurrentTick = () => getCurrentTick();
+	}
+	if (ctx.isTickPaused) {
+		const isTickPaused = ctx.isTickPaused;
+		hooks.isTickPaused = () => isTickPaused();
+	}
+	if (ctx.reset) {
+		const reset = ctx.reset;
+		hooks.reset = (opts) => reset(opts);
+	}
+	if (ctx.subscribeEvents) {
+		const subscribeEvents = ctx.subscribeEvents;
+		hooks.subscribeEvents = (cb) => subscribeEvents(cb);
+	}
+	return hooks;
+}
+function attachDevHooks(ctx) {
+	window.__uzu_dev = createDevHooks(ctx);
+}
+//#endregion
+//#region src/run/optimistic-action-client.ts
+function createOptimisticActionClient(config) {
+	const { logic, playerId, onState, events, sendAction } = config;
+	/** サーバー確定 state (楽観的更新のベース) */
+	let confirmedState = null;
+	/** 表示用 state (pending actions 適用済み) */
+	let displayState = null;
+	/** クライアント側の action 通番 */
+	let actionSeq = 0;
+	/**
+	* 送信済みだがサーバー未確認の action キュー。
+	* `time` は送信時に推定した値。再適用でも同じ値を使う (取り直すと表示がガタつく)。
+	*/
+	const pendingActions = [];
+	/**
+	* 先読みで実行済みの events。
+	*
+	* IMPORTANT: pending action ごとではなくクライアント単位で持つ。二重実行は「自分の
+	* action の ack」だけでなく「他プレイヤーの action のブロードキャスト」でも起きるため
+	* (A と B が同時に同じ行送りを撃つと、B は自分の先読みで実行済みなのに A 由来の
+	* 配信でもう一度実行してしまう)。どの配信が来ても、まずここと突き合わせる。
+	*
+	* 記録には「どの action の先読みで実行したか」(seq) を持たせる。その action が ack
+	* された時点で引き当てられていない記録は「予測したが実際には起きなかった出来事」なので
+	* 捨てる。seq を持たせずに「pending が空になったら捨てる」だけにすると、別の action が
+	* 未確定な間ずっと外れた記録が生き残り、その後に本当に起きた同名イベントを 1 回
+	* 握り潰してしまう。
+	*
+	* サーバーは 1 本の接続へ処理順どおりに送るので、他プレイヤーの配信は自分の ack より
+	* 必ず先に届く = 引き当てのチャンスは記録が生きている間に必ず来る。
+	*/
+	let firedPredictions = [];
+	/** 再適用時はイベントを発火しない (送信時に既に発火済み) */
+	const noopEmit = () => {};
+	const dispatchEvents = (evts) => {
+		for (const e of evts) events?.[e.name]?.handler(e.data);
+	};
+	/** events の同一性キー。name と data が一致すれば「同じ出来事」とみなす。 */
+	const eventKey = (e) => `${e.name}\u0000${JSON.stringify(e.data ?? {})}`;
+	/**
+	* サーバーの events から、先読みで実行済みのものを差し引く (多重集合の差)。
+	*
+	* - 予測が当たった  → 差が空。二重に実行しない
+	* - 予測が外れた    → サーバー側の正しい event が残り、確定として実行される
+	* - 先読みで実行していない (predict: false / serverActions 由来 / 他プレイヤー由来)
+	*   → そのまま残って実行される
+	*/
+	const subtractFired = (serverEvts) => {
+		if (firedPredictions.length === 0) return serverEvts;
+		const out = [];
+		for (const e of serverEvts) {
+			const k = eventKey(e);
+			const idx = firedPredictions.findIndex((f) => eventKey(f) === k);
+			if (idx >= 0) firedPredictions.splice(idx, 1);
+			else out.push(e);
+		}
+		return out;
+	};
+	/**
+	* confirmedState をベースに pending actions を再適用して displayState を更新する。
+	* 再適用失敗した action はキューから除去する。
+	*/
+	const reapplyPendingActions = () => {
+		if (confirmedState === null) return;
+		displayState = structuredClone(confirmedState);
+		let i = 0;
+		while (i < pendingActions.length) {
+			const { action, payload, time } = pendingActions[i];
+			const handler = logic.actions[action];
+			if (!handler || isServerOnlyAction(handler)) {
+				pendingActions.splice(i, 1);
+				continue;
+			}
+			const base = structuredClone(displayState);
+			try {
+				runPredicted(action, () => handler({
+					state: displayState,
+					payload,
+					playerId,
+					ctx: {
+						time,
+						after: (d) => plus(time, d),
+						emit: noopEmit
+					}
+				}));
+				i++;
+			} catch {
+				displayState = base;
+				pendingActions.splice(i, 1);
+			}
+		}
+		onState(displayState, playerId);
+	};
+	/**
+	* サーバーからの配信を処理する。
+	*
+	* 送信元が誰であれ、まず先読みの実行記録と突き合わせる。自分の ack だけを見ていると、
+	* 他プレイヤーの action が同じ出来事を起こしたときに二重実行になる。
+	*/
+	const handleAck = (ack, from, evts) => {
+		dispatchEvents(subtractFired(evts));
+		if (from === playerId && ack !== void 0) {
+			while (pendingActions.length > 0 && pendingActions[0].seq <= ack) pendingActions.shift();
+			firedPredictions = firedPredictions.filter((f) => f.seq > ack);
+		}
+	};
+	return {
+		send(type, payload) {
+			if (isPaused()) {
+				console.warn(`[uzu] 緊急停止中は action を送れません (action="${type}")`);
+				return;
+			}
+			actionSeq++;
+			const seq = actionSeq;
+			const handler = logic.actions[type];
+			if (!handler && !logic.serverActions?.[type]) console.error(`[uzu] unknown action: "${type}". logic.actions / logic.serverActions のどちらにも登録されていません。`);
+			const target = displayState;
+			const time = gameTime();
+			const predictEmit = (eventName, data) => {
+				const subscription = events?.[eventName];
+				if (!subscription?.predict) return;
+				const payloadData = data ?? {};
+				subscription.handler(payloadData);
+				firedPredictions.push({
+					seq,
+					name: eventName,
+					data: payloadData
+				});
+			};
+			if (handler && !isServerOnlyAction(handler) && target !== null) try {
+				runPredicted(type, () => handler({
+					state: target,
+					payload: payload ?? {},
+					playerId,
+					ctx: {
+						time,
+						after: (d) => plus(time, d),
+						emit: predictEmit
+					}
+				}));
+				pendingActions.push({
+					seq,
+					action: type,
+					payload: payload ?? {},
+					time
+				});
+				onState(target, playerId);
+			} catch {}
+			sendAction({
+				action: type,
+				payload: payload ?? {},
+				seq
+			});
+		},
+		observeGameTime(t) {
+			observeGameTime(t);
+		},
+		applyState(state, options = {}) {
+			handleAck(options.ack, options.from, options.events ?? []);
+			confirmedState = state;
+			reapplyPendingActions();
+		},
+		applyDelta(patches, options = {}) {
+			if (confirmedState === null) return false;
+			const cloned = structuredClone(confirmedState);
+			if (!applyPatch(cloned, patches)) return false;
+			confirmedState = cloned;
+			handleAck(options.ack, options.from, options.events ?? []);
+			reapplyPendingActions();
+			return true;
+		},
+		rollback(seq) {
+			const idx = pendingActions.findIndex((p) => p.seq === seq);
+			if (idx !== -1) {
+				pendingActions.splice(idx, 1);
+				firedPredictions = firedPredictions.filter((f) => f.seq !== seq);
+				reapplyPendingActions();
+			}
+		},
+		reset(state) {
+			pendingActions.length = 0;
+			firedPredictions = [];
+			confirmedState = state;
+			displayState = structuredClone(state);
+			onState(displayState, playerId);
+		}
+	};
+}
+//#endregion
+//#region src/run/server-action.ts
+function runOnlineServerAction(config, gameEndpoint, roomId, seatId, players, seatKind) {
+	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 wsUrl = `${gameEndpoint}/${roomId}?${new URLSearchParams({
+		seatId,
+		nickname: "Player",
+		players: roster,
+		seats: roster
+	})}`;
+	console.log(`[SDK ServerAction] 🔗 Connecting wsUrl=${wsUrl}`);
+	const ws = new ReconnectableWebSocket(wsUrl, {
+		onConnectionStateChange: (state) => {
+			console.log(`[SDK ServerAction] 📡 Connection state: ${state}`);
+			config.onConnectionStateChange?.(state);
+		},
+		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;
+			}
+		}
+	});
+	setPauseRequester((paused) => {
+		console.log(`[SDK ServerAction] ➡ send ${paused ? "__pause" : "__resume"}`);
+		ws.send(JSON.stringify({ type: paused ? "__pause" : "__resume" }));
+	});
+	/** サーバー seq (delta の連続性チェック用) */
+	let serverSeq = 0;
+	/** フル state 再要求中フラグ (多重要求防止) */
+	let requestStatePending = false;
+	/** 楽観更新クライアント (transport は本ファイル内で WebSocket に bind) */
+	const client = createOptimisticActionClient({
+		logic: config.logic,
+		playerId: seatId,
+		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" }));
+	};
+	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}`);
+		client.observeGameTime(parsed.gameTime);
+		if (msgType === "__pause_state") {
+			const frozen = parsed.frozen === true;
+			console.log(`[SDK ServerAction] ${frozen ? "⏸" : "▶️"} pause_state frozen=${frozen}`);
+			setPauseState(frozen, parsed.by ?? null);
+			return;
+		}
+		if (msgType === "__room_init") {
+			console.log(`[SDK ServerAction] ✅ Room init myId=${parsed.myId}`);
+			return;
+		}
+		if (msgType === "__game_start") {
+			serverSeq = parsed.seq ?? 0;
+			requestStatePending = false;
+			client.reset(parsed.state);
+			console.log(`[SDK ServerAction] 🎮 Game started (pending cleared)`);
+			return;
+		}
+		if (msgType === "__tick") {
+			const evts = parsed.events ?? [];
+			serverSeq = parsed.seq ?? serverSeq + 1;
+			requestStatePending = false;
+			client.applyState(parsed.state, { events: evts });
+			return;
+		}
+		if (msgType === "__tick_delta") {
+			const evts = parsed.events ?? [];
+			const newSeq = parsed.seq ?? serverSeq + 1;
+			if (newSeq !== serverSeq + 1) {
+				requestFullState();
+				return;
+			}
+			if (!client.applyDelta(parsed.patches ?? [], { events: evts })) {
+				requestFullState();
+				return;
+			}
+			serverSeq = newSeq;
+			requestStatePending = false;
+			return;
+		}
+		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;
+		}
+		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;
+			}
+			if (!client.applyDelta(parsed.patches ?? [], {
+				ack,
+				from,
+				events: evts
+			})) {
+				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 !== void 0) client.rollback(errorSeq);
+			return;
+		}
+		if (msgType === "__state") {
+			serverSeq = parsed.seq ?? 0;
+			requestStatePending = false;
+			console.log(`[SDK ServerAction] 🔄 State restored (reconnect/late join) seq=${serverSeq}`);
+			setPauseState(parsed.frozen === true, parsed.pausedBy ?? null);
+			client.reset(parsed.state);
+			return;
+		}
+	});
+}
+//#endregion
+//#region src/run/local-server-action.ts
+function runLocalServerAction(config) {
+	const { logic, inputs, events } = config;
+	const onState = (next, id) => {
+		observeGameTime(gameTime());
+		config.onState(next, id, "player");
+	};
+	const tickRate = logic.tickRate ?? 0;
+	const clock = new GameClock();
+	const gameTime = () => clock.now();
+	const frozen = () => clock.frozen;
+	/** ハンドラへ渡す ctx の時刻部分。1 回の呼び出し内で値が動かないよう束ねる。 */
+	const timeCtx = (t) => ({
+		time: t,
+		after: (d) => plus(t, d)
+	});
+	/** at() が壊れた値を返したと既に記録した締切。ログを 1 回に絞るため。 */
+	const warnedDeadlines = /* @__PURE__ */ new Set();
+	const random = new SeededRandomImpl(Math.floor(Math.random() * 4294967295));
+	const players = Array.from({ length: config.playerCount }, (_, i) => ({
+		id: `local_${i}`,
+		nickname: `Player ${i + 1}`,
+		iconUrl: DEFAULT_ICON_URLS[i % DEFAULT_ICON_URLS.length]
+	}));
+	const myId = players[0].id;
+	let wakeupTimer = null;
+	let wakeupAt = null;
+	const nextDeadline = () => {
+		if (!logic.deadlines) return null;
+		let earliest = null;
+		for (const [key, deadline] of Object.entries(logic.deadlines)) {
+			let raw;
+			try {
+				raw = deadline.at({ state });
+			} catch (err) {
+				console.error(`[Deadline] ❌ ${key}.at() で例外`, err);
+				continue;
+			}
+			const at = resolveDeadline(raw, key, warnedDeadlines, (m) => console.error(`[Deadline] ❌ ${m}`));
+			if (at === null) continue;
+			if (earliest === null || at < earliest) earliest = at;
+		}
+		return earliest;
+	};
+	const fireDue = () => {
+		wakeupTimer = null;
+		wakeupAt = null;
+		if (!logic.deadlines || frozen()) return;
+		const time = gameTime();
+		const evts = [];
+		const firedKeys = [];
+		for (const [key, deadline] of Object.entries(logic.deadlines)) {
+			const pending = [];
+			let snapshot = null;
+			try {
+				const at = resolveDeadline(deadline.at({ state }), key, warnedDeadlines, (m) => console.error(`[Deadline] ❌ ${m}`));
+				if (at === null || at > time) continue;
+				snapshot = structuredClone(state);
+				withGameClock(time, () => deadline.handler({
+					state,
+					ctx: {
+						...timeCtx(time),
+						random,
+						emit: (name, data) => pending.push({
+							name,
+							data: data ?? {}
+						})
+					}
+				}));
+				evts.push(...pending);
+				firedKeys.push(key);
+			} catch (err) {
+				if (snapshot !== null) state = snapshot;
+				console.error(`[Deadline] ❌ ${key} で例外`, err);
+			}
+		}
+		syncWakeup();
+		if (firedKeys.length === 0) return;
+		console.log(`[Deadline] ⏰ ${firedKeys.length} 件発火: ${firedKeys.join(", ")}`);
+		dispatchEvents(evts);
+		onState(state, myId);
+	};
+	const syncWakeup = () => {
+		const next = frozen() ? null : nextDeadline();
+		if (next === wakeupAt) return;
+		if (wakeupTimer) clearTimeout(wakeupTimer);
+		wakeupTimer = null;
+		wakeupAt = next;
+		if (next === null) return;
+		wakeupTimer = setTimeout(fireDue, Math.max(0, clock.toWall(next) - Date.now()));
+	};
+	const dispatchEvents = (evts) => {
+		for (const e of evts) events?.[e.name]?.handler(e.data);
+	};
+	clock.restart();
+	const setupTime = gameTime();
+	const setupArgs = {
+		players,
+		seats: players,
+		ctx: {
+			random,
+			...timeCtx(setupTime)
+		}
+	};
+	let state = withGameClock(setupTime, () => logic.setup(setupArgs));
+	let tick = 0;
+	const playerInputs = {};
+	const dispatchAction = (type, payload) => {
+		if (frozen()) {
+			console.warn(`[SDK LocalServerAction] 緊急停止中は action を実行しません (action="${type}")`);
+			return;
+		}
+		const plain = logic.actions[type];
+		const legacyServerOnly = isServerOnlyAction(plain) ? plain : null;
+		const server = logic.serverActions?.[type] ?? legacyServerOnly;
+		if (!plain && !server) return;
+		const plainEvents = [];
+		const serverEvents = [];
+		const plainEmit = (name, data) => plainEvents.push({
+			name,
+			data: data ?? {}
+		});
+		const serverEmit = (name, data) => serverEvents.push({
+			name,
+			data: data ?? {}
+		});
+		const time = gameTime();
+		if (plain && !legacyServerOnly) {
+			try {
+				withGameClock(time, () => plain({
+					state,
+					payload: payload ?? {},
+					playerId: myId,
+					ctx: {
+						...timeCtx(time),
+						emit: plainEmit
+					}
+				}));
+			} catch (err) {
+				console.warn("[SDK LocalServerAction] Action error:", err);
+				return;
+			}
+			dispatchEvents(plainEvents);
+			syncWakeup();
+			onState(state, myId);
+		}
+		if (!server) return;
+		(async () => {
+			try {
+				await server({
+					state,
+					payload: payload ?? {},
+					playerId: myId,
+					ctx: {
+						tick,
+						random,
+						...timeCtx(time),
+						emit: serverEmit
+					}
+				});
+			} catch (err) {
+				console.warn("[SDK LocalServerAction] Action error:", err);
+				return;
+			}
+			dispatchEvents(serverEvents);
+			syncWakeup();
+			onState(state, myId);
+		})();
+	};
+	/**
+	* ソロの停止 / 解除。サーバーが居ないので自分の時計を直接触る。
+	*
+	* `__uzu_dev.pauseTick()` とは別物。あちらは tick を止めるだけの開発者ツールで、
+	* ゲーム内時計も action ゲートも持たない。流用しない。
+	*/
+	const applyPause = (paused) => {
+		if (!(paused ? clock.freeze("emergency-stop") : clock.unfreeze("emergency-stop"))) return;
+		observeGameTime(gameTime());
+		setPauseState(paused, paused ? myId : null);
+		observeGameTime(gameTime());
+		syncWakeup();
+	};
+	setPauseRequester(applyPause);
+	inputs(dispatchAction);
+	syncWakeup();
+	onState(state, myId);
+	if (tickRate > 0) setInterval(() => {
+		if (frozen()) return;
+		const tickEvents = [];
+		const tickEmit = (name, data) => tickEvents.push({
+			name,
+			data: data ?? {}
+		});
+		const time = gameTime();
+		try {
+			withGameClock(time, () => logic.update({
+				state,
+				ctx: {
+					random,
+					tick,
+					...timeCtx(time),
+					emit: tickEmit,
+					playerInputs
+				}
+			}));
+		} catch (err) {
+			console.error(`[SDK LocalServerAction] tick error at tick=${tick}:`, err);
+			tick++;
+			return;
+		}
+		tick++;
+		dispatchEvents(tickEvents);
+		syncWakeup();
+		onState(state, myId);
+	}, 1e3 / tickRate);
+	return {
+		getRawState: () => state,
+		setRawState: async (next) => {
+			state = next;
+			syncWakeup();
+			onState(state, myId);
+		},
+		mergeRawState: async (patch) => {
+			applyJsonMergePatch(state, patch);
+			onState(state, myId);
+		},
+		patchRawState: async (ops) => {
+			applyJsonPatch(state, ops);
+			onState(state, myId);
+		},
+		sendAction: dispatchAction
+	};
+}
+//#endregion
+//#region src/sync/local.ts
+function resolveLocalTime(ops) {
+	const now = Date.now();
+	return ops.map((op) => op.value === "__SERVER_TIME__" ? {
+		...op,
+		value: now
+	} : op);
+}
+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());
+	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());
+		}
+	};
+}
+//#endregion
+//#region src/sync/online.ts
+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);
+		},
+		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;
+	let serverTimeOffset = 0;
+	let localSeq = 0;
+	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;
+		if (state) {
+			applyPatch(state, resolveToServerTime(ops));
+			onState(state, myId, estimateServerTime());
+		}
+		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);
+	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") {
+			console.log(`[SDK Sync] 🔄 Reconnected myId=${myId}`);
+			if (!gameInitSent) tryInitState();
+			return;
+		}
+		if (msgType === "__state_cleared") {
+			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);
+			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;
+			if (ackSenderId === myId) {
+				localSeq = ackSeq;
+				serverTimeOffset = serverTime - Date.now();
+				return;
+			}
+			if (requestStatePending) return;
+			if (ackSeq === localSeq + 1) {
+				if (!applyPatch(state, ackOps)) {
+					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) {
+				console.log(`[SDK Sync] ⚠️ Seq gap detected: expected=${localSeq + 1} received=${ackSeq}, requesting full state`);
+				requestStatePending = true;
+				ws.send(JSON.stringify({ type: "__request_state" }));
+			}
+			return;
+		}
+		if (msgType === "__state") {
+			state = parsed.state;
+			const serverTime = parsed.serverTime;
+			localSeq = parsed.seq ?? 0;
+			requestStatePending = false;
+			serverTimeOffset = serverTime - Date.now();
+			console.log(`[SDK Sync] ✅ State received serverTime=${serverTime} offset=${serverTimeOffset} seq=${localSeq}`);
+			ws.clearBuffer();
+			onState(state, myId, serverTime);
+			return;
+		}
+	});
+	return { ws };
+}
+//#endregion
+//#region src/index.ts
+const gameHandlers = /* @__PURE__ */ new Map();
 const _playersChangedHandlers = [];
 let _room = null;
 let _lastStateSnap = null;
@@ -26,443 +1870,361 @@ 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();
+const _snapshotListeners = /* @__PURE__ */ new Set();
 function notifyDevSnapshot(snap) {
-    _snapshotListeners.forEach((cb) => {
-        try {
-            cb(snap);
-        }
-        catch (err) {
-            console.warn('[uzu_dev] snapshot listener threw:', err);
-        }
-    });
+	_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 ─────────────────────────────────────────────
-// Node (serverActionLogic / vitest) からこの module を import しても落ちないよう
-// guard する。 トップレベルで window を読むと、 型やヘルパーを取りたいだけの
-// import でその場で ReferenceError になる。
-export const isHosted = typeof window !== 'undefined' && (!!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();
-    }
+	if (window.FlutterHost) return;
+	attachDevHooks({
+		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);
+			};
+		}
+	});
+}
+const isHosted = typeof window !== "undefined" && (!!window.FlutterHost || window.parent !== window);
+function getRoom() {
+	return _room;
+}
+function onRoom(callback) {
+	if (_room) callback(_room);
+	else _onRoomCallbacks.push(callback);
+}
+function init(opts) {
+	const params = new URLSearchParams(window.location.search);
+	_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.");
+	const serverParam = params.get("server");
+	if (serverParam && serverParam.length > 0) {
+		const base = serverParam.replace(/\/$/, "");
+		_wsEndpoint = `${base}/ws/rooms`;
+		_syncEndpoint = `${base}/ws/sync`;
+		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}`;
+	}
+	if (opts?.wsEndpoint) _wsEndpoint = opts.wsEndpoint;
+	if (opts?.syncEndpoint) _syncEndpoint = opts.syncEndpoint;
+	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);
+		} };
+		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 {}
+		});
+		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`);
+		onPauseChange((paused) => {
+			sendRaw("sdk", "pauseState", {
+				paused,
+				by: getPausedBy()
+			});
+		});
+		sendRaw("sdk", "ready", {});
+		_initialized = true;
+	}
+	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");
+		}
+	}
+	if (!_usesRun) attachDevHooksIfNotHosted();
 }
 /** game channel でカスタムメッセージを送信する。 native コマンドには使用不可。 */
-export function send(type, payload) {
-    sendRaw('game', type, payload ?? {});
+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);
+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 });
+function playSound(sound) {
+	sendRaw("sdk", "playSound", { sound });
 }
-export function playBgm(sound) {
-    sendRaw('sdk', 'playBgm', { sound });
+function playBgm(sound) {
+	sendRaw("sdk", "playBgm", { sound });
 }
-export function stopBgm() {
-    sendRaw('sdk', 'stopBgm', {});
+function stopBgm() {
+	sendRaw("sdk", "stopBgm", {});
 }
-export function setMicEnabled(enabled) {
-    sendRaw('sdk', 'setMicEnabled', { enabled });
+function setMicEnabled(enabled) {
+	sendRaw("sdk", "setMicEnabled", { enabled });
 }
-export function changeRoom(roomId) {
-    sendRaw('sdk', 'changeRoom', { roomId });
+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', {});
+* splash 描画完了を Flutter ホストに通知する。
+*
+* YouTube Playables の `firstFrameReady()` 相当。 Flutter は受信時に splash overlay を
+* 非表示にし WebView を可視化する。 **呼ばないと splash が出っぱなしになる**。
+*
+* 呼び出しタイミング: scenario が最初の絵 (splash / loading 画面) を画面に描いた直後。
+* paint commit を保証するため `requestAnimationFrame` を 1 段挟むのが定石。
+*
+* @example
+* ```ts
+* init();
+* drawSplash();
+* requestAnimationFrame(() => firstFrameReady());
+* ```
+*/
+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 ホストに通知する。
+*
+* YouTube Playables の `gameReady()` 相当。 Flutter は受信時に入力受付を開始し、TTI
+* (Time To Interactive) 計測を終了する。 将来の広告タイマー / leaderboard / analytics
+* の発火点としても使われる予定。
+*
+* 呼び出しタイミング: asset load 完了、 ゲーム本体の setup 完了、 入力受付可能になった直後。
+*
+* @example
+* ```ts
+* await loadAssets();
+* setupGame();
+* gameReady();
+* ```
+*/
+function gameReady() {
+	sendRaw("sdk", "gameReady", {});
 }
 /** Flutter からの playersChanged メッセージを受信するハンドラを登録する。 */
-export function onPlayersChanged(handler) {
-    _playersChangedHandlers.push(handler);
+function onPlayersChanged(handler) {
+	_playersChangedHandlers.push(handler);
 }
 /**
- * `A` に既定値が要る。 TypeScript は型引数の部分推論ができないので、 既定が無いと
- * 既存の `run<State>({…})` が「2 つ必要」で落ちる。 既定を置けば型引数を書かない
- * 呼び出しは `A` が推論されて検査が効き、 `run<State>` は従来どおり通る。
- *
- * `SA` の既定が `ServerActionMap<S>` (= `Record<string, …>`) だと
- * `keyof (A & SA)` が `string` へ潰れ、action 名の検査が丸ごと消える。
- * `serverActions` を持たない logic でもキーが残るよう空 map を既定にする。
- */
-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, mySeatKind) {
-            _lastStateSnap = { state, serverTime: 0, myId: myPlayerId };
-            origOnState(state, myPlayerId, mySeatKind);
-            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, players } = resolveSeatParams(params);
-        const seatKind = resolveSeatKind(params);
-        runOnlineServerAction(wrappedConfig, _gameEndpoint, roomId, seatId, players, seatKind);
-    }
-    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, players } = resolveSeatParams(params);
-        const { ws } = syncOnline(wrappedConfig, _syncEndpoint, roomId, seatId, players);
-        _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 ───────────────────────────────────────────────
+* `A` に既定値が要る。 TypeScript は型引数の部分推論ができないので、 既定が無いと
+* 既存の `run<State>({…})` が「2 つ必要」で落ちる。 既定を置けば型引数を書かない
+* 呼び出しは `A` が推論されて検査が効き、 `run<State>` は従来どおり通る。
+*
+* `SA` の既定が `ServerActionMap<S>` (= `Record<string, …>`) だと
+* `keyof (A & SA)` が `string` へ潰れ、action 名の検査が丸ごと消える。
+* `serverActions` を持たない logic でもキーが残るよう空 map を既定にする。
+*/
+function run(config) {
+	_usesRun = true;
+	const params = new URLSearchParams(window.location.search);
+	if (!isHosted) return;
+	init();
+	const origOnState = config.onState;
+	const wrappedConfig = {
+		...config,
+		onState(state, myPlayerId, mySeatKind) {
+			_lastStateSnap = {
+				state,
+				serverTime: 0,
+				myId: myPlayerId
+			};
+			runRendered(() => origOnState(state, myPlayerId, mySeatKind));
+			notifyDevSnapshot(state);
+		}
+	};
+	const roomId = params.get("roomId");
+	if (!roomId) _runHandle = runLocalServerAction(wrappedConfig);
+	else if (_gameEndpoint) {
+		const { seatId, players } = resolveSeatParams(params);
+		const seatKind = resolveSeatKind(params);
+		runOnlineServerAction(wrappedConfig, _gameEndpoint, roomId, seatId, players, seatKind);
+	} 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();
+}
+function sync(config) {
+	_usesRun = true;
+	const params = new URLSearchParams(window.location.search);
+	if (!isHosted) return;
+	init();
+	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, players } = resolveSeatParams(params);
+		const { ws } = syncOnline(wrappedConfig, _syncEndpoint, roomId, seatId, players);
+		_syncWs = ws;
+	} 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();
+}
 /**
- * 自分の席種別を URL から取り出す。
- *
- * `?seatKind=` はホスト (harness / emulator) が観測席の iframe に付ける。付いていない
- * ホストからの接続は player とみなす — 本番 (mobile / uzutokyo) は player 席しか開かない。
- *
- * この値は iframe URL 限定で、WebSocket には出さない。play-server は roster に居ない接続を
- * 通すだけで、その席が admin か spectator かを知る必要が無い。
- */
+* 自分の席種別を URL から取り出す。
+*
+* `?seatKind=` はホスト (harness / emulator) が観測席の iframe に付ける。付いていない
+* ホストからの接続は player とみなす — 本番 (mobile / uzutokyo) は player 席しか開かない。
+*
+* この値は iframe URL 限定で、WebSocket には出さない。play-server は roster に居ない接続を
+* 通すだけで、その席が admin か spectator かを知る必要が無い。
+*/
 function resolveSeatKind(params) {
-    const raw = params.get('seatKind');
-    return raw === 'admin' || raw === 'spectator' ? raw : 'player';
+	const raw = params.get("seatKind");
+	return raw === "admin" || raw === "spectator" ? raw : "player";
 }
 /**
- * 自席の ID と roster を URL から取り出す。
- *
- * roster (`?players=`) に自席が居ないことは異常ではない。観測者はそもそも roster に
- * 載らないまま接続してくる。
- *
- * 移行期: 旧ホスト (デプロイ前の mobile / uzutokyo / emulator) は `?seats=` で送ってくる。
- */
+* 自席の ID と roster を URL から取り出す。
+*
+* roster (`?players=`) に自席が居ないことは異常ではない。観測者はそもそも roster に
+* 載らないまま接続してくる。
+*
+* 移行期: 旧ホスト (デプロイ前の mobile / uzutokyo / emulator) は `?seats=` で送ってくる。
+*/
 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('players') ?? params.get('seats');
-    if (!json) {
-        throw new Error('[UZU SDK] players is required. Pass ?players=[...] in the URL.');
-    }
-    const raw = JSON.parse(json);
-    const players = raw.map((p) => ({
-        id: p.id,
-        nickname: p.name,
-        iconUrl: p.iconUrl,
-        characterId: p.characterId,
-    }));
-    return { seatId, players };
+	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("players") ?? params.get("seats");
+	if (!json) throw new Error("[UZU SDK] players is required. Pass ?players=[...] in the URL.");
+	return {
+		seatId,
+		players: JSON.parse(json).map((p) => ({
+			id: p.id,
+			nickname: p.name,
+			iconUrl: p.iconUrl,
+			characterId: p.characterId
+		}))
+	};
 }
 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;
+	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`);
-        }
-    });
+	const { seatId } = resolveSeatParams(new URLSearchParams(window.location.search));
+	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") 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), '*');
-    }
+	const msg = {
+		channel,
+		type,
+		payload,
+		..._playerId ? { playerId: _playerId } : {}
+	};
+	console.log(`[SDK] ➡ send channel=${channel} type=${type}`, JSON.stringify(msg));
+	if (window.FlutterHost) window.FlutterHost.postMessage(JSON.stringify(msg));
+	else if (window.parent !== window) 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 { channel, type, payload } = msg;
+	if (channel === "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;
+			}
+			case "requestPause":
+				console.log(`[SDK] ⏸ handleMessage sdk/requestPause`);
+				requestPause();
+				return;
+			case "requestResume":
+				console.log(`[SDK] ▶️ handleMessage sdk/requestResume`);
+				requestResume();
+				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;
+	}
+}
 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 (安全側に倒す)
- */
+* 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('players') ?? params.get('seats');
-    if (json) {
-        try {
-            const raw = JSON.parse(json);
-            actionCount = raw.length >= 2 ? 2 : 0;
-        }
-        catch {
-            // パース失敗時はデフォルト値を使用
-        }
-    }
-    let x = HUD_LEFT + UZU_BUTTON_SIZE;
-    if (actionCount > 0) {
-        x += GAP + ACTION_ITEM_WIDTH * actionCount;
-    }
-    return { x, y };
+	const y = 52;
+	let actionCount = 2;
+	const json = params.get("players") ?? params.get("seats");
+	if (json) try {
+		actionCount = JSON.parse(json).length >= 2 ? 2 : 0;
+	} catch {}
+	let x = 56;
+	if (actionCount > 0) x += GAP + ACTION_ITEM_WIDTH * actionCount;
+	return {
+		x,
+		y
+	};
 }
+//#endregion
+export { DEFAULT_ICON_URLS, ReconnectableWebSocket, Room, SERVER_TIME, SeededRandomImpl, applyJsonMergePatch, applyJsonPatch, attachDevHooks, changeRoom, createDevHooks, firstFrameReady, gameReady, gameTime, getPredictionWarnings, getRoom, init, isHosted, isPaused, isServerOnlyAction, minus, on, onPauseChange, onPlayersChanged, onRoom, playBgm, playSound, plus, run, send, serverOnly, setMicEnabled, stopBgm, sync };