@tiramisu-docs/kit 0.1.0

package/src/lib/open-links.ts

@@ -0,0 +1,50 @@
+export interface OpenLinkOptions {
+  baseUrl: string
+  slug: string
+  locale?: string
+  github?: { repo: string; branch?: string; dir?: string }
+  mcp?: boolean | string
+  title?: string
+}
+
+export interface OpenLink {
+  label: string
+  href?: string
+  copy?: string
+  icon: "chatgpt" | "claude" | "cursor" | "github" | "mcp" | "vscode"
+  type: "open" | "edit" | "mcp"
+}
+
+export function getPageUrl(opts: OpenLinkOptions): string {
+  const localePart = opts.locale ? `${opts.locale}/` : ""
+  const slug = opts.slug === "index" ? "" : opts.slug.replace(/\/index$/, "")
+  return `${opts.baseUrl}/docs/${localePart}${slug}`
+}
+
+export function getGitHubEditUrl(opts: OpenLinkOptions): string | null {
+  if (!opts.github) return null
+  const branch = opts.github.branch ?? "main"
+  const dir = opts.github.dir ?? "src/docs"
+  const localePart = opts.locale ? `${opts.locale}/` : ""
+  return `https://github.com/${opts.github.repo}/edit/${branch}/${dir}/${localePart}${opts.slug}.tiramisu`
+}
+
+export function getOpenLinks(opts: OpenLinkOptions): OpenLink[] {
+  const pageUrl = getPageUrl(opts)
+  const prompt = encodeURIComponent(`Read ${pageUrl} and answer questions about the content.`)
+  const cursorPrompt = encodeURIComponent(`Read ${pageUrl}, I want to ask questions about it.`)
+  const links: OpenLink[] = [
+    { label: "Open in ChatGPT", href: `https://chat.openai.com/?q=${prompt}`, icon: "chatgpt", type: "open" },
+    { label: "Open in Claude", href: `https://claude.ai/new?q=${prompt}`, icon: "claude", type: "open" },
+    { label: "Open in Cursor", href: `https://cursor.com/link/prompt?text=${cursorPrompt}`, icon: "cursor", type: "open" },
+  ]
+  if (opts.mcp) {
+    const mcpUrl = typeof opts.mcp === "string" ? opts.mcp : `${opts.baseUrl}/mcp`
+    links.push({ label: "Connect with MCP", copy: mcpUrl, icon: "mcp", type: "mcp" })
+    const mcpMeta = JSON.stringify({ name: opts.title ?? "Documentation", url: mcpUrl })
+    links.push({ label: "Connect to VSCode", href: `vscode:mcp/install?${encodeURIComponent(mcpMeta)}`, icon: "vscode", type: "mcp" })
+  }
+  const ghUrl = getGitHubEditUrl(opts)
+  if (ghUrl) links.push({ label: "Edit on GitHub", href: ghUrl, icon: "github", type: "edit" })
+  return links
+}

package/src/lib/routes/docs/[...slug]/+page.svelte

@@ -0,0 +1,26 @@
+<script lang="ts">
+  import { DocsLayout, DocPage } from "$lib/components";
+
+  let { data }: { data: Record<string, any> } = $props();
+</script>
+
+<DocsLayout
+  config={data.config}
+  sidebar={data.activeSidebar}
+  headings={data.headings}
+  sections={data.sections}
+  locale={data.locale}
+  locales={data.locales}
+  showFallbackBanner={data.showFallbackBanner}
+>
+  <DocPage
+    meta={data.meta}
+    lastEdited={data.lastEdited}
+    slug={data.slug}
+    baseUrl={data.config?.url}
+    sidebar={data.activeSidebar}
+    siteName={data.config?.title}
+  >
+    <svelte:component this={data.component} />
+  </DocPage>
+</DocsLayout>

package/src/lib/routes/docs/[...slug]/+page.ts

