@reftrixmcp/mcp-server 0.1.8 → 0.2.0

package/dist/services/page/section-postprocessor.service.js

@@ -1,708 +0,0 @@
-"use strict";
-// SPDX-FileCopyrightText: 2025-2026 Reftrix Contributors
-// SPDX-License-Identifier: AGPL-3.0-only
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.postProcessSections = postProcessSections;
-/**
- * Section Merge Post-Processor
- *
- * JSDOM ベースのセクション検出で発生する過剰分割を、ルールベースのポストプロセッサで修正する。
- * Phase 1 (Layout Analysis) 内、mergeVisionDetectedSections() 後、DB保存前に実行される。
- *
- * Fixes over-segmentation from JSDOM-based section detection via rule-based post-processing.
- * Runs in Phase 1 (Layout Analysis) after mergeVisionDetectedSections(), before DB save.
- *
- * ルール（実行順序） / Rules (execution order):
- * - Rule 4: 巨大セクション再分割（height > 10,000px → 3戦略で再分割）
- *           Large section split (height > 10,000px → split via 3 strategies)
- * - Rule 1: 同一タイプ連続マージ（3+連続の同一タイプセクション → 1つに統合）
- *           Consecutive same-type merge (3+ consecutive same-type sections → 1)
- * - Rule 3: 同名隣接マージ（同一タイプ+同名の2+連続セクション → 1つに統合）
- *           Same-heading adjacent merge (same type + same heading, 2+ consecutive → 1)
- * - Rule 2: コンテンツ空セクション吸収（heading無し+textContent<20文字 → 隣接に吸収）
- *           Empty-content section absorption (no heading + textContent<20 chars → absorb into neighbor)
- *
- * PII: PII分類はPhase 5で実施。このフェーズではPIIフィルタリング不要。
- * PII: PII classification is performed in Phase 5. No PII filtering needed in this phase.
- *
- * @module services/page/section-postprocessor
- */
-const logger_1 = require("../../utils/logger");
-// =====================================================
-// 定数 / Constants
-// =====================================================
-/**
- * 同一タイプ連続マージの最小連続数
- * Minimum consecutive count for same-type merge
- */
-const MIN_CONSECUTIVE_COUNT = 3;
-/**
- * マージ対象のセクションタイプ（構造的に繰り返しが多いタイプ）
- * navigation/hero/footer は個別に意味があるためマージ対象外
- * cta はv0.1.8でマージ対象に変更（3+連続CTAの過剰分割が実データで確認されたため）
- *
- * Section types eligible for merge (types that commonly repeat structurally).
- * navigation/hero/footer are excluded as they have individual significance.
- * cta was added in v0.1.8 (3+ consecutive CTA over-segmentation confirmed in production data).
- */
-const MERGEABLE_TYPES = new Set([
-    "unknown",
-    "feature",
-    "testimonial",
-    "gallery",
-    "partners",
-    "portfolio",
-    "team",
-    "stories",
-    "stats",
-    "faq",
-    "cta",
-]);
-/**
- * 同名隣接マージの最小連続数（Rule 3用）
- * Minimum consecutive count for same-heading adjacent merge (Rule 3)
- */
-const MIN_SAME_HEADING_COUNT = 2;
-/**
- * textContent空判定の閾値（文字数）
- * Threshold for textContent empty detection (character count)
- */
-const TEXT_CONTENT_EMPTY_THRESHOLD = 20;
-/**
- * 入力セクション数の安全上限
- * Maximum input section count safety limit
- */
-const MAX_INPUT_SECTIONS = 500;
-/**
- * 巨大セクション再分割閾値（px）
- * Large section split threshold (px)
- *
- * TDA MEDIUM-4: 10,000px は DINOv2 ViT-B/14 の入力解像度 224x224 に対して
- * アスペクト比が極端になり visual embedding 品質が劣化する閾値。
- * 一般的なビューポート高さ（900px）の約11倍に相当し、
- * 実データ（supabase.com等）で 10,000px 超セクションの embedding 類似度低下が確認されたため設定。
- *
- * TDA MEDIUM-4: 10,000px is the threshold where aspect ratio becomes extreme
- * relative to DINOv2 ViT-B/14 input resolution (224x224), degrading visual embedding quality.
- * Equals ~11x typical viewport height (900px). Confirmed embedding similarity degradation
- * for sections exceeding 10,000px in production data (e.g., supabase.com).
- */
-const MAX_SECTION_HEIGHT = 10_000;
-/**
- * 分割後の最小高さ（px）
- * Minimum height after split (px)
- */
-const MIN_SPLIT_SECTION_HEIGHT = 1_000;
-/**
- * 1セクションからの最大分割数
- * Maximum splits per section
- */
-const MAX_SPLIT_COUNT = 20;
-/**
- * 巨大セクション再分割の Feature flag（ランタイム評価）
- * Feature flag for large section split (runtime evaluation)
- */
-function isSectionSplitEnabled() {
-    return process.env["ENABLE_SECTION_SPLIT_POSTPROCESSOR"] !== "false";
-}
-// =====================================================
-// Rule 4: 巨大セクション再分割 / Large Section Split
-// =====================================================
-/**
- * HTML子セクションの分割点を検出する正規表現
- * Regex to detect split points from HTML child elements
- *
- * SEC-07: この正規表現は分割点検出のみに使用。出力・サニタイズには使用しない。
- * SEC-07: This regex is used for split point detection only. Not used for output or sanitization.
- */
-const SPLIT_POINT_REGEX = /<(?:section|article|h[1-3])[\s>]/gi;
-/**
- * 巨大セクション（height > MAX_SECTION_HEIGHT）を再分割する
- * Splits oversized sections (height > MAX_SECTION_HEIGHT) into smaller ones
- *
- * 3戦略 / 3 strategies:
- * - 戦略A: HTML子セクション検出（section/article/h1-h3 タグ） / Strategy A: HTML child detection
- * - 戦略B: 等分割フォールバック / Strategy B: Equal division fallback
- * - 戦略C: 分割しない（Graceful Degradation） / Strategy C: No split (Graceful Degradation)
- *
- * @param sections - 入力セクション配列 / Input section array
- * @returns 分割後のセクション配列、分割統計、分割されたセクションIDのSet
- *          Split sections, split statistics, and Set of split section IDs
- */
-function splitOversizedSections(sections) {
-    if (!isSectionSplitEnabled()) {
-        return { sections, splitCount: 0, splitSectionsGenerated: 0, splitSectionIds: new Set() };
-    }
-    const result = [];
-    let splitCount = 0;
-    let splitSectionsGenerated = 0;
-    const splitSectionIds = new Set();
-    for (const section of sections) {
-        const height = section.position?.height;
-        // 分割不要: position無し、高さ未超過、または NaN/Infinity
-        // No split needed: no position, height within limit, or NaN/Infinity
-        if (!section.position || !height || height <= MAX_SECTION_HEIGHT || !Number.isFinite(height)) {
-            result.push(section);
-            continue;
-        }
-        // 戦略A: HTML子セクション検出 / Strategy A: HTML child detection
-        const strategySplits = trySplitByHtml(section);
-        if (strategySplits) {
-            for (const s of strategySplits) {
-                splitSectionIds.add(s.id);
-            }
-            result.push(...strategySplits);
-            splitCount++;
-            splitSectionsGenerated += strategySplits.length;
-            continue;
-        }
-        // 戦略B: 等分割フォールバック / Strategy B: Equal division fallback
-        const equalSplits = trySplitEqually(section);
-        if (equalSplits) {
-            for (const s of equalSplits) {
-                splitSectionIds.add(s.id);
-            }
-            result.push(...equalSplits);
-            splitCount++;
-            splitSectionsGenerated += equalSplits.length;
-            continue;
-        }
-        // 戦略C: 分割しない（Graceful Degradation） / Strategy C: No split
-        result.push(section);
-    }
-    return { sections: result, splitCount, splitSectionsGenerated, splitSectionIds };
-}
-/**
- * 戦略A: HTML子セクション（section/article/h1-h3）を分割点として使用
- * Strategy A: Use HTML child sections (section/article/h1-h3) as split points
- *
- * SEC-07: HTML解析は分割点検出のみに使用。出力・サニタイズには使用しない。
- * SEC-07: HTML parsing is used for split point detection only. Not used for output or sanitization.
- *
- * @returns 分割セクション配列、または分割不可能な場合はnull / Split sections or null if not splittable
- */
-function trySplitByHtml(section) {
-    if (!section.htmlSnippet || !section.position) {
-        return null;
-    }
-    // SEC-07: HTML解析は分割点検出のみに使用。出力には使用しない。
-    // SEC-07: HTML parsing for split point detection only. Not used for output.
-    const matches = [];
-    let match;
-    const regex = new RegExp(SPLIT_POINT_REGEX.source, "gi");
-    while ((match = regex.exec(section.htmlSnippet)) !== null) {
-        matches.push(match.index);
-    }
-    // 2つ以上の分割点が必要（最初の1つはセクション自体の開始点と重なる可能性）
-    // Need 2+ split points (first one may overlap with section start)
-    if (matches.length < 2) {
-        return null;
-    }
-    // 分割数の制限 / Limit split count
-    const splitCount = Math.min(matches.length, MAX_SPLIT_COUNT);
-    // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
-    if (!Number.isFinite(splitCount) || splitCount <= 0) {
-        return null;
-    }
-    // 各分割点を元にセクションの高さを按分
-    // Distribute section height proportionally based on split points
-    const totalLength = section.htmlSnippet.length;
-    const splitPositions = matches.slice(0, splitCount);
-    const { startY, height } = section.position;
-    const splits = [];
-    for (let i = 0; i < splitPositions.length; i++) {
-        const ratioStart = splitPositions[i] / totalLength;
-        const ratioEnd = i + 1 < splitPositions.length ? splitPositions[i + 1] / totalLength : 1;
-        const splitStartY = startY + height * ratioStart;
-        const splitEndY = startY + height * ratioEnd;
-        const splitHeight = splitEndY - splitStartY;
-        // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
-        if (!Number.isFinite(splitStartY) ||
-            !Number.isFinite(splitEndY) ||
-            !Number.isFinite(splitHeight)) {
-            continue;
-        }
-        // 最小高さチェック / Minimum height check
-        if (splitHeight < MIN_SPLIT_SECTION_HEIGHT) {
-            continue;
-        }
-        splits.push({
-            ...section,
-            id: `${section.id}-split-${i}`,
-            positionIndex: section.positionIndex + i,
-            position: {
-                startY: splitStartY,
-                endY: splitEndY,
-                height: splitHeight,
-            },
-        });
-    }
-    // 分割結果が2つ未満なら戦略Aは失敗 / Strategy A fails if less than 2 splits
-    if (splits.length < 2) {
-        return null;
-    }
-    return splits;
-}
-/**
- * 戦略B: 等分割フォールバック
- * Strategy B: Equal division fallback
- *
- * @returns 分割セクション配列、または分割不可能な場合はnull / Split sections or null if not splittable
- */
-function trySplitEqually(section) {
-    if (!section.position) {
-        return null;
-    }
-    const { startY, height } = section.position;
-    // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
-    const rawSplitCount = Math.ceil(height / MAX_SECTION_HEIGHT);
-    if (!Number.isFinite(rawSplitCount) || rawSplitCount <= 0) {
-        return null;
-    }
-    const splitCount = Math.min(rawSplitCount, MAX_SPLIT_COUNT);
-    const splitHeight = height / splitCount;
-    // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
-    if (!Number.isFinite(splitHeight) || splitHeight <= 0) {
-        return null;
-    }
-    // 分割後が最小高さ未満なら戦略Cへ / Fall through to Strategy C if below minimum height
-    if (splitHeight < MIN_SPLIT_SECTION_HEIGHT) {
-        return null;
-    }
-    const splits = [];
-    for (let i = 0; i < splitCount; i++) {
-        const splitStartY = startY + splitHeight * i;
-        const splitEndY = i === splitCount - 1
-            ? startY + height // 最後の分割は元の endY を使用 / Last split uses original endY
-            : startY + splitHeight * (i + 1);
-        const actualHeight = splitEndY - splitStartY;
-        // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
-        if (!Number.isFinite(splitStartY) ||
-            !Number.isFinite(splitEndY) ||
-            !Number.isFinite(actualHeight)) {
-            continue;
-        }
-        splits.push({
-            ...section,
-            id: `${section.id}-split-${i}`,
-            positionIndex: section.positionIndex + i,
-            position: {
-                startY: splitStartY,
-                endY: splitEndY,
-                height: actualHeight,
-            },
-        });
-    }
-    if (splits.length < 2) {
-        return null;
-    }
-    return splits;
-}
-// =====================================================
-// Rule 1: 同一タイプ連続マージ / Consecutive Same-Type Merge
-// =====================================================
-/**
- * 同一タイプが3つ以上連続するセクションを1つにマージする
- * Merges 3+ consecutive sections of the same type into one
- *
- * TDA MEDIUM-5: excludeIds に含まれるセクションIDはマージ対象から除外する。
- * Rule 4 で分割されたセクションが Rule 1 で再マージされることを防止する。
- *
- * TDA MEDIUM-5: Section IDs in excludeIds are excluded from merge candidates.
- * Prevents Rule 4 split sections from being re-merged by Rule 1.
- *
- * @param sections - 入力セクション配列 / Input section array
- * @param excludeIds - マージ対象外のセクションIDセット / Section IDs excluded from merging
- * @returns マージ後のセクション配列とマージ数 / Merged sections and merge count
- */
-function mergeConsecutiveSameType(sections, excludeIds = new Set()) {
-    if (sections.length < MIN_CONSECUTIVE_COUNT) {
-        return { sections, mergedGroups: 0 };
-    }
-    const result = [];
-    let mergedGroups = 0;
-    let i = 0;
-    while (i < sections.length) {
-        const current = sections[i];
-        // マージ対象外タイプはそのまま保持
-        // Non-mergeable types are kept as-is
-        if (!MERGEABLE_TYPES.has(current.type)) {
-            result.push(current);
-            i++;
-            continue;
-        }
-        // TDA MEDIUM-5: Rule 4分割セクションはマージ対象外
-        // TDA MEDIUM-5: Rule 4 split sections are excluded from merging
-        if (excludeIds.has(current.id)) {
-            result.push(current);
-            i++;
-            continue;
-        }
-        // 同一タイプの連続セクションを収集（excludeIds除外）
-        // Collect consecutive sections of the same type (excluding excludeIds)
-        const group = [current];
-        let j = i + 1;
-        while (j < sections.length &&
-            sections[j].type === current.type &&
-            !excludeIds.has(sections[j].id)) {
-            group.push(sections[j]);
-            j++;
-        }
-        if (group.length >= MIN_CONSECUTIVE_COUNT) {
-            // マージ: 先頭セクションをベースに統合
-            // Merge: use first section as base
-            const merged = mergeGroup(group);
-            result.push(merged);
-            mergedGroups++;
-        }
-        else {
-            // 閾値未満はそのまま保持
-            // Below threshold: keep as-is
-            result.push(...group);
-        }
-        i = j;
-    }
-    return { sections: result, mergedGroups };
-}
-/**
- * セクショングループを1つに統合
- * Merge a group of sections into one
- *
- * @param group - マージ対象のセクション群（3+件） / Sections to merge (3+)
- * @returns マージ後のセクション / Merged section
- */
-function mergeGroup(group) {
-    const first = group[0];
-    // position再計算（NaN/Infinity防御付き）
-    // Recalculate position with NaN/Infinity defense
-    let mergedPosition = first.position;
-    if (group.some((s) => s.position)) {
-        const positions = group.filter((s) => s.position).map((s) => s.position);
-        const newStartY = Math.min(...positions.map((p) => p.startY));
-        const newEndY = Math.max(...positions.map((p) => p.endY));
-        const newHeight = newEndY - newStartY;
-        if (Number.isFinite(newStartY) && Number.isFinite(newEndY) && Number.isFinite(newHeight)) {
-            mergedPosition = { startY: newStartY, endY: newEndY, height: newHeight };
-        }
-        else {
-            logger_1.logger.warn("[section-postprocessor] Invalid position after merge, using first section position", {
-                groupSize: group.length,
-            });
-            mergedPosition = first.position;
-        }
-    }
-    // heading: 最初の非nullなheadingを使用
-    // heading: use first non-null heading
-    const headingSection = group.find((s) => s.heading);
-    // confidence: グループ内の最大値
-    // confidence: max in group
-    const confidence = Math.max(...group.map((s) => s.confidence));
-    // 先頭セクションをベースにマージ結果を構築（追加プロパティ保持のためスプレッド）
-    // Build merged result from first section as base (spread to preserve additional properties)
-    // htmlSnippet: 先頭セクションのみ保持（SEC監査: XSSリスク回避のため単純結合しない）
-    // htmlSnippet: keep only first section's snippet (SEC audit: avoid XSS risk from concatenation)
-    // スプレッドベースでマージ結果を構築
-    // Build via spread, then conditionally set optional fields
-    const merged = {
-        ...first,
-        confidence: Number.isFinite(confidence) ? confidence : first.confidence,
-    };
-    if (mergedPosition) {
-        merged.position = mergedPosition;
-    }
-    if (headingSection?.heading) {
-        merged.heading = headingSection.heading;
-    }
-    return merged;
-}
-// =====================================================
-// Rule 3: 同名隣接マージ / Same-Heading Adjacent Merge
-// =====================================================
-/**
- * 同一タイプかつ同名の2+連続セクションを1つにマージする
- * Merges 2+ consecutive sections with same type and same heading
- *
- * SEC: heading=null/undefined/空文字列同士はマージ対象外
- * SEC: null/undefined/empty string headings are NOT treated as matching
- *
- * @param sections - 入力セクション配列 / Input section array
- * @returns マージ後のセクション配列とマージ数 / Merged sections and merge count
- */
-function mergeConsecutiveSameHeading(sections, excludeIds = new Set()) {
-    if (sections.length < MIN_SAME_HEADING_COUNT) {
-        return { sections, sameHeadingMergedCount: 0 };
-    }
-    const result = [];
-    let sameHeadingMergedCount = 0;
-    let i = 0;
-    while (i < sections.length) {
-        const current = sections[i];
-        // heading無し、またはMERGEABLE_TYPES外はスキップ
-        // Skip if no heading or non-mergeable type
-        if (!current.heading || !MERGEABLE_TYPES.has(current.type)) {
-            result.push(current);
-            i++;
-            continue;
-        }
-        // Rule 4分割セクションはマージ対象外
-        // Rule 4 split sections are excluded from merging
-        if (excludeIds.has(current.id)) {
-            result.push(current);
-            i++;
-            continue;
-        }
-        // 同一タイプ+同名の連続セクションを収集（excludeIds除外）
-        // Collect consecutive sections with same type and same heading (excluding excludeIds)
-        const group = [current];
-        let j = i + 1;
-        while (j < sections.length &&
-            sections[j].type === current.type &&
-            sections[j].heading === current.heading &&
-            !excludeIds.has(sections[j].id)) {
-            group.push(sections[j]);
-            j++;
-        }
-        if (group.length >= MIN_SAME_HEADING_COUNT) {
-            const merged = mergeGroup(group);
-            result.push(merged);
-            sameHeadingMergedCount++;
-        }
-        else {
-            result.push(...group);
-        }
-        i = j;
-    }
-    return { sections: result, sameHeadingMergedCount };
-}
-// =====================================================
-// Rule 2: コンテンツ空セクション吸収 / Empty Content Absorption
-// =====================================================
-/**
- * コンテンツが空のセクションを隣接セクションに吸収する
- * Absorbs empty-content sections into neighboring sections
- *
- * 空の判定: heading無し、htmlSnippetが無いか極小（<50文字）
- * Empty criteria: no heading, no htmlSnippet or very small (<50 chars)
- *
- * @param sections - 入力セクション配列 / Input section array
- * @returns 吸収後のセクション配列と吸収数 / Absorbed sections and count
- */
-function absorbEmptyContentSections(sections) {
-    if (sections.length <= 1) {
-        return { sections, absorbedCount: 0 };
-    }
-    const keep = new Array(sections.length).fill(true);
-    let absorbedCount = 0;
-    for (let i = 0; i < sections.length; i++) {
-        const section = sections[i];
-        // 空でないセクションは保持
-        // Keep non-empty sections
-        if (!isEmptyContent(section)) {
-            continue;
-        }
-        // 明確なタイプを持つセクションは保持（unknownのみ吸収対象）
-        // Keep sections with definite types (only unknown is eligible for absorption)
-        if (section.type !== "unknown") {
-            continue;
-        }
-        // 前のセクションに吸収（前がなければ次に吸収）
-        // Absorb into previous section (or next if no previous)
-        const prevIdx = findPrevKept(keep, i);
-        const nextIdx = findNextKept(keep, i, sections.length);
-        if (prevIdx !== -1) {
-            const prev = sections[prevIdx];
-            if (prev.position && section.position) {
-                // 前のセクションの範囲を拡張
-                // Extend previous section's range
-                const newEndY = Math.max(prev.position.endY, section.position.endY);
-                const newHeight = newEndY - prev.position.startY;
-                if (Number.isFinite(newEndY) && Number.isFinite(newHeight)) {
-                    prev.position = {
-                        startY: prev.position.startY,
-                        endY: newEndY,
-                        height: newHeight,
-                    };
-                }
-                keep[i] = false;
-                absorbedCount++;
-            }
-        }
-        else if (nextIdx !== -1) {
-            const next = sections[nextIdx];
-            if (next.position && section.position) {
-                // 次のセクションの範囲を拡張
-                // Extend next section's range
-                const newStartY = Math.min(next.position.startY, section.position.startY);
-                const newHeight = next.position.endY - newStartY;
-                if (Number.isFinite(newStartY) && Number.isFinite(newHeight)) {
-                    next.position = {
-                        startY: newStartY,
-                        endY: next.position.endY,
-                        height: newHeight,
-                    };
-                }
-                keep[i] = false;
-                absorbedCount++;
-            }
-        }
-        // 前後とも無い場合はそのまま保持
-        // Keep if no neighbors available
-    }
-    const result = sections.filter((_, i) => keep[i]);
-    return { sections: result, absorbedCount };
-}
-/**
- * セクションのコンテンツが空かどうかを判定
- * Determines if a section has empty content
- *
- * SEC: この正規表現は空判定のみに使用。出力・サニタイズには使用しない。
- * SEC: This regex is used for empty-content detection only. Not used for output or sanitization.
- */
-function isEmptyContent(section) {
-    // headingがあれば非空
-    if (section.heading) {
-        return false;
-    }
-    // htmlSnippetが無いなら空
-    if (!section.htmlSnippet) {
-        return true;
-    }
-    // HTMLタグ除去後のtextContentで判定（SEC: 判定のみ、出力には使用しない）
-    // Determine by textContent after HTML tag removal (SEC: detection only, not used for output)
-    const textContent = section.htmlSnippet.replace(/<[^>]*>/g, "").trim();
-    if (textContent.length < TEXT_CONTENT_EMPTY_THRESHOLD) {
-        return true;
-    }
-    return false;
-}
-/** 前方で保持されているセクションのインデックスを探す */
-function findPrevKept(keep, current) {
-    for (let i = current - 1; i >= 0; i--) {
-        if (keep[i])
-            return i;
-    }
-    return -1;
-}
-/** 後方で保持されているセクションのインデックスを探す */
-function findNextKept(keep, current, length) {
-    for (let i = current + 1; i < length; i++) {
-        if (keep[i])
-            return i;
-    }
-    return -1;
-}
-// =====================================================
-// メインエントリポイント / Main Entry Point
-// =====================================================
-/**
- * セクション配列をポストプロセスして過剰分割を修正する
- * Post-processes section array to fix over-segmentation
- *
- * Feature flag: ENABLE_SECTION_MERGE_POSTPROCESSOR (default: true, opt-out)
- *
- * 実行順序 / Execution order: Rule 4 → Rule 1 → Rule 3 → Rule 2
- * Rule 4 を最初に実行する理由: 分割により新たな連続同一タイプが発生する可能性があり、
- * Rule 1 で処理できるため。ただし TDA MEDIUM-5 により、Rule 4 で分割されたセクション間の
- * マージは excludeIds で防止される。
- *
- * Rule 4 runs first because splits may create new consecutive same-type sequences
- * processable by Rule 1. However, TDA MEDIUM-5 prevents re-merging of Rule 4 split
- * sections via excludeIds.
- *
- * @param sections - 入力セクション配列 / Input section array
- * @returns ポストプロセス結果 / Post-process result
- */
-function postProcessSections(sections) {
-    const inputCount = sections.length;
-    const emptyStats = {
-        inputCount,
-        outputCount: inputCount,
-        mergedGroups: 0,
-        sameHeadingMergedCount: 0,
-        absorbedCount: 0,
-        splitCount: 0,
-        splitSectionsGenerated: 0,
-    };
-    // Feature flag チェック / Feature flag check
-    if (process.env["ENABLE_SECTION_MERGE_POSTPROCESSOR"] === "false") {
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.debug("[section-postprocessor] Disabled via feature flag");
-        }
-        return { sections, stats: emptyStats };
-    }
-    // 空配列のearly return / Early return for empty array
-    if (sections.length === 0) {
-        return {
-            sections: [],
-            stats: { ...emptyStats, inputCount: 0, outputCount: 0 },
-        };
-    }
-    // 安全上限チェック / Safety limit check
-    if (sections.length > MAX_INPUT_SECTIONS) {
-        logger_1.logger.warn("[section-postprocessor] Input exceeds safety limit, skipping post-processing", {
-            sectionCount: sections.length,
-            limit: MAX_INPUT_SECTIONS,
-        });
-        return { sections, stats: emptyStats };
-    }
-    try {
-        // Rule 4: 巨大セクション再分割 / Large section split
-        const rule4Result = splitOversizedSections(sections);
-        // SEC-09: Rule 4出力後の安全上限チェック / SEC-09: Safety limit check after Rule 4 output
-        if (rule4Result.sections.length > MAX_INPUT_SECTIONS) {
-            logger_1.logger.warn("[section-postprocessor] Post-Rule 4 output exceeds safety limit, returning Rule 4 result only", {
-                sectionCount: rule4Result.sections.length,
-                limit: MAX_INPUT_SECTIONS,
-            });
-            // positionIndex を再採番 / Re-number positionIndex
-            for (let i = 0; i < rule4Result.sections.length; i++) {
-                rule4Result.sections[i].positionIndex = i;
-            }
-            return {
-                sections: rule4Result.sections,
-                stats: {
-                    ...emptyStats,
-                    outputCount: rule4Result.sections.length,
-                    splitCount: rule4Result.splitCount,
-                    splitSectionsGenerated: rule4Result.splitSectionsGenerated,
-                },
-            };
-        }
-        // Rule 1: 同一タイプ連続マージ（TDA MEDIUM-5: Rule 4分割セクション除外）
-        // Rule 1: Consecutive same-type merge (TDA MEDIUM-5: exclude Rule 4 split sections)
-        const rule1Result = mergeConsecutiveSameType(rule4Result.sections, rule4Result.splitSectionIds);
-        // Rule 3: 同名隣接マージ（Rule 4分割セクション除外）
-        // Rule 3: Same-heading adjacent merge (exclude Rule 4 split sections)
-        const rule3Result = mergeConsecutiveSameHeading(rule1Result.sections, rule4Result.splitSectionIds);
-        // Rule 2: コンテンツ空セクション吸収 / Empty content absorption
-        const rule2Result = absorbEmptyContentSections(rule3Result.sections);
-        // positionIndex を再採番 / Re-number positionIndex
-        const processed = rule2Result.sections;
-        for (let i = 0; i < processed.length; i++) {
-            processed[i].positionIndex = i;
-        }
-        const stats = {
-            inputCount,
-            outputCount: processed.length,
-            mergedGroups: rule1Result.mergedGroups,
-            sameHeadingMergedCount: rule3Result.sameHeadingMergedCount,
-            absorbedCount: rule2Result.absorbedCount,
-            splitCount: rule4Result.splitCount,
-            splitSectionsGenerated: rule4Result.splitSectionsGenerated,
-        };
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.info("[section-postprocessor] Post-processing complete", stats);
-        }
-        return { sections: processed, stats };
-    }
-    catch (error) {
-        // Graceful Degradation: 失敗時は元のセクション配列をそのまま返す
-        // Graceful Degradation: return original sections on failure
-        logger_1.logger.warn("[section-postprocessor] Post-processing failed, returning original sections", {
-            error: error.message,
-            sectionCount: sections.length,
-        });
-        return { sections, stats: emptyStats };
-    }
-}
-//# sourceMappingURL=section-postprocessor.service.js.map