sdocs 0.0.41 → 0.0.42

package/dist/server/snippet-compiler.js

@@ -15,13 +15,25 @@ let docPathRoot = process.cwd();
 export function setDocPathRoot(root) {
     docPathRoot = root;
 }
-/** Encode a doc file path for use in URLs and emitted file names */
-export function encodeDocPath(filePath) {
-    return base64urlEncode(relative(docPathRoot, filePath).split(sep).join('/'));
+/** Encode a doc entity (file + entity slug) for URLs and emitted file names.
+ * The slug rides inside the token as a '#' fragment so every URL shape keeps
+ * exactly one token path segment. */
+export function encodeEntityId(filePath, entitySlug) {
+    return base64urlEncode(relative(docPathRoot, filePath).split(sep).join('/') + '#' + entitySlug);
 }
-/** Decode an encoded doc path back to an absolute path */
-function decodeDocPath(encoded) {
-    return resolve(docPathRoot, base64urlDecode(encoded));
+/** Decode an encoded entity id back to an absolute path + entity slug */
+function decodeEntityId(encoded) {
+    const decoded = base64urlDecode(encoded);
+    const hash = decoded.lastIndexOf('#');
+    const relPath = hash === -1 ? decoded : decoded.slice(0, hash);
+    return {
+        docFilePath: resolve(docPathRoot, relPath),
+        entitySlug: hash === -1 ? '' : decoded.slice(hash + 1),
+    };
+}
+/** The docEntries key for one entity of one file */
+export function entityKey(filePath, entitySlug) {
+    return `${filePath}#${entitySlug}`;
 }
 /** Resolve relative imports to absolute paths for use in virtual components */
 export function resolveImportsToAbsolute(imports, docFilePath) {
@@ -206,48 +218,39 @@ export function generateStaticPreviewHtml(scriptSrc, cssLinks) {
     return previewHtmlShell(links, `<script type="module" src="${scriptSrc}"></script>`);
 }
 /** Build the virtual module ID for an iframe wrapper component */
-export function iframeVirtualId(docFilePath, snippetName) {
-    return `/@sdocs/iframe/${encodeDocPath(docFilePath)}/${snippetName}.svelte`;
+export function iframeVirtualId(docFilePath, entitySlug, snippetSlug) {
+    return `/@sdocs/iframe/${encodeEntityId(docFilePath, entitySlug)}/${snippetSlug}.svelte`;
 }
 /** Build the preview URL for an iframe HTML page (dev mode) */
-export function previewUrl(docFilePath, snippetName) {
-    return `/@sdocs/preview/${encodeDocPath(docFilePath)}/${snippetName}`;
+export function previewUrl(docFilePath, entitySlug, snippetSlug) {
+    return `/@sdocs/preview/${encodeEntityId(docFilePath, entitySlug)}/${snippetSlug}`;
 }
 /** Build the preview URL for static build output */
-export function buildPreviewUrl(docFilePath, snippetName) {
-    return `/previews/${encodeDocPath(docFilePath)}/${snippetName}.html`;
+export function buildPreviewUrl(docFilePath, entitySlug, snippetSlug) {
+    return `/previews/${encodeEntityId(docFilePath, entitySlug)}/${snippetSlug}.html`;
 }
 /** Virtual module ID for a preview's mount script (embedded production builds) */
-export function mountVirtualId(docFilePath, snippetName) {
-    return `/@sdocs/mount/${encodeDocPath(docFilePath)}/${snippetName}.js`;
+export function mountVirtualId(docFilePath, entitySlug, snippetSlug) {
+    return `/@sdocs/mount/${encodeEntityId(docFilePath, entitySlug)}/${snippetSlug}.js`;
 }
 /** Parse a mount virtual ID back into its parts */
 export function parseMountId(id) {
-    const match = id.match(/^\/@sdocs\/mount\/([^/]+)\/(\w+)\.js$/);
+    const match = id.match(/^\/@sdocs\/mount\/([^/]+)\/([\w-]+)\.js$/);
     if (!match)
         return null;
-    return {
-        docFilePath: decodeDocPath(match[1]),
-        snippetName: match[2],
-    };
+    return { ...decodeEntityId(match[1]), snippetSlug: match[2] };
 }
 /** Parse an iframe virtual ID back into its parts */
 export function parseIframeId(id) {
-    const match = id.match(/^\/@sdocs\/iframe\/([^/]+)\/(\w+)\.svelte$/);
+    const match = id.match(/^\/@sdocs\/iframe\/([^/]+)\/([\w-]+)\.svelte$/);
     if (!match)
         return null;
-    return {
-        docFilePath: decodeDocPath(match[1]),
-        snippetName: match[2],
-    };
+    return { ...decodeEntityId(match[1]), snippetSlug: match[2] };
 }
 /** Parse a preview URL back into its parts */
 export function parsePreviewUrl(url) {
-    const match = url.match(/^\/@sdocs\/preview\/([^/]+)\/(\w+)$/);
+    const match = url.match(/^\/@sdocs\/preview\/([^/]+)\/([\w-]+)$/);
     if (!match)
         return null;
-    return {
-        docFilePath: decodeDocPath(match[1]),
-        snippetName: match[2],
-    };
+    return { ...decodeEntityId(match[1]), snippetSlug: match[2] };
 }

package/dist/types.d.ts

@@ -33,18 +33,12 @@ export interface ResolvedSdocsConfig {
         open: string[];
     };
 }
-/** Meta extracted from a .sdoc file */
+/** Entity metadata from a [DOCS]/[PAGE]/[LAYOUT] opener */
 export interface SdocMeta {
-    /** The Svelte component being documented */
-    component?: unknown;
     /** Sidebar path (e.g. 'Demo / Button') */
     title: string;
     /** Short description */
     description?: string;
-    /** Default prop values */
-    args?: Record<string, unknown>;
-    /** Preview settings (padding, background, etc.) */
-    settings?: Record<string, unknown>;
 }
 /** A parsed prop */
 export interface ParsedProp {
@@ -82,36 +76,58 @@ export interface ComponentData {
     state: ParsedState[];
     cssProps: ParsedCssProp[];
 }
-/** An extracted snippet */
+/** A renderable snippet of an entity: a preview, an example, or the body */
 export interface ExtractedSnippet {
+    /** Display name: preview label / example title / 'Content' */
     name: string;
+    /** URL-safe id, unique within the entity */
+    slug: string;
+    role: 'preview' | 'example' | 'content';
     body: string;
     highlightedHtml?: string;
     /** Preview URL for iframe (added by virtual module) */
     previewUrl?: string;
 }
+/** One [preview] of a DOCS entity: a live showcase of one component */
+export interface PreviewEntry {
+    /** Tab label (title override or the component name) */
+    label: string;
+    /** The previewed component's identifier in the file's script */
+    componentName: string | null;
+    /** Absolute path to the previewed component */
+    componentPath: string | null;
+    /** Parsed component data (props, methods, state, CSS props) */
+    componentData: ComponentData | null;
+    /** Highlighted component source HTML */
+    highlightedSource: string | null;
+    /** Control defaults for this preview */
+    args: Record<string, unknown>;
+    snippet: ExtractedSnippet;
+}
 /** A table of contents heading (for pages) */
 export interface TocHeading {
     text: string;
     level: number;
     id: string;
 }
-/** A complete doc entry (one .sdoc file) */
+/** A complete doc entry (one entity of one .sdoc file) */
 export interface DocEntry {
-    /** Doc kind */
+    /** Doc kind: DOCS / PAGE / LAYOUT */
     kind: 'component' | 'page' | 'layout';
     /** Absolute path to the .sdoc file */
     filePath: string;
-    /** Absolute path to the documented component */
-    componentPath: string | null;
-    /** Parsed meta */
+    /** URL-safe entity id, unique within the file */
+    entitySlug: string;
+    /** Entity metadata (title drives the sidebar) */
     meta: SdocMeta;
-    /** Parsed component data (props, methods, state, CSS props) */
-    componentData: ComponentData | null;
-    /** Extracted snippets */
-    snippets: ExtractedSnippet[];
-    /** Highlighted component source HTML */
-    highlightedSource: string | null;
+    /** Live previews (component kind; empty otherwise) */
+    previews: PreviewEntry[];
+    /** Frozen examples (component kind; empty otherwise) */
+    examples: ExtractedSnippet[];
+    /** The rendered body (page/layout kind; null otherwise) */
+    content: ExtractedSnippet | null;
     /** Table of contents headings (pages only) */
     toc?: TocHeading[];
+    /** Stage padding (layouts only) */
+    padding?: string | null;
 }

package/dist/vite.js

@@ -1,17 +1,25 @@
 import { readFile } from 'node:fs/promises';
 import { loadRawConfig, resolveAndFinalize } from './server/config.js';
-import { discoverDocFiles, getSdocKind } from './server/discovery.js';
-import { parseDocSource } from './server/meta-parser.js';
+import { discoverDocFiles } from './server/discovery.js';
 import { parseComponent } from './server/prop-parser.js';
-import { extractSnippets, extractMarkupBody, hasDefaultSnippet, generateAutoDefault, } from './server/snippet-extractor.js';
+import { parseSdoc, offsetToPosition } from './language/index.js';
+import { planEntitySnippets, extractImports, resolveComponentImport, } from './server/doc-model.js';
+import { renderPageMarkdown } from './server/page-markdown.js';
 import { highlight, disposeHighlighter } from './server/highlighter.js';
-import { extractTocFromHtml } from './server/toc-extractor.js';
-import { parseIframeId, parseMountId, parsePreviewUrl, resolveImportsToAbsolute, generateIframeComponent, generateMountScript, generatePreviewHtml, generateStaticPreviewHtml, iframeVirtualId, mountVirtualId, previewUrl, buildPreviewUrl, encodeDocPath, setDocPathRoot, } from './server/snippet-compiler.js';
+import { parseIframeId, parseMountId, parsePreviewUrl, resolveImportsToAbsolute, generateIframeComponent, generateMountScript, generatePreviewHtml, generateStaticPreviewHtml, iframeVirtualId, mountVirtualId, previewUrl, buildPreviewUrl, encodeEntityId, entityKey, setDocPathRoot, } from './server/snippet-compiler.js';
 const VIRTUAL_MODULE_ID = 'virtual:sdocs';
 const RESOLVED_VIRTUAL_ID = '\0virtual:sdocs';
 const IFRAME_PREFIX = '/@sdocs/iframe/';
 const PREVIEW_PREFIX = '/@sdocs/preview/';
 const MOUNT_PREFIX = '/@sdocs/mount/';
+/** Every renderable snippet of an entry, in order. */
+function allSnippets(entry) {
+    return [
+        ...entry.previews.map((p) => p.snippet),
+        ...entry.examples,
+        ...(entry.content ? [entry.content] : []),
+    ];
+}
 export function sdocsPlugin(userConfig) {
     let config;
     let root;
@@ -48,19 +56,19 @@ export function sdocsPlugin(userConfig) {
                 const parsed = parsePreviewUrl(req.url);
                 if (!parsed)
                     return next();
-                const entry = docEntries.get(parsed.docFilePath);
+                const entry = docEntries.get(entityKey(parsed.docFilePath, parsed.entitySlug));
                 if (!entry) {
                     res.statusCode = 404;
                     res.end('Doc not found');
                     return;
                 }
-                const snippet = entry.snippets.find((s) => s.name === parsed.snippetName);
+                const snippet = allSnippets(entry).find((s) => s.slug === parsed.snippetSlug);
                 if (!snippet) {
                     res.statusCode = 404;
                     res.end('Snippet not found');
                     return;
                 }
-                const iframeId = iframeVirtualId(parsed.docFilePath, parsed.snippetName);
+                const iframeId = iframeVirtualId(parsed.docFilePath, parsed.entitySlug, snippet.slug);
                 const html = generatePreviewHtml(iframeId, config.css);
                 res.setHeader('Content-Type', 'text/html');
                 // Let Vite transform the HTML (resolves imports, injects HMR client)
@@ -83,7 +91,7 @@ export function sdocsPlugin(userConfig) {
             server.watcher.on('unlink', (filePath) => {
                 if (isDocFile(filePath)) {
                     console.log(`[sdocs] Removed doc file: ${filePath}`);
-                    docEntries.delete(filePath);
+                    deleteEntriesOf(filePath);
                     docImportsCache.delete(filePath);
                     invalidateVirtualModule();
                 }
@@ -140,17 +148,17 @@ export function sdocsPlugin(userConfig) {
                     }
                 }
                 for (const entry of docEntries.values()) {
-                    const encoded = encodeDocPath(entry.filePath);
-                    for (const snippet of entry.snippets) {
-                        const jsFileName = `previews/${encoded}/${snippet.name}.js`;
+                    const encoded = encodeEntityId(entry.filePath, entry.entitySlug);
+                    for (const snippet of allSnippets(entry)) {
+                        const jsFileName = `previews/${encoded}/${snippet.slug}.js`;
                         this.emitFile({
                             type: 'chunk',
-                            id: mountVirtualId(entry.filePath, snippet.name),
+                            id: mountVirtualId(entry.filePath, entry.entitySlug, snippet.slug),
                             fileName: jsFileName,
                         });
                         plannedPreviews.push({
                             jsFileName,
-                            htmlFileName: `previews/${encoded}/${snippet.name}.html`,
+                            htmlFileName: `previews/${encoded}/${snippet.slug}.html`,
                         });
                     }
                 }
@@ -178,7 +186,7 @@ export function sdocsPlugin(userConfig) {
                         cssFiles.add(css);
                     queue.push(...mod.imports);
                 }
-                // The HTML sits at previews/<doc>/<name>.html — two levels deep.
+                // The HTML sits at previews/<entity>/<name>.html — two levels deep.
                 const cssLinks = [
                     ...emittedCssLinks,
                     ...[...cssFiles].map((file) => ({ href: `../../${file}` })),
@@ -209,23 +217,25 @@ export function sdocsPlugin(userConfig) {
                 const parsed = parseIframeId(realId);
                 if (!parsed)
                     return null;
-                const entry = docEntries.get(parsed.docFilePath);
+                const entry = docEntries.get(entityKey(parsed.docFilePath, parsed.entitySlug));
                 if (!entry)
                     return null;
-                const snippet = entry.snippets.find((s) => s.name === parsed.snippetName);
+                const snippet = allSnippets(entry).find((s) => s.slug === parsed.snippetSlug);
                 if (!snippet)
                     return null;
                 const absoluteImports = docImportsCache.get(parsed.docFilePath) ?? [];
-                const stateNames = (entry.componentData?.state ?? []).map((s) => s.name);
-                const componentName = entry.componentPath?.split('/').pop()?.replace('.svelte', '');
-                return generateIframeComponent(absoluteImports, snippet.body, stateNames, componentName);
+                // Method calls and live state bind to the snippet's own preview;
+                // example iframes fall back to the first preview's component.
+                const preview = entry.previews.find((p) => p.snippet.slug === snippet.slug) ?? entry.previews[0];
+                const stateNames = (preview?.componentData?.state ?? []).map((s) => s.name);
+                return generateIframeComponent(absoluteImports, snippet.body, stateNames, preview?.componentName ?? undefined);
             }
             // Virtual mount script for an emitted preview page
             if (id.startsWith('\0' + MOUNT_PREFIX)) {
                 const parsed = parseMountId(id.slice(1));
                 if (!parsed)
                     return null;
-                return generateMountScript(iframeVirtualId(parsed.docFilePath, parsed.snippetName));
+                return generateMountScript(iframeVirtualId(parsed.docFilePath, parsed.entitySlug, parsed.snippetSlug));
             }
         },
         async buildEnd() {
@@ -234,90 +244,132 @@ export function sdocsPlugin(userConfig) {
     };
     // ─── Process a single doc file ───
     async function processDocFile(filePath) {
-        const source = await readFile(filePath, 'utf-8');
-        const kind = getSdocKind(filePath);
-        const parsed = parseDocSource(source, filePath);
-        const meta = parsed.meta;
-        const componentPath = parsed.componentPath;
-        const imports = parsed.imports;
-        let snippets;
-        let toc;
-        if (kind === 'page' || kind === 'layout') {
-            const body = extractMarkupBody(source);
-            snippets = [{ name: 'Content', body }];
-            if (kind === 'page') {
-                toc = extractTocFromHtml(body);
-            }
+        try {
+            await processDocFileInner(filePath);
         }
-        else {
-            snippets = extractSnippets(source);
-            if (!hasDefaultSnippet(snippets)) {
-                const componentName = componentPath?.split('/').pop()?.replace('.svelte', '') ?? 'Component';
-                snippets.unshift({
-                    name: 'Default',
-                    body: generateAutoDefault(componentName),
-                });
-            }
+        catch (err) {
+            // A half-written file must never kill the dev server.
+            console.warn(`[sdocs] Failed to process ${filePath}:`, err);
         }
-        // If component is specified as a path but not imported, auto-add the import
-        if (componentPath) {
-            const componentName = componentPath.split('/').pop()?.replace('.svelte', '') ?? 'Component';
-            const hasImport = imports.some((imp) => imp.includes(componentName));
-            if (!hasImport) {
-                imports.push(`import ${componentName} from '${componentPath}'`);
-            }
+    }
+    async function processDocFileInner(filePath) {
+        const source = await readFile(filePath, 'utf-8');
+        const doc = parseSdoc(source);
+        for (const d of doc.diagnostics) {
+            const pos = offsetToPosition(source, d.span.start);
+            console.warn(`[sdocs] ${filePath}:${pos.line + 1}:${pos.column + 1} — ${d.message}`);
         }
-        // Cache resolved imports for iframe component generation
+        deleteEntriesOf(filePath);
+        const scriptContent = doc.script?.content ?? '';
+        const imports = extractImports(scriptContent);
         docImportsCache.set(filePath, resolveImportsToAbsolute(imports, filePath));
-        let componentData = null;
-        let highlightedSource = null;
-        if (kind === 'component' && componentPath) {
-            try {
-                componentData = await parseComponent(componentPath);
-                const componentSource = await readFile(componentPath, 'utf-8');
-                highlightedSource = await highlight(componentSource);
+        // One component parse per component file per rebuild, however many
+        // previews reference it.
+        const componentCache = new Map();
+        const loadComponent = async (componentPath) => {
+            let cached = componentCache.get(componentPath);
+            if (!cached) {
+                cached = { data: null, highlighted: null };
+                try {
+                    cached.data = await parseComponent(componentPath);
+                    const componentSource = await readFile(componentPath, 'utf-8');
+                    cached.highlighted = await highlight(componentSource);
+                }
+                catch (err) {
+                    console.warn(`[sdocs] Failed to parse component: ${componentPath}`, err);
+                }
+                componentCache.set(componentPath, cached);
+            }
+            return cached;
+        };
+        for (const entity of doc.entities) {
+            const planned = planEntitySnippets(entity);
+            const snippets = planned.map((p) => ({
+                name: p.name,
+                slug: p.slug,
+                role: p.role,
+                body: p.body,
+            }));
+            const entry = {
+                kind: entity.kind === 'DOCS' ? 'component' : entity.kind === 'PAGE' ? 'page' : 'layout',
+                filePath,
+                entitySlug: entity.slug,
+                meta: { title: entity.title },
+                previews: [],
+                examples: [],
+                content: null,
+            };
+            if (entity.kind === 'DOCS') {
+                if (entity.description)
+                    entry.meta.description = entity.description;
+                for (const [i, preview] of entity.previews.entries()) {
+                    const snippet = snippets[i];
+                    let componentPath = null;
+                    let componentData = null;
+                    let highlightedSource = null;
+                    if (preview.componentName) {
+                        componentPath = resolveComponentImport(preview.componentName, imports, filePath);
+                        if (componentPath) {
+                            const loaded = await loadComponent(componentPath);
+                            componentData = loaded.data;
+                            highlightedSource = loaded.highlighted;
+                        }
+                        else {
+                            console.warn(`[sdocs] ${filePath}: component {${preview.componentName}} is not imported in the file's <script>`);
+                        }
+                    }
+                    snippet.highlightedHtml = await highlight(snippet.body);
+                    entry.previews.push({
+                        label: preview.label,
+                        componentName: preview.componentName,
+                        componentPath,
+                        componentData,
+                        highlightedSource,
+                        args: preview.args ?? {},
+                        snippet,
+                    });
+                }
+                entry.examples = snippets.filter((s) => s.role === 'example');
+                for (const example of entry.examples) {
+                    example.highlightedHtml = await highlight(example.body);
+                }
             }
-            catch (err) {
-                console.warn(`[sdocs] Failed to parse component: ${componentPath}`, err);
+            else if (entity.kind === 'PAGE') {
+                const rendered = await renderPageMarkdown(entity.body);
+                snippets[0].body = rendered.html;
+                entry.content = snippets[0];
+                entry.toc = rendered.toc;
             }
+            else {
+                entry.content = snippets[0];
+                entry.padding = entity.padding;
+            }
+            docEntries.set(entityKey(filePath, entity.slug), entry);
         }
-        for (const snippet of snippets) {
-            snippet.highlightedHtml = await highlight(snippet.body);
-        }
-        docEntries.set(filePath, {
-            kind,
-            filePath,
-            componentPath,
-            meta,
-            componentData,
-            snippets,
-            highlightedSource,
-            toc,
-        });
     }
     // ─── Generate the virtual module ───
     function generateVirtualModule() {
-        const entries = Array.from(docEntries.values());
-        const data = entries.map((e) => ({
+        const urlFor = (entry, snippet) => 
+        // Only absolute bases prefix here; SvelteKit builds with a relative
+        // base ('./') and passes its real path via the Explorer's previewBase.
+        (base.startsWith('/') && base !== '/' ? base.replace(/\/$/, '') : '') +
+            (buildMode || isBuild
+                ? buildPreviewUrl(entry.filePath, entry.entitySlug, snippet.slug)
+                : previewUrl(entry.filePath, entry.entitySlug, snippet.slug));
+        const withUrl = (entry, snippet) => ({
+            ...snippet,
+            previewUrl: urlFor(entry, snippet),
+        });
+        const data = Array.from(docEntries.values()).map((e) => ({
             kind: e.kind,
             filePath: e.filePath,
-            componentPath: e.componentPath,
+            entitySlug: e.entitySlug,
             meta: e.meta,
-            componentData: e.componentData,
-            snippets: e.snippets.map((s) => ({
-                name: s.name,
-                body: s.body,
-                highlightedHtml: s.highlightedHtml,
-                previewUrl: 
-                // Only absolute bases prefix here; SvelteKit builds with a relative
-                // base ('./') and passes its real path via the Explorer's previewBase.
-                (base.startsWith('/') && base !== '/' ? base.replace(/\/$/, '') : '') +
-                    (buildMode || isBuild
-                        ? buildPreviewUrl(e.filePath, s.name)
-                        : previewUrl(e.filePath, s.name)),
-            })),
-            highlightedSource: e.highlightedSource,
+            previews: e.previews.map((p) => ({ ...p, snippet: withUrl(e, p.snippet) })),
+            examples: e.examples.map((s) => withUrl(e, s)),
+            content: e.content ? withUrl(e, e.content) : null,
             toc: e.toc,
+            padding: e.padding,
         }));
         // Extract named CSS stylesheet names (empty array if single string or null)
         const cssNames = config.css && typeof config.css === 'object'
@@ -335,10 +387,9 @@ export function sdocsPlugin(userConfig) {
         }
         // Also invalidate iframe virtual modules for the changed doc file
         if (docFilePath) {
-            const entry = docEntries.get(docFilePath);
-            if (entry) {
-                for (const snippet of entry.snippets) {
-                    const iframeId = '\0' + iframeVirtualId(docFilePath, snippet.name);
+            for (const entry of entriesOf(docFilePath)) {
+                for (const snippet of allSnippets(entry)) {
+                    const iframeId = '\0' + iframeVirtualId(docFilePath, entry.entitySlug, snippet.slug);
                     const iframeMod = server.moduleGraph.getModuleById(iframeId);
                     if (iframeMod) {
                         server.moduleGraph.invalidateModule(iframeMod);
@@ -351,6 +402,20 @@ export function sdocsPlugin(userConfig) {
     function isDocFile(filePath) {
         return filePath.endsWith('.sdoc');
     }
+    function entriesOf(filePath) {
+        const entries = [];
+        for (const [key, entry] of docEntries) {
+            if (key.startsWith(filePath + '#'))
+                entries.push(entry);
+        }
+        return entries;
+    }
+    function deleteEntriesOf(filePath) {
+        for (const key of [...docEntries.keys()]) {
+            if (key.startsWith(filePath + '#'))
+                docEntries.delete(key);
+        }
+    }
     /** Emit a user stylesheet as a build asset; returns its href relative to a preview page. */
     async function emitCssAsset(ctx, href, name) {
         if (href.startsWith('http'))
@@ -362,16 +427,20 @@ export function sdocsPlugin(userConfig) {
     }
     function isComponentReferencedByDoc(filePath) {
         for (const entry of docEntries.values()) {
-            if (entry.componentPath === filePath)
+            if (entry.previews.some((p) => p.componentPath === filePath))
                 return true;
         }
         return false;
     }
     async function reprocessComponentEntries(componentPath) {
-        for (const [docPath, entry] of docEntries) {
-            if (entry.componentPath === componentPath) {
-                await processDocFile(docPath);
+        const files = new Set();
+        for (const entry of docEntries.values()) {
+            if (entry.previews.some((p) => p.componentPath === componentPath)) {
+                files.add(entry.filePath);
             }
         }
+        for (const file of files) {
+            await processDocFile(file);
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdocs",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "description": "A lightweight documentation tool for Svelte 5 components",
   "type": "module",
   "license": "MIT",
@@ -61,6 +61,7 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "marked": "^16.4.2",
     "shiki": "^3.22.0",
     "tinyglobby": "^0.2.15",
     "typescript": "^5.7.0"

package/dist/server/meta-parser.d.ts

@@ -1,11 +0,0 @@
-import type { SdocMeta } from '../types.js';
-interface MetaParseResult {
-    meta: SdocMeta;
-    componentPath: string | null;
-    imports: string[];
-}
-/** Extract meta and imports from a .sdoc file */
-export declare function parseDocFile(filePath: string): Promise<MetaParseResult>;
-/** Parse meta from .sdoc source */
-export declare function parseDocSource(source: string, filePath: string): MetaParseResult;
-export {};