@reftrixmcp/mcp-server 0.1.7

package/dist/services/embedding-backfill.service.js

@@ -0,0 +1,672 @@
+"use strict";
+// SPDX-FileCopyrightText: 2026 TKMD and Reftrix Contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkWebPageEmbeddingCoverage = checkWebPageEmbeddingCoverage;
+exports.findWebPagesWithMissingEmbeddings = findWebPagesWithMissingEmbeddings;
+exports.backfillWebPageEmbeddings = backfillWebPageEmbeddings;
+/**
+ * Embedding Backfill Service
+ *
+ * page.analyze の Embedding フェーズ（Phase 5）で OOM 等により欠損した
+ * embedding を自動的に補完するサービス。
+ *
+ * 3つのエントリポイント:
+ * 1. backfillWebPageEmbeddings() — 特定 WebPage の欠損 embedding を補完
+ * 2. checkWebPageEmbeddingCoverage() — 欠損チェックのみ（バックフィルなし）
+ * 3. findWebPagesWithMissingEmbeddings() — 全 WebPage から欠損のあるものを検索
+ *
+ * メモリ管理 (v0.1.0):
+ * - 動的RSS閾値: システム全メモリ × ratio（デフォルト70%）
+ * - チャンク間は「メモリ圧力時のみ」dispose（通常はパイプライン保持）
+ * - 圧力検出時: dispose → GC → 待機 → 回復確認してから再開
+ * - CLI使用時は閾値0で無制限も可能
+ *
+ * @module services/embedding-backfill
+ */
+const database_1 = require("@reftrixmcp/database");
+const node_os_1 = __importDefault(require("node:os"));
+const layout_embedding_service_1 = require("./layout-embedding.service");
+const frame_embedding_service_1 = require("./motion/frame-embedding.service");
+const background_design_embedding_service_1 = require("./background/background-design-embedding.service");
+const embedding_handler_1 = require("../tools/page/handlers/embedding-handler");
+const responsive_analysis_embedding_service_1 = require("./responsive/responsive-analysis-embedding.service");
+// =====================================================
+// Constants
+// =====================================================
+/** Default chunk size for backfill */
+const DEFAULT_BACKFILL_CHUNK_SIZE = 30;
+/** Model name for embedding generation */
+const MODEL_NAME = "multilingual-e5-base";
+/** Default memory ratio: 70% of total system memory */
+const DEFAULT_MEMORY_RATIO = 0.7;
+/** Memory recovery wait time (ms) */
+const MEMORY_RECOVERY_WAIT_MS = 3000;
+/** Max memory recovery attempts before giving up for current chunk */
+const MAX_MEMORY_RECOVERY_ATTEMPTS = 3;
+// =====================================================
+// Memory Management
+// =====================================================
+/**
+ * Calculate RSS threshold based on system memory and ratio.
+ * Returns 0 if explicitly disabled.
+ */
+function resolveRssThreshold(options) {
+    if (options?.rssThreshold === 0)
+        return 0; // explicitly disabled
+    if (options?.rssThreshold !== undefined && options.rssThreshold > 0)
+        return options.rssThreshold;
+    const ratio = options?.memoryRatio ?? DEFAULT_MEMORY_RATIO;
+    return Math.floor(node_os_1.default.totalmem() * ratio);
+}
+function getRssBytes() {
+    return process.memoryUsage().rss;
+}
+function toGB(bytes) {
+    return Math.round((bytes / 1024 / 1024 / 1024) * 10) / 10;
+}
+function tryGarbageCollect() {
+    if (typeof global.gc === "function") {
+        global.gc();
+    }
+}
+/**
+ * Adaptive memory check with recovery.
+ *
+ * Returns 'ok' if memory is fine, 'recovered' if memory was released by dispose+GC,
+ * or 'exceeded' if memory couldn't be recovered after retries.
+ */
+async function checkMemoryPressure(threshold, embeddingService, type, onMemoryPressure) {
+    if (threshold <= 0)
+        return "ok";
+    const rss = getRssBytes();
+    if (rss <= threshold)
+        return "ok";
+    // Memory pressure detected — try to recover
+    const thresholdGB = toGB(threshold);
+    onMemoryPressure?.(type, toGB(rss), thresholdGB, "dispose");
+    await embeddingService.disposeEmbeddingPipeline();
+    tryGarbageCollect();
+    for (let attempt = 0; attempt < MAX_MEMORY_RECOVERY_ATTEMPTS; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, MEMORY_RECOVERY_WAIT_MS));
+        tryGarbageCollect();
+        const currentRss = getRssBytes();
+        if (currentRss <= threshold) {
+            return "recovered";
+        }
+    }
+    // Still above threshold after recovery attempts
+    onMemoryPressure?.(type, toGB(getRssBytes()), thresholdGB, "skip");
+    return "exceeded";
+}
+// =====================================================
+// DB → Text Conversion Functions
+// =====================================================
+function extractHeadingFromComponents(components) {
+    if (!Array.isArray(components))
+        return undefined;
+    for (const comp of components) {
+        if (typeof comp === "object" &&
+            comp !== null &&
+            "type" in comp &&
+            comp.type === "heading" &&
+            "text" in comp) {
+            return String(comp.text);
+        }
+    }
+    return undefined;
+}
+function dbMotionToEmbeddingInput(row) {
+    const animation = row.animation;
+    const properties = row.properties;
+    let duration;
+    if (animation && typeof animation.duration === "number") {
+        duration = animation.duration;
+    }
+    let easing = "ease";
+    if (animation) {
+        if (typeof animation.easing === "string") {
+            easing = animation.easing;
+        }
+        else if (typeof animation.easing === "object" && animation.easing !== null) {
+            const easingObj = animation.easing;
+            if (typeof easingObj.type === "string") {
+                easing = easingObj.type;
+            }
+        }
+    }
+    let propertyNames = [];
+    if (Array.isArray(properties)) {
+        propertyNames = properties
+            .map((p) => typeof p === "string"
+            ? p
+            : typeof p === "object" && p !== null && "property" in p
+                ? String(p.property)
+                : "")
+            .filter(Boolean);
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        type: row.type ?? "css_animation",
+        category: row.category,
+        trigger: row.trigger_type,
+        duration,
+        easing,
+        properties: propertyNames,
+        propertiesDetailed: undefined,
+        performance: {
+            level: "good",
+            usesTransform: false,
+            usesOpacity: false,
+        },
+        accessibility: {
+            respectsReducedMotion: false,
+        },
+    };
+}
+function dbBackgroundToTextInput(row) {
+    return {
+        name: row.name,
+        designType: row.design_type,
+        selector: row.selector ?? undefined,
+        colorInfo: row.color_info,
+        gradientInfo: row.gradient_info,
+        visualProperties: row.visual_properties,
+        animationInfo: row.animation_info,
+    };
+}
+function generateJsAnimationTextFromDb(row) {
+    const parts = [];
+    const typeName = row.cdp_source_type ?? row.animation_type;
+    parts.push(`JavaScript animation: ${row.name || typeName}`);
+    parts.push(`Type: ${typeName}`);
+    if (row.duration_ms !== null && row.duration_ms > 0) {
+        parts.push(`Duration: ${row.duration_ms}ms`);
+    }
+    if (row.easing) {
+        parts.push(`Easing: ${row.easing}`);
+    }
+    if (row.cdp_play_state) {
+        parts.push(`Play state: ${row.cdp_play_state}`);
+    }
+    const props = row.properties;
+    if (Array.isArray(props) && props.length > 0) {
+        const propNames = props
+            .map((p) => {
+            if (typeof p === "string")
+                return p;
+            if (typeof p === "object" && p !== null && "property" in p) {
+                return String(p.property);
+            }
+            return "";
+        })
+            .filter(Boolean);
+        if (propNames.length > 0) {
+            parts.push(`Properties: ${propNames.join(", ")}`);
+        }
+    }
+    if (row.library_type && row.library_type !== "unknown") {
+        const libraryLabels = {
+            gsap: "GSAP",
+            framer_motion: "Framer Motion",
+            anime_js: "anime.js",
+            three_js: "Three.js",
+            lottie: "Lottie",
+            web_animations_api: "Web Animations API",
+        };
+        const label = libraryLabels[row.library_type] ?? row.library_type;
+        parts.push(`Library: ${label}`);
+    }
+    if (row.trigger_type) {
+        parts.push(`Trigger: ${row.trigger_type}`);
+    }
+    return `passage: ${parts.join(". ")}.`;
+}
+// =====================================================
+// Missing Embedding Queries
+// =====================================================
+async function getMissingSectionEmbeddings(webPageId) {
+    return database_1.prisma.$queryRawUnsafe(`SELECT sp.id, sp.section_type, sp.position_index, sp.components, sp.visual_features
+     FROM section_patterns sp
+     LEFT JOIN section_embeddings se ON sp.id = se.section_pattern_id
+     WHERE sp.web_page_id = $1::uuid AND se.id IS NULL`, webPageId);
+}
+async function getMissingMotionEmbeddings(webPageId) {
+    return database_1.prisma.$queryRawUnsafe(`SELECT mp.id, mp.type, mp.name, mp.category, mp.trigger_type, mp.animation, mp.properties
+     FROM motion_patterns mp
+     LEFT JOIN motion_embeddings me ON mp.id = me.motion_pattern_id
+     WHERE mp.web_page_id = $1::uuid AND me.id IS NULL`, webPageId);
+}
+async function getMissingBackgroundEmbeddings(webPageId) {
+    return database_1.prisma.$queryRawUnsafe(`SELECT bd.id, bd.name, bd.design_type, bd.selector, bd.color_info, bd.gradient_info,
+            bd.visual_properties, bd.animation_info
+     FROM background_designs bd
+     LEFT JOIN background_design_embeddings bde ON bd.id = bde.background_design_id
+     WHERE bd.web_page_id = $1::uuid AND bde.id IS NULL`, webPageId);
+}
+async function getMissingJsAnimationEmbeddings(webPageId) {
+    return database_1.prisma.$queryRawUnsafe(`SELECT jap.id, jap.name, jap.library_type, jap.animation_type,
+            jap.description, jap.duration_ms, jap.easing, jap.trigger_type,
+            jap.properties, jap.cdp_source_type, jap.cdp_play_state
+     FROM js_animation_patterns jap
+     LEFT JOIN js_animation_embeddings jae ON jap.id = jae.js_animation_pattern_id
+     WHERE jap.web_page_id = $1::uuid AND jae.id IS NULL`, webPageId);
+}
+// =====================================================
+// Public API
+// =====================================================
+/**
+ * Check embedding coverage for a specific WebPage (no backfill)
+ */
+async function checkWebPageEmbeddingCoverage(webPageId) {
+    const results = [];
+    const sectionTotal = await database_1.prisma.sectionPattern.count({ where: { webPageId } });
+    const sectionEmbedded = await database_1.prisma.sectionEmbedding.count({
+        where: { sectionPattern: { webPageId } },
+    });
+    results.push({
+        type: "section",
+        total: sectionTotal,
+        embedded: sectionEmbedded,
+        missing: sectionTotal - sectionEmbedded,
+    });
+    const motionTotal = await database_1.prisma.motionPattern.count({ where: { webPageId } });
+    const motionEmbedded = await database_1.prisma.motionEmbedding.count({
+        where: { motionPattern: { webPageId } },
+    });
+    results.push({
+        type: "motion",
+        total: motionTotal,
+        embedded: motionEmbedded,
+        missing: motionTotal - motionEmbedded,
+    });
+    const bgTotal = await database_1.prisma.backgroundDesign.count({ where: { webPageId } });
+    const bgEmbedded = await database_1.prisma.backgroundDesignEmbedding.count({
+        where: { backgroundDesign: { webPageId } },
+    });
+    results.push({
+        type: "background",
+        total: bgTotal,
+        embedded: bgEmbedded,
+        missing: bgTotal - bgEmbedded,
+    });
+    const jsTotal = await database_1.prisma.jSAnimationPattern.count({ where: { webPageId } });
+    const jsEmbedded = await database_1.prisma.jSAnimationEmbedding.count({
+        where: { jsAnimationPattern: { webPageId } },
+    });
+    results.push({
+        type: "jsAnimation",
+        total: jsTotal,
+        embedded: jsEmbedded,
+        missing: jsTotal - jsEmbedded,
+    });
+    const responsiveTotal = await database_1.prisma.responsiveAnalysis.count({ where: { webPageId } });
+    const responsiveEmbedded = await database_1.prisma.responsiveAnalysisEmbedding.count({
+        where: { responsiveAnalysis: { webPageId } },
+    });
+    results.push({
+        type: "responsive",
+        total: responsiveTotal,
+        embedded: responsiveEmbedded,
+        missing: responsiveTotal - responsiveEmbedded,
+    });
+    return results;
+}
+/**
+ * Find all WebPages that have patterns with missing embeddings
+ */
+async function findWebPagesWithMissingEmbeddings() {
+    const rows = await database_1.prisma.$queryRawUnsafe(`
+    SELECT wp.id, wp.url, COUNT(*) as missing_count FROM (
+      SELECT sp.web_page_id
+      FROM section_patterns sp
+      LEFT JOIN section_embeddings se ON sp.id = se.section_pattern_id
+      WHERE se.id IS NULL
+      UNION ALL
+      SELECT mp.web_page_id
+      FROM motion_patterns mp
+      LEFT JOIN motion_embeddings me ON mp.id = me.motion_pattern_id
+      WHERE me.id IS NULL AND mp.web_page_id IS NOT NULL
+      UNION ALL
+      SELECT bd.web_page_id
+      FROM background_designs bd
+      LEFT JOIN background_design_embeddings bde ON bd.id = bde.background_design_id
+      WHERE bde.id IS NULL AND bd.web_page_id IS NOT NULL
+      UNION ALL
+      SELECT jap.web_page_id
+      FROM js_animation_patterns jap
+      LEFT JOIN js_animation_embeddings jae ON jap.id = jae.js_animation_pattern_id
+      WHERE jae.id IS NULL AND jap.web_page_id IS NOT NULL
+      UNION ALL
+      SELECT ra.web_page_id
+      FROM responsive_analyses ra
+      LEFT JOIN responsive_analysis_embeddings rae ON ra.id = rae.responsive_analysis_id
+      WHERE rae.id IS NULL
+    ) AS missing
+    JOIN web_pages wp ON wp.id = missing.web_page_id
+    GROUP BY wp.id, wp.url
+    ORDER BY missing_count DESC
+  `);
+    return rows.map((row) => ({
+        webPageId: row.id,
+        url: row.url,
+        missingCount: Number(row.missing_count),
+    }));
+}
+/**
+ * Backfill missing embeddings for a specific WebPage.
+ *
+ * Dynamic memory management:
+ * - Pipeline stays alive between chunks (fast GPU inference)
+ * - When RSS exceeds threshold: dispose → GC → wait → retry
+ * - If recovery fails: skip remaining items (next invocation will retry)
+ */
+async function backfillWebPageEmbeddings(webPageId, options) {
+    const chunkSize = Math.max(1, Math.min(options?.chunkSize ?? DEFAULT_BACKFILL_CHUNK_SIZE, 100));
+    const rssThreshold = resolveRssThreshold(options);
+    const onProgress = options?.onProgress;
+    const onMemoryPressure = options?.onMemoryPressure;
+    const result = {
+        sectionBackfilled: 0,
+        motionBackfilled: 0,
+        backgroundBackfilled: 0,
+        jsAnimationBackfilled: 0,
+        responsiveBackfilled: 0,
+        totalBackfilled: 0,
+        errors: [],
+        memorySkips: 0,
+    };
+    const embeddingService = new layout_embedding_service_1.LayoutEmbeddingService({ cacheEnabled: false });
+    try {
+        const missingSections = await getMissingSectionEmbeddings(webPageId);
+        if (missingSections.length > 0) {
+            const r = await backfillSections(missingSections, embeddingService, chunkSize, rssThreshold, result.errors, onProgress, onMemoryPressure);
+            result.sectionBackfilled = r.backfilled;
+            result.memorySkips += r.memorySkips;
+        }
+        const missingMotions = await getMissingMotionEmbeddings(webPageId);
+        if (missingMotions.length > 0) {
+            const r = await backfillMotions(missingMotions, embeddingService, chunkSize, rssThreshold, result.errors, onProgress, onMemoryPressure);
+            result.motionBackfilled = r.backfilled;
+            result.memorySkips += r.memorySkips;
+        }
+        const missingBackgrounds = await getMissingBackgroundEmbeddings(webPageId);
+        if (missingBackgrounds.length > 0) {
+            const r = await backfillBackgrounds(missingBackgrounds, embeddingService, chunkSize, rssThreshold, result.errors, onProgress, onMemoryPressure);
+            result.backgroundBackfilled = r.backfilled;
+            result.memorySkips += r.memorySkips;
+        }
+        const missingJsAnimations = await getMissingJsAnimationEmbeddings(webPageId);
+        if (missingJsAnimations.length > 0) {
+            const r = await backfillJsAnimations(missingJsAnimations, embeddingService, chunkSize, rssThreshold, result.errors, onProgress, onMemoryPressure);
+            result.jsAnimationBackfilled = r.backfilled;
+            result.memorySkips += r.memorySkips;
+        }
+        const missingResponsive = await getMissingResponsiveEmbeddings(webPageId);
+        if (missingResponsive.length > 0) {
+            const r = await backfillResponsive(missingResponsive, embeddingService, chunkSize, rssThreshold, result.errors, onProgress, onMemoryPressure);
+            result.responsiveBackfilled = r.backfilled;
+            result.memorySkips += r.memorySkips;
+        }
+        result.totalBackfilled =
+            result.sectionBackfilled +
+                result.motionBackfilled +
+                result.backgroundBackfilled +
+                result.jsAnimationBackfilled +
+                result.responsiveBackfilled;
+    }
+    finally {
+        await embeddingService.disposeEmbeddingPipeline();
+        tryGarbageCollect();
+    }
+    return result;
+}
+async function backfillSections(rows, embeddingService, chunkSize, rssThreshold, errors, onProgress, onMemoryPressure) {
+    let backfilled = 0;
+    let memorySkips = 0;
+    for (let offset = 0; offset < rows.length; offset += chunkSize) {
+        const memStatus = await checkMemoryPressure(rssThreshold, embeddingService, "section", onMemoryPressure);
+        if (memStatus === "exceeded") {
+            memorySkips++;
+            break;
+        }
+        const chunk = rows.slice(offset, offset + chunkSize);
+        for (const row of chunk) {
+            try {
+                const heading = extractHeadingFromComponents(row.components);
+                const sectionInput = {
+                    id: row.id,
+                    type: row.section_type,
+                    positionIndex: row.position_index,
+                    confidence: 1.0,
+                };
+                if (heading !== undefined) {
+                    sectionInput.heading = heading;
+                }
+                const text = (0, embedding_handler_1.generateSectionTextRepresentation)(sectionInput);
+                const { embedding } = await embeddingService.generateFromText(text);
+                await (0, layout_embedding_service_1.saveSectionEmbedding)(row.id, embedding, MODEL_NAME, text);
+                backfilled++;
+            }
+            catch (error) {
+                errors.push(`section[${row.id}]: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        onProgress?.("section", Math.min(offset + chunkSize, rows.length), rows.length);
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return { backfilled, memorySkips };
+}
+async function backfillMotions(rows, embeddingService, chunkSize, rssThreshold, errors, onProgress, onMemoryPressure) {
+    let backfilled = 0;
+    let memorySkips = 0;
+    for (let offset = 0; offset < rows.length; offset += chunkSize) {
+        const memStatus = await checkMemoryPressure(rssThreshold, embeddingService, "motion", onMemoryPressure);
+        if (memStatus === "exceeded") {
+            memorySkips++;
+            break;
+        }
+        const chunk = rows.slice(offset, offset + chunkSize);
+        for (const row of chunk) {
+            try {
+                const pattern = dbMotionToEmbeddingInput(row);
+                const text = (0, embedding_handler_1.generateMotionTextRepresentation)(pattern);
+                const { embedding } = await embeddingService.generateFromText(text);
+                await (0, frame_embedding_service_1.saveMotionEmbedding)(row.id, embedding, MODEL_NAME);
+                backfilled++;
+            }
+            catch (error) {
+                errors.push(`motion[${row.id}]: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        onProgress?.("motion", Math.min(offset + chunkSize, rows.length), rows.length);
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return { backfilled, memorySkips };
+}
+async function backfillBackgrounds(rows, embeddingService, chunkSize, rssThreshold, errors, onProgress, onMemoryPressure) {
+    let backfilled = 0;
+    let memorySkips = 0;
+    for (let offset = 0; offset < rows.length; offset += chunkSize) {
+        const memStatus = await checkMemoryPressure(rssThreshold, embeddingService, "background", onMemoryPressure);
+        if (memStatus === "exceeded") {
+            memorySkips++;
+            break;
+        }
+        const chunk = rows.slice(offset, offset + chunkSize);
+        for (const row of chunk) {
+            try {
+                const bgForText = dbBackgroundToTextInput(row);
+                const text = (0, background_design_embedding_service_1.generateBackgroundDesignTextRepresentation)(bgForText);
+                const embeddingResult = await embeddingService.generateFromText(text);
+                const createdRecord = await database_1.prisma.backgroundDesignEmbedding.create({
+                    data: {
+                        backgroundDesignId: row.id,
+                        textRepresentation: text,
+                        modelVersion: MODEL_NAME,
+                    },
+                });
+                const vectorString = `[${embeddingResult.embedding.join(",")}]`;
+                await database_1.prisma.$executeRawUnsafe(`UPDATE background_design_embeddings SET embedding = $1::vector WHERE id = $2::uuid`, vectorString, createdRecord.id);
+                backfilled++;
+            }
+            catch (error) {
+                errors.push(`background[${row.id}]: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        onProgress?.("background", Math.min(offset + chunkSize, rows.length), rows.length);
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return { backfilled, memorySkips };
+}
+async function backfillJsAnimations(rows, embeddingService, chunkSize, rssThreshold, errors, onProgress, onMemoryPressure) {
+    let backfilled = 0;
+    let memorySkips = 0;
+    for (let offset = 0; offset < rows.length; offset += chunkSize) {
+        const memStatus = await checkMemoryPressure(rssThreshold, embeddingService, "jsAnimation", onMemoryPressure);
+        if (memStatus === "exceeded") {
+            memorySkips++;
+            break;
+        }
+        const chunk = rows.slice(offset, offset + chunkSize);
+        const embeddingItems = [];
+        for (const row of chunk) {
+            try {
+                const text = generateJsAnimationTextFromDb(row);
+                const embeddingResult = await embeddingService.generateFromText(text);
+                embeddingItems.push({
+                    dbId: row.id,
+                    textRepresentation: text,
+                    embedding: embeddingResult.embedding,
+                });
+            }
+            catch (error) {
+                errors.push(`jsAnimation[${row.id}]: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (embeddingItems.length > 0) {
+            try {
+                await database_1.prisma.jSAnimationEmbedding.createMany({
+                    data: embeddingItems.map((item) => ({
+                        jsAnimationPatternId: item.dbId,
+                        textRepresentation: item.textRepresentation,
+                        modelVersion: MODEL_NAME,
+                    })),
+                });
+                const vectorUpdates = embeddingItems.filter((item) => item.embedding.length > 0);
+                if (vectorUpdates.length > 0) {
+                    const valuesClause = vectorUpdates
+                        .map((_, idx) => `($${idx * 2 + 1}::vector, $${idx * 2 + 2}::uuid)`)
+                        .join(", ");
+                    const params = [];
+                    for (const item of vectorUpdates) {
+                        params.push(`[${item.embedding.join(",")}]`);
+                        params.push(item.dbId);
+                    }
+                    await database_1.prisma.$executeRawUnsafe(`UPDATE js_animation_embeddings AS e SET embedding = v.vec FROM (VALUES ${valuesClause}) AS v(vec, pattern_id) WHERE e.js_animation_pattern_id = v.pattern_id`, ...params);
+                }
+                backfilled += embeddingItems.length;
+            }
+            catch (error) {
+                errors.push(`jsAnimation-batch: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        onProgress?.("jsAnimation", Math.min(offset + chunkSize, rows.length), rows.length);
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return { backfilled, memorySkips };
+}
+// =====================================================
+// Responsive Analysis Backfill
+// =====================================================
+async function getMissingResponsiveEmbeddings(webPageId) {
+    return database_1.prisma.$queryRawUnsafe(`
+    SELECT ra.id, ra.web_page_id, wp.url,
+           ra.viewports_analyzed, ra.differences, ra.breakpoints, ra.screenshot_diffs
+    FROM responsive_analyses ra
+    LEFT JOIN responsive_analysis_embeddings rae ON ra.id = rae.responsive_analysis_id
+    JOIN web_pages wp ON ra.web_page_id = wp.id
+    WHERE rae.id IS NULL AND ra.web_page_id = $1::uuid
+  `, webPageId);
+}
+function convertResponsiveRowToTextInput(row) {
+    const viewportsAnalyzed = Array.isArray(row.viewports_analyzed)
+        ? row.viewports_analyzed
+        : [];
+    const differences = Array.isArray(row.differences)
+        ? row.differences
+        : [];
+    const breakpoints = Array.isArray(row.breakpoints)
+        ? row.breakpoints
+        : undefined;
+    const screenshotDiffs = Array.isArray(row.screenshot_diffs)
+        ? row.screenshot_diffs
+        : undefined;
+    return {
+        id: row.id,
+        url: row.url ?? undefined,
+        viewportsAnalyzed,
+        differences,
+        breakpoints,
+        screenshotDiffs,
+    };
+}
+async function backfillResponsive(rows, embeddingService, chunkSize, rssThreshold, errors, onProgress, onMemoryPressure) {
+    let backfilled = 0;
+    let memorySkips = 0;
+    for (let offset = 0; offset < rows.length; offset += chunkSize) {
+        const memStatus = await checkMemoryPressure(rssThreshold, embeddingService, "responsive", onMemoryPressure);
+        if (memStatus === "exceeded") {
+            memorySkips++;
+            break;
+        }
+        const chunk = rows.slice(offset, offset + chunkSize);
+        const embeddingItems = [];
+        for (const row of chunk) {
+            try {
+                const textInput = convertResponsiveRowToTextInput(row);
+                const textRepresentation = (0, responsive_analysis_embedding_service_1.generateResponsiveAnalysisTextRepresentation)(textInput);
+                const { embedding } = await embeddingService.generateFromText(textRepresentation);
+                embeddingItems.push({ dbId: row.id, textRepresentation, embedding });
+            }
+            catch (error) {
+                errors.push(`responsive-${row.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (embeddingItems.length > 0) {
+            try {
+                await database_1.prisma.responsiveAnalysisEmbedding.createMany({
+                    data: embeddingItems.map((item) => ({
+                        responsiveAnalysisId: item.dbId,
+                        textRepresentation: item.textRepresentation,
+                        modelVersion: MODEL_NAME,
+                    })),
+                });
+                const vectorUpdates = embeddingItems.filter((item) => item.embedding.length > 0);
+                if (vectorUpdates.length > 0) {
+                    const valuesClause = vectorUpdates
+                        .map((_, idx) => `($${idx * 2 + 1}::vector, $${idx * 2 + 2}::uuid)`)
+                        .join(", ");
+                    const params = [];
+                    for (const item of vectorUpdates) {
+                        params.push(`[${item.embedding.join(",")}]`);
+                        params.push(item.dbId);
+                    }
+                    await database_1.prisma.$executeRawUnsafe(`UPDATE responsive_analysis_embeddings AS e SET embedding = v.vec FROM (VALUES ${valuesClause}) AS v(vec, analysis_id) WHERE e.responsive_analysis_id = v.analysis_id`, ...params);
+                }
+                backfilled += embeddingItems.length;
+            }
+            catch (error) {
+                errors.push(`responsive-batch: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        onProgress?.("responsive", Math.min(offset + chunkSize, rows.length), rows.length);
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return { backfilled, memorySkips };
+}
+//# sourceMappingURL=embedding-backfill.service.js.map