@uzuhq/code-cli 0.5.1 → 0.5.2

package/dist/dev-server/game-room.js

@@ -14,8 +14,6 @@
 import { randomUUID } from 'crypto';
 import { compare, applyJsonMergePatch, applyJsonPatch } from './json-patch.js';
 import { SeededRandomImpl } from './random.js';
-import { SCHEDULED_ACTOR } from './game-types.js';
-import { ScheduleDraft, loadQueue, popDue, saveQueue, } from './scheduler.js';
 /**
  * serverOnly() で wrap された handler かを判定する (SDK の isServerOnlyAction と同じ brand)。
  * dev-server は SDK を import できないため実装を持つ。
@@ -208,9 +206,7 @@ export class GameRoom {
         const events = [];
         const emit = (name, data) => events.push({ name, data: data ?? {} });
         // ctx.now と予約の基準時刻は同じ値にする。別々に Date.now() を呼ぶと
-        // 「schedule の戻り値 = ctx.now + after * 1000」という約束が数 ms 崩れる。
         const tickNow = Date.now();
-        const tickDraft = new ScheduleDraft(tickNow, (a) => this.hasAction(a));
         try {
             this.logic.update({
                 state: this.gameState,
@@ -218,8 +214,6 @@ export class GameRoom {
                     random: this.random,
                     tick: this.tickCount,
                     now: tickNow,
-                    schedule: (o) => tickDraft.schedule(o),
-                    unschedule: (k) => tickDraft.unschedule(k),
                     emit,
                     playerInputs: this.playerInputs,
                 },
@@ -231,8 +225,7 @@ export class GameRoom {
             return;
         }
         this.tickCount++;
-        if (tickDraft.dirty)
-            void this.flushSchedule(tickDraft);
+        this.syncWakeup();
         this.broadcastStateDelta(events, { tick: this.tickCount });
     }
     // ─── Connection ────────────────────────────────────────
@@ -383,11 +376,6 @@ export class GameRoom {
         // 値が変わると、片方だけを見た state が一瞬矛盾する。
         const now = Date.now();
         // handler 内では配列を触るだけにして、反映は dispatch 後にまとめて行う。
-        const draft = new ScheduleDraft(now, (a) => this.hasAction(a));
-        const scheduleCtx = {
-            schedule: (o) => draft.schedule(o),
-            unschedule: (k) => draft.unschedule(k),
-        };
         try {
             // 決定的な部分を先に走らせ、serverActions がその結果を見られるようにする。
             if (plain && !legacyServerOnly) {
@@ -395,7 +383,7 @@ export class GameRoom {
                     state: this.gameState,
                     payload: payload ?? {},
                     playerId: senderId,
-                    ctx: { now, emit, ...scheduleCtx },
+                    ctx: { now, emit },
                 });
             }
             if (serverHandler) {
@@ -408,7 +396,6 @@ export class GameRoom {
                         random: this.random ?? new SeededRandomImpl(this.seed),
                         now,
                         emit: serverEmit,
-                        ...scheduleCtx,
                     },
                 });
             }
@@ -417,78 +404,103 @@ export class GameRoom {
             this.gameState = snapshot;
             throw err;
         }
-        if (draft.dirty)
-            await this.flushSchedule(draft);
+        this.syncWakeup();
         this.broadcastStateDelta(events, { ack: ackSeq, from: senderId });
     }
-    // ─── Scheduler (本番の Durable Object alarm 相当) ──────────
-    /** dev はメモリ + setTimeout。本番は storage + alarm。 */
-    scheduled = [];
+    // ─── Deadlines (本番の Durable Object alarm 相当) ──────────
+    /** dev は setTimeout。本番は storage の alarm。意味論は同じ。 */
     wakeupTimer = null;