@@ -0,0 +1,117 @@
+import { error, redirect } from "@sveltejs/kit";
+import type { VirtualModule, LocaleData, ResolvedSection, SidebarGroup } from "../../../../types.js";
+
+export async function load({ params }: { params: { slug?: string } }) {
+  const rawSlug = params.slug || "index";
+  const mod: VirtualModule = await import("virtual:tiramisu-docs");
+
+  // If i18n is enabled, parse locale from slug
+  if (mod.locales && mod.defaultLocale) {
+    const segments = rawSlug.split("/");
+    const possibleLocale = segments[0];
+    const localeData = mod.locales[possibleLocale];
+
+    if (localeData) {
+      const locale = possibleLocale;
+      const slug = segments.slice(1).join("/") || "index";
+      return loadDoc(localeData, slug, locale, mod);
+    } else {
+      // No locale prefix — redirect to default locale
+      throw redirect(302, `/docs/${mod.defaultLocale}/${rawSlug}`);
+    }
+  }
+
+  // No i18n — legacy behavior
+  return loadLegacy(mod, rawSlug);
+}
+
+function loadLegacy(mod: VirtualModule, slug: string) {
+  let importFn = mod.docImports[slug] ?? mod.docImports[slug + "/index"];
+
+  // Root /docs with no page — redirect to first section
+  if (!importFn && slug === "index" && mod.sections) {
+    const firstSection = mod.sections.find((s) => s.path);
+    if (firstSection) throw redirect(302, `/docs/${firstSection.path}`);
+  }
+
+  if (!importFn) throw error(404, "Page not found");
+  if (!mod.docImports[slug]) slug = slug + "/index";
+
+  return importFn().then((c) => {
+    const doc = mod.docs.find((d) => d.slug === slug);
+    let activeSidebar: SidebarGroup[] = mod.sidebar;
+    if (mod.sections) {
+      activeSidebar = findActiveSectionSidebar(mod.sections, slug) ?? mod.sidebar;
+    }
+    return {
+      component: c.default ?? c,
+      meta: doc?.meta ?? {},
+      headings: doc?.headings ?? [],
+      lastEdited: doc?.lastEdited,
+      slug,
+      sections: mod.sections ?? undefined,
+      activeSidebar,
+    };
+  });
+}
+
+async function loadDoc(localeData: LocaleData, slug: string, locale: string, mod: VirtualModule) {
+  type ImportFn = () => Promise<{ default: any }>;
+  let importFn: ImportFn | undefined = localeData.docImports[slug] ?? localeData.docImports[slug + "/index"];
+  if (!localeData.docImports[slug] && localeData.docImports[slug + "/index"]) slug = slug + "/index";
+  let showFallbackBanner = false;
+
+  if (!importFn) {
+    const defaultData = mod.locales?.[mod.defaultLocale!];
+    importFn = defaultData?.docImports[slug] ?? defaultData?.docImports[slug + "/index"];
+    if (!defaultData?.docImports[slug] && defaultData?.docImports[slug + "/index"]) slug = slug + "/index";
+    if (!importFn) {
+      // Root /docs/<locale> with no index page — redirect to first section
+      if (slug === "index" && localeData.sections) {
+        const firstSection = localeData.sections.find((s) => s.path);
+        if (firstSection) throw redirect(302, `/docs/${locale}/${firstSection.path}`);
+      }
+      throw error(404, "Page not found");
+    }
+    showFallbackBanner = true;
+  }
+
+  const component = await importFn();
+  const doc = localeData.docs.find((d) => d.slug === slug)
+    ?? mod.locales?.[mod.defaultLocale!]?.docs.find((d) => d.slug === slug);
+
+  const sections = localeData.sections;
+  let activeSidebar: SidebarGroup[] = localeData.sidebar;
+  if (sections) {
+    activeSidebar = findActiveSectionSidebar(sections, slug) ?? localeData.sidebar;
+  }
+
+  return {
+    component: component.default ?? component,
+    meta: doc?.meta ?? {},
+    headings: doc?.headings ?? [],
+    lastEdited: doc?.lastEdited,
+    slug,
+    locale,
+    locales: Object.keys(mod.locales!),
+    sections,
+    activeSidebar,
+    showFallbackBanner,
+  };
+}
+
+function findActiveSectionSidebar(sections: ResolvedSection[], slug: string): SidebarGroup[] | null {
+  for (const section of sections) {
+    if (section.path && (slug === section.path || slug.startsWith(section.path + "/"))) {
+      return section.sidebar ?? null;
+    }
+    if (section.children) {
+      const found = findActiveSectionSidebar(section.children, slug);
+      if (found) return found;
+    }
+  }
+  if (sections.length > 0 && sections[0].sidebar && !sections[0].path) {
+    return sections[0].sidebar;
+  }
+  return null;
+}

