@stainless-api/docs 0.1.0-beta.89 → 0.1.0-beta.90

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @stainless-api/docs
 
+## 0.1.0-beta.90
+
+### Minor Changes
+
+- b8f1f3c: improve prose chunking
+
+### Patch Changes
+
+- 3de4232: support additional extra custom fonts
+- c77e607: fixes issue where sdk select wasnt showing on readme pages
+
 ## 0.1.0-beta.89
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stainless-api/docs",
-  "version": "0.1.0-beta.89",
+  "version": "0.1.0-beta.90",
   "publishConfig": {
     "access": "public"
   },
@@ -51,7 +51,7 @@
     "remark-gfm": "^4.0.1",
     "remark-github-alerts": "^0.1.1",
     "remark-stringify": "^11.0.0",
-    "shiki": "^3.21.0",
+    "shiki": "^3.22.0",
     "unified": "^11.0.5",
     "vite-plugin-prebundle-workers": "^0.2.0",
     "web-worker": "^1.5.0",
@@ -64,10 +64,10 @@
     "@astrojs/check": "^0.9.6",
     "@markdoc/markdoc": "^0.5.4",
     "@types/node": "24.10.9",
-    "@types/react": "19.2.7",
+    "@types/react": "19.2.10",
     "@types/react-dom": "^19.2.3",
-    "react": "^19.2.3",
-    "react-dom": "^19.2.3",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
     "tsx": "^4.21.0",
     "typescript": "5.9.3",
     "vite": "^6.4.1",

package/plugin/components/SDKSelect.astro

@@ -1,10 +1,6 @@
 ---
 import { parseRoute } from '@stainless-api/docs-ui/routing';
-import {
-  RESOLVED_API_REFERENCE_PATH,
-  DEFAULT_LANGUAGE,
-  EXCLUDE_LANGUAGES,
-} from 'virtual:stl-starlight-virtual-module';
+import { DEFAULT_LANGUAGE, EXCLUDE_LANGUAGES } from 'virtual:stl-starlight-virtual-module';
 import { Languages } from '../languages';
 import { SDKSelectReactComponent } from '../react/Routing';
 import { getSDKJSONInSSR } from '../specs/fetchSpecSSR';
@@ -32,8 +28,7 @@ const options = getDocsLanguages(spec, EXCLUDE_LANGUAGES).map((value) => ({
   selected: data.language === value,
 }));
 
-const readmeSlug =
-  language === 'http' ? RESOLVED_API_REFERENCE_PATH : `${RESOLVED_API_REFERENCE_PATH}/${language}`;
+const readmeSlug = language === 'http' ? API_REFERENCE_BASE_PATH : `${API_REFERENCE_BASE_PATH}/${language}`;
 ---
 
 <span

package/plugin/replaceSidebarPlaceholderMiddleware.ts