-    get schedulerStore() {
-        return {
-            get: async () => this.scheduled,
-            put: async (entries) => {
-                this.scheduled = entries;
-            },
-            setWakeup: async (at) => {
-                if (this.wakeupTimer)
-                    clearTimeout(this.wakeupTimer);
-                this.wakeupTimer = null;
-                if (at == null)
-                    return;
-                this.wakeupTimer = setTimeout(() => void this.fireDue(), Math.max(0, at - Date.now()));
-            },
-        };
-    }
-    hasAction(name) {
-        return Boolean(this.logic.actions[name] || this.logic.serverActions?.[name]);
-    }
+    wakeupAt = null;
     /**
-     * 予約の書き込みを直列化する。
-     *
-     * tick / action / 発火処理が同時に走ると、後着が先着を上書きして予約が消える。
-     * 呼び出し順に 1 本の鎖へ並べる (play-server 版と同じ)。
+     * 宣言された締切のうち最も早い時刻。締切が無ければ null。
+     * state から毎回導出するので保存しない。
      */
-    scheduleChain = Promise.resolve();
-    queueScheduleWrite(mutate) {
-        this.scheduleChain = this.scheduleChain
-            .then(async () => {
-            const current = await loadQueue(this.schedulerStore);
-            await saveQueue(this.schedulerStore, mutate(current));
-        })
-            .catch((err) => {
-            console.error('[Scheduler] ❌ 予約の書き込みに失敗', err);
-        });
-        return this.scheduleChain;
+    nextDeadline() {
+        if (!this.gameState || !this.logic.deadlines)
+            return null;
+        let earliest = null;
+        for (const [key, deadline] of Object.entries(this.logic.deadlines)) {
+            let at;
+            try {
+                at = deadline.at({ state: this.gameState });
+            }
+            catch (err) {
+                console.error(`[Deadline] ❌ ${key}.at() で例外`, err);
+                continue;
+            }
+            if (typeof at !== 'number' || !Number.isFinite(at))
+                continue;
+            if (earliest === null || at < earliest)
+                earliest = at;
+        }
+        return earliest;
     }
-    flushSchedule(draft) {
-        return this.queueScheduleWrite((current) => draft.apply(current));
+    /** 起床時刻を現在の state に合わせる。state を変えた後は必ず通す。 */
+    syncWakeup() {
+        const next = this.nextDeadline();
+        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()));
+        // dev の setTimeout は process を掴み続けるので、他に仕事が無ければ抜けられるようにする。
+        this.wakeupTimer.unref?.();
     }
     /**
-     * 期限の来た予約を実行する。本番の alarm() と同じ意味論。
+     * 過ぎた締切の handler を実行する。本番の alarm() と同じ意味論。
      *
-     * 失敗は握って捨てる (決定的バグでクラッシュを繰り返さない)。ログには必ず残す。
+     * handler の直前に at を評価し直す (先に走った handler が別の締切を消しうる)。
+     * 失敗は握って捨てる。ログには必ず残す。
      */
