docorbit 0.1.0 → 0.1.2

package/dist/packages/mcp/src/transports/http.d.ts

@@ -0,0 +1,31 @@
+import * as http from 'node:http';
+import type { McpServer } from '../server.ts';
+import type { McpTransport } from './types.ts';
+export interface HttpTransportOptions {
+    port?: number;
+    host?: string;
+    maxBodyBytes?: number;
+    noListen?: boolean;
+}
+export declare class StreamableHttpTransport implements McpTransport {
+    private port;
+    private host;
+    private maxBodyBytes;
+    private noListen;
+    private serverInstance;
+    private mcpServer;
+    private sseClients;
+    private heartbeatTimer;
+    constructor(options?: HttpTransportOptions);
+    getServerInstance(): http.Server | null;
+    dispatch(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+    getPort(): number;
+    start(server: McpServer): Promise<void>;
+    private setCorsHeaders;
+    private handleHttpRequest;
+    private handleSseConnection;
+    private handleMcpPost;
+    private readBody;
+    private startHeartbeats;
+    close(): Promise<void>;
+}

package/dist/packages/mcp/src/transports/http.js

@@ -0,0 +1,215 @@
+import * as http from 'node:http';
+import { JSONRPC_ERRORS } from "../types.js";
+export class StreamableHttpTransport {
+    port;
+    host;
+    maxBodyBytes;
+    noListen;
+    serverInstance = null;
+    mcpServer = null;
+    sseClients = new Set();
+    heartbeatTimer = null;
+    constructor(options = {}) {
+        this.port = options.port ?? 3000;
+        this.host = options.host ?? '127.0.0.1';
+        this.maxBodyBytes = options.maxBodyBytes ?? 10 * 1024 * 1024; // 10MB
+        this.noListen = options.noListen ?? false;
+    }
+    getServerInstance() {
+        return this.serverInstance;
+    }
+    async dispatch(req, res) {
+        return this.handleHttpRequest(req, res);
+    }
+    getPort() {
+        if (this.serverInstance) {
+            const addr = this.serverInstance.address();
+            if (addr && typeof addr === 'object') {
+                return addr.port;
+            }
+        }
+        return this.port;
+    }
+    async start(server) {
+        this.mcpServer = server;
+        this.serverInstance = http.createServer((req, res) => {
+            this.handleHttpRequest(req, res).catch(err => {
+                if (!res.headersSent) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                }
+            });
+        });
+        if (this.noListen) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.serverInstance.on('error', reject);
+            this.serverInstance.listen(this.port, this.host, () => {
+                this.startHeartbeats();
+                resolve();
+            });
+        });
+    }
+    setCorsHeaders(res) {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Accept');
+    }
+    async handleHttpRequest(req, res) {
+        this.setCorsHeaders(res);
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url || '/', `http://${this.host}:${this.port}`);
+        const pathname = url.pathname;
+        if (req.method === 'GET' && (pathname === '/health' || pathname === '/')) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                status: 'ok',
+                server: 'docorbit-mcp',
+                version: '0.5.0',
+                endpoints: {
+                    mcp: '/mcp',
+                    sse: '/sse',
+                    health: '/health',
+                },
+            }));
+            return;
+        }
+        if (req.method === 'GET' && pathname === '/sse') {
+            this.handleSseConnection(req, res);
+            return;
+        }
+        if (req.method === 'POST' && pathname === '/mcp') {
+            await this.handleMcpPost(req, res);
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: `Not found: ${req.method} ${pathname}` }));
+    }
+    handleSseConnection(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+        });
+        // Send endpoint notification so client knows where to POST messages
+        res.write('event: endpoint\ndata: /mcp\n\n');
+        this.sseClients.add(res);
+        req.on('close', () => {
+            this.sseClients.delete(res);
+        });
+    }
+    async handleMcpPost(req, res) {
+        const rawBody = await this.readBody(req);
+        let parsed;
+        try {
+            parsed = JSON.parse(rawBody);
+        }
+        catch {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                jsonrpc: '2.0',
+                id: null,
+                error: {
+                    code: JSONRPC_ERRORS.PARSE_ERROR,
+                    message: 'Parse error: invalid JSON payload.',
+                },
+            }));
+            return;
+        }
+        if (!this.mcpServer) {
+            res.writeHead(503, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Server not initialized' }));
+            return;
+        }
+        let responsePayload;
+        if (Array.isArray(parsed)) {
+            const responses = await Promise.all(parsed.map(item => this.mcpServer.handleMessage(item)));
+            responsePayload = responses.filter(r => r !== null);
+        }
+        else {
+            responsePayload = await this.mcpServer.handleMessage(parsed);
+        }
+        const acceptHeader = req.headers['accept'] || '';
+        const wantsSse = acceptHeader.includes('text/event-stream');
+        if (wantsSse) {
+            // Modern Streamable HTTP response over SSE chunk
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+            });
+            if (responsePayload !== null && responsePayload !== undefined) {
+                res.write(`event: message\ndata: ${JSON.stringify(responsePayload)}\n\n`);
+            }
+            res.end();
+            return;
+        }
+        // Standard JSON response
+        if (responsePayload === null || responsePayload === undefined) {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify(responsePayload));
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let totalLength = 0;
+            req.on('data', chunk => {
+                const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                totalLength += buf.length;
+                if (totalLength > this.maxBodyBytes) {
+                    req.destroy(new Error(`Payload exceeds maximum limit of ${this.maxBodyBytes} bytes`));
+                    return;
+                }
+                chunks.push(buf);
+            });
+            req.on('end', () => {
+                resolve(Buffer.concat(chunks).toString('utf-8'));
+            });
+            req.on('error', reject);
+        });
+    }
+    startHeartbeats() {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = setInterval(() => {
+            for (const client of this.sseClients) {
+                try {
+                    client.write(': ping\n\n');
+                }
+                catch {
+                    this.sseClients.delete(client);
+                }
+            }
+        }, 15000);
+    }
+    async close() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        for (const client of this.sseClients) {
+            try {
+                client.end();
+            }
+            catch {
+                // Continue
+            }
+        }
+        this.sseClients.clear();
+        if (this.serverInstance) {
+            await new Promise((resolve) => {
+                this.serverInstance.close(() => resolve());
+            });
+            this.serverInstance = null;
+        }
+    }
+}

