@sayue_ltr/fleq 1.50.0 → 1.51.0

package/dist/engine/messages/message-router.js

@@ -1,53 +1,22 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMessageHandler = createMessageHandler;
-const telegram_parser_1 = require("../../dmdata/telegram-parser");
-const volcano_parser_1 = require("../../dmdata/volcano-parser");
-const formatter_1 = require("../../ui/formatter");
-const eew_formatter_1 = require("../../ui/eew-formatter");
-const earthquake_formatter_1 = require("../../ui/earthquake-formatter");
-const volcano_formatter_1 = require("../../ui/volcano-formatter");
-const volcano_vfvo53_aggregator_1 = require("./volcano-vfvo53-aggregator");
+const chalk_1 = __importDefault(require("chalk"));
 const eew_tracker_1 = require("../eew/eew-tracker");
 const eew_logger_1 = require("../eew/eew-logger");
 const notifier_1 = require("../notification/notifier");
 const tsunami_state_1 = require("./tsunami-state");
 const volcano_state_1 = require("./volcano-state");
-const volcano_presentation_1 = require("../notification/volcano-presentation");
-const log = __importStar(require("../../logger"));
+const telegram_stats_1 = require("./telegram-stats");
+const summary_tracker_1 = require("./summary-tracker");
+const process_message_1 = require("../presentation/processors/process-message");
+const to_presentation_event_1 = require("../presentation/events/to-presentation-event");
+const pipeline_1 = require("../filter-template/pipeline");
+const diff_store_1 = require("../presentation/diff-store");
+const volcano_route_handler_1 = require("./volcano-route-handler");
 /**
  * classification と head.type から処理ルートを判定する。
  * ルーティング優先順位:
@@ -86,169 +55,130 @@ function classifyMessage(classification, headType) {
     }
     return "raw";
 }
-// ── ルート別処理 ──
-/** EEW パス: パース → 重複判定 → ログ → 表示 → 通知 */
-function handleEew(msg, eewTracker, eewLogger, notifier) {
-    const eewInfo = (0, telegram_parser_1.parseEewTelegram)(msg);
-    if (!eewInfo) {
-        (0, formatter_1.displayRawHeader)(msg);
-        return;
-    }
-    const result = eewTracker.update(eewInfo);
-    if (result.isDuplicate) {
-        log.debug(`EEW 重複報スキップ: EventID=${eewInfo.eventId} 第${eewInfo.serial}報`);
-        return;
-    }
-    // ログ記録 (非重複報のみ)
-    eewLogger.logReport(eewInfo, result);
-    // 取消報の場合はログを閉じる
-    if (result.isCancelled && eewInfo.eventId) {
-        eewLogger.closeEvent(eewInfo.eventId, "取消");
-    }
-    // 最終報の場合はログを閉じ、トラッカーのイベントを終了扱いにする
-    if (eewInfo.nextAdvisory && eewInfo.eventId && !result.isCancelled) {
-        eewLogger.closeEvent(eewInfo.eventId, "最終報");
-        eewTracker.finalizeEvent(eewInfo.eventId);
-    }
-    (0, eew_formatter_1.displayEewInfo)(eewInfo, {
-        activeCount: result.activeCount,
-        diff: result.diff,
-        colorIndex: result.colorIndex,
-    });
-    notifier.notifyEew(eewInfo, result);
-}
-/** テキスト系 (VXSE56/VXSE60/VZSE40) パス */
-function handleSeismicText(msg, notifier) {
-    const textInfo = (0, telegram_parser_1.parseSeismicTextTelegram)(msg);
-    if (textInfo) {
-        (0, earthquake_formatter_1.displaySeismicTextInfo)(textInfo);
-        notifier.notifySeismicText(textInfo);
-    }
-    else {
-        (0, formatter_1.displayRawHeader)(msg);
-    }
-}
-/** 長周期地震動観測情報 (VXSE62) パス */
-function handleLgObservation(msg, notifier) {
-    const lgInfo = (0, telegram_parser_1.parseLgObservationTelegram)(msg);
-    if (lgInfo) {
-        (0, earthquake_formatter_1.displayLgObservationInfo)(lgInfo);
-        notifier.notifyLgObservation(lgInfo);
-    }
-    else {
-        (0, formatter_1.displayRawHeader)(msg);
-    }
-}
-/** 地震情報 (VXSE51/52/53/61 等) パス */
-function handleEarthquake(msg, notifier) {
-    const eqInfo = (0, telegram_parser_1.parseEarthquakeTelegram)(msg);
-    if (eqInfo) {
-        (0, earthquake_formatter_1.displayEarthquakeInfo)(eqInfo);
-        notifier.notifyEarthquake(eqInfo);
-    }
-    else {
-        (0, formatter_1.displayRawHeader)(msg);
-    }
-}
-/** 津波情報 (VTSE41/51/52) パス */
-function handleTsunami(msg, notifier, tsunamiState) {
-    const tsunamiInfo = (0, telegram_parser_1.parseTsunamiTelegram)(msg);
-    if (tsunamiInfo) {
-        // VTSE41 (津波警報・注意報) の場合のみ状態を更新
-        if (msg.head.type === "VTSE41") {
-            tsunamiState.update(tsunamiInfo);
-        }
-        (0, earthquake_formatter_1.displayTsunamiInfo)(tsunamiInfo);
-        notifier.notifyTsunami(tsunamiInfo);
-    }
-    else {
-        (0, formatter_1.displayRawHeader)(msg);
+// ── dispatch helpers ──
+/** 通知のみ実行 (filter 非適用) */
+function dispatchNotify(outcome, notifier) {
+    switch (outcome.domain) {
+        case "eew":
+            notifier.notifyEew(outcome.parsed, outcome.eewResult);
+            break;
+        case "earthquake":
+            notifier.notifyEarthquake(outcome.parsed);
+            break;
+        case "seismicText":
+            notifier.notifySeismicText(outcome.parsed);
+            break;
+        case "lgObservation":
+            notifier.notifyLgObservation(outcome.parsed);
+            break;
+        case "tsunami":
+            notifier.notifyTsunami(outcome.parsed);
+            break;
+        case "nankaiTrough":
+            notifier.notifyNankaiTrough(outcome.parsed);
+            break;
+        // raw: 通知なし
+        // volcano: VolcanoRouteHandler が通知を担当
     }
 }
-/** 南海トラフ関連 (VYSE50/51/52/60) パス */
-function handleNankaiTrough(msg, notifier) {
-    const nankaiInfo = (0, telegram_parser_1.parseNankaiTroughTelegram)(msg);
-    if (nankaiInfo) {
-        (0, earthquake_formatter_1.displayNankaiTroughInfo)(nankaiInfo);
-        notifier.notifyNankaiTrough(nankaiInfo);
-    }
-    else {
-        (0, formatter_1.displayRawHeader)(msg);
-    }
-}
-/** 火山情報パス (aggregator 経由) */
-function handleVolcano(msg, vfvo53Aggregator) {
-    const volcanoInfo = (0, volcano_parser_1.parseVolcanoTelegram)(msg);
-    if (volcanoInfo) {
-        vfvo53Aggregator.handle(volcanoInfo);
-    }
-    else {
-        (0, formatter_1.displayRawHeader)(msg);
+/** outcome.stats に基づいて統計を記録する */
+function recordStats(outcome, stats) {
+    if (outcome.stats.shouldRecord) {
+        stats.record({
+            headType: outcome.headType,
+            category: outcome.statsCategory,
+            eventId: outcome.stats.eventId,
+        });
+    }
+    if (outcome.stats.maxIntUpdate) {
+        const u = outcome.stats.maxIntUpdate;
+        stats.updateMaxInt(u.eventId, u.maxInt, u.headType);
     }
 }
 /** 受信データのハンドリング */
-function createMessageHandler() {
+function createMessageHandler(options) {
+    const pipeline = options?.pipeline ?? { filter: null, template: null, focus: null };
+    const display = options?.display;
     const eewLogger = new eew_logger_1.EewEventLogger();
     const notifier = new notifier_1.Notifier();
     const tsunamiState = new tsunami_state_1.TsunamiStateHolder();
     const volcanoState = new volcano_state_1.VolcanoStateHolder();
+    const stats = new telegram_stats_1.TelegramStats();
+    const summaryTracker = new summary_tracker_1.SummaryWindowTracker();
+    const diffStore = new diff_store_1.PresentationDiffStore();
     const eewTracker = new eew_tracker_1.EewTracker({
         onCleanup: (eventId) => {
             eewLogger.closeEvent(eventId, "タイムアウト");
         },
     });
-    // VFVO53 バッチ集約器
-    const vfvo53Aggregator = new volcano_vfvo53_aggregator_1.VolcanoVfvo53Aggregator(
-    // emitSingle: 従来の単発処理パイプライン (opts?.notify === false なら通知スキップ)
-    (info, opts) => {
-        const presentation = (0, volcano_presentation_1.resolveVolcanoPresentation)(info, volcanoState);
-        (0, volcano_formatter_1.displayVolcanoInfo)(info, presentation);
-        volcanoState.update(info);
-        if (opts?.notify !== false) {
-            notifier.notifyVolcano(info, presentation);
+    const processDeps = {
+        eewTracker,
+        eewLogger,
+        tsunamiState,
+        volcanoState,
+    };
+    /**
+     * 共通の表示パイプライン処理。
+     * filter/diffStore/summaryTracker/focus/template/compact の6ステップを一元的に実行する。
+     * @returns true なら表示済み。false ならフィルタで非表示。
+     */
+    function runDisplayPipeline(outcome, displayFn) {
+        const rawEvent = (0, to_presentation_event_1.toPresentationEvent)(outcome);
+        const event = diffStore.apply(rawEvent);
+        const displayed = (0, pipeline_1.shouldDisplay)(event, pipeline);
+        summaryTracker.record(event, displayed);
+        if (!displayed) {
+            return false;
+        }
+        const isFocused = pipeline.focus == null || pipeline.focus(event);
+        if (!isFocused && display) {
+            console.log(chalk_1.default.dim(display.renderSummaryLine(event)));
+            return true;
+        }
+        const templateOutput = (0, pipeline_1.renderTemplate)(event, pipeline);
+        if (templateOutput != null) {
+            console.log(templateOutput);
+            return true;
         }
-    }, 
-    // emitBatch: バッチ専用処理
-    (batch, opts) => {
-        const presentation = (0, volcano_presentation_1.resolveVolcanoBatchPresentation)(batch);
-        (0, volcano_formatter_1.displayVolcanoAshfallBatch)(batch, presentation);
-        if (opts.notify) {
-            notifier.notifyVolcanoBatch(batch, presentation);
+        if (display && display.getDisplayMode() === "compact") {
+            console.log(display.renderSummaryLine(event));
+            return true;
         }
+        displayFn();
+        return true;
+    }
+    // 火山ルートハンドラ
+    const volcanoHandler = new volcano_route_handler_1.VolcanoRouteHandler({
+        volcanoState,
+        notifier,
+        runDisplayPipeline,
+        display,
     });
     const handler = (msg) => {
         // XML電文でない場合はヘッダ情報のみ表示
         if (msg.format !== "xml" || !msg.head.xml) {
-            (0, formatter_1.displayRawHeader)(msg);
+            display?.displayRawHeader(msg);
             return;
         }
         const route = classifyMessage(msg.classification, msg.head.type);
-        switch (route) {
-            case "eew":
-                handleEew(msg, eewTracker, eewLogger, notifier);
-                break;
-            case "seismicText":
-                handleSeismicText(msg, notifier);
-                break;
-            case "lgObservation":
-                handleLgObservation(msg, notifier);
-                break;
-            case "earthquake":
-                handleEarthquake(msg, notifier);
-                break;
-            case "tsunami":
-                handleTsunami(msg, notifier, tsunamiState);
-                break;
-            case "nankaiTrough":
-                handleNankaiTrough(msg, notifier);
-                break;
-            case "volcano":
-                handleVolcano(msg, vfvo53Aggregator);
-                break;
-            case "raw":
-                (0, formatter_1.displayRawHeader)(msg);
-                break;
+        // 火山は VolcanoRouteHandler に委譲
+        if (route === "volcano") {
+            volcanoHandler.handle(msg);
+            stats.record({
+                headType: msg.head.type,
+                category: (0, telegram_stats_1.routeToCategory)(route),
+                eventId: msg.xmlReport?.head.eventId ?? null,
+            });
+            return;
+        }
+        // 火山以外: processMessage → recordStats → dispatchNotify → runDisplayPipeline
+        const outcome = (0, process_message_1.processMessage)(msg, route, processDeps);
+        if (outcome == null) {
+            return;
         }
+        recordStats(outcome, stats);
+        dispatchNotify(outcome, notifier);
+        runDisplayPipeline(outcome, () => display?.displayOutcome(outcome));
     };
     return {
         handler,
@@ -256,6 +186,8 @@ function createMessageHandler() {
         notifier,
         tsunamiState,
         volcanoState,
-        flushAndDisposeVolcanoBuffer: () => vfvo53Aggregator.flushAndDispose(),
+        stats,
+        summaryTracker,
+        flushAndDisposeVolcanoBuffer: () => volcanoHandler.flushAndDispose(),
     };
 }

package/dist/engine/messages/summary-tracker.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummaryWindowTracker = exports.WINDOW_MINUTES = void 0;
+const intensity_1 = require("../../utils/intensity");
+/** リングバッファの窓幅(分) */
+exports.WINDOW_MINUTES = 30;
+const MINUTE_MS = 60_000;
+/** 直近30分のリングバッファで受信統計を追跡する */
+class SummaryWindowTracker {
+    buckets = [];
+    /** イベントを記録する */
+    record(event, matched, now) {
+        const ts = now ?? Date.now();
+        this.pruneOld(ts);
+        const bucket = this.getOrCreateBucket(ts);
+        bucket.received++;
+        if (matched) {
+            bucket.matched++;
+        }
+        bucket.byDomain[event.domain] = (bucket.byDomain[event.domain] ?? 0) + 1;
+        // maxInt 追跡 (バケット単位で記録)
+        if (event.maxInt != null) {
+            const rank = (0, intensity_1.intensityToRank)(event.maxInt);
+            if (rank > bucket.maxIntRank) {
+                bucket.maxIntRank = rank;
+                bucket.maxIntStr = event.maxInt;
+            }
+        }
+    }
+    /** 現在のスナップショットを取得する */
+    getSnapshot(now) {
+        const ts = now ?? Date.now();
+        this.pruneOld(ts);
+        let totalReceived = 0;
+        let totalMatched = 0;
+        const byDomain = {};
+        for (const bucket of this.buckets) {
+            totalReceived += bucket.received;
+            totalMatched += bucket.matched;
+            for (const [domain, count] of Object.entries(bucket.byDomain)) {
+                byDomain[domain] = (byDomain[domain] ?? 0) + (count ?? 0);
+            }
+        }
+        // maxInt を残存バケットから再計算 (30分窓で減衰)
+        let maxIntRank = 0;
+        let maxIntStr = null;
+        for (const bucket of this.buckets) {
+            if (bucket.maxIntRank > maxIntRank) {
+                maxIntRank = bucket.maxIntRank;
+                maxIntStr = bucket.maxIntStr;
+            }
+        }
+        // sparklineData: 30スロット (古い順 → 新しい順)
+        const sparklineData = this.buildSparklineData(ts);
+        return {
+            totalReceived,
+            totalMatched,
+            byDomain,
+            maxIntSeen: maxIntStr,
+            sparklineData,
+        };
+    }
+    /** 統計をクリアする */
+    clear() {
+        this.buckets = [];
+    }
+    /** 30分超の古いバケットを除去する */
+    pruneOld(now) {
+        const cutoff = this.minuteStart(now) - (exports.WINDOW_MINUTES - 1) * MINUTE_MS;
+        this.buckets = this.buckets.filter((b) => b.minuteStartMs >= cutoff);
+    }
+    /** 指定時刻のバケットを取得、なければ作成 */
+    getOrCreateBucket(now) {
+        const ms = this.minuteStart(now);
+        const existing = this.buckets.find((b) => b.minuteStartMs === ms);
+        if (existing)
+            return existing;
+        const bucket = {
+            minuteStartMs: ms,
+            received: 0,
+            matched: 0,
+            byDomain: {},
+            maxIntRank: 0,
+            maxIntStr: null,
+        };
+        this.buckets.push(bucket);
+        return bucket;
+    }
+    /** 30スロットの sparkline データを生成する (古い順) */
+    buildSparklineData(now) {
+        const currentMinuteStart = this.minuteStart(now);
+        const data = new Array(exports.WINDOW_MINUTES).fill(0);
+        for (const bucket of this.buckets) {
+            const slotIndex = Math.round((bucket.minuteStartMs - (currentMinuteStart - (exports.WINDOW_MINUTES - 1) * MINUTE_MS)) / MINUTE_MS);
+            if (slotIndex >= 0 && slotIndex < exports.WINDOW_MINUTES) {
+                data[slotIndex] = bucket.received;
+            }
+        }
+        return data;
+    }
+    /** タイムスタンプを分の開始に丸める */
+    minuteStart(ts) {
+        return Math.floor(ts / MINUTE_MS) * MINUTE_MS;
+    }
+}
+exports.SummaryWindowTracker = SummaryWindowTracker;

package/dist/engine/messages/telegram-stats.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramStats = void 0;
+exports.routeToCategory = routeToCategory;
+/** Route → StatsCategory 変換 */
+function routeToCategory(route) {
+    switch (route) {
+        case "eew": return "eew";
+        case "earthquake":
+        case "seismicText":
+        case "lgObservation": return "earthquake";
+        case "tsunami": return "tsunami";
+        case "volcano": return "volcano";
+        case "nankaiTrough": return "nankaiTrough";
+        default: return "other";
+    }
+}
+/** 最大震度 headType → priority マッピング */
+const MAX_INT_PRIORITY = {
+    VXSE53: 3,
+    VXSE61: 2,
+    VXSE51: 1,
+};
+/** Set/Map のサイズ上限 */
+const MAX_EVENT_ENTRIES = 1000;
+/** 上限超過時に削除するエントリ数 (バッチ削除で頻繁な削除を回避) */
+const EVICT_BATCH_SIZE = 100;
+/** Set のサイズ上限を適用する。超過時は挿入順で古い方から削除する。 */
+function evictOldestFromSet(set, maxSize) {
+    if (set.size <= maxSize)
+        return;
+    let toRemove = set.size - maxSize + EVICT_BATCH_SIZE;
+    for (const item of set) {
+        if (toRemove <= 0)
+            break;
+        set.delete(item);
+        toRemove--;
+    }
+}
+/** Map のサイズ上限を適用する。超過時は挿入順で古い方から削除する。 */
+function evictOldestFromMap(map, maxSize) {
+    if (map.size <= maxSize)
+        return;
+    let toRemove = map.size - maxSize + EVICT_BATCH_SIZE;
+    for (const key of map.keys()) {
+        if (toRemove <= 0)
+            break;
+        map.delete(key);
+        toRemove--;
+    }
+}
+/** セッション中の電文受信統計を管理する */
+class TelegramStats {
+    startTime;
+    countByType = new Map();
+    categoryByType = new Map();
+    eewEventIds = new Set();
+    earthquakeMaxIntByEvent = new Map();
+    constructor(startTime) {
+        this.startTime = startTime ?? new Date();
+    }
+    /** headType カウント加算。EEW の場合は eventId を Set に追加 */
+    record(rec) {
+        this.countByType.set(rec.headType, (this.countByType.get(rec.headType) ?? 0) + 1);
+        // headType → category の対応は固定なので初回のみ登録する
+        if (!this.categoryByType.has(rec.headType)) {
+            this.categoryByType.set(rec.headType, rec.category);
+        }
+        if (rec.category === "eew" && rec.eventId != null) {
+            this.eewEventIds.add(rec.eventId);
+            evictOldestFromSet(this.eewEventIds, MAX_EVENT_ENTRIES);
+        }
+    }
+    /**
+     * 地震イベントの代表最大震度を更新する。
+     * 認識する headType: VXSE53 (priority 3), VXSE61 (priority 2), VXSE51 (priority 1)。
+     * 未知の headType は priority 0 として扱う。
+     */
+    updateMaxInt(eventId, maxInt, headType) {
+        const priority = MAX_INT_PRIORITY[headType] ?? 0;
+        const existing = this.earthquakeMaxIntByEvent.get(eventId);
+        if (existing == null || priority >= existing.priority) {
+            this.earthquakeMaxIntByEvent.set(eventId, { maxInt, priority });
+            evictOldestFromMap(this.earthquakeMaxIntByEvent, MAX_EVENT_ENTRIES);
+        }
+    }
+    /** 表示用の読み取り専用スナップショットを返す */
+    getSnapshot() {
+        let totalCount = 0;
+        for (const count of this.countByType.values()) {
+            totalCount += count;
+        }
+        return {
+            startTime: new Date(this.startTime),
+            countByType: new Map(this.countByType),
+            categoryByType: new Map(this.categoryByType),
+            eewEventCount: this.eewEventIds.size,
+            earthquakeMaxIntByEvent: new Map([...this.earthquakeMaxIntByEvent.entries()].map(([k, v]) => [k, v.maxInt])),
+            totalCount,
+        };
+    }
+}
+exports.TelegramStats = TelegramStats;

package/dist/engine/messages/volcano-route-handler.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * 火山電文のルーティング処理を一元管理するハンドラ。
+ *
+ * 火山は VFVO53 アグリゲータによるバッチ集約があるため、
+ * 他ドメインの processMessage() → outcome → display の線形フローとは異なる。
+ * このハンドラが火山の パース → キャッシュ → 集約 → 通知 → 表示 を担当する。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolcanoRouteHandler = void 0;
+const volcano_parser_1 = require("../../dmdata/volcano-parser");
+const volcano_vfvo53_aggregator_1 = require("./volcano-vfvo53-aggregator");
+const volcano_presentation_1 = require("../notification/volcano-presentation");
+const process_volcano_1 = require("../presentation/processors/process-volcano");
+// ── 定数 ──
+const VOLCANO_CACHE_TTL_MS = 10 * 60 * 1000; // 10分
+// ── 本体 ──
+class VolcanoRouteHandler {
+    volcanoState;
+    notifier;
+    runDisplayPipeline;
+    display;
+    aggregator;
+    msgCache = new Map();
+    constructor(deps) {
+        this.volcanoState = deps.volcanoState;
+        this.notifier = deps.notifier;
+        this.runDisplayPipeline = deps.runDisplayPipeline;
+        this.display = deps.display;
+        this.aggregator = new volcano_vfvo53_aggregator_1.VolcanoVfvo53Aggregator((info, opts) => this.emitSingle(info, opts), (batch, opts) => this.emitBatch(batch, opts));
+    }
+    /**
+     * 火山電文を処理する。
+     * @returns パース成功なら ParsedVolcanoInfo (統計記録用)、失敗なら null。
+     */
+    handle(msg) {
+        this.pruneMsgCache();
+        const volcanoInfo = (0, volcano_parser_1.parseVolcanoTelegram)(msg);
+        if (!volcanoInfo)
+            return null;
+        this.msgCache.set(volcanoInfo.volcanoCode, { msg, cachedAt: Date.now() });
+        this.aggregator.handle(volcanoInfo);
+        return volcanoInfo;
+    }
+    /** 保留中の火山バッファを flush してリソースを破棄する */
+    flushAndDispose() {
+        this.aggregator.flushAndDispose();
+    }
+    // ── private: emit callbacks ──
+    emitSingle(info, opts) {
+        const cacheEntry = this.msgCache.get(info.volcanoCode);
+        const cachedMsg = cacheEntry?.msg;
+        const outcome = cachedMsg
+            ? (0, process_volcano_1.buildVolcanoOutcome)(cachedMsg, info, this.volcanoState)
+            : null;
+        const presentation = (0, volcano_presentation_1.resolveVolcanoPresentation)(info, this.volcanoState);
+        this.volcanoState.update(info);
+        // 通知は filter 非適用
+        if (opts?.notify !== false) {
+            this.notifier.notifyVolcano(info, presentation);
+        }
+        // PresentationEvent パイプライン
+        if (outcome) {
+            this.runDisplayPipeline(outcome, () => this.display?.displayVolcano(info, presentation));
+        }
+        else {
+            // msg キャッシュがない場合はフォールバック表示
+            this.display?.displayVolcano(info, presentation);
+        }
+        this.msgCache.delete(info.volcanoCode);
+    }
+    emitBatch(batch, opts) {
+        const presentation = (0, volcano_presentation_1.resolveVolcanoBatchPresentation)(batch);
+        if (opts.notify) {
+            this.notifier.notifyVolcanoBatch(batch, presentation);
+        }
+        const firstItem = batch.items[0];
+        const cacheEntry = firstItem ? this.msgCache.get(firstItem.volcanoCode) : undefined;
+        const cachedMsg = cacheEntry?.msg;
+        if (cachedMsg) {
+            const batchOutcome = {
+                domain: "volcano",
+                msg: cachedMsg,
+                headType: cachedMsg.head.type,
+                statsCategory: "volcano",
+                parsed: batch.items,
+                isBatch: true,
+                volcanoPresentation: presentation,
+                batchReportDateTime: batch.reportDateTime,
+                batchIsTest: batch.isTest,
+                stats: {
+                    shouldRecord: false,
+                },
+                presentation: {
+                    frameLevel: presentation.frameLevel,
+                    soundLevel: presentation.soundLevel,
+                    notifyCategory: "volcano",
+                },
+            };
+            this.runDisplayPipeline(batchOutcome, () => this.display?.displayVolcanoBatch(batch, presentation));
+        }
+        else {
+            this.display?.displayVolcanoBatch(batch, presentation);
+        }
+        this.cleanupBatchCache(batch);
+    }
+    // ── private: cache management ──
+    pruneMsgCache() {
+        const now = Date.now();
+        for (const [key, entry] of this.msgCache) {
+            if (now - entry.cachedAt > VOLCANO_CACHE_TTL_MS) {
+                this.msgCache.delete(key);
+            }
+        }
+    }
+    cleanupBatchCache(batch) {
+        for (const item of batch.items) {
+            this.msgCache.delete(item.volcanoCode);
+        }
+    }
+}
+exports.VolcanoRouteHandler = VolcanoRouteHandler;