@sayue_ltr/fleq 1.50.1 → 2.0.0

package/dist/ui/summary/token-builders.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSummaryTokens = buildSummaryTokens;
+const formatter_1 = require("../formatter");
+// ── Helper ──
+function token(id, text, priority, dropMode, shortText) {
+    const minW = shortText != null ? (0, formatter_1.visualWidth)(shortText) : (0, formatter_1.visualWidth)(text);
+    const prefW = (0, formatter_1.visualWidth)(text);
+    return { id, text, shortText, priority, minWidth: minW, preferredWidth: prefW, dropMode };
+}
+/** 地方・県名の末尾パターンを除去する簡易短縮 */
+function shortenHypocenter(name) {
+    return name
+        .replace(/地方$/, "")
+        .replace(/^.+県/, "");
+}
+/**
+ * areaNames を先頭 n 件で結合し、残りがあれば「ほかN」の shortText を返す。
+ */
+function topAreaTokenParts(names, limit) {
+    if (names.length === 0)
+        return null;
+    const top = names.slice(0, limit);
+    const text = top.join(",");
+    if (names.length > limit) {
+        const short = `${top[0]}ほか${names.length - 1}`;
+        return { text, shortText: short };
+    }
+    return { text };
+}
+// ── Domain builders ──
+function buildEewTokens(event, model) {
+    const tokens = [];
+    tokens.push(token("severity", model.severity, 0, "never"));
+    // kind
+    if (event.isCancellation) {
+        tokens.push(token("kind", "EEW取消", 0, "never"));
+    }
+    else if (event.isWarning) {
+        tokens.push(token("kind", "EEW警報", 0, "never"));
+    }
+    else {
+        tokens.push(token("kind", "EEW予報", 0, "never"));
+    }
+    // serial
+    if (model.serial) {
+        tokens.push(token("serial", model.serial, 1, "drop"));
+    }
+    // hypocenter
+    if (event.hypocenterName) {
+        const short = shortenHypocenter(event.hypocenterName);
+        tokens.push(token("hypocenter", event.hypocenterName, 1, "shorten", short !== event.hypocenterName ? short : undefined));
+    }
+    // maxInt
+    const eewMaxInt = event.forecastMaxInt ? `震度${event.forecastMaxInt}` : (model.maxInt ?? "震度-");
+    tokens.push(token("maxInt", eewMaxInt, 0, "never"));
+    // maxLgInt
+    if (model.maxLgInt) {
+        tokens.push(token("maxLgInt", model.maxLgInt, 2, "drop"));
+    }
+    // magnitude
+    if (model.magnitude) {
+        tokens.push(token("magnitude", model.magnitude, 2, "shorten", model.magnitude));
+    }
+    // depth
+    if (event.depth) {
+        tokens.push(token("depth", `深さ${event.depth}`, 3, "drop"));
+    }
+    // forecastAreaTop
+    if (event.forecastAreaNames.length > 0) {
+        const parts = topAreaTokenParts(event.forecastAreaNames, 3);
+        if (parts) {
+            tokens.push(token("forecastAreaTop", parts.text, 3, "drop"));
+        }
+    }
+    return tokens;
+}
+function buildEarthquakeTokens(event, model) {
+    const tokens = [];
+    const headType = event.type;
+    tokens.push(token("severity", model.severity, 0, "never"));
+    if (headType === "VXSE51") {
+        // 震度速報
+        tokens.push(token("type", "震度速報", 0, "never"));
+        if (model.maxInt)
+            tokens.push(token("maxInt", model.maxInt, 0, "never"));
+        const parts = topAreaTokenParts(event.areaNames, 2);
+        if (parts)
+            tokens.push(token("topAreas", parts.text, 1, "shorten", parts.shortText));
+        if (event.headline && event.headline.includes("津波")) {
+            tokens.push(token("tsunami", event.headline, 2, "drop"));
+        }
+    }
+    else if (headType === "VXSE52") {
+        // 震源情報
+        tokens.push(token("type", "震源情報", 0, "never"));
+        if (event.hypocenterName) {
+            const short = shortenHypocenter(event.hypocenterName);
+            tokens.push(token("hypocenter", event.hypocenterName, 1, "shorten", short !== event.hypocenterName ? short : undefined));
+        }
+        if (model.magnitude)
+            tokens.push(token("magnitude", model.magnitude, 1, "shorten", model.magnitude));
+        if (event.depth)
+            tokens.push(token("depth", `深さ${event.depth}`, 2, "drop"));
+        if (event.headline && event.headline.includes("津波")) {
+            tokens.push(token("tsunami", event.headline, 2, "drop"));
+        }
+    }
+    else if (headType === "VXSE53") {
+        // 震源・震度情報
+        tokens.push(token("type", "震源・震度情報", 0, "shorten", "震源震度"));
+        if (event.hypocenterName) {
+            const short = shortenHypocenter(event.hypocenterName);
+            tokens.push(token("hypocenter", event.hypocenterName, 1, "shorten", short !== event.hypocenterName ? short : undefined));
+        }
+        if (model.magnitude)
+            tokens.push(token("magnitude", model.magnitude, 1, "shorten", model.magnitude));
+        if (model.maxInt)
+            tokens.push(token("maxInt", model.maxInt, 0, "never"));
+        if (model.maxLgInt)
+            tokens.push(token("maxLgInt", model.maxLgInt, 2, "drop"));
+        if (event.headline && event.headline.includes("津波")) {
+            tokens.push(token("tsunami", event.headline, 2, "drop"));
+        }
+        const parts = topAreaTokenParts(event.areaNames, 2);
+        if (parts)
+            tokens.push(token("topAreas", parts.text, 2, "drop"));
+    }
+    else if (headType === "VXSE61") {
+        // 遠地地震
+        tokens.push(token("type", "遠地地震情報", 0, "shorten", "遠地地震"));
+        if (event.hypocenterName) {
+            const short = shortenHypocenter(event.hypocenterName);
+            tokens.push(token("hypocenter", event.hypocenterName, 1, "shorten", short !== event.hypocenterName ? short : undefined));
+        }
+        if (model.magnitude)
+            tokens.push(token("magnitude", model.magnitude, 1, "shorten", model.magnitude));
+        if (model.maxInt)
+            tokens.push(token("maxInt", model.maxInt, 0, "never"));
+    }
+    else {
+        // その他の地震電文
+        tokens.push(token("type", event.title, 0, "shorten"));
+        if (event.hypocenterName) {
+            const short = shortenHypocenter(event.hypocenterName);
+            tokens.push(token("hypocenter", event.hypocenterName, 1, "shorten", short !== event.hypocenterName ? short : undefined));
+        }
+        if (model.maxInt)
+            tokens.push(token("maxInt", model.maxInt, 0, "never"));
+    }
+    return tokens;
+}
+function buildTsunamiTokens(event, model) {
+    const tokens = [];
+    tokens.push(token("severity", model.severity, 0, "never"));
+    // bannerKind: headline から抽出、なければ title
+    const bannerKind = event.headline ?? event.title;
+    tokens.push(token("bannerKind", bannerKind, 0, "never"));
+    // topAreas
+    const parts = topAreaTokenParts(event.forecastAreaNames, 2);
+    if (parts)
+        tokens.push(token("topAreas", parts.text, 1, "shorten", parts.shortText));
+    // areaCount
+    if (event.forecastAreaCount > 0) {
+        tokens.push(token("areaCount", `(${event.forecastAreaCount}地域)`, 1, "drop"));
+    }
+    // hypocenter
+    if (event.hypocenterName) {
+        tokens.push(token("hypocenter", event.hypocenterName, 3, "drop"));
+    }
+    // magnitude
+    if (model.magnitude) {
+        tokens.push(token("magnitude", model.magnitude, 3, "drop"));
+    }
+    return tokens;
+}
+function buildVolcanoTokens(event, model) {
+    const tokens = [];
+    const headType = event.type;
+    tokens.push(token("severity", model.severity, 0, "never"));
+    if (headType === "VFVO50" || headType.startsWith("VFSV")) {
+        // 火山警報
+        tokens.push(token("type", event.title, 0, "shorten"));
+        if (event.volcanoName)
+            tokens.push(token("volcanoName", event.volcanoName, 0, "never"));
+        if (event.alertLevel != null) {
+            tokens.push(token("alertLevel", `Lv${event.alertLevel}`, 0, "shorten"));
+        }
+        if (event.areaCount > 0) {
+            tokens.push(token("areaCount", `対象${event.areaCount}市町村`, 2, "drop"));
+        }
+    }
+    else if (headType === "VFVO52" || headType === "VFVO56") {
+        // 噴火速報 / 噴火情報
+        tokens.push(token("type", event.title, 0, "never"));
+        if (event.volcanoName)
+            tokens.push(token("volcanoName", event.volcanoName, 0, "never"));
+        // phenomenon/plumeHeight: try to extract from raw if available
+        // Phase 3 - use available info only
+    }
+    else if (headType === "VFVO53" || headType === "VFVO54" || headType === "VFVO55") {
+        // 降灰
+        tokens.push(token("type", event.title, 0, "shorten"));
+        if (event.volcanoName)
+            tokens.push(token("volcanoName", event.volcanoName, 0, "never"));
+        if (event.areaCount > 0) {
+            tokens.push(token("areaCount", `対象${event.areaCount}地域`, 1, "drop"));
+        }
+    }
+    else if (headType === "VFVO51" || headType === "VZVO40") {
+        // 火山テキスト
+        tokens.push(token("type", event.title, 0, "shorten"));
+        if (event.volcanoName)
+            tokens.push(token("volcanoName", event.volcanoName, 0, "never"));
+        if (event.headline) {
+            tokens.push(token("headline", event.headline, 1, "shorten"));
+        }
+        if (event.alertLevel != null) {
+            tokens.push(token("alertLevel", `Lv${event.alertLevel}`, 2, "drop"));
+        }
+    }
+    else if (headType === "VFVO60") {
+        // 噴煙流向
+        tokens.push(token("type", event.title, 0, "shorten"));
+        if (event.volcanoName)
+            tokens.push(token("volcanoName", event.volcanoName, 0, "never"));
+    }
+    else {
+        // fallback
+        tokens.push(token("type", event.title, 0, "shorten"));
+        if (event.volcanoName)
+            tokens.push(token("volcanoName", event.volcanoName, 0, "never"));
+    }
+    return tokens;
+}
+function buildSeismicTextTokens(event, model) {
+    const tokens = [];
+    tokens.push(token("severity", model.severity, 0, "never"));
+    tokens.push(token("type", event.title, 0, "shorten"));
+    if (event.headline) {
+        tokens.push(token("headline", event.headline, 1, "shorten"));
+    }
+    return tokens;
+}
+function buildLgObservationTokens(event, model) {
+    const tokens = [];
+    tokens.push(token("severity", model.severity, 0, "never"));
+    tokens.push(token("type", "長周期地震動観測情報", 0, "shorten", "長周期観測"));
+    if (event.hypocenterName) {
+        const short = shortenHypocenter(event.hypocenterName);
+        tokens.push(token("hypocenter", event.hypocenterName, 1, "shorten", short !== event.hypocenterName ? short : undefined));
+    }
+    if (model.maxLgInt) {
+        // "長周期4" → shortText "L4"
+        const lgNum = model.maxLgInt.replace("長周期", "");
+        tokens.push(token("maxLgInt", model.maxLgInt, 0, "shorten", `L${lgNum}`));
+    }
+    if (model.maxInt) {
+        tokens.push(token("maxInt", model.maxInt, 1, "shorten"));
+    }
+    const parts = topAreaTokenParts(event.observationNames, 2);
+    if (parts)
+        tokens.push(token("topAreas", parts.text, 2, "drop"));
+    if (model.magnitude) {
+        tokens.push(token("magnitude", model.magnitude, 2, "drop"));
+    }
+    if (event.depth) {
+        tokens.push(token("depth", `深さ${event.depth}`, 3, "drop"));
+    }
+    return tokens;
+}
+function buildNankaiTroughTokens(event, model) {
+    const tokens = [];
+    tokens.push(token("severity", model.severity, 0, "never"));
+    tokens.push(token("type", "南海トラフ臨時情報", 0, "shorten", "南海トラフ"));
+    if (event.headline) {
+        tokens.push(token("headline", event.headline, 1, "shorten"));
+    }
+    return tokens;
+}
+function buildRawTokens(event, model) {
+    const tokens = [];
+    tokens.push(token("severity", model.severity, 0, "never"));
+    tokens.push(token("RAW", "RAW", 0, "never"));
+    tokens.push(token("type", event.type, 0, "never"));
+    if (event.title) {
+        tokens.push(token("title", event.title, 1, "shorten"));
+    }
+    if (event.headline) {
+        tokens.push(token("headline", event.headline, 2, "drop"));
+    }
+    if (event.publishingOffice) {
+        tokens.push(token("office", event.publishingOffice, 3, "drop"));
+    }
+    return tokens;
+}
+// ── Public API ──
+function buildSummaryTokens(event, model) {
+    switch (model.domain) {
+        case "eew":
+            return buildEewTokens(event, model);
+        case "earthquake":
+            return buildEarthquakeTokens(event, model);
+        case "tsunami":
+            return buildTsunamiTokens(event, model);
+        case "volcano":
+            return buildVolcanoTokens(event, model);
+        case "seismicText":
+            return buildSeismicTextTokens(event, model);
+        case "lgObservation":
+            return buildLgObservationTokens(event, model);
+        case "nankaiTrough":
+            return buildNankaiTroughTokens(event, model);
+        case "raw":
+            return buildRawTokens(event, model);
+    }
+}

