@uzuhq/code-cli 0.6.3 → 0.6.4

package/dist/cli.js

@@ -3,10 +3,10 @@
 // src/cli.ts
 import { Command, Option } from "commander";
 import { execSync } from "child_process";
-import { readFileSync as readFileSync6, existsSync as existsSync4, unlinkSync, createWriteStream } from "fs";
-import { dirname as dirname5, resolve as resolve6 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync5, unlinkSync as unlinkSync2, createWriteStream } from "fs";
+import { dirname as dirname5, resolve as resolve7 } from "path";
 import { ZipArchive } from "archiver";
-import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL2 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/r2-upload.ts
 import { readFileSync } from "fs";
@@ -418,6 +418,9 @@ var registerRevision = async (params) => {
 
 // src/build-server-logic.ts
 import { build } from "esbuild";
+import { existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { pathToFileURL } from "url";
 
 // src/sdk-server-stub.ts
 import { existsSync } from "fs";
@@ -461,10 +464,27 @@ var buildServerLogic = async (logicPath, outPath) => {
   });
   console.log(`Built server logic: ${logicPath} \u2192 ${outPath}`);
 };
+var buildAndVerifyServerLogic = async (cwd, serverActionLogicPath) => {
+  const logicOutPath = resolve2(cwd, "__logic__.js");
+  try {
+    await buildServerLogic(resolve2(cwd, serverActionLogicPath), logicOutPath);
+    const logicModule = await import(pathToFileURL(logicOutPath).href);
+    if (!(logicModule.default ?? logicModule.logic)) {
+      throw new Error(
+        `${serverActionLogicPath} must export a GameLogic object.
+  Use either: export default logic
+  Or:         export const logic: GameLogic<State> = { ... }`
+      );
+    }
+    return readFileSync2(logicOutPath, "utf-8");
+  } finally {
+    if (existsSync2(logicOutPath)) unlinkSync(logicOutPath);
+  }
+};
 
 // src/create-2d-game.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync, readdirSync, statSync } from "fs";
