@reftrixmcp/mcp-server 0.1.7

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

@@ -0,0 +1,708 @@
+"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