package/dist/ui/summary/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/summary/width-fit.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fitTokensToWidth = fitTokensToWidth;
+const formatter_1 = require("../formatter");
+const SEPARATOR = "  ";
+const SEPARATOR_WIDTH = 2;
+function fitTokensToWidth(tokens, maxWidth) {
+    if (tokens.length === 0)
+        return "";
+    // Step 1: Check if all tokens fit at preferred width
+    const totalPreferred = tokens.reduce((sum, t) => sum + t.preferredWidth, 0);
+    const separatorTotal = SEPARATOR_WIDTH * Math.max(0, tokens.length - 1);
+    if (totalPreferred + separatorTotal <= maxWidth) {
+        return tokens.map((t) => t.text).join(SEPARATOR);
+    }
+    // Step 2: Drop tokens by priority (4 → 3 → 2)
+    let remaining = [...tokens];
+    for (const pri of [4, 3, 2]) {
+        const currentWidth = calcTotalWidth(remaining);
+        if (currentWidth <= maxWidth)
+            break;
+        remaining = remaining.filter((t) => !(t.priority === pri && t.dropMode === "drop"));
+    }
+    // Step 3: Shorten tokens if still too wide
+    if (calcTotalWidth(remaining) > maxWidth) {
+        remaining = remaining.map((t) => {
+            if (t.dropMode === "shorten" && t.shortText != null) {
+                return { ...t, text: t.shortText };
+            }
+            return t;
+        });
+    }
+    return remaining.map((t) => t.text).join(SEPARATOR);
+}
+function calcTotalWidth(tokens) {
+    if (tokens.length === 0)
+        return 0;
+    const textWidth = tokens.reduce((sum, t) => sum + (0, formatter_1.visualWidth)(t.text), 0);
+    const sepWidth = SEPARATOR_WIDTH * (tokens.length - 1);
+    return textWidth + sepWidth;
+}

