@refrakt-md/editor 0.6.0

package/dist/server.js

@@ -0,0 +1,694 @@
+import { createServer } from 'node:http';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync, rmSync, statSync, renameSync, watch } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { join, resolve, normalize, extname, relative } from 'node:path';
+import { exec } from 'node:child_process';
+import { ContentTree } from '@refrakt-md/content';
+import { parseFrontmatter, serializeFrontmatter } from '@refrakt-md/content';
+import { runes as allRunes, RUNE_EXAMPLES } from '@refrakt-md/runes';
+import { createTransform } from '@refrakt-md/transform';
+import { bundleCss } from './css.js';
+import { renderPreviewPage, renderPreviewContent } from './preview.js';
+import { createHighlightTransform } from '@refrakt-md/highlight';
+import { buildPreviewRuntime } from './preview-builder.js';
+import { LayoutResolver } from './layout-resolver.js';
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+};
+/**
+ * Resolve the path to the built frontend (app/dist).
+ * Works from both the compiled dist/ directory and the source src/ directory.
+ */
+function resolveAppDist() {
+    // import.meta.dirname gives us the directory of THIS file.
+    // In compiled form: packages/editor/dist/
+    // We need:          packages/editor/app/dist/
+    const thisDir = import.meta.dirname;
+    const appDist = resolve(thisDir, '..', 'app', 'dist');
+    return appDist;
+}
+export async function startEditor(options) {
+    const { contentDir, port = 4800, themeConfig, themeCssPath, themeSveltePath, staticDir, devServer, open = true, configPath, } = options;
+    let routeRules = options.routeRules ?? [];
+    const absContentDir = resolve(contentDir);
+    const appDistDir = resolveAppDist();
+    // ── Own-write suppression ────────────────────────────────────
+    // When the server writes a file, record the path so the watcher
+    // can skip the resulting fs event. Entries expire after 2 seconds.
+    const ownWrites = new Map();
+    function markOwnWrite(relPath) {
+        ownWrites.set(relPath, Date.now() + 2000);
+    }
+    function isOwnWrite(relPath) {
+        const deadline = ownWrites.get(relPath);
+        if (!deadline)
+            return false;
+        if (Date.now() > deadline) {
+            ownWrites.delete(relPath);
+            return false;
+        }
+        ownWrites.delete(relPath);
+        return true;
+    }
+    const sseClients = new Set();
+    function broadcastSSE(event, data) {
+        const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        for (const client of sseClients) {
+            client.write(payload);
+        }
+    }
+    // Bundle theme CSS once on startup
+    let themeCss = '';
+    if (themeCssPath && existsSync(themeCssPath)) {
+        themeCss = bundleCss(themeCssPath);
+    }
+    // Initialize syntax highlighting (Shiki)
+    const highlightTransform = await createHighlightTransform();
+    if (highlightTransform.css) {
+        themeCss += '\n' + highlightTransform.css;
+    }
+    // Build Svelte preview runtime if theme has a Svelte entry
+    let previewRuntimeDir = null;
+    if (themeSveltePath) {
+        const result = await buildPreviewRuntime(themeSveltePath);
+        if (result.success) {
+            previewRuntimeDir = result.outputDir;
+            console.log('  Preview runtime: built \u2713');
+        }
+    }
+    // Initialize layout resolver for full-page preview with layouts
+    const layoutResolver = new LayoutResolver(absContentDir, themeConfig);
+    await layoutResolver.refresh();
+    // Create identity transform once (reused across preview requests)
+    const identityTransform = createTransform(themeConfig);
+    const server = createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url, `http://localhost:${port}`);
+            const method = req.method ?? 'GET';
+            // CORS headers for development
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            if (method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            // API routes
+            if (method === 'GET' && url.pathname === '/api/tree') {
+                await handleGetTree(res, absContentDir);
+            }
+            else if (method === 'GET' && url.pathname.startsWith('/api/files/')) {
+                const filePath = decodeURIComponent(url.pathname.slice('/api/files/'.length));
+                handleGetFile(res, absContentDir, filePath);
+            }
+            else if (method === 'PUT' && url.pathname.startsWith('/api/files/')) {
+                const filePath = decodeURIComponent(url.pathname.slice('/api/files/'.length));
+                markOwnWrite(filePath);
+                await handlePutFile(req, res, absContentDir, filePath);
+                // Refresh layout resolver so layout changes propagate to preview
+                layoutResolver.refresh().catch(() => { });
+            }
+            else if (method === 'GET' && url.pathname.startsWith('/api/preview/')) {
+                const filePath = decodeURIComponent(url.pathname.slice('/api/preview/'.length));
+                handlePreview(res, absContentDir, filePath, themeConfig, themeCss, highlightTransform);
+            }
+            else if (method === 'POST' && url.pathname === '/api/preview') {
+                await handlePreviewContent(req, res, themeConfig, themeCss, highlightTransform);
+            }
+            else if (method === 'POST' && url.pathname === '/api/pages') {
+                await handleCreatePage(req, res, absContentDir, markOwnWrite);
+            }
+            else if (method === 'POST' && url.pathname === '/api/directories') {
+                await handleCreateDirectory(req, res, absContentDir, markOwnWrite);
+            }
+            else if (method === 'POST' && url.pathname === '/api/rename') {
+                await handleRename(req, res, absContentDir, markOwnWrite);
+            }
+            else if (method === 'POST' && url.pathname === '/api/duplicate') {
+                await handleDuplicate(req, res, absContentDir, markOwnWrite);
+            }
+            else if (method === 'DELETE' && url.pathname.startsWith('/api/files/')) {
+                const filePath = decodeURIComponent(url.pathname.slice('/api/files/'.length));
+                markOwnWrite(filePath);
+                handleDelete(res, absContentDir, filePath);
+            }
+            else if (method === 'POST' && url.pathname === '/api/toggle-draft') {
+                await handleToggleDraft(req, res, absContentDir, markOwnWrite);
+            }
+            else if (method === 'GET' && url.pathname === '/api/pages-list') {
+                await handlePagesList(res, absContentDir);
+            }
+            else if (method === 'GET' && url.pathname === '/api/runes') {
+                handleGetRunes(res);
+            }
+            else if (method === 'GET' && url.pathname === '/api/config') {
+                serveJson(res, {
+                    previewRuntime: previewRuntimeDir !== null,
+                    devServerUrl: devServer ?? null,
+                    themeCss,
+                    themeConfig: stripFunctions(themeConfig),
+                });
+            }
+            else if (method === 'GET' && url.pathname === '/api/route-rules') {
+                serveJson(res, { routeRules });
+            }
+            else if (method === 'PUT' && url.pathname === '/api/route-rules') {
+                if (!configPath) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'No config file path available' }));
+                }
+                else {
+                    const body = await readBody(req);
+                    const { routeRules: newRules } = JSON.parse(body);
+                    // Update in-memory rules
+                    routeRules = newRules;
+                    // Read existing config, update routeRules field, write back
+                    const configRaw = readFileSync(configPath, 'utf-8');
+                    const config = JSON.parse(configRaw);
+                    config.routeRules = newRules;
+                    writeFileSync(configPath, JSON.stringify(config, null, '\t') + '\n', 'utf-8');
+                    serveJson(res, { ok: true });
+                }
+            }
+            else if (method === 'POST' && url.pathname === '/api/preview-data') {
+                await handlePreviewData(req, res, layoutResolver, identityTransform, highlightTransform);
+            }
+            else if (method === 'GET' && url.pathname === '/api/events') {
+                // SSE endpoint — keep connection open for file-change push events
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'Access-Control-Allow-Origin': '*',
+                });
+                res.write(': connected\n\n');
+                sseClients.add(res);
+                req.on('close', () => { sseClients.delete(res); });
+                return;
+            }
+            else if (previewRuntimeDir && method === 'GET' && url.pathname === '/preview/theme.css') {
+                res.writeHead(200, { 'Content-Type': 'text/css; charset=utf-8' });
+                res.end(themeCss);
+            }
+            else if (previewRuntimeDir && method === 'GET' && url.pathname.startsWith('/preview/')) {
+                const file = url.pathname.slice('/preview/'.length) || 'index.html';
+                serveStatic(res, previewRuntimeDir, '/' + file);
+            }
+            else if (staticDir && method === 'GET' && !url.pathname.startsWith('/api/')) {
+                // Try project static dir first (images, fonts, etc.), then SPA fallback
+                const staticFile = join(staticDir, url.pathname);
+                if (staticFile.startsWith(staticDir) && existsSync(staticFile) && statSync(staticFile).isFile()) {
+                    const ext = extname(staticFile);
+                    const contentType = MIME_TYPES[ext] ?? 'application/octet-stream';
+                    const content = readFileSync(staticFile);
+                    res.writeHead(200, { 'Content-Type': contentType });
+                    res.end(content);
+                }
+                else {
+                    serveStatic(res, appDistDir, url.pathname);
+                }
+            }
+            else if (method === 'GET') {
+                // Serve static frontend (SPA fallback to index.html)
+                serveStatic(res, appDistDir, url.pathname);
+            }
+            else {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Not Found' }));
+            }
+        }
+        catch (err) {
+            console.error('Server error:', err);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Internal Server Error' }));
+        }
+    });
+    server.listen(port, '127.0.0.1', () => {
+        const url = `http://localhost:${port}`;
+        console.log(`\n  refrakt editor running at ${url}\n`);
+        console.log(`  Content directory: ${absContentDir}`);
+        if (staticDir)
+            console.log(`  Static directory: ${staticDir}`);
+        if (devServer)
+            console.log(`  Dev server: ${devServer}`);
+        console.log('');
+        if (open) {
+            const cmd = process.platform === 'darwin'
+                ? 'open'
+                : process.platform === 'win32'
+                    ? 'start'
+                    : 'xdg-open';
+            exec(`${cmd} ${url}`);
+        }
+    });
+    // ── File watcher ─────────────────────────────────────────────
+    // Watch content directory for external changes (other editors, git, etc.)
+    const watchDebounce = new Map();
+    watch(absContentDir, { recursive: true }, (eventType, filename) => {
+        if (!filename)
+            return;
+        // Skip hidden files and directories (.DS_Store, .git, etc.)
+        if (filename.split('/').some(part => part.startsWith('.')))
+            return;
+        // Only care about markdown files
+        if (!filename.endsWith('.md'))
+            return;
+        const relPath = filename;
+        // Skip our own writes
+        if (isOwnWrite(relPath))
+            return;
+        // Debounce: coalesce rapid events for the same file (300ms)
+        clearTimeout(watchDebounce.get(relPath));
+        watchDebounce.set(relPath, setTimeout(() => {
+            watchDebounce.delete(relPath);
+            const fullPath = join(absContentDir, relPath);
+            let event;
+            if (eventType === 'rename') {
+                event = existsSync(fullPath) ? 'file-created' : 'file-deleted';
+            }
+            else {
+                event = 'file-changed';
+            }
+            broadcastSSE(event, { path: relPath });
+            // Refresh layout resolver so layout changes propagate
+            layoutResolver.refresh().catch(() => { });
+        }, 300));
+    });
+}
+// ── Static file serving ──────────────────────────────────────────────────
+function serveStatic(res, appDistDir, pathname) {
+    // Try exact file first, then fall back to index.html (SPA routing)
+    let filePath = join(appDistDir, pathname === '/' ? 'index.html' : pathname);
+    if (!existsSync(filePath) || !filePath.startsWith(appDistDir)) {
+        // SPA fallback
+        filePath = join(appDistDir, 'index.html');
+    }
+    if (!existsSync(filePath)) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Editor frontend not built. Run: npm run build -w packages/editor');
+        return;
+    }
+    const ext = extname(filePath);
+    const contentType = MIME_TYPES[ext] ?? 'application/octet-stream';
+    const content = readFileSync(filePath);
+    res.writeHead(200, { 'Content-Type': contentType });
+    res.end(content);
+}
+// ── Route handlers ──────────────────────────────────────────────────────
+async function handleGetTree(res, contentDir) {
+    const tree = await ContentTree.fromDirectory(contentDir);
+    serveJson(res, directoryToJson(tree.root, contentDir));
+}
+function handleGetFile(res, contentDir, filePath) {
+    const fullPath = safePath(contentDir, filePath);
+    if (!fullPath) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    if (!existsSync(fullPath)) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'File not found' }));
+        return;
+    }
+    const raw = readFileSync(fullPath, 'utf-8');
+    const { frontmatter, content } = parseFrontmatter(raw);
+    serveJson(res, { path: filePath, frontmatter, content, raw });
+}
+async function handlePutFile(req, res, contentDir, filePath) {
+    const fullPath = safePath(contentDir, filePath);
+    if (!fullPath) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    const body = await readBody(req);
+    const { content } = JSON.parse(body);
+    writeFileSync(fullPath, content, 'utf-8');
+    serveJson(res, { ok: true, path: filePath });
+}
+function handlePreview(res, contentDir, filePath, themeConfig, themeCss, highlight) {
+    const fullPath = safePath(contentDir, filePath);
+    if (!fullPath) {
+        res.writeHead(403, { 'Content-Type': 'text/plain' });
+        res.end('Forbidden');
+        return;
+    }
+    if (!existsSync(fullPath)) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('File not found');
+        return;
+    }
+    const html = renderPreviewPage(contentDir, filePath, themeConfig, themeCss, highlight);
+    serveHtml(res, html);
+}
+async function handlePreviewContent(req, res, themeConfig, themeCss, highlight) {
+    const body = await readBody(req);
+    const { content } = JSON.parse(body);
+    const html = renderPreviewContent(content, themeConfig, themeCss, highlight);
+    serveHtml(res, html);
+}
+async function handlePreviewData(req, res, resolver, transform, highlight) {
+    const body = await readBody(req);
+    const { path, content } = JSON.parse(body);
+    const isLayout = path.endsWith('_layout.md');
+    const data = isLayout
+        ? resolver.buildLayoutPreviewData(path, content, transform, highlight)
+        : resolver.buildPreviewData(path, content, transform, highlight);
+    serveJson(res, data);
+}
+// ── File operation handlers ──────────────────────────────────────────────
+const SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+const PAGE_TEMPLATES = {
+    blank: (title) => ({ title }),
+    blog: (title) => ({ title, date: new Date().toISOString().slice(0, 10), tags: [] }),
+    docs: (title) => ({ title, order: 0 }),
+};
+async function handleCreatePage(req, res, contentDir, markOwnWrite) {
+    const body = await readBody(req);
+    const { directory = '', slug, title, template = 'blank', draft } = JSON.parse(body);
+    if (!slug || !SLUG_RE.test(slug)) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Invalid slug. Use lowercase alphanumeric and hyphens.' }));
+        return;
+    }
+    const dirPath = safePath(contentDir, directory);
+    if (!dirPath) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    const fileName = `${slug}.md`;
+    const fullPath = join(dirPath, fileName);
+    if (existsSync(fullPath)) {
+        res.writeHead(409, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'File already exists' }));
+        return;
+    }
+    const templateFn = PAGE_TEMPLATES[template] ?? PAGE_TEMPLATES.blank;
+    const fm = templateFn(title);
+    if (draft)
+        fm.draft = true;
+    const content = serializeFrontmatter(fm, '\n');
+    writeFileSync(fullPath, content, 'utf-8');
+    const relativePath = directory ? `${directory}/${fileName}` : fileName;
+    markOwnWrite(relativePath);
+    serveJson(res, { ok: true, path: relativePath });
+}
+async function handleCreateDirectory(req, res, contentDir, markOwnWrite) {
+    const body = await readBody(req);
+    const { parent = '', name, createLayout } = JSON.parse(body);
+    if (!name || !SLUG_RE.test(name)) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Invalid directory name. Use lowercase alphanumeric and hyphens.' }));
+        return;
+    }
+    const parentPath = safePath(contentDir, parent);
+    if (!parentPath) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    const dirPath = join(parentPath, name);
+    if (existsSync(dirPath)) {
+        res.writeHead(409, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Directory already exists' }));
+        return;
+    }
+    mkdirSync(dirPath, { recursive: true });
+    if (createLayout) {
+        const layoutContent = serializeFrontmatter({ title: name }, '\n');
+        const layoutRelPath = parent ? `${parent}/${name}/_layout.md` : `${name}/_layout.md`;
+        markOwnWrite(layoutRelPath);
+        writeFileSync(join(dirPath, '_layout.md'), layoutContent, 'utf-8');
+    }
+    const relativePath = parent ? `${parent}/${name}` : name;
+    serveJson(res, { ok: true, path: relativePath });
+}
+async function handleRename(req, res, contentDir, markOwnWrite) {
+    const body = await readBody(req);
+    const { oldPath, newName } = JSON.parse(body);
+    const fullOld = safePath(contentDir, oldPath);
+    if (!fullOld) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    if (!existsSync(fullOld)) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'File not found' }));
+        return;
+    }
+    const dir = dirname(fullOld);
+    const fullNew = join(dir, newName);
+    if (!fullNew.startsWith(contentDir)) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    if (existsSync(fullNew)) {
+        res.writeHead(409, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Target name already exists' }));
+        return;
+    }
+    renameSync(fullOld, fullNew);
+    const parentRelative = dirname(oldPath);
+    const newPath = parentRelative === '.' ? newName : `${parentRelative}/${newName}`;
+    markOwnWrite(oldPath);
+    markOwnWrite(newPath);
+    serveJson(res, { ok: true, oldPath, newPath });
+}
+async function handleDuplicate(req, res, contentDir, markOwnWrite) {
+    const body = await readBody(req);
+    const { path: filePath } = JSON.parse(body);
+    const fullPath = safePath(contentDir, filePath);
+    if (!fullPath) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    if (!existsSync(fullPath)) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'File not found' }));
+        return;
+    }
+    const dir = dirname(fullPath);
+    const name = basename(fullPath);
+    const ext = extname(name);
+    const base = name.slice(0, -ext.length);
+    let copyName = `${base}-copy${ext}`;
+    let counter = 2;
+    while (existsSync(join(dir, copyName))) {
+        copyName = `${base}-copy-${counter}${ext}`;
+        counter++;
+    }
+    copyFileSync(fullPath, join(dir, copyName));
+    const parentRelative = dirname(filePath);
+    const newPath = parentRelative === '.' ? copyName : `${parentRelative}/${copyName}`;
+    markOwnWrite(newPath);
+    serveJson(res, { ok: true, path: newPath });
+}
+function handleDelete(res, contentDir, filePath) {
+    const fullPath = safePath(contentDir, filePath);
+    if (!fullPath) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    if (!existsSync(fullPath)) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+        return;
+    }
+    const stat = statSync(fullPath);
+    rmSync(fullPath, { recursive: stat.isDirectory() });
+    serveJson(res, { ok: true });
+}
+async function handleToggleDraft(req, res, contentDir, markOwnWrite) {
+    const body = await readBody(req);
+    const { path: filePath } = JSON.parse(body);
+    const fullPath = safePath(contentDir, filePath);
+    if (!fullPath) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden' }));
+        return;
+    }
+    if (!existsSync(fullPath)) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'File not found' }));
+        return;
+    }
+    const raw = readFileSync(fullPath, 'utf-8');
+    const { frontmatter, content } = parseFrontmatter(raw);
+    if (frontmatter.draft) {
+        delete frontmatter.draft;
+    }
+    else {
+        frontmatter.draft = true;
+    }
+    const newRaw = serializeFrontmatter(frontmatter, content);
+    markOwnWrite(filePath);
+    writeFileSync(fullPath, newRaw, 'utf-8');
+    serveJson(res, { ok: true, draft: frontmatter.draft ?? false });
+}
+async function handlePagesList(res, contentDir) {
+    const tree = await ContentTree.fromDirectory(contentDir);
+    const pages = [];
+    function walk(dir) {
+        for (const page of dir.pages) {
+            const name = page.relativePath.split('/').pop();
+            const slug = name.replace(/\.md$/, '');
+            const { frontmatter } = parseFrontmatter(page.raw);
+            pages.push({
+                slug,
+                path: page.relativePath,
+                title: frontmatter.title || slug,
+            });
+        }
+        for (const child of dir.children) {
+            walk(child);
+        }
+    }
+    walk(tree.root);
+    serveJson(res, { pages });
+}
+// ── Rune metadata ────────────────────────────────────────────────────────
+const CHILD_RUNES = new Set([
+    'tab', 'step', 'tier', 'accordion-item', 'timeline-entry', 'changelog-release',
+    'cast-member', 'conversation-message', 'reveal-step', 'bento-cell',
+    'storyboard-panel', 'note', 'form-field', 'comparison-column', 'comparison-row',
+    'symbol-group', 'symbol-member', 'map-pin', 'definition', 'region',
+]);
+const RUNE_CATEGORIES = {
+    hero: 'Section', cta: 'Section', feature: 'Section', pricing: 'Section',
+    comparison: 'Section', testimonial: 'Section',
+    hint: 'Content', steps: 'Content', sidenote: 'Content', figure: 'Content',
+    details: 'Content', embed: 'Content', icon: 'Content', form: 'Content',
+    grid: 'Layout', tabs: 'Layout', accordion: 'Layout', bento: 'Layout',
+    reveal: 'Layout', annotate: 'Layout',
+    codegroup: 'Code & Data', compare: 'Code & Data', diff: 'Code & Data',
+    api: 'Code & Data', symbol: 'Code & Data', datatable: 'Code & Data',
+    chart: 'Code & Data', diagram: 'Code & Data', preview: 'Code & Data',
+    sandbox: 'Code & Data',
+    recipe: 'Semantic', howto: 'Semantic', event: 'Semantic', cast: 'Semantic',
+    organization: 'Semantic', timeline: 'Semantic', changelog: 'Semantic',
+    conversation: 'Semantic', storyboard: 'Semantic', map: 'Semantic',
+    'music-playlist': 'Semantic', 'music-recording': 'Semantic', error: 'Semantic',
+    swatch: 'Design', palette: 'Design', typography: 'Design',
+    spacing: 'Design', 'design-context': 'Design',
+    nav: 'Site', layout: 'Site', toc: 'Site', breadcrumb: 'Site',
+};
+let cachedRuneData = null;
+function handleGetRunes(res) {
+    if (!cachedRuneData) {
+        cachedRuneData = [];
+        for (const rune of Object.values(allRunes)) {
+            if (CHILD_RUNES.has(rune.name))
+                continue;
+            const attrs = {};
+            if (rune.schema.attributes) {
+                for (const [name, attr] of Object.entries(rune.schema.attributes)) {
+                    const typeName = typeof attr.type === 'function'
+                        ? attr.type.name
+                        : Array.isArray(attr.type)
+                            ? attr.type.map((t) => t.name ?? 'unknown').join(' | ')
+                            : 'String';
+                    attrs[name] = {
+                        type: typeName,
+                        required: attr.required ?? false,
+                        ...(Array.isArray(attr.matches) ? { values: attr.matches.map(String) } : {}),
+                    };
+                }
+            }
+            cachedRuneData.push({
+                name: rune.name,
+                aliases: rune.aliases,
+                description: rune.description,
+                selfClosing: rune.schema.selfClosing ?? false,
+                category: RUNE_CATEGORIES[rune.name] ?? 'Other',
+                attributes: attrs,
+                example: RUNE_EXAMPLES[rune.name],
+            });
+        }
+    }
+    serveJson(res, { runes: cachedRuneData });
+}
+// ── Helpers ─────────────────────────────────────────────────────────────
+/** Resolve a user-provided path within contentDir, returning null if it escapes */
+function safePath(contentDir, filePath) {
+    const full = normalize(join(contentDir, filePath));
+    if (!full.startsWith(contentDir))
+        return null;
+    return full;
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        req.on('data', chunk => { data += chunk; });
+        req.on('end', () => resolve(data));
+        req.on('error', reject);
+    });
+}
+function directoryToJson(dir, rootDir) {
+    const dirRelPath = relative(rootDir, dir.dirPath);
+    const node = {
+        name: dir.name,
+        type: 'directory',
+        path: dirRelPath || '',
+        children: [],
+    };
+    if (dir.layout) {
+        const { frontmatter } = parseFrontmatter(dir.layout.raw);
+        node.layout = {
+            name: '_layout.md',
+            type: 'layout',
+            path: dir.layout.relativePath,
+            draft: frontmatter.draft,
+        };
+    }
+    for (const page of dir.pages) {
+        const { frontmatter } = parseFrontmatter(page.raw);
+        node.children.push({
+            name: page.relativePath.split('/').pop(),
+            type: 'page',
+            path: page.relativePath,
+            draft: frontmatter.draft,
+        });
+    }
+    for (const child of dir.children) {
+        node.children.push(directoryToJson(child, rootDir));
+    }
+    return node;
+}
+function serveJson(res, data) {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data, null, 2));
+}
+function serveHtml(res, html) {
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(html);
+}
+/** Strip non-serializable function values (postTransform) from ThemeConfig for JSON transport */
+function stripFunctions(config) {
+    const runes = {};
+    for (const [name, rune] of Object.entries(config.runes)) {
+        const { postTransform, ...rest } = rune;
+        runes[name] = rest;
+    }
+    return { ...config, runes };
+}
+//# sourceMappingURL=server.js.map