package/dist/packages/mcp/src/transports/stdio.d.ts

@@ -0,0 +1,22 @@
+import type { Readable, Writable } from 'node:stream';
+import type { McpServer } from '../server.ts';
+import type { McpTransport } from './types.ts';
+export interface StdioTransportOptions {
+    input?: Readable;
+    output?: Writable;
+    errorOutput?: Writable;
+}
+export declare class StdioServerTransport implements McpTransport {
+    private input;
+    private output;
+    private errorOutput;
+    private rl;
+    private server;
+    private running;
+    constructor(options?: StdioTransportOptions);
+    start(server: McpServer): Promise<void>;
+    private processLine;
+    private send;
+    private log;
+    close(): Promise<void>;
+}

package/dist/packages/mcp/src/transports/stdio.js

@@ -0,0 +1,86 @@
+import * as readline from 'node:readline';
+import { JSONRPC_ERRORS } from "../types.js";
+export class StdioServerTransport {
+    input;
+    output;
+    errorOutput;
+    rl = null;
+    server = null;
+    running = false;
+    constructor(options = {}) {
+        this.input = options.input || process.stdin;
+        this.output = options.output || process.stdout;
+        this.errorOutput = options.errorOutput || process.stderr;
+    }
+    async start(server) {
+        this.server = server;
+        this.running = true;
+        this.rl = readline.createInterface({
+            input: this.input,
+            terminal: false,
+        });
+        this.log('[DocOrbit MCP] Stdio transport started.');
+        this.rl.on('line', async (line) => {
+            try {
+                await this.processLine(line);
+            }
+            catch (err) {
+                this.log(`[DocOrbit MCP] Stdio error processing line: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
+        this.rl.on('close', () => {
+            this.running = false;
+            this.log('[DocOrbit MCP] Stdio transport stream closed.');
+        });
+    }
+    async processLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            const parseError = {
+                jsonrpc: '2.0',
+                id: null,
+                error: {
+                    code: JSONRPC_ERRORS.PARSE_ERROR,
+                    message: 'Parse error: invalid JSON payload.',
+                },
+            };
+            this.send(parseError);
+            return;
+        }
+        if (!this.server)
+            return;
+        if (Array.isArray(parsed)) {
+            // JSON-RPC Batch
+            const responses = await Promise.all(parsed.map(item => this.server.handleMessage(item)));
+            const filtered = responses.filter(r => r !== null);
+            if (filtered.length > 0) {
+                this.send(filtered);
+            }
+            return;
+        }
+        const response = await this.server.handleMessage(parsed);
+        if (response !== null) {
+            this.send(response);
+        }
+    }
+    send(payload) {
+        if (!this.running)
+            return;
+        const serialized = JSON.stringify(payload) + '\n';
+        this.output.write(serialized);
+    }
+    log(message) {
+        // Isolated to stderr to never corrupt stdout JSON-RPC stream
+        this.errorOutput.write(`${message}\n`);
+    }
+    async close() {
+        this.running = false;
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+    }
+}

package/{packages/mcp/src/transports/types.ts → dist/packages/mcp/src/transports/types.d.ts}

@@ -1,6 +1,5 @@
 import type { McpServer } from '../server.ts';
-
 export interface McpTransport {
-  start(server: McpServer): Promise<void>;
-  close(): Promise<void>;
+    start(server: McpServer): Promise<void>;
+    close(): Promise<void>;
 }

package/dist/packages/mcp/src/transports/types.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/mcp/src/types.d.ts

@@ -0,0 +1,89 @@
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: string | number | null;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    result?: unknown;
+    error?: JsonRpcErrorObject;
+}
+export interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JsonRpcErrorObject {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export declare const JSONRPC_ERRORS: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+};
+export interface ToolInputSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        description: string;
+        items?: Record<string, unknown>;
+        enum?: string[];
+        default?: unknown;
+    }>;
+    required?: string[];
+}
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema;
+}
+export interface ToolContentItem {
+    type: 'text';
+    text: string;
+}
+export interface CallToolResult {
+    content: ToolContentItem[];
+    isError?: boolean;
+}
+export interface McpResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface ResourceContent {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+export interface ReadResourceResult {
+    contents: ResourceContent[];
+}
+export interface ServerCapabilities {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        subscribe?: boolean;
+        listChanged?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+    logging?: Record<string, unknown>;
+}
+export interface InitializeResult {
+    protocolVersion: string;
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+    capabilities: ServerCapabilities;
+}

package/dist/packages/mcp/src/types.js

@@ -0,0 +1,7 @@
+export const JSONRPC_ERRORS = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+};

package/dist/packages/normalizer/src/example-indexer.d.ts

@@ -0,0 +1,5 @@
+import type { NormalizedPage, DocumentChunk, IndexedExample, SourceAuthority } from '../../shared/src/index.ts';
+/**
+ * Extracts and indexes first-class code examples from normalized pages and chunks.
+ */
+export declare function extractIndexedExamples(page: NormalizedPage, chunks: DocumentChunk[], authority: SourceAuthority, docVersion?: string, snapshotId?: string): IndexedExample[];

package/dist/packages/normalizer/src/example-indexer.js

@@ -0,0 +1,200 @@
+import { createHash } from 'node:crypto';
+const FRAMEWORK_PATTERNS = [
+    { framework: 'next', pattern: /(?:from\s+['"]next(?:\/.*)?['"]|require\(['"]next(?:\/.*)?['"]\)|'use client'|'use server')/i },
+    { framework: 'react', pattern: /(?:from\s+['"]react['"]|require\(['"]react['"]\)|useState|useEffect|useMemo|useCallback)/ },
+    { framework: 'express', pattern: /(?:from\s+['"]express['"]|require\(['"]express['"]\)|express\(\))/i },
+    { framework: 'fastify', pattern: /(?:from\s+['"]fastify['"]|require\(['"]fastify['"]\))/i },
+    { framework: 'hono', pattern: /(?:from\s+['"]hono['"]|require\(['"]hono['"]\))/i },
+    { framework: 'vue', pattern: /(?:from\s+['"]vue['"]|createApp\(|defineComponent)/i },
+    { framework: 'svelte', pattern: /(?:from\s+['"]svelte['"]|<script.*lang=["']ts["']>)/i },
+    { framework: 'fastapi', pattern: /(?:from\s+fastapi\s+import|FastAPI\()/i },
+    { framework: 'flask', pattern: /(?:from\s+flask\s+import|Flask\(__name__\))/i },
+    { framework: 'django', pattern: /(?:from\s+django|django\.)/i },
+    { framework: 'spring', pattern: /(?:@SpringBootApplication|@RestController|@GetMapping|@PostMapping)/i },
+    { framework: 'gin', pattern: /(?:github\.com\/gin-gonic\/gin|gin\.Default\(\))/i },
+];
+const API_METHOD_PATH_REGEX = /\b(GET|POST|PUT|DELETE|PATCH)\s+([/\w\-_{}]+)/i;
+/**
+ * Detects framework from code snippet content.
+ */
+function detectFramework(code) {
+    for (const { framework, pattern } of FRAMEWORK_PATTERNS) {
+        if (pattern.test(code)) {
+            return framework;
+        }
+    }
+    return undefined;
+}
+/**
+ * Detects an API endpoint reference from code or task context.
+ */
+function detectRelatedApi(code, context) {
+    // Check context first (e.g. "POST /v1/webhook_endpoints")
+    const contextMatch = context.match(API_METHOD_PATH_REGEX);
+    if (contextMatch) {
+        return `${contextMatch[1].toUpperCase()} ${contextMatch[2]}`;
+    }
+    // Check code
+    const codeMatch = code.match(API_METHOD_PATH_REGEX);
+    if (codeMatch) {
+        return `${codeMatch[1].toUpperCase()} ${codeMatch[2]}`;
+    }
+    // Common client library calls (e.g. fetch('/api/v1/foo', { method: 'POST' }))
+    const fetchMatch = code.match(/fetch\(\s*['"`]([/\w\-_{}]+)['"`](?:,\s*\{[^}]*method:\s*['"](\w+)['"])?/i);
+    if (fetchMatch) {
+        const method = (fetchMatch[2] || 'GET').toUpperCase();
+        return `${method} ${fetchMatch[1]}`;
+    }
+    // Framework router calls: app.post('/api/webhook', ...) or router.get('/users', ...) or @app.post('/webhook')
+    const routeMatch = code.match(/(?:app|router)\.(get|post|put|delete|patch)\(\s*['"`]([/\w\-_{}]+)['"`]/i);
+    if (routeMatch) {
+        return `${routeMatch[1].toUpperCase()} ${routeMatch[2]}`;
+    }
+    // Python decorators: @app.post("/webhook")
+    const pyRouteMatch = code.match(/@(?:app|router)\.(get|post|put|delete|patch)\(\s*['"`]([/\w\-_{}]+)['"`]/i);
+    if (pyRouteMatch) {
+        return `${pyRouteMatch[1].toUpperCase()} ${pyRouteMatch[2]}`;
+    }
+    return undefined;
+}
+/**
+ * Detects a primary symbol or function call from code.
+ */
+function detectRelatedSymbol(code) {
+    // Check function declarations
+    const funcMatch = code.match(/(?:function\s+([a-zA-Z0-9_$]+)|const\s+([a-zA-Z0-9_$]+)\s*=\s*(?:async\s*)?\()/);
+    if (funcMatch) {
+        return funcMatch[1] || funcMatch[2];
+    }
+    // Check class declarations
+    const classMatch = code.match(/class\s+([a-zA-Z0-9_$]+)/);
+    if (classMatch) {
+        return classMatch[1];
+    }
+    // Check prominent method invocations, ignoring routing boilerplate like app.post or res.json
+    const boilerplateCalls = new Set([
+        'app.get', 'app.post', 'app.put', 'app.delete', 'app.use',
+        'router.get', 'router.post', 'router.use',
+        'express.raw', 'express.json', 'express.urlencoded',
+        'res.json', 'res.send', 'res.status', 'console.log', 'console.error',
+    ]);
+    const allCalls = Array.from(code.matchAll(/([a-zA-Z0-9_$]+(?:\.[a-zA-Z0-9_$]+)+)\s*\(/g));
+    for (const match of allCalls) {
+        if (!boilerplateCalls.has(match[1])) {
+            return match[1];
+        }
+    }
+    if (allCalls.length > 0) {
+        return allCalls[0][1];
+    }
+    return undefined;
+}
+/**
+ * Extracts and indexes first-class code examples from normalized pages and chunks.
+ */
+export function extractIndexedExamples(page, chunks, authority, docVersion, snapshotId) {
+    const examples = [];
+    const seenCodeHashes = new Set();
+    const nowIso = new Date().toISOString();
+    // Map each code example in the page to its enclosing chunk
+    for (const codeExample of page.codeExamples) {
+        const rawCode = codeExample.code.trim();
+        if (!rawCode || rawCode.length < 15)
+            continue; // Skip trivial snippets
+        const codeHash = createHash('sha256').update(rawCode).digest('hex');
+        if (seenCodeHashes.has(codeHash))
+            continue;
+        seenCodeHashes.add(codeHash);
+        // Find the chunk that contains this code snippet
+        const matchingChunk = chunks.find(c => c.chunkType === 'code' && c.content.includes(rawCode)) || chunks.find(c => c.content.includes(rawCode));
+        // Determine task context from breadcrumbs or headings
+        let task = '';
+        if (matchingChunk && matchingChunk.sectionPath.length > 0) {
+            task = matchingChunk.sectionPath.join(' > ');
+        }
+        else if (matchingChunk && matchingChunk.title) {
+            task = matchingChunk.title;
+        }
+        else {
+            task = page.title;
+        }
+        const language = (codeExample.language || (matchingChunk?.language) || 'typescript').toLowerCase();
+        const framework = detectFramework(rawCode);
+        const relatedApi = detectRelatedApi(rawCode, task);
+        const relatedSymbol = detectRelatedSymbol(rawCode);
+        const exampleId = createHash('sha256')
+            .update(`${page.id}:${codeHash}`)
+            .digest('hex')
+            .substring(0, 16);
+        const provenance = {
+            sourceUrl: page.url,
+            retrievedAt: page.metadata?.extractedAt || nowIso,
+            sourceAuthority: authority,
+        };
+        const effectiveSnapshotId = snapshotId || matchingChunk?.snapshotId || page.snapshotId || 'snap_default';
+        examples.push({
+            id: exampleId,
+            chunkId: matchingChunk?.id,
+            pageId: page.id,
+            snapshotId: effectiveSnapshotId,
+            language,
+            framework,
+            task,
+            code: rawCode,
+            sourceUrl: page.url,
+            sourceAuthority: authority,
+            relatedApi,
+            relatedSymbol,
+            docVersion: docVersion || page.docVersion,
+            provenance,
+            createdAt: nowIso,
+        });
+    }
+    // Also check chunks of type 'code' that might not have been caught in page.codeExamples
+    for (const chunk of chunks) {
+        if (chunk.chunkType !== 'code')
+            continue;
+        const rawCode = chunk.content.trim();
+        if (!rawCode || rawCode.length < 15)
+            continue;
+        const codeHash = createHash('sha256').update(rawCode).digest('hex');
+        if (seenCodeHashes.has(codeHash))
+            continue;
+        seenCodeHashes.add(codeHash);
+        const task = chunk.sectionPath.length > 0
+            ? chunk.sectionPath.join(' > ')
+            : (chunk.title || page.title);
+        const language = (chunk.language || 'typescript').toLowerCase();
+        const framework = detectFramework(rawCode);
+        const relatedApi = detectRelatedApi(rawCode, task);
+        const relatedSymbol = detectRelatedSymbol(rawCode);
+        const exampleId = createHash('sha256')
+            .update(`${page.id}:${codeHash}`)
+            .digest('hex')
+            .substring(0, 16);
+        const provenance = {
+            sourceUrl: page.url,
+            retrievedAt: page.metadata?.extractedAt || nowIso,
+            sourceAuthority: authority,
+        };
+        const effectiveSnapshotId = snapshotId || chunk.snapshotId || page.snapshotId || 'snap_default';
+        examples.push({
+            id: exampleId,
+            chunkId: chunk.id,
+            pageId: page.id,
+            snapshotId: effectiveSnapshotId,
+            language,
+            framework,
+            task,
+            code: rawCode,
+            sourceUrl: page.url,
+            sourceAuthority: authority,
+            relatedApi,
+            relatedSymbol,
+            docVersion: docVersion || chunk.docVersion || page.docVersion,
+            provenance,
+            createdAt: nowIso,
+        });
+    }
+    return examples;
+}

package/dist/packages/normalizer/src/html.d.ts

@@ -0,0 +1,13 @@
+import type { Heading, Link, CodeExample } from '../../shared/src/index.ts';
+export interface ExtractedHtmlDoc {
+    title: string;
+    markdown: string;
+    headings: Heading[];
+    links: Link[];
+    codeExamples: CodeExample[];
+}
+/**
+ * Deterministically normalizes HTML documentation into clean Markdown,
+ * preserving code fences, language tags, headings, tables, callouts, and links.
+ */
+export declare function normalizeHtmlToMarkdown(html: string, baseUrl: string): ExtractedHtmlDoc;