package/src/lib/styles/theme.css

@@ -0,0 +1,222 @@
+@custom-variant dark (&:is(.dark *));
+
+:root {
+  --radius: 0.5rem;
+  --font-sans: 'Geist', ui-sans-serif, system-ui, sans-serif;
+  --font-mono: 'Geist Mono', ui-monospace, monospace;
+
+  /* Zinc neutral palette */
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.965 0.001 286.375);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.965 0.001 286.375);
+  --muted-foreground: oklch(0.44 0.003 286.286);
+  --accent: oklch(0.965 0.001 286.375);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: oklch(0.922 0.004 286.32);
+  --input: oklch(0.922 0.004 286.32);
+  --ring: oklch(0.708 0.003 286.286);
+
+  /* Sidebar */
+  --sidebar: oklch(0.985 0 0);
+  --sidebar-foreground: oklch(0.145 0 0);
+  --sidebar-primary: oklch(0.205 0 0);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.965 0.001 286.375);
+  --sidebar-accent-foreground: oklch(0.205 0 0);
+  --sidebar-border: oklch(0.922 0.004 286.32);
+}
+
+.dark {
+  --background: oklch(0.119 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.119 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.119 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.985 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0.006 286.033);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0.006 286.033);
+  --muted-foreground: oklch(0.708 0.003 286.286);
+  --accent: oklch(0.269 0.006 286.033);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(0.24 0.005 286);
+  --input: oklch(0.24 0.005 286);
+  --ring: oklch(0.556 0.002 286.286);
+
+  --sidebar: oklch(0.15 0 0);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.985 0 0);
+  --sidebar-primary-foreground: oklch(0.205 0 0);
+  --sidebar-accent: oklch(0.269 0.006 286.033);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(0.269 0.006 286.033);
+}
+
+/* Tailwind v4 theme mapping */
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --color-sidebar: var(--sidebar);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-border: var(--sidebar-border);
+
+  --font-family-sans: var(--font-sans);
+  --font-family-mono: var(--font-mono);
+
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+}
+
+/* Base styles */
+* {
+  border-color: var(--border);
+}
+
+body {
+  font-family: var(--font-sans);
+  background-color: var(--background);
+  color: var(--foreground);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+/* Smooth scrolling with offset for anchors */
+html {
+  scroll-behavior: smooth;
+  scroll-padding-top: 4rem;
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+::-webkit-scrollbar-thumb {
+  background: var(--border);
+  border-radius: 3px;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: var(--muted-foreground);
+}
+
+/* Selection */
+::selection {
+  background: var(--primary);
+  color: var(--primary-foreground);
+}
+
+/* Blockquote */
+blockquote {
+  border-left: 3px solid var(--border);
+  margin: 1.5rem 0;
+  padding: 0.75rem 1rem;
+  color: var(--muted-foreground);
+  font-style: italic;
+}
+
+blockquote footer {
+  margin-top: 0.5rem;
+  font-style: normal;
+  font-size: 0.875rem;
+}
+
+blockquote cite {
+  color: var(--foreground);
+  font-weight: 500;
+}
+
+/* Task list */
+.task-list {
+  list-style: none;
+  padding-left: 0;
+  margin: 1rem 0;
+}
+
+.task-list li {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.25rem 0;
+}
+
+.task-checkbox {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 1rem;
+  height: 1rem;
+  border: 2px solid var(--border);
+  border-radius: 3px;
+  flex-shrink: 0;
+}
+
+.task-checkbox.checked {
+  background: var(--primary);
+  border-color: var(--primary);
+}
+
+.task-checkbox.checked::after {
+  content: "";
+  width: 0.375rem;
+  height: 0.625rem;
+  border: solid var(--primary-foreground);
+  border-width: 0 2px 2px 0;
+  transform: rotate(45deg) translateY(-1px);
+}
+
+/* Columns */
+.columns {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+  gap: 1.5rem;
+  margin: 1.5rem 0;
+}
+
+.column {
+  min-width: 0;
+}
+
+/* Cards grid */
+.cards-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
+  gap: 1rem;
+  margin: 1.5rem 0;
+}

package/src/lib/utils.ts

@@ -0,0 +1,10 @@
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+export type WithElementRef<T, El extends HTMLElement = HTMLElement> = T & {
+  ref?: El | null
+}

package/src/mcp.ts

@@ -0,0 +1,180 @@
+import type { VirtualDoc, SearchIndexEntry, SidebarGroup } from "./types.js"
+
+export interface McpData {
+  docs: VirtualDoc[]
+  searchIndex: SearchIndexEntry[]
+  sidebar: SidebarGroup[]
+}
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0"
+  id?: string | number
+  method: string
+  params?: Record<string, unknown>
+}
+
+interface JsonRpcResponse {
+  jsonrpc: "2.0"
+  id?: string | number | null
+  result?: unknown
+  error?: { code: number; message: string; data?: unknown }
+}
+
+const TOOL_DEFINITIONS = [
+  {
+    name: "search_docs",
+    description: "Search documentation pages by keyword",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        query: { type: "string", description: "Search query" },
+        limit: { type: "number", description: "Max results (default 10)" },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "read_doc",
+    description: "Read a specific documentation page by slug",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        slug: { type: "string", description: "Page slug" },
+      },
+      required: ["slug"],
+    },
+  },
+  {
+    name: "list_pages",
+    description: "List documentation pages, optionally filtered by section",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        section: { type: "string", description: "Filter by section name" },
+      },
+    },
+  },
+  {
+    name: "list_sections",
+    description: "List all documentation sections with page counts",
+    inputSchema: { type: "object" as const, properties: {} },
+  },
+  {
+    name: "get_table_of_contents",
+    description: "Get headings for a documentation page",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        slug: { type: "string", description: "Page slug" },
+      },
+      required: ["slug"],
+    },
+  },
+]
+
+function toolResult(data: unknown) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] }
+}
+
+function toolError(message: string) {
+  return { content: [{ type: "text", text: message }], isError: true }
+}
+
+function callTool(name: string, args: Record<string, unknown>, data: McpData) {
+  switch (name) {
+    case "search_docs": {
+      const query = String(args.query ?? "")
+      const limit = Number(args.limit ?? 10)
+      const terms = query.toLowerCase().split(/\s+/)
+      const scored = data.searchIndex
+        .map((entry) => {
+          const haystack = `${entry.title} ${entry.headings} ${entry.text}`.toLowerCase()
+          const score = terms.reduce((s, t) => s + (haystack.includes(t) ? 1 : 0), 0)
+          return { entry, score }
+        })
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit)
+      return toolResult(scored.map((r) => ({
+        title: r.entry.title,
+        slug: r.entry.slug,
+        snippet: r.entry.text.slice(0, 200),
+      })))
+    }
+    case "read_doc": {
+      const slug = String(args.slug ?? "")
+      const doc = data.docs.find((d) => d.slug === slug)
+      const idx = data.searchIndex.find((e) => e.slug === slug)
+      if (!doc || !idx) return toolError(`Page not found: ${slug}`)
+      return toolResult({
+        title: doc.meta.title ?? doc.slug,
+        description: doc.meta.description ?? "",
+        content: idx.text,
+        headings: doc.headings,
+      })
+    }
+    case "list_pages": {
+      const section = args.section ? String(args.section).toLowerCase() : ""
+      let filtered = data.searchIndex
+      if (section) {
+        filtered = filtered.filter((e) => e.group.toLowerCase().includes(section))
+      }
+      return toolResult(filtered.map((e) => ({
+        title: e.title,
+        slug: e.slug,
+        description: data.docs.find((d) => d.slug === e.slug)?.meta.description ?? "",
+      })))
+    }
+    case "list_sections": {
+      const groups = new Map<string, number>()
+      for (const entry of data.searchIndex) {
+        groups.set(entry.group, (groups.get(entry.group) ?? 0) + 1)
+      }
+      return toolResult(Array.from(groups.entries()).map(([label, pageCount]) => ({
+        label,
+        path: label.toLowerCase().replace(/ > /g, "/").replace(/ /g, "-"),
+        pageCount,
+      })))
+    }
+    case "get_table_of_contents": {
+      const slug = String(args.slug ?? "")
+      const doc = data.docs.find((d) => d.slug === slug)
+      if (!doc) return toolError(`Page not found: ${slug}`)
+      return toolResult(doc.headings.map((h) => ({ level: h.level, text: h.text, id: h.id })))
+    }
+    default:
+      return toolError(`Unknown tool: ${name}`)
+  }
+}
+
+export function handleMcpRequest(body: JsonRpcRequest, data: McpData): JsonRpcResponse {
+  const { method, id, params } = body
+
+  switch (method) {
+    case "initialize":
+      return {
+        jsonrpc: "2.0",
+        id: id ?? null,
+        result: {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: "tiramisu-docs", version: "0.1.0" },
+        },
+      }
+    case "notifications/initialized":
+      return { jsonrpc: "2.0", id: id ?? null, result: {} }
+    case "tools/list":
+      return { jsonrpc: "2.0", id: id ?? null, result: { tools: TOOL_DEFINITIONS } }
+    case "tools/call": {
+      const name = String((params as any)?.name ?? "")
+      const args = ((params as any)?.arguments ?? {}) as Record<string, unknown>
+      return { jsonrpc: "2.0", id: id ?? null, result: callTool(name, args, data) }
+    }
+    default:
+      return {
+        jsonrpc: "2.0",
+        id: id ?? null,
+        error: { code: -32601, message: `Method not found: ${method}` },
+      }
+  }
+}

package/src/scan.ts

@@ -0,0 +1,92 @@
+import { compileTiramisu } from "@tiramisu-docs/core"
+import type { DocMeta, Heading } from "@tiramisu-docs/core"
+import fs from "node:fs"
+import path from "node:path"
+
+export interface ScannedDoc {
+  slug: string
+  meta: DocMeta
+  headings: Heading[]
+}
+
+import type { SearchIndexEntry } from "./types.js"
+export type { SearchIndexEntry } from "./types.js"
+
+export function findTiramisuFiles(dir: string): string[] {
+  const results: string[] = []
+  if (!fs.existsSync(dir)) return results
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      results.push(...findTiramisuFiles(fullPath))
+    } else if (entry.name.endsWith(".tiramisu")) {
+      results.push(fullPath)
+    }
+  }
+  return results
+}
+
+export function extractPlainText(html: string): string {
+  return html
+    .replace(/<script[\s\S]*?<\/script>/g, "")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/\s+/g, " ")
+    .trim()
+}
+
+export function titleCase(slug: string): string {
+  return slug
+    .split("-")
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(" ")
+}
+
+function resolveSearchGroup(slug: string, meta: DocMeta): string {
+  const segments = slug.split("/")
+  if (segments.length === 1) return meta.group ?? "Docs"
+  return segments
+    .slice(0, -1)
+    .map(titleCase)
+    .join(" > ")
+}
+
+export function scanDocs(docsDir: string): {
+  docs: ScannedDoc[]
+  searchIndex: SearchIndexEntry[]
+} {
+  const absDocsDir = path.resolve(docsDir)
+  const files = findTiramisuFiles(absDocsDir)
+
+  const docs: ScannedDoc[] = []
+
+  for (const file of files) {
+    const source = fs.readFileSync(file, "utf-8")
+    const { meta, headings } = compileTiramisu(source)
+    const relativePath = path.relative(absDocsDir, file)
+    const slug = relativePath.replace(/\.tiramisu$/, "").replace(/\\/g, "/")
+    docs.push({ slug, meta, headings })
+  }
+
+  const searchIndex: SearchIndexEntry[] = docs.map((doc) => {
+    const file = path.resolve(absDocsDir, doc.slug + ".tiramisu")
+    const source = fs.readFileSync(file, "utf-8")
+    const { svelte } = compileTiramisu(source)
+    const text = extractPlainText(svelte)
+    return {
+      id: doc.slug,
+      title: doc.meta.title ?? doc.slug,
+      group: resolveSearchGroup(doc.slug, doc.meta),
+      slug: doc.slug,
+      headings: doc.headings.map((h) => h.text).join(" "),
+      text,
+    }
+  })
+
+  return { docs, searchIndex }
+}