@uzuhq/code-cli 0.5.10 → 0.6.1

package/dist/cli.js

@@ -548,6 +548,111 @@ import { WebSocketServer } from "ws";
 // src/dev-server/game-room.ts
 import { randomUUID } from "crypto";
 
+// ../engine-core/src/game-time.ts
+var toMs = (t) => t;
+var plus = (t, d) => toMs(t) + d;
+var asGameTime = (ms) => ms;
+
+// ../engine-core/src/game-clock.ts
+var NO_PLAYERS_GRACE_MS = 5 * 6e4;
+var GameClock = class {
+  startedAtWall = 0;
+  pausedTotalMs = 0;
+  pausedAtWall = null;
+  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 toMs(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();
+  }
+};
+function withGameClock(time, fn) {
+  const realNow = Date.now;
+  const RealDate = Date;
+  const ms = toMs(time);
+  Date.now = () => ms;
+  globalThis.Date = new Proxy(RealDate, {
+    construct: (target, args) => Reflect.construct(target, args.length === 0 ? [ms] : args)
+  });
+  try {
+    return fn();
+  } finally {
+    globalThis.Date = RealDate;
+    Date.now = realNow;
+  }
+}
+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}" \u306E at() \u304C\u7DE0\u5207\u306B\u4F7F\u3048\u306A\u3044\u5024\u3092\u8FD4\u3057\u305F: ${String(at)}\u3002\u3053\u306E\u7DE0\u5207\u306F\u4E8C\u5EA6\u3068\u767A\u706B\u3057\u306A\u3044\u3002\u5EC3\u6B62\u3055\u308C\u305F ctx.now \u3092\u8AAD\u3093\u3067\u3044\u306A\u3044\u304B\u78BA\u8A8D\u3059\u308B\u3053\u3068`
+    );
+  }
+  return null;
+}
+
 // ../engine-core/src/json-patch.ts
 function escapePointer(key) {
   return key.replace(/~/g, "~0").replace(/\//g, "~1");
@@ -673,8 +778,8 @@ function parseRoster(rosterParam) {
 }
 
 // ../engine-core/src/versions.ts
-var BRIDGE_VERSION = 1;
-var WIRE_VERSION = 1;
+var BRIDGE_VERSION = 2;
+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";
@@ -736,6 +841,13 @@ var GameRoom = class _GameRoom {
   seq = 0;
   prevBroadcastState = null;
   static SNAPSHOT_INTERVAL = 20;
+  // ─── ゲーム内時計 ──────────────────────────────────────
+  // 算術と凍結の出入りは engine-core の GameClock (facet と共有)。
+  clock = new GameClock();
+  pausedBy = null;
+  lastEmptyAtWall = null;
+  /** at() が壊れた値を返したと既に記録した締切。ログを 1 回に絞るため。 */
+  warnedDeadlines = /* @__PURE__ */ new Set();
   sockets = /* @__PURE__ */ new Set();
   attachments = /* @__PURE__ */ new WeakMap();
   snapshotSubscribers = /* @__PURE__ */ new Set();
@@ -750,6 +862,42 @@ var GameRoom = class _GameRoom {
       );
     }
   }
+  // ─── ゲーム内時計 ───────────────────────────────────────
+  /** ゲーム開始からの ms。停止中は進まない。Unix epoch ではない。 */
+  gameTime() {
+    return this.clock.now();
+  }
+  get frozen() {
+    return this.clock.frozen;
+  }
+  /** ハンドラへ渡す ctx の時刻部分。1 回の呼び出し内で値が動かないよう束ねる。 */
+  timeCtx(time) {
+    return { time, after: (d) => plus(time, d) };
+  }
+  freeze(reason) {
+    if (!this.clock.freeze(reason)) return;
+    this.stopTickLoop();
+    this.syncWakeup();
+  }
+  unfreeze(reason) {
+    if (!this.clock.unfreeze(reason)) return;
+    this.syncWakeup();
+    this.ensureTickLoop();
+  }
+  /**
+   * 停止の状態を全接続へ配る。
+   *
+   * `no-players` は見せない。外れる条件が「接続した」なので、クライアントが見られる
+   * 状態では必ず外れている。
+   */
+  broadcastPauseState() {
+    this.broadcastAll({
+      type: "__pause_state",
+      frozen: this.clock.isFrozenBy("emergency-stop"),
+      by: this.pausedBy,
+      gameTime: this.gameTime()
+    });
+  }
   // ─── Broadcast ─────────────────────────────────────────
   broadcastAll(msg) {
     const data = JSON.stringify(msg);
@@ -768,7 +916,7 @@ var GameRoom = class _GameRoom {
   }
   broadcastStateDelta(events, extra) {
     this.seq++;
-    const serverTime = Date.now();
+    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;
@@ -778,7 +926,7 @@ var GameRoom = class _GameRoom {
         state: this.gameState,
         events,
         seq: this.seq,
-        serverTime,
+        gameTime,
         ...extra
       });
     } else {
@@ -788,7 +936,7 @@ var GameRoom = class _GameRoom {
         patches,
         events,
         seq: this.seq,
-        serverTime,
+        gameTime,
         ...extra
       });
       const fullPayload = JSON.stringify({
@@ -796,7 +944,7 @@ var GameRoom = class _GameRoom {
         state: this.gameState,
         events,
         seq: this.seq,
-        serverTime,
+        gameTime,
         ...extra
       });
       const data = deltaPayload.length < fullPayload.length ? deltaPayload : fullPayload;
@@ -841,7 +989,7 @@ var GameRoom = class _GameRoom {
     return {
       players: this.players,
       seats: this.players,
-      ctx: { random, now: Date.now() }
+      ctx: { random, ...this.timeCtx(this.gameTime()) }
     };
   }
   maybeStartGame() {
@@ -849,7 +997,12 @@ var GameRoom = class _GameRoom {
     if (this.players.length === 0) return;
     this.seed = Math.floor(Math.random() * 4294967295);
     this.random = new SeededRandomImpl(this.seed);
-    this.gameState = this.logic.setup(this.setupArgs(this.random));
+    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.seq = 0;
@@ -859,9 +1012,11 @@ var GameRoom = class _GameRoom {
       type: "__game_start",
       state: this.gameState,
       seed: this.seed,
-      seq: 0
+      seq: 0,
+      gameTime: this.gameTime()
     });
     if (this.tickRate > 0) this.startTickLoop();
+    this.syncWakeup();
     this.notifySnapshotSubscribers();
   }
   startTickLoop() {
@@ -871,30 +1026,41 @@ var GameRoom = class _GameRoom {
   // 全クライアント切断で tickTimer は止まる (handleClose) が gameState は残るため、
   // 再接続や reset で「動いているべきなのに止まっている」状態を復旧する。
   ensureTickLoop() {
-    if (this.tickRate > 0 && this.gameState !== null && this.sockets.size > 0 && !this.tickPaused && !this.tickTimer) {
+    if (this.tickRate > 0 && this.gameState !== null && this.sockets.size > 0 && !this.tickPaused && !this.frozen && !this.tickTimer) {
       this.startTickLoop();
     }
   }
+  stopTickLoop() {
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+  }
   tick() {
-    if (this.tickPaused) return;
+    if (this.tickPaused || this.frozen) return;
     this.runOneTick();
   }
   runOneTick() {
     if (!this.gameState || !this.random) return;
     const events = [];
     const emit = (name, data) => events.push({ name, data: data ?? {} });
-    const tickNow = Date.now();
+    const time = this.gameTime();
+    const random = this.random;
+    const state = this.gameState;
     try {
-      this.logic.update({
-        state: this.gameState,
-        ctx: {
-          random: this.random,
-          tick: this.tickCount,
-          now: tickNow,
-          emit,
-          playerInputs: this.playerInputs
-        }
-      });
+      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++;
@@ -905,6 +1071,22 @@ var GameRoom = class _GameRoom {
     this.broadcastStateDelta(events, { tick: this.tickCount });
   }
   // ─── Connection ────────────────────────────────────────
+  /**
+   * 復帰用の state メッセージ。
+   *
+   * 停止中に接続・再接続した端末が overlay を出せるよう `frozen` / `pausedBy` を載せる。
+   */
+  stateMessage() {
+    return {
+      type: "__state",
+      state: this.gameState,
+      tick: this.tickCount,
+      seq: this.seq,
+      gameTime: this.gameTime(),
+      frozen: this.clock.isFrozenBy("emergency-stop"),
+      pausedBy: this.pausedBy
+    };
+  }
   handleConnection(ws, url) {
     const playerId = url.searchParams.get("seatId");
     if (!playerId) {
@@ -936,14 +1118,10 @@ var GameRoom = class _GameRoom {
       type: "__room_init",
       myId: playerId
     });
+    this.lastEmptyAtWall = null;
+    this.unfreeze("no-players");
     if (this.stateInitialized && this.gameState !== null) {
-      this.sendTo(ws, {
-        type: "__state",
-        state: this.gameState,
-        tick: this.tickCount,
-        seq: this.seq,
-        serverTime: Date.now()
-      });
+      this.sendTo(ws, this.stateMessage());
     }
     this.maybeStartGame();
     this.ensureTickLoop();
@@ -967,6 +1145,31 @@ var GameRoom = class _GameRoom {
     }
     const msgType = parsed.type;
     console.log(`[GameRoom] \u2B05 recv from=${senderId} type=${msgType}`);
+    if (msgType === "__pause") {
+      if (!this.gameState) return;
+      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()}`);
+      }
+      this.broadcastPauseState();
+      return;
+    }
+    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.broadcastPauseState();
+      return;
+    }
+    if (this.frozen && (msgType === "__action" || msgType === "__input")) {
+      if (msgType === "__action") {
+        this.sendTo(ws, { type: "__action_error", error: "Paused", seq: parsed.seq });
+      }
+      return;
+    }
     if (msgType === "__action") {
       if (!this.gameState) {
         this.sendTo(ws, {
@@ -992,13 +1195,7 @@ var GameRoom = class _GameRoom {
     }
     if (msgType === "__request_state") {
       if (this.gameState !== null) {
-        this.sendTo(ws, {
-          type: "__state",
-          state: this.gameState,
-          tick: this.tickCount,
-          seq: this.seq,
-          serverTime: Date.now()
-        });
+        this.sendTo(ws, this.stateMessage());
       }
       return;
     }
@@ -1022,15 +1219,19 @@ var GameRoom = class _GameRoom {
     const emit = (name, data) => events.push({ name, data: data ?? {} });
     const serverEmit = emit;
     const snapshot = structuredClone(this.gameState);
-    const now = Date.now();
+    const time = this.gameTime();
     try {
       if (plain && !legacyServerOnly) {
-        plain({
-          state: this.gameState,
-          payload: payload ?? {},
-          playerId: senderId,
-          ctx: { now, emit }
-        });
+        const state = this.gameState;
+        withGameClock(
+          time,
+          () => plain({
+            state,
+            payload: payload ?? {},
+            playerId: senderId,
+            ctx: { ...this.timeCtx(time), emit }
+          })
+        );
       }
       if (serverHandler) {
         await serverHandler({
@@ -1040,7 +1241,7 @@ var GameRoom = class _GameRoom {
           ctx: {
             tick: this.tickCount,
             random: this.random ?? new SeededRandomImpl(this.seed),
-            now,
+            ...this.timeCtx(time),
             emit: serverEmit
           }
         });
@@ -1057,28 +1258,50 @@ var GameRoom = class _GameRoom {
   wakeupTimer = null;
   wakeupAt = null;
   /**
-   * 宣言された締切のうち最も早い時刻。締切が無ければ null。
+   * 宣言された締切のうち最も早いゲーム内時刻。締切が無ければ null。
    * state から毎回導出するので保存しない。
    */
-  nextDeadline() {
+  earliestDeadline() {
     if (!this.gameState || !this.logic.deadlines) return null;
     let earliest = null;
     for (const [key, deadline] of Object.entries(this.logic.deadlines)) {
-      let at;
+      let raw;
       try {
-        at = deadline.at({ state: this.gameState });
+        raw = deadline.at({ state: this.gameState });
       } catch (err) {
         console.error(`[Deadline] \u274C ${key}.at() \u3067\u4F8B\u5916`, err);
         continue;
       }
-      if (typeof at !== "number" || !Number.isFinite(at)) 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;
   }
+  /**
+   * 次に起きるべき実時刻。締切と無人猶予の早い方。
+   *
+   * 停止中はシナリオの締切を予約しない (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.nextDeadline();
+    const next = this.nextWakeupWall();
     if (next === this.wakeupAt) return;
     if (this.wakeupTimer) clearTimeout(this.wakeupTimer);
     this.wakeupTimer = null;
@@ -1087,6 +1310,14 @@ var GameRoom = class _GameRoom {
     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() と同じ意味論。
    *
@@ -1096,8 +1327,12 @@ var GameRoom = class _GameRoom {
   fireDue() {
     this.wakeupTimer = null;
     this.wakeupAt = null;
-    if (!this.gameState || !this.logic.deadlines) return;
-    const now = Date.now();
+    this.freezeIfEmptyGraceExpired();
+    if (!this.gameState || !this.logic.deadlines || this.frozen) {
+      this.syncWakeup();
+      return;
+    }
+    const time = this.gameTime();
     const events = [];
     const firedKeys = [];
     for (const [key, deadline] of Object.entries(this.logic.deadlines)) {
@@ -1106,17 +1341,25 @@ var GameRoom = class _GameRoom {
       const pending = [];
       let snapshot = null;
       try {
-        const at = deadline.at({ state });
-        if (typeof at !== "number" || !Number.isFinite(at) || at > now) continue;
+        const at = resolveDeadline(
+          deadline.at({ state }),
+          key,
+          this.warnedDeadlines,
+          (m) => console.error(`[Deadline] \u274C ${m}`)
+        );
+        if (at === null || at > time) continue;
         snapshot = structuredClone(state);
-        deadline.handler({
-          state,
-          ctx: {
-            now,
-            random: this.random ?? new SeededRandomImpl(this.seed),
-            emit: (name, data) => pending.push({ name, data: data ?? {} })
-          }
-        });
+        withGameClock(
+          time,
+          () => deadline.handler({
+            state,
+            ctx: {
+              ...this.timeCtx(time),
+              random: this.random ?? new SeededRandomImpl(this.seed),
+              emit: (name, data) => pending.push({ name, data: data ?? {} })
+            }
+          })
+        );
         events.push(...pending);
         firedKeys.push(key);
       } catch (err) {
@@ -1138,9 +1381,12 @@ var GameRoom = class _GameRoom {
     this.sockets.delete(ws);
     this.attachments.delete(ws);
     delete this.playerInputs[attachment.playerId];
-    if (this.sockets.size === 0 && this.tickTimer) {
-      clearInterval(this.tickTimer);
-      this.tickTimer = null;
+    if (this.sockets.size === 0) {
+      this.stopTickLoop();
+      if (this.gameState !== null && this.lastEmptyAtWall === null) {
+        this.lastEmptyAtWall = Date.now();
+        this.syncWakeup();
+      }
     }
   }
   // ─── Admin API (parent frame __uzu_dev から使う) ──────────────────
@@ -1190,7 +1436,13 @@ var GameRoom = class _GameRoom {
           this.seed = opts.seed;
         }
         this.random = new SeededRandomImpl(this.seed);
-        this.gameState = this.logic.setup(this.setupArgs(this.random));
+        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;
@@ -1199,8 +1451,10 @@ var GameRoom = class _GameRoom {
           type: "__game_start",
           state: this.gameState,
           seed: this.seed,
-          seq: 0
+          seq: 0,
+          gameTime: this.gameTime()
         });
+        this.syncWakeup();
         this.notifySnapshotSubscribers();
         this.ensureTickLoop();
       },

package/dist/dev-server/sdk-server-shim.js

@@ -6,6 +6,214 @@ var DEFAULT_ICON_URLS = [
   "https://imagedelivery.net/htp-D7B2hJT5XtdWYN9e7Q/43f45d11-da38-4d6e-637d-3df78e583500/original"
 ];
 
+// ../engine-core/src/game-time.ts
+var toMs = (t) => t;
+var plus = (t, d) => toMs(t) + d;
+var sub = (t, d) => toMs(t) - d;
+var minus = (a, b) => toMs(a) - toMs(b);
+var asGameTime = (ms) => ms;
+
+// ../engine-core/src/game-clock.ts
+var NO_PLAYERS_GRACE_MS = 5 * 6e4;
+var GameClock = class {
+  startedAtWall = 0;
+  pausedTotalMs = 0;
+  pausedAtWall = null;
+  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 toMs(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();
+  }
+};
+function withGameClock(time, fn) {
+  const realNow = Date.now;
+  const RealDate = Date;
+  const ms = toMs(time);
+  Date.now = () => ms;
+  globalThis.Date = new Proxy(RealDate, {
+    construct: (target, args) => Reflect.construct(target, args.length === 0 ? [ms] : args)
+  });
+  try {
+    return fn();
+  } finally {
+    globalThis.Date = RealDate;
+    Date.now = realNow;
+  }
+}
+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}" \u306E at() \u304C\u7DE0\u5207\u306B\u4F7F\u3048\u306A\u3044\u5024\u3092\u8FD4\u3057\u305F: ${String(at)}\u3002\u3053\u306E\u7DE0\u5207\u306F\u4E8C\u5EA6\u3068\u767A\u706B\u3057\u306A\u3044\u3002\u5EC3\u6B62\u3055\u308C\u305F ctx.now \u3092\u8AAD\u3093\u3067\u3044\u306A\u3044\u304B\u78BA\u8A8D\u3059\u308B\u3053\u3068`
+    );
+  }
+  return null;
+}
+
+// ../engine-core/src/json-patch.ts
+function escapePointer(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapePointer(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function compare(oldObj, newObj, basePath = "") {
+  if (oldObj === newObj) return [];
+  if (oldObj === null || newObj === null || typeof oldObj !== "object" || typeof newObj !== "object") {
+    return [{ op: "replace", path: basePath || "/", value: newObj }];
+  }
+  if (Array.isArray(oldObj) || Array.isArray(newObj)) {
+    if (JSON.stringify(oldObj) === JSON.stringify(newObj)) return [];
+    return [{ op: "replace", path: basePath || "/", value: newObj }];
+  }
+  const ops = [];
+  const oldKeys = Object.keys(oldObj);
+  const newKeys = Object.keys(newObj);
+  for (const key of oldKeys) {
+    if (!(key in newObj)) {
+      ops.push({ op: "remove", path: `${basePath}/${escapePointer(key)}` });
+    }
+  }
+  for (const key of newKeys) {
+    const childPath = `${basePath}/${escapePointer(key)}`;
+    if (!(key in oldObj)) {
+      ops.push({ op: "add", path: childPath, value: newObj[key] });
+    } else {
+      const childOps = compare(oldObj[key], newObj[key], childPath);
+      ops.push(...childOps);
+    }
+  }
+  return ops;
+}
+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;
+}
+
+// ../engine-core/src/random.ts
+var SeededRandomImpl = class _SeededRandomImpl {
+  _state;
+  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;
+  }
+};
+
 // ../engine-core/src/server-only.ts
 function serverOnly(handler) {
   return Object.assign(handler, { __serverOnly: true });
@@ -13,9 +221,45 @@ function serverOnly(handler) {
 function isServerOnlyAction(handler) {
   return typeof handler === "function" && "__serverOnly" in handler && handler.__serverOnly === true;
 }
+
+// ../engine-core/src/roster.ts
+function parseRoster(rosterParam) {
+  if (!rosterParam) return null;
+  let raw;
+  try {
+    raw = JSON.parse(rosterParam);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(raw)) return null;
+  return raw.filter((p) => (p.kind ?? "player") === "player").map((p) => ({
+    id: p.id,
+    nickname: p.name ?? "Guest",
+    iconUrl: p.iconUrl ?? "",
+    characterId: p.characterId
+  }));
+}
+
+// ../engine-core/src/versions.ts
+var BRIDGE_VERSION = 2;
+var WIRE_VERSION = 2;
 export {
+  BRIDGE_VERSION,
   DEFAULT_ICON_URLS,
+  GameClock,
+  NO_PLAYERS_GRACE_MS,
   SERVER_TIME,
+  SeededRandomImpl,
+  WIRE_VERSION,
+  applyPatch,
+  asGameTime,
+  compare,
   isServerOnlyAction,
-  serverOnly
+  minus,
+  parseRoster,
+  plus,
+  resolveDeadline,
+  serverOnly,
+  sub,
+  withGameClock
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uzuhq/code-cli",
-  "version": "0.5.10",
+  "version": "0.6.1",
   "description": "UZU ゲーム開発 CLI - ビルド・パブリッシュ・プロジェクト作成ツール",
   "type": "module",
   "bin": {