-    async fireDue() {
-        let due = [];
-        // 先に残りを確定させる。実行中に新しい予約が積まれても失われない。
-        await this.queueScheduleWrite((current) => {
-            const split = popDue(current, Date.now());
-            due = split.due;
-            return split.rest;
-        });
-        if (due.length > 0) {
-            console.log(`[Scheduler] ⏰ ${due.length} 件発火: ${due.map((e) => e.key).join(', ')}`);
-        }
-        for (const entry of due) {
+    fireDue() {
+        this.wakeupTimer = null;
+        this.wakeupAt = null;
+        if (!this.gameState || !this.logic.deadlines)
+            return;
+        const now = Date.now();
+        const events = [];
+        const firedKeys = [];
+        for (const [key, deadline] of Object.entries(this.logic.deadlines)) {
+            // 巻き戻しで this.gameState が差し替わるので、毎周読み直す。
+            const state = this.gameState;
+            if (!state)
+                break;
+            // handler が emit してから throw したときに捨てられるよう、締切ごとに溜める。
+            // state を戻したのに音や演出だけ流れると、起きていない出来事が見えてしまう。
+            const pending = [];
+            let snapshot = null;
             try {
-                await this.dispatchAction(entry.action, entry.payload, SCHEDULED_ACTOR);
+                const at = deadline.at({ state });
+                if (typeof at !== 'number' || !Number.isFinite(at) || at > now)
+                    continue;
+                // 期限が来たものだけ複製する。毎周撮ると締切の数だけ state の複製が走る。
+                snapshot = structuredClone(state);
+                deadline.handler({
+                    state,
+                    ctx: {
+                        now,
+                        random: this.random ?? new SeededRandomImpl(this.seed),
+                        emit: (name, data) => pending.push({ name, data: data ?? {} }),
+                    },
+                });
+                events.push(...pending);
+                firedKeys.push(key);
             }
             catch (err) {
-                console.error(`[Scheduler] ❌ key=${entry.key} action=${entry.action}:`, err);
+                if (snapshot !== null)
+                    this.gameState = snapshot;
+                console.error(`[Deadline] ❌ ${key} で例外`, err);
             }
         }
+        this.syncWakeup();
+        if (firedKeys.length === 0)
+            return;
+        console.log(`[Deadline] ⏰ ${firedKeys.length} 件発火: ${firedKeys.join(', ')}`);
+        this.broadcastStateDelta(events, {});
     }
     handleClose(ws) {
         const attachment = this.attachments.get(ws);

package/dist/dev-server/game-types.js

@@ -8,10 +8,4 @@
  * SDK を直接 import できず、game-worker-template と同じく copy を持つ。
  * 3 か所いずれかを変更したら他 2 か所も同期させること。
  */
-/**
- * 予約から発火した action に渡る playerId。
- *
- * 送信者がいないので、人間の操作と区別するための定数。
- * `if (playerId !== SCHEDULED_ACTOR) return;` で人間からの直接実行を弾ける。
- */
-export const SCHEDULED_ACTOR = '__scheduled';
+export {};

package/package.json

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

package/dist/dev-server/scheduler.js

@@ -1,135 +0,0 @@
-/**
- * @docs
- * - ServerAction仕様: docs/docs/uzu_code/connection-method/arch3-authority.md
- *
- * サーバー権威のタイマー。
- *
- * これは dev-server (Node) 用のコピー。本番の Durable Object 版
- * (play-server/src/game-worker-template/scheduler.ts) と**同一内容に保つこと**。
- * 意味論がずれると「dev では動くが本番で止まる」という一番タチの悪い差になる。
- *
- * dev では alarm の代わりに setTimeout、storage の代わりにメモリを使う (SchedulerStore
- * の実装差だけで吸収する)。
- */
-const STORAGE_KEY = '__scheduled';
-/**
- * 同時に持てる予約の上限。
- *
- * key で置き換わるので通常は増えないが、キーを動的に生成する (`narration:${i++}` 等)
- * バグを踏むと際限なく積み上がる。その歯止め。
- *
- * NOTE: 値そのものに根拠は無い。マダミスの実データ (フェーズ数 + ナレーション行列で
- * 数十件) から見て十分に余裕がある数字を置いているだけ。
- */
-export const MAX_SCHEDULED = 256;
-/**
- * 予約できる先の上限 (ms)。
- *
- * 狙いは単位の取り違え。`after: 1200 * 1000` (ms のつもり) を書くと 13.9 日後になるが、
- * 型では防げない。ゲームは長くても数時間なので、これを超える予約は事実上バグ。
- *
- * NOTE: 値そのものに根拠は無い。
- */
-export const MAX_HORIZON_MS = 24 * 60 * 60 * 1000;
-/**
- * 1 dispatch ぶんの予約変更を溜めるバッファ。
- *
- * action handler の中では同期的に呼ばれるので、ここでは配列を触るだけにして、
- * dispatch が終わってからまとめてストレージへ書き戻す (I/O を handler の外へ出す)。
- */
-export class ScheduleDraft {
-    now;
-    knownActions;
-    added = [];
-    removed = new Set();
-    /** 予約 / 取り消しが 1 件でもあったか。無ければストレージに触らない。 */
-    dirty = false;
-    constructor(now, knownActions) {
-        this.now = now;
-        this.knownActions = knownActions;
-    }
-    schedule(options) {
-        const { key, action } = options;
-        if (options.at != null && options.after != null) {
-            throw new Error(`schedule: key=${key} — at と after は排他です`);
-        }
-        const at = options.at != null ? Number(options.at) : this.now + Number(options.after ?? 0) * 1000;
-        // IMPORTANT: 検査に引っかかったら握り潰さず throw する。
-        //
-        // 黙って捨てると、呼び出し側は予約できたつもりで戻り値を endsAt として state に入れ、
-        // タイマーが表示されたまま永久に発火しない = ゲームが静かに止まる。予約方式は
-        // 「何も起きないこと」に気づけないので、その場で失敗させるしかない。
-        // ここに来るのはバグのときだけなので、action 全体がロールバックされて構わない。
-        if (!key)
-            throw new Error('schedule: key は必須です');
-        if (!Number.isFinite(at))
-            throw new Error(`schedule: key=${key} の時刻が不正です`);
-        if (!this.knownActions(action)) {
-            throw new Error(`schedule: key=${key} の action "${action}" が logic に存在しません`);
-        }
-        if (at - this.now > MAX_HORIZON_MS) {
-            const days = ((at - this.now) / 86_400_000).toFixed(1);
-            throw new Error(`schedule: key=${key} の予約が上限 (24h) を超えています (${days} 日後)。` +
-                ' after は「秒」です。ms を渡していませんか');
-        }
-        this.removed.add(key);
-        const idx = this.added.findIndex((e) => e.key === key);
-        const entry = { key, at, action, payload: options.payload ?? {} };
-        if (idx >= 0)
-            this.added[idx] = entry;
-        else
-            this.added.push(entry);
-        this.dirty = true;
-        return at;
-    }
-    unschedule(key) {
-        this.removed.add(key);
-        const idx = this.added.findIndex((e) => e.key === key);
-        if (idx >= 0)
-            this.added.splice(idx, 1);
-        this.dirty = true;
-    }
-    /**
-     * 既存キューへ変更を適用する。key 単位で必ず 1 件に畳まれる。
-     *
-     * 上限超過は throw する。どれを捨てるかを SDK が決めると、フェーズタイマー (遠い) を
-     * 捨ててナレーション (近い) を残す、といった優先順位の判断を勝手にすることになる。
-     */
-    apply(current) {
-        const next = current.filter((e) => !this.removed.has(e.key));
-        next.push(...this.added);
-        if (next.length > MAX_SCHEDULED) {
-            throw new Error(`schedule: 予約が上限 ${MAX_SCHEDULED} 件を超えました (${next.length} 件)。` +
-                ' key を動的に生成していませんか');
-        }
-        next.sort((a, b) => a.at - b.at);
-        return next;
-    }
-}
-/** ストレージのキューを読む。 */
-export async function loadQueue(store) {
-    return (await store.get()) ?? [];
-}
-/** キューを書き戻し、最も早い 1 件へ起床時刻を張り替える。 */
-export async function saveQueue(store, entries) {
-    await store.put(entries);
-    const next = entries.length > 0 ? entries[0] : null;
-    await store.setWakeup(next ? next.at : null);
-    // 予約方式は「静かに何も起きない」ので、状態がログに出ないと調査手段が無くなる。
-    if (next) {
-        const inSec = Math.round((next.at - Date.now()) / 1000);
-        console.log(`[Scheduler] 📅 ${entries.length} 件 / 次は ${next.key} (${next.action}) ${inSec}s 後`);
-    }
-    else {
-        console.log('[Scheduler] 📭 予約なし');
-    }
-}
-/** 期限が来た予約を取り出し、残りを返す。 */
-export function popDue(entries, now) {
-    const due = [];
-    const rest = [];
-    for (const e of entries)
-        (e.at <= now ? due : rest).push(e);
-    return { due, rest };
-}
-export const SCHEDULER_STORAGE_KEY = STORAGE_KEY;