-import { resolve as resolve2, dirname as dirname2, join as join3 } from "path";
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync, readdirSync, statSync } from "fs";
+import { resolve as resolve3, dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname = dirname2(fileURLToPath2(import.meta.url));
 var copyDir = (src, dest, replacements) => {
@@ -477,13 +497,13 @@ var copyDir = (src, dest, replacements) => {
       continue;
     }
     if (entry.endsWith(".tpl")) {
-      let content = readFileSync2(srcPath, "utf-8");
+      let content = readFileSync3(srcPath, "utf-8");
       for (const [key, value] of Object.entries(replacements)) {
         content = content.replaceAll(`{{${key}}}`, value);
       }
       writeFileSync(join3(dest, entry.replace(/\.tpl$/, "")), content);
     } else {
-      const content = readFileSync2(srcPath, "utf-8");
+      const content = readFileSync3(srcPath, "utf-8");
       let output = content;
       for (const [key, value] of Object.entries(replacements)) {
         output = output.replaceAll(`{{${key}}}`, value);
@@ -494,8 +514,8 @@ var copyDir = (src, dest, replacements) => {
 };
 var toTitle = (name) => name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 var create2dGame = (name) => {
-  const dest = resolve2(process.cwd(), name);
-  const templateDir = resolve2(__dirname, "..", "game-2d-template");
+  const dest = resolve3(process.cwd(), name);
+  const templateDir = resolve3(__dirname, "..", "game-2d-template");
   const title = toTitle(name);
   const replacements = { name, title };
   console.log(`Creating 2D game project: ${name}`);
@@ -510,7 +530,7 @@ Next steps:`);
 };
 
 // src/cf-images-upload.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { basename as basename2 } from "path";
 var parseUploadedImageId = (v) => {
   if (typeof v === "object" && v !== null && "success" in v && v.success === true && "result" in v && typeof v.result === "object" && v.result !== null && "id" in v.result && typeof v.result.id === "string" && v.result.id !== "") {
@@ -529,7 +549,7 @@ var uploadIconsToCfImages = async (env, token, filePaths) => {
     filePaths.map(async (filePath, i) => {
       const image = session.images[i];
       const formData = new FormData();
-      formData.append("file", new Blob([readFileSync3(filePath)]), basename2(filePath));
+      formData.append("file", new Blob([readFileSync4(filePath)]), basename2(filePath));
       const res = await fetch(image.uploadURL, { method: "POST", body: formData });
       if (!res.ok) {
         const detail = (await res.text()).trim();
@@ -546,8 +566,8 @@ var uploadIconsToCfImages = async (env, token, filePaths) => {
 
 // src/dev.ts
 import { spawn } from "child_process";
-import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
-import { dirname as dirname3, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { createInterface } from "readline";
 
@@ -786,7 +806,7 @@ function parseRoster(rosterParam) {
     return null;
   }
   if (!Array.isArray(raw)) return null;
-  return raw.filter((p) => (p.kind ?? "player") === "player").map((p) => ({
+  return raw.map((p) => ({
     id: p.id,
     nickname: p.name ?? "Guest",
     iconUrl: p.iconUrl ?? "",
@@ -798,154 +818,215 @@ function parseRoster(rosterParam) {
 var BRIDGE_VERSION = 1;
 var WIRE_VERSION = 2;
 
-// src/dev-server/admin-state-patch.ts
-var MERGE_PATCH_ARRAY_REJECT = "[applyJsonMergePatch] cannot merge a non-array patch into an array target";
-function applyJsonMergePatch(target, patch) {
-  if (patch === null || typeof patch !== "object" || Array.isArray(patch)) return;
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === void 0) continue;
-    if (value === null) {
-      target[key] = null;
-      continue;
-    }
-    if (Array.isArray(value)) {
-      target[key] = value;
-      continue;
-    }
-    if (typeof value === "object") {
-      const existing = target[key];
-      if (Array.isArray(existing)) {
-        throw new Error(MERGE_PATCH_ARRAY_REJECT);
-      }
-      if (existing === null || typeof existing !== "object") {
-        target[key] = value;
-        continue;
-      }
-      applyJsonMergePatch(existing, value);
-      continue;
-    }
-    target[key] = value;
-  }
-}
-function applyJsonPatch(target, ops) {
-  const ok = applyPatch(target, ops);
-  if (!ok) {
-    throw new Error("[applyJsonPatch] failed to apply one or more operations");
-  }
-}
-
-// src/dev-server/game-room.ts
-var GameRoom = class _GameRoom {
+// ../room-core/src/room-core.ts
+var newSeed = () => crypto.getRandomValues(new Uint32Array(1))[0];
+var asString = (value) => typeof value === "string" ? value : null;
+var asNumber = (value) => typeof value === "number" ? value : null;
+var GameRoomCore = class _GameRoomCore {
   logic;
+  label;
+  storage;
+  /** transport の tick ループ制御用。0 なら tick を回さない。 */
   tickRate;
+  /** 進行中の state。null ならまだ `setup()` が走っていない。 */
   gameState = null;
   stateInitialized = false;
   random = null;
+  /** dev harness が `reset({ seed })` の再現に使うので protected。 */
   seed = 0;
   tickCount = 0;
-  tickTimer = null;
-  tickPaused = false;
   playerInputs = {};
-  /**
-   * roster。 配役を受け取る player 席のみで、 観測席 (GM 席・観戦席) は載らない。
-   * dev harness では manifest から組んだ roster を constructor で注入する
-   * (server 権威)。 その場合、 接続クエリの roster 申告は一切採用しないので、
-   * 旧世代 harness page の残タブが reconnect しても roster を汚染できない。
-   * 本番 DO は backend 由来の roster を全 client が同一申告するため接続時
-   * 登録で成立している — 権威が platform 側にある点は同じ。
-   */
+  /** 所与の roster。配役を受け取る player 席のみで、観測席 (GM 席・観戦席) は載らない。 */
   players = [];
+  /** 差分同期用シーケンス番号 */
   seq = 0;
+  /** 前回ブロードキャスト時の state スナップショット（差分計算ベース） */
   prevBroadcastState = null;
+  /** N回に1回フルスナップショットを送信する間隔 */
   static SNAPSHOT_INTERVAL = 20;
+  /** storage 書き込みデバウンス用タイマー */
+  storageFlushTimer = null;
+  static STORAGE_DEBOUNCE_MS = 500;
+  /** 処理中の RPC 1 回分の送信バッファ。各 RPC の入口で begin() が張り替える。 */
+  out = { toSender: [], broadcast: [] };
   // ─── ゲーム内時計 ──────────────────────────────────────
-  // 算術と凍結の出入りは engine-core の GameClock (facet と共有)。
+  // 算術と凍結の出入りは engine-core の GameClock に閉じている (ソロ実装とも共有)。
+  // ここが持つのは永続化と、停止に付随する情報だけ。
   clock = new GameClock();
+  /** 緊急停止を要求した playerId (表示用)。 */
   pausedBy = null;
+  /** 接続が 0 になった実時刻。猶予の判定にだけ使う。 */
   lastEmptyAtWall = null;
   /** at() が壊れた値を返したと既に記録した締切。ログを 1 回に絞るため。 */
   warnedDeadlines = /* @__PURE__ */ new Set();
-  sockets = /* @__PURE__ */ new Set();
-  attachments = /* @__PURE__ */ new WeakMap();
-  snapshotSubscribers = /* @__PURE__ */ new Set();
-  eventSubscribers = /* @__PURE__ */ new Set();
-  constructor(logic, players) {
+  constructor(logic, opts) {
     this.logic = logic;
+    this.label = opts.label;
+    this.storage = opts.storage ?? null;
     this.tickRate = logic.tickRate ?? 0;
-    if (players && players.length > 0) {
-      this.players = players;
+    if (opts.players && opts.players.length > 0) {
+      this.players = opts.players;
       console.log(
-        `[GameRoom] \u{1F4CB} Roster (server-authoritative): ${players.map((p) => p.id).join(", ")}`
+        `${this.label} \u{1F4CB} Roster (server-authoritative): ${opts.players.map((p) => p.id).join(", ")}`
       );
     }
   }
-  // ─── ゲーム内時計 ───────────────────────────────────────
-  /** ゲーム開始からの ms。停止中は進まない。Unix epoch ではない。 */
   gameTime() {
     return this.clock.now();
   }
   get frozen() {
     return this.clock.frozen;
   }
+  /** 凍結の出入りは必ずここを通す。時計と storage が一緒に動くのを保証する。 */
+  freeze(reason) {
+    if (this.clock.freeze(reason)) this.persistClock();
+  }
+  /** 実際に理由を外したら true。呼び出し側が二重 put を避けるために使う。 */
+  unfreeze(reason) {
+    if (!this.clock.unfreeze(reason)) return false;
+    this.persistClock();
+    return true;
+  }
   /** ハンドラへ渡す ctx の時刻部分。1 回の呼び出し内で値が動かないよう束ねる。 */
   timeCtx(time) {
     return { time, after: (d) => plus(time, d) };
   }
-  freeze(reason) {
-    if (!this.clock.freeze(reason)) return;
-    this.stopTickLoop();
-    this.syncWakeup();
+  // ─── Outcome ───────────────────────────────────────────
+  begin() {
+    this.out = { toSender: [], broadcast: [] };
   }
-  unfreeze(reason) {
-    if (!this.clock.unfreeze(reason)) return;
-    this.syncWakeup();
-    this.ensureTickLoop();
+  finish() {
+    return {
+      toSender: this.out.toSender,
+      broadcast: this.out.broadcast,
+      nextDeadline: this.nextDeadline(),
+      tickRate: this.tickRate,
+      started: this.gameState !== null,
+      frozen: this.frozen
+    };
   }
+  // ─── Hibernation Recovery ──────────────────────────────
   /**
-   * 停止の状態を全接続へ配る。
+   * 永続化したインメモリ state を復元する。
    *
-   * `no-players` は見せない。外れる条件が「接続した」なので、クライアントが見られる
-   * 状態では必ず外れている。
+   * facet はコード更新 (`facets.abort()`) や eviction で再起動されるので、**全 RPC の
+   * 入口で呼ぶこと**。呼び忘れると再起動後の `__action` が `state === null` で無視され、
+   * プレイヤーの入力がサーバーに反映されない。
+   *
+   * 揮発 (storage なし) なら何も読むものが無いので即座に返る。
    */
-  broadcastPauseState() {
-    this.broadcastAll({
-      type: "__pause_state",
-      frozen: this.clock.isFrozenBy("emergency-stop"),
-      by: this.pausedBy,
-      gameTime: this.gameTime()
+  async hydrate() {
+    if (this.stateInitialized || this.storage === null) return;
+    const savedState = asString(await this.storage.get("state"));
+    if (savedState === null) return;
+    this.gameState = JSON.parse(savedState);
+    this.stateInitialized = true;
+    this.tickCount = asNumber(await this.storage.get("tickCount")) ?? 0;
+    this.seed = asNumber(await this.storage.get("seed")) ?? newSeed();
+    const savedRandomState = asNumber(await this.storage.get("randomState"));
+    this.random = savedRandomState !== null ? SeededRandomImpl.fromState(savedRandomState) : new SeededRandomImpl(this.seed);
+    const savedRoster = asString(await this.storage.get("seats"));
+    if (savedRoster) this.players = JSON.parse(savedRoster);
+    this.seq = asNumber(await this.storage.get("seq")) ?? 0;
+    await this.loadClock();
+    this.prevBroadcastState = null;
+    console.log(
+      `${this.label} \u{1F504} State recovered from storage tick=${this.tickCount} seq=${this.seq} frozenBy=[${this.clock.snapshot().frozenBy.join(",")}]`
+    );
+  }
+  // ─── Storage Persistence ───────────────────────────────
+  /** 揮発なら書かない。dev-server は CLI restart で state を失う前提で動いている。 */
+  persist(entries) {
+    const storage = this.storage;
+    if (storage === null) return;
+    Promise.all(Object.entries(entries).map(([key, value]) => storage.put(key, value))).catch(
+      (err) => console.error(`${this.label} \u274C Storage put failed`, err)
+    );
+  }
+  /**
+   * 時計を即時 put する。**停止の遷移だけは debounce を通さない。**
+   *
+   * 停止直後に evict されて停止が消えると、世界が勝手に動き出す。
+   */
+  persistClock() {
+    this.persist({
+      clock: JSON.stringify(this.clock.snapshot()),
+      pausedBy: this.pausedBy,
+      lastEmptyAtWall: this.lastEmptyAtWall
     });
   }
-  // ─── Broadcast ─────────────────────────────────────────
-  broadcastAll(msg) {
-    const data = JSON.stringify(msg);
-    for (const ws of this.sockets) {
+  /** 欠損は「未停止」に倒す。読めなかったせいで世界が止まったままになる方が悪い。 */
+  async loadClock() {
+    const storage = this.storage;
+    if (storage === null) return;
+    const saved = asString(await storage.get("clock"));
+    if (saved !== null) {
       try {
-        ws.send(data);
-      } catch {
+        this.clock.restore(JSON.parse(saved));
+      } catch (err) {
+        console.error(`${this.label} \u274C Clock restore failed \u2192 \u672A\u505C\u6B62\u3068\u3057\u3066\u7D9A\u884C`, err);
       }
     }
+    this.pausedBy = asString(await storage.get("pausedBy"));
+    this.lastEmptyAtWall = asNumber(await storage.get("lastEmptyAtWall"));
+    if (!this.clock.isFrozenBy("emergency-stop")) this.pausedBy = null;
   }
-  sendTo(ws, msg) {
-    try {
-      ws.send(JSON.stringify(msg));
-    } catch {
+  cancelStorageFlush() {
+    if (this.storageFlushTimer !== null) {
+      clearTimeout(this.storageFlushTimer);
+      this.storageFlushTimer = null;
     }
   }
+  /**
+   * デバウンス付き storage 書き込み。ブロードキャストのクリティカルパスから I/O を除去。
+   */
+  debouncedPersist() {
+    if (this.storage === null) return;
+    this.cancelStorageFlush();
+    this.storageFlushTimer = setTimeout(() => {
+      this.storageFlushTimer = null;
+      this.persist({
+        state: JSON.stringify(this.gameState),
+        tickCount: this.tickCount,
+        randomState: this.random?.state ?? 0,
+        seq: this.seq
+      });
+    }, _GameRoomCore.STORAGE_DEBOUNCE_MS);
+  }
+  // ─── Message Buffers ───────────────────────────────────
+  broadcastAll(msg) {
+    this.out.broadcast.push(JSON.stringify(msg));
+  }
+  sendToSender(msg) {
+    this.out.toSender.push(JSON.stringify(msg));
+  }
+  /**
+   * state を配ったあとに呼ばれる。dev harness の購読 (`subscribeSnapshot` /
+   * `subscribeEvents`) はここに乗る。本番は override しないので何もしない。
+   */
+  afterStateChanged(_events) {
+  }
+  /**
+   * 差分 or フルで state をブロードキャストする。
+   * prevBroadcastState が null、または SNAPSHOT_INTERVAL ごとにフル送信。
+   * それ以外は JSON Patch 差分を送信し、サイズが小さい方を採用する。
+   */
   broadcastStateDelta(events, extra) {
     this.seq++;
     const gameTime = this.gameTime();
     const fullType = extra.ack !== void 0 ? "__action_result" : "__tick";
     const deltaType = extra.ack !== void 0 ? "__action_result_delta" : "__tick_delta";
-    const needFull = this.prevBroadcastState === null || this.seq % _GameRoom.SNAPSHOT_INTERVAL === 0;
+    const needFull = this.prevBroadcastState === null || this.seq % _GameRoomCore.SNAPSHOT_INTERVAL === 0;
+    const fullPayload = JSON.stringify({
+      type: fullType,
+      state: this.gameState,
+      events,
+      seq: this.seq,
+      gameTime,
+      ...extra
+    });
     if (needFull) {
-      this.broadcastAll({
-        type: fullType,
-        state: this.gameState,
-        events,
-        seq: this.seq,
-        gameTime,
-        ...extra
-      });
+      this.out.broadcast.push(fullPayload);
     } else {
       const patches = compare(this.prevBroadcastState, this.gameState);
       const deltaPayload = JSON.stringify({
@@ -956,75 +1037,169 @@ var GameRoom = class _GameRoom {
         gameTime,
         ...extra
       });
-      const fullPayload = JSON.stringify({
-        type: fullType,
-        state: this.gameState,
-        events,
-        seq: this.seq,
-        gameTime,
-        ...extra
-      });
-      const data = deltaPayload.length < fullPayload.length ? deltaPayload : fullPayload;
-      for (const ws of this.sockets) {
-        try {
-          ws.send(data);
-        } catch {
-        }
-      }
+      this.out.broadcast.push(
+        deltaPayload.length < fullPayload.length ? deltaPayload : fullPayload
+      );
     }
     this.prevBroadcastState = structuredClone(this.gameState);
-    this.notifySnapshotSubscribers();
-    if (events.length > 0) this.notifyEventSubscribers(events);
+    this.afterStateChanged(events);
   }
-  notifySnapshotSubscribers() {
-    this.snapshotSubscribers.forEach((cb) => {
-      try {
-        cb(this.gameState);
-      } catch (err) {
-        console.warn("[GameRoom] snapshot subscriber threw:", err);
-      }
-    });
+  // ─── Deadlines ─────────────────────────────────────────
+  hasAction(name) {
+    return Boolean(this.logic.actions[name] || this.logic.serverActions?.[name]);
   }
-  notifyEventSubscribers(events) {
-    const frozen = Object.freeze(events.slice());
-    this.eventSubscribers.forEach((cb) => {
+  /**
+   * 宣言された締切のうち最も早いゲーム内時刻。締切が無ければ null。
+   *
+   * state から毎回導出するので保存しない。action が throw して state が巻き戻れば
+   * 締切も一緒に巻き戻る。
+   */
+  earliestDeadline() {
+    if (!this.gameState || !this.logic.deadlines) return null;
+    let earliest = null;
+    for (const [key, deadline] of Object.entries(this.logic.deadlines)) {
+      let raw;
       try {
-        cb(frozen);
+        raw = deadline.at({ state: this.gameState });
       } catch (err) {
-        console.warn("[GameRoom] event subscriber threw:", err);
+        console.error(`[Deadline] \u274C ${key}.at() \u3067\u4F8B\u5916`, err);
+        continue;
       }
+      const at = resolveDeadline(
+        raw,
+        key,
+        this.warnedDeadlines,
+        (m) => console.error(`[Deadline] \u274C ${m}`)
+      );
+      if (at === null) continue;
+      if (earliest === null || at < earliest) earliest = at;
+    }
+    return earliest;
+  }
+  /**
+   * transport に写す次の起床**実時刻**。
+   *
+   * 停止中はシナリオの締切を予約しない。停止に入った時点で予約済みの起床は残って
+   * 発火するが、期限はゲーム内時刻で見るので空振りし、再アームで自己修復する。
+   */
+  nextDeadline() {
+    const candidates = [];
+    if (!this.frozen) {
+      const earliest = this.earliestDeadline();
+      if (earliest !== null) candidates.push(this.clock.toWall(earliest));
+    }
+    if (this.lastEmptyAtWall !== null && !this.clock.isFrozenBy("no-players")) {
+      candidates.push(this.lastEmptyAtWall + NO_PLAYERS_GRACE_MS);
+    }
+    return candidates.length === 0 ? null : Math.min(...candidates);
+  }
+  /** 猶予が満了していれば無人凍結に入る。 */
+  freezeIfEmptyGraceExpired() {
+    if (this.lastEmptyAtWall === null) return;
+    if (this.clock.isFrozenBy("no-players")) return;
+    if (Date.now() < this.lastEmptyAtWall + NO_PLAYERS_GRACE_MS) return;
+    console.log(
+      `${this.label} \u{1F9CA} \u7121\u4EBA\u7336\u4E88 ${NO_PLAYERS_GRACE_MS}ms \u6E80\u4E86 \u2192 \u6642\u8A08\u3092\u505C\u6B62 gameTime=${this.gameTime()}`
+    );
+    this.freeze("no-players");
+  }
+  /**
+   * 停止の状態を全接続へ配る。
+   *
+   * `no-players` は見せない。外れる条件が「接続した」なので、クライアントが見られる
+   * 状態では必ず外れている。overlay は `emergency-stop` だけで出す。
+   */
+  broadcastPauseState() {
+    this.broadcastAll({
+      type: "__pause_state",
+      frozen: this.clock.isFrozenBy("emergency-stop"),
+      by: this.pausedBy,
+      gameTime: this.gameTime()
     });
   }
-  // ─── Game Lifecycle ────────────────────────────────────
   /**
-   * 移行期: 手元のシナリオが `setup({ seats })` のままでも `uzu dev` を動かせるよう、
-   * 同じ配列を旧名でも渡す。 本番 (play-server) が publish 済み logic.js のために
-   * 同じことをしているのと揃えている。 `SetupArgs` に `seats` を宣言しないのは、
-   * 新規シナリオに旧名を選ばせないため。
+   * action を 1 件実行して broadcast する。
+   *
+   * WebSocket 経由 (ack あり) と予約発火 (ack 無し) の両方から使う。
+   * 「全部成功か全部失敗か」にするため、throw したら state を巻き戻して broadcast しない。
    */
-  setupArgs(random) {
+  async runAction(actionName, payload, senderId, opts) {
+    if (!this.gameState) return { ok: false, error: "Game not started" };
+    const plain = this.logic.actions[actionName];
+    const legacyServerOnly = isServerOnlyAction(plain) ? plain : null;
+    const serverHandler = this.logic.serverActions?.[actionName] ?? legacyServerOnly;
+    if (!plain && !serverHandler) return { ok: false, error: `Unknown action: ${actionName}` };
+    const events = [];
+    const emit = (name, data) => events.push({ name, data: data ?? {} });
+    const serverEmit = emit;
+    const snapshot = structuredClone(this.gameState);
+    const time = this.gameTime();
+    try {
+      if (plain && !legacyServerOnly) {
+        const state = this.gameState;
+        withGameClock(
+          time,
+          () => plain({
+            state,
+            payload,
+            playerId: senderId,
+            ctx: { ...this.timeCtx(time), emit }
+          })
+        );
+      }
+      if (serverHandler) {
+        await serverHandler({
+          state: this.gameState,
+          payload,
+          playerId: senderId,
+          ctx: {
+            tick: this.tickCount,
+            random: this.random ?? new SeededRandomImpl(this.seed),
+            ...this.timeCtx(time),
+            emit: serverEmit
+          }
+        });
+      }
+    } catch (err) {
+      this.gameState = snapshot;
+      return { ok: false, error: err instanceof Error ? err.message : "unknown", cause: err };
+    }
+    this.broadcastStateDelta(
+      events,
+      opts.ack !== void 0 ? { ack: opts.ack, from: senderId } : {}
+    );
+    this.debouncedPersist();
+    return { ok: true };
+  }
+  // ─── Game Lifecycle ────────────────────────────────────
+  setupArgs(random, setupTime) {
     return {
       players: this.players,
-      seats: this.players,
-      ctx: { random, ...this.timeCtx(this.gameTime()) }
+      ctx: { random, ...this.timeCtx(setupTime) }
     };
   }
-  maybeStartGame() {
-    if (this.gameState !== null) return;
-    if (this.players.length === 0) return;
-    this.seed = Math.floor(Math.random() * 4294967295);
-    this.random = new SeededRandomImpl(this.seed);
+  /**
+   * `setup()` を走らせて部屋を起動する。開始と reset の共通部。
+   *
+   * ctx は withGameClock の外で組み立てる。中で gameTime() を読むと、差し替えた
+   * Date.now を実時刻として引き算してしまう。
+   */
+  startGame(seed) {
+    this.seed = seed;
+    this.random = new SeededRandomImpl(seed);
     this.clock.restart();
     this.pausedBy = null;
     this.lastEmptyAtWall = null;
     const setupTime = this.gameTime();
-    const args = this.setupArgs(this.random);
+    const args = this.setupArgs(this.random, setupTime);
     this.gameState = withGameClock(setupTime, () => this.logic.setup(args));
     this.stateInitialized = true;
     this.tickCount = 0;
     this.seq = 0;
     this.prevBroadcastState = structuredClone(this.gameState);
-    console.log(`[GameRoom] \u2705 Game started with ${this.players.length} players`);
+    this.persist({ seats: JSON.stringify(this.players), seed: this.seed });
+    this.persistClock();
+    this.debouncedPersist();
     this.broadcastAll({
       type: "__game_start",
       state: this.gameState,
@@ -1032,62 +1207,46 @@ var GameRoom = class _GameRoom {
       seq: 0,
       gameTime: this.gameTime()
     });
-    if (this.tickRate > 0) this.startTickLoop();
-    this.syncWakeup();
-    this.notifySnapshotSubscribers();
+    this.afterStateChanged([]);
   }
-  startTickLoop() {
-    if (this.tickTimer) clearInterval(this.tickTimer);
-    this.tickTimer = setInterval(() => this.tick(), 1e3 / this.tickRate);
-  }
-  // 全クライアント切断で tickTimer は止まる (handleClose) が gameState は残るため、
-  // 再接続や reset で「動いているべきなのに止まっている」状態を復旧する。
-  ensureTickLoop() {
-    if (this.tickRate > 0 && this.gameState !== null && this.sockets.size > 0 && !this.tickPaused && !this.frozen && !this.tickTimer) {
-      this.startTickLoop();
-    }
+  /**
+   * roster が確定していればゲームを開始する。
+   * roster は所与 (注入か URL の players パラメータ)。接続の有無には依存しない。
+   */
+  maybeStartGame() {
+    if (this.gameState !== null) return;
+    if (this.players.length === 0) return;
+    this.startGame(newSeed());
+    console.log(`${this.label} \u2705 Game started with ${this.players.length} players`);
   }
-  stopTickLoop() {
-    if (this.tickTimer) {
-      clearInterval(this.tickTimer);
-      this.tickTimer = null;
-    }
+  /**
+   * 部屋を作り直す。dev harness の `reset()` 専用で、本番の RPC からは到達しない。
+   *
+   * 新規ゲームなので時計も 0 から始め直す。
+   */
+  resetGame(opts) {
+    this.begin();
+    const seed = opts?.seed === "random" ? newSeed() : typeof opts?.seed === "number" ? opts.seed : this.seed;
+    this.startGame(seed);
+    return this.finish();
   }
-  tick() {
-    if (this.tickPaused || this.frozen) return;
-    this.runOneTick();
+  // ─── Roster ────────────────────────────────────────────
+  /**
+   * 申告 roster が pin 済み roster と食い違ったら警告する。挙動は変えない。
+   *
+   * roster は端末ごとに組まれるうえ roomId は固定なので、参加者が確定する前に誰か
+   * 1 人が接続すると、その時点の顔ぶれで部屋が固定される。溢れた player 席は
+   * state.players に居ないまま繋がり、真っ黒ではなく静かに観測者ビューになる。
+   * 例外も出ないため、ログでしか気付けない。
+   */
+  warnIfRosterDiffers(declared, seatId) {
+    const pinned = this.players.map((p) => p.id).sort();
+    const incoming = declared.map((p) => p.id).sort();
+    if (pinned.length === incoming.length && pinned.every((id, i) => id === incoming[i])) return;
+    console.warn(
+      `${this.label} \u26A0\uFE0F Roster mismatch seatId=${seatId} pinned=[${pinned.join(",")}] declared=[${incoming.join(",")}]`
+    );
   }
-  runOneTick() {
-    if (!this.gameState || !this.random) return;
-    const events = [];
-    const emit = (name, data) => events.push({ name, data: data ?? {} });
-    const time = this.gameTime();
-    const random = this.random;
-    const state = this.gameState;
-    try {
-      withGameClock(
-        time,
-        () => this.logic.update({
-          state,
-          ctx: {
-            random,
-            tick: this.tickCount,
-            ...this.timeCtx(time),
-            emit,
-            playerInputs: this.playerInputs
-          }
-        })
-      );
-    } catch (err) {
-      console.error(`[GameRoom] tick error at tick=${this.tickCount}:`, err);
-      this.tickCount++;
-      return;
-    }
-    this.tickCount++;
-    this.syncWakeup();
-    this.broadcastStateDelta(events, { tick: this.tickCount });
-  }
-  // ─── Connection ────────────────────────────────────────
   /**
    * 復帰用の state メッセージ。
    *
@@ -1104,251 +1263,173 @@ var GameRoom = class _GameRoom {
       pausedBy: this.pausedBy
     };
   }
-  handleConnection(ws, url) {
-    const playerId = url.searchParams.get("seatId");
-    if (!playerId) {
-      ws.close(1008, "Missing required query parameter: seatId");
-      return;
-    }
-    const nickname = url.searchParams.get("nickname") ?? "Guest";
-    const connectionId = randomUUID();
+  // ─── RPC (transport から呼ばれる) ───────────────────────
+  /**
+   * 接続 1 件の受け入れ処理。transport が WS を受け入れた後に呼ぶ。
+   * 進行中なら toSender に __state、roster 確定でゲーム開始なら broadcast に
+   * __game_start が載る (両者は排他: 開始済みなら maybeStartGame は no-op)。
+   *
+   * IMPORTANT: 永続化ありの transport は**必ず [hydrate] を先に await すること**。
+   * facet 再起動直後は this.players が空なので、復元前にここへ入ると pin 済み roster を
+   * 持つ部屋を未 pin と誤認し、申告どおりに上書きしてしまう。
+   */
+  connect(playerId, rosterParam) {
+    this.begin();
+    const declaredRoster = parseRoster(rosterParam);
     if (this.players.length === 0) {
-      const declared = parseRoster(
-        url.searchParams.get("players") ?? url.searchParams.get("seats")
-      );
-      if (declared && declared.length > 0) {
-        this.players = declared;
-        console.log(`[GameRoom] \u{1F4CB} Roster pinned: ${this.players.map((p) => p.id).join(", ")}`);
+      if (declaredRoster && declaredRoster.length > 0) {
+        this.players = declaredRoster;
+        console.log(`${this.label} \u{1F4CB} Roster pinned: ${this.players.map((p) => p.id).join(", ")}`);
       }
+    } else if (declaredRoster) {
+      this.warnIfRosterDiffers(declaredRoster, playerId);
     }
-    console.log(
-      `[GameRoom] \u{1F517} New connection: connectionId=${connectionId} playerId=${playerId} nickname=${nickname}`
-    );
-    this.sockets.add(ws);
-    this.attachments.set(ws, { connectionId, playerId, nickname });
-    ws.on("message", (raw) => {
-      void this.handleMessage(ws, raw.toString());
-    });
-    ws.on("close", () => this.handleClose(ws));
-    ws.on("error", () => this.handleClose(ws));
-    this.sendTo(ws, {
-      type: "__room_init",
-      myId: playerId
-    });
+    const hadEmptyMark = this.lastEmptyAtWall !== null;
     this.lastEmptyAtWall = null;
-    this.unfreeze("no-players");
+    if (!this.unfreeze("no-players") && hadEmptyMark) this.persistClock();
     if (this.stateInitialized && this.gameState !== null) {
-      this.sendTo(ws, this.stateMessage());
+      this.sendToSender(this.stateMessage());
     }
     this.maybeStartGame();
-    this.ensureTickLoop();
+    return this.finish();
   }
-  async handleMessage(ws, msg) {
-    if (msg === "__ping") {
-      try {
-        ws.send("__pong");
-      } catch {
-      }
-      return;
-    }
-    const attachment = this.attachments.get(ws);
-    if (!attachment) return;
-    const senderId = attachment.playerId;
+  /** WS メッセージ 1 件の処理。 */
+  async message(senderId, msg) {
+    this.begin();
     let parsed;
     try {
       parsed = JSON.parse(msg);
     } catch {
-      return;
+      return this.finish();
     }
     const msgType = parsed.type;
-    console.log(`[GameRoom] \u2B05 recv from=${senderId} type=${msgType}`);
+    console.log(`${this.label} \u2B05 recv from=${senderId} type=${msgType}`);
     if (msgType === "__pause") {
-      if (!this.gameState) return;
+      if (!this.gameState) return this.finish();
       if (!this.clock.isFrozenBy("emergency-stop")) {
         this.pausedBy = senderId;
         this.freeze("emergency-stop");
-        console.log(`[GameRoom] \u23F8 \u7DCA\u6025\u505C\u6B62 by=${senderId} gameTime=${this.gameTime()}`);
+        console.log(`${this.label} \u23F8 \u7DCA\u6025\u505C\u6B62 by=${senderId} gameTime=${this.gameTime()}`);
       }
       this.broadcastPauseState();
-      return;
+      return this.finish();
     }
     if (msgType === "__resume") {
       if (this.clock.isFrozenBy("emergency-stop")) {
-        this.unfreeze("emergency-stop");
         this.pausedBy = null;
-        console.log(`[GameRoom] \u25B6\uFE0F \u7DCA\u6025\u505C\u6B62\u3092\u89E3\u9664 by=${senderId} gameTime=${this.gameTime()}`);
+        this.unfreeze("emergency-stop");
+        console.log(`${this.label} \u25B6\uFE0F \u7DCA\u6025\u505C\u6B62\u3092\u89E3\u9664 by=${senderId} gameTime=${this.gameTime()}`);
       }
       this.broadcastPauseState();
-      return;
+      return this.finish();
     }
     if (this.frozen && (msgType === "__action" || msgType === "__input")) {
       if (msgType === "__action") {
-        this.sendTo(ws, { type: "__action_error", error: "Paused", seq: parsed.seq });
+        this.sendToSender({ type: "__action_error", error: "Paused", seq: parsed.seq });
       }
-      return;
+      return this.finish();
     }
     if (msgType === "__action") {
       if (!this.gameState) {
-        this.sendTo(ws, {
+        this.sendToSender({
           type: "__action_error",
           error: "Game not started",
           seq: parsed.seq
         });
-        return;
+        return this.finish();
       }
       const actionName = parsed.action;
       const payload = parsed.payload ?? {};
       const seq = parsed.seq;
-      try {
-        await this.dispatchAction(actionName, payload, senderId, seq);
-      } catch (err) {
-        this.sendTo(ws, {
+      if (!this.hasAction(actionName)) {
+        this.sendToSender({
           type: "__action_error",
-          error: `Action failed: ${err instanceof Error ? err.message : "unknown"}`,
+          error: `Unknown action: ${actionName}`,
           seq
         });
+        return this.finish();
       }
-      return;
+      const outcome = await this.runAction(
+        actionName,
+        payload,
+        senderId,
+        {
+          ack: seq
+        }
+      );
+      if (!outcome.ok) {
+        this.sendToSender({
+          type: "__action_error",
+          error: `Action failed: ${outcome.error}`,
+          seq
+        });
+      }
+      return this.finish();
     }
     if (msgType === "__request_state") {
       if (this.gameState !== null) {
-        this.sendTo(ws, this.stateMessage());
+        this.sendToSender(this.stateMessage());
       }
-      return;
+      return this.finish();
     }
     if (msgType === "__input") {
       const inputData = parsed.data;
-      if (inputData) this.playerInputs[senderId] = inputData;
-      return;
+      if (inputData) {
+        this.playerInputs[senderId] = inputData;
+      }
+      return this.finish();
     }
+    return this.finish();
   }
-  async dispatchAction(actionName, payload, senderId, ackSeq) {
-    const plain = this.logic.actions[actionName];
-    const legacyServerOnly = isServerOnlyAction(plain) ? plain : null;
-    const serverHandler = this.logic.serverActions?.[actionName] ?? legacyServerOnly;
-    if (!plain && !serverHandler) {
-      throw new Error(`Unknown action: ${actionName}`);
-    }
-    if (!this.gameState) {
-      throw new Error("Game not started");
-    }
+  /** tick 1 周分。transport の tick ループから呼ばれる。 */
+  tick() {
+    this.begin();
+    const random = this.random;
+    if (!this.gameState || !random) return this.finish();
+    if (this.frozen) return this.finish();
     const events = [];
     const emit = (name, data) => events.push({ name, data: data ?? {} });
-    const serverEmit = emit;
-    const snapshot = structuredClone(this.gameState);
     const time = this.gameTime();
+    const state = this.gameState;
     try {
-      if (plain && !legacyServerOnly) {
-        const state = this.gameState;
-        withGameClock(
-          time,
-          () => plain({
-            state,
-            payload: payload ?? {},
-            playerId: senderId,
-            ctx: { ...this.timeCtx(time), emit }
-          })
-        );
-      }
-      if (serverHandler) {
-        await serverHandler({
-          state: this.gameState,
-          payload: payload ?? {},
-          playerId: senderId,
+      withGameClock(
+        time,
+        () => this.logic.update({
+          state,
           ctx: {
+            random,
             tick: this.tickCount,
-            random: this.random ?? new SeededRandomImpl(this.seed),
             ...this.timeCtx(time),
-            emit: serverEmit
+            emit,
+            playerInputs: this.playerInputs
           }
-        });
-      }
-    } catch (err) {
-      this.gameState = snapshot;
-      throw err;
-    }
-    this.syncWakeup();
-    this.broadcastStateDelta(events, { ack: ackSeq, from: senderId });
-  }
-  // ─── Deadlines (本番の Durable Object alarm 相当) ──────────
-  /** dev は setTimeout。本番は storage の alarm。意味論は同じ。 */
-  wakeupTimer = null;
-  wakeupAt = null;
-  /**
-   * 宣言された締切のうち最も早いゲーム内時刻。締切が無ければ null。
-   * state から毎回導出するので保存しない。
-   */
-  earliestDeadline() {
-    if (!this.gameState || !this.logic.deadlines) return null;
-    let earliest = null;
-    for (const [key, deadline] of Object.entries(this.logic.deadlines)) {
-      let raw;
-      try {
-        raw = deadline.at({ state: this.gameState });
-      } catch (err) {
-        console.error(`[Deadline] \u274C ${key}.at() \u3067\u4F8B\u5916`, err);
-        continue;
-      }
-      const at = resolveDeadline(
-        raw,
-        key,
-        this.warnedDeadlines,
-        (m) => console.error(`[Deadline] \u274C ${m}`)
+        })
       );
-      if (at === null) continue;
-      if (earliest === null || at < earliest) earliest = at;
+    } catch (err) {
+      console.error(`${this.label} tick error at tick=${this.tickCount}:`, err);
+      this.tickCount++;
+      return this.finish();
     }
-    return earliest;
+    this.tickCount++;
+    this.broadcastStateDelta(events, { tick: this.tickCount });
+    this.debouncedPersist();
+    return this.finish();
   }
   /**
-   * 次に起きるべき実時刻。締切と無人猶予の早い方。
+   * 過ぎた締切の handler を実行する。heartbeat 起床でも呼ばれるが、期限が来ていなければ
+   * 何もしない。
    *
-   * 停止中はシナリオの締切を予約しない (facet と同じ)。
-   */
-  nextWakeupWall() {
-    const candidates = [];
-    if (!this.frozen) {
-      const earliest = this.earliestDeadline();
-      if (earliest !== null) candidates.push(this.clock.toWall(earliest));
-    }
-    if (this.lastEmptyAtWall !== null && !this.clock.isFrozenBy("no-players")) {
-      candidates.push(this.lastEmptyAtWall + NO_PLAYERS_GRACE_MS);
-    }
-    return candidates.length === 0 ? null : Math.min(...candidates);
-  }
-  /** 起床時刻を現在の state に合わせる。state を変えた後は必ず通す。 */
-  syncWakeup() {
-    const next = this.nextWakeupWall();
-    if (next === this.wakeupAt) return;
-    if (this.wakeupTimer) clearTimeout(this.wakeupTimer);
-    this.wakeupTimer = null;
-    this.wakeupAt = next;
-    if (next === null) return;
-    this.wakeupTimer = setTimeout(() => this.fireDue(), Math.max(0, next - Date.now()));
-    this.wakeupTimer.unref?.();
-  }
-  /** 猶予が満了していれば無人凍結に入る。 */
-  freezeIfEmptyGraceExpired() {
-    if (this.lastEmptyAtWall === null) return;
-    if (this.clock.isFrozenBy("no-players")) return;
-    if (Date.now() < this.lastEmptyAtWall + NO_PLAYERS_GRACE_MS) return;
-    console.log(`[GameRoom] \u{1F9CA} \u7121\u4EBA\u7336\u4E88 ${NO_PLAYERS_GRACE_MS}ms \u6E80\u4E86 \u2192 \u6642\u8A08\u3092\u505C\u6B62`);
-    this.freeze("no-players");
-  }
-  /**
-   * 過ぎた締切の handler を実行する。本番の alarm() と同じ意味論。
+   * 各 handler の直前に `at` を評価し直す。先に走った handler が別の締切を消したり
+   * 先送りしたりしうるので、まとめて取ってから回すと消えたはずの締切まで撃ってしまう。
+   * これにより at-least-once の重複発火も自然に弾かれる。
    *
-   * handler の直前に at を評価し直す (先に走った handler が別の締切を消しうる)。
-   * 失敗は握って捨てる。ログには必ず残す。
+   * IMPORTANT: ゲームロジックの失敗は一時的障害より決定的バグの方が多く、素通しすると
+   * alarm リトライでクラッシュを繰り返すだけなので、ここで握る (ログには必ず残す)。
    */
-  fireDue() {
-    this.wakeupTimer = null;
-    this.wakeupAt = null;
+  alarm() {
+    this.begin();
     this.freezeIfEmptyGraceExpired();
-    if (!this.gameState || !this.logic.deadlines || this.frozen) {
-      this.syncWakeup();
-      return;
-    }
+    if (!this.gameState || !this.logic.deadlines || this.frozen) return this.finish();
     const time = this.gameTime();
     const events = [];
     const firedKeys = [];
@@ -1384,10 +1465,241 @@ var GameRoom = class _GameRoom {
         console.error(`[Deadline] \u274C ${key} \u3067\u4F8B\u5916`, err);
       }
     }
-    this.syncWakeup();
-    if (firedKeys.length === 0) return;
-    console.log(`[Deadline] \u23F0 ${firedKeys.length} \u4EF6\u767A\u706B: ${firedKeys.join(", ")}`);
-    this.broadcastStateDelta(events, {});
+    if (firedKeys.length === 0) return this.finish();
+    console.log(`[Deadline] \u23F0 ${firedKeys.length} \u4EF6\u767A\u706B: ${firedKeys.join(", ")}`);
+    this.broadcastStateDelta(events, {});
+    this.debouncedPersist();
+    return this.finish();
+  }
+  /**
+   * 切断 1 件の後処理。nextDeadline を返して transport の起床同期に使わせる。
+   *
+   * `remainingConnections` は transport しか数えられない。接続 0 になった時点から
+   * 猶予を張り、満了を起床で見る。
+   */
+  disconnect(playerId, remainingConnections) {
+    this.begin();
+    delete this.playerInputs[playerId];
+    if (remainingConnections === 0 && this.gameState !== null && this.lastEmptyAtWall === null) {
+      this.lastEmptyAtWall = Date.now();
+      this.persistClock();
+    }
+    return this.finish();
+  }
+  // ─── dev harness 用 (サブクラスからのみ触る) ─────────────
+  /**
+   * action を 1 件実行し、失敗したら throw する。dev harness の `sendAction` 専用。
+   *
+   * WS 経由 (`message`) は `__action_error` を返す形なので throw しない。ここだけが
+   * 例外で伝える形なのは、呼び出し元が harness の JS で、返り値を握り潰されると
+   * 失敗が画面にもコンソールにも出ないため。
+   */
+  async dispatchAction(actionName, payload, senderId) {
+    this.begin();
+    const outcome = await this.runAction(
+      actionName,
+      payload ?? {},
+      senderId,
+      {}
+    );
+    if (!outcome.ok) {
+      throw outcome.cause instanceof Error ? outcome.cause : new Error(outcome.error ?? "unknown");
+    }
+    return this.finish();
+  }
+  /**
+   * state を差し替えて配り直す。dev harness の state 流し込み専用。
+   *
+   * 同じオブジェクトを in-place で書き換えたあとに渡してもよい (merge / patch 用)。
+   */
+  publishState(next) {
+    this.begin();
+    this.gameState = next;
+    this.broadcastStateDelta([], { tick: this.tickCount });
+    this.debouncedPersist();
+    return this.finish();
+  }
+};
+
+// src/dev-server/admin-state-patch.ts
+var MERGE_PATCH_ARRAY_REJECT = "[applyJsonMergePatch] cannot merge a non-array patch into an array target";
+function applyJsonMergePatch(target, patch) {
+  if (patch === null || typeof patch !== "object" || Array.isArray(patch)) return;
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) continue;
+    if (value === null) {
+      target[key] = null;
+      continue;
+    }
+    if (Array.isArray(value)) {
+      target[key] = value;
+      continue;
+    }
+    if (typeof value === "object") {
+      const existing = target[key];
+      if (Array.isArray(existing)) {
+        throw new Error(MERGE_PATCH_ARRAY_REJECT);
+      }
+      if (existing === null || typeof existing !== "object") {
+        target[key] = value;
+        continue;
+      }
+      applyJsonMergePatch(existing, value);
+      continue;
+    }
+    target[key] = value;
+  }
+}
+function applyJsonPatch(target, ops) {
+  const ok = applyPatch(target, ops);
+  if (!ok) {
+    throw new Error("[applyJsonPatch] failed to apply one or more operations");
+  }
+}
+
+// src/dev-server/game-room.ts
+var GameRoom = class extends GameRoomCore {
+  sockets = /* @__PURE__ */ new Set();
+  attachments = /* @__PURE__ */ new WeakMap();
+  tickTimer = null;
+  tickPaused = false;
+  /** dev は setTimeout。本番は storage の alarm。意味論は同じ。 */
+  wakeupTimer = null;
+  wakeupAt = null;
+  snapshotSubscribers = /* @__PURE__ */ new Set();
+  eventSubscribers = /* @__PURE__ */ new Set();
+  /**
+   * `players` を渡すと server 権威の roster になり、接続クエリの申告では上書きされない。
+   * dev harness は manifest から組んだものを注入するので、旧世代 harness page の残タブが
+   * reconnect しても roster を汚染できない (申告がズレていれば core が warn を出す)。
+   */
+  constructor(logic, players) {
+    super(logic, { label: "[GameRoom]", storage: null, players });
+  }
+  // ─── Outcome の適用 ─────────────────────────────────────
+  /**
+   * core が返した「送るべきメッセージ」と tick / 起床の指示を transport へ反映する。
+   *
+   * core を呼んだら必ずここを通す。通し忘れると締切が armed にならず、
+   * 「dev では発火しないのに本番では発火する」が生まれる。
+   */
+  applyOutcome(outcome, sender) {
+    if (sender) for (const data of outcome.toSender) this.sendRaw(sender, data);
+    for (const data of outcome.broadcast) {
+      for (const ws of this.sockets) this.sendRaw(ws, data);
+    }
+    if (outcome.frozen) this.stopTickLoop();
+    else this.ensureTickLoop(outcome);
+    this.syncWakeup(outcome.nextDeadline);
+  }
+  sendRaw(ws, data) {
+    try {
+      ws.send(data);
+    } catch {
+    }
+  }
+  sendJson(ws, msg) {
+    this.sendRaw(ws, JSON.stringify(msg));
+  }
+  /**
+   * state を配ったあとに dev harness の購読者へ知らせる。
+   * 本番 (facet) は override しないので、この経路ごと存在しない。
+   */
+  afterStateChanged(events) {
+    this.snapshotSubscribers.forEach((cb) => {
+      try {
+        cb(this.gameState);
+      } catch (err) {
+        console.warn("[GameRoom] snapshot subscriber threw:", err);
+      }
+    });
+    if (events.length === 0) return;
+    const frozen = Object.freeze(events.slice());
+    this.eventSubscribers.forEach((cb) => {
+      try {
+        cb(frozen);
+      } catch (err) {
+        console.warn("[GameRoom] event subscriber threw:", err);
+      }
+    });
+  }
+  // ─── Tick ループ ────────────────────────────────────────
+  /**
+   * 全クライアント切断で tickTimer は止まる (handleClose) が state は残るため、
+   * 再接続や reset で「動いているべきなのに止まっている」状態を復旧する。
+   */
+  ensureTickLoop(outcome) {
+    if (!outcome.started || outcome.tickRate <= 0) return;
+    if (this.sockets.size === 0 || this.tickPaused || this.tickTimer) return;
+    this.tickTimer = setInterval(() => this.onTickTimer(), 1e3 / outcome.tickRate);
+  }
+  stopTickLoop() {
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+  }
+  /** interval は pause 中も回し続け、ここで捨てる (再開のたびに張り直さない)。 */
+  onTickTimer() {
+    if (this.tickPaused) return;
+    this.applyOutcome(this.tick());
+  }
+  // ─── 起床 (本番の Durable Object alarm 相当) ──────────────
+  /**
+   * 起床時刻を core の宣言に合わせる。
+   *
+   * 本番 (GameHost.syncAlarm) は「現在の alarm より早い時だけ set し、後ろ倒しはしない」
+   * という制約を持つが、それは workerd#6800 の evict 経路を踏まないための都合。
+   * dev は素直に張り替える。
+   */
+  syncWakeup(next) {
+    if (next === this.wakeupAt) return;
+    if (this.wakeupTimer) clearTimeout(this.wakeupTimer);
+    this.wakeupTimer = null;
+    this.wakeupAt = next;
+    if (next === null) return;
+    this.wakeupTimer = setTimeout(() => this.fireDue(), Math.max(0, next - Date.now()));
+    this.wakeupTimer.unref?.();
+  }
+  fireDue() {
+    this.wakeupTimer = null;
+    this.wakeupAt = null;
+    this.applyOutcome(this.alarm());
+  }
+  // ─── Connection ────────────────────────────────────────
+  handleConnection(ws, url) {
+    const playerId = url.searchParams.get("seatId");
+    if (!playerId) {
+      ws.close(1008, "Missing required query parameter: seatId");
+      return;
+    }
+    const nickname = url.searchParams.get("nickname") ?? "Guest";
+    const connectionId = randomUUID();
+    console.log(
+      `[GameRoom] \u{1F517} New connection: connectionId=${connectionId} playerId=${playerId} nickname=${nickname}`
+    );
+    const rosterParam = url.searchParams.get("players");
+    const outcome = this.connect(playerId, rosterParam);
+    this.sockets.add(ws);
+    this.attachments.set(ws, { connectionId, playerId, nickname });
+    ws.on("message", (raw) => this.handleMessage(ws, raw.toString()));
+    ws.on("close", () => this.handleClose(ws));
+    ws.on("error", () => this.handleClose(ws));
+    this.sendJson(ws, { type: "__room_init", myId: playerId });
+    this.applyOutcome(outcome, ws);
+  }
+  async handleMessage(ws, msg) {
+    if (msg === "__ping") {
+      this.sendRaw(ws, "__pong");
+      return;
+    }
+    const attachment = this.attachments.get(ws);
+    if (!attachment) return;
+    try {
+      this.applyOutcome(await this.message(attachment.playerId, msg), ws);
+    } catch (err) {
+      console.error(`[GameRoom] message relay error playerId=${attachment.playerId}:`, err);
+    }
   }
   handleClose(ws) {
     const attachment = this.attachments.get(ws);
@@ -1397,14 +1709,8 @@ var GameRoom = class _GameRoom {
     );
     this.sockets.delete(ws);
     this.attachments.delete(ws);
-    delete this.playerInputs[attachment.playerId];
-    if (this.sockets.size === 0) {
-      this.stopTickLoop();
-      if (this.gameState !== null && this.lastEmptyAtWall === null) {
-        this.lastEmptyAtWall = Date.now();
-        this.syncWakeup();
-      }
-    }
+    if (this.sockets.size === 0) this.stopTickLoop();
+    this.applyOutcome(this.disconnect(attachment.playerId, this.sockets.size));
   }
   // ─── Admin API (parent frame __uzu_dev から使う) ──────────────────
   admin() {
@@ -1412,21 +1718,22 @@ var GameRoom = class _GameRoom {
       getSnapshot: () => this.gameState,
       getRawState: () => this.gameState,
       setRawState: (next) => {
-        this.gameState = next;
-        this.broadcastStateDelta([], { tick: this.tickCount });
+        this.applyOutcome(this.publishState(next));
       },
       mergeRawState: (patch) => {
-        if (!this.gameState) return;
-        applyJsonMergePatch(this.gameState, patch);
-        this.broadcastStateDelta([], { tick: this.tickCount });
+        const state = this.gameState;
+        if (!state) return;
+        applyJsonMergePatch(state, patch);
+        this.applyOutcome(this.publishState(state));
       },
       patchRawState: (ops) => {
-        if (!this.gameState) return;
-        applyJsonPatch(this.gameState, ops);
-        this.broadcastStateDelta([], { tick: this.tickCount });
+        const state = this.gameState;
+        if (!state) return;
+        applyJsonPatch(state, ops);
+        this.applyOutcome(this.publishState(state));
       },
       sendAction: async ({ as, type, payload }) => {
-        await this.dispatchAction(type, payload, as);
+        this.applyOutcome(await this.dispatchAction(type, payload, as));
       },
       getSeed: () => this.seed,
       pauseTick: () => {
@@ -1442,38 +1749,13 @@ var GameRoom = class _GameRoom {
         if (!Number.isInteger(n) || n < 0) {
           throw new RangeError(`stepTick: n must be a non-negative integer (got ${n})`);
         }
-        for (let i = 0; i < n; i++) this.runOneTick();
+        for (let i = 0; i < n; i++) this.applyOutcome(this.tick());
       },
       getCurrentTick: () => this.tickCount,
       isTickPaused: () => this.tickPaused,
       reset: (opts) => {
-        if (opts?.seed === "random") {
-          this.seed = Math.floor(Math.random() * 4294967295);
-        } else if (typeof opts?.seed === "number") {
-          this.seed = opts.seed;
-        }
-        this.random = new SeededRandomImpl(this.seed);
-        this.clock.restart();
-        this.pausedBy = null;
-        this.lastEmptyAtWall = null;
-        const setupTime = this.gameTime();
-        const args = this.setupArgs(this.random);
-        this.gameState = withGameClock(setupTime, () => this.logic.setup(args));
-        this.stateInitialized = true;
-        this.tickCount = 0;
         this.tickPaused = false;
-        this.seq = 0;
-        this.prevBroadcastState = structuredClone(this.gameState);
-        this.broadcastAll({
-          type: "__game_start",
-          state: this.gameState,
-          seed: this.seed,
-          seq: 0,
-          gameTime: this.gameTime()
-        });
-        this.syncWakeup();
-        this.notifySnapshotSubscribers();
-        this.ensureTickLoop();
+        this.applyOutcome(this.resetGame(opts));
       },
       subscribeSnapshot: (cb) => {
         this.snapshotSubscribers.add(cb);
@@ -1491,314 +1773,6 @@ var GameRoom = class _GameRoom {
   }
 };
 
-// src/dev-server/sync-room.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var SERVER_TIME_SENTINEL = "__SERVER_TIME__";
-function resolveServerTime(ops, now) {
-  for (const op of ops) {
-    if (op.value === SERVER_TIME_SENTINEL) {
-      op.value = now;
-    }
-  }
-}
-var SyncRoom = class _SyncRoom {
-  cachedState = null;
-  stateInitialized = false;
-  seq = 0;
-  patchesSinceReconciliation = 0;
-  static RECONCILIATION_INTERVAL = 30;
-  sockets = /* @__PURE__ */ new Set();
-  attachments = /* @__PURE__ */ new WeakMap();
-  snapshotSubscribers = /* @__PURE__ */ new Set();
-  broadcastFullState() {
-    if (!this.stateInitialized || this.cachedState === null) return;
-    const stateMsg = JSON.stringify({
-      type: "__state",
-      state: this.cachedState,
-      seq: this.seq,
-      serverTime: Date.now()
-    });
-    for (const peer of this.sockets) {
-      try {
-        peer.send(stateMsg);
-      } catch {
-      }
-    }
-    this.notifySnapshotSubscribers();
-  }
-  notifySnapshotSubscribers() {
-    this.snapshotSubscribers.forEach((cb) => {
-      try {
-        cb(this.cachedState);
-      } catch (err) {
-        console.warn("[SyncRoom] snapshot subscriber threw:", err);
-      }
-    });
-  }
-  handleConnection(ws, url) {
-    const playerId = url.searchParams.get("playerId");
-    if (!playerId) {
-      ws.close(1008, "Missing required query parameter: playerId");
-      return;
-    }
-    const connectionId = randomUUID2();
-    console.log(`[SyncRoom] \u{1F517} New connection: connectionId=${connectionId} playerId=${playerId}`);
-    this.sockets.add(ws);
-    this.attachments.set(ws, { connectionId, playerId });
-    ws.on("message", (raw) => this.handleMessage(ws, raw.toString()));
-    ws.on("close", () => this.handleClose(ws));
-    ws.on("error", () => this.handleClose(ws));
-    ws.send(JSON.stringify({ type: "__room_init", myId: playerId }));
-    if (this.stateInitialized && this.cachedState !== null) {
-      ws.send(
-        JSON.stringify({
-          type: "__state",
-          state: this.cachedState,
-          seq: this.seq,
-          serverTime: Date.now()
-        })
-      );
-    }
-  }
-  handleMessage(ws, msg) {
-    if (msg === "__ping") {
-      try {
-        ws.send("__pong");
-      } catch {
-      }
-      return;
-    }
-    const attachment = this.attachments.get(ws);
-    if (!attachment) return;
-    const senderId = attachment.playerId;
-    let parsed;
-    try {
-      parsed = JSON.parse(msg);
-    } catch {
-      return;
-    }
-    const msgType = parsed.type;
-    console.log(`[SyncRoom] \u2B05 recv from=${senderId} type=${msgType}`);
-    if (msgType === "__init_state") {
-      if (this.stateInitialized) {
-        console.log(`[SyncRoom] __init_state skipped (already initialized)`);
-        return;
-      }
-      this.stateInitialized = true;
-      this.cachedState = parsed.state;
-      this.seq = 0;
-      this.patchesSinceReconciliation = 0;
-      console.log(`[SyncRoom] \u2705 State initialized`);
-      this.broadcastFullState();
-      return;
-    }
-    if (msgType === "__clear_state") {
-      this.cachedState = null;
-      this.stateInitialized = false;
-      this.seq = 0;
-      this.patchesSinceReconciliation = 0;
-      console.log(`[SyncRoom] \u{1F5D1} State cleared`);
-      const clearedMsg = JSON.stringify({ type: "__state_cleared" });
-      for (const peer of this.sockets) {
-        try {
-          peer.send(clearedMsg);
-        } catch {
-        }
-      }
-      this.notifySnapshotSubscribers();
-      return;
-    }
-    if (msgType === "__request_state") {
-      if (!this.stateInitialized || this.cachedState === null) return;
-      try {
-        ws.send(
-          JSON.stringify({
-            type: "__state",
-            state: this.cachedState,
-            seq: this.seq,
-            serverTime: Date.now()
-          })
-        );
-      } catch {
-      }
-      return;
-    }
-    if (msgType === "__patch") {
-      if (!this.stateInitialized || this.cachedState === null) return;
-      const ops = parsed.ops;
-      if (!ops || !Array.isArray(ops) || ops.length === 0) return;
-      const serverTime = Date.now();
-      resolveServerTime(ops, serverTime);
-      const workingCopy = structuredClone(this.cachedState);
-      const ok = applyPatch(workingCopy, ops);
-      if (!ok) {
-        try {
-          ws.send(JSON.stringify({ type: "__patch_failed", reason: "apply_error" }));
-          ws.send(
-            JSON.stringify({
-              type: "__state",
-              state: this.cachedState,
-              seq: this.seq,
-              serverTime: Date.now()
-            })
-          );
-        } catch {
-        }
-        return;
-      }
-      this.cachedState = workingCopy;
-      this.seq++;
-      const ackMsg = JSON.stringify({
-        type: "__patch_ack",
-        ops,
-        seq: this.seq,
-        serverTime,
-        senderId
-      });
-      for (const peer of this.sockets) {
-        try {
-          peer.send(ackMsg);
-        } catch {
-        }
-      }
-      this.notifySnapshotSubscribers();
-      this.patchesSinceReconciliation++;
-      if (this.patchesSinceReconciliation >= _SyncRoom.RECONCILIATION_INTERVAL) {
-        this.patchesSinceReconciliation = 0;
-        this.broadcastFullState();
-      }
-      return;
-    }
-    const outData = JSON.stringify({ ...parsed, __from: senderId });
-    if (parsed.__to && typeof parsed.__to === "string") {
-      for (const peer of this.sockets) {
-        const pa = this.attachments.get(peer);
-        if (pa && pa.playerId === parsed.__to) {
-          try {
-            peer.send(outData);
-          } catch {
-          }
-        }
-      }
-    } else {
-      for (const peer of this.sockets) {
-        if (peer === ws) continue;
-        try {
-          peer.send(outData);
-        } catch {
-        }
-      }
-    }
-  }
-  handleClose(ws) {
-    const attachment = this.attachments.get(ws);
-    if (attachment) {
-      console.log(
-        `[SyncRoom] \u274C Disconnected: connectionId=${attachment.connectionId} playerId=${attachment.playerId}`
-      );
-    }
-    this.sockets.delete(ws);
-    this.attachments.delete(ws);
-  }
-  // ─── Admin API (parent frame __uzu_dev から使う) ──────────────────
-  admin() {
-    return {
-      getSnapshot: () => this.cachedState,
-      getRawState: () => this.cachedState,
-      setRawState: (next) => {
-        this.cachedState = next;
-        this.stateInitialized = true;
-        this.broadcastFullState();
-      },
-      mergeRawState: (patch) => {
-        if (!this.cachedState) return;
-        applyJsonMergePatch(this.cachedState, patch);
-        this.broadcastFullState();
-      },
-      patchRawState: (ops) => {
-        if (!this.cachedState) return;
-        applyJsonPatch(this.cachedState, ops);
-        this.broadcastFullState();
-      },
-      subscribeSnapshot: (cb) => {
-        this.snapshotSubscribers.add(cb);
-        return () => {
-          this.snapshotSubscribers.delete(cb);
-        };
-      }
-    };
-  }
-};
-
-// src/dev-server/relay-room.ts
-import { randomUUID as randomUUID3 } from "crypto";
-var RelayRoom = class {
-  sockets = /* @__PURE__ */ new Set();
-  attachments = /* @__PURE__ */ new WeakMap();
-  handleConnection(ws, url) {
-    const playerId = url.searchParams.get("playerId");
-    if (!playerId) {
-      ws.close(1008, "Missing required query parameter: playerId");
-      return;
-    }
-    const connectionId = randomUUID3();
-    console.log(`[RelayRoom] \u{1F517} New connection: connectionId=${connectionId} playerId=${playerId}`);
-    this.sockets.add(ws);
-    this.attachments.set(ws, { connectionId, playerId });
-    ws.on("message", (raw) => this.handleMessage(ws, raw.toString()));
-    ws.on("close", () => this.handleClose(ws));
-    ws.on("error", () => this.handleClose(ws));
-    ws.send(JSON.stringify({ type: "__room_init", myId: playerId }));
-  }
-  handleMessage(ws, msg) {
-    if (msg === "__ping") {
-      try {
-        ws.send("__pong");
-      } catch {
-      }
-      return;
-    }
-    const attachment = this.attachments.get(ws);
-    if (!attachment) return;
-    const senderId = attachment.playerId;
-    let parsed;
-    try {
-      parsed = JSON.parse(msg);
-    } catch {
-      return;
-    }
-    console.log(`[RelayRoom] \u2B05 recv from=${senderId}`, JSON.stringify(parsed));
-    const outData = JSON.stringify({ ...parsed, __from: senderId });
-    if (parsed.__to && typeof parsed.__to === "string") {
-      for (const peer of this.sockets) {
-        const pa = this.attachments.get(peer);
-        if (pa && pa.playerId === parsed.__to) {
-          try {
-            peer.send(outData);
-          } catch {
-          }
-        }
-      }
-    } else {
-      for (const peer of this.sockets) {
-        if (peer === ws) continue;
-        try {
-          peer.send(outData);
-        } catch {
-        }
-      }
-    }
-  }
-  handleClose(ws) {
-    const attachment = this.attachments.get(ws);
-    if (attachment) {
-      console.log(`[RelayRoom] \u274C Disconnected: connectionId=${attachment.connectionId}`);
-    }
-    this.sockets.delete(ws);
-    this.attachments.delete(ws);
-  }
-};
-
 // src/dev-server/server.ts
 var CONTENT_TYPES = {
   html: "text/html; charset=utf-8",
@@ -1807,15 +1781,10 @@ var CONTENT_TYPES = {
 };
 function startHarnessServer(opts) {
   const gameRooms = /* @__PURE__ */ new Map();
-  const syncRooms = /* @__PURE__ */ new Map();
-  const relayRooms = /* @__PURE__ */ new Map();
   const resolveAdmin = () => {
     const preferredKey = `${opts.meta.revisionId}/${opts.meta.roomKey}`;
-    const gameRoom = gameRooms.get(preferredKey) ?? gameRooms.values().next().value;
-    if (gameRoom) return { kind: "game", game: gameRoom.admin() };
-    const syncRoom = syncRooms.values().next().value;
-    if (syncRoom) return { kind: "sync", sync: syncRoom.admin() };
-    return null;
+    const room = gameRooms.get(preferredKey) ?? gameRooms.values().next().value;
+    return room ? room.admin() : null;
   };
   const httpServer = createServer((req, res) => {
     handleHttpRequest(req, res, opts);
@@ -1843,32 +1812,6 @@ function startHarnessServer(opts) {
       });
       return;
     }
-    const syncMatch = pathname.match(/^\/ws\/sync\/([^/]+)$/);
-    if (syncMatch) {
-      const roomId = syncMatch[1];
-      wss.handleUpgrade(req, socket, head, (ws) => {
-        let room = syncRooms.get(roomId);
-        if (!room) {
-          room = new SyncRoom();
-          syncRooms.set(roomId, room);
-        }
-        room.handleConnection(ws, url);
-      });
-      return;
-    }
-    const relayMatch = pathname.match(/^\/ws\/rooms\/([^/]+)$/);
-    if (relayMatch) {
-      const roomId = relayMatch[1];
-      wss.handleUpgrade(req, socket, head, (ws) => {
-        let room = relayRooms.get(roomId);
-        if (!room) {
-          room = new RelayRoom();
-          relayRooms.set(roomId, room);
-        }
-        room.handleConnection(ws, url);
-      });
-      return;
-    }
     if (pathname === "/dev/admin") {
       wss.handleUpgrade(req, socket, head, (ws) => {
         handleAdminConnection(ws, resolveAdmin);
@@ -1879,7 +1822,7 @@ function startHarnessServer(opts) {
   });
   httpServer.listen(opts.port, opts.host ?? "127.0.0.1");
   return {
-    stop: () => new Promise((resolve7) => {
+    stop: () => new Promise((resolve8) => {
       for (const ws of wss.clients) {
         try {
           ws.close();
@@ -1887,7 +1830,7 @@ function startHarnessServer(opts) {
         }
       }
       wss.close(() => {
-        httpServer.close(() => resolve7());
+        httpServer.close(() => resolve8());
       });
     })
   };
@@ -2004,30 +1947,19 @@ function handleAdminConnection(ws, resolveAdmin) {
   });
 }
 function adminHasMethod(admin, method) {
-  if (admin.kind === "game" && admin.game) {
-    return typeof admin.game[method] === "function";
-  }
-  if (admin.kind === "sync" && admin.sync) {
-    return typeof admin.sync[method] === "function";
-  }
-  return false;
+  return typeof admin[method] === "function";
 }
 async function invokeAdminMethod(admin, method, args) {
-  const target = admin.kind === "game" ? admin.game : admin.sync;
-  if (!target) return void 0;
-  const fn = target[method];
+  const fn = admin[method];
   if (typeof fn !== "function") return void 0;
-  return await fn.apply(target, args);
+  return await fn.apply(admin, args);
 }
 function subscribeAdmin(admin, kind, cb) {
   if (kind === "snapshot") {
-    const target = admin.kind === "game" ? admin.game : admin.sync;
-    if (!target) return null;
-    return target.subscribeSnapshot(cb);
+    return admin.subscribeSnapshot(cb);
   }
   if (kind === "events") {
-    if (admin.kind !== "game" || !admin.game) return null;
-    return admin.game.subscribeEvents(cb);
+    return admin.subscribeEvents(cb);
   }
   return null;
 }
@@ -2105,10 +2037,10 @@ function proxyUpgradeToScenario(req, socket, head, scenarioUrl) {
 import { build as build2 } from "esbuild";
 import { mkdtempSync, rmSync } from "fs";
 import { tmpdir } from "os";
-import { join as join4, resolve as resolve3 } from "path";
-import { pathToFileURL } from "url";
+import { join as join4, resolve as resolve4 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
 async function loadLogicFromPath(logicPath) {
-  const absPath = resolve3(logicPath);
+  const absPath = resolve4(logicPath);
   const tempDir = mkdtempSync(join4(tmpdir(), "uzu-dev-logic-"));
   const outPath = join4(tempDir, "logic.mjs");
   await build2({
@@ -2120,7 +2052,7 @@ async function loadLogicFromPath(logicPath) {
     platform: "neutral",
     plugins: [uzuSdkServerStub]
   });
-  const mod = await import(pathToFileURL(outPath).href);
+  const mod = await import(pathToFileURL2(outPath).href);
   const logic = mod.default ?? mod.logic;
   if (!logic) {
     throw new Error(
@@ -2185,12 +2117,12 @@ var DEFAULT_READY_PATTERN = "Local:\\s+(https?://[^\\s]+)";
 var DEFAULT_MIN_IFRAME_SHORT_EDGE = 360;
 async function runDevCommand() {
   const cwd = process.cwd();
-  const manifestPath = resolve4(cwd, "manifest.json");
-  if (!existsSync2(manifestPath)) {
+  const manifestPath = resolve5(cwd, "manifest.json");
+  if (!existsSync3(manifestPath)) {
     console.error("manifest.json \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002 scenario \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3067\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
     process.exit(1);
   }
-  const manifest = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
   const playerCount = manifest.characters?.length ?? manifest.playerCount ?? 2;
   const orientation = manifest.orientation ?? "portrait";
   const devCommand = manifest.dev?.command ?? DEFAULT_DEV_COMMAND;
@@ -2198,14 +2130,14 @@ async function runDevCommand() {
   let loaded = null;
   if (manifest.serverActionLogicPath) {
     console.log(`[uzu dev] Building server logic from ${manifest.serverActionLogicPath}...`);
-    const logicPath = resolve4(cwd, manifest.serverActionLogicPath);
+    const logicPath = resolve5(cwd, manifest.serverActionLogicPath);
     loaded = await loadLogicFromPath(logicPath);
     console.log("[uzu dev] Server logic ready");
   }
   const thisDir = dirname3(fileURLToPath3(import.meta.url));
-  const clientEntryJs = resolve4(thisDir, "harness", "client-entry.js");
-  const clientEntryTs = resolve4(thisDir, "harness", "client-entry.ts");
-  const clientEntry = existsSync2(clientEntryJs) ? clientEntryJs : existsSync2(clientEntryTs) ? clientEntryTs : null;
+  const clientEntryJs = resolve5(thisDir, "harness", "client-entry.js");
+  const clientEntryTs = resolve5(thisDir, "harness", "client-entry.ts");
+  const clientEntry = existsSync3(clientEntryJs) ? clientEntryJs : existsSync3(clientEntryTs) ? clientEntryTs : null;
   if (!clientEntry) {
     console.error(`harness client entry \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${clientEntryJs}`);
     process.exit(1);
@@ -2301,7 +2233,7 @@ function stripAnsi(s) {
   return s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
 }
 function watchForReady(child, pattern) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const timeout = setTimeout(() => {
       reject(new Error("Timed out waiting for scenario dev server to become ready (30s)"));
     }, 3e4);
@@ -2317,7 +2249,7 @@ function watchForReady(child, pattern) {
       const url = /^https?:\/\//i.test(captured) ? captured : `http://localhost:${captured}`;
       resolved = true;
       clearTimeout(timeout);
-      resolve7(url.replace(/\/$/, ""));
+      resolve8(url.replace(/\/$/, ""));
     };
     if (child.stdout) {
       const rl = createInterface({ input: child.stdout });
@@ -2344,14 +2276,14 @@ var MAX_HARNESS_PORT_ATTEMPTS = 100;
 var HARNESS_HOST = "0.0.0.0";
 async function findFreePort() {
   const net = await import("net");
-  const tryPort = (port) => new Promise((resolve7) => {
+  const tryPort = (port) => new Promise((resolve8) => {
     const server = net.createServer();
     server.unref();
-    server.once("error", () => resolve7(null));
+    server.once("error", () => resolve8(null));
     server.listen(port, HARNESS_HOST, () => {
       const address = server.address();
       const assigned = typeof address === "object" && address !== null ? address.port : port;
-      server.close(() => resolve7(assigned));
+      server.close(() => resolve8(assigned));
     });
   });
   for (let i = 0; i < MAX_HARNESS_PORT_ATTEMPTS; i++) {
@@ -2365,8 +2297,8 @@ async function findFreePort() {
 }
 
 // src/sdk-version.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, resolve as resolve5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname4, resolve as resolve6 } from "path";
 var SDK_PACKAGE_PATHS = [
   ["@uzuhq", "code-sdk"],
   ["@uzupj", "uzu-sdk"]
@@ -2378,18 +2310,18 @@ var readInstalledSdkVersion = (cwd) => {
       "@uzuhq/code-sdk \u304C node_modules \u306B\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002\u4F9D\u5B58\u3092 install \u3057\u3066\u304B\u3089 publish \u3057\u3066\u304F\u3060\u3055\u3044\u3002"
     );
   }
-  const version = JSON.parse(readFileSync5(pkgPath, "utf-8")).version;
+  const version = JSON.parse(readFileSync6(pkgPath, "utf-8")).version;
   if (!version) {
     throw new Error(`${pkgPath} \u306B version \u304C\u3042\u308A\u307E\u305B\u3093\u3002`);
   }
   return version;
 };
 var findSdkPackageJson = (cwd) => {
-  let dir = resolve5(cwd);
+  let dir = resolve6(cwd);
   for (; ; ) {
     const found = SDK_PACKAGE_PATHS.map(
-      (segments) => resolve5(dir, "node_modules", ...segments, "package.json")
-    ).find(existsSync3);
+      (segments) => resolve6(dir, "node_modules", ...segments, "package.json")
+    ).find(existsSync4);
     if (found) {
       return found;
     }
@@ -2450,7 +2382,7 @@ var failureHtml = (msg) => {
 </body>`;
 };
 var startLoopbackServer = async () => {
-  let resolve7 = null;
+  let resolve8 = null;
   let reject = null;
   let delivered = false;
   let pending = null;
@@ -2487,7 +2419,7 @@ var startLoopbackServer = async () => {
     }
     res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
     res.end(SUCCESS_HTML);
-    if (resolve7) resolve7(code);
+    if (resolve8) resolve8(code);
     else pending = { code };
   });
   await new Promise((res, rej) => {
@@ -2509,7 +2441,7 @@ var startLoopbackServer = async () => {
         () => rej(new Error(`login timed out after ${timeoutMs}ms`)),
         timeoutMs
       );
-      resolve7 = (code) => {
+      resolve8 = (code) => {
         clearTimeout(t);
         res(code);
       };
@@ -2557,8 +2489,8 @@ var runLoginFlow = async (env, onURL) => {
 // src/cli.ts
 var envOption = () => new Option("--env <env>", "\u63A5\u7D9A\u5148\u74B0\u5883 (dev | stg | prd)").default(DEFAULT_ENV).hideHelp();
 var readOwnCliVersion = () => {
-  const pkgPath = resolve6(dirname5(fileURLToPath4(import.meta.url)), "..", "package.json");
-  const version = JSON.parse(readFileSync6(pkgPath, "utf-8")).version;
+  const pkgPath = resolve7(dirname5(fileURLToPath4(import.meta.url)), "..", "package.json");
+  const version = JSON.parse(readFileSync7(pkgPath, "utf-8")).version;
   if (!version) {
     throw new Error("uzu-cli \u306E package.json \u306B version \u304C\u3042\u308A\u307E\u305B\u3093\u3002");
   }
@@ -2571,7 +2503,7 @@ program.command("create-2d-game").description("2D \u30A8\u30F3\u30B8\u30F3\u3092
   create2dGame(name);
 });
 program.command("dev").description(
-  "scenario \u306E dev server \u3092\u8D77\u52D5\u3057\u3001 dev harness (iframe grid + HUD) \u3068 in-memory GameRoom / SyncRoom / RelayRoom \u3092\u63D0\u4F9B\u3059\u308B"
+  "scenario \u306E dev server \u3092\u8D77\u52D5\u3057\u3001 dev harness (iframe grid + HUD) \u3068 in-memory GameRoom \u3092\u63D0\u4F9B\u3059\u308B"
 ).action(async () => {
   try {
     await runDevCommand();
@@ -2583,12 +2515,12 @@ program.command("dev").description(
 program.command("publish").description("\u30B2\u30FC\u30E0\u3092\u30D3\u30EB\u30C9\u3057\u3066 R2 \u306B\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9 \u2192 \u767B\u9332").option("--change-notes <msg>", "\u30EA\u30D3\u30B8\u30E7\u30F3\u306E\u5909\u66F4\u30E1\u30E2", "").addOption(envOption()).action(async (options) => {
   const env = resolveEnv(options.env);
   const cwd = process.cwd();
-  const manifestPath = resolve6(cwd, "manifest.json");
-  if (!existsSync4(manifestPath)) {
+  const manifestPath = resolve7(cwd, "manifest.json");
+  if (!existsSync5(manifestPath)) {
     console.error("manifest.json \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002\u30B2\u30FC\u30E0\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3067\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
     process.exit(1);
   }
-  const manifest = JSON.parse(readFileSync6(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync7(manifestPath, "utf-8"));
   if (typeof manifest !== "object" || manifest === null) {
     console.error("manifest.json \u304C\u4E0D\u6B63\u306A\u5F62\u5F0F\u3067\u3059\u3002");
     process.exit(1);
@@ -2637,93 +2569,90 @@ program.command("publish").description("\u30B2\u30FC\u30E0\u3092\u30D3\u30EB\u30
     console.error(e instanceof Error ? e.message : String(e));
     process.exit(1);
   });
+  let logicJs;
+  if (manifest.serverActionLogicPath) {
+    console.log("Building server logic...");
+    try {
+      logicJs = await buildAndVerifyServerLogic(cwd, manifest.serverActionLogicPath);
+    } catch (e) {
+      console.error(e instanceof Error ? e.message : String(e));
+      process.exit(1);
+    }
+  }
+  const isLocalIcon = (char) => !!char.icon && !char.icon.startsWith("http://") && !char.icon.startsWith("https://");
+  const localIconPaths = (manifestCharacters ?? []).filter(isLocalIcon).map((char) => {
+    const iconAbsPath = resolve7(cwd, char.icon);
+    if (!existsSync5(iconAbsPath)) {
+      console.error(`\u30A2\u30A4\u30B3\u30F3\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${char.icon}`);
+      process.exit(1);
+    }
+    return iconAbsPath;
+  });
   if (buildCommand) {
     console.log("Building...");
     execSync(buildCommand, { stdio: "inherit", cwd });
   }
   console.log("Creating ZIP...");
-  const absoluteOutputDir = resolve6(cwd, outputDir);
-  const zipPath = resolve6(cwd, "__zip__.zip");
-  await new Promise((res, reject) => {
-    const output = createWriteStream(zipPath);
-    const archive = new ZipArchive({ zlib: { level: 9 } });
-    output.on("close", () => res());
-    archive.on("error", (err) => reject(err));
-    archive.pipe(output);
-    archive.directory(absoluteOutputDir, false);
-    archive.finalize();
-  });
-  console.log(`Created: ${zipPath}`);
-  console.log("Uploading to R2...");
-  const { resourceId, revisionId, token } = await uploadGameToR2(env, zipPath, absoluteOutputDir);
-  console.log(`Uploaded to R2. revisionId: ${revisionId}, resourceId: ${resourceId}`);
-  if (manifest.serverActionLogicPath) {
-    const logicEntryPoint = resolve6(cwd, manifest.serverActionLogicPath);
-    const logicOutPath = resolve6(cwd, "__logic__.js");
-    try {
-      console.log("Building server logic...");
-      await buildServerLogic(logicEntryPoint, logicOutPath);
-      const logicModule = await import(pathToFileURL2(logicOutPath).href);
-      const resolvedLogic = logicModule.default ?? logicModule.logic;
-      if (!resolvedLogic) {
-        console.error(
-          `Error: ${manifest.serverActionLogicPath} must export a GameLogic object.
-  Use either: export default logic
-  Or:         export const logic: GameLogic<State> = { ... }`
-        );
-        process.exit(1);
-      }
-      console.log("Uploading logic.js to R2...");
-      const logicJsContent = readFileSync6(logicOutPath, "utf-8");
-      await uploadLogicToR2(env, token, logicJsContent, { wireVersion: WIRE_VERSION });
-    } finally {
-      if (existsSync4(logicOutPath)) unlinkSync(logicOutPath);
-    }
-  }
-  let resolvedCharacters;
-  if (manifestCharacters) {
-    console.log("Resolving character icons...");
-    const isLocalIcon = (char) => !!char.icon && !char.icon.startsWith("http://") && !char.icon.startsWith("https://");
-    const localIconPaths = manifestCharacters.filter(isLocalIcon).map((char) => {
-      const iconAbsPath = resolve6(cwd, char.icon);
-      if (!existsSync4(iconAbsPath)) {
-        console.error(`\u30A2\u30A4\u30B3\u30F3\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${char.icon}`);
-        process.exit(1);
-      }
-      return iconAbsPath;
+  const absoluteOutputDir = resolve7(cwd, outputDir);
+  const zipPath = resolve7(cwd, "__zip__.zip");
+  try {
+    await new Promise((res, reject) => {
+      const output = createWriteStream(zipPath);
+      const archive = new ZipArchive({ zlib: { level: 9 } });
+      output.on("close", () => res());
+      archive.on("error", (err) => reject(err));
+      archive.pipe(output);
+      archive.directory(absoluteOutputDir, false);
+      archive.finalize();
     });
-    const iconURLs = await uploadIconsToCfImages(env, token, localIconPaths);
-    resolvedCharacters = manifestCharacters.map((char) => {
-      if (!isLocalIcon(char)) return char;
-      const cfImagesUrl = iconURLs.get(resolve6(cwd, char.icon));
-      if (!cfImagesUrl) {
-        console.error(`\u30A2\u30A4\u30B3\u30F3\u306E\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9\u7D50\u679C\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${char.icon}`);
-        process.exit(1);
+    console.log(`Created: ${zipPath}`);
+    console.log("Uploading to R2...");
+    const { resourceId, revisionId, token } = await uploadGameToR2(
+      env,
+      zipPath,
+      absoluteOutputDir
+    );
+    console.log(`Uploaded to R2. revisionId: ${revisionId}, resourceId: ${resourceId}`);
+    if (logicJs !== void 0) {
+      console.log("Uploading logic.js to R2...");
+      await uploadLogicToR2(env, token, logicJs, { wireVersion: WIRE_VERSION });
+    }
+    let resolvedCharacters;
+    if (manifestCharacters) {
+      console.log("Resolving character icons...");
+      const iconURLs = await uploadIconsToCfImages(env, token, localIconPaths);
+      resolvedCharacters = manifestCharacters.map((char) => {
+        if (!isLocalIcon(char)) return char;
+        const cfImagesUrl = iconURLs.get(resolve7(cwd, char.icon));
+        if (!cfImagesUrl) {
+          throw new Error(`\u30A2\u30A4\u30B3\u30F3\u306E\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9\u7D50\u679C\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${char.icon}`);
+        }
+        console.log(`Uploaded icon: ${char.icon}`);
+        return { ...char, icon: cfImagesUrl };
+      });
+    }
+    console.log("Registering revision...");
+    const revId = await registerRevision({
+      env,
+      gameId,
+      resourceId,
+      uploadToken: token,
+      changeNotes: options.changeNotes || "",
+      playerCount,
+      orientation,
+      characters: resolvedCharacters,
+      manifest,
+      publishMeta: {
+        sdkVersion,
+        cliVersion: OWN_CLI_VERSION,
+        bridgeVersion: BRIDGE_VERSION,
+        wireVersion: WIRE_VERSION
       }
-      console.log(`Uploaded icon: ${char.icon}`);
-      return { ...char, icon: cfImagesUrl };
     });
+    console.log(`Registered revision: ${revId}`);
+  } finally {
+    if (existsSync5(zipPath)) unlinkSync2(zipPath);
   }
-  console.log("Registering revision...");
-  const revId = await registerRevision({
-    env,
-    gameId,
-    resourceId,
-    uploadToken: token,
-    changeNotes: options.changeNotes || "",
-    playerCount,
-    orientation,
-    characters: resolvedCharacters,
-    manifest,
-    publishMeta: {
-      sdkVersion,
-      cliVersion: OWN_CLI_VERSION,
-      bridgeVersion: BRIDGE_VERSION,
-      wireVersion: WIRE_VERSION
-    }
-  });
-  console.log(`Registered revision: ${revId}`);
-  unlinkSync(zipPath);
   const studioUrl = `https://${studioHost(env)}/ja/scenarios/global-id/${gameId}`;
   console.log("\nDone!");
   console.log(`UZU Studio: ${studioUrl}`);