@sayue_ltr/fleq 1.50.1 → 2.0.0

package/dist/engine/filter/type-checker.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeCheck = typeCheck;
+const field_registry_1 = require("./field-registry");
+const errors_1 = require("./errors");
+/** AST を走査し、フィールド参照と演算子の型整合を検証する */
+function typeCheck(ast, source) {
+    switch (ast.kind) {
+        case "or":
+        case "and":
+            for (const child of ast.children)
+                typeCheck(child, source);
+            break;
+        case "not":
+            typeCheck(ast.operand, source);
+            break;
+        case "truthy":
+            validateFieldExists(ast.value);
+            break;
+        case "comparison":
+            validateComparison(ast.left, ast.op, ast.right, source);
+            break;
+    }
+}
+function validateFieldExists(node) {
+    if (node.kind === "path") {
+        const name = node.segments.join(".");
+        const field = (0, field_registry_1.resolveField)(name);
+        if (field == null) {
+            throw new errors_1.FilterFieldError(name, (0, field_registry_1.fieldNames)());
+        }
+    }
+}
+function validateComparison(left, op, right, source) {
+    // パスが左辺にある場合のフィールド検証
+    if (left.kind === "path") {
+        const name = left.segments.join(".");
+        const field = (0, field_registry_1.resolveField)(name);
+        if (field == null) {
+            throw new errors_1.FilterFieldError(name, (0, field_registry_1.fieldNames)());
+        }
+        // enum 型に対する数値リテラルチェック
+        if (field.kind === "enum:intensity" && right.kind === "number") {
+            throw new errors_1.FilterTypeError(`型が不一致: ${name} ${op} ${right.value}\n` +
+                `\`${name}\` は震度文字列("1", "5-", "6+"等)で比較する。数値リテラルは使えない`);
+        }
+        if (field.kind === "enum:lgInt" && right.kind === "number") {
+            throw new errors_1.FilterTypeError(`型が不一致: ${name} ${op} ${right.value}\n` +
+                `\`${name}\` は長周期階級文字列("0"〜"4")で比較する。数値リテラルは使えない`);
+        }
+        // 順序比較の型検証
+        if (op === "<" || op === "<=" || op === ">" || op === ">=") {
+            if (!field.supportsOrder) {
+                throw new errors_1.FilterTypeError(`\`${name}\` (${field.kind}) は順序比較に対応していない`);
+            }
+        }
+        // regex 演算子の検証
+        if (op === "~" || op === "!~") {
+            if (field.kind !== "string" && field.kind !== "enum:frameLevel" && field.kind !== "enum:intensity" && field.kind !== "enum:lgInt") {
+                throw new errors_1.FilterTypeError(`\`${name}\` (${field.kind}) は正規表現マッチに対応していない`);
+            }
+            if (right.kind === "string") {
+                try {
+                    new RegExp(right.value);
+                }
+                catch {
+                    throw new errors_1.FilterTypeError(`正規表現が不正だ: "~" の右辺 "${right.value}" を解釈できない`);
+                }
+                if (isRedosRisk(right.value)) {
+                    throw new errors_1.FilterTypeError(`正規表現が危険だ: "${right.value}" は入れ子の量指定子を含んでおり、ReDoS の恐れがある`);
+                }
+            }
+        }
+        // in の検証: 右辺はリストでなければならない
+        if (op === "in") {
+            if (right.kind !== "list") {
+                throw new errors_1.FilterTypeError(`\`in\` の右辺にはリスト [...] が必要`);
+            }
+        }
+        // contains の検証
+        if (op === "contains") {
+            if (field.kind !== "string[]" && field.kind !== "number[]" && field.kind !== "string") {
+                throw new errors_1.FilterTypeError(`\`${name}\` (${field.kind}) は contains に対応していない`);
+            }
+            // 右辺はリテラル (string/number) でなければならない
+            if (right.kind !== "string" && right.kind !== "number") {
+                throw new errors_1.FilterTypeError(`\`contains\` の右辺にはリテラル (文字列または数値) が必要`);
+            }
+        }
+    }
+    // 右辺のパスも検証
+    if (right.kind === "path") {
+        validateFieldExists(right);
+    }
+}
+/**
+ * 入れ子の量指定子パターンを簡易検出して ReDoS リスクを判定する。
+ * `(a+)+`, `(a*)*`, `(a+)*` のように、量指定子を含むグループに
+ * さらに量指定子が付くケースを検出する。
+ */
+function isRedosRisk(pattern) {
+    // 量指定子(+, *, ?, {n,m})で終わるグループの直後に量指定子が来るパターン
+    return /(\+|\*|\?|\})\)(\+|\*|\?|\{)/.test(pattern);
+}