@@ -21,9 +21,6 @@ function markCurrentItems(sidebar: SidebarEntry[], currentSlug: string) {
     for (const entry of entries) {
       if (entry.type === 'link') {
         entry.isCurrent = removeTrailingSlash(entry.href) === normalizedCurrentSlug;
-        if (entry.isCurrent) {
-          return;
-        }
       }
       if (entry.type === 'group') {
         recursiveMarkCurrent(entry.entries);

package/stl-docs/components/Head.astro

@@ -5,11 +5,13 @@ import Default from '@astrojs/starlight/components/Head.astro';
 import path from 'path';
 
 const mdPath = path.posix.join(Astro.url.pathname, 'index.md');
+const fonts = [FONTS.primary, FONTS.heading, FONTS.mono, ...(FONTS.additional ?? [])].filter(Boolean);
 ---
 
 <Default />
 
-{Object.values(FONTS).map((font) => <Font cssVariable={font.cssVariable} preload={font.preload} />)}
+{fonts.map((font) => <Font cssVariable={font.cssVariable} preload={font.preload} />)}
+
 <link rel="alternate" type="text/markdown" href={mdPath} />
 
 <script>

package/stl-docs/fonts.ts

@@ -6,16 +6,19 @@ import type { FontPreloadFilter } from 'astro:assets';
 type AstroFontConfigEntry = Defined<AstroConfig['experimental']['fonts']>[number];
 
 // Apply Omit to each member of the union while preserving union structure
+type PreloadFilter = { preload?: FontPreloadFilter };
 export type StlDocsFontConfigEntry = (AstroFontConfigEntry extends infer T
   ? T extends unknown
     ? Omit<T, 'cssVariable'>
     : never
-  : never) & { preload?: FontPreloadFilter };
+  : never) &
+  PreloadFilter;
 
 export type StlDocsFontConfig = {
   primary?: StlDocsFontConfigEntry;
   heading?: StlDocsFontConfigEntry;
   mono?: StlDocsFontConfigEntry;
+  additional?: (AstroFontConfigEntry & PreloadFilter)[];
 };
 const latinFeatureSettings = "'ss01' on, 'ss03' on, 'ss04' on, 'ss06' on, 'ss08' on";
 /* prettier-ignore */
@@ -31,6 +34,7 @@ export function getFontRoles(fonts: StlDocsFontConfig | undefined) {
     primary?: { cssVariable: string; preload?: FontPreloadFilter };
     heading?: { cssVariable: string; preload?: FontPreloadFilter };
     mono?: { cssVariable: string; preload?: FontPreloadFilter };
+    additional?: { cssVariable: string; preload?: FontPreloadFilter }[];
   } = {};
   if (fonts.primary) {
     fontConfigs['primary'] = {
@@ -50,6 +54,12 @@ export function getFontRoles(fonts: StlDocsFontConfig | undefined) {
       preload: fonts.mono.preload ?? [{ style: 'normal' }],
     };
   }
+  if (fonts.additional) {
+    fontConfigs['additional'] = fonts.additional.map((font) => ({
+      cssVariable: font.cssVariable,
+      preload: font.preload ?? [{ style: 'normal' }],
+    }));
+  }
   return fontConfigs;
 }
 
@@ -141,6 +151,7 @@ export function normalizeFonts(fonts: StlDocsFontConfig | undefined): StlDocsFon
     primary: fonts?.primary ?? defaultPrimary,
     heading: fonts?.heading ?? undefined,
     mono: fonts?.mono ?? defaultMono,
+    additional: fonts?.additional ?? [],
   };
 }
 
@@ -168,5 +179,8 @@ export function flattenFonts(fonts: StlDocsFontConfig | undefined): AstroFontCon
       cssVariable: '--stl-typography-font-mono' as const,
     } as AstroFontConfigEntry);
   }
+  if (fonts.additional) {
+    fontConfigs.push(...fonts.additional.map((font) => font as AstroFontConfigEntry));
+  }
   return fontConfigs;
 }

package/stl-docs/index.ts

