@lightcone-ai/daemon 0.15.52 → 0.15.54

package/src/_vendor/video/understanding/analyze-page.js

@@ -1,737 +0,0 @@
-import { existsSync } from 'fs';
-import { createRequire } from 'module';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-import {
-  buildHeuristicCoreMessage,
-  buildHeuristicHighlights,
-  buildRecruitmentSemanticSlots,
-  computeFocusRange,
-  derivePageType,
-} from './heuristics.js';
-import { isAnthropicConfigured, runTextLlm, runVisionLlm } from './llm-client.js';
-import { chooseUnderstandingPath, normalizePageUnderstanding } from './schema.js';
-import { SEMANTIC_CORE_SELECTORS, SITE_CORE_SELECTORS } from './site-selectors.js';
-
-const require = createRequire(import.meta.url);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const IOS_UA = 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1';
-
-const DEFAULT_OPTIONS = Object.freeze({
-  viewportWidth: 1080,
-  viewportHeight: 1920,
-  settleMs: 3500,
-  timeoutMs: 120000,
-  binHeight: 400,
-  minBinChars: 30,
-  minTextBins: 10,
-  maxVisionChunks: 6,
-  visionChunkHeight: 2200,
-  allowVisionFallback: true,
-  useLlm: true,
-});
-
-function clampInt(value, min, max, fallback) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return fallback;
-  return Math.max(min, Math.min(max, Math.round(n)));
-}
-
-function normalizeOptions(options = {}) {
-  return {
-    viewportWidth: clampInt(options.viewportWidth, 360, 2160, DEFAULT_OPTIONS.viewportWidth),
-    viewportHeight: clampInt(options.viewportHeight, 480, 3840, DEFAULT_OPTIONS.viewportHeight),
-    settleMs: clampInt(options.settleMs, 500, 30000, DEFAULT_OPTIONS.settleMs),
-    timeoutMs: clampInt(options.timeoutMs, 5000, 240000, DEFAULT_OPTIONS.timeoutMs),
-    binHeight: clampInt(options.binHeight, 200, 900, DEFAULT_OPTIONS.binHeight),
-    minBinChars: clampInt(options.minBinChars, 12, 200, DEFAULT_OPTIONS.minBinChars),
-    minTextBins: clampInt(options.minTextBins, 3, 40, DEFAULT_OPTIONS.minTextBins),
-    maxVisionChunks: clampInt(options.maxVisionChunks, 1, 12, DEFAULT_OPTIONS.maxVisionChunks),
-    visionChunkHeight: clampInt(options.visionChunkHeight, 700, 3000, DEFAULT_OPTIONS.visionChunkHeight),
-    allowVisionFallback: options.allowVisionFallback !== false,
-    useLlm: options.useLlm !== false,
-    executablePath: typeof options.executablePath === 'string' ? options.executablePath.trim() : '',
-    disableSandbox: options.disableSandbox !== false,
-  };
-}
-
-function resolveReadabilityScriptPath() {
-  try {
-    return require.resolve('@mozilla/readability/Readability.js');
-  } catch {
-    return '';
-  }
-}
-
-function resolveChromeExecutable(options = {}) {
-  const candidates = [
-    options.executablePath,
-    process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH,
-    process.env.GOOGLE_CHROME_BIN,
-    process.env.GOOGLE_CHROME_SHIM,
-    '/usr/bin/google-chrome',
-    '/usr/bin/google-chrome-stable',
-    '/usr/bin/chromium',
-    '/usr/bin/chromium-browser',
-  ]
-    .map(item => String(item ?? '').trim())
-    .filter(Boolean);
-
-  for (const filePath of candidates) {
-    if (existsSync(filePath)) return filePath;
-  }
-  return '';
-}
-
-async function loadPlaywrightChromium() {
-  try {
-    const mod = await import('playwright-core');
-    return mod.chromium;
-  } catch {
-    throw new Error('playwright_core_missing: run `npm install playwright-core`');
-  }
-}
-
-async function maybeInjectReadability(page) {
-  const readabilityPath = resolveReadabilityScriptPath();
-  if (!readabilityPath) return false;
-  try {
-    await page.addScriptTag({ path: readabilityPath });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function normalizeMeta(meta) {
-  const input = meta && typeof meta === 'object' ? meta : {};
-  return {
-    og_title: input.og_title ?? null,
-    og_description: input.og_description ?? null,
-    og_image: input.og_image ?? null,
-    title: input.title ?? null,
-    description: input.description ?? null,
-    publish_time: input.publish_time ?? null,
-    date: input.date ?? null,
-  };
-}
-
-async function extractStructure(page, { binHeight, minBinChars }) {
-  const structure = await page.evaluate(({
-    siteSelectors,
-    semanticSelectors,
-    binHeightPx,
-    minBinCharsCount,
-  }) => {
-    function cleanText(value) {
-      return String(value ?? '').replace(/\s+/g, ' ').trim();
-    }
-
-    function isVisibleEnough(element, minHeight = 120) {
-      if (!element) return false;
-      const rect = element.getBoundingClientRect();
-      if (!rect || rect.height < minHeight || rect.width < 200) return false;
-      const style = window.getComputedStyle(element);
-      return style.display !== 'none' && style.visibility !== 'hidden';
-    }
-
-    function pickElementFromSelectors(selectors) {
-      for (const selector of selectors) {
-        const el = document.querySelector(selector);
-        if (isVisibleEnough(el, 120)) return { element: el, selector };
-      }
-      return null;
-    }
-
-    function rangeFromMatches(matches, fallbackTotalHeight) {
-      if (!matches.length) return null;
-      const ys = matches.map(item => item.y).filter(Number.isFinite);
-      if (!ys.length) return null;
-      const top = Math.max(0, Math.min(...ys) - 120);
-      const bottom = Math.min(fallbackTotalHeight, Math.max(...ys) + 420);
-      if (bottom <= top + 100) return null;
-      return [Math.round(top), Math.round(bottom)];
-    }
-
-    function readabilityRange() {
-      if (typeof window.Readability !== 'function') return null;
-      const cloned = document.cloneNode(true);
-      let article = null;
-      try {
-        article = new window.Readability(cloned).parse();
-      } catch {
-        article = null;
-      }
-      if (!article?.textContent || article.textContent.length < 260) return null;
-
-      const snippets = article.textContent
-        .split(/[\n。！？!?]/g)
-        .map(text => cleanText(text))
-        .filter(text => text.length >= 24)
-        .slice(0, 28)
-        .map(text => text.slice(0, 32));
-
-      if (!snippets.length) return null;
-
-      const root = document.scrollingElement || document.documentElement;
-      const scrollTop = root.scrollTop;
-      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, {
-        acceptNode(node) {
-          const text = cleanText(node.nodeValue || '');
-          if (text.length < 20) return NodeFilter.FILTER_REJECT;
-          return NodeFilter.FILTER_ACCEPT;
-        },
-      });
-
-      const matches = [];
-      let node;
-      while ((node = walker.nextNode())) {
-        const text = cleanText(node.nodeValue || '');
-        const hit = snippets.some(snippet => text.includes(snippet));
-        if (!hit) continue;
-        const parent = node.parentElement;
-        if (!parent) continue;
-        const rect = parent.getBoundingClientRect();
-        const y = Math.round(rect.top + scrollTop);
-        if (!Number.isFinite(y) || rect.height < 10) continue;
-        matches.push({ y });
-        if (matches.length >= 400) break;
-      }
-
-      return rangeFromMatches(matches, root.scrollHeight);
-    }
-
-    function trimNoiseFromBottom(range, pageHeight, detectionStrategy) {
-      // Site-specific selectors already point to the exact content element — trust them.
-      if (detectionStrategy && detectionStrategy.startsWith('site:')) return range;
-
-      const [coreTop, rawBottom] = range;
-      const minContentHeight = 600; // always keep at least 600px of core content
-
-      // Selectors that reliably identify non-article noise below the body text.
-      const noiseSelectors = [
-        // Comment sections
-        '[class*="comment-list"]', '[class*="comment-wrap"]', '[class*="commentList"]',
-        '[id*="comment"]', '[class*="discuss"]', '[class*="reply-list"]',
-        // Related / recommended articles
-        '[class*="related-read"]', '[class*="related-article"]', '[class*="relatedArticle"]',
-        '[class*="recommend"]', '[class*="more-article"]', '[class*="further-reading"]',
-        // Article footer / bottom toolbars
-        '[class*="article-footer"]', '[class*="post-footer"]', '[class*="article-bottom"]',
-        // Social sharing bars that sit below the body
-        '[class*="share-bar"]', '[class*="share-wrap"]', '[class*="article-share"]',
-        // Generic page footer inside the core element
-        'footer',
-      ];
-
-      const root = document.scrollingElement || document.documentElement;
-      let trimBottom = rawBottom;
-
-      for (const sel of noiseSelectors) {
-        try {
-          const elements = document.querySelectorAll(sel);
-          for (const el of elements) {
-            if (!isVisibleEnough(el, 40)) continue;
-            const rect = el.getBoundingClientRect();
-            const elTop = Math.round(rect.top + root.scrollTop);
-            if (
-              elTop > coreTop + minContentHeight
-              && elTop < trimBottom
-              && rect.height > 60
-            ) {
-              trimBottom = elTop;
-            }
-          }
-        } catch {
-          // ignore selector errors for individual sites
-        }
-      }
-
-      return [coreTop, trimBottom];
-    }
-
-    function collectTextBins({ range, coreElement }) {
-      const [rangeTop, rangeBottom] = range;
-      const root = document.scrollingElement || document.documentElement;
-      const scrollTop = root.scrollTop;
-      const scope = coreElement || document.body;
-      const chunks = [];
-
-      const walker = document.createTreeWalker(scope, NodeFilter.SHOW_TEXT, {
-        acceptNode(node) {
-          const text = cleanText(node.nodeValue || '');
-          if (text.length < 4) return NodeFilter.FILTER_REJECT;
-          return NodeFilter.FILTER_ACCEPT;
-        },
-      });
-
-      let node;
-      while ((node = walker.nextNode())) {
-        const text = cleanText(node.nodeValue || '');
-        const parent = node.parentElement;
-        if (!parent) continue;
-        const rect = parent.getBoundingClientRect();
-        if (!rect || rect.height < 8) continue;
-        const y = Math.round(rect.top + scrollTop);
-        if (y < rangeTop || y > rangeBottom) continue;
-        chunks.push({ y, text });
-      }
-
-      chunks.sort((a, b) => a.y - b.y);
-      const bins = [];
-      const startY = Math.floor(rangeTop / binHeightPx) * binHeightPx;
-
-      for (let cursor = startY, idx = 0; cursor < rangeBottom; cursor += binHeightPx) {
-        const inBin = chunks.filter(item => item.y >= cursor && item.y < cursor + binHeightPx);
-        if (!inBin.length) continue;
-        const text = cleanText(inBin.map(item => item.text).join(' ')).slice(0, 420);
-        if (text.length <= minBinCharsCount) continue;
-        bins.push({
-          id: `bin_${idx}`,
-          y_start: cursor,
-          y_center: cursor + Math.floor(binHeightPx / 2),
-          text,
-        });
-        idx += 1;
-      }
-
-      return bins;
-    }
-
-    function collectHotspots({ range }) {
-      const [rangeTop, rangeBottom] = range;
-      const root = document.scrollingElement || document.documentElement;
-      const scrollTop = root.scrollTop;
-      const selectors = ['h1', 'h2', 'h3', 'strong', 'b', 'img'];
-      const list = [];
-
-      for (const selector of selectors) {
-        const nodes = document.querySelectorAll(selector);
-        for (const node of nodes) {
-          const rect = node.getBoundingClientRect();
-          if (!rect || rect.height < 8 || rect.width < 40) continue;
-          const y = Math.round(rect.top + scrollTop + rect.height / 2);
-          if (!Number.isFinite(y) || y < rangeTop || y > rangeBottom) continue;
-          const text = cleanText(node.textContent || '');
-          list.push({
-            id: `${selector}_${list.length + 1}`,
-            y,
-            type: selector,
-            reason: text ? text.slice(0, 80) : `anchor_${selector}`,
-            weight: selector.startsWith('h') ? 9 : selector === 'img' ? 8 : 7,
-          });
-          if (list.length >= 24) break;
-        }
-      }
-
-      return list;
-    }
-
-    function collectMeta() {
-      const pick = (selector, attr = 'content') => {
-        const element = document.querySelector(selector);
-        if (!element) return null;
-        const value = element.getAttribute(attr);
-        return cleanText(value);
-      };
-
-      return {
-        og_title: pick('meta[property="og:title"]'),
-        og_description: pick('meta[property="og:description"]'),
-        og_image: pick('meta[property="og:image"]'),
-        title: cleanText(document.title || ''),
-        description: pick('meta[name="description"]'),
-        publish_time: cleanText(document.querySelector('#publish_time')?.textContent || ''),
-        date: cleanText(document.querySelector('#publish_time, time, meta[property=\"article:published_time\"]')?.getAttribute?.('content')
-          || document.querySelector('#publish_time, time')?.textContent
-          || ''),
-      };
-    }
-
-    const host = String(location.hostname || '').toLowerCase();
-    const root = document.scrollingElement || document.documentElement;
-    const totalHeight = Math.max(root.scrollHeight, document.body?.scrollHeight || 0, window.innerHeight);
-    let strategy = 'fallback:body';
-    let coreElement = null;
-    let coreRange = null;
-
-    for (const [domain, selectors] of Object.entries(siteSelectors || {})) {
-      if (!host.includes(domain)) continue;
-      const picked = pickElementFromSelectors(selectors);
-      if (!picked) continue;
-      const rect = picked.element.getBoundingClientRect();
-      const top = Math.round(rect.top + root.scrollTop);
-      const bottom = Math.round(rect.bottom + root.scrollTop);
-      coreElement = picked.element;
-      coreRange = [Math.max(0, top), Math.min(totalHeight, bottom)];
-      strategy = `site:${domain}:${picked.selector}`;
-      break;
-    }
-
-    if (!coreRange) {
-      const readableRange = readabilityRange();
-      if (readableRange) {
-        coreRange = readableRange;
-        strategy = 'readability';
-      }
-    }
-
-    if (!coreRange) {
-      const semanticPicked = pickElementFromSelectors(semanticSelectors || []);
-      if (semanticPicked) {
-        const rect = semanticPicked.element.getBoundingClientRect();
-        const top = Math.round(rect.top + root.scrollTop);
-        const bottom = Math.round(rect.bottom + root.scrollTop);
-        coreElement = semanticPicked.element;
-        coreRange = [Math.max(0, top), Math.min(totalHeight, bottom)];
-        strategy = `semantic:${semanticPicked.selector}`;
-      }
-    }
-
-    if (!coreRange) {
-      coreRange = [0, totalHeight];
-      coreElement = document.body;
-      strategy = 'fallback:body';
-    }
-
-    if (coreRange[1] <= coreRange[0]) {
-      coreRange = [0, totalHeight];
-      strategy = `${strategy}:range_fixed`;
-    }
-
-    // Trim coreBottom to exclude footer noise (comments, related articles, recommendations)
-    // that commonly appear below the article body.
-    coreRange = trimNoiseFromBottom(coreRange, totalHeight, strategy);
-
-    const bins = collectTextBins({ range: coreRange, coreElement });
-    const focusRange = (() => {
-      const span = coreRange[1] - coreRange[0];
-      if (span <= 3000) return [...coreRange];
-      return [coreRange[0], coreRange[0] + Math.round(span * 0.7)];
-    })();
-
-    return {
-      strategy,
-      hostname: host,
-      total_height: totalHeight,
-      viewport_height: window.innerHeight,
-      core_y_range: coreRange,
-      focus_y_range: focusRange,
-      bins,
-      hotspots: collectHotspots({ range: coreRange }),
-      meta: collectMeta(),
-    };
-  }, {
-    siteSelectors: SITE_CORE_SELECTORS,
-    semanticSelectors: SEMANTIC_CORE_SELECTORS,
-    binHeightPx: binHeight,
-    minBinCharsCount: minBinChars,
-  });
-
-  return {
-    ...structure,
-    meta: normalizeMeta(structure.meta),
-  };
-}
-
-async function captureVisionChunks(page, structure, options) {
-  const chunks = [];
-  const [focusTop, focusBottom] = structure.focus_y_range;
-  const chunkHeight = options.visionChunkHeight;
-  const maxChunks = options.maxVisionChunks;
-
-  let y = focusTop;
-  let idx = 0;
-  while (y < focusBottom && idx < maxChunks) {
-    const height = Math.min(chunkHeight, focusBottom - y);
-    const imageBase64 = await page.screenshot({
-      type: 'png',
-      fullPage: true,
-      clip: {
-        x: 0,
-        y,
-        width: options.viewportWidth,
-        height,
-      },
-      encoding: 'base64',
-    });
-
-    chunks.push({
-      id: `chunk_${idx}`,
-      y_start: y,
-      y_end: y + height,
-      image_base64: imageBase64,
-    });
-
-    y += height;
-    idx += 1;
-  }
-
-  return chunks;
-}
-
-function coerceHighlights(highlights, focusRange) {
-  const [focusTop, focusBottom] = focusRange;
-  return (Array.isArray(highlights) ? highlights : [])
-    .map((row) => ({
-      y: Number.isFinite(Number(row?.y)) ? Math.round(Number(row.y)) : NaN,
-      from_chunk: String(row?.from_chunk ?? '').trim() || 'unknown',
-      reason: String(row?.reason ?? '').trim() || 'highlight',
-    }))
-    .filter((row) => Number.isFinite(row.y) && row.y >= focusTop && row.y <= focusBottom)
-    .slice(0, 3);
-}
-
-async function runTextPath({ persona, structure, options }) {
-  if (options.useLlm && isAnthropicConfigured()) {
-    try {
-      return await runTextLlm({ persona, structure });
-    } catch {
-      // fall through to heuristic
-    }
-  }
-
-  return {
-    core_message: buildHeuristicCoreMessage({
-      persona,
-      meta: structure.meta,
-      bins: structure.bins,
-    }),
-    highlights: buildHeuristicHighlights({
-      bins: structure.bins,
-      hotspots: structure.hotspots,
-      coreRange: structure.core_y_range,
-      focusRange: structure.focus_y_range,
-    }),
-    model_used: 'heuristic',
-  };
-}
-
-async function runVisionPath({ page, persona, structure, options }) {
-  const chunks = await captureVisionChunks(page, structure, options);
-  if (options.useLlm && chunks.length > 0 && isAnthropicConfigured()) {
-    try {
-      return await runVisionLlm({
-        persona,
-        structure,
-        chunks,
-      });
-    } catch {
-      // fall through to heuristic
-    }
-  }
-
-  return {
-    core_message: buildHeuristicCoreMessage({
-      persona,
-      meta: structure.meta,
-      bins: structure.bins,
-    }),
-    highlights: buildHeuristicHighlights({
-      bins: structure.bins,
-      hotspots: structure.hotspots,
-      coreRange: structure.core_y_range,
-      focusRange: structure.focus_y_range,
-    }),
-    model_used: 'heuristic',
-  };
-}
-
-function buildSkipZones(structure) {
-  const [coreTop, coreBottom] = structure.core_y_range;
-  const totalHeight = structure.total_height;
-  const zones = [];
-
-  if (coreTop > 0) zones.push({ y_range: [0, coreTop], reason: 'non_core_top' });
-  if (coreBottom < totalHeight) zones.push({ y_range: [coreBottom, totalHeight], reason: 'non_core_bottom' });
-
-  return zones;
-}
-
-function buildRecommendedDuration(highlightsCount) {
-  if (highlightsCount >= 3) return [45, 65];
-  if (highlightsCount === 2) return [35, 55];
-  return [28, 45];
-}
-
-export async function analyzePage({
-  url,
-  persona = '',
-  options = {},
-} = {}) {
-  const targetUrl = String(url ?? '').trim();
-  if (!targetUrl) throw new Error('url_required');
-
-  const normalizedOptions = normalizeOptions(options);
-  const chromium = await loadPlaywrightChromium();
-  const executablePath = resolveChromeExecutable(normalizedOptions);
-
-  if (!executablePath) {
-    throw new Error('chrome_executable_not_found');
-  }
-
-  const browser = await chromium.launch({
-    executablePath,
-    headless: true,
-    args: normalizedOptions.disableSandbox
-      ? ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
-      : ['--disable-dev-shm-usage'],
-  });
-
-  let pagePath = 'vision';
-  try {
-    const context = await browser.newContext({
-      viewport: {
-        width: normalizedOptions.viewportWidth,
-        height: normalizedOptions.viewportHeight,
-      },
-      isMobile: true,
-      hasTouch: true,
-      userAgent: IOS_UA,
-      deviceScaleFactor: 1,
-    });
-    const page = await context.newPage();
-
-    await page.goto(targetUrl, {
-      waitUntil: 'domcontentloaded',
-      timeout: normalizedOptions.timeoutMs,
-    });
-    try {
-      await page.waitForLoadState('networkidle', { timeout: 10000 });
-    } catch {
-      // ignore networkidle timeout
-    }
-    await page.waitForTimeout(normalizedOptions.settleMs);
-    await maybeInjectReadability(page);
-
-    const structure = await extractStructure(page, normalizedOptions);
-    const focusRange = computeFocusRange(structure.core_y_range);
-    structure.focus_y_range = focusRange;
-    structure.url = targetUrl;
-
-    pagePath = chooseUnderstandingPath(structure, {
-      minCount: normalizedOptions.minTextBins,
-      minChars: normalizedOptions.minBinChars,
-    });
-
-    let llmResult = null;
-    if (pagePath === 'text') {
-      llmResult = await runTextPath({ page, persona, structure, options: normalizedOptions });
-      const needsFallback = normalizedOptions.allowVisionFallback && (llmResult.highlights?.length ?? 0) < 1;
-      if (needsFallback) {
-        const visionResult = await runVisionPath({ page, persona, structure, options: normalizedOptions });
-        llmResult = {
-          ...visionResult,
-          fallback_from: 'text',
-        };
-        pagePath = 'vision_fallback';
-      }
-    } else {
-      llmResult = await runVisionPath({ page, persona, structure, options: normalizedOptions });
-    }
-
-    const normalizedHighlights = coerceHighlights(llmResult.highlights, structure.focus_y_range);
-    const pageType = derivePageType({ hostname: structure.hostname, meta: structure.meta });
-
-    const semanticOutput = buildRecruitmentSemanticSlots({
-      pageType,
-      url: targetUrl,
-      meta: structure.meta,
-      bins: structure.bins,
-      hotspots: structure.hotspots,
-      coreRange: structure.core_y_range,
-      focusRange: structure.focus_y_range,
-    });
-
-    return normalizePageUnderstanding({
-      url: targetUrl,
-      page_type: pageType,
-      hostname: structure.hostname,
-      core_message: llmResult.core_message || buildHeuristicCoreMessage({
-        persona,
-        meta: structure.meta,
-        bins: structure.bins,
-      }),
-      core_y_range: structure.core_y_range,
-      focus_y_range: structure.focus_y_range,
-      total_height: structure.total_height,
-      candidate_hotspots: normalizedHighlights,
-      skip_zones: buildSkipZones(structure),
-      recommended_duration_s: buildRecommendedDuration(normalizedHighlights.length),
-      semantic_slots: semanticOutput.semantic_slots,
-      mode_hint: semanticOutput.mode_hint,
-      mode_hint_confidence: semanticOutput.mode_hint_confidence,
-      meta: structure.meta,
-      hotspots: structure.hotspots,
-      debug: {
-        extraction_strategy: structure.strategy,
-        path: pagePath,
-        model_used: llmResult.model_used ?? 'heuristic',
-        bins_count: Array.isArray(structure.bins) ? structure.bins.length : 0,
-      },
-    });
-  } finally {
-    await browser.close().catch(() => {});
-  }
-}
-
-export async function analyzePageFromHtmlFixture({
-  url = 'https://fixture.local',
-  hostname = 'fixture.local',
-  coreRange = [200, 2200],
-  focusRange = [200, 1800],
-  totalHeight = 3000,
-  bins = [],
-  hotspots = [],
-  meta = {},
-  persona = '',
-} = {}) {
-  const highlights = buildHeuristicHighlights({
-    bins,
-    hotspots,
-    coreRange,
-    focusRange,
-  });
-
-  const pageType = derivePageType({ hostname, meta });
-  const semanticOutput = buildRecruitmentSemanticSlots({
-    pageType,
-    url,
-    meta,
-    bins,
-    hotspots,
-    coreRange,
-    focusRange,
-  });
-
-  return normalizePageUnderstanding({
-    url,
-    page_type: pageType,
-    hostname,
-    core_message: buildHeuristicCoreMessage({ persona, meta, bins }),
-    core_y_range: coreRange,
-    focus_y_range: focusRange,
-    total_height: totalHeight,
-    candidate_hotspots: highlights,
-    skip_zones: [
-      { y_range: [0, coreRange[0]], reason: 'non_core_top' },
-      { y_range: [coreRange[1], totalHeight], reason: 'non_core_bottom' },
-    ],
-    recommended_duration_s: buildRecommendedDuration(highlights.length),
-    semantic_slots: semanticOutput.semantic_slots,
-    mode_hint: semanticOutput.mode_hint,
-    mode_hint_confidence: semanticOutput.mode_hint_confidence,
-    meta,
-    hotspots,
-    debug: {
-      extraction_strategy: 'fixture',
-      path: chooseUnderstandingPath({ bins }),
-      model_used: 'heuristic',
-      bins_count: bins.length,
-      fixture_dir: __dirname,
-    },
-  });
-}