@reftrixmcp/mcp-server 0.1.8 → 0.2.0

package/dist/tools/page/handlers/layout-handler.js

@@ -1,1181 +0,0 @@
-"use strict";
-// SPDX-FileCopyrightText: 2026 TKMD and Reftrix Contributors
-// SPDX-License-Identifier: AGPL-3.0-only
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultAnalyzeLayout = defaultAnalyzeLayout;
-/**
- * page.analyze レイアウト分析ハンドラー
- *
- * analyze.tool.tsから抽出したレイアウト分析ロジック
- * - LayoutAnalyzerService を使用したHTML解析
- * - Vision API (Ollama + llama3.2-vision) による画像解析
- * - Per-Section Vision分析
- *
- * @module tools/page/handlers/layout-handler
- */
-const uuid_1 = require("uuid");
-const logger_1 = require("../../../utils/logger");
-const layout_analyzer_service_1 = require("../../../services/page/layout-analyzer.service");
-const section_screenshot_service_1 = require("../../../services/section-screenshot.service");
-const schemas_1 = require("../schemas");
-const section_postprocessor_service_1 = require("../../../services/page/section-postprocessor.service");
-const types_1 = require("./types");
-// Visual Feature Extraction Services (Phase 1 - Deterministic)
-const color_extractor_service_1 = require("../../../services/visual-extractor/color-extractor.service");
-const theme_detector_service_1 = require("../../../services/visual-extractor/theme-detector.service");
-const density_calculator_service_1 = require("../../../services/visual-extractor/density-calculator.service");
-const gradient_detector_service_1 = require("../../../services/visual-extractor/gradient-detector.service");
-const visual_feature_merger_service_1 = require("../../../services/visual-extractor/visual-feature-merger.service");
-// CSS Variable Extraction (v0.1.0)
-const css_variable_extractor_service_1 = require("../../../services/visual/css-variable-extractor.service");
-// Background Design Detection
-const background_design_detector_service_1 = require("../../../services/background/background-design-detector.service");
-// Vision CPU完走保証 (Phase 1-2 Services)
-const hardware_detector_1 = require("../../../services/vision/hardware-detector");
-const timeout_calculator_1 = require("../../../services/vision/timeout-calculator");
-const image_optimizer_1 = require("../../../services/vision/image-optimizer");
-const index_1 = require("../../../services/vision/index");
-// =====================================================
-// セクション統合処理（Phase 1: Vision統合）
-// =====================================================
-/**
- * Vision検出セクション境界をHTML検出結果と統合
- *
- * HTML解析で検出できなかったビジュアルセクションをVision分析結果から追加する。
- * - 既存セクションとの重複を除去（Y座標の50%以上重複で同一とみなす）
- * - Vision専用セクションは新規IDで追加
- * - 信頼度スコアを統合計算
- *
- * @param htmlSections - HTML解析で検出されたセクション
- * @param visionBoundaries - Vision分析で検出されたセクション境界
- * @returns 統合されたセクション配列
- */
-function mergeVisionDetectedSections(htmlSections, visionBoundaries) {
-    if (!visionBoundaries || !visionBoundaries.sections || visionBoundaries.sections.length === 0) {
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.debug("[layout-handler] mergeVisionDetectedSections: No vision boundaries to merge");
-        }
-        return htmlSections;
-    }
-    const mergedSections = [...htmlSections];
-    let addedVisionSections = 0;
-    let boostedSections = 0;
-    for (const visionSection of visionBoundaries.sections) {
-        const visionStartY = visionSection.startY;
-        const visionEndY = visionSection.endY;
-        const visionHeight = visionEndY - visionStartY;
-        if (visionHeight <= 0) {
-            continue;
-        }
-        // 既存セクションとの重複チェック
-        let hasOverlap = false;
-        let bestOverlapIndex = -1;
-        let bestOverlapRatio = 0;
-        for (let i = 0; i < mergedSections.length; i++) {
-            const htmlSection = mergedSections[i];
-            if (!htmlSection?.position) {
-                continue;
-            }
-            const htmlStartY = htmlSection.position.startY;
-            const htmlEndY = htmlSection.position.endY;
-            // 重複領域を計算
-            const overlapStartY = Math.max(visionStartY, htmlStartY);
-            const overlapEndY = Math.min(visionEndY, htmlEndY);
-            const overlapHeight = Math.max(0, overlapEndY - overlapStartY);
-            // 重複率を計算（両方向で確認）
-            const overlapRatioVision = overlapHeight / visionHeight;
-            const overlapRatioHtml = overlapHeight / (htmlEndY - htmlStartY);
-            const maxOverlapRatio = Math.max(overlapRatioVision, overlapRatioHtml);
-            if (maxOverlapRatio > 0.5) {
-                hasOverlap = true;
-                if (maxOverlapRatio > bestOverlapRatio) {
-                    bestOverlapRatio = maxOverlapRatio;
-                    bestOverlapIndex = i;
-                }
-            }
-        }
-        if (hasOverlap && bestOverlapIndex >= 0) {
-            // 既存セクションと重複: 信頼度をブースト
-            const existingSection = mergedSections[bestOverlapIndex];
-            if (existingSection) {
-                // Vision検出で確認されたので信頼度を上げる（最大15%ブースト）
-                const boostAmount = Math.min(0.15, visionSection.confidence * 0.2);
-                existingSection.confidence = Math.min(1, existingSection.confidence + boostAmount);
-                // セクションタイプがunknownの場合はVisionの結果で更新
-                if (existingSection.type === "unknown" && visionSection.type !== "unknown") {
-                    existingSection.type = visionSection.type;
-                }
-                boostedSections++;
-            }
-        }
-        else {
-            // 新規Vision専用セクションとして追加
-            const newSection = {
-                id: (0, uuid_1.v7)(),
-                type: visionSection.type || "unknown",
-                positionIndex: mergedSections.length,
-                confidence: visionSection.confidence * 0.85, // Vision検出は若干低めに設定
-                position: {
-                    startY: visionStartY,
-                    endY: visionEndY,
-                    height: visionHeight,
-                },
-                // Vision検出セクションはHTMLスニペットなし（後で取得可能）
-                visionFeatures: {
-                    success: true,
-                    features: [
-                        {
-                            type: "section_boundaries",
-                            confidence: visionSection.confidence,
-                            description: `Vision-detected ${visionSection.type} section`,
-                        },
-                    ],
-                    processingTimeMs: 0,
-                    modelName: "llama3.2-vision",
-                },
-            };
-            mergedSections.push(newSection);
-            addedVisionSections++;
-        }
-    }
-    // 位置インデックスを再計算（Y座標順にソート）
-    mergedSections.sort((a, b) => {
-        const aStartY = a.position?.startY ?? 0;
-        const bStartY = b.position?.startY ?? 0;
-        return aStartY - bStartY;
-    });
-    mergedSections.forEach((section, index) => {
-        section.positionIndex = index;
-    });
-    if ((0, logger_1.isDevelopment)()) {
-        logger_1.logger.info("[layout-handler] mergeVisionDetectedSections: completed", {
-            originalHtmlSections: htmlSections.length,
-            visionSections: visionBoundaries.sections.length,
-            addedVisionSections,
-            boostedSections,
-            totalMergedSections: mergedSections.length,
-        });
-    }
-    return mergedSections;
-}
-// =====================================================
-// Deterministic Visual Feature Extraction (Phase 1)
-// =====================================================
-/**
- * スクリーンショットから決定論的なVisual Featuresを抽出
- *
- * 4つのサービスを使用して画像から特徴を抽出:
- * - ColorExtractor: 支配色・アクセントカラー抽出
- * - ThemeDetector: light/dark/mixed テーマ検出
- * - DensityCalculator: コンテンツ密度・ホワイトスペース計算
- * - GradientDetector: グラデーション検出
- *
- * @param screenshot - Base64エンコードされたスクリーンショット
- * @param computedStyles - Computed Styles（Playwrightから取得、optional）
- * @returns Visual Features（エラー時はundefined）
- */
-async function extractDeterministicVisualFeatures(screenshot, computedStyles) {
-    const startTime = Date.now();
-    if ((0, logger_1.isDevelopment)()) {
-        logger_1.logger.info("[layout-handler] extractDeterministicVisualFeatures: starting", {
-            screenshotSize: screenshot.base64.length,
-            mimeType: screenshot.mimeType,
-        });
-    }
-    try {
-        // Convert base64 to Buffer
-        const imageBuffer = Buffer.from(screenshot.base64, "base64");
-        // Create service instances
-        const colorExtractor = (0, color_extractor_service_1.createColorExtractorService)();
-        const themeDetector = (0, theme_detector_service_1.createThemeDetectorService)();
-        const densityCalculator = (0, density_calculator_service_1.createDensityCalculatorService)();
-        const gradientDetector = (0, gradient_detector_service_1.createGradientDetectorService)();
-        const visualFeatureMerger = (0, visual_feature_merger_service_1.createVisualFeatureMerger)();
-        // Execute all deterministic extractions in parallel
-        // Note: Theme detection uses computed styles if available for more accurate results
-        const [colorResult, themeResult, densityResult, gradientResult] = await Promise.all([
-            colorExtractor.extractColors(imageBuffer).catch((error) => {
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] ColorExtractor failed", {
-                        error: error instanceof Error ? error.message : "Unknown error",
-                    });
-                }
-                return undefined;
-            }),
-            // Use detectThemeWithComputedStyles for more accurate theme detection
-            // This prioritizes computed backgroundColor values from Playwright over screenshot analysis
-            themeDetector.detectThemeWithComputedStyles(imageBuffer, computedStyles).catch((error) => {
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] ThemeDetector failed", {
-                        error: error instanceof Error ? error.message : "Unknown error",
-                    });
-                }
-                return undefined;
-            }),
-            densityCalculator.calculateDensity(imageBuffer).catch((error) => {
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] DensityCalculator failed", {
-                        error: error instanceof Error ? error.message : "Unknown error",
-                    });
-                }
-                return undefined;
-            }),
-            gradientDetector.detectGradient(imageBuffer).catch((error) => {
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] GradientDetector failed", {
-                        error: error instanceof Error ? error.message : "Unknown error",
-                    });
-                }
-                return undefined;
-            }),
-        ]);
-        // Check if at least one extraction succeeded
-        if (!colorResult && !themeResult && !densityResult && !gradientResult) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.warn("[layout-handler] All deterministic extractions failed");
-            }
-            return undefined;
-        }
-        // Prepare deterministic input for merger (used for metadata calculation)
-        const deterministicInput = {};
-        if (colorResult)
-            deterministicInput.colors = colorResult;
-        if (themeResult)
-            deterministicInput.theme = themeResult;
-        if (densityResult)
-            deterministicInput.density = densityResult;
-        // Merge deterministic results (no Vision AI input for now)
-        // Note: We use merger for metadata calculation, but build visualFeatures directly
-        // to avoid type incompatibility between MergedVisualFeatures and VisualFeatures
-        const mergedFeatures = await visualFeatureMerger.merge(deterministicInput, null);
-        // Build final VisualFeatures directly from service results
-        // This avoids type incompatibility issues between Merger types and Schema types
-        const visualFeatures = {
-            // Colors: Build from colorResult directly
-            colors: colorResult
-                ? {
-                    dominant: colorResult.dominantColors,
-                    accent: colorResult.accentColors,
-                    palette: colorResult.colorPalette,
-                    source: "deterministic",
-                    confidence: 0.95,
-                }
-                : null,
-            // Theme: Build from themeResult with luminance
-            theme: themeResult
-                ? {
-                    type: themeResult.theme,
-                    backgroundColor: themeResult.backgroundColor,
-                    textColor: themeResult.textColor,
-                    contrastRatio: themeResult.contrastRatio,
-                    luminance: themeResult.luminance,
-                    source: "deterministic",
-                    confidence: themeResult.confidence,
-                }
-                : null,
-            // Density: Build from densityResult directly
-            // Note: regions and metrics are optional in schema, and service types differ
-            // from schema types, so we only include the core fields
-            density: densityResult
-                ? {
-                    contentDensity: densityResult.contentDensity,
-                    whitespaceRatio: densityResult.whitespaceRatio,
-                    visualBalance: densityResult.visualBalance,
-                    source: "deterministic",
-                    confidence: 0.95,
-                }
-                : null,
-            // Mood and BrandTone: null for now (Phase 2 Vision AI features)
-            mood: null,
-            brandTone: null,
-            // Metadata from merger
-            metadata: mergedFeatures.metadata,
-            // Gradient: Build from gradientResult directly
-            gradient: gradientResult
-                ? {
-                    hasGradient: gradientResult.hasGradient,
-                    gradients: gradientResult.gradients,
-                    dominantGradientType: gradientResult.dominantGradientType,
-                    confidence: gradientResult.confidence,
-                    processingTimeMs: gradientResult.processingTimeMs,
-                    source: "deterministic",
-                }
-                : null,
-        };
-        const processingTimeMs = Date.now() - startTime;
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.info("[layout-handler] extractDeterministicVisualFeatures: completed", {
-                processingTimeMs,
-                hasColors: !!visualFeatures.colors,
-                hasTheme: !!visualFeatures.theme,
-                hasDensity: !!visualFeatures.density,
-                hasGradient: !!visualFeatures.gradient,
-                overallConfidence: visualFeatures.metadata?.overallConfidence,
-            });
-        }
-        return visualFeatures;
-    }
-    catch (error) {
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.error("[layout-handler] extractDeterministicVisualFeatures failed", {
-                error: error instanceof Error ? error.message : "Unknown error",
-                processingTimeMs: Date.now() - startTime,
-            });
-        }
-        // Graceful degradation - return undefined, don't throw
-        return undefined;
-    }
-}
-/**
- * ページ全体のVision分析を実行（セクション境界検出を含む）
- *
- * Vision CPU完走保証 Phase 3:
- * - HardwareDetector: GPU/CPU自動判定（Ollama /api/ps API使用）
- * - TimeoutCalculator: ハードウェア・画像サイズに基づく動的タイムアウト
- * - ImageOptimizer: CPU推論向け画像最適化（リサイズ、圧縮）
- * - Graceful Degradation: タイムアウト時はHTML解析のみで続行
- *
- * @param screenshot - スクリーンショットデータ
- * @param result - レイアウト分析結果（更新される）
- * @param visionStartTime - Vision分析開始時刻
- * @param visionOptions - Vision CPU完走保証オプション（Phase 3）
- * @param progressContext - MCP進捗報告コンテキスト（Phase 4）
- * @returns セクション境界データ（HTMLセクションとのマージに使用）
- */
-async function executePageVisionAnalysis(screenshot, result, visionStartTime, visionOptions, progressContext) {
-    const analysisResult = {};
-    // Vision CPU完走保証: デフォルトオプション
-    const visionForceCpu = visionOptions?.visionForceCpu ?? false;
-    const visionEnableProgress = visionOptions?.visionEnableProgress ?? false;
-    const visionFallbackToHtmlOnly = visionOptions?.visionFallbackToHtmlOnly ?? true;
-    const visionTimeoutMs = visionOptions?.visionTimeoutMs;
-    // @ts-expect-error Phase 4予定: 最大画像サイズ制限で使用
-    const _visionImageMaxSize = visionOptions?.visionImageMaxSize;
-    // Vision CPU完走保証 Phase 4: 進捗報告セットアップ
-    let progressReporter = null;
-    if (visionEnableProgress && progressContext?.progressToken !== undefined) {
-        const progressCallback = (0, index_1.createMCPProgressCallback)({
-            progressToken: progressContext.progressToken,
-            sendNotification: progressContext.sendNotification,
-        });
-        if (progressCallback) {
-            // Vision分析の推定時間: CPU環境では180秒（3分）をデフォルトとする
-            const estimatedTotalMs = visionOptions?.visionTimeoutMs ?? 180000;
-            progressReporter = new index_1.ProgressReporter({ onProgress: progressCallback });
-            progressReporter.start(estimatedTotalMs);
-        }
-    }
-    try {
-        const { LlamaVisionAdapter } = await import("../../../services/vision-adapter/index.js");
-        const visionAdapter = new LlamaVisionAdapter();
-        const isAvailable = await visionAdapter.isAvailable();
-        if (isAvailable) {
-            let imageBuffer = Buffer.from(screenshot.base64, "base64");
-            const mimeType = screenshot.mimeType;
-            const originalImageSize = imageBuffer.length;
-            // ================================================================
-            // Vision CPU完走保証 Phase 1: ハードウェア検出
-            // ================================================================
-            const hardwareDetector = new hardware_detector_1.HardwareDetector();
-            let hardwareType = hardware_detector_1.HardwareType.CPU; // デフォルトはCPU（安全側）
-            let hardwareInfo = null;
-            try {
-                hardwareInfo = await hardwareDetector.detect();
-                hardwareType = visionForceCpu ? hardware_detector_1.HardwareType.CPU : hardwareInfo.type;
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.info("[layout-handler] Hardware detection completed", {
-                        detectedType: hardwareInfo.type,
-                        effectiveType: hardwareType,
-                        forceCpu: visionForceCpu,
-                        vramBytes: hardwareInfo.vramBytes,
-                        isGpuAvailable: hardwareInfo.isGpuAvailable,
-                    });
-                }
-            }
-            catch (hwError) {
-                // ハードウェア検出失敗時はCPUと仮定（安全側）
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] Hardware detection failed, assuming CPU", {
-                        error: hwError instanceof Error ? hwError.message : "Unknown error",
-                    });
-                }
-            }
-            // Phase 4: 進捗報告 - ハードウェア検出完了 (5%)
-            if (progressReporter) {
-                progressReporter.updatePhase("preparing");
-                progressReporter.updateProgress(5);
-            }
-            // ================================================================
-            // Vision CPU完走保証 Phase 1: タイムアウト計算
-            // ================================================================
-            const timeoutCalculator = new timeout_calculator_1.TimeoutCalculator();
-            const calculatedTimeout = visionTimeoutMs ?? timeoutCalculator.calculate(hardwareType, originalImageSize);
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.info("[layout-handler] Vision timeout calculated", {
-                    hardwareType,
-                    imageSizeBytes: originalImageSize,
-                    calculatedTimeoutMs: calculatedTimeout,
-                    userOverride: visionTimeoutMs !== undefined,
-                    formatted: timeoutCalculator.formatTimeout(calculatedTimeout),
-                });
-            }
-            // ================================================================
-            // Vision CPU完走保証 Phase 2: 画像最適化（CPU時のみ）
-            // ================================================================
-            const imageOptimizer = new image_optimizer_1.ImageOptimizer();
-            let optimizationApplied = false;
-            if (hardwareType === hardware_detector_1.HardwareType.CPU) {
-                try {
-                    const optimizeResult = await imageOptimizer.optimizeForCPU(imageBuffer, {
-                        hardwareType,
-                    });
-                    if (!optimizeResult.skipped) {
-                        // Buffer型の互換性を確保するため、新しいBufferとしてコピー
-                        imageBuffer = Buffer.from(optimizeResult.buffer);
-                        optimizationApplied = true;
-                        if ((0, logger_1.isDevelopment)()) {
-                            logger_1.logger.info("[layout-handler] Image optimization applied", {
-                                originalSize: optimizeResult.originalSizeBytes,
-                                optimizedSize: optimizeResult.optimizedSizeBytes,
-                                compressionRatio: optimizeResult.compressionRatio.toFixed(2),
-                                dimensions: optimizeResult.dimensions,
-                                processingTimeMs: optimizeResult.processingTimeMs,
-                            });
-                        }
-                    }
-                    else {
-                        if ((0, logger_1.isDevelopment)()) {
-                            logger_1.logger.debug("[layout-handler] Image optimization skipped", {
-                                reason: optimizeResult.reason,
-                            });
-                        }
-                    }
-                }
-                catch (optError) {
-                    // 最適化失敗時は元の画像を使用
-                    if ((0, logger_1.isDevelopment)()) {
-                        logger_1.logger.warn("[layout-handler] Image optimization failed, using original", {
-                            error: optError instanceof Error ? optError.message : "Unknown error",
-                        });
-                    }
-                }
-            }
-            // Phase 4: 進捗報告 - 画像最適化完了 (20%)
-            if (progressReporter) {
-                progressReporter.updatePhase("optimizing");
-                progressReporter.updateProgress(20);
-            }
-            // ================================================================
-            // Vision分析実行（タイムアウト付き）
-            // ================================================================
-            const analyzeWithTimeout = async () => {
-                return new Promise((resolve, reject) => {
-                    const timeoutId = setTimeout(() => {
-                        reject(new Error(`Vision analysis timeout after ${calculatedTimeout}ms (${timeoutCalculator.formatTimeout(calculatedTimeout)})`));
-                    }, calculatedTimeout);
-                    visionAdapter
-                        .analyze({ imageBuffer, mimeType })
-                        .then((result) => {
-                        clearTimeout(timeoutId);
-                        resolve(result);
-                    })
-                        .catch((error) => {
-                        clearTimeout(timeoutId);
-                        reject(error);
-                    });
-                });
-            };
-            // Phase 4: 進捗報告 - Vision分析開始 (30%)
-            if (progressReporter) {
-                progressReporter.updatePhase("analyzing");
-                progressReporter.updateProgress(30);
-            }
-            try {
-                const visionResult = await analyzeWithTimeout();
-                const visionProcessingTimeMs = Date.now() - visionStartTime;
-                // Phase 4: 進捗報告 - Vision分析完了 (70%)
-                if (progressReporter) {
-                    progressReporter.updateProgress(70);
-                }
-                result.visionFeatures = {
-                    success: visionResult.success,
-                    features: visionResult.features.map((f) => {
-                        const desc = "description" in f.data
-                            ? f.data.description
-                            : undefined;
-                        const feature = {
-                            type: f.type,
-                            confidence: f.confidence,
-                        };
-                        if (desc !== undefined) {
-                            feature.description = desc;
-                        }
-                        return feature;
-                    }),
-                    processingTimeMs: visionProcessingTimeMs,
-                    modelName: visionResult.modelName,
-                    // Vision CPU完走保証: メタ情報を追加
-                    hardwareType,
-                    timeoutMs: calculatedTimeout,
-                    optimizationApplied,
-                };
-                result.textRepresentation = visionAdapter.generateTextRepresentation(visionResult);
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.info("[layout-handler] Vision analysis completed", {
-                        featureCount: visionResult.features.length,
-                        processingTimeMs: visionProcessingTimeMs,
-                        textRepresentationLength: result.textRepresentation?.length,
-                        hardwareType,
-                        optimizationApplied,
-                    });
-                }
-                // Reftrix専用: セクション境界検出
-                try {
-                    const boundaryStartTime = Date.now();
-                    const boundaryResult = await visionAdapter.detectSectionBoundaries({
-                        imageBuffer,
-                        mimeType,
-                    });
-                    if (boundaryResult.success && boundaryResult.data) {
-                        analysisResult.sectionBoundaries = boundaryResult.data;
-                        if ((0, logger_1.isDevelopment)()) {
-                            logger_1.logger.info("[layout-handler] Section boundary detection completed", {
-                                sectionCount: boundaryResult.data.sections?.length ?? 0,
-                                processingTimeMs: Date.now() - boundaryStartTime,
-                            });
-                        }
-                    }
-                    else {
-                        if ((0, logger_1.isDevelopment)()) {
-                            logger_1.logger.warn("[layout-handler] Section boundary detection failed", {
-                                error: boundaryResult.error,
-                            });
-                        }
-                    }
-                }
-                catch (boundaryError) {
-                    if ((0, logger_1.isDevelopment)()) {
-                        logger_1.logger.warn("[layout-handler] Section boundary detection error (non-critical)", {
-                            error: boundaryError instanceof Error ? boundaryError.message : "Unknown error",
-                        });
-                    }
-                    // セクション境界検出エラーは非クリティカル - 続行
-                }
-                // Phase 4: 進捗報告 - セクション境界検出完了 (90%)
-                if (progressReporter) {
-                    progressReporter.updatePhase("completing");
-                    progressReporter.updateProgress(90);
-                }
-                // Phase 4: 進捗報告 - 完了 (100%)
-                if (progressReporter) {
-                    progressReporter.complete();
-                }
-            }
-            catch (visionError) {
-                // ================================================================
-                // Vision CPU完走保証 Phase 3: Graceful Degradation
-                // ================================================================
-                const isTimeout = visionError instanceof Error && visionError.message.includes("timeout");
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] Vision analysis failed", {
-                        error: visionError instanceof Error ? visionError.message : "Unknown error",
-                        isTimeout,
-                        fallbackEnabled: visionFallbackToHtmlOnly,
-                    });
-                }
-                if (visionFallbackToHtmlOnly) {
-                    // Graceful Degradation: HTML解析のみで続行
-                    result.visionFeatures = {
-                        success: false,
-                        features: [],
-                        error: visionError instanceof Error ? visionError.message : "Vision analysis failed",
-                        processingTimeMs: Date.now() - visionStartTime,
-                        modelName: "llama3.2-vision",
-                        // Vision CPU完走保証: フォールバック情報
-                        fallback: true,
-                        fallbackReason: isTimeout ? "timeout" : "error",
-                        hardwareType,
-                        timeoutMs: calculatedTimeout,
-                    };
-                    // Phase 4: 進捗報告 - フォールバック完了 (100%)
-                    if (progressReporter) {
-                        progressReporter.updatePhase("completing");
-                        progressReporter.complete();
-                    }
-                    if ((0, logger_1.isDevelopment)()) {
-                        logger_1.logger.info("[layout-handler] Graceful Degradation: continuing with HTML analysis only");
-                    }
-                }
-                else {
-                    // フォールバック無効: エラーを再スロー
-                    throw visionError;
-                }
-            }
-        }
-        else {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.warn("[layout-handler] VisionAdapter not available, skipping Vision analysis");
-            }
-            result.visionFeatures = {
-                success: false,
-                features: [],
-                error: "Ollama service unavailable. Please ensure Ollama is running with llama3.2-vision model.",
-                processingTimeMs: Date.now() - visionStartTime,
-                modelName: "llama3.2-vision",
-            };
-            // Phase 4: 進捗報告 - Ollama利用不可（100%で完了扱い）
-            if (progressReporter) {
-                progressReporter.updatePhase("completing");
-                progressReporter.complete();
-            }
-        }
-    }
-    catch (visionError) {
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.error("[layout-handler] Vision analysis failed", { error: visionError });
-        }
-        result.visionFeatures = {
-            success: false,
-            features: [],
-            error: visionError instanceof Error ? visionError.message : "Vision analysis failed",
-            processingTimeMs: Date.now() - visionStartTime,
-            modelName: "llama3.2-vision",
-        };
-        // Phase 4: 進捗報告 - エラー終了（100%で完了扱い）
-        if (progressReporter) {
-            progressReporter.updatePhase("completing");
-            progressReporter.complete();
-        }
-    }
-    return analysisResult;
-}
-/**
- * Per-Section Vision分析を実行
- */
-async function executePerSectionVisionAnalysis(screenshot, sections, options) {
-    const perSectionStartTime = Date.now();
-    if ((0, logger_1.isDevelopment)()) {
-        logger_1.logger.info("[layout-handler] Per-section Vision analysis: starting", {
-            sectionCount: sections.length,
-            batchSize: options?.visionBatchSize ?? 3,
-        });
-    }
-    try {
-        const screenshotService = new section_screenshot_service_1.SectionScreenshotService();
-        const batchSize = options?.visionBatchSize ?? 3;
-        // セクション境界情報を収集
-        const allSectionsWithBounds = sections
-            .filter((s) => s.position?.startY !== undefined && s.position?.endY !== undefined)
-            .map((s) => ({
-            id: s.id,
-            type: s.type,
-            bounds: {
-                startY: s.position.startY,
-                endY: s.position.endY,
-                height: s.position.endY - s.position.startY,
-            },
-        }));
-        // メモリ保護: 最大セクション数に制限
-        const sectionsWithBounds = allSectionsWithBounds.slice(0, types_1.MAX_SECTIONS_FOR_PER_SECTION_VISION);
-        if (allSectionsWithBounds.length > types_1.MAX_SECTIONS_FOR_PER_SECTION_VISION) {
-            logger_1.logger.warn("[layout-handler] Per-section Vision analysis: section count exceeded limit", {
-                totalSections: allSectionsWithBounds.length,
-                processedSections: sectionsWithBounds.length,
-                maxSections: types_1.MAX_SECTIONS_FOR_PER_SECTION_VISION,
-                skippedSections: allSectionsWithBounds.length - sectionsWithBounds.length,
-            });
-        }
-        if (sectionsWithBounds.length > 0) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.debug("[layout-handler] Per-section Vision analysis: extracting sections", {
-                    sectionsWithBoundsCount: sectionsWithBounds.length,
-                });
-            }
-            const extractResult = await screenshotService.extractMultipleSections(screenshot.base64, sectionsWithBounds.map((s) => ({ id: s.id, bounds: s.bounds })));
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.debug("[layout-handler] Per-section Vision analysis: extraction complete", {
-                    successCount: extractResult.successes.length,
-                    errorCount: extractResult.errors.length,
-                });
-            }
-            const { LlamaVisionAdapter } = await import("../../../services/vision-adapter/index.js");
-            const visionAdapter = new LlamaVisionAdapter();
-            const isVisionAvailable = await visionAdapter.isAvailable();
-            if (isVisionAvailable) {
-                const totalBatches = Math.ceil(extractResult.successes.length / batchSize);
-                for (let i = 0; i < extractResult.successes.length; i += batchSize) {
-                    const batch = extractResult.successes.slice(i, i + batchSize);
-                    const batchIndex = Math.floor(i / batchSize) + 1;
-                    if ((0, logger_1.isDevelopment)()) {
-                        logger_1.logger.info(`[layout-handler] Per-section Vision analysis: batch ${batchIndex}/${totalBatches}`, {
-                            batchSectionIds: batch.map((b) => b.sectionId),
-                        });
-                    }
-                    const visionResults = await Promise.allSettled(batch.map((ss) => {
-                        const sectionInfo = sectionsWithBounds.find((s) => s.id === ss.sectionId);
-                        const sectionType = sectionInfo?.type;
-                        if (sectionType !== undefined) {
-                            return visionAdapter.analyzeSection({
-                                imageBuffer: ss.imageBuffer,
-                                mimeType: "image/png",
-                                features: ["layout_structure", "color_palette", "whitespace"],
-                                sectionId: ss.sectionId,
-                                sectionTypeHint: sectionType,
-                            });
-                        }
-                        return visionAdapter.analyzeSection({
-                            imageBuffer: ss.imageBuffer,
-                            mimeType: "image/png",
-                            features: ["layout_structure", "color_palette", "whitespace"],
-                            sectionId: ss.sectionId,
-                        });
-                    }));
-                    // 結果をセクションに紐付け
-                    for (let j = 0; j < batch.length; j++) {
-                        const batchItem = batch[j];
-                        if (!batchItem)
-                            continue;
-                        const sectionIndex = sections.findIndex((s) => s.id === batchItem.sectionId);
-                        if (sectionIndex >= 0) {
-                            const currentSection = sections[sectionIndex];
-                            if (!currentSection)
-                                continue;
-                            const visionResult = visionResults[j];
-                            if (!visionResult)
-                                continue;
-                            if (visionResult.status === "fulfilled") {
-                                const vr = visionResult.value;
-                                currentSection.visionFeatures = {
-                                    success: vr.success,
-                                    features: vr.features.map((f) => {
-                                        const feature = {
-                                            type: f.type,
-                                            confidence: f.confidence,
-                                        };
-                                        const featureData = f.data;
-                                        if (featureData &&
-                                            typeof featureData === "object" &&
-                                            "description" in featureData) {
-                                            feature.description = String(featureData.description);
-                                        }
-                                        return feature;
-                                    }),
-                                    textRepresentation: visionAdapter.generateSectionTextRepresentation(vr, currentSection.type),
-                                    processingTimeMs: vr.processingTimeMs,
-                                    modelName: vr.modelName,
-                                    sectionBounds: batchItem.bounds,
-                                };
-                            }
-                            else if (visionResult.status === "rejected") {
-                                currentSection.visionFeatures = {
-                                    success: false,
-                                    features: [],
-                                    error: String(visionResult.reason),
-                                    processingTimeMs: 0,
-                                    modelName: "llama3.2-vision",
-                                };
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] Per-section Vision analysis: Ollama not available");
-                }
-                for (const section of sections) {
-                    if (section.position) {
-                        section.visionFeatures = {
-                            success: false,
-                            features: [],
-                            error: "Ollama service unavailable for per-section Vision analysis.",
-                            processingTimeMs: 0,
-                            modelName: "llama3.2-vision",
-                        };
-                    }
-                }
-            }
-            // 切り出し失敗したセクションの処理
-            for (const extractError of extractResult.errors) {
-                const sectionIndex = sections.findIndex((s) => s.id === extractError.sectionId);
-                if (sectionIndex >= 0) {
-                    const failedSection = sections[sectionIndex];
-                    if (failedSection) {
-                        failedSection.visionFeatures = {
-                            success: false,
-                            features: [],
-                            error: `Screenshot extraction failed: ${extractError.errorMessage}`,
-                            processingTimeMs: 0,
-                            modelName: "llama3.2-vision",
-                        };
-                    }
-                }
-            }
-        }
-        if ((0, logger_1.isDevelopment)()) {
-            const perSectionProcessingTime = Date.now() - perSectionStartTime;
-            const successCount = sections.filter((s) => s.visionFeatures?.success).length;
-            logger_1.logger.info("[layout-handler] Per-section Vision analysis: completed", {
-                totalSections: sections.length,
-                processedSections: sectionsWithBounds.length,
-                successCount,
-                processingTimeMs: perSectionProcessingTime,
-            });
-        }
-    }
-    catch (perSectionError) {
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.error("[layout-handler] Per-section Vision analysis failed", {
-                error: perSectionError instanceof Error ? perSectionError.message : "Unknown error",
-            });
-        }
-        for (const section of sections) {
-            if (section.position && !section.visionFeatures) {
-                section.visionFeatures = {
-                    success: false,
-                    features: [],
-                    error: `Per-section analysis failed: ${perSectionError instanceof Error ? perSectionError.message : "Unknown error"}`,
-                    processingTimeMs: 0,
-                    modelName: "llama3.2-vision",
-                };
-            }
-        }
-    }
-}
-// =====================================================
-// メインエクスポート関数
-// =====================================================
-/**
- * デフォルトのレイアウト分析
- *
- * @reftrixmcp/webdesign-core の SectionDetector を使用した高精度なセクション検出
- * - セマンティック要素（header, nav, main, section, article, aside, footer）の検出
- * - class/id名ベースのヒューリスティックによるセクションタイプ推定
- * - グリッド/フレックスレイアウトの検出
- * - タイポグラフィ・色情報の抽出
- * - Vision API解析（useVision=true時、スクリーンショートから直接セクション検出）
- * - Computed Stylesのインラインスタイル適用（computedStyles指定時）
- *
- * @param html - 分析対象のHTML
- * @param options - レイアウト分析オプション
- * @param screenshot - Vision解析用スクリーンショート（useVision=true時に使用）
- * @param computedStyles - Computed Styles配列（PageIngestAdapterから取得、htmlSnippetにインラインスタイルとして適用）
- * @param baseUrl - ベースURL（外部CSS解決用）
- * @param preExtractedCssUrls - サニタイズ前のHTMLから抽出した外部CSS URL配列（DOMPurifyで<link>タグが除去される問題の回避策）
- * @param visionOptions - Vision CPU完走保証オプション
- * @param progressContext - MCP進捗報告コンテキスト（Vision CPU完走保証 Phase 4）
- * @param webPageId - 外部から渡されたwebPageId（asyncモードで一貫性を保証するため）
- */
-async function defaultAnalyzeLayout(html, options, screenshot, computedStyles, baseUrl, preExtractedCssUrls, visionOptions, progressContext, webPageId) {
-    const startTime = Date.now();
-    if ((0, logger_1.isDevelopment)()) {
-        logger_1.logger.debug("[layout-handler] defaultAnalyzeLayout called", {
-            htmlLength: html.length,
-            hasOptions: !!options,
-            useVision: options?.useVision,
-            hasScreenshot: !!screenshot,
-            hasComputedStyles: !!computedStyles,
-            computedStylesCount: computedStyles?.length ?? 0,
-            hasBaseUrl: !!baseUrl,
-        });
-    }
-    try {
-        const useVision = options?.useVision === true;
-        const shouldFetchExternalCss = options?.fetchExternalCss ?? true;
-        // LayoutAnalyzerService を使用してセクション検出（HTML解析）
-        const layoutAnalyzer = (0, layout_analyzer_service_1.getLayoutAnalyzerService)();
-        const analysisResult = await layoutAnalyzer.analyze(html, {
-            includeContent: true,
-            includeStyles: true,
-            ...(shouldFetchExternalCss &&
-                baseUrl && {
-                externalCss: {
-                    fetchExternalCss: true,
-                    baseUrl,
-                    // DOMPurifyで<link>タグが除去される問題の回避策
-                    // サニタイズ前のHTMLから抽出したURLを使用
-                    ...(preExtractedCssUrls &&
-                        preExtractedCssUrls.length > 0 && {
-                        preExtractedUrls: preExtractedCssUrls,
-                    }),
-                },
-            }),
-            // Computed StylesをhtmlSnippetにインラインスタイルとして適用
-            ...(computedStyles && computedStyles.length > 0 && { computedStyles }),
-        });
-        // セクションを LayoutServiceResult 形式に変換
-        const sections = analysisResult.sections.map((section, index) => {
-            const result = {
-                id: section.id,
-                type: section.type,
-                positionIndex: index,
-                confidence: section.confidence,
-            };
-            const headingText = section.content?.headings?.[0]?.text;
-            if (headingText !== undefined) {
-                result.heading = headingText;
-            }
-            if (section.htmlSnippet !== undefined) {
-                result.htmlSnippet = section.htmlSnippet;
-            }
-            if (section.position) {
-                result.position = {
-                    startY: section.position.startY,
-                    endY: section.position.endY,
-                    height: section.position.height,
-                };
-            }
-            return result;
-        });
-        const result = {
-            success: true,
-            sectionCount: analysisResult.sectionCount,
-            sectionTypes: analysisResult.sectionTypes,
-            processingTimeMs: analysisResult.processingTimeMs,
-        };
-        // cssSnippetが存在する場合は結果に含める（exactOptionalPropertyTypes対応）
-        if (analysisResult.cssSnippet !== undefined && analysisResult.cssSnippet.length > 0) {
-            result.cssSnippet = analysisResult.cssSnippet;
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.debug("[layout-handler] CSS snippet extracted", {
-                    cssSnippetLength: analysisResult.cssSnippet.length,
-                });
-            }
-        }
-        if (analysisResult.externalCssContent !== undefined &&
-            analysisResult.externalCssContent.length > 0) {
-            result.externalCssContent = analysisResult.externalCssContent;
-            // v0.1.0: CSS変数抽出（外部CSSが取得された場合）
-            // Webサイト構築時の参考データとして活用可能
-            try {
-                const cssVariableExtractor = (0, css_variable_extractor_service_1.createCSSVariableExtractorService)();
-                const combinedCss = [analysisResult.cssSnippet, analysisResult.externalCssContent]
-                    .filter(Boolean)
-                    .join("\n");
-                const cssVariablesResult = cssVariableExtractor.extractFromCSS(combinedCss);
-                if (cssVariablesResult.variables.length > 0 || cssVariablesResult.clampValues.length > 0) {
-                    result.cssVariables = cssVariablesResult;
-                    if ((0, logger_1.isDevelopment)()) {
-                        logger_1.logger.info("[layout-handler] CSS variables extracted", {
-                            variableCount: cssVariablesResult.variables.length,
-                            clampValueCount: cssVariablesResult.clampValues.length,
-                            calcExpressionCount: cssVariablesResult.calcExpressions.length,
-                            designTokensFramework: cssVariablesResult.designTokens.framework,
-                            processingTimeMs: cssVariablesResult.processingTimeMs,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] CSS variable extraction failed", { error });
-                }
-                // エラー時はcssVariablesを省略（Graceful Degradation）
-            }
-        }
-        if (analysisResult.externalCssMeta !== undefined) {
-            result.externalCssMeta = analysisResult.externalCssMeta;
-        }
-        // cssFrameworkが存在する場合は結果に含める（exactOptionalPropertyTypes対応）
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.debug("[layout-handler] Checking cssFramework from analysisResult", {
-                hasCssFramework: analysisResult.cssFramework !== undefined,
-                cssFrameworkValue: analysisResult.cssFramework,
-            });
-        }
-        if (analysisResult.cssFramework !== undefined) {
-            result.cssFramework = {
-                framework: analysisResult.cssFramework.framework,
-                confidence: analysisResult.cssFramework.confidence,
-                evidence: analysisResult.cssFramework.evidence,
-            };
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.debug("[layout-handler] CSS framework detected and set", {
-                    framework: analysisResult.cssFramework.framework,
-                    confidence: analysisResult.cssFramework.confidence,
-                    evidenceCount: analysisResult.cssFramework.evidence.length,
-                    resultCssFramework: result.cssFramework,
-                });
-            }
-        }
-        else {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.warn("[layout-handler] cssFramework is undefined in analysisResult");
-            }
-        }
-        // Background Design Detection
-        // CSSコンテンツから背景デザインパターンを検出（Graceful Degradation）
-        let backgroundDesigns = [];
-        try {
-            const bgDetector = (0, background_design_detector_service_1.createBackgroundDesignDetectorService)();
-            const bgResult = bgDetector.detect({
-                cssContent: analysisResult.cssSnippet ?? "",
-                htmlContent: html,
-                externalCssContent: analysisResult.externalCssContent ?? "",
-            });
-            backgroundDesigns = bgResult.backgrounds;
-            if ((0, logger_1.isDevelopment)() && backgroundDesigns.length > 0) {
-                logger_1.logger.info("[layout-handler] Background designs detected", {
-                    count: backgroundDesigns.length,
-                    types: backgroundDesigns.map((bg) => bg.designType),
-                    processingTimeMs: bgResult.processingTimeMs.toFixed(1),
-                });
-            }
-        }
-        catch (bgError) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.warn("[layout-handler] Background design detection failed", {
-                    error: bgError instanceof Error ? bgError.message : String(bgError),
-                });
-            }
-            // Graceful Degradation: 背景デザイン検出失敗はpage.analyzeを中断しない
-        }
-        // 検出された背景デザインを結果に含める
-        if (backgroundDesigns.length > 0) {
-            result.backgroundDesigns = backgroundDesigns;
-        }
-        // Vision解析実行（useVision=true かつ スクリーンショートがある場合）
-        let visionAnalysisResult = {};
-        if (useVision && screenshot) {
-            const visionStartTime = Date.now();
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.info("[layout-handler] Starting Vision analysis", {
-                    screenshotSize: screenshot.base64.length,
-                    mimeType: screenshot.mimeType,
-                });
-            }
-            visionAnalysisResult = await executePageVisionAnalysis(screenshot, result, visionStartTime, visionOptions, progressContext);
-        }
-        else if (useVision && !screenshot) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.warn("[layout-handler] useVision=true but no screenshot available, falling back to HTML analysis");
-            }
-            result.visionFeatures = {
-                success: false,
-                features: [],
-                error: "Screenshot not available for Vision analysis. Falling back to HTML analysis.",
-                processingTimeMs: 0,
-                modelName: "llama3.2-vision",
-            };
-        }
-        // Phase 1: Vision検出セクション境界とHTML検出セクションをマージ
-        const visionMergedSections = mergeVisionDetectedSections(sections, visionAnalysisResult.sectionBoundaries);
-        // Phase 1: Section Merge Post-Processor（過剰分割修正）
-        // JSDOM cannot interpret CSS layout (flexbox, grid, inline-block) → over-segmentation.
-        // Post-processor merges consecutive same-type sections and absorbs empty content.
-        const postProcessResult = (0, section_postprocessor_service_1.postProcessSections)(visionMergedSections);
-        const mergedSections = postProcessResult.sections;
-        if (postProcessResult.stats.mergedGroups > 0 ||
-            postProcessResult.stats.absorbedCount > 0 ||
-            postProcessResult.stats.splitCount > 0) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.info("[layout-handler] Section post-processing applied", postProcessResult.stats);
-            }
-        }
-        // マージ結果を更新（sectionCount, sectionTypesも更新）
-        if (mergedSections.length !== sections.length) {
-            result.sectionCount = mergedSections.length;
-            // sectionTypesを再計算
-            const updatedSectionTypes = {};
-            for (const section of mergedSections) {
-                updatedSectionTypes[section.type] = (updatedSectionTypes[section.type] ?? 0) + 1;
-            }
-            result.sectionTypes = updatedSectionTypes;
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.info("[layout-handler] Sections merged with Vision boundaries", {
-                    originalCount: sections.length,
-                    mergedCount: mergedSections.length,
-                    addedSections: mergedSections.length - sections.length,
-                });
-            }
-        }
-        // Phase 1: Deterministic Visual Feature Extraction (Screenshot必須)
-        // Note: computedStyles are passed for improved theme detection
-        // This allows accurate detection of dark themes from CSS-in-JS/Tailwind
-        if (useVision && screenshot) {
-            const visualFeaturesStartTime = Date.now();
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.info("[layout-handler] Starting Deterministic Visual Feature Extraction", {
-                    screenshotSize: screenshot.base64.length,
-                    hasComputedStyles: !!computedStyles,
-                    computedStylesCount: computedStyles?.length ?? 0,
-                });
-            }
-            const visualFeatures = await extractDeterministicVisualFeatures(screenshot, computedStyles);
-            if (visualFeatures) {
-                result.visualFeatures = visualFeatures;
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.info("[layout-handler] Deterministic Visual Features extracted", {
-                        hasDominantColors: !!visualFeatures.colors?.dominant?.length,
-                        hasAccentColors: !!visualFeatures.colors?.accent?.length,
-                        hasTheme: !!visualFeatures.theme,
-                        themeType: visualFeatures.theme?.type,
-                        hasDensity: !!visualFeatures.density,
-                        hasGradients: !!visualFeatures.gradient?.gradients?.length,
-                        processingTimeMs: Date.now() - visualFeaturesStartTime,
-                    });
-                }
-            }
-            else {
-                if ((0, logger_1.isDevelopment)()) {
-                    logger_1.logger.warn("[layout-handler] Deterministic Visual Feature Extraction failed, continuing without visualFeatures");
-                }
-            }
-        }
-        // オプションに応じて詳細を追加
-        // MCP-RESP-03: snake_case (include_html) を優先し、camelCase (includeHtml) はフォールバック
-        const shouldIncludeHtml = options?.include_html ?? options?.includeHtml;
-        const shouldIncludeScreenshot = options?.include_screenshot ?? options?.includeScreenshot;
-        if (shouldIncludeHtml) {
-            result.html = html;
-        }
-        if (shouldIncludeScreenshot) {
-            result.screenshot = {
-                base64: "placeholder",
-                format: types_1.DEFAULT_SCREENSHOT.FORMAT,
-                width: types_1.DEFAULT_SCREENSHOT.WIDTH,
-                height: types_1.DEFAULT_SCREENSHOT.HEIGHT,
-            };
-        }
-        if (options?.saveToDb) {
-            // webPageIdが外部から渡された場合はそれを使用（asyncモードでの一貫性保証）
-            // 渡されていない場合は新規生成
-            result.pageId = webPageId ?? (0, uuid_1.v7)();
-        }
-        // sections は summary=false の場合に返す（マージ後のセクションを使用）
-        result.sections = mergedSections;
-        // Per-Section Vision Analysis (perSectionVision=true の場合)
-        // マージ後のセクションを使用して各セクションの詳細Vision分析を実行
-        if (useVision && options?.perSectionVision && screenshot?.base64 && mergedSections.length > 0) {
-            await executePerSectionVisionAnalysis(screenshot, mergedSections, options);
-        }
-        // 最終処理時間を更新（Vision解析含む）
-        result.processingTimeMs = Date.now() - startTime;
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.debug("[layout-handler] defaultAnalyzeLayout completed", {
-                sectionCount: result.sectionCount,
-                sectionTypes: result.sectionTypes,
-                processingTimeMs: result.processingTimeMs,
-                hasVisionFeatures: !!result.visionFeatures,
-                hasTextRepresentation: !!result.textRepresentation,
-            });
-        }
-        return result;
-    }
-    catch (error) {
-        if ((0, logger_1.isDevelopment)()) {
-            logger_1.logger.error("[layout-handler] defaultAnalyzeLayout error", { error });
-        }
-        return {
-            success: false,
-            sectionCount: 0,
-            sectionTypes: {},
-            processingTimeMs: Date.now() - startTime,
-            error: {
-                code: schemas_1.PAGE_ANALYZE_ERROR_CODES.LAYOUT_ANALYSIS_FAILED,
-                message: error instanceof Error ? error.message : "Layout analysis failed",
-            },
-        };
-    }
-}
-//# sourceMappingURL=layout-handler.js.map