@absolutejs/absolute 0.19.0-beta.603 → 0.19.0-beta.605

package/dist/ai/index.js

@@ -216,6 +216,10 @@ var buildContextLabel = (metadata) => {
     return from ? `Message from ${from}` : "Message evidence";
   }
   const page = getContextNumber(metadata.page) ?? getContextNumber(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  if (page && region) {
+    return `Page ${page} region ${region}`;
+  }
   if (page) {
     return `Page ${page}`;
   }
@@ -239,6 +243,11 @@ var buildContextLabel = (metadata) => {
   if (speaker) {
     return `Speaker ${speaker}`;
   }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString(metadata.sectionTitle) ?? sectionPath.at(-1);
+  if (sectionTitle) {
+    return `Section ${sectionTitle}`;
+  }
   return;
 };
 var formatMediaTimestamp = (value) => {
@@ -256,6 +265,10 @@ var buildLocatorLabel = (metadata, source, title) => {
     return;
   }
   const page = getContextNumber(metadata.page) ?? getContextNumber(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  if (page && region) {
+    return `Page ${page} \xB7 Region ${region}`;
+  }
   if (page) {
     return `Page ${page}`;
   }
@@ -284,6 +297,10 @@ var buildLocatorLabel = (metadata, source, title) => {
   if (mediaStart) {
     return `Timestamp ${mediaStart}`;
   }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+  if (sectionPath.length > 0) {
+    return `Section ${sectionPath.join(" > ")}`;
+  }
   return;
 };
 var formatTimestampLabel = (value) => {
@@ -308,9 +325,11 @@ var buildProvenanceLabel = (metadata) => {
   const transcriptSource = getContextString(metadata.transcriptSource);
   const pdfTextMode = getContextString(metadata.pdfTextMode);
   const ocrEngine = getContextString(metadata.ocrEngine);
+  const ocrConfidence = getContextNumber(metadata.ocrRegionConfidence) ?? getContextNumber(metadata.ocrConfidence);
   const labels = [
     pdfTextMode ? `PDF ${pdfTextMode}` : "",
     ocrEngine ? `OCR ${ocrEngine}` : "",
+    typeof ocrConfidence === "number" ? `Confidence ${ocrConfidence.toFixed(2)}` : "",
     mediaKind ? `Media ${mediaKind}` : "",
     transcriptSource ? `Transcript ${transcriptSource}` : "",
     threadTopic ? `Thread ${threadTopic}` : "",
@@ -331,8 +350,10 @@ var buildExcerpt = (text, maxLength = 160) => {
 var buildGroundingReferenceEvidenceLabel = (reference) => [reference.label, reference.locatorLabel, reference.contextLabel].filter((value) => Boolean(value && value.length > 0)).filter((value, index, values) => values.findIndex((entry) => entry === value) === index).join(" \xB7 ");
 var buildGroundingReferenceEvidenceSummary = (reference) => [
   reference.source ?? reference.title ?? reference.chunkId,
+  reference.locatorLabel,
+  reference.contextLabel,
   reference.provenanceLabel
-].filter((value) => Boolean(value && value.length > 0)).join(" \xB7 ");
+].filter((value) => Boolean(value && value.length > 0)).filter((value, index, values) => values.findIndex((entry) => entry === value) === index).join(" \xB7 ");
 var buildGroundedAnswerCitationDetail = (reference) => ({
   contextLabel: reference.contextLabel,
   evidenceLabel: buildGroundingReferenceEvidenceLabel(reference),
@@ -356,12 +377,12 @@ var buildRAGCitations = (sources) => {
       continue;
     unique.set(key, {
       chunkId: source.chunkId,
-      contextLabel: buildContextLabel(source.metadata),
+      contextLabel: source.labels?.contextLabel ?? buildContextLabel(source.metadata),
       key,
       label: buildSourceLabel(source),
-      locatorLabel: buildLocatorLabel(source.metadata, source.source, source.title),
+      locatorLabel: source.labels?.locatorLabel ?? buildLocatorLabel(source.metadata, source.source, source.title),
       metadata: source.metadata,
-      provenanceLabel: buildProvenanceLabel(source.metadata),
+      provenanceLabel: source.labels?.provenanceLabel ?? buildProvenanceLabel(source.metadata),
       score: source.score,
       source: source.source,
       text: source.text,
@@ -431,7 +452,7 @@ var buildRAGGroundingReferences = (sources) => {
   const citationReferenceMap = buildRAGCitationReferenceMap(citations);
   return citations.map((citation) => ({
     chunkId: citation.chunkId,
-    contextLabel: buildContextLabel(citation.metadata),
+    contextLabel: citation.contextLabel ?? buildContextLabel(citation.metadata),
     excerpt: buildExcerpt(citation.text),
     label: citation.label,
     locatorLabel: citation.locatorLabel ?? buildLocatorLabel(citation.metadata, citation.source, citation.title),
@@ -3977,6 +3998,10 @@ var buildContextLabel2 = (metadata) => {
     return from ? `Message from ${from}` : "Message evidence";
   }
   const page = getContextNumber2(metadata.page) ?? getContextNumber2(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber2(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  if (page && region) {
+    return `Page ${page} region ${region}`;
+  }
   if (page) {
     return `Page ${page}`;
   }
@@ -4000,6 +4025,11 @@ var buildContextLabel2 = (metadata) => {
   if (speaker) {
     return `Speaker ${speaker}`;
   }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString2(metadata.sectionTitle) ?? sectionPath.at(-1);
+  if (sectionTitle) {
+    return `Section ${sectionTitle}`;
+  }
   return;
 };
 var buildLocatorLabel2 = (metadata, source, title) => {
@@ -4007,6 +4037,10 @@ var buildLocatorLabel2 = (metadata, source, title) => {
     return;
   }
   const page = getContextNumber2(metadata.page) ?? getContextNumber2(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber2(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  if (page && region) {
+    return `Page ${page} \xB7 Region ${region}`;
+  }
   if (page) {
     return `Page ${page}`;
   }
@@ -4035,6 +4069,10 @@ var buildLocatorLabel2 = (metadata, source, title) => {
   if (mediaStart) {
     return `Timestamp ${mediaStart}`;
   }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  if (sectionPath.length > 0) {
+    return `Section ${sectionPath.join(" > ")}`;
+  }
   return;
 };
 var buildProvenanceLabel2 = (metadata) => {
@@ -4049,9 +4087,11 @@ var buildProvenanceLabel2 = (metadata) => {
   const transcriptSource = getContextString2(metadata.transcriptSource);
   const pdfTextMode = getContextString2(metadata.pdfTextMode);
   const ocrEngine = getContextString2(metadata.ocrEngine);
+  const ocrConfidence = getContextNumber2(metadata.ocrRegionConfidence) ?? getContextNumber2(metadata.ocrConfidence);
   const labels = [
     pdfTextMode ? `PDF ${pdfTextMode}` : "",
     ocrEngine ? `OCR ${ocrEngine}` : "",
+    typeof ocrConfidence === "number" ? `Confidence ${ocrConfidence.toFixed(2)}` : "",
     mediaKind ? `Media ${mediaKind}` : "",
     transcriptSource ? `Transcript ${transcriptSource}` : "",
     threadTopic ? `Thread ${threadTopic}` : "",
@@ -4061,6 +4101,50 @@ var buildProvenanceLabel2 = (metadata) => {
   ].filter((value) => value.length > 0);
   return labels.length > 0 ? labels.join(" \xB7 ") : undefined;
 };
+var buildRAGSourceLabels = ({
+  metadata,
+  source,
+  title
+}) => {
+  const contextLabel = buildContextLabel2(metadata);
+  const locatorLabel = buildLocatorLabel2(metadata, source, title);
+  const provenanceLabel = buildProvenanceLabel2(metadata);
+  if (!contextLabel && !locatorLabel && !provenanceLabel) {
+    return;
+  }
+  return {
+    contextLabel,
+    locatorLabel,
+    provenanceLabel
+  };
+};
+var buildRAGChunkStructure = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.filter((value) => typeof value === "string" && value.trim().length > 0) : undefined;
+  const sectionKind = metadata.sectionKind === "markdown_heading" || metadata.sectionKind === "html_heading" ? metadata.sectionKind : undefined;
+  const section = {
+    depth: getContextNumber2(metadata.sectionDepth),
+    kind: sectionKind,
+    path: sectionPath && sectionPath.length > 0 ? sectionPath : undefined,
+    title: getContextString2(metadata.sectionTitle)
+  };
+  const sequence = {
+    nextChunkId: getContextString2(metadata.nextChunkId),
+    previousChunkId: getContextString2(metadata.previousChunkId),
+    sectionChunkCount: getContextNumber2(metadata.sectionChunkCount),
+    sectionChunkId: getContextString2(metadata.sectionChunkId),
+    sectionChunkIndex: getContextNumber2(metadata.sectionChunkIndex)
+  };
+  if (!section.title && (!section.path || section.path.length === 0) && typeof section.depth !== "number" && !section.kind && !sequence.nextChunkId && !sequence.previousChunkId && typeof sequence.sectionChunkCount !== "number" && !sequence.sectionChunkId && typeof sequence.sectionChunkIndex !== "number") {
+    return;
+  }
+  return {
+    section: section.title || section.path && section.path.length > 0 || typeof section.depth === "number" || section.kind ? section : undefined,
+    sequence: sequence.nextChunkId || sequence.previousChunkId || typeof sequence.sectionChunkCount === "number" || sequence.sectionChunkId || typeof sequence.sectionChunkIndex === "number" ? sequence : undefined
+  };
+};
 var buildExcerpt2 = (text, maxLength = 160) => {
   const normalized = text.replaceAll(/\s+/g, " ").trim();
   if (normalized.length <= maxLength) {
@@ -4068,6 +4152,136 @@ var buildExcerpt2 = (text, maxLength = 160) => {
   }
   return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
 };
+var buildRAGChunkGraph = (chunks) => {
+  const nodes = [];
+  const edges = [];
+  const edgeKeys = new Set;
+  const sections = new Map;
+  for (const chunk of chunks) {
+    const labels = chunk.labels ?? buildRAGSourceLabels({
+      metadata: chunk.metadata,
+      source: chunk.source,
+      title: chunk.title
+    });
+    const structure = chunk.structure ?? buildRAGChunkStructure(chunk.metadata);
+    nodes.push({
+      chunkId: chunk.chunkId,
+      contextLabel: labels?.contextLabel,
+      label: chunk.source ?? chunk.title ?? chunk.chunkId,
+      locatorLabel: labels?.locatorLabel,
+      provenanceLabel: labels?.provenanceLabel,
+      score: chunk.score,
+      source: chunk.source,
+      structure,
+      title: chunk.title
+    });
+    const previousChunkId = structure?.sequence?.previousChunkId;
+    if (previousChunkId) {
+      const key = `previous:${previousChunkId}:${chunk.chunkId}`;
+      if (!edgeKeys.has(key)) {
+        edgeKeys.add(key);
+        edges.push({
+          fromChunkId: previousChunkId,
+          relation: "previous",
+          toChunkId: chunk.chunkId
+        });
+      }
+    }
+    const nextChunkId = structure?.sequence?.nextChunkId;
+    if (nextChunkId) {
+      const key = `next:${chunk.chunkId}:${nextChunkId}`;
+      if (!edgeKeys.has(key)) {
+        edgeKeys.add(key);
+        edges.push({
+          fromChunkId: chunk.chunkId,
+          relation: "next",
+          toChunkId: nextChunkId
+        });
+      }
+    }
+    const sectionId = structure?.sequence?.sectionChunkId;
+    if (sectionId) {
+      const existing = sections.get(sectionId);
+      if (!existing) {
+        sections.set(sectionId, {
+          chunkCount: structure.sequence?.sectionChunkCount ?? 1,
+          chunkIds: [chunk.chunkId],
+          depth: structure.section?.depth,
+          id: sectionId,
+          kind: structure.section?.kind,
+          path: structure.section?.path,
+          title: structure.section?.title
+        });
+        continue;
+      }
+      if (!existing.chunkIds.includes(chunk.chunkId)) {
+        existing.chunkIds.push(chunk.chunkId);
+      }
+      existing.chunkCount = Math.max(existing.chunkCount, structure.sequence?.sectionChunkCount ?? existing.chunkCount);
+    }
+  }
+  for (const section of sections.values()) {
+    section.chunkIds.sort((left, right) => {
+      const leftNode = nodes.find((node) => node.chunkId === left);
+      const rightNode = nodes.find((node) => node.chunkId === right);
+      const leftIndex = leftNode?.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+      const rightIndex = rightNode?.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+      if (leftIndex !== rightIndex) {
+        return leftIndex - rightIndex;
+      }
+      return left.localeCompare(right);
+    });
+  }
+  nodes.sort((left, right) => {
+    const leftSection = left.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+    const rightSection = right.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+    if (leftSection !== rightSection) {
+      return leftSection - rightSection;
+    }
+    const leftScore = left.score ?? Number.NEGATIVE_INFINITY;
+    const rightScore = right.score ?? Number.NEGATIVE_INFINITY;
+    if (leftScore !== rightScore) {
+      return rightScore - leftScore;
+    }
+    return left.label.localeCompare(right.label);
+  });
+  return {
+    edges,
+    nodes,
+    sections: [...sections.values()].sort((left, right) => (left.title ?? left.id).localeCompare(right.title ?? right.id))
+  };
+};
+var buildRAGChunkPreviewGraph = (preview) => buildRAGChunkGraph(preview.chunks.map((chunk) => ({
+  chunkId: chunk.chunkId,
+  labels: chunk.labels,
+  metadata: chunk.metadata,
+  source: chunk.source ?? preview.document.source,
+  structure: chunk.structure,
+  title: chunk.title ?? preview.document.title
+})));
+var buildRAGChunkPreviewNavigation = (preview, activeChunkId) => buildRAGChunkGraphNavigation(buildRAGChunkPreviewGraph(preview), activeChunkId);
+var buildRAGChunkGraphNavigation = (graph, activeChunkId) => {
+  if (graph.nodes.length === 0) {
+    return {
+      activeChunkId,
+      sectionNodes: []
+    };
+  }
+  const activeNode = (activeChunkId ? graph.nodes.find((node) => node.chunkId === activeChunkId) : undefined) ?? graph.nodes[0];
+  const resolvedActiveChunkId = activeNode?.chunkId;
+  const previousNode = activeNode?.structure?.sequence?.previousChunkId ? graph.nodes.find((node) => node.chunkId === activeNode.structure?.sequence?.previousChunkId) : undefined;
+  const nextNode = activeNode?.structure?.sequence?.nextChunkId ? graph.nodes.find((node) => node.chunkId === activeNode.structure?.sequence?.nextChunkId) : undefined;
+  const section = activeNode?.structure?.sequence?.sectionChunkId ? graph.sections.find((entry) => entry.id === activeNode.structure?.sequence?.sectionChunkId) : undefined;
+  const sectionNodes = section ? section.chunkIds.map((chunkId) => graph.nodes.find((node) => node.chunkId === chunkId)).filter((node) => Boolean(node)) : activeNode ? [activeNode] : [];
+  return {
+    activeChunkId: resolvedActiveChunkId,
+    activeNode,
+    nextNode,
+    previousNode,
+    section,
+    sectionNodes
+  };
+};
 var buildRAGRetrievedState = (messages) => {
   const message = getLatestRetrievedMessage(messages);
   if (!message) {
@@ -4102,13 +4316,14 @@ var buildRAGSourceSummaries = (sources) => {
       citationNumbers: groupCitations.map((citation) => citationReferenceMap[citation.chunkId] ?? 0),
       citations: groupCitations,
       chunkIds: group.chunks.map((chunk) => chunk.chunkId),
-      contextLabel: buildContextLabel2(leadChunk?.metadata),
+      contextLabel: leadChunk?.labels?.contextLabel ?? buildContextLabel2(leadChunk?.metadata),
       count: group.count,
       excerpt: buildExcerpt2(leadChunk?.text ?? ""),
       key: group.key,
       label: group.label,
-      locatorLabel: buildLocatorLabel2(leadChunk?.metadata, leadChunk?.source, leadChunk?.title),
-      provenanceLabel: buildProvenanceLabel2(leadChunk?.metadata),
+      locatorLabel: leadChunk?.labels?.locatorLabel ?? buildLocatorLabel2(leadChunk?.metadata, leadChunk?.source, leadChunk?.title),
+      provenanceLabel: leadChunk?.labels?.provenanceLabel ?? buildProvenanceLabel2(leadChunk?.metadata),
+      structure: leadChunk?.structure ?? buildRAGChunkStructure(leadChunk?.metadata),
       source: group.source,
       title: group.title
     };
@@ -4232,6 +4447,12 @@ var buildSourceGroup = (source, key) => ({
   count: 1,
   key,
   label: buildSourceLabel2(source),
+  labels: source.labels ?? buildRAGSourceLabels({
+    metadata: source.metadata,
+    source: source.source,
+    title: source.title
+  }),
+  structure: source.structure ?? buildRAGChunkStructure(source.metadata),
   source: source.source,
   title: source.title
 });
@@ -4242,7 +4463,20 @@ var updateSourceGroup = (groups, source) => {
     groups.set(key, buildSourceGroup(source, key));
     return;
   }
-  existing.bestScore = Math.max(existing.bestScore, source.score);
+  if (source.score > existing.bestScore) {
+    existing.bestScore = source.score;
+    existing.label = buildSourceLabel2(source);
+    existing.labels = source.labels ?? buildRAGSourceLabels({
+      metadata: source.metadata,
+      source: source.source,
+      title: source.title
+    });
+    existing.structure = source.structure ?? buildRAGChunkStructure(source.metadata);
+    existing.source = source.source;
+    existing.title = source.title;
+  } else {
+    existing.bestScore = Math.max(existing.bestScore, source.score);
+  }
   existing.count += 1;
   existing.chunks.push(source);
 };
@@ -7787,11 +8021,71 @@ var decodeHtmlEntities = (value) => {
   output = output.replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)));
   return output.replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16)));
 };
-var stripHtml = (value) => {
-  const withoutTags = value.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<br\s*\/?>/gi, `
+var formatHtmlLinkContext = (href) => {
+  const decoded = decodeHtmlEntities(href.trim());
+  if (!decoded) {
+    return;
+  }
+  if (decoded.startsWith("#")) {
+    return decoded;
+  }
+  if (/^[a-z]+:/i.test(decoded)) {
+    try {
+      const url = new URL(decoded);
+      const path = url.pathname === "/" ? "" : url.pathname;
+      return `${url.hostname}${path}`;
+    } catch {
+      return decoded;
+    }
+  }
+  return decoded;
+};
+var stripHtmlTags = (value) => {
+  const withoutTags = value.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<a\b[^>]*href=(['"])(.*?)\1[^>]*>([\s\S]*?)<\/a>/gi, (_match, _quote, href, inner) => {
+    const label = normalizeWhitespace(stripHtmlTags(inner));
+    const context = formatHtmlLinkContext(href);
+    if (!label) {
+      return context ?? " ";
+    }
+    if (!context || context === label) {
+      return label;
+    }
+    return `${label} (${context})`;
+  }).replace(/<br\s*\/?>/gi, `
 `).replace(/<\/(p|div|section|article|li|ul|ol|h[1-6]|table|tr)>/gi, `
 `).replace(/<li\b[^>]*>/gi, "- ").replace(/<[^>]+>/g, " ");
-  return normalizeWhitespace(decodeHtmlEntities(withoutTags));
+  return decodeHtmlEntities(withoutTags);
+};
+var extractMainHtmlContent = (value) => {
+  const trimmed = value.trim();
+  if (!/<html\b|<body\b|<main\b|<article\b/i.test(trimmed)) {
+    return value;
+  }
+  const boilerplateStripped = trimmed.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<(nav|footer|header|aside|form)\b[^>]*>[\s\S]*?<\/\1>/gi, " ");
+  const mainMatch = boilerplateStripped.match(/<main\b[^>]*>([\s\S]*?)<\/main>/i);
+  if (mainMatch?.[1]) {
+    return mainMatch[1];
+  }
+  const articleMatches = [
+    ...boilerplateStripped.matchAll(/<article\b[^>]*>([\s\S]*?)<\/article>/gi)
+  ].map((match) => match[1]?.trim()).filter(Boolean);
+  if (articleMatches.length > 0) {
+    return articleMatches.join(`
+`);
+  }
+  const roleMainMatch = boilerplateStripped.match(/<([a-z0-9:_-]+)\b[^>]*\brole=(['"])main\2[^>]*>([\s\S]*?)<\/\1>/i);
+  if (roleMainMatch?.[3]) {
+    return roleMainMatch[3];
+  }
+  const bodyMatch = boilerplateStripped.match(/<body\b[^>]*>([\s\S]*?)<\/body>/i);
+  if (bodyMatch?.[1]) {
+    return bodyMatch[1];
+  }
+  return boilerplateStripped;
+};
+var stripHtml = (value) => {
+  const focused = extractMainHtmlContent(value);
+  return normalizeWhitespace(stripHtmlTags(focused));
 };
 var stripMarkdown = (value) => {
   const withoutCodeBlocks = value.replace(/```[\s\S]*?```/g, (block) => {
@@ -7811,31 +8105,93 @@ var markdownStructureUnits = (value) => {
 `);
   const sections = [];
   let current = [];
+  let currentPath = [];
+  const headingStack = [];
   const flushCurrentSection = () => {
     if (current.length === 0) {
       return;
     }
-    sections.push(current.join(`
-`));
+    sections.push({
+      lines: current,
+      sectionPath: [...currentPath]
+    });
     current = [];
   };
   for (const line of lines) {
-    const startsNewSection = /^\s*#{1,6}\s+/.test(line) && current.length > 0;
-    if (startsNewSection)
-      flushCurrentSection();
+    const headingMatch = line.match(/^\s*(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      if (current.length > 0) {
+        flushCurrentSection();
+      }
+      const depth = headingMatch[1]?.length ?? 1;
+      const headingText = normalizeWhitespace(headingMatch[2] ?? "");
+      if (headingText) {
+        headingStack[depth - 1] = headingText;
+        headingStack.length = depth;
+        currentPath = [...headingStack];
+      }
+    }
     current.push(line);
   }
   flushCurrentSection();
-  return sections.map((section) => stripMarkdown(section)).map((section) => normalizeWhitespace(section)).filter(Boolean);
+  return sections.map(({ lines: sectionLines, sectionPath }) => ({
+    sectionDepth: sectionPath.length > 0 ? sectionPath.length : undefined,
+    sectionKind: sectionPath.length > 0 ? "markdown_heading" : undefined,
+    sectionPath: sectionPath.length > 0 ? sectionPath : undefined,
+    sectionTitle: sectionPath.at(-1),
+    text: normalizeWhitespace(stripMarkdown(sectionLines.join(`
+`)))
+  })).filter((section) => Boolean(section.text));
+};
+var joinHtmlHeadingSection = (headings, content) => {
+  const normalizedHeadings = headings.map((heading) => normalizeWhitespace(heading));
+  const combined = [...normalizedHeadings, content].filter(Boolean).join(`
+`);
+  return normalizeWhitespace(combined);
 };
 var htmlStructureUnits = (value) => {
-  const marked = value.replace(/<(section|article|main|aside|nav|h[1-6])\b[^>]*>/gi, `
-
-__ABS_SECTION_BREAK__ `).replace(/<\/(section|article|main|aside|nav|h[1-6])>/gi, `
-
-`);
-  const normalized = stripHtml(marked);
-  return normalized.split(/__ABS_SECTION_BREAK__/).map((section) => normalizeWhitespace(section)).filter(Boolean);
+  const focused = extractMainHtmlContent(value);
+  const headingPattern = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi;
+  const sections = [];
+  const headingStack = [];
+  let cursor = 0;
+  let currentContentStart = 0;
+  let activeHeadings = [];
+  const flushSection = (end) => {
+    const content = normalizeWhitespace(stripHtmlTags(focused.slice(currentContentStart, end)));
+    if (!content) {
+      return;
+    }
+    const section = joinHtmlHeadingSection(activeHeadings, content);
+    if (section) {
+      sections.push({
+        sectionDepth: activeHeadings.length > 0 ? activeHeadings.length : undefined,
+        sectionKind: activeHeadings.length > 0 ? "html_heading" : undefined,
+        sectionPath: activeHeadings.length > 0 ? [...activeHeadings] : undefined,
+        sectionTitle: activeHeadings.at(-1),
+        text: section
+      });
+    }
+  };
+  for (const match of focused.matchAll(headingPattern)) {
+    const fullMatch = match[0];
+    const start = match.index ?? cursor;
+    flushSection(start);
+    const level = Number.parseInt(match[1] ?? "1", 10);
+    const headingText = normalizeWhitespace(stripHtmlTags(match[2] ?? ""));
+    if (headingText) {
+      headingStack[level - 1] = headingText;
+      headingStack.length = level;
+      activeHeadings = [...headingStack];
+    }
+    cursor = start + fullMatch.length;
+    currentContentStart = cursor;
+  }
+  flushSection(focused.length);
+  if (sections.length > 0) {
+    return sections;
+  }
+  return [{ text: normalizeWhitespace(stripHtmlTags(focused)) }].filter((section) => Boolean(section.text));
 };
 var inferFormat = (document) => {
   if (document.format) {
@@ -7927,10 +8283,77 @@ var isLikelyTextData = (data) => {
 };
 var decodePdfLiteral = (value) => value.replace(/\\([\\()])/g, "$1").replace(/\\n/g, `
 `).replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\b/g, "\b").replace(/\\f/g, "\f").replace(/\\([0-7]{1,3})/g, (_match, octal) => String.fromCharCode(parseInt(octal, 8)));
+var PDF_TABLE_GAP_THRESHOLD = 120;
+var extractPdfArrayText = (value) => {
+  const parts = [];
+  const tokenPattern = /\(((?:\\.|[^\\)])*)\)|([-+]?\d*\.?\d+)/g;
+  let pendingColumnGap = false;
+  for (const match of value.matchAll(tokenPattern)) {
+    if (match[1] !== undefined) {
+      const decoded = decodePdfLiteral(match[1]);
+      if (pendingColumnGap && decoded && !/^\s/.test(decoded) && parts.at(-1) !== " | ") {
+        parts.push(" | ");
+      }
+      parts.push(decoded);
+      pendingColumnGap = false;
+      continue;
+    }
+    const gap = Number(match[2]);
+    if (Number.isFinite(gap) && gap >= PDF_TABLE_GAP_THRESHOLD) {
+      pendingColumnGap = true;
+    }
+  }
+  return normalizeWhitespace(parts.join("")).replace(/\s+\|\s+/g, " | ").trim();
+};
+var appendPdfText = (parts, value) => {
+  if (!value) {
+    return;
+  }
+  parts.push(value);
+};
+var appendPdfLineBreak = (parts) => {
+  const last = parts.at(-1);
+  if (!last || last.endsWith(`
+`)) {
+    return;
+  }
+  parts.push(`
+`);
+};
+var PDF_TEXT_OPERATOR_PATTERN = /(\[((?:\\.|[^\]])*)\]\s*TJ)|(\(((?:\\.|[^\\)])*)\)\s*Tj)|([-+]?\d*\.?\d+\s+[-+]?\d*\.?\d+\s+\(((?:\\.|[^\\)])*)\)\s*")|(\(((?:\\.|[^\\)])*)\)\s*')|((?:[-+]?\d*\.?\d+\s+){2}(?:Td|TD))|(T\*)|((?:[-+]?\d*\.?\d+\s+){6}Tm)/g;
+var extractTextFromPDFTextObject = (value) => {
+  const parts = [];
+  for (const match of value.matchAll(PDF_TEXT_OPERATOR_PATTERN)) {
+    if (match[2] !== undefined) {
+      appendPdfText(parts, extractPdfArrayText(match[2]));
+      continue;
+    }
+    if (match[4] !== undefined) {
+      appendPdfText(parts, decodePdfLiteral(match[4]));
+      continue;
+    }
+    if (match[6] !== undefined) {
+      appendPdfLineBreak(parts);
+      appendPdfText(parts, decodePdfLiteral(match[6]));
+      continue;
+    }
+    if (match[8] !== undefined) {
+      appendPdfLineBreak(parts);
+      appendPdfText(parts, decodePdfLiteral(match[8]));
+      continue;
+    }
+    if (match[9] !== undefined || match[10] !== undefined || match[11] !== undefined) {
+      appendPdfLineBreak(parts);
+    }
+  }
+  return parts.join("");
+};
 var extractTextFromPDFBytes = (data) => {
   const raw = Buffer.from(data).toString("latin1");
-  const matches = [...raw.matchAll(/\(((?:\\.|[^\\)])*)\)\s*Tj/g)];
-  const combined = matches.map((match) => decodePdfLiteral(match[1] ?? "")).join(`
+  const textObjects = [...raw.matchAll(/BT([\s\S]*?)ET/g)].map((match) => extractTextFromPDFTextObject(match[1] ?? "")).filter(Boolean);
+  const combined = textObjects.length > 0 ? textObjects.join(`
+
+`) : [...raw.matchAll(/\(((?:\\.|[^\\)])*)\)\s*Tj/g)].map((match) => decodePdfLiteral(match[1] ?? "")).join(`
 `);
   return normalizeWhitespace(combined);
 };
@@ -8022,7 +8445,40 @@ var decodeGzipEntries = (data, input) => {
   ];
 };
 var extractXmlText = (value) => normalizeWhitespace(decodeHtmlEntities(value.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ")));
+var extractOfficeParagraphText = (value) => normalizeWhitespace(decodeHtmlEntities(value.replace(/<w:tab\b[^>]*\/>/gi, "\t").replace(/<w:br\b[^>]*\/>/gi, `
+`).replace(/<[^>]+>/g, " ")));
+var officeDocumentParagraphs = (entries) => {
+  const documentEntry = entries.find((entry) => entry.path === "word/document.xml");
+  if (!documentEntry) {
+    return [];
+  }
+  const xml = decodeUtf8(documentEntry.data);
+  const paragraphs = [...xml.matchAll(/<w:p\b[\s\S]*?<\/w:p>/g)];
+  return paragraphs.map((match) => {
+    const paragraphXml = match[0] ?? "";
+    const text = extractOfficeParagraphText(paragraphXml);
+    if (!text) {
+      return "";
+    }
+    const styleMatch = paragraphXml.match(/<w:pStyle\b[^>]*w:val="([^"]+)"[^>]*\/?>/i);
+    const style = (styleMatch?.[1] ?? "").toLowerCase();
+    if (style === "title") {
+      return text;
+    }
+    const headingMatch = style.match(/^heading([1-6])$/);
+    if (headingMatch) {
+      return text;
+    }
+    return text;
+  }).filter(Boolean);
+};
 var officeDocumentText = (entries) => {
+  const paragraphs = officeDocumentParagraphs(entries);
+  if (paragraphs.length > 0) {
+    return normalizeWhitespace(paragraphs.join(`
+
+`));
+  }
   const documentEntry = entries.find((entry) => entry.path === "word/document.xml");
   if (!documentEntry) {
     return "";
@@ -8037,31 +8493,68 @@ var officeDocumentSectionCount = (entries) => {
   const count = [...decodeUtf8(documentEntry.data).matchAll(/<w:p\b/g)].length;
   return count > 0 ? count : undefined;
 };
-var spreadsheetText = (entries) => {
-  const sharedStrings = entries.filter((entry) => entry.path === "xl/sharedStrings.xml").flatMap((entry) => [
-    ...decodeUtf8(entry.data).matchAll(/<t[^>]*>([\s\S]*?)<\/t>/g)
-  ].map((match) => decodeHtmlEntities(match[1] ?? "")));
-  const sheetValues = entries.filter((entry) => entry.path.startsWith("xl/worksheets/") && entry.path.endsWith(".xml")).flatMap((entry) => [...decodeUtf8(entry.data).matchAll(/<v>([\s\S]*?)<\/v>/g)].map((match) => match[1] ?? "")).map((value) => {
-    const index = Number(value);
-    return Number.isInteger(index) && sharedStrings[index] ? sharedStrings[index] : value;
+var spreadsheetSharedStrings = (entries) => entries.filter((entry) => entry.path === "xl/sharedStrings.xml").flatMap((entry) => [
+  ...decodeUtf8(entry.data).matchAll(/<t[^>]*>([\s\S]*?)<\/t>/g)
+].map((match) => decodeHtmlEntities(match[1] ?? "")));
+var spreadsheetColumnLabel = (reference) => {
+  const match = reference?.match(/([A-Z]+)/i);
+  return match?.[1]?.toUpperCase() ?? "";
+};
+var spreadsheetResolveCellValue = (cellXml, sharedStrings) => {
+  const inlineMatch = cellXml.match(/<is\b[^>]*>[\s\S]*?<t[^>]*>([\s\S]*?)<\/t>[\s\S]*?<\/is>/i);
+  if (inlineMatch?.[1]) {
+    return normalizeWhitespace(decodeHtmlEntities(inlineMatch[1]));
+  }
+  const valueMatch = cellXml.match(/<v>([\s\S]*?)<\/v>/i);
+  if (!valueMatch?.[1]) {
+    return "";
+  }
+  const rawValue = decodeHtmlEntities(valueMatch[1]);
+  const typeMatch = cellXml.match(/\bt="([^"]+)"/i);
+  if (typeMatch?.[1] === "s") {
+    const index = Number(rawValue);
+    return Number.isInteger(index) && sharedStrings[index] ? sharedStrings[index] : rawValue;
+  }
+  return normalizeWhitespace(rawValue);
+};
+var spreadsheetWorksheetRows = (worksheetXml, sharedStrings) => [...worksheetXml.matchAll(/<row\b[^>]*>([\s\S]*?)<\/row>/gi)].map((rowMatch) => {
+  const rowXml = rowMatch[1] ?? "";
+  const cells = [...rowXml.matchAll(/<c\b([^>]*)>([\s\S]*?)<\/c>/gi)].map((cellMatch) => {
+    const attributes = cellMatch[1] ?? "";
+    const cellBody = cellMatch[2] ?? "";
+    const referenceMatch = attributes.match(/\br="([^"]+)"/i);
+    const reference = referenceMatch?.[1];
+    const value = spreadsheetResolveCellValue(`<c${attributes}>${cellBody}</c>`, sharedStrings);
+    return {
+      column: spreadsheetColumnLabel(reference),
+      reference,
+      value
+    };
+  }).filter((cell) => cell.value);
+  return cells;
+}).filter((row) => row.length > 0);
+var spreadsheetRowText = (row, headers) => {
+  const entries = row.map((cell, index) => {
+    const header = headers[index];
+    if (header) {
+      return `${header}: ${cell.value}`;
+    }
+    return cell.column ? `${cell.column}: ${cell.value}` : cell.value;
   });
-  return normalizeWhitespace(sheetValues.join(`
-`));
+  return normalizeWhitespace(entries.join(" | "));
 };
 var spreadsheetSheetTexts = (entries) => {
-  const sharedStrings = entries.filter((entry) => entry.path === "xl/sharedStrings.xml").flatMap((entry) => [
-    ...decodeUtf8(entry.data).matchAll(/<t[^>]*>([\s\S]*?)<\/t>/g)
-  ].map((match) => decodeHtmlEntities(match[1] ?? "")));
+  const sharedStrings = spreadsheetSharedStrings(entries);
   const sheetNames = spreadsheetSheetNames(entries);
   const sheetEntries = entries.filter((entry) => entry.path.startsWith("xl/worksheets/") && entry.path.endsWith(".xml")).sort((left, right) => left.path.localeCompare(right.path));
   return sheetEntries.map((entry, index) => {
-    const values = [
-      ...decodeUtf8(entry.data).matchAll(/<v>([\s\S]*?)<\/v>/g)
-    ].map((match) => match[1] ?? "").map((value) => {
-      const sharedStringIndex = Number(value);
-      return Number.isInteger(sharedStringIndex) && sharedStrings[sharedStringIndex] ? sharedStrings[sharedStringIndex] : value;
-    });
-    const text = normalizeWhitespace(values.join(`
+    const rows = spreadsheetWorksheetRows(decodeUtf8(entry.data), sharedStrings);
+    if (rows.length === 0) {
+      return null;
+    }
+    const headers = rows[0].map((cell) => cell.value);
+    const rowTexts = rows.map((row, rowIndex) => normalizeWhitespace(`Row ${rowIndex + 1}. ${spreadsheetRowText(row, rowIndex === 0 ? [] : headers)}`));
+    const text = normalizeWhitespace(rowTexts.join(`
 `));
     if (!text) {
       return null;
@@ -8072,19 +8565,38 @@ var spreadsheetSheetTexts = (entries) => {
     };
   }).filter((entry) => Boolean(entry));
 };
+var spreadsheetText = (entries) => normalizeWhitespace(spreadsheetSheetTexts(entries).map((sheet) => `Sheet ${sheet.name}
+${sheet.text}`).join(`
+
+`));
 var spreadsheetSheetNames = (entries) => entries.filter((entry) => entry.path === "xl/workbook.xml").flatMap((entry) => [
   ...decodeUtf8(entry.data).matchAll(/<sheet[^>]*name="([^"]+)"/g)
 ].map((match) => match[1] ?? "")).filter(Boolean);
-var presentationText = (entries) => {
-  const slides = entries.filter((entry) => entry.path.startsWith("ppt/slides/") && entry.path.endsWith(".xml")).map((entry) => extractXmlText(decodeUtf8(entry.data)));
-  return normalizeWhitespace(slides.join(`
-
+var presentationNotesByIndex = (entries) => new Map(entries.filter((entry) => entry.path.startsWith("ppt/notesSlides/") && entry.path.endsWith(".xml")).sort((left, right) => left.path.localeCompare(right.path)).map((entry) => {
+  const indexMatch = entry.path.match(/notesSlide(\d+)\.xml$/i);
+  const index = Number(indexMatch?.[1] ?? "0") - 1;
+  return [
+    index,
+    normalizeWhitespace(extractXmlText(decodeUtf8(entry.data)))
+  ];
+}).filter((entry) => entry[0] >= 0 && Boolean(entry[1])));
+var presentationSlides = (entries) => {
+  const notesByIndex = presentationNotesByIndex(entries);
+  return entries.filter((entry) => entry.path.startsWith("ppt/slides/") && entry.path.endsWith(".xml")).sort((left, right) => left.path.localeCompare(right.path)).map((entry, index) => {
+    const slideText = normalizeWhitespace(extractXmlText(decodeUtf8(entry.data)));
+    const notesText = notesByIndex.get(index);
+    const text = normalizeWhitespace([slideText, notesText ? `Speaker notes: ${notesText}` : ""].filter(Boolean).join(`
 `));
+    return {
+      index,
+      notesText,
+      text
+    };
+  }).filter((slide) => Boolean(slide.text));
 };
-var presentationSlides = (entries) => entries.filter((entry) => entry.path.startsWith("ppt/slides/") && entry.path.endsWith(".xml")).sort((left, right) => left.path.localeCompare(right.path)).map((entry, index) => ({
-  index,
-  text: normalizeWhitespace(extractXmlText(decodeUtf8(entry.data)))
-})).filter((slide) => Boolean(slide.text));
+var presentationText = (entries) => normalizeWhitespace(presentationSlides(entries).map((slide) => slide.text).join(`
+
+`));
 var presentationSlideCount = (entries) => entries.filter((entry) => entry.path.startsWith("ppt/slides/") && entry.path.endsWith(".xml")).length;
 var epubText = (entries) => {
   const htmlEntries = entries.filter((entry) => /\.(xhtml|html|htm)$/i.test(entry.path));
@@ -8092,17 +8604,113 @@ var epubText = (entries) => {
 
 `));
 };
-var extractEmailText = (raw) => {
+var splitEmailMessage = (raw) => {
   const normalized = raw.replace(/\r\n?/g, `
 `);
-  const [, ...bodyParts] = normalized.split(`
-
-`);
-  const body = bodyParts.join(`
+  const separator = normalized.indexOf(`
 
 `);
+  if (separator < 0) {
+    return {
+      body: "",
+      headerBlock: normalized
+    };
+  }
+  return {
+    body: normalized.slice(separator + 2),
+    headerBlock: normalized.slice(0, separator)
+  };
+};
+var parseHeaderBlock = (headerBlock) => {
+  const unfolded = headerBlock.replace(/\n[ \t]+/g, " ");
+  const headers = new Map;
+  for (const line of unfolded.split(`
+`)) {
+    const separator = line.indexOf(":");
+    if (separator < 0) {
+      continue;
+    }
+    headers.set(line.slice(0, separator).trim().toLowerCase(), line.slice(separator + 1).trim());
+  }
+  return headers;
+};
+var decodeQuotedPrintable = (value) => value.replace(/=\r?\n/g, "").replace(/=([0-9A-F]{2})/gi, (_match, hex) => String.fromCharCode(parseInt(hex, 16)));
+var decodeEmailPartBody = (body, encoding) => {
+  const normalizedEncoding = encoding?.toLowerCase();
+  const trimmed = body.trim();
+  if (normalizedEncoding === "base64") {
+    return new Uint8Array(Buffer.from(trimmed.replace(/\s+/g, ""), "base64"));
+  }
+  if (normalizedEncoding === "quoted-printable") {
+    return new Uint8Array(Buffer.from(decodeQuotedPrintable(body), "utf8"));
+  }
+  return new Uint8Array(Buffer.from(body, "utf8"));
+};
+var parseMimeBoundary = (contentType) => {
+  const match = contentType?.match(/boundary="?([^";]+)"?/i);
+  return match?.[1];
+};
+var parseEmailMimeParts = (body, contentType) => {
+  const boundary = parseMimeBoundary(contentType);
+  if (!boundary) {
+    const htmlMatch = body.match(/<html[\s\S]*<\/html>/i);
+    return {
+      attachments: [],
+      bodyHtml: htmlMatch?.[0],
+      bodyText: htmlMatch ? undefined : body
+    };
+  }
+  const attachments = [];
+  let bodyText;
+  let bodyHtml;
+  const parts = body.split(`--${boundary}`);
+  for (const rawPart of parts) {
+    const trimmed = rawPart.trim();
+    if (!trimmed || trimmed === "--") {
+      continue;
+    }
+    const { body: partBody, headerBlock } = splitEmailMessage(trimmed);
+    const headers = parseHeaderBlock(headerBlock);
+    const partContentType = headers.get("content-type");
+    const disposition = headers.get("content-disposition");
+    const transferEncoding = headers.get("content-transfer-encoding");
+    const filename = disposition?.match(/filename="?([^";]+)"?/i)?.[1] ?? partContentType?.match(/name="?([^";]+)"?/i)?.[1];
+    if (filename) {
+      attachments.push({
+        contentType: partContentType,
+        data: decodeEmailPartBody(partBody, transferEncoding),
+        fileName: filename
+      });
+      continue;
+    }
+    const decoded = Buffer.from(decodeEmailPartBody(partBody, transferEncoding)).toString("utf8");
+    if (partContentType?.toLowerCase().includes("text/html")) {
+      bodyHtml = decoded;
+      continue;
+    }
+    if (partContentType?.toLowerCase().includes("text/plain")) {
+      bodyText = decoded;
+    }
+  }
+  return {
+    attachments,
+    bodyHtml,
+    bodyText
+  };
+};
+var extractEmailText = (raw) => {
+  const { body, headerBlock } = splitEmailMessage(raw);
+  const headers = parseHeaderBlock(headerBlock);
+  const parsed = parseEmailMimeParts(body, headers.get("content-type"));
+  if (parsed.bodyHtml) {
+    return stripHtml(parsed.bodyHtml);
+  }
+  if (parsed.bodyText) {
+    return normalizeWhitespace(parsed.bodyText);
+  }
   if (!body) {
-    return normalizeWhitespace(normalized);
+    return normalizeWhitespace(raw.replace(/\r\n?/g, `
+`));
   }
   const htmlMatch = body.match(/<html[\s\S]*<\/html>/i);
   if (htmlMatch) {
@@ -8111,17 +8719,15 @@ var extractEmailText = (raw) => {
   return normalizeWhitespace(body);
 };
 var parseEmailHeaders = (raw) => {
-  const normalized = raw.replace(/\r\n?/g, `
-`);
-  const [headerBlock = ""] = normalized.split(`
-
-`);
-  const getHeader = (name) => {
-    const match = headerBlock.match(new RegExp(`^${name}:\\s*(.+)$`, "im"));
-    return match?.[1]?.trim();
-  };
+  const { headerBlock } = splitEmailMessage(raw);
+  const headers = parseHeaderBlock(headerBlock);
+  const getHeader = (name) => headers.get(name.toLowerCase());
   return {
+    contentType: getHeader("Content-Type"),
     from: getHeader("From"),
+    inReplyTo: getHeader("In-Reply-To"),
+    messageId: getHeader("Message-ID"),
+    references: getHeader("References"),
     subject: getHeader("Subject"),
     threadTopic: getHeader("Thread-Topic") ?? getHeader("Subject"),
     to: getHeader("To")
@@ -8142,6 +8748,87 @@ var extractPrintableStrings = (data) => {
   return unique.join(`
 `);
 };
+var ocrMetadata = (result) => {
+  const regions = result.regions?.filter((region) => normalizeWhitespace(region.text ?? "").length > 0);
+  const confidenceValues = [
+    typeof result.confidence === "number" ? result.confidence : undefined,
+    ...(regions ?? []).map((region) => typeof region.confidence === "number" ? region.confidence : undefined)
+  ].filter((value) => value !== undefined);
+  const averageConfidence = confidenceValues.length > 0 ? confidenceValues.reduce((sum, value) => sum + value, 0) / confidenceValues.length : undefined;
+  return {
+    ...result.metadata ?? {},
+    ocrConfidence: result.confidence,
+    ocrRegionCount: regions?.length,
+    ocrRegions: regions,
+    ocrAverageConfidence: averageConfidence
+  };
+};
+var ocrPageDocuments = (result, input, baseMetadata) => {
+  const grouped = new Map;
+  for (const region of result.regions ?? []) {
+    const text = normalizeWhitespace(region.text ?? "");
+    if (!text || typeof region.page !== "number" || region.page < 1) {
+      continue;
+    }
+    const bucket = grouped.get(region.page) ?? [];
+    bucket.push({ ...region, text });
+    grouped.set(region.page, bucket);
+  }
+  return [...grouped.entries()].sort((left, right) => left[0] - right[0]).map(([pageNumber, regions]) => ({
+    chunking: input.chunking,
+    contentType: input.contentType,
+    format: "text",
+    metadata: {
+      ...input.metadata ?? {},
+      ...baseMetadata,
+      ocrRegionCount: regions.length,
+      ocrRegions: regions,
+      pageNumber,
+      pageIndex: pageNumber - 1,
+      sourceNativeKind: "pdf_page"
+    },
+    source: input.source ?? input.path ?? input.name ?? `${slugify(input.title ?? DEFAULT_BINARY_NAME)}.pdf`,
+    text: normalizeWhitespace(`PDF page ${pageNumber} from ${input.title ?? input.name ?? input.path ?? DEFAULT_BINARY_NAME}.
+${regions.map((region) => region.text).join(`
+`)}`),
+    title: input.title ? `${input.title} \xB7 Page ${pageNumber}` : `Page ${pageNumber}`
+  }));
+};
+var ocrRegionDocuments = (result, input, baseMetadata) => {
+  const documents = [];
+  for (const [index, region] of (result.regions ?? []).entries()) {
+    const text = normalizeWhitespace(region.text ?? "");
+    if (!text || typeof region.page !== "number" || region.page < 1) {
+      continue;
+    }
+    const pageNumber = region.page;
+    const regionNumber = index + 1;
+    documents.push({
+      chunking: input.chunking,
+      contentType: input.contentType,
+      format: "text",
+      metadata: {
+        ...input.metadata ?? {},
+        ...baseMetadata,
+        ocrRegionConfidence: region.confidence,
+        ocrRegionHeight: region.height,
+        ocrRegionWidth: region.width,
+        ocrRegionX: region.x,
+        ocrRegionY: region.y,
+        pageNumber,
+        pageIndex: pageNumber - 1,
+        regionIndex: index,
+        regionNumber,
+        sourceNativeKind: "pdf_region"
+      },
+      source: input.source ?? input.path ?? input.name ?? `${slugify(input.title ?? DEFAULT_BINARY_NAME)}.pdf`,
+      text: normalizeWhitespace(`PDF page ${pageNumber} region ${regionNumber} from ${input.title ?? input.name ?? input.path ?? DEFAULT_BINARY_NAME}.
+${text}`),
+      title: input.title ? `${input.title} \xB7 Page ${pageNumber} Region ${regionNumber}` : `Page ${pageNumber} Region ${regionNumber}`
+    });
+  }
+  return documents;
+};
 var textExtractorSupports = (input) => {
   if (input.format) {
     return true;
@@ -8227,24 +8914,52 @@ var createBuiltinArchiveExpander = () => ({
 var createEmailExtractor = () => ({
   name: "absolute_email",
   supports: emailExtractorSupports,
-  extract: (input) => {
+  extract: async (input) => {
     const raw = decodeUtf8(input.data);
     const headers = parseEmailHeaders(raw);
-    return {
+    const { body } = splitEmailMessage(raw);
+    const parsed = parseEmailMimeParts(body, headers.contentType);
+    const source = input.source ?? input.path ?? input.name ?? `${slugify(input.title ?? DEFAULT_BINARY_NAME)}.eml`;
+    const messageMetadata = {
+      ...input.metadata ?? {},
+      emailKind: "message",
+      fileKind: "email",
+      from: headers.from,
+      inReplyTo: headers.inReplyTo,
+      messageId: headers.messageId,
+      references: headers.references,
+      threadTopic: headers.subject,
+      to: headers.to,
+      hasAttachments: parsed.attachments.length > 0
+    };
+    const attachmentDocuments = await Promise.all(parsed.attachments.map(async (attachment, index) => {
+      const documents = await extractRAGFileDocuments({
+        chunking: input.chunking,
+        contentType: attachment.contentType,
+        data: attachment.data,
+        format: inferFormatFromContentType(attachment.contentType ?? null) ?? inferFormatFromName(attachment.fileName),
+        metadata: {
+          ...messageMetadata,
+          attachmentIndex: index,
+          attachmentName: attachment.fileName,
+          emailKind: "attachment"
+        },
+        name: attachment.fileName,
+        source: `${source}#attachments/${attachment.fileName}`,
+        title: headers.subject ? `${headers.subject} \xB7 ${attachment.fileName}` : attachment.fileName
+      });
+      return documents;
+    }));
+    const messageDocument = {
       chunking: input.chunking,
       contentType: input.contentType,
       format: "text",
-      metadata: {
-        ...input.metadata ?? {},
-        fileKind: "email",
-        from: headers.from,
-        threadTopic: headers.subject,
-        to: headers.to
-      },
-      source: input.source ?? input.path ?? input.name ?? `${slugify(input.title ?? DEFAULT_BINARY_NAME)}.eml`,
+      metadata: messageMetadata,
+      source,
       text: extractEmailText(raw),
       title: input.title ?? headers.subject
     };
+    return [messageDocument, ...attachmentDocuments.flat()];
   }
 });
 var createEPUBExtractor = () => ({
@@ -8388,7 +9103,7 @@ var createRAGImageOCRExtractor = (provider) => ({
       format: "text",
       metadata: {
         ...input.metadata ?? {},
-        ...result.metadata ?? {},
+        ...ocrMetadata(result),
         fileKind: "image"
       },
       source: input.source ?? input.path ?? input.name ?? `${slugify(input.title ?? DEFAULT_BINARY_NAME)}.image.txt`,
@@ -8476,6 +9191,9 @@ var expandArchiveEntry = async (entry, archiveInput, extractors) => {
     metadata: {
       ...archiveInput.metadata ?? {},
       ...entry.metadata ?? {},
+      archiveEntryName: basename(entry.path),
+      archiveParentName: archiveInput.name ?? archiveInput.path?.split(/[/\\]/).pop() ?? archiveInput.source,
+      archiveParentSource: archiveInput.source ?? archiveInput.path ?? archiveInput.name,
       archivePath: entry.path,
       fileKind: "archive_entry"
     },
@@ -8551,21 +9269,27 @@ var createRAGPDFOCRExtractor = (options) => ({
       ...input,
       contentType: input.contentType ?? "application/pdf"
     });
-    return {
+    const baseMetadata = {
+      ...ocrMetadata(ocr),
+      fileKind: "pdf",
+      pageCount: estimatePDFPageCount(input.data),
+      pdfTextMode: "ocr"
+    };
+    const summaryDocument = {
       chunking: input.chunking,
       contentType: input.contentType ?? "application/pdf",
       format: "text",
       metadata: {
         ...input.metadata ?? {},
-        ...ocr.metadata ?? {},
-        fileKind: "pdf",
-        pageCount: estimatePDFPageCount(input.data),
-        pdfTextMode: "ocr"
+        ...baseMetadata
       },
       source: input.source ?? input.path ?? input.name ?? `${slugify(input.title ?? DEFAULT_BINARY_NAME)}.pdf`,
       text: ocr.text,
       title: ocr.title ?? input.title
     };
+    const pageDocuments = ocrPageDocuments(ocr, input, baseMetadata);
+    const regionDocuments = ocrRegionDocuments(ocr, input, baseMetadata);
+    return [summaryDocument, ...pageDocuments, ...regionDocuments];
   }
 });
 var DEFAULT_FILE_EXTRACTORS = [
@@ -8632,7 +9356,7 @@ var fixedUnits = (text, maxChunkLength) => {
   return units;
 };
 var sourceAwareUnits = (document, format, normalizedText) => {
-  const resolveStructuredUnits = (sections) => sections.length > 0 ? sections : paragraphUnits(normalizedText);
+  const resolveStructuredUnits = (sections) => sections.length > 0 ? sections : paragraphUnits(normalizedText).map((text) => ({ text }));
   switch (format) {
     case "markdown": {
       const sections = markdownStructureUnits(document.text);
@@ -8644,7 +9368,7 @@ var sourceAwareUnits = (document, format, normalizedText) => {
     }
     case "text":
     default:
-      return paragraphUnits(normalizedText);
+      return paragraphUnits(normalizedText).map((text) => ({ text }));
   }
 };
 var overlapTail = (value, overlap) => {
@@ -8708,10 +9432,13 @@ var chunkFromUnits = (units, maxChunkLength, chunkOverlap, minChunkLength) => {
   return merged;
 };
 var chunkSourceAwareUnit = (unit, options) => {
-  if (unit.length <= options.maxChunkLength) {
+  if (unit.text.length <= options.maxChunkLength) {
     return [unit];
   }
-  return chunkFromUnits(paragraphUnits(unit), options.maxChunkLength, options.chunkOverlap, options.minChunkLength);
+  return chunkFromUnits(paragraphUnits(unit.text), options.maxChunkLength, options.chunkOverlap, options.minChunkLength).map((text) => ({
+    ...unit,
+    text
+  }));
 };
 var resolveChunkingUnits = (text, options) => {
   if (options.strategy === "fixed") {
@@ -8734,15 +9461,15 @@ var resolveChunkingOptions = (document, defaults) => {
     strategy
   };
 };
-var createChunkTexts = (document, format, text, options) => {
+var createChunkEntries = (document, format, text, options) => {
   if (text.length <= options.maxChunkLength && options.strategy !== "source_aware") {
-    return [text];
+    return [{ text }];
   }
   if (options.strategy === "source_aware") {
     return sourceAwareUnits(document, format, text).flatMap((unit) => chunkSourceAwareUnit(unit, options));
   }
   const units = resolveChunkingUnits(text, options);
-  return chunkFromUnits(units, options.maxChunkLength, options.chunkOverlap, options.minChunkLength);
+  return chunkFromUnits(units, options.maxChunkLength, options.chunkOverlap, options.minChunkLength).map((entry) => ({ text: entry }));
 };
 var prepareRAGDocument = (document, defaultChunking) => {
   const format = inferFormat(document);
@@ -8764,18 +9491,46 @@ var prepareRAGDocument = (document, defaultChunking) => {
     source,
     title
   };
-  const chunkTexts = createChunkTexts(document, format, normalizedText, chunking);
-  const chunks = chunkTexts.map((text, index) => ({
-    chunkId: `${documentId}:${String(index + 1).padStart(RAG_CHUNK_ID_PAD_LENGTH, "0")}`,
-    metadata: {
-      ...metadata,
-      chunkCount: chunkTexts.length,
-      chunkIndex: index
-    },
-    source,
-    text,
-    title
-  }));
+  const chunkEntries = createChunkEntries(document, format, normalizedText, chunking);
+  const chunks = chunkEntries.map((entry, index) => {
+    const sectionPath = Array.isArray(entry.sectionPath) ? entry.sectionPath.filter((value) => typeof value === "string" && value.length > 0) : undefined;
+    const sectionTitle = typeof entry.sectionTitle === "string" && entry.sectionTitle.length > 0 ? entry.sectionTitle : sectionPath?.at(-1);
+    const chunkTitle = sectionTitle && sectionTitle !== title ? `${title} \xB7 ${sectionTitle}` : title;
+    const sectionChunkId = sectionPath && sectionPath.length > 0 ? `${documentId}:section:${slugify(sectionPath.join(" "))}` : undefined;
+    const sectionSiblingIndexes = sectionChunkId === undefined ? [index] : chunkEntries.reduce((indexes, candidate, candidateIndex) => {
+      const candidatePath = Array.isArray(candidate.sectionPath) ? candidate.sectionPath.filter((value) => typeof value === "string" && value.length > 0) : undefined;
+      const candidateSectionId = candidatePath && candidatePath.length > 0 ? `${documentId}:section:${slugify(candidatePath.join(" "))}` : undefined;
+      if (candidateSectionId === sectionChunkId) {
+        indexes.push(candidateIndex);
+      }
+      return indexes;
+    }, []);
+    const sectionChunkIndex = sectionSiblingIndexes.indexOf(index);
+    const previousChunkId = index > 0 ? `${documentId}:${String(index).padStart(RAG_CHUNK_ID_PAD_LENGTH, "0")}` : undefined;
+    const nextChunkId = index + 1 < chunkEntries.length ? `${documentId}:${String(index + 2).padStart(RAG_CHUNK_ID_PAD_LENGTH, "0")}` : undefined;
+    return {
+      chunkId: `${documentId}:${String(index + 1).padStart(RAG_CHUNK_ID_PAD_LENGTH, "0")}`,
+      metadata: {
+        ...metadata,
+        chunkCount: chunkEntries.length,
+        chunkIndex: index,
+        ...sectionTitle ? { sectionTitle } : {},
+        ...sectionPath && sectionPath.length > 0 ? { sectionPath } : {},
+        ...typeof entry.sectionDepth === "number" ? { sectionDepth: entry.sectionDepth } : {},
+        ...entry.sectionKind ? { sectionKind: entry.sectionKind } : {},
+        ...sectionChunkId ? { sectionChunkId } : {},
+        ...sectionChunkId && sectionChunkIndex >= 0 ? {
+          sectionChunkCount: sectionSiblingIndexes.length,
+          sectionChunkIndex
+        } : {},
+        ...previousChunkId ? { previousChunkId } : {},
+        ...nextChunkId ? { nextChunkId } : {}
+      },
+      source,
+      text: entry.text,
+      title: chunkTitle
+    };
+  });
   return {
     chunks,
     documentId,
@@ -9421,6 +10176,30 @@ var searchDocuments = async (collection, input) => collection.search(input);
 // src/ai/rag/htmxWorkflowRenderers.ts
 init_constants();
 var escapeHtml2 = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var renderSourceLabels = (input) => {
+  if (!input) {
+    return "";
+  }
+  const rows = [
+    input.contextLabel ? `<li><strong>Context</strong> ${escapeHtml2(input.contextLabel)}</li>` : "",
+    input.locatorLabel ? `<li><strong>Location</strong> ${escapeHtml2(input.locatorLabel)}</li>` : "",
+    input.provenanceLabel ? `<li><strong>Provenance</strong> ${escapeHtml2(input.provenanceLabel)}</li>` : ""
+  ].filter((row) => row.length > 0);
+  return rows.length > 0 ? `<ul class="rag-source-labels">${rows.join("")}</ul>` : "";
+};
+var renderChunkStructure = (structure) => {
+  if (!structure) {
+    return "";
+  }
+  const rows = [
+    structure.section?.title ? `<li><strong>Section</strong> ${escapeHtml2(structure.section.title)}</li>` : "",
+    structure.section?.path && structure.section.path.length > 1 ? `<li><strong>Section path</strong> ${escapeHtml2(structure.section.path.join(" > "))}</li>` : "",
+    typeof structure.sequence?.sectionChunkIndex === "number" && typeof structure.sequence?.sectionChunkCount === "number" ? `<li><strong>Section chunk</strong> ${structure.sequence.sectionChunkIndex + 1} of ${structure.sequence.sectionChunkCount}</li>` : "",
+    structure.sequence?.previousChunkId ? `<li><strong>Previous</strong> ${escapeHtml2(structure.sequence.previousChunkId)}</li>` : "",
+    structure.sequence?.nextChunkId ? `<li><strong>Next</strong> ${escapeHtml2(structure.sequence.nextChunkId)}</li>` : ""
+  ].filter((row) => row.length > 0);
+  return rows.length > 0 ? `<ul class="rag-chunk-structure">${rows.join("")}</ul>` : "";
+};
 var renderEmptyState = (kind) => {
   switch (kind) {
     case "documents":
@@ -9460,17 +10239,41 @@ var defaultStatus = ({
   }
   return `<dl class="rag-status">` + `<div><dt>Backend</dt><dd>${escapeHtml2(status.backend)}</dd></div>` + `<div><dt>Vector mode</dt><dd>${escapeHtml2(status.vectorMode)}</dd></div>` + `<div><dt>Embedding dimensions</dt><dd>${status.dimensions ?? "n/a"}</dd></div>` + `<div><dt>Vector acceleration</dt><dd>${status.native?.active ? "active" : "inactive"}</dd></div>` + `<div><dt>Documents</dt><dd>${documents?.total ?? "n/a"}</dd></div>` + `<div><dt>Total chunks</dt><dd>${documents?.chunkCount ?? "n/a"}</dd></div>` + `<div><dt>Seed docs</dt><dd>${documents?.byKind.seed ?? 0}</dd></div>` + `<div><dt>Custom docs</dt><dd>${documents?.byKind.custom ?? 0}</dd></div>` + `</dl>${renderCapabilityList(capabilities)}`;
 };
-var defaultSearchResultItem = (source, index) => '<article class="rag-search-result">' + `<h3>${escapeHtml2(source.title ?? source.chunkId ?? `Result ${index + 1}`)}</h3>` + `<p class="rag-search-source">${escapeHtml2(source.source ?? "unknown source")}</p>` + `<p class="rag-search-score">score ${source.score.toFixed(RAG_SEARCH_SCORE_DECIMAL_PLACES)}</p>` + `<p class="rag-search-text">${escapeHtml2(source.text)}</p>` + "</article>";
+var defaultSearchResultItem = (source, index) => '<article class="rag-search-result">' + `<h3>${escapeHtml2(source.title ?? source.chunkId ?? `Result ${index + 1}`)}</h3>` + `<p class="rag-search-source">${escapeHtml2(source.source ?? "unknown source")}</p>` + renderSourceLabels(source.labels) + renderChunkStructure(source.structure) + `<p class="rag-search-score">score ${source.score.toFixed(RAG_SEARCH_SCORE_DECIMAL_PLACES)}</p>` + `<p class="rag-search-text">${escapeHtml2(source.text)}</p>` + "</article>";
 var defaultSearchResults = ({
   query,
   results,
   trace
 }) => results.length === 0 ? renderEmptyState("searchResults") : `<section class="rag-search-results">` + `<p class="rag-search-summary">${results.length} results for ${escapeHtml2(query)}</p>` + (trace ? `<p class="rag-search-summary">mode=${escapeHtml2(trace.mode)} \xB7 final=${trace.resultCounts.final} \xB7 vector=${trace.resultCounts.vector} \xB7 lexical=${trace.resultCounts.lexical}</p>` : "") + `${results.map((result, index) => defaultSearchResultItem(result, index)).join("")}</section>`;
-var defaultDocumentItem = (document, index) => '<article class="rag-document">' + `<h3>${escapeHtml2(document.title || `Document ${index + 1}`)}</h3>` + `<p class="rag-document-id">${escapeHtml2(document.id)}</p>` + `<p class="rag-document-source">${escapeHtml2(document.source)}</p>` + `<p class="rag-document-meta">${escapeHtml2(document.format ?? "text")} \xB7 ${escapeHtml2(document.chunkStrategy ?? "paragraphs")} \xB7 ${document.chunkCount ?? 0} chunks</p>` + "</article>";
+var defaultDocumentItem = (document, index) => '<article class="rag-document">' + `<h3>${escapeHtml2(document.title || `Document ${index + 1}`)}</h3>` + `<p class="rag-document-id">${escapeHtml2(document.id)}</p>` + `<p class="rag-document-source">${escapeHtml2(document.source)}</p>` + renderSourceLabels(document.labels) + `<p class="rag-document-meta">${escapeHtml2(document.format ?? "text")} \xB7 ${escapeHtml2(document.chunkStrategy ?? "paragraphs")} \xB7 ${document.chunkCount ?? 0} chunks</p>` + "</article>";
 var defaultDocuments = ({
   documents
 }) => documents.length === 0 ? renderEmptyState("documents") : `<section class="rag-documents">${documents.map((document, index) => defaultDocumentItem(document, index)).join("")}</section>`;
-var defaultChunkPreview = (input) => `<section class="rag-chunk-preview">` + `<h3>${escapeHtml2(input.document.title)}</h3>` + `<p class="rag-chunk-preview-source">${escapeHtml2(input.document.source)}</p>` + `<article class="rag-chunk-normalized">` + `<h4>Normalized text</h4>` + `<pre>${escapeHtml2(input.normalizedText)}</pre>` + `</article>${input.chunks.map((chunk) => '<article class="rag-chunk">' + `<h4>${escapeHtml2(chunk.chunkId)}</h4>` + `<p class="rag-chunk-meta">chunk ${typeof chunk.metadata?.chunkIndex === "number" ? chunk.metadata.chunkIndex : 0} of ${typeof chunk.metadata?.chunkCount === "number" ? chunk.metadata.chunkCount : input.chunks.length}</p>` + `<pre>${escapeHtml2(chunk.text)}</pre>` + "</article>").join("")}</section>`;
+var defaultChunkPreview = (input) => {
+  const groups = input.chunks.reduce((acc, chunk) => {
+    const metadata = chunk.metadata ?? {};
+    const kind = typeof metadata.sourceNativeKind === "string" ? metadata.sourceNativeKind : "document_chunk";
+    const locator = chunk.labels?.locatorLabel ?? "";
+    const title = kind === "pdf_page" ? locator || "PDF pages" : kind === "pdf_region" ? locator || "PDF regions" : kind === "spreadsheet_sheet" ? locator || "Spreadsheet sheets" : kind === "presentation_slide" ? locator || "Presentation slides" : kind === "attachment" ? locator || "Attachments" : kind === "archive_entry" ? locator || "Archive entries" : "Chunks";
+    const key = kind === "document_chunk" ? "document_chunk" : `${kind}:${title}`;
+    const existing = acc.find((entry) => entry.key === key);
+    if (existing) {
+      existing.chunks.push(chunk);
+      return acc;
+    }
+    acc.push({
+      chunks: [chunk],
+      key,
+      title
+    });
+    return acc;
+  }, []);
+  const groupHtml = groups.map((group) => {
+    const chunkHtml = group.chunks.map((chunk) => '<article class="rag-chunk">' + `<h5>${escapeHtml2(chunk.chunkId)}</h5>` + `<p class="rag-chunk-meta">chunk ${typeof chunk.metadata?.chunkIndex === "number" ? chunk.metadata.chunkIndex : 0} of ${typeof chunk.metadata?.chunkCount === "number" ? chunk.metadata.chunkCount : input.chunks.length}</p>` + renderSourceLabels(chunk.labels) + renderChunkStructure(chunk.structure) + `<pre>${escapeHtml2(chunk.text)}</pre>` + "</article>").join("");
+    return `<section class="rag-chunk-group"><h4>${escapeHtml2(group.title)}</h4>${chunkHtml}</section>`;
+  }).join("");
+  return `<section class="rag-chunk-preview">` + `<h3>${escapeHtml2(input.document.title)}</h3>` + `<p class="rag-chunk-preview-source">${escapeHtml2(input.document.source)}</p>` + renderSourceLabels(input.document.labels) + `<article class="rag-chunk-normalized">` + `<h4>Normalized text</h4>` + `<pre>${escapeHtml2(input.normalizedText)}</pre>` + `</article>${groupHtml}</section>`;
+};
 var defaultMutationResult = (input) => {
   if (!input.ok) {
     return `<div class="rag-mutation error">${escapeHtml2(input.error ?? "Request failed")}</div>`;
@@ -9533,6 +10336,10 @@ var buildRAGContextLocatorLabel = (metadata, source, title) => {
     return;
   }
   const page = getContextNumber3(metadata.page) ?? getContextNumber3(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber3(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  if (page && region) {
+    return `Page ${page} \xB7 Region ${region}`;
+  }
   if (page) {
     return `Page ${page}`;
   }
@@ -9574,9 +10381,11 @@ var buildRAGContextProvenanceLabel = (metadata) => {
   const threadTopic = getContextString3(metadata.threadTopic);
   const from = getContextString3(metadata.from);
   const speaker = getContextString3(metadata.speaker);
+  const ocrConfidence = getContextNumber3(metadata.ocrRegionConfidence) ?? getContextNumber3(metadata.ocrConfidence);
   const labels = [
     pdfTextMode ? `PDF ${pdfTextMode}` : "",
     ocrEngine ? `OCR ${ocrEngine}` : "",
+    typeof ocrConfidence === "number" ? `Confidence ${ocrConfidence.toFixed(2)}` : "",
     mediaKind ? `Media ${mediaKind}` : "",
     transcriptSource ? `Transcript ${transcriptSource}` : "",
     threadTopic ? `Thread ${threadTopic}` : "",
@@ -9886,9 +10695,15 @@ var isRAGDocumentUrlArray = (value) => Array.isArray(value) && value.every((entr
 var isRAGDocumentChunkArray = (value) => Array.isArray(value) && value.every((entry) => isRAGDocumentChunk(entry));
 var buildSources2 = (results) => results.map((result) => ({
   chunkId: result.chunkId,
+  labels: buildRAGSourceLabels({
+    metadata: result.metadata,
+    source: result.source,
+    title: result.title
+  }),
   metadata: result.metadata,
   score: normalizeScore(result.score),
   source: result.source,
+  structure: buildRAGChunkStructure(result.metadata),
   text: result.chunkText,
   title: result.title
 }));
@@ -13616,6 +14431,11 @@ var ragChat = (config) => {
     let documentsWithoutChunkPreview = 0;
     let inspectedDocuments = 0;
     let inspectedChunks = 0;
+    let documentsWithSourceLabels = 0;
+    let chunksWithSourceLabels = 0;
+    const sourceNativeKinds = new Map;
+    const sampleDocuments = [];
+    const sampleChunks = [];
     let oldestDocumentAgeMs;
     let newestDocumentAgeMs;
     const staleDocuments = [];
@@ -13656,6 +14476,27 @@ var ragChat = (config) => {
       if ((document.chunkCount ?? 0) === 0) {
         emptyDocuments += 1;
       }
+      const documentLabels = buildRAGSourceLabels({
+        metadata: document.metadata,
+        source: document.source,
+        title: document.title
+      });
+      if (documentLabels) {
+        documentsWithSourceLabels += 1;
+      }
+      const documentSourceNativeKind = typeof document.metadata?.sourceNativeKind === "string" ? document.metadata.sourceNativeKind : undefined;
+      if (documentSourceNativeKind) {
+        sourceNativeKinds.set(documentSourceNativeKind, (sourceNativeKinds.get(documentSourceNativeKind) ?? 0) + 1);
+      }
+      if (sampleDocuments.length < 5 && (documentLabels || documentSourceNativeKind)) {
+        sampleDocuments.push({
+          id: document.id,
+          labels: documentLabels,
+          source: document.source,
+          sourceNativeKind: documentSourceNativeKind,
+          title: document.title
+        });
+      }
       if (indexManager?.getDocumentChunks) {
         const preview = await indexManager.getDocumentChunks(document.id);
         if (!preview) {
@@ -13665,6 +14506,27 @@ var ragChat = (config) => {
         inspectedDocuments += 1;
         for (const chunk of preview.chunks) {
           inspectedChunks += 1;
+          const chunkLabels = buildRAGSourceLabels({
+            metadata: chunk.metadata,
+            source: chunk.source ?? preview.document.source,
+            title: chunk.title ?? preview.document.title
+          });
+          if (chunkLabels) {
+            chunksWithSourceLabels += 1;
+          }
+          const chunkSourceNativeKind = typeof chunk.metadata?.sourceNativeKind === "string" ? chunk.metadata.sourceNativeKind : undefined;
+          if (chunkSourceNativeKind) {
+            sourceNativeKinds.set(chunkSourceNativeKind, (sourceNativeKinds.get(chunkSourceNativeKind) ?? 0) + 1);
+          }
+          if (sampleChunks.length < 8 && (chunkLabels || chunkSourceNativeKind)) {
+            sampleChunks.push({
+              chunkId: chunk.chunkId,
+              documentId: document.id,
+              labels: chunkLabels,
+              source: chunk.source ?? preview.document.source,
+              sourceNativeKind: chunkSourceNativeKind
+            });
+          }
           const normalized = chunk.text.trim();
           if (!normalized) {
             emptyChunks += 1;
@@ -13721,6 +14583,13 @@ var ragChat = (config) => {
       failuresByInputKind: Object.fromEntries(failuresByInputKind.entries()),
       inspectedChunks,
       inspectedDocuments,
+      inspection: {
+        chunksWithSourceLabels,
+        documentsWithSourceLabels,
+        sampleChunks,
+        sampleDocuments,
+        sourceNativeKinds: Object.fromEntries(sourceNativeKinds.entries())
+      },
       lowSignalChunks,
       newestDocumentAgeMs,
       oldestDocumentAgeMs,
@@ -14901,7 +15770,14 @@ var ragChat = (config) => {
     }
     const documents = await indexManager.listDocuments({ kind });
     return {
-      documents,
+      documents: documents.map((document) => ({
+        ...document,
+        labels: buildRAGSourceLabels({
+          metadata: document.metadata,
+          source: document.source,
+          title: document.title
+        })
+      })),
       ok: true
     };
   };
@@ -14961,7 +15837,24 @@ var ragChat = (config) => {
     }
     return {
       ok: true,
-      ...preview
+      ...preview,
+      document: {
+        ...preview.document,
+        labels: buildRAGSourceLabels({
+          metadata: preview.document.metadata,
+          source: preview.document.source,
+          title: preview.document.title
+        })
+      },
+      chunks: preview.chunks.map((chunk) => ({
+        ...chunk,
+        labels: buildRAGSourceLabels({
+          metadata: chunk.metadata,
+          source: chunk.source ?? preview.document.source,
+          title: chunk.title ?? preview.document.title
+        }),
+        structure: buildRAGChunkStructure(chunk.metadata)
+      }))
     };
   };
   const handleDeleteDocument = async (id) => {
@@ -20557,5 +21450,5 @@ export {
   aiChat
 };
 
-//# debugId=E76E681490B6CFE564756E2164756E21
+//# debugId=DE5EC1314BD5A9F664756E2164756E21
 //# sourceMappingURL=index.js.map