package/dist/ui/summary-interval-formatter.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSparkline = buildSparkline;
+exports.formatSummaryInterval = formatSummaryInterval;
+const chalk_1 = __importDefault(require("chalk"));
+const summary_tracker_1 = require("../engine/messages/summary-tracker");
+/** sparkline で使う8段階の文字 */
+const SPARK_CHARS = "▁▂▃▄▅▆▇█";
+/** ドメインの表示ラベル */
+const DOMAIN_LABELS = {
+    eew: "EEW",
+    earthquake: "地震",
+    tsunami: "津波",
+    seismicText: "テキスト",
+    lgObservation: "長周期",
+    volcano: "火山",
+    nankaiTrough: "南海トラフ",
+    raw: "その他",
+};
+/**
+ * sparklineData (数値配列) から sparkline 文字列を生成する。
+ * 最大値に対する比率で8段階の文字を選択する。全部0なら ▁ の繰り返し。
+ */
+function buildSparkline(data) {
+    const max = Math.max(...data);
+    if (max === 0) {
+        return SPARK_CHARS[0].repeat(data.length);
+    }
+    return data
+        .map((v) => {
+        const ratio = v / max;
+        const idx = Math.min(Math.round(ratio * (SPARK_CHARS.length - 1)), SPARK_CHARS.length - 1);
+        return SPARK_CHARS[idx];
+    })
+        .join("");
+}
+/**
+ * 要約行をフォーマットする。
+ * @param snapshot SummaryWindowTracker のスナップショット
+ * @param intervalMinutes 要約間隔(分)
+ * @param sparkline sparkline を含めるか
+ */
+function formatSummaryInterval(snapshot, intervalMinutes, sparkline) {
+    const parts = [];
+    // ドメイン別件数
+    const domainParts = [];
+    for (const [domain, count] of Object.entries(snapshot.byDomain)) {
+        if (count > 0) {
+            const label = DOMAIN_LABELS[domain] ?? domain;
+            domainParts.push(`${label} ${count}件`);
+        }
+    }
+    // ヘッダ
+    const header = chalk_1.default.gray(`── ${intervalMinutes}分要約 ──`);
+    const domainStr = domainParts.length > 0
+        ? domainParts.join(chalk_1.default.gray(" | "))
+        : chalk_1.default.gray("受信なし");
+    // maxInt
+    const maxIntStr = snapshot.maxIntSeen != null
+        ? chalk_1.default.gray(` (最大${snapshot.maxIntSeen})`)
+        : "";
+    parts.push(`${header} ${domainStr}${maxIntStr}`);
+    // sparkline 行
+    if (sparkline) {
+        const sparkStr = buildSparkline(snapshot.sparklineData);
+        parts.push(chalk_1.default.gray("受信 ") + sparkStr + chalk_1.default.gray(`  (${summary_tracker_1.WINDOW_MINUTES}分)`));
+    }
+    return parts.join("\n");
+}