@@ -197,7 +197,7 @@ function stainlessDocsIntegration(
 
         updateConfig({
           experimental: {
-            fonts: flattenFonts(config.fonts),
+            fonts: [...flattenFonts(config.fonts), ...(astroConfig.experimental?.fonts ?? [])],
           },
           vite: {
             plugins: [

package/stl-docs/proseSearchIndexing.ts

@@ -8,22 +8,37 @@ import { toMarkdown } from './proseMarkdown/toMarkdown';
 import { NormalizedStainlessDocsConfig } from './loadStlDocsConfig';
 import { buildProseIndex } from '@stainless-api/docs-search/providers/algolia';
 
-interface ContentBlock {
-  type: 'header' | 'content';
-  tag?: string;
-  id?: string;
-  text: string;
-}
+type ContentBlock =
+  | { type: 'header'; tag: string; id: string; text: string }
+  | { type: 'content'; tag: string; text: string }
+  | { type: 'code'; tag: string; language?: string; text: string };
+
+class SectionContext {
+  headers: { level: number; text: string }[] = [];
+  headerId: string | undefined;
+  headerTag: string | undefined;
+  headerText: string | undefined;
+  hasContent = false;
+
+  get(): string | undefined {
+    if (this.headers.length === 0) return;
+    return this.headers.map((h) => h.text).join(' > ');
+  }
 
-// Chunking configuration
-// We target 64-256 tokens per chunk, using ~1.3 tokens/word for English text
-const TOKENS_PER_WORD = 1.3;
-const MIN_TOKENS = 64;
-const MAX_TOKENS = 256;
-const MIN_WORDS = Math.floor(MIN_TOKENS / TOKENS_PER_WORD); // ~49 words
-const MAX_WORDS = Math.floor(MAX_TOKENS / TOKENS_PER_WORD); // ~197 words
-const LINE_BREAK_WORDS = Math.floor((MAX_TOKENS * 0.75) / TOKENS_PER_WORD); // ~148 words
-const SENTENCE_BREAK_WORDS = Math.floor((MAX_TOKENS * 0.875) / TOKENS_PER_WORD); // ~172 words
+  header({ id, tag, text }: { id: string; tag: string; text: string }) {
+    const level = getHeaderLevel(tag);
+    if (level > 0) {
+      while (this.headers.length > 0 && this.headers[this.headers.length - 1]!.level >= level) {
+        this.headers.pop();
+      }
+      this.headers.push({ level, text });
+    }
+    this.headerId = id;
+    this.headerTag = tag;
+    this.headerText = text;
+    this.hasContent = false;
+  }
+}
 
 // Generate a URL-safe ID from header text (e.g., "OpenAPI Config" -> "openapi-config")
 function slugify(text: string): string {
@@ -39,22 +54,97 @@ function isTableCellBoundary(word: string): boolean {
   return word.endsWith('|') && !word.endsWith('\\|');
 }
 
+/**
+ * Extracts the header level from a tag like "h1", "h2", etc.
+ */
+function getHeaderLevel(tag: string): number {
+  const match = tag.match(/^h(\d)$/);
+  return match ? parseInt(match[1]!, 10) : 0;
+}
+
+// Chunking configuration
+// We target 64-256 tokens per chunk, using ~1.3 tokens/word for English text
+const TOKENS_PER_WORD = 1.3;
+const MIN_TOKENS = 64;
+const MAX_TOKENS = 256;
+const MIN_WORDS = Math.floor(MIN_TOKENS / TOKENS_PER_WORD); // ~49 words
+const MAX_WORDS = Math.floor(MAX_TOKENS / TOKENS_PER_WORD); // ~197 words
+const LINE_BREAK_WORDS = Math.floor((MAX_TOKENS * 0.75) / TOKENS_PER_WORD); // ~148 words
+const SENTENCE_BREAK_WORDS = Math.floor((MAX_TOKENS * 0.875) / TOKENS_PER_WORD); // ~172 words
+
+/**
+ * Chunks text content into segments of 64-256 tokens using word-based boundaries.
+ * Prefers breaking at sentence endings for natural chunk boundaries.
+ */
+function chunkTextByWords(text: string): string[] {
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+
+  if (words.length <= MAX_WORDS) {
+    return words.length > 0 ? [words.join(' ')] : [];
+  }
+
+  const chunks: string[] = [];
+  let currentChunk: string[] = [];
+
+  for (const word of words) {
+    currentChunk.push(word);
+
+    // Force break at max words
+    if (currentChunk.length >= MAX_WORDS) {
+      chunks.push(currentChunk.join(' '));
+      currentChunk = [];
+      continue;
+    }
+
+    // Prefer breaking at sentence boundaries after threshold
+    if (currentChunk.length >= SENTENCE_BREAK_WORDS && /[.!?]["']?$/.test(word)) {
+      chunks.push(currentChunk.join(' '));
+      currentChunk = [];
+    }
+  }
+
+  if (currentChunk.length > 0) {
+    if (currentChunk.length < MIN_WORDS && chunks.length > 0) {
+      const lastChunk = chunks[chunks.length - 1]!;
+      const mergedWords = lastChunk.split(/\s+/).length + currentChunk.length;
+      if (mergedWords <= MAX_WORDS) {
+        chunks[chunks.length - 1] = lastChunk + ' ' + currentChunk.join(' ');
+      } else {
+        chunks.push(currentChunk.join(' '));
+      }
+    } else {
+      chunks.push(currentChunk.join(' '));
+    }
+  }
+
+  return chunks;
+}
+
+type ContentBlockChunk = {
+  type: 'prose';
+  content: string;
+  headerId?: string;
+  headerTag?: string;
+  tag?: string;
+  language?: string;
+  sectionContext?: string;
+};
+
 /**
  * Chunks content blocks into segments of 64-256 tokens.
  *
  * Chunking strategy:
- * 1. Break at headers if chunk has >= MIN_WORDS, otherwise merge with next section
+ * 1. Break at headers to keep sections isolated
  * 2. Prefer breaking at line/table boundaries after LINE_BREAK_WORDS (~148 words / ~192 tokens)
  * 3. Break at sentence endings after SENTENCE_BREAK_WORDS (~172 words / ~224 tokens)
  * 4. Force break at MAX_WORDS, preferring table row boundaries if available
- * 5. Header context (id/tag) is preserved for continuation chunks
+ * 5. Section context (header hierarchy) is recorded alongside each chunk for discoverability
  */
-function chunkByWords(blocks: ContentBlock[]): { content: string; headerId?: string; headerTag?: string }[] {
-  const chunks: { content: string; headerId?: string; headerTag?: string }[] = [];
+function chunkByWords(blocks: ContentBlock[]): ContentBlockChunk[] {
+  const chunks: ContentBlockChunk[] = [];
 
   let currentChunk: string[] = [];
-  let currentHeaderId: string | undefined;
-  let currentHeaderTag: string | undefined;
+  const ctx = new SectionContext();
 
   // Flush current chunk to output. If splitAt is provided, keep words after that index for next chunk.
   const flushChunk = (splitAt?: number) => {
@@ -64,11 +154,17 @@ function chunkByWords(blocks: ContentBlock[]): { content: string; headerId?: str
     const wordsToKeep = splitAt !== undefined ? currentChunk.slice(splitAt) : [];
 
     if (wordsToFlush.length > 0) {
+      const chunkText = wordsToFlush.join(' ').trim();
+      const sectionContext = ctx.get();
+
       chunks.push({
-        content: wordsToFlush.join(' ').trim(),
-        headerId: currentHeaderId,
-        headerTag: currentHeaderTag,
+        type: 'prose',
+        content: chunkText,
+        headerId: ctx.headerId,
+        headerTag: ctx.headerTag,
+        sectionContext: sectionContext || undefined,
       });
+      ctx.hasContent = true;
     }
     currentChunk = wordsToKeep;
   };
@@ -89,18 +185,33 @@ function chunkByWords(blocks: ContentBlock[]): { content: string; headerId?: str
 
   for (const block of blocks) {
     if (block.type === 'header') {
-      // Flush at header boundaries only if chunk meets minimum size
-      // This avoids creating tiny chunks for headers with little content
-      if (currentChunk.length >= MIN_WORDS) {
-        flushChunk();
+      flushChunk();
+      ctx.header(block);
+      continue;
+    }
+
+    // Chunk code blocks separately; they tend to be more important.
+    if (block.type === 'code') {
+      flushChunk();
+      const codeText = block.text.trim();
+      if (codeText) {
+        for (const chunkText of chunkTextByWords(codeText)) {
+          chunks.push({
+            type: 'prose',
+            content: chunkText,
+            headerId: ctx.headerId,
+            tag: 'code',
+            language: block.language,
+            sectionContext: ctx.get(),
+          });
+          ctx.hasContent = true;
+        }
       }
-      currentHeaderId = block.id;
-      currentHeaderTag = block.tag;
-      // Include header text at the start of the new chunk
-      currentChunk.push(...block.text.split(/\s+/).filter((w) => w.length > 0));
       continue;
     }
 
+    if (block.type !== 'content') continue;
+
     // Split by newlines first to preserve line boundary information
     const lines = block.text.split(/\n/);
     let inCodeBlock = false;
@@ -108,8 +219,8 @@ function chunkByWords(blocks: ContentBlock[]): { content: string; headerId?: str
     for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
       const line = lines[lineIdx]!;
 
-      // Track code block boundaries
-      if (/^(`{3,}|~{3,})/.test(line.trim())) {
+      // Track code block boundaries (standalone fences only)
+      if (/^(`{3,}|~{3,})([a-zA-Z0-9+-]*)?\s*$/.test(line.trim())) {
         inCodeBlock = !inCodeBlock;
       }
 
@@ -155,14 +266,14 @@ function chunkByWords(blocks: ContentBlock[]): { content: string; headerId?: str
 }
 
 /**
- * Parses markdown into content blocks, identifying headers and content sections.
- * Tracks fenced code blocks to avoid treating # comments in code as headers.
+ * Parses markdown into content blocks, identifying headers, content sections, and code blocks.
+ * Code blocks are extracted separately with language metadata for specialized indexing.
  */
 function parseMarkdown(markdown: string): ContentBlock[] {
   const blocks: ContentBlock[] = [];
 
   // Extract title from frontmatter and treat it as h1
-  const frontmatterMatch = markdown.match(/^---\n([\s\S]*?)\n---/);
+  const frontmatterMatch = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (frontmatterMatch) {
     const frontmatter = frontmatterMatch[1]!;
     const titleMatch = frontmatter.match(/^title:\s*(.+)$/m);
@@ -178,61 +289,99 @@ function parseMarkdown(markdown: string): ContentBlock[] {
   }
 
   // Remove frontmatter
-  const content = markdown.replace(/^---[\s\S]*?---\n*/, '').trim();
+  const content = markdown.replace(/^---[\s\S]*?---\r?\n*/, '').trim();
 
   // Split into lines and process
   const lines = content.split('\n');
   let currentContent: string[] = [];
   let inCodeBlock = false;
+  let codeBlockLanguage: string | undefined;
+  let codeBlockContent: string[] = [];
 
   const flushContent = () => {
     const text = currentContent.join('\n').trim();
     if (text) {
-      blocks.push({ type: 'content', text });
+      blocks.push({ type: 'content', tag: 'p', text });
     }
     currentContent = [];
   };
 
+  const flushCodeBlock = () => {
+    if (codeBlockContent.length > 0) {
+      const code = codeBlockContent.join('\n').trim();
+      if (code) {
+        blocks.push({
+          type: 'code',
+          tag: 'code',
+          text: code,
+          language: codeBlockLanguage || undefined,
+        });
+      }
+    }
+    codeBlockContent = [];
+    codeBlockLanguage = undefined;
+  };
+
   for (const line of lines) {
     // Track fenced code blocks (``` or ~~~)
     // Only match standalone markers: ```[language] with nothing else on the line
     // This avoids matching inline code blocks in table cells like "``` Then content..."
-    if (/^(`{3,}|~{3,})([a-zA-Z0-9]*)?(\s*)$/.test(line)) {
-      inCodeBlock = !inCodeBlock;
-      currentContent.push(line);
+    const codeBlockMatch = line.match(/^(`{3,}|~{3,})([a-zA-Z0-9+-]*)?\s*$/);
+    if (codeBlockMatch) {
+      if (!inCodeBlock) {
+        flushContent();
+        inCodeBlock = true;
+        codeBlockLanguage = codeBlockMatch[2] || undefined;
+      } else {
+        flushCodeBlock();
+        inCodeBlock = false;
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeBlockContent.push(line);
       continue;
     }
 
     // Only match headers outside of code blocks
-    if (!inCodeBlock) {
-      const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
 
-      if (headerMatch) {
-        flushContent();
-        const level = headerMatch[1]!.length;
-        const headerText = headerMatch[2]!.trim();
-        blocks.push({
-          type: 'header',
-          tag: `h${level}`,
-          id: slugify(headerText),
-          text: headerText,
-        });
-        continue;
-      }
+    if (headerMatch) {
+      flushContent();
+      const level = headerMatch[1]!.length;
+      const headerText = headerMatch[2]!.trim();
+      blocks.push({
+        type: 'header',
+        tag: `h${level}`,
+        id: slugify(headerText),
+        text: headerText,
+      });
+      continue;
     }
 
     currentContent.push(line);
   }
 
+  flushCodeBlock();
   flushContent();
   return blocks;
 }
 
+export type IndexEntry = {
+  chunk: { id: string; index: number; total: number };
+  id: string;
+  tag: string;
+  content: string;
+  language?: string;
+  sectionContext?: string;
+};
+
 /**
  * Extracts and chunks markdown content for search indexing.
- * Yields chunk objects with content, header context, and chunk metadata.
+ * Yields prose and code chunks with section context and language metadata.
  */
-export function* indexMarkdown(markdown: string) {
+export function* indexMarkdown(markdown: string): Generator<IndexEntry> {
   const blocks = parseMarkdown(markdown);
   const chunks = chunkByWords(blocks);
   const documentId = crypto.randomUUID();
@@ -240,8 +389,10 @@ export function* indexMarkdown(markdown: string) {
   for (const [index, chunk] of chunks.entries()) {
     yield {
       id: chunk.headerId ?? '',
-      tag: chunk.headerTag ?? '',
+      tag: chunk.tag ?? chunk.headerTag ?? '',
       content: chunk.content,
+      ...(chunk.sectionContext ? { sectionContext: chunk.sectionContext } : {}),
+      ...(chunk.language ? { language: chunk.language } : {}),
       chunk: {
         id: documentId,
         index,
@@ -251,64 +402,68 @@ export function* indexMarkdown(markdown: string) {
   }
 }
 
-function chunkHTMLByWords(content: string, chunkSize: number = 30000, chunkOverlap: number = 10) {
-  if (Buffer.byteLength(content) < chunkSize) return [content];
+const DEFAULT_ROOT = 'main';
+const DEFAULT_PATTERN = 'h1, h2, h3, h4, h5, h6, p, li, pre code';
 
-  const words = content.split(/\s+/);
-  const chunks: string[] = [];
-
-  let currentChunk: string[] = [];
-  let currentSize = 0;
+/**
+ * Indexes HTML content for search, with section context and code language extraction.
+ *
+ * Features:
+ * - Tracks header hierarchy to prepend section context (e.g., "Guide > Setup: ...")
+ * - Extracts language metadata from code blocks (class="language-js")
+ * - Uses word-based chunking with sentence boundary detection
+ */
+export function* indexHTML(
+  content: string,
+  root = DEFAULT_ROOT,
+  pattern = DEFAULT_PATTERN,
+): Generator<IndexEntry> {
+  const $ = cheerio.load(content);
+  const matches = $(root).find(pattern);
 
-  for (const word of words) {
-    const wordSize = Buffer.byteLength(word + ' ', 'utf-8');
+  const ctx = new SectionContext();
 
-    if (currentSize + wordSize > chunkSize && currentChunk.length > 0) {
-      chunks.push(currentChunk.join(' '));
+  for (const match of matches) {
+    const tagName = match.tagName.toLowerCase();
+    const rawText = $(match).text().trim();
 
-      const overlapStart = Math.max(0, currentChunk.length - chunkOverlap);
-      currentChunk = currentChunk.slice(overlapStart);
-      currentSize = Buffer.byteLength(currentChunk.join(' '), 'utf-8');
+    if (getHeaderLevel(tagName) > 0) {
+      ctx.header({ id: $(match).attr('id') ?? slugify(rawText), tag: tagName, text: rawText });
+      continue;
     }
 
-    currentChunk.push(word);
-    currentSize += wordSize;
-  }
-
-  if (currentChunk.length > 0) {
-    chunks.push(currentChunk.join(' '));
-  }
-
-  return chunks;
-}
-
-export function* indexHTML(content: string, root: string, pattern: string) {
-  const $ = cheerio.load(content);
-  const matches = $(root).find(pattern);
+    // Check if this is a code block and extract language
+    const isCode = tagName === 'code' && $(match).parent().is('pre');
+    let language: string | undefined;
+    if (isCode) {
+      const classes = $(match).attr('class') || '';
+      const langMatch = classes.match(/(?:language-|lang-)([a-zA-Z0-9+-]+)/);
+      language = langMatch ? langMatch[1] : undefined;
+    }
 
-  for (const match of matches) {
-    const rawText = $(match).text().trim();
-    const chunks = chunkHTMLByWords(rawText);
+    // Build content with section context
+    const sectionContext = ctx.get();
+    const chunks = chunkTextByWords(rawText);
     const chunkId = crypto.randomUUID();
 
-    for (const [chunkN, content] of chunks.entries()) {
+    for (const [chunkN, chunkText] of chunks.entries()) {
       yield {
-        id: $(match).attr('id'),
-        tag: match.tagName.toLowerCase(),
-        content,
+        id: ctx.headerId ?? $(match).attr('id') ?? chunkId,
+        tag: isCode ? 'code' : tagName,
+        content: chunkText,
+        ...(sectionContext ? { sectionContext } : {}),
+        ...(language && { language }),
         chunk: {
           id: chunkId,
           index: chunkN,
           total: chunks.length,
         },
       };
+      ctx.hasContent = true;
     }
   }
 }
 
-const root = 'main';
-const pattern = 'h1, h2, h3, h4, h5, h6, p, li';
-
 export function stainlessDocsAlgoliaProseIndexing({
   apiReferenceBasePath,
 }: {
@@ -338,7 +493,7 @@ export function stainlessDocsAlgoliaProseIndexing({
         const objects = [];
         for (const absHtmlPath of pagesToRender) {
           const content = await readFile(absHtmlPath, 'utf-8');
-          const idx = indexHTML(content, root, pattern);
+          const idx = indexHTML(content);
           for (const entry of idx)
             objects.push({
               ...entry,
@@ -403,6 +558,7 @@ export function stainlessDocsVectorProseIndexing(
           id: string;
           tag: string;
           content: string;
+          language?: string;
           kind: 'prose';
           source: string;
         }[] = [];
@@ -412,7 +568,7 @@ export function stainlessDocsVectorProseIndexing(
 
           if (markdown) {
             const idx = indexMarkdown(markdown);
-            for (const { chunk, ...entry } of idx)
+            for (const { chunk: _, ...entry } of idx)
               objects.push({
                 ...entry,
                 kind: 'prose',

package/virtual-module.d.ts

@@ -57,6 +57,7 @@ declare module 'virtual:stl-docs-virtual-module' {
     primary?: FontConfig;
     heading?: FontConfig;
     mono?: FontConfig;
+    additional?: FontConfig[];
   };
 }