@uzuhq/code-cli 0.5.1 → 0.5.3

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 ────────────────────────────────────────
@@ -297,6 +290,17 @@ export class GameRoom {
         this.ensureTickLoop();
     }
     async handleMessage(ws, msg) {
+        // SDK は生文字列で送受信する (本番の setWebSocketAutoResponse と同じ wire 形式)。
+        // JSON.parse より前に返さないと heartbeat が落ちて 35 秒ごとに全席が再接続する。
+        if (msg === '__ping') {
+            try {
+                ws.send('__pong');
+            }
+            catch {
+                /* disconnected */
+            }
+            return;
+        }
         const attachment = this.attachments.get(ws);
         if (!attachment)
             return;
@@ -309,10 +313,6 @@ export class GameRoom {
             return;
         }
         const msgType = parsed.type;
-        if (msgType === '__ping') {
-            this.sendTo(ws, { type: '__pong' });
-            return;
-        }
         console.log(`[GameRoom] ⬅ recv from=${senderId} type=${msgType}`);
         if (msgType === '__action') {
             if (!this.gameState) {
@@ -383,11 +383,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 +390,7 @@ export class GameRoom {
                     state: this.gameState,
                     payload: payload ?? {},
                     playerId: senderId,
-                    ctx: { now, emit, ...scheduleCtx },
+                    ctx: { now, emit },
                 });
             }
             if (serverHandler) {
@@ -408,7 +403,6 @@ export class GameRoom {
                         random: this.random ?? new SeededRandomImpl(this.seed),
                         now,
                         emit: serverEmit,
-                        ...scheduleCtx,
                     },
                 });
             }
@@ -417,78 +411,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/dist/dev-server/relay-room.js

@@ -25,6 +25,17 @@ export class RelayRoom {
         ws.send(JSON.stringify({ type: '__room_init', myId: playerId }));
     }
     handleMessage(ws, msg) {
+        // SDK は生文字列で送受信する (本番の setWebSocketAutoResponse と同じ wire 形式)。
+        // JSON.parse より前に返さないと heartbeat が落ちて 35 秒ごとに全席が再接続する。
+        if (msg === '__ping') {
+            try {
+                ws.send('__pong');
+            }
+            catch {
+                /* disconnected */
+            }
+            return;
+        }
         const attachment = this.attachments.get(ws);
         if (!attachment)
             return;
@@ -36,15 +47,6 @@ export class RelayRoom {
         catch {
             return;
         }
-        if (parsed.type === '__ping') {
-            try {
-                ws.send(JSON.stringify({ type: '__pong' }));
-            }
-            catch {
-                /* disconnected */
-            }
-            return;
-        }
         console.log(`[RelayRoom] ⬅ recv from=${senderId}`, JSON.stringify(parsed));
         const outData = JSON.stringify({ ...parsed, __from: senderId });
         if (parsed.__to && typeof parsed.__to === 'string') {

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

@@ -78,6 +78,17 @@ export class SyncRoom {
         }
     }
     handleMessage(ws, msg) {
+        // SDK は生文字列で送受信する (本番の setWebSocketAutoResponse と同じ wire 形式)。
+        // JSON.parse より前に返さないと heartbeat が落ちて 35 秒ごとに全席が再接続する。
+        if (msg === '__ping') {
+            try {
+                ws.send('__pong');
+            }
+            catch {
+                /* disconnected */
+            }
+            return;
+        }
         const attachment = this.attachments.get(ws);
         if (!attachment)
             return;
@@ -90,15 +101,6 @@ export class SyncRoom {
             return;
         }
         const msgType = parsed.type;
-        if (msgType === '__ping') {
-            try {
-                ws.send(JSON.stringify({ type: '__pong' }));
-            }
-            catch {
-                /* disconnected */
-            }
-            return;
-        }
         console.log(`[SyncRoom] ⬅ recv from=${senderId} type=${msgType}`);
         if (msgType === '__init_state') {
             if (this.stateInitialized) {

package/dist/harness/mount.js

@@ -33,6 +33,14 @@ const PHONE_SVG = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" x
 <rect x="6.5" y="2" width="11" height="20" rx="2.5" stroke="white" stroke-width="2"/>
 <line x1="10" y1="18.5" x2="14" y2="18.5" stroke="white" stroke-width="2" stroke-linecap="round"/>
 </svg>`;
+// 擬似ノッチ表示トグル。 createNotchDecor が実際に描く装飾 (横向き端末・左の
+// Dynamic Island・下中央のホームインジケータ) をそのまま象る。 隣の PHONE_SVG
+// (縦向き) とは向きで見分ける。
+const NOTCH_SVG = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect x="2" y="4.5" width="20" height="15" rx="3.5" stroke="white" stroke-width="1.8"/>
+<rect x="4.8" y="8.5" width="2.2" height="7" rx="1.1" fill="white"/>
+<line x1="11" y1="17" x2="17" y2="17" stroke="white" stroke-width="1.6" stroke-linecap="round"/>
+</svg>`;
 /** buildIframeUrl に渡す HUD の避け領域 (Flutter HudInsets と同じ計算)。 */
 function hudInsetParams(hasMenu, actionCount) {
     let x = HUD_LEFT;
@@ -429,19 +437,12 @@ function openPlayerSwitcher(opts, currentIndex, anchor) {
     };
     setTimeout(() => document.addEventListener('click', close), 0);
 }
-/**
- * 各 iframe (= 各プレイヤー画面) の左上に載せる overlay chrome。
- * 本番アプリ (Flutter GamePlayScreen) と同じ仕様:
- *   SafeArea top:8 / left:12 → [UZU ボタン 44] [gap 6] [ActionBar ピル: chat, mic]。
- * UZU ボタンは dev メニュー (State/Reset/Emulator) + その player の「スマホで開く」を開く。
- * chat / mic は本番の見た目に合わせた dev 表示 (機能は SDK 側が担うため配線しない)。
- */
 function createCellChrome(opts, playerIndex, 
 // facade=true (実機の単体表示) では見た目だけ揃える。 admin channel が無いので
 // UZU メニュー / 実機 QR は配線せず、 アイコンはタップ無効 (ハリボテ)。
 facade = false, 
-// grid では no-op のマイクアイコンを擬似ノッチ表示トグルに転用する。
-onMicClick, 
+// grid では no-op のマイク枠を擬似ノッチ表示トグルに転用する。
+notchToggle, 
 // 単体表示 (実機) では UZU ボタンをプレイヤー切替に転用する。
 onUzuClick) {
     const wrap = document.createElement('div');
@@ -489,17 +490,24 @@ onUzuClick) {
         'border-radius:18px',
         'display:flex;align-items:center',
     ].join(';');
-    // 1つめ: マイク。 本番は音声トグルだが harness では no-op なので、 grid では
-    // 擬似ノッチ表示のトグルに転用する (単体表示 facade では装飾のみ)。
-    const mic = document.createElement(onMicClick ? 'button' : 'div');
-    mic.innerHTML = MIC_SVG;
-    mic.title = onMicClick ? '擬似ノッチ表示 ON/OFF' : 'マイク (dev 表示のみ)';
-    mic.style.cssText = onMicClick
+    // 1つめ: 本番は音声トグルだが harness には音声が無い。 grid ではこの枠を擬似ノッチ
+    // 表示のトグルに転用し、 アイコンも端末フレームへ差し替える (facade は本番の見た目)。
+    const micSlot = document.createElement(notchToggle ? 'button' : 'div');
+    micSlot.innerHTML = notchToggle ? NOTCH_SVG : MIC_SVG;
+    micSlot.style.cssText = notchToggle
         ? 'padding:0 10px;height:36px;background:none;border:none;cursor:pointer;display:flex;align-items:center;'
         : 'padding:0 10px;display:flex;align-items:center;';
-    if (onMicClick)
-        mic.onclick = onMicClick;
-    bar.appendChild(mic);
+    if (notchToggle) {
+        micSlot.onclick = notchToggle.toggle;
+        notchToggle.register((on) => {
+            micSlot.style.opacity = on ? '1' : '0.4';
+            micSlot.title = `擬似ノッチ表示: ${on ? 'ON' : 'OFF'}`;
+        });
+    }
+    else {
+        micSlot.title = 'マイク (dev 表示のみ)';
+    }
+    bar.appendChild(micSlot);
     // 2つめ: 携帯 (その player を実機で開く QR)。 facade では装飾のみ。
     const phone = document.createElement('button');
     phone.innerHTML = PHONE_SVG;
@@ -528,7 +536,8 @@ export function mountIframeGrid(opts) {
     const iframeSplashes = new Map();
     const iframePredictionWarns = new Map();
     // 擬似ノッチ (各 cell 共通トグル)。 iframe を再生成せず inset だけ切り替える。
-    let notchSimOn = true;
+    // 既定は OFF: ノッチ帯のぶん画面が縮むので、 SafeArea を確認したいときだけ出す。
+    let notchSimOn = false;
     const notchAppliers = [];
     const toggleNotchSim = () => {
         notchSimOn = !notchSimOn;
@@ -575,6 +584,7 @@ export function mountIframeGrid(opts) {
         iframeStatusDots.clear();
         iframeSplashes.clear();
         iframePredictionWarns.clear();
+        notchAppliers.length = 0;
         for (let i = 0; i < opts.seats.length; i++) {
             const seat = seatAt(opts, i);
             const cell = document.createElement('div');
@@ -616,7 +626,13 @@ export function mountIframeGrid(opts) {
             screen.appendChild(splash);
             // admin は端末を模す必要が無いので overlay chrome / 擬似ノッチを載せず素の画面にする。
             if (seat.kind !== 'admin') {
-                screen.appendChild(createCellChrome(opts, i, false, toggleNotchSim));
+                screen.appendChild(createCellChrome(opts, i, false, {
+                    toggle: toggleNotchSim,
+                    register: (apply) => {
+                        apply(notchSimOn);
+                        notchAppliers.push(apply);
+                    },
+                }));
             }
             // 先読み警告の内訳パネル。 バッジクリックで開閉する。 画面の上に重ねるので
             // ゲームの見た目は普段どおりのまま、 必要なときだけ前に出る。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uzuhq/code-cli",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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;