package/dist/ui/test-samples.js

@@ -116,6 +116,7 @@ exports.SAMPLE_EARTHQUAKE = {
     reportDateTime: "2024/01/01 00:00:00",
     headline: "１日００時００分ころ、地震がありました。",
     publishingOffice: "気象庁",
+    eventId: "20240101000000",
     earthquake: {
         originTime: "2024/01/01 00:00:00",
         hypocenterName: "石川県能登地方",
@@ -280,6 +281,7 @@ const FALLBACK_EARTHQUAKE_WARNING = {
     reportDateTime: "2024/01/02 10:00:00",
     headline: "長野県北部で震度4を観測しました。",
     publishingOffice: "気象庁",
+    eventId: null,
     earthquake: {
         originTime: "2024/01/02 09:58:00",
         hypocenterName: "長野県北部",
@@ -305,6 +307,7 @@ const FALLBACK_EARTHQUAKE_CANCEL = {
     reportDateTime: "2024/01/02 10:05:00",
     headline: "先ほどの地震情報を取り消します。",
     publishingOffice: "気象庁",
+    eventId: null,
     isTest: true,
 };
 const FALLBACK_EARTHQUAKE_ENCHI = {
@@ -314,6 +317,7 @@ const FALLBACK_EARTHQUAKE_ENCHI = {
     reportDateTime: "2024/01/03 08:20:00",
     headline: "日本への津波の影響はありません。",
     publishingOffice: "気象庁",
+    eventId: null,
     earthquake: {
         originTime: "2024/01/03 08:10:00",
         hypocenterName: "台湾付近",
@@ -332,6 +336,7 @@ const FALLBACK_EARTHQUAKE_SHINDO = {
     reportDateTime: "2024/01/04 14:00:00",
     headline: "各地の震度に関する情報です。",
     publishingOffice: "気象庁",
+    eventId: null,
     intensity: {
         maxInt: "5弱",
         areas: [
@@ -349,6 +354,7 @@ const FALLBACK_EARTHQUAKE_LG = {
     reportDateTime: "2024/01/05 19:30:00",
     headline: "関東地方で長周期地震動階級4を観測しました。",
     publishingOffice: "気象庁",
+    eventId: null,
     earthquake: {
         originTime: "2024/01/05 19:27:00",
         hypocenterName: "千葉県北西部",

package/dist/ui/theme.js

@@ -40,6 +40,8 @@ exports.DEFAULT_ROLES = exports.DEFAULT_PALETTE = void 0;
 exports.hexToRgb = hexToRgb;
 exports.rgbToHex = rgbToHex;
 exports.resolveTheme = resolveTheme;
+exports.setNightMode = setNightMode;
+exports.isNightMode = isNightMode;
 exports.getThemePath = getThemePath;
 exports.loadTheme = loadTheme;
 exports.loadThemeFromPath = loadThemeFromPath;
@@ -58,6 +60,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../config");
+const night_overlay_1 = require("./night-overlay");
 /** RoleStyleDef の型ガード */
 function isRoleStyleDef(value) {
     if (typeof value === "string")
@@ -186,6 +189,15 @@ exports.DEFAULT_ROLES = {
     // volcano: バナー
     volcanoAlertBanner: { bg: "vermillion", fg: "#FFFFFF", bold: true },
     volcanoFlashBanner: { bg: "darkRed", fg: "#FFFFFF", bold: true },
+    // stats: 統計表示
+    statsMuted: "gray",
+    statsCount: { fg: "sky", bold: true },
+    statsCategoryEew: { fg: "sky", bold: true },
+    statsCategoryEarthquake: { fg: "blue", bold: true },
+    statsCategoryTsunami: { fg: "blueGreen", bold: true },
+    statsCategoryVolcano: { fg: "orange", bold: true },
+    statsCategoryNankaiTrough: { fg: "vermillion", bold: true },
+    statsCategoryOther: { fg: "gray", bold: true },
 };
 /** ロール名の一覧 */
 const ROLE_NAMES = Object.keys(exports.DEFAULT_ROLES);
@@ -352,7 +364,29 @@ function buildDefaultResolvedTheme() {
     return deepFreezeTheme(theme);
 }
 // ── モジュール状態 ──
-let currentTheme = buildDefaultResolvedTheme();
+let baseTheme = buildDefaultResolvedTheme();
+let nightModeEnabled = false;
+let currentTheme = baseTheme;
+// ── night mode ──
+/** baseTheme に night overlay を適用して currentTheme を更新する */
+function rebuildActiveTheme() {
+    if (nightModeEnabled) {
+        currentTheme = deepFreezeTheme((0, night_overlay_1.applyNightOverlay)(baseTheme));
+    }
+    else {
+        currentTheme = baseTheme;
+    }
+    chalkCache.clear();
+}
+/** ナイトモードの ON/OFF を設定し、テーマを再構築する */
+function setNightMode(enabled) {
+    nightModeEnabled = enabled;
+    rebuildActiveTheme();
+}
+/** ナイトモードが有効かどうかを返す */
+function isNightMode() {
+    return nightModeEnabled;
+}
 // ── パス解決 ──
 /** theme.json のパスを返す */
 function getThemePath() {
@@ -367,14 +401,16 @@ function loadTheme() {
 function loadThemeFromPath(themePath) {
     chalkCache.clear();
     if (!fs.existsSync(themePath)) {
-        currentTheme = buildDefaultResolvedTheme();
+        baseTheme = buildDefaultResolvedTheme();
+        rebuildActiveTheme();
         return [];
     }
     try {
         const raw = fs.readFileSync(themePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (typeof parsed !== "object" || parsed == null || Array.isArray(parsed)) {
-            currentTheme = buildDefaultResolvedTheme();
+            baseTheme = buildDefaultResolvedTheme();
+            rebuildActiveTheme();
             return ["theme.json の形式が不正です。デフォルトテーマを使用します。"];
         }
         const { themeFile, warnings: sanitizeWarnings } = sanitizeThemeInput(parsed);
@@ -382,11 +418,13 @@ function loadThemeFromPath(themePath) {
             palette: exports.DEFAULT_PALETTE,
             roles: exports.DEFAULT_ROLES,
         });
-        currentTheme = deepFreezeTheme(theme);
+        baseTheme = deepFreezeTheme(theme);
+        rebuildActiveTheme();
         return [...sanitizeWarnings, ...warnings];
     }
     catch (err) {
-        currentTheme = buildDefaultResolvedTheme();
+        baseTheme = buildDefaultResolvedTheme();
+        rebuildActiveTheme();
         if (err instanceof SyntaxError) {
             return ["theme.json のJSONパースに失敗しました。デフォルトテーマを使用します。"];
         }

package/dist/ui/tip-shuffler.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TipShuffler = void 0;
+const waiting_tips_1 = require("./waiting-tips");
+/**
+ * 待機中Tipのエポックデッキ生成シャッフラ。
+ *
+ * - カテゴリごとにシャッフルした後、同カテゴリ連続を避けつつ
+ *   全Tipを1エポック分のデッキにインターリーブする。
+ * - デッキを使い切ったら自動で再構築する。
+ * - タイミング制御は持たず、`next()` で次のTipを返すだけの純粋な順序供給器。
+ */
+class TipShuffler {
+    deck = [];
+    rng;
+    constructor(rng = Math.random) {
+        this.rng = rng;
+        this.rebuildDeck();
+    }
+    /** 次のTipを返す。デッキが空なら自動再構築。 */
+    next() {
+        if (this.deck.length === 0) {
+            this.rebuildDeck();
+        }
+        return this.deck.shift();
+    }
+    rebuildDeck() {
+        // 1. カテゴリごとにシャッフル
+        const buckets = [];
+        for (let ci = 0; ci < waiting_tips_1.TIP_CATEGORIES.length; ci++) {
+            const shuffled = this.shuffle([...waiting_tips_1.TIP_CATEGORIES[ci].tips]);
+            for (const tip of shuffled) {
+                buckets.push({ categoryIndex: ci, tip });
+            }
+        }
+        // 2. インターリーブ: 同カテゴリ連続を避けつつデッキ構築
+        this.deck = this.interleave(buckets);
+    }
+    /** 同カテゴリ連続を避けつつ全アイテムをインターリーブする */
+    interleave(items) {
+        // カテゴリごとのキューに分割
+        const queues = new Map();
+        for (const item of items) {
+            if (!queues.has(item.categoryIndex)) {
+                queues.set(item.categoryIndex, []);
+            }
+            queues.get(item.categoryIndex).push(item.tip);
+        }
+        const result = [];
+        let lastCategory = -1;
+        while (queues.size > 0) {
+            // 直前カテゴリ以外で残りがあるカテゴリから選択
+            const candidates = [...queues.keys()].filter((k) => k !== lastCategory);
+            if (candidates.length === 0) {
+                // 1カテゴリしか残っていない場合はそのまま流し込む
+                const remaining = [...queues.keys()][0];
+                result.push(...queues.get(remaining));
+                queues.delete(remaining);
+                break;
+            }
+            // ランダムに1カテゴリ選択
+            const chosen = candidates[Math.floor(this.rng() * candidates.length)];
+            const queue = queues.get(chosen);
+            result.push(queue.shift());
+            lastCategory = chosen;
+            if (queue.length === 0) {
+                queues.delete(chosen);
+            }
+        }
+        return result;
+    }
+    /** Fisher-Yates シャッフル */
+    shuffle(arr) {
+        for (let i = arr.length - 1; i > 0; i--) {
+            const j = Math.floor(this.rng() * (i + 1));
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+        return arr;
+    }
+}
+exports.TipShuffler = TipShuffler;