package/dist/engine/filter/types.js

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

package/dist/engine/filter-template/pipeline-controller.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineController = void 0;
+const compile_filter_1 = require("../filter/compile-filter");
+const compile_template_1 = require("../template/compile-template");
+/**
+ * FilterTemplatePipeline の状態を管理する controller。
+ * REPL はこの API 経由でのみ pipeline を変更する。
+ * getPipeline() は同一オブジェクト参照を返すため、
+ * message-router 側に渡した pipeline と常に同期する。
+ */
+class PipelineController {
+    _pipeline;
+    _filterExpr = null;
+    _templateExpr = null;
+    _focusExpr = null;
+    constructor() {
+        this._pipeline = { filter: null, template: null, focus: null };
+    }
+    /** 同一オブジェクト参照を返す。router 側と共有される。 */
+    getPipeline() {
+        return this._pipeline;
+    }
+    // --- Filter ---
+    getFilterExpr() { return this._filterExpr; }
+    /** フィルタ式をコンパイルして設定する。無効な式の場合は例外を投げる。 */
+    setFilter(expr) {
+        const predicate = (0, compile_filter_1.compileFilter)(expr);
+        this._pipeline.filter = predicate;
+        this._filterExpr = expr;
+    }
+    clearFilter() {
+        this._pipeline.filter = null;
+        this._filterExpr = null;
+    }
+    // --- Template ---
+    getTemplateExpr() { return this._templateExpr; }
+    /** テンプレート式をコンパイルして設定する。 */
+    setTemplate(expr) {
+        const renderer = (0, compile_template_1.compileTemplate)(expr);
+        this._pipeline.template = renderer;
+        this._templateExpr = expr;
+    }
+    clearTemplate() {
+        this._pipeline.template = null;
+        this._templateExpr = null;
+    }
+    // --- Focus ---
+    getFocusExpr() { return this._focusExpr; }
+    /** フォーカス式をコンパイルして設定する。無効な式の場合は例外を投げる。 */
+    setFocus(expr) {
+        const predicate = (0, compile_filter_1.compileFilter)(expr);
+        this._pipeline.focus = predicate;
+        this._focusExpr = expr;
+    }
+    clearFocus() {
+        this._pipeline.focus = null;
+        this._focusExpr = null;
+    }
+    // --- Factory ---
+    /** 式文字列から PipelineController を構築する。null/undefined はスキップ。 */
+    static fromExpressions(opts) {
+        const ctrl = new PipelineController();
+        if (opts.filter != null)
+            ctrl.setFilter(opts.filter);
+        if (opts.template != null)
+            ctrl.setTemplate(opts.template);
+        if (opts.focus != null)
+            ctrl.setFocus(opts.focus);
+        return ctrl;
+    }
+}
+exports.PipelineController = PipelineController;

package/dist/engine/filter-template/pipeline.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldDisplay = shouldDisplay;
+exports.renderTemplate = renderTemplate;
+/** PresentationEvent にフィルタを適用する。true = 表示、false = 非表示 */
+function shouldDisplay(event, pipeline) {
+    if (pipeline.filter == null)
+        return true;
+    return pipeline.filter(event);
+}
+/** テンプレートが設定されていれば1行に変換する。null = テンプレートなし */
+function renderTemplate(event, pipeline) {
+    if (pipeline.template == null)
+        return null;
+    return pipeline.template(event);
+}

package/dist/engine/messages/display-callbacks.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * engine → ui の逆方向依存を解消するための表示コールバックインターフェース。
+ * engine 層はこのインターフェースを通じてのみ表示を行う。
+ * 実装は ui 層の display-adapter.ts で提供される。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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;