@oml/server 0.14.0

package/src/rest/server.ts

@@ -0,0 +1,2517 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import * as http from 'node:http';
+import * as fsSync from 'node:fs';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { randomUUID, createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { PassThrough } from 'node:stream';
+import { URL, pathToFileURL } from 'node:url';
+import { URI } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+import { createConnection, type Connection } from 'vscode-languageserver/node.js';
+import { DataFactory, Writer } from 'n3';
+import uFuzzy from '@leeoniya/ufuzzy';
+import {
+    MarkdownHandlerRegistry,
+    MarkdownPreviewRuntime,
+    buildTemplateCatalog as buildNavigationTemplateCatalog,
+    extractLeadingFrontMatter,
+    resolveTemplateForNavigation,
+    renderTemplate,
+    type TemplateInvocation,
+    MarkdownExecutor,
+    type MdBlockKind,
+    type MdExecutableBlock,
+    type MdBlockExecutionResult,
+} from '@oml/markdown';
+import { STATIC_MARKDOWN_RUNTIME_BUNDLE_FILE, STATIC_MARKDOWN_RUNTIME_CSS } from '@oml/markdown/static';
+import {
+    applyOmlUpdate,
+    collectOntologyMembers,
+    getIriForNode,
+    getOntologyModelIndex,
+    iriFragment,
+    isDescription,
+    isOntology,
+    isVocabulary,
+    tokenizeForFuzzy,
+    type OmlEditRequest,
+    type OmlEditResponse,
+    type OmlFuzzyIndexedEntry,
+} from '@oml/language';
+import { detectSparqlKind } from '@oml/owl';
+import { exportAssertedWorkspace, exportWorkspace, type RestExportContext } from './export.js';
+import { startOmlLanguageServer, type OmlLanguageServerRuntime } from '../lsp/language-server.js';
+import { createOpenApiSpec, dispatchRestRoute } from './routes.js';
+import {
+    buildTemplateCatalog,
+    expandTemplateComposeBlocks,
+    findFilesByExtension,
+    frontMatterString,
+    isTemplateMarkdownFile,
+    normalizeContextOntologyIri,
+} from './template.js';
+import { lintWorkspace, reasonWorkspace, type RestLintResult, type RestValidationContext, validateWorkspace } from './validation.js';
+
+const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';
+const HTML_CONTENT_TYPE = 'text/html; charset=utf-8';
+const DEFAULT_BODY_LIMIT_BYTES = 2 * 1024 * 1024;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+
+const SUPPORTED_MD_BLOCK_KINDS = new Set<MdBlockKind>([
+    'table',
+    'tree',
+    'graph',
+    'chart',
+    'diagram',
+    'list',
+    'text',
+    'matrix',
+    'table-editor'
+]);
+
+export interface OmlRestServerOptions {
+    host: string;
+    port: number;
+    workspaceRoot?: string;
+    watchWorkspace?: boolean;
+    requestTimeoutMs?: number;
+    authToken?: string;
+    runtime?: OmlLanguageServerRuntime;
+}
+
+interface WorkspaceModelFileEntry {
+    path: string;
+    uri: string;
+}
+
+const BUILT_IN_ONTOLOGIES = new Set([
+    'http://www.w3.org/2001/XMLSchema',
+    'http://www.w3.org/1999/02/22-rdf-syntax-ns',
+    'http://www.w3.org/2000/01/rdf-schema',
+    'http://www.w3.org/2002/07/owl',
+    'http://www.w3.org/2003/11/swrl',
+    'http://www.w3.org/2003/11/swrlb',
+]);
+
+
+function jsonResponse(res: http.ServerResponse, status: number, payload: unknown): void {
+    const body = JSON.stringify(payload);
+    res.statusCode = status;
+    res.setHeader('content-type', JSON_CONTENT_TYPE);
+    res.setHeader('content-length', Buffer.byteLength(body, 'utf-8'));
+    res.end(body);
+}
+
+function htmlResponse(res: http.ServerResponse, status: number, body: string): void {
+        res.statusCode = status;
+        res.setHeader('content-type', HTML_CONTENT_TYPE);
+        res.setHeader('content-length', Buffer.byteLength(body, 'utf-8'));
+        res.end(body);
+}
+
+function escapeHtml(value: string): string {
+        return value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+async function listWorkspaceModelFiles(workspaceRoot: string): Promise<WorkspaceModelFileEntry[]> {
+    const entries: WorkspaceModelFileEntry[] = [];
+    const ignoredNames = new Set(['.git', 'node_modules', 'dist', 'build', 'out']);
+
+    const visit = async (currentDir: string): Promise<void> => {
+        const children = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const child of children) {
+            const childPath = path.join(currentDir, child.name);
+            if (child.isDirectory()) {
+                if (ignoredNames.has(child.name) || child.name.startsWith('.')) {
+                    continue;
+                }
+                await visit(childPath);
+                continue;
+            }
+            if (!child.isFile() || !child.name.toLowerCase().endsWith('.oml')) {
+                continue;
+            }
+            const relativePath = path.relative(workspaceRoot, childPath).split(path.sep).join('/');
+            entries.push({
+                path: relativePath,
+                uri: pathToFileURL(childPath).toString(),
+            });
+        }
+    };
+
+    await visit(workspaceRoot);
+    entries.sort((left, right) => left.path.localeCompare(right.path));
+    return entries;
+}
+
+function createSparqlWorkbenchPage(defaultWorkspaceRoot: string): string {
+    const escapedWorkspaceRoot = escapeHtml(defaultWorkspaceRoot);
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>OML SPARQL Workbench</title>
+    <style>
+        :root {
+            --bg: #f3f5f9;
+            --bg-soft: #eef1f7;
+            --card: rgba(255, 255, 255, 0.94);
+            --card-strong: #ffffff;
+            --ink: #101828;
+            --muted: #475467;
+            --line: #d0d5dd;
+            --line-soft: #e4e7ec;
+            --primary: #155eef;
+            --primary-strong: #004eea;
+            --primary-soft: rgba(21, 94, 239, 0.14);
+            --success: #067647;
+            --danger: #b42318;
+            --shadow-xl: 0 20px 48px rgba(16, 24, 40, 0.12);
+            --shadow-md: 0 8px 20px rgba(16, 24, 40, 0.08);
+            --radius-lg: 18px;
+            --radius-md: 12px;
+            --mono: "SFMono-Regular", "Menlo", "Monaco", "Consolas", monospace;
+            --sans: "Inter", "Segoe UI", "SF Pro Text", sans-serif;
+        }
+
+        * { box-sizing: border-box; }
+
+        body {
+            margin: 0;
+            min-height: 100vh;
+            background:
+                radial-gradient(1200px 600px at 100% -10%, rgba(21, 94, 239, 0.12), transparent 60%),
+                radial-gradient(900px 460px at -5% -20%, rgba(2, 132, 199, 0.08), transparent 58%),
+                linear-gradient(180deg, #f8fafc 0%, var(--bg) 100%);
+            color: var(--ink);
+            font-family: var(--sans);
+        }
+
+        .shell {
+            width: min(1520px, calc(100vw - 36px));
+            margin: 20px auto 28px;
+            display: grid;
+            gap: 16px;
+        }
+
+        .hero {
+            background: linear-gradient(180deg, rgba(255, 255, 255, 0.78), rgba(255, 255, 255, 0.62));
+            border: 1px solid rgba(255, 255, 255, 0.65);
+            border-radius: var(--radius-lg);
+            box-shadow: var(--shadow-xl);
+            backdrop-filter: blur(6px);
+            padding: 20px 24px;
+        }
+
+        .page-title {
+            margin: 0;
+            font-size: clamp(1.9rem, 3.4vw, 2.7rem);
+            font-weight: 800;
+            letter-spacing: -0.035em;
+            color: #0f172a;
+        }
+
+        .page-subtitle {
+            margin: 8px 0 0;
+            color: var(--muted);
+            font-size: 0.98rem;
+        }
+
+        .row {
+            background: var(--card);
+            border: 1px solid var(--line-soft);
+            border-radius: var(--radius-lg);
+            box-shadow: var(--shadow-md);
+            overflow: hidden;
+            backdrop-filter: blur(4px);
+        }
+
+        .row-body {
+            padding: 16px 18px;
+        }
+
+        .top-row {
+            display: grid;
+            grid-template-columns: minmax(280px, 0.95fr) minmax(440px, 1.45fr);
+            gap: 16px;
+            align-items: end;
+        }
+
+        .workspace-label,
+        .field-label,
+        .section-title {
+            color: #344054;
+            font-size: 0.78rem;
+            font-weight: 700;
+            letter-spacing: 0.08em;
+            text-transform: uppercase;
+        }
+
+        .workspace-value {
+            margin-top: 6px;
+            padding: 11px 12px;
+            border-radius: var(--radius-md);
+            border: 1px solid var(--line);
+            background: var(--card-strong);
+            font-family: var(--mono);
+            font-size: 0.9rem;
+            color: #1d2939;
+            word-break: break-all;
+        }
+
+        .file-row {
+            display: grid;
+            grid-template-columns: minmax(0, 1fr) auto;
+            gap: 10px;
+            align-items: end;
+        }
+
+        .field {
+            display: grid;
+            gap: 6px;
+            min-width: 0;
+        }
+
+        .query-row {
+            display: grid;
+            gap: 12px;
+        }
+
+        .query-editor {
+            position: relative;
+        }
+
+        .query-header,
+        .results-header,
+        .json-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            gap: 14px;
+            flex-wrap: wrap;
+        }
+
+        .status {
+            min-height: 1.3em;
+            color: var(--muted);
+            font-size: 0.92rem;
+        }
+
+        .status.error {
+            color: var(--danger);
+            font-weight: 600;
+        }
+
+        .status.success {
+            color: var(--success);
+            font-weight: 600;
+        }
+
+        input,
+        textarea,
+        button,
+        pre,
+        table {
+            font: inherit;
+        }
+
+        input,
+        textarea {
+            width: 100%;
+            border: 1px solid var(--line);
+            border-radius: var(--radius-md);
+            padding: 12px 13px;
+            background: #ffffff;
+            color: #101828;
+            font-family: var(--mono);
+            font-size: 0.9rem;
+            transition: border-color 140ms ease, box-shadow 140ms ease;
+        }
+
+        input:focus,
+        textarea:focus {
+            outline: none;
+            border-color: var(--primary);
+            box-shadow: 0 0 0 4px var(--primary-soft);
+        }
+
+        textarea {
+            min-height: 250px;
+            resize: vertical;
+            line-height: 1.55;
+            padding-right: 70px;
+            padding-top: 16px;
+        }
+
+        button {
+            border: 0;
+            border-radius: var(--radius-md);
+            padding: 11px 16px;
+            cursor: pointer;
+            font-weight: 700;
+            transition: transform 130ms ease, box-shadow 130ms ease, opacity 130ms ease;
+        }
+
+        button:hover {
+            transform: translateY(-1px);
+        }
+
+        button:disabled {
+            cursor: wait;
+            opacity: 0.62;
+            transform: none;
+            box-shadow: none;
+        }
+
+        .primary {
+            background: linear-gradient(180deg, var(--primary), var(--primary-strong));
+            color: #f8faff;
+            box-shadow: 0 10px 24px rgba(21, 94, 239, 0.3);
+        }
+
+        .play-button {
+            position: absolute;
+            top: 12px;
+            right: 12px;
+            width: 44px;
+            height: 44px;
+            padding: 0;
+            display: grid;
+            place-items: center;
+            border-radius: 999px;
+            z-index: 1;
+        }
+
+        .ghost {
+            background: #ffffff;
+            color: #344054;
+            border: 1px solid var(--line);
+        }
+
+        .ghost:hover {
+            background: #f8fafc;
+        }
+
+        .table-frame {
+            border-top: 1px solid var(--line-soft);
+            background: #ffffff;
+        }
+
+        .table-viewport {
+            height: 390px;
+            overflow: auto;
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            min-width: 100%;
+            font-family: var(--mono);
+            font-size: 0.86rem;
+        }
+
+        thead th {
+            position: sticky;
+            top: 0;
+            z-index: 1;
+            padding: 10px 12px;
+            border-bottom: 1px solid var(--line-soft);
+            background: #f9fafb;
+            color: #344054;
+            text-align: left;
+            white-space: nowrap;
+        }
+
+        tbody td {
+            padding: 10px 12px;
+            border-top: 1px solid #f2f4f7;
+            color: #101828;
+            vertical-align: top;
+            word-break: break-word;
+        }
+
+        tbody tr:nth-child(even) {
+            background: #fcfcfd;
+        }
+
+        .empty {
+            min-height: 100%;
+            display: grid;
+            place-items: center;
+            padding: 24px;
+            color: var(--muted);
+            font-style: italic;
+        }
+
+        .pager {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            gap: 10px;
+            padding: 12px 16px;
+            border-top: 1px solid var(--line-soft);
+            background: #fcfcfd;
+        }
+
+        .pager-meta {
+            color: #475467;
+            font-size: 0.88rem;
+        }
+
+        .pager-actions {
+            display: flex;
+            gap: 8px;
+        }
+
+        .raw {
+            margin: 0;
+            min-height: 230px;
+            max-height: 340px;
+            overflow: auto;
+            padding: 16px;
+            border-top: 1px solid var(--line-soft);
+            background: #0f172a;
+            color: #e2e8f0;
+            font-family: var(--mono);
+            font-size: 0.86rem;
+            line-height: 1.55;
+        }
+
+        #browseDialog {
+            width: min(900px, calc(100vw - 40px));
+            border: 0;
+            border-radius: 20px;
+            padding: 0;
+            overflow: hidden;
+            box-shadow: 0 34px 90px rgba(16, 24, 40, 0.32);
+            background: #ffffff;
+            color: var(--ink);
+        }
+
+        #browseDialog::backdrop {
+            background: rgba(2, 6, 23, 0.56);
+            backdrop-filter: blur(2px);
+        }
+
+        .dialog-header {
+            padding: 18px 22px 14px;
+            border-bottom: 1px solid var(--line-soft);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            gap: 16px;
+            background: linear-gradient(180deg, #f8fafc, #f2f4f7);
+        }
+
+        .dialog-title {
+            font-size: 1.02rem;
+            font-weight: 800;
+            color: #0f172a;
+        }
+
+        .dialog-subtitle {
+            margin-top: 4px;
+            font-size: 0.9rem;
+            color: var(--muted);
+        }
+
+        .dialog-body {
+            padding: 16px 22px 22px;
+            display: grid;
+            gap: 10px;
+            background: #ffffff;
+        }
+
+        .browse-list {
+            display: grid;
+            gap: 8px;
+            max-height: 440px;
+            overflow: auto;
+            padding-right: 2px;
+        }
+
+        .browse-entry {
+            text-align: left;
+            border: 1px solid var(--line-soft);
+            background: #ffffff;
+            border-radius: 12px;
+            padding: 11px 12px;
+            transition: border-color 120ms ease, box-shadow 120ms ease, background-color 120ms ease;
+        }
+
+        .browse-entry:hover {
+            border-color: #b2ccff;
+            background: #f8fbff;
+            box-shadow: 0 6px 16px rgba(21, 94, 239, 0.12);
+        }
+
+        .browse-entry.selected {
+            border-color: var(--primary);
+            background: #eef4ff;
+            box-shadow: 0 0 0 3px var(--primary-soft);
+        }
+
+        .browse-entry-path,
+        .browse-entry-uri {
+            font-family: var(--mono);
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+        }
+
+        .browse-entry-path {
+            color: #101828;
+            font-size: 0.9rem;
+        }
+
+        .browse-entry-uri {
+            color: #667085;
+            font-size: 0.78rem;
+            margin-top: 4px;
+        }
+
+        @media (max-width: 920px) {
+            .shell {
+                width: min(100vw - 16px, 1520px);
+                margin: 10px auto 16px;
+            }
+
+            .hero {
+                padding: 16px;
+            }
+
+            .file-row {
+                grid-template-columns: 1fr;
+            }
+
+            .top-row {
+                grid-template-columns: 1fr;
+            }
+
+            .query-header,
+            .results-header,
+            .json-header,
+            .pager {
+                align-items: start;
+                flex-direction: column;
+            }
+
+            .table-viewport {
+                height: 320px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="shell">
+        <section class="hero">
+            <h1 class="page-title">OML Language Server</h1>
+            <p class="page-subtitle">Run SPARQL queries against workspace models with fast browsing, paged table results, and raw JSON diagnostics.</p>
+        </section>
+
+        <section class="row">
+            <div class="row-body top-row">
+                <div class="workspace-row field">
+                    <div class="workspace-label">Workspace</div>
+                    <div class="workspace-value">${escapedWorkspaceRoot}</div>
+                </div>
+                <div class="file-row">
+                    <label class="field">
+                        <span class="field-label">OML File</span>
+                        <input id="modelUri" type="text" spellcheck="false" placeholder="Select an OML file from Browse" readonly>
+                    </label>
+                    <button id="browseModelsButton" class="ghost" type="button">Browse</button>
+                </div>
+            </div>
+        </section>
+
+        <section class="row">
+            <div class="row-body query-row">
+                <div class="query-header">
+                    <div class="section-title">Query</div>
+                    <div id="status" class="status">Ready.</div>
+                </div>
+                <div class="query-editor">
+                    <button id="runQueryButton" class="primary play-button" type="button" aria-label="Run Query" title="Run Query">▶</button>
+                    <textarea id="sparql" spellcheck="false">SELECT * WHERE {
+    ?s ?p ?o
+}
+LIMIT 25</textarea>
+                </div>
+            </div>
+        </section>
+
+        <section class="row">
+            <div class="row-body results-header">
+                <div class="section-title">Results Table</div>
+                <div id="tableStatus" class="status">Run a SELECT query to populate the table.</div>
+            </div>
+            <div class="table-frame">
+                <div class="table-viewport" id="tableViewport"><div class="empty" id="tableShell">Run a SELECT query to populate the table.</div></div>
+                <div class="pager">
+                    <div id="pagerMeta" class="pager-meta">No rows.</div>
+                    <div class="pager-actions">
+                        <button id="prevPageButton" class="ghost" type="button" disabled>Previous</button>
+                        <button id="nextPageButton" class="ghost" type="button" disabled>Next</button>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+        <section class="row">
+            <div class="row-body json-header">
+                <div class="section-title">JSON Result</div>
+            </div>
+            <pre id="rawOutput" class="raw">{
+    "ok": true,
+    "result": {
+        "success": true,
+        "kind": "select",
+        "warnings": []
+    }
+}</pre>
+        </section>
+    </div>
+
+    <dialog id="browseDialog">
+        <form method="dialog">
+            <div class="dialog-header">
+                <div>
+                    <div class="dialog-title">Workspace OML Files</div>
+                    <div class="dialog-subtitle">Select the model file to run the query against.</div>
+                </div>
+                <button id="closeBrowseDialog" type="submit" class="ghost">Close</button>
+            </div>
+            <div class="dialog-body">
+                <input id="browseFilter" type="text" placeholder="Filter files by path" spellcheck="false">
+                <div id="browseStatus" class="status">Loading...</div>
+                <div id="browseList" class="browse-list"></div>
+            </div>
+        </form>
+    </dialog>
+
+    <script>
+        const modelUriInput = document.getElementById('modelUri');
+        const sparqlInput = document.getElementById('sparql');
+        const runButton = document.getElementById('runQueryButton');
+        const browseModelsButton = document.getElementById('browseModelsButton');
+        const statusNode = document.getElementById('status');
+        const tableStatus = document.getElementById('tableStatus');
+        const tableViewport = document.getElementById('tableViewport');
+        const tableShell = document.getElementById('tableShell');
+        const rawOutput = document.getElementById('rawOutput');
+        const pagerMeta = document.getElementById('pagerMeta');
+        const prevPageButton = document.getElementById('prevPageButton');
+        const nextPageButton = document.getElementById('nextPageButton');
+        const browseDialog = document.getElementById('browseDialog');
+        const browseStatus = document.getElementById('browseStatus');
+        const browseList = document.getElementById('browseList');
+        const browseFilter = document.getElementById('browseFilter');
+
+        let browseEntries = [];
+        let selectedModelUri = '';
+        let currentTableColumns = [];
+        let currentTableRows = [];
+        let currentPageIndex = 0;
+        const pageSize = 12;
+
+        function escapeClientHtml(value) {
+            return String(value)
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&#39;');
+        }
+
+        function setStatus(message, kind) {
+            statusNode.textContent = message;
+            statusNode.className = kind ? 'status ' + kind : 'status';
+        }
+
+        function setTableStatus(message) {
+            tableStatus.textContent = message;
+        }
+
+        function showTableMessage(message) {
+            tableShell.innerHTML = '<div class="empty">' + escapeClientHtml(message) + '</div>';
+            tableViewport.scrollTop = 0;
+        }
+
+        function formatTerm(term) {
+            if (!term || typeof term !== 'object') {
+                return '';
+            }
+            if (term.termType === 'Literal') {
+                const suffix = term.language ? '@' + term.language : (term.datatype ? '^^' + term.datatype : '');
+                return '"' + term.value + '"' + suffix;
+            }
+            return String(term.value ?? '');
+        }
+
+        function resetTable(message) {
+            currentTableColumns = [];
+            currentTableRows = [];
+            currentPageIndex = 0;
+            showTableMessage(message);
+            pagerMeta.textContent = 'No rows.';
+            prevPageButton.disabled = true;
+            nextPageButton.disabled = true;
+            setTableStatus(message);
+        }
+
+        function renderTablePage() {
+            if (currentTableRows.length === 0 || currentTableColumns.length === 0) {
+                resetTable('The SELECT query returned no rows.');
+                return;
+            }
+
+            const totalPages = Math.max(1, Math.ceil(currentTableRows.length / pageSize));
+            if (currentPageIndex >= totalPages) {
+                currentPageIndex = totalPages - 1;
+            }
+            const startIndex = currentPageIndex * pageSize;
+            const pageRows = currentTableRows.slice(startIndex, startIndex + pageSize);
+            const head = '<thead><tr>' + currentTableColumns.map((column) => '<th>' + escapeClientHtml(column) + '</th>').join('') + '</tr></thead>';
+            const body = '<tbody>' + pageRows.map((row) => {
+                return '<tr>' + currentTableColumns.map((column) => '<td>' + escapeClientHtml(formatTerm(row[column])) + '</td>').join('') + '</tr>';
+            }).join('') + '</tbody>';
+            tableShell.innerHTML = '<table>' + head + body + '</table>';
+            tableViewport.scrollTop = 0;
+
+            const from = startIndex + 1;
+            const to = startIndex + pageRows.length;
+            pagerMeta.textContent = 'Rows ' + from + '-' + to + ' of ' + currentTableRows.length + ' | Page ' + (currentPageIndex + 1) + ' of ' + totalPages;
+            prevPageButton.disabled = currentPageIndex === 0;
+            nextPageButton.disabled = currentPageIndex >= totalPages - 1;
+            setTableStatus('');
+        }
+
+        function renderSelectTable(result) {
+            const rows = Array.isArray(result.rows) ? result.rows : [];
+            if (rows.length === 0) {
+                resetTable('The SELECT query returned no rows.');
+                return;
+            }
+            currentTableColumns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+            currentTableRows = rows;
+            currentPageIndex = 0;
+            renderTablePage();
+        }
+
+        function renderBrowseEntries(entries) {
+            if (entries.length === 0) {
+                browseList.innerHTML = '<div class="empty">No OML files found for the current filter.</div>';
+                return;
+            }
+            browseList.innerHTML = entries.map((entry) => {
+                const isSelected = selectedModelUri && selectedModelUri === entry.uri;
+                const selectedClass = isSelected ? ' selected' : '';
+                return '<button type="button" class="browse-entry' + selectedClass + '" data-uri="' + escapeClientHtml(entry.uri) + '" data-path="' + escapeClientHtml(entry.path) + '">'
+                    + '<div class="browse-entry-path" title="' + escapeClientHtml(entry.path) + '">' + escapeClientHtml(entry.path) + '</div>'
+                    + '</button>';
+            }).join('');
+        }
+
+        function applyBrowseFilter() {
+            const filter = (browseFilter.value || '').trim().toLowerCase();
+            const filtered = filter.length === 0
+                ? browseEntries
+                : browseEntries.filter((entry) => entry.path.toLowerCase().includes(filter));
+            renderBrowseEntries(filtered);
+        }
+
+        async function loadWorkspaceModels() {
+            browseStatus.textContent = 'Loading workspace OML files...';
+            browseStatus.className = 'status';
+            try {
+                const response = await fetch('/v0/models');
+                const payload = await response.json();
+                if (!response.ok) {
+                    throw new Error(payload.error || 'Unable to list workspace OML files.');
+                }
+                browseEntries = Array.isArray(payload.files) ? payload.files : [];
+                browseStatus.textContent = 'Loaded ' + browseEntries.length + ' workspace OML file(s).';
+                browseStatus.className = 'status success';
+                applyBrowseFilter();
+            } catch (error) {
+                browseEntries = [];
+                browseList.innerHTML = '<div class="empty">Unable to load workspace OML files.</div>';
+                browseStatus.textContent = error instanceof Error ? error.message : String(error);
+                browseStatus.className = 'status error';
+            }
+        }
+
+        function validateModelUri(modelUri) {
+            if (!modelUri) {
+                return 'OML file is required.';
+            }
+            if (!modelUri.startsWith('file://')) {
+                return 'OML file must be a file:// URI for an .oml file under the server workspace.';
+            }
+            if (modelUri.toLowerCase().endsWith('.md')) {
+                return 'Markdown files are not queryable directly. Choose an .oml file or resolve the markdown document\\'s ontology context first.';
+            }
+            if (!modelUri.toLowerCase().endsWith('.oml')) {
+                return 'Choose an .oml model file.';
+            }
+            return undefined;
+        }
+
+        async function executeQuery() {
+            const modelUri = selectedModelUri.trim();
+            const sparql = sparqlInput.value.trim();
+            const modelUriError = validateModelUri(modelUri);
+            if (modelUriError) {
+                setStatus(modelUriError, 'error');
+                rawOutput.textContent = JSON.stringify({ error: modelUriError }, null, 2);
+                resetTable('Choose a valid OML model file to run a query.');
+                browseModelsButton.focus();
+                return;
+            }
+            if (!sparql) {
+                setStatus('Query is required.', 'error');
+                rawOutput.textContent = JSON.stringify({ error: 'Query is required.' }, null, 2);
+                resetTable('Table rendering is available only for successful SELECT queries.');
+                sparqlInput.focus();
+                return;
+            }
+
+            runButton.disabled = true;
+            setStatus('Running query...', '');
+
+            try {
+                const response = await fetch('/v0/query', {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ modelUri, sparql })
+                });
+                const payload = await response.json();
+                rawOutput.textContent = JSON.stringify(payload, null, 2);
+
+                if (!response.ok) {
+                    resetTable('Raw response is shown below.');
+                    setStatus(payload.error || 'Request failed.', 'error');
+                    return;
+                }
+
+                const result = payload && typeof payload === 'object' ? payload.result : undefined;
+                const kind = result && typeof result.kind === 'string' ? result.kind : 'unknown';
+                if (kind === 'select') {
+                    renderSelectTable(result);
+                } else {
+                    resetTable('Raw response is shown below. Table rendering is available only for SELECT queries.');
+                }
+
+                if (result && result.success === false) {
+                    setStatus(result.error || 'Query completed with an error.', 'error');
+                    return;
+                }
+
+                const warnings = Array.isArray(result && result.warnings) ? result.warnings.length : 0;
+                const warningSuffix = warnings > 0 ? ' ' + warnings + ' warning(s).' : '';
+                setStatus('Query completed as ' + kind.toUpperCase() + '.' + warningSuffix, 'success');
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                resetTable('Raw response is shown below.');
+                rawOutput.textContent = JSON.stringify({ error: errorMessage }, null, 2);
+                setStatus('Request failed. See JSON result.', 'error');
+            } finally {
+                runButton.disabled = false;
+            }
+        }
+
+        browseModelsButton.addEventListener('click', async () => {
+            if (typeof browseDialog.showModal === 'function') {
+                browseDialog.showModal();
+            }
+            await loadWorkspaceModels();
+            browseFilter.focus();
+        });
+
+        browseFilter.addEventListener('input', () => {
+            applyBrowseFilter();
+        });
+
+        browseList.addEventListener('click', (event) => {
+            const target = event.target && event.target.closest ? event.target.closest('button[data-uri]') : null;
+            if (!target) {
+                return;
+            }
+            const uri = target.getAttribute('data-uri');
+            const relativePath = target.getAttribute('data-path');
+            if (!uri) {
+                return;
+            }
+            selectedModelUri = uri;
+            modelUriInput.value = relativePath || '';
+            setStatus('Selected workspace OML file.', 'success');
+            applyBrowseFilter();
+            if (browseDialog.open) {
+                browseDialog.close();
+            }
+        });
+
+        prevPageButton.addEventListener('click', () => {
+            if (currentPageIndex === 0) {
+                return;
+            }
+            currentPageIndex -= 1;
+            renderTablePage();
+        });
+
+        nextPageButton.addEventListener('click', () => {
+            if ((currentPageIndex + 1) * pageSize >= currentTableRows.length) {
+                return;
+            }
+            currentPageIndex += 1;
+            renderTablePage();
+        });
+
+        runButton.addEventListener('click', () => {
+            void executeQuery();
+        });
+
+        sparqlInput.addEventListener('keydown', (event) => {
+            if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
+                event.preventDefault();
+                void executeQuery();
+            }
+        });
+    </script>
+</body>
+</html>`;
+}
+
+async function readJsonBody(req: http.IncomingMessage): Promise<Record<string, unknown>> {
+    const chunks: Buffer[] = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buffer.length;
+        if (total > DEFAULT_BODY_LIMIT_BYTES) {
+            throw new Error(`Request body exceeds ${DEFAULT_BODY_LIMIT_BYTES} bytes.`);
+        }
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0) {
+        return {};
+    }
+    const parsed = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+    return typeof parsed === 'object' && parsed !== null ? parsed as Record<string, unknown> : {};
+}
+
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number, method: string): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`LSP request timeout for '${method}' after ${timeoutMs}ms.`));
+        }, timeoutMs);
+        void promise.then(
+            (value) => {
+                clearTimeout(timer);
+                resolve(value);
+            },
+            (error: unknown) => {
+                clearTimeout(timer);
+                reject(error);
+            },
+        );
+    });
+}
+
+function normalizeOntologyNamespace(value: string | undefined): string | undefined {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.replace(/^<|>$/g, '').replace(/[\/#]+$/, '');
+    return normalized.length > 0 ? normalized : undefined;
+}
+
+function resolveOutputPathFromOntologyIriString(ontologyIri: string, format: 'ttl' | 'trig' | 'nt' | 'nq' | 'n3'): string {
+    const iri = new URL(ontologyIri);
+    const rawPath = iri.pathname.replace(/\/+$/, '');
+    const pathSegments = rawPath.split('/').filter(Boolean);
+    const fileStem = pathSegments.at(-1) || 'index';
+    const directorySegments = iri.host
+        ? [iri.host, ...pathSegments.slice(0, -1)]
+        : pathSegments.slice(0, -1);
+    return path.join(...directorySegments, `${fileStem}.${format}`);
+}
+
+async function serializeQuads(
+    quads: any[],
+    format: 'ttl' | 'trig' | 'nt' | 'nq' | 'n3',
+    pretty = false,
+): Promise<string> {
+    const writer = new Writer({
+        format: format === 'ttl'
+            ? 'text/turtle'
+            : (format === 'trig'
+                ? 'application/trig'
+                : (format === 'nt'
+                    ? 'N-Triples'
+                    : (format === 'nq' ? 'N-Quads' : 'application/n3'))),
+    });
+    writer.addQuads(quads);
+    const serialized = await new Promise<string>((resolve, reject) => {
+        writer.end((error, result) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(result);
+        });
+    });
+    return pretty ? prettyPrintRdf(serialized, format) : serialized;
+}
+
+function prettyPrintRdf(serialized: string, format: 'ttl' | 'trig' | 'nt' | 'nq' | 'n3'): string {
+    if (format !== 'ttl' && format !== 'trig') {
+        return serialized;
+    }
+    const lines = serialized.split('\n');
+    const out: string[] = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        out.push(line);
+        if (line.trim() === '.') {
+            const next = lines[i + 1];
+            if (next !== undefined && next.trim().length > 0) {
+                out.push('');
+            }
+        }
+    }
+    return out.join('\n');
+}
+
+function toSparqlRowDto(row: Map<string, any>): Record<string, {
+    termType: 'NamedNode' | 'Literal' | 'BlankNode';
+    value: string;
+    datatype?: string;
+    language?: string;
+}> {
+    const result: Record<string, {
+        termType: 'NamedNode' | 'Literal' | 'BlankNode';
+        value: string;
+        datatype?: string;
+        language?: string;
+    }> = {};
+    for (const [key, term] of row.entries()) {
+        if (!term) {
+            continue;
+        }
+        result[key] = {
+            termType: term.termType,
+            value: term.value,
+            datatype: term.datatype?.value,
+            language: term.language,
+        };
+    }
+    return result;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+type RenderedBlockResult = MdBlockExecutionResult & {
+    options?: Record<string, unknown>;
+};
+
+function toMdBlockKind(language: string): MdBlockKind | undefined {
+    return SUPPORTED_MD_BLOCK_KINDS.has(language as MdBlockKind) ? (language as MdBlockKind) : undefined;
+}
+
+function toExecutableBlocks(codeBlocks: ReadonlyArray<{
+    id: string;
+    language: string;
+    content: string;
+    meta?: string;
+    options?: Record<string, unknown>;
+    lineStart: number;
+    lineEnd: number;
+}>): MdExecutableBlock[] {
+    const executable: MdExecutableBlock[] = [];
+    for (const block of codeBlocks) {
+        const kind = toMdBlockKind(block.language);
+        if (!kind) {
+            continue;
+        }
+        executable.push({
+            id: block.id,
+            kind,
+            source: block.content,
+            meta: block.meta,
+            options: block.options,
+            lineStart: block.lineStart,
+            lineEnd: block.lineEnd,
+        });
+    }
+    return executable;
+}
+
+function splitHref(href: string): { path: string; query: string; fragment: string } {
+    const hashIndex = href.indexOf('#');
+    const pathAndQuery = hashIndex >= 0 ? href.slice(0, hashIndex) : href;
+    const fragment = hashIndex >= 0 ? href.slice(hashIndex) : '';
+    const queryIndex = pathAndQuery.indexOf('?');
+    return {
+        path: queryIndex >= 0 ? pathAndQuery.slice(0, queryIndex) : pathAndQuery,
+        query: queryIndex >= 0 ? pathAndQuery.slice(queryIndex) : '',
+        fragment
+    };
+}
+
+function resolveWorkspacePath(workspaceRoot: string, hrefPath: string): string | undefined {
+    const relative = hrefPath.slice('workspace:/'.length).replace(/^\/+/, '');
+    const resolved = path.resolve(workspaceRoot, relative);
+    const relativeToWorkspace = path.relative(workspaceRoot, resolved);
+    if (relativeToWorkspace.startsWith('..') || path.isAbsolute(relativeToWorkspace)) {
+        return undefined;
+    }
+    return resolved;
+}
+
+function toRelativeWebPath(fromDir: string, toFile: string): string {
+    const relative = path.relative(fromDir, toFile).split(path.sep).join('/');
+    if (!relative || relative === '.') {
+        return '.';
+    }
+    return relative.startsWith('.') ? relative : `./${relative}`;
+}
+
+function isImagePath(filePath: string): boolean {
+    return /\.(png|jpe?g|gif|svg|webp|bmp|ico|avif)$/i.test(filePath);
+}
+
+function resolveAssetTargetPath(
+    resolvedFile: string,
+    context: {
+        workspaceRoot: string;
+        inputRoot: string;
+        outputRoot: string;
+    }
+): string {
+    const workspaceRelative = path.relative(context.workspaceRoot, resolvedFile);
+    const markdownRelative = path.relative(context.inputRoot, resolvedFile);
+    const isInsideMarkdownRoot = !markdownRelative.startsWith('..') && !path.isAbsolute(markdownRelative);
+    if (isImagePath(resolvedFile)) {
+        const imageRelative = (isInsideMarkdownRoot ? markdownRelative : workspaceRelative).split(path.sep).join('/');
+        return path.join(context.outputRoot, 'assets', 'images', imageRelative);
+    }
+    const outputRelative = isInsideMarkdownRoot ? markdownRelative : workspaceRelative;
+    return path.join(context.outputRoot, outputRelative);
+}
+
+function rewriteHref(
+    href: string,
+    context: {
+        workspaceRoot: string;
+        inputRoot: string;
+        inputFile: string;
+        outputRoot: string;
+        outputFile: string;
+    },
+    workspaceAssets: Set<string>
+): string {
+    const parts = splitHref(href);
+    if (!parts.path) {
+        return href;
+    }
+    const trimmedPath = parts.path.trim();
+    if (!trimmedPath || trimmedPath.startsWith('#') || trimmedPath.startsWith('//')) {
+        return href;
+    }
+    if (trimmedPath.startsWith('workspace:/')) {
+        const resolved = resolveWorkspacePath(context.workspaceRoot, trimmedPath);
+        if (!resolved) {
+            return href;
+        }
+        if (!resolved.toLowerCase().endsWith('.md')) {
+            workspaceAssets.add(resolved);
+        }
+        const targetInOutput = resolved.toLowerCase().endsWith('.md')
+            ? path.join(
+                context.outputRoot,
+                path.relative(context.inputRoot, resolved).replace(/\.md$/i, '.html')
+            )
+            : resolveAssetTargetPath(resolved, context);
+        const rewrittenPath = toRelativeWebPath(path.dirname(context.outputFile), targetInOutput);
+        return `${rewrittenPath}${parts.query}${parts.fragment}`;
+    }
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmedPath)) {
+        return href;
+    }
+    if (!trimmedPath.startsWith('/')) {
+        const resolved = path.resolve(path.dirname(context.inputFile), trimmedPath);
+        const workspaceRelative = path.relative(context.workspaceRoot, resolved);
+        if (!workspaceRelative.startsWith('..') && !path.isAbsolute(workspaceRelative)) {
+            if (!resolved.toLowerCase().endsWith('.md')) {
+                workspaceAssets.add(resolved);
+            }
+            const targetInOutput = resolved.toLowerCase().endsWith('.md')
+                ? path.join(
+                    context.outputRoot,
+                    path.relative(context.inputRoot, resolved).replace(/\.md$/i, '.html')
+                )
+                : resolveAssetTargetPath(resolved, context);
+            const rewrittenPath = toRelativeWebPath(path.dirname(context.outputFile), targetInOutput);
+            return `${rewrittenPath}${parts.query}${parts.fragment}`;
+        }
+    }
+    const rewrittenPath = trimmedPath.toLowerCase().endsWith('.md')
+        ? trimmedPath.slice(0, -3) + '.html'
+        : trimmedPath;
+    return `${rewrittenPath}${parts.query}${parts.fragment}`;
+}
+
+function rewriteRenderedLinks(
+    content: string,
+    context: {
+        workspaceRoot: string;
+        inputRoot: string;
+        inputFile: string;
+        outputRoot: string;
+        outputFile: string;
+    }
+): {
+    html: string;
+    workspaceAssets: Set<string>;
+} {
+    const workspaceAssets = new Set<string>();
+    const html = content.replace(/(\b(?:href|src)\s*=\s*)(["'])([^"']+)\2/gi, (_match, prefix: string, quote: string, rawHref: string) => {
+        const rewritten = rewriteHref(rawHref, context, workspaceAssets);
+        return `${prefix}${quote}${rewritten}${quote}`;
+    });
+    return { html, workspaceAssets };
+}
+
+function rewriteAssetReference(
+    rawValue: string,
+    context: {
+        workspaceRoot: string;
+        inputRoot: string;
+        sourceFile: string;
+        outputRoot: string;
+        outputFile: string;
+    }
+): { rewritten: string; sourceAsset?: string } {
+    const trimmed = rawValue.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('data:') || trimmed.startsWith('//')) {
+        return { rewritten: rawValue };
+    }
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed) && !trimmed.startsWith('workspace:/')) {
+        return { rewritten: rawValue };
+    }
+    let resolved: string | undefined;
+    if (trimmed.startsWith('workspace:/')) {
+        resolved = resolveWorkspacePath(context.workspaceRoot, trimmed);
+    } else if (trimmed.startsWith('/')) {
+        const candidate = path.resolve(context.workspaceRoot, trimmed.replace(/^\/+/, ''));
+        const relative = path.relative(context.workspaceRoot, candidate);
+        if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
+            resolved = candidate;
+        }
+    } else {
+        const candidate = path.resolve(path.dirname(context.sourceFile), trimmed);
+        const relative = path.relative(context.workspaceRoot, candidate);
+        if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
+            resolved = candidate;
+        }
+    }
+    if (!resolved) {
+        return { rewritten: rawValue };
+    }
+    const target = resolveAssetTargetPath(resolved, {
+        workspaceRoot: context.workspaceRoot,
+        inputRoot: context.inputRoot,
+        outputRoot: context.outputRoot,
+    });
+    return {
+        rewritten: toRelativeWebPath(path.dirname(context.outputFile), target),
+        sourceAsset: resolved,
+    };
+}
+
+function rewriteBlockResultAssetPaths(
+    result: RenderedBlockResult,
+    context: {
+        workspaceRoot: string;
+        inputRoot: string;
+        sourceFile: string;
+        outputRoot: string;
+        outputFile: string;
+    },
+    workspaceAssets: Set<string>,
+): RenderedBlockResult {
+    if (!result.options || result.kind !== 'diagram') {
+        return result;
+    }
+    const stylesheet = result.options.stylesheet;
+    if (!Array.isArray(stylesheet)) {
+        return result;
+    }
+    let changed = false;
+    const rewrittenStylesheet = stylesheet.map((entry) => {
+        if (!isRecord(entry) || !isRecord(entry.style) || !isRecord(entry.style.icon)) {
+            return entry;
+        }
+        let entryChanged = false;
+        const icon = { ...entry.style.icon } as Record<string, unknown>;
+        for (const key of ['href', 'xlinkHref', 'xlink:href']) {
+            const value = icon[key];
+            if (typeof value !== 'string') {
+                continue;
+            }
+            const rewritten = rewriteAssetReference(value, context);
+            if (rewritten.sourceAsset) {
+                workspaceAssets.add(rewritten.sourceAsset);
+            }
+            if (rewritten.rewritten !== value) {
+                icon[key] = rewritten.rewritten;
+                changed = true;
+                entryChanged = true;
+            }
+        }
+        if (!entryChanged) {
+            return entry;
+        }
+        return {
+            ...entry,
+            style: {
+                ...entry.style,
+                icon,
+            },
+        };
+    });
+    if (!changed) {
+        return result;
+    }
+    return {
+        ...result,
+        options: {
+            ...result.options,
+            stylesheet: rewrittenStylesheet,
+        },
+    };
+}
+
+function sanitizeBlockId(value: string): string {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return 'block';
+    }
+    return trimmed.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+
+async function writeBlockArtifacts(outputFile: string, results: ReadonlyArray<RenderedBlockResult>): Promise<{
+    count: number;
+    manifest: Array<{ blockId: string; path: string }>;
+}> {
+    if (results.length === 0) {
+        return { count: 0, manifest: [] };
+    }
+    const blockDirName = `${path.basename(outputFile, '.html')}.blocks`;
+    const blockDir = path.join(path.dirname(outputFile), blockDirName);
+    await fs.mkdir(blockDir, { recursive: true });
+    const manifest: Array<{ blockId: string; path: string }> = [];
+    for (const result of results) {
+        const safeId = sanitizeBlockId(result.blockId);
+        const fileName = `${safeId}.json`;
+        const filePath = path.join(blockDir, fileName);
+        await fs.writeFile(filePath, JSON.stringify(result, null, 2), 'utf-8');
+        manifest.push({
+            blockId: result.blockId,
+            path: `./${blockDirName}/${fileName}`
+        });
+    }
+    return { count: results.length, manifest };
+}
+
+async function loadStaticRuntimeBundle(): Promise<string> {
+    const require = createRequire(import.meta.url);
+    const staticEntry = require.resolve('@oml/markdown/static');
+    const bundlePath = path.join(path.dirname(staticEntry), STATIC_MARKDOWN_RUNTIME_BUNDLE_FILE);
+    try {
+        return await fs.readFile(bundlePath, 'utf-8');
+    } catch {
+        throw new Error(`Unable to load markdown static runtime bundle at '${bundlePath}'.`);
+    }
+}
+
+async function loadCodeBlockStylesheet(): Promise<string> {
+    const require = createRequire(import.meta.url);
+    const staticEntry = require.resolve('@oml/markdown/static');
+    const stylesheetPath = path.resolve(path.dirname(staticEntry), '..', '..', 'src', 'static', 'markdown-webview.css');
+    try {
+        return await fs.readFile(stylesheetPath, 'utf-8');
+    } catch {
+        throw new Error(`Unable to load markdown webview stylesheet at '${stylesheetPath}'.`);
+    }
+}
+
+async function writeStaticAssets(outputRoot: string): Promise<{
+    runtimeScriptFile: string;
+    stylesheetFile: string;
+}> {
+    const runtimeBundle = await loadStaticRuntimeBundle();
+    const sourceStylesheet = await loadCodeBlockStylesheet();
+    const mergedStylesheet = `${sourceStylesheet}\n\n${STATIC_MARKDOWN_RUNTIME_CSS}\n`;
+    const runtimeVersion = createHash('sha1').update(runtimeBundle).digest('hex').slice(0, 12);
+    const stylesheetVersion = createHash('sha1').update(mergedStylesheet).digest('hex').slice(0, 12);
+    const runtimeFile = path.join(outputRoot, 'assets', `markdown-static-${runtimeVersion}.js`);
+    const stylesheetFile = path.join(outputRoot, 'assets', `markdown-webview-${stylesheetVersion}.css`);
+    await fs.mkdir(path.dirname(runtimeFile), { recursive: true });
+    await fs.writeFile(runtimeFile, runtimeBundle, 'utf-8');
+    await fs.writeFile(stylesheetFile, mergedStylesheet, 'utf-8');
+    return { runtimeScriptFile: runtimeFile, stylesheetFile };
+}
+
+function escapeAttribute(value: string): string {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+
+function escapeJsonForScript(value: string): string {
+    return value.replace(/</g, '\\u003c');
+}
+
+function normalizeWikiPathKey(raw: string): string {
+    const normalized = raw.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+/g, '/');
+    if (!normalized) {
+        return '';
+    }
+    const withoutHtml = normalized.replace(/\.html$/i, '');
+    return withoutHtml.replace(/^\.\//, '').toLowerCase();
+}
+
+function buildWikiPageIndex(markdownFiles: ReadonlyArray<string>, inputRoot: string, outputRoot: string): Map<string, string> {
+    const index = new Map<string, string>();
+    for (const markdownFile of markdownFiles) {
+        const relativeInput = path.relative(inputRoot, markdownFile).split(path.sep).join('/');
+        const normalizedRelative = normalizeWikiPathKey(relativeInput.replace(/\.md$/i, ''));
+        if (!normalizedRelative) {
+            continue;
+        }
+        const outputFile = path.join(outputRoot, relativeInput.replace(/\.md$/i, '.html'));
+        index.set(normalizedRelative, outputFile);
+    }
+    return index;
+}
+
+function buildWikiLinkHrefMapForPage(
+    wikiPageIndex: ReadonlyMap<string, string>,
+    outputFile: string
+): Record<string, string> {
+    const map: Record<string, string> = {};
+    for (const [key, targetFile] of wikiPageIndex.entries()) {
+        map[key] = toRelativeWebPath(path.dirname(outputFile), targetFile);
+    }
+    return map;
+}
+
+function normalizeIri(value: string): string {
+    return value.trim().replace(/^<|>$/g, '');
+}
+
+function inferOntologyIriFromMemberIri(memberIri: string): string | undefined {
+    const normalized = normalizeIri(memberIri);
+    if (!normalized) {
+        return undefined;
+    }
+    const hashIndex = normalized.indexOf('#');
+    if (hashIndex >= 0) {
+        return normalized.slice(0, hashIndex).replace(/[\/#]+$/, '');
+    }
+    const schemeIndex = normalized.indexOf('://');
+    const slashIndex = normalized.lastIndexOf('/');
+    if (slashIndex > schemeIndex + 2) {
+        return normalized.slice(0, slashIndex).replace(/[\/#]+$/, '');
+    }
+    return normalized.replace(/[\/#]+$/, '');
+}
+
+function memberIriToOutputFile(outputRoot: string, memberIri: string): string | undefined {
+    const normalized = normalizeIri(memberIri);
+    let parsed: URL;
+    try {
+        parsed = new URL(normalized);
+    } catch {
+        return undefined;
+    }
+    const host = (parsed.hostname || '').trim().toLowerCase();
+    if (!host) {
+        return undefined;
+    }
+    const pathname = decodeURIComponent(parsed.pathname || '').replace(/^\/+/, '').replace(/\/+$/, '');
+    const fragment = decodeURIComponent(parsed.hash.replace(/^#/, '')).trim();
+    const tailSegment = pathname.split('/').filter((segment) => segment.length > 0).pop() ?? '';
+    const memberSegment = fragment || tailSegment;
+    if (!memberSegment) {
+        return undefined;
+    }
+    const safeMember = memberSegment.replace(/[^\w.-]/g, '_');
+    const basePath = fragment
+        ? pathname
+        : pathname.split('/').slice(0, -1).join('/');
+    return path.join(outputRoot, host, basePath, `${safeMember}.html`);
+}
+
+async function queryMemberTypes(
+    reasoningService: any,
+    modelUri: string,
+): Promise<Map<string, string[]>> {
+    const queryResult = await reasoningService.getSparqlService().query(modelUri, `
+        PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        SELECT DISTINCT ?member ?type
+        WHERE {
+            GRAPH ?g {
+                ?member rdf:type ?type .
+                FILTER(isIRI(?member) && isIRI(?type))
+            }
+        }
+    `);
+    if (!queryResult?.success || !Array.isArray(queryResult.rows)) {
+        return new Map<string, string[]>();
+    }
+    const byMember = new Map<string, Set<string>>();
+    for (const row of queryResult.rows as Array<Map<string, { value: string } | undefined>>) {
+        const member = normalizeIri(row.get('member')?.value ?? '');
+        const type = normalizeIri(row.get('type')?.value ?? '');
+        if (!member || !type) {
+            continue;
+        }
+        const existing = byMember.get(member) ?? new Set<string>();
+        existing.add(type);
+        byMember.set(member, existing);
+    }
+    return new Map<string, string[]>(
+        Array.from(byMember.entries()).map(([member, types]) => [member, Array.from(types)])
+    );
+}
+
+function buildIriAliasMapForPage(
+    aliasesByIri: ReadonlyMap<string, string>,
+    outputFile: string
+): Record<string, string> {
+    const aliases: Record<string, string> = {};
+    for (const [iri, absoluteTarget] of aliasesByIri.entries()) {
+        aliases[iri] = toRelativeWebPath(path.dirname(outputFile), absoluteTarget);
+    }
+    return aliases;
+}
+
+function wrapHtml(
+    content: string,
+    runtimeScriptPath: string,
+    stylesheetPath: string,
+    blockManifest: Array<{ blockId: string; path: string }>,
+    blockResults: ReadonlyArray<RenderedBlockResult>,
+    wikiLinkHrefByKey: Record<string, string>,
+    iriAliasByIri: Record<string, string>,
+): string {
+    const escapedManifest = escapeJsonForScript(JSON.stringify(blockManifest));
+    const inlineResults = Object.fromEntries(blockResults.map((result) => [result.blockId, result]));
+    const escapedInlineResults = escapeJsonForScript(JSON.stringify(inlineResults));
+    const escapedWikiIndex = escapeJsonForScript(JSON.stringify(wikiLinkHrefByKey));
+    const escapedIriAliasIndex = escapeJsonForScript(JSON.stringify(iriAliasByIri));
+    const escapedLinkingConfig = escapeJsonForScript(JSON.stringify({ linkingEnabled: true }));
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OML Markdown</title>
+  <link rel="stylesheet" href="${escapeAttribute(stylesheetPath)}">
+</head>
+<body>
+${content}
+<script id="oml-md-block-manifest" type="application/json">${escapedManifest}</script>
+<script id="oml-md-block-inline-results" type="application/json">${escapedInlineResults}</script>
+<script id="oml-md-wikilink-index" type="application/json">${escapedWikiIndex}</script>
+<script id="oml-md-wikilink-iri-aliases" type="application/json">${escapedIriAliasIndex}</script>
+<script id="oml-md-wikilink-config" type="application/json">${escapedLinkingConfig}</script>
+<script id="oml-md-member-labels" type="application/json">{}</script>
+<script src="${escapeAttribute(runtimeScriptPath)}"></script>
+</body>
+</html>
+`;
+}
+
+class InMemoryJsonRpcLspClient {
+    private readonly workspaceRoot: string;
+    private readonly requestTimeoutMs: number;
+    private readonly clientConnection?: Connection;
+    private readonly serverConnection?: Connection;
+    private readonly clientToServer?: PassThrough;
+    private readonly serverToClient?: PassThrough;
+    private initPromise?: Promise<void>;
+    private readonly runtime: OmlLanguageServerRuntime;
+    private readonly useExternalRuntime: boolean;
+    private readonly watchWorkspace: boolean;
+    private readonly watchers: Set<fsSync.FSWatcher> = new Set();
+    private watcherFlushTimer: NodeJS.Timeout | undefined;
+    private watcherActive = false;
+    private refreshInFlight = false;
+    private refreshQueued = false;
+    private initialWorkspaceSyncCompleted = false;
+
+    constructor(workspaceRoot: string, requestTimeoutMs: number, watchWorkspace: boolean, runtime?: OmlLanguageServerRuntime) {
+        this.workspaceRoot = workspaceRoot;
+        this.requestTimeoutMs = requestTimeoutMs;
+        this.useExternalRuntime = runtime !== undefined;
+        this.watchWorkspace = runtime ? false : watchWorkspace;
+        if (runtime) {
+            this.runtime = runtime;
+        } else {
+            this.clientToServer = new PassThrough();
+            this.serverToClient = new PassThrough();
+            this.serverConnection = createConnection(this.clientToServer, this.serverToClient);
+            this.runtime = startOmlLanguageServer(this.serverConnection, {
+                fileSystem: NodeFileSystem,
+                registerDiagramHandlers: true,
+                suppressTransientDiagnostics: true,
+                installNodeProcessHandlers: true,
+            });
+            this.clientConnection = createConnection(this.serverToClient, this.clientToServer);
+            this.clientConnection.listen();
+        }
+        if (this.watchWorkspace) {
+            this.startWorkspaceWatcher();
+        }
+    }
+
+    private getWorkspaceOmlDocuments(): any[] {
+        const documents = this.runtime.shared.workspace.LangiumDocuments;
+        const allDocs = documents.all ?? [];
+        const iterable: any[] = Array.isArray(allDocs)
+            ? allDocs
+            : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs as Iterable<any>));
+        return iterable
+            .filter((doc) => String(doc?.uri ?? '').trim().toLowerCase().endsWith('.oml'))
+            .sort((left, right) => String(left?.uri ?? '').localeCompare(String(right?.uri ?? '')));
+    }
+
+    async lintWorkspace(params: Record<string, unknown> = {}): Promise<RestLintResult> {
+        const context: RestValidationContext = {
+            workspaceRoot: this.workspaceRoot,
+            runtime: this.runtime,
+            ensureInitialized: () => this.ensureInitialized(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            getWorkspaceOmlDocuments: () => this.getWorkspaceOmlDocuments(),
+            writeWorkspaceAssertedOwl: (outputDir, format, pretty) => this.writeWorkspaceAssertedOwl(outputDir, format, pretty),
+        };
+        return await lintWorkspace(context, params);
+    }
+
+    async queryWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+        await this.ensureInitialized();
+        await this.ensureWorkspaceCurrent();
+        const modelUri = typeof params.modelUri === 'string' ? params.modelUri.trim() : '';
+        const sparql = typeof params.sparql === 'string' ? params.sparql : '';
+        if (!modelUri) {
+            return {
+                success: false,
+                kind: detectSparqlKind(sparql),
+                warnings: [],
+                error: "Missing 'modelUri'.",
+            };
+        }
+        try {
+            const reasoningService = this.runtime.Oml.reasoning.ReasoningService as any;
+            const kind = detectSparqlKind(sparql);
+            await reasoningService.ensureQueryContext(modelUri);
+            const sparqlService = reasoningService.getSparqlService();
+            if (kind === 'select') {
+                const result = await sparqlService.query(modelUri, sparql);
+                return {
+                    success: result.success,
+                    kind,
+                    warnings: result.warnings ?? [],
+                    rows: result.rows.map((row: Map<string, any>) => toSparqlRowDto(row)),
+                    error: result.error,
+                };
+            }
+            if (kind === 'ask') {
+                const result = await sparqlService.ask(modelUri, sparql);
+                return {
+                    success: result.success,
+                    kind,
+                    warnings: result.warnings ?? [],
+                    result: result.result,
+                    error: result.error,
+                };
+            }
+            if (kind === 'construct' || kind === 'describe') {
+                const result = await sparqlService.construct(modelUri, sparql);
+                return {
+                    success: result.success,
+                    kind,
+                    warnings: result.warnings ?? [],
+                    quads: result.quads.map((quad: any) => ({
+                        subject: quad.subject.value,
+                        predicate: quad.predicate.value,
+                        object: quad.object.value,
+                        graph: quad.graph.value,
+                    })),
+                    error: result.error,
+                };
+            }
+            return {
+                success: false,
+                kind: 'unknown',
+                warnings: [],
+                error: 'Unsupported or unknown SPARQL query kind.',
+            };
+        } catch (error) {
+            return {
+                success: false,
+                kind: detectSparqlKind(sparql),
+                warnings: [],
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+
+    async updateWorkspace(params: Record<string, unknown>): Promise<OmlEditResponse> {
+        await this.ensureInitialized();
+        await this.ensureWorkspaceCurrent();
+        return await applyOmlUpdate(
+            this.runtime.shared,
+            params as OmlEditRequest,
+            (message) => this.logError(message),
+        );
+    }
+
+    async fuzzySearchWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+        await this.ensureInitialized();
+        await this.ensureWorkspaceCurrent();
+        try {
+            const text = (typeof params.text === 'string' ? params.text : '').trim();
+            if (!text) {
+                return { success: true, candidates: [] };
+            }
+            const limit = Math.max(1, Math.min(50, typeof params.limit === 'number' ? params.limit : 12));
+            const ontologyIndex = getOntologyModelIndex(this.runtime.shared as any);
+            const langiumDocuments: any = this.runtime.shared.workspace.LangiumDocuments;
+            const allDocs = langiumDocuments.all ?? [];
+            const iterable: any[] = Array.isArray(allDocs)
+                ? allDocs
+                : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs as Iterable<any>));
+            const modelUris: string[] = [];
+            const candidateByIri = new Map<string, { iri: string; label?: string }>();
+            for (const doc of iterable) {
+                const root = doc?.parseResult?.value;
+                if (!root || !isOntology(root) || (!isVocabulary(root) && !isDescription(root))) {
+                    continue;
+                }
+                modelUris.push(doc.uri.toString());
+                for (const member of collectOntologyMembers(root)) {
+                    const iri = getIriForNode(member);
+                    if (!iri) {
+                        continue;
+                    }
+                    candidateByIri.set(iri, { iri });
+                }
+            }
+            const labelSnapshot = ontologyIndex.getMemberLabelSnapshot(modelUris);
+            for (const [iri, label] of Object.entries(labelSnapshot)) {
+                const entry = candidateByIri.get(iri) ?? { iri };
+                entry.label = label;
+                candidateByIri.set(iri, entry);
+            }
+
+            const indexedEntries: OmlFuzzyIndexedEntry[] = [...candidateByIri.values()].map((entry) => ({
+                iri: entry.iri,
+                label: entry.label,
+                fragment: iriFragment(entry.iri),
+                fragmentTokens: tokenizeForFuzzy(iriFragment(entry.iri)),
+                labelTokens: tokenizeForFuzzy(entry.label ?? ''),
+            }));
+            const haystack = indexedEntries.map((entry) => `${entry.fragment}\n${entry.label ?? ''}\n${entry.iri}`);
+            const uf = new uFuzzy({});
+            const filtered = uf.filter(haystack, text);
+            if (!filtered || filtered.length === 0) {
+                return { success: true, candidates: [] };
+            }
+            const info = uf.info(filtered, haystack, text);
+            const order = info ? uf.sort(info, haystack, text) : null;
+            const ranked = (order ?? filtered.map((_, index) => index))
+                .map((index) => filtered[index]!)
+                .slice(0, limit);
+            const queryTokens = tokenizeForFuzzy(text).slice(0, 6);
+            const candidates = ranked.map((entryIndex, index) => {
+                const entry = indexedEntries[entryIndex]!;
+                const fragment = entry.fragment.toLowerCase();
+                const lowerLabel = (entry.label ?? '').toLowerCase();
+                const lowerInput = text.toLowerCase();
+                const fragmentTokenSet = new Set(entry.fragmentTokens);
+                const labelTokenSet = new Set(entry.labelTokens);
+                let fragmentTokenHits = 0;
+                let labelTokenHits = 0;
+                for (const token of queryTokens) {
+                    if (fragmentTokenSet.has(token)) {
+                        fragmentTokenHits += 1;
+                    }
+                    if (labelTokenSet.has(token)) {
+                        labelTokenHits += 1;
+                    }
+                }
+                return {
+                    iri: entry.iri,
+                    label: entry.label,
+                    score: ranked.length - index,
+                    diagnostics: {
+                        fragment,
+                        label: lowerLabel,
+                        exactFragment: fragment === lowerInput,
+                        exactLabel: lowerLabel === lowerInput,
+                        containsInputInFragment: fragment.includes(lowerInput),
+                        containsInputInLabel: lowerLabel.includes(lowerInput),
+                        fragmentTokenHits,
+                        labelTokenHits,
+                    },
+                };
+            });
+            return { success: true, candidates };
+        } catch (error) {
+            return {
+                success: false,
+                candidates: [],
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+
+    private async writeWorkspaceAssertedOwl(
+        outputDir: string,
+        format: 'ttl' | 'trig' | 'nt' | 'nq' | 'n3',
+        pretty: boolean,
+    ): Promise<Array<{ modelUri: string; ontologyIri: string; owlPath: string }>> {
+        const entries: Array<{ modelUri: string; ontologyIri: string; owlPath: string }> = [];
+        const docs = this.getWorkspaceOmlDocuments();
+        const reasoningService = this.runtime.Oml.reasoning.ReasoningService as any;
+        const store = reasoningService.getStore().getStore();
+        for (const doc of docs) {
+            const modelUri = String(doc?.uri ?? '').trim();
+            const root = doc?.parseResult?.value as { namespace?: string } | undefined;
+            const ontologyIri = normalizeOntologyNamespace(root?.namespace)?.replace(/[\/#]+$/, '');
+            if (!ontologyIri || BUILT_IN_ONTOLOGIES.has(ontologyIri)) {
+                continue;
+            }
+            await reasoningService.ensureQueryContext(modelUri);
+            const quads = store.getQuads(null, null, null, DataFactory.namedNode(modelUri))
+                .map((quad: any) => DataFactory.quad(quad.subject, quad.predicate, quad.object));
+            const owlPath = path.join(outputDir, resolveOutputPathFromOntologyIriString(ontologyIri, format));
+            await fs.mkdir(path.dirname(owlPath), { recursive: true });
+            await fs.writeFile(owlPath, await serializeQuads(quads, format, pretty), 'utf-8');
+            entries.push({ modelUri, ontologyIri, owlPath });
+        }
+        entries.sort((left, right) => left.ontologyIri.localeCompare(right.ontologyIri));
+        return entries;
+    }
+
+    async reasonWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+        const context: RestValidationContext = {
+            workspaceRoot: this.workspaceRoot,
+            runtime: this.runtime,
+            ensureInitialized: () => this.ensureInitialized(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            getWorkspaceOmlDocuments: () => this.getWorkspaceOmlDocuments(),
+            writeWorkspaceAssertedOwl: (outputDir, format, pretty) => this.writeWorkspaceAssertedOwl(outputDir, format, pretty),
+        };
+        return await reasonWorkspace(context, params);
+    }
+
+    async validateWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+        const context: RestValidationContext = {
+            workspaceRoot: this.workspaceRoot,
+            runtime: this.runtime,
+            ensureInitialized: () => this.ensureInitialized(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            getWorkspaceOmlDocuments: () => this.getWorkspaceOmlDocuments(),
+            writeWorkspaceAssertedOwl: (outputDir, format, pretty) => this.writeWorkspaceAssertedOwl(outputDir, format, pretty),
+        };
+        return await validateWorkspace(context, params);
+    }
+
+    async exportWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+        const context: RestExportContext = {
+            workspaceRoot: this.workspaceRoot,
+            ensureInitialized: () => this.ensureInitialized(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            writeWorkspaceAssertedOwl: (outputDir, format, pretty) => this.writeWorkspaceAssertedOwl(outputDir, format, pretty),
+            exportAssertedWorkspace: (options) => exportAssertedWorkspace(context, options),
+        };
+        return await exportWorkspace(context, params);
+    }
+
+    async close(): Promise<void> {
+        this.stopWorkspaceWatcher();
+        if (!this.useExternalRuntime) {
+            try {
+                this.clientConnection?.sendNotification('exit');
+            } catch {
+                // Ignore close-time notification failures.
+            }
+            this.clientConnection?.dispose();
+            this.serverConnection?.dispose();
+            this.clientToServer?.destroy();
+            this.serverToClient?.destroy();
+        }
+    }
+
+    private logError(message: string): void {
+        if (this.clientConnection?.console?.error) {
+            this.clientConnection.console.error(message);
+            return;
+        }
+        console.error(`[oml-rest] ${message}`);
+    }
+
+    private startWorkspaceWatcher(): void {
+        if (this.watcherActive) {
+            return;
+        }
+        this.watcherActive = true;
+        this.watchDirectory(this.workspaceRoot);
+    }
+
+    private stopWorkspaceWatcher(): void {
+        this.watcherActive = false;
+        if (this.watcherFlushTimer) {
+            clearTimeout(this.watcherFlushTimer);
+            this.watcherFlushTimer = undefined;
+        }
+        for (const watcher of this.watchers) {
+            watcher.close();
+        }
+        this.watchers.clear();
+    }
+
+    private watchDirectory(dirPath: string): void {
+        const basename = path.basename(dirPath);
+        if (basename.startsWith('.') || basename === 'node_modules' || basename === 'out' || basename === 'build') {
+            return;
+        }
+        try {
+            const watcher = fsSync.watch(dirPath, { recursive: false }, (_eventType, filename) => {
+                if (!this.watcherActive || !filename) {
+                    return;
+                }
+                const fullPath = path.join(dirPath, filename.toString());
+                if (!fullPath.toLowerCase().endsWith('.oml')) {
+                    return;
+                }
+                this.scheduleWorkspaceRefresh();
+            });
+            this.watchers.add(watcher);
+        } catch {
+            return;
+        }
+
+        try {
+            const entries = fsSync.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    this.watchDirectory(path.join(dirPath, entry.name));
+                }
+            }
+        } catch {
+            // Ignore unreadable directories.
+        }
+    }
+
+    private scheduleWorkspaceRefresh(): void {
+        if (this.watcherFlushTimer) {
+            return;
+        }
+        this.watcherFlushTimer = setTimeout(() => {
+            this.watcherFlushTimer = undefined;
+            void this.refreshWorkspaceOmlDocumentsQueued().catch(() => {});
+        }, 100);
+    }
+
+    private async refreshWorkspaceOmlDocumentsQueued(): Promise<void> {
+        if (this.refreshInFlight) {
+            this.refreshQueued = true;
+            return;
+        }
+        this.refreshInFlight = true;
+        try {
+            await this.refreshWorkspaceOmlDocuments();
+        } finally {
+            this.refreshInFlight = false;
+        }
+        if (this.refreshQueued) {
+            this.refreshQueued = false;
+            await this.refreshWorkspaceOmlDocumentsQueued();
+        }
+    }
+
+    async exportAssertedWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+        const context: RestExportContext = {
+            workspaceRoot: this.workspaceRoot,
+            ensureInitialized: () => this.ensureInitialized(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            writeWorkspaceAssertedOwl: (outputDir, format, pretty) => this.writeWorkspaceAssertedOwl(outputDir, format, pretty),
+            exportAssertedWorkspace: (options) => exportAssertedWorkspace(context, options),
+        };
+        return await exportAssertedWorkspace(context, params);
+    }
+
+    async renderWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+        await this.ensureInitialized();
+        await this.ensureWorkspaceCurrent();
+        if (params.only !== true) {
+            const lint = await this.lintWorkspace();
+            if (lint.errors > 0 || lint.warnings > 0) {
+                return {
+                    success: false,
+                    filesRendered: 0,
+                    outputDir: '',
+                    error: `lint failed with ${lint.errors} error(s) and ${lint.warnings} warning(s).`,
+                    lint,
+                };
+            }
+        }
+        const workspaceRoot = path.resolve(this.workspaceRoot);
+        const inputFromOptions = typeof params.inputDir === 'string' && params.inputDir.trim().length > 0
+            ? params.inputDir.trim()
+            : (typeof params.md === 'string' && params.md.trim().length > 0 ? params.md.trim() : 'src/md');
+        const outputFromOptions = typeof params.outputDir === 'string' && params.outputDir.trim().length > 0
+            ? params.outputDir.trim()
+            : (typeof params.web === 'string' && params.web.trim().length > 0 ? params.web.trim() : 'build/web');
+        const inputDir = path.resolve(
+            workspaceRoot,
+            inputFromOptions,
+        );
+        const outputDir = path.resolve(
+            workspaceRoot,
+            outputFromOptions,
+        );
+        const contextOption = typeof params.contextOntologyIri === 'string' && params.contextOntologyIri.trim().length > 0
+            ? params.contextOntologyIri.trim()
+            : (typeof params.context === 'string' && params.context.trim().length > 0 ? params.context.trim() : undefined);
+        const defaultContextOntologyIri = contextOption
+            ? normalizeContextOntologyIri(contextOption)
+            : undefined;
+        const runtime = new MarkdownPreviewRuntime(new MarkdownHandlerRegistry());
+        const templateCatalog = await buildTemplateCatalog(workspaceRoot);
+        const navigationTemplateCatalog = buildNavigationTemplateCatalog(
+            Array.from(templateCatalog.values()).flatMap((entries) => entries.map((entry) => entry.definition))
+        );
+        const staticAssets = await writeStaticAssets(outputDir);
+        const reasoningService = this.runtime.Oml.reasoning.ReasoningService as any;
+        const ontologyIndex = getOntologyModelIndex(this.runtime.shared as any);
+        const executor = new MarkdownExecutor({
+            ensureContext: (modelUri) => reasoningService.ensureQueryContext(modelUri),
+            resolveContextIri: (modelUri) => reasoningService.getContextIri(modelUri),
+            countContextQuads: (modelUri) => reasoningService.countContextDatasetQuads(modelUri),
+            query: (modelUri, sparql) => reasoningService.getSparqlService().query(modelUri, sparql),
+            construct: (modelUri, sparql) => reasoningService.getSparqlService().construct(modelUri, sparql),
+        });
+        const markdownFiles = await findFilesByExtension(inputDir, '.md');
+        const wikiPageIndex = buildWikiPageIndex(markdownFiles, inputDir, outputDir);
+        const workspaceAssetFiles = new Set<string>();
+        const aliasesByIri = new Map<string, string>();
+        const renderJobs: Array<{
+            htmlPath: string;
+            renderedHtml: string;
+            blockManifest: Array<{ blockId: string; path: string }>;
+            blockResults: ReadonlyArray<RenderedBlockResult>;
+            wikiLinkHrefByKey: Record<string, string>;
+        }> = [];
+        const contextModelUris = new Set<string>();
+        let filesRendered = 0;
+        let blockArtifactFiles = 0;
+        for (const markdownPath of markdownFiles) {
+            const markdown = await fs.readFile(markdownPath, 'utf-8');
+            if (isTemplateMarkdownFile(markdown)) {
+                continue;
+            }
+            const frontMatter = extractLeadingFrontMatter(markdown);
+            const contextOntologyIri = normalizeContextOntologyIri(
+                frontMatter?.contextOntologyIri
+                    ?? frontMatterString(frontMatter?.data, 'ontologyIri')
+                    ?? frontMatterString(frontMatter?.data, 'ontology')
+            );
+            const contextMemberIri = frontMatterString(frontMatter?.data, 'memberIri')
+                ?? frontMatterString(frontMatter?.data, 'contextMemberIri');
+            const referencingUri = pathToFileURL(markdownPath).toString();
+            const effectiveOntologyIri = contextOntologyIri ?? defaultContextOntologyIri;
+            const resolvedModelUri = effectiveOntologyIri
+                ? ontologyIndex.resolveModelUri(effectiveOntologyIri, referencingUri)
+                : undefined;
+            const contextModelUri = resolvedModelUri;
+            if (contextModelUri) {
+                contextModelUris.add(contextModelUri);
+            }
+            const expandedMarkdown = await expandTemplateComposeBlocks(markdown, templateCatalog, {
+                workspaceRoot,
+                sourceMarkdownPath: markdownPath,
+                contextOntologyIri: effectiveOntologyIri,
+                contextModelUri,
+                contextMemberIri,
+            });
+            const prepared = runtime.prepare(expandedMarkdown);
+            const relative = path.relative(inputDir, markdownPath).replace(/\\/g, '/');
+            const htmlPath = path.join(outputDir, relative.replace(/\.md$/i, '.html'));
+            const rewriteResult = rewriteRenderedLinks(prepared.renderedHtml, {
+                workspaceRoot,
+                inputRoot: inputDir,
+                inputFile: markdownPath,
+                outputRoot: outputDir,
+                outputFile: htmlPath,
+            });
+            for (const asset of rewriteResult.workspaceAssets) {
+                workspaceAssetFiles.add(asset);
+            }
+            const executableBlocks = toExecutableBlocks(prepared.codeBlocks);
+            const optionsByBlockId = new Map(prepared.codeBlocks.map((block) => [block.id, block.options] as const));
+            const blockResults = executableBlocks.length === 0 || !contextModelUri
+                ? []
+                : (await executor.executeBlocks({
+                    markdownUri: pathToFileURL(path.resolve(markdownPath)).toString(),
+                    modelUri: contextModelUri,
+                    blocks: executableBlocks,
+                })).results.map((result) => ({
+                    ...result,
+                    options: optionsByBlockId.get(result.blockId),
+                } as RenderedBlockResult));
+            const rewrittenBlockResults = blockResults.map((result) => rewriteBlockResultAssetPaths(result, {
+                workspaceRoot,
+                inputRoot: inputDir,
+                sourceFile: markdownPath,
+                outputRoot: outputDir,
+                outputFile: htmlPath,
+            }, workspaceAssetFiles));
+            const blockArtifacts = await writeBlockArtifacts(htmlPath, rewrittenBlockResults);
+            blockArtifactFiles += blockArtifacts.count;
+            const wikiLinkHrefByKey = buildWikiLinkHrefMapForPage(wikiPageIndex, htmlPath);
+            renderJobs.push({
+                htmlPath,
+                renderedHtml: rewriteResult.html,
+                blockManifest: blockArtifacts.manifest,
+                blockResults: rewrittenBlockResults,
+                wikiLinkHrefByKey,
+            });
+            filesRendered += 1;
+        }
+        const renderedNavigationPages = new Set<string>();
+        for (const modelUri of contextModelUris) {
+            await reasoningService.ensureQueryContext(modelUri);
+            const membersToTypes = await queryMemberTypes(reasoningService, modelUri);
+            for (const [memberIri, rdfTypes] of membersToTypes.entries()) {
+                const resolution = resolveTemplateForNavigation(navigationTemplateCatalog, rdfTypes);
+                if (!resolution.template) {
+                    continue;
+                }
+                const targetFile = memberIriToOutputFile(outputDir, memberIri);
+                if (!targetFile) {
+                    continue;
+                }
+                aliasesByIri.set(memberIri, targetFile);
+                if (renderedNavigationPages.has(targetFile)) {
+                    continue;
+                }
+                renderedNavigationPages.add(targetFile);
+                const contextOntologyIri = inferOntologyIriFromMemberIri(memberIri);
+                const sourceDocumentUri = resolution.template.sourceUri?.trim() || pathToFileURL(path.join(workspaceRoot, 'index.md')).toString();
+                const invocation: TemplateInvocation = {
+                    templateId: resolution.template.id,
+                    mode: 'navigation',
+                    context: {
+                        invocation: {
+                            mode: 'navigation',
+                            sourceDocumentUri,
+                            referenceDocumentUri: sourceDocumentUri,
+                        },
+                        model: {
+                            ontologyIri: contextOntologyIri,
+                            modelUri,
+                        },
+                        focus: {
+                            memberIri,
+                        },
+                        selection: {
+                            iris: [memberIri],
+                        },
+                    },
+                    args: {},
+                };
+                const rendered = renderTemplate(resolution.template, invocation);
+                if (rendered.missingRequired.length > 0) {
+                    continue;
+                }
+                const syntheticSourcePath = resolution.template.sourceUri?.startsWith('file:')
+                    ? decodeURIComponent(new URL(resolution.template.sourceUri).pathname)
+                    : path.join(workspaceRoot, 'index.md');
+                const expanded = await expandTemplateComposeBlocks(rendered.output, templateCatalog, {
+                    workspaceRoot,
+                    sourceMarkdownPath: syntheticSourcePath,
+                    contextOntologyIri,
+                    contextModelUri: modelUri,
+                    contextMemberIri: memberIri,
+                });
+                const prepared = runtime.prepare(expanded);
+                const rewriteResult = rewriteRenderedLinks(prepared.renderedHtml, {
+                    workspaceRoot,
+                    inputRoot: inputDir,
+                    inputFile: syntheticSourcePath,
+                    outputRoot: outputDir,
+                    outputFile: targetFile,
+                });
+                for (const asset of rewriteResult.workspaceAssets) {
+                    workspaceAssetFiles.add(asset);
+                }
+                const executableBlocks = toExecutableBlocks(prepared.codeBlocks);
+                const optionsByBlockId = new Map(prepared.codeBlocks.map((block) => [block.id, block.options] as const));
+                const blockResults = executableBlocks.length === 0
+                    ? []
+                    : (await executor.executeBlocks({
+                        markdownUri: sourceDocumentUri,
+                        modelUri,
+                        blocks: executableBlocks,
+                    })).results.map((result) => ({
+                        ...result,
+                        options: optionsByBlockId.get(result.blockId),
+                    } as RenderedBlockResult));
+                const rewrittenBlockResults = blockResults.map((result) => rewriteBlockResultAssetPaths(result, {
+                    workspaceRoot,
+                    inputRoot: inputDir,
+                    sourceFile: syntheticSourcePath,
+                    outputRoot: outputDir,
+                    outputFile: targetFile,
+                }, workspaceAssetFiles));
+                const blockArtifacts = await writeBlockArtifacts(targetFile, rewrittenBlockResults);
+                blockArtifactFiles += blockArtifacts.count;
+                renderJobs.push({
+                    htmlPath: targetFile,
+                    renderedHtml: rewriteResult.html,
+                    blockManifest: blockArtifacts.manifest,
+                    blockResults: rewrittenBlockResults,
+                    wikiLinkHrefByKey: buildWikiLinkHrefMapForPage(wikiPageIndex, targetFile),
+                });
+                filesRendered += 1;
+            }
+        }
+        for (const job of renderJobs) {
+            const runtimeScriptRelative = toRelativeWebPath(path.dirname(job.htmlPath), staticAssets.runtimeScriptFile);
+            const stylesheetRelative = toRelativeWebPath(path.dirname(job.htmlPath), staticAssets.stylesheetFile);
+            const html = wrapHtml(
+                job.renderedHtml,
+                runtimeScriptRelative,
+                stylesheetRelative,
+                job.blockManifest,
+                job.blockResults,
+                job.wikiLinkHrefByKey,
+                buildIriAliasMapForPage(aliasesByIri, job.htmlPath),
+            );
+            await fs.mkdir(path.dirname(job.htmlPath), { recursive: true });
+            await fs.writeFile(job.htmlPath, html, 'utf-8');
+        }
+        for (const file of workspaceAssetFiles) {
+            const workspaceRelative = path.relative(workspaceRoot, file);
+            if (workspaceRelative.startsWith('..') || path.isAbsolute(workspaceRelative)) {
+                continue;
+            }
+            if (workspaceRelative.toLowerCase().endsWith('.md')) {
+                continue;
+            }
+            const target = resolveAssetTargetPath(file, {
+                workspaceRoot,
+                inputRoot: inputDir,
+                outputRoot: outputDir,
+            });
+            await fs.mkdir(path.dirname(target), { recursive: true });
+            try {
+                await fs.copyFile(file, target);
+            } catch (error) {
+                const code = (error as NodeJS.ErrnoException).code;
+                if (code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }
+        return { success: true, filesRendered, outputDir, blockArtifactFiles };
+    }
+
+    private async ensureWorkspaceCurrent(): Promise<void> {
+        if (this.useExternalRuntime) {
+            return;
+        }
+        if (!this.watchWorkspace) {
+            await this.refreshWorkspaceOmlDocuments();
+            return;
+        }
+        if (!this.initialWorkspaceSyncCompleted) {
+            await this.refreshWorkspaceOmlDocuments();
+            this.initialWorkspaceSyncCompleted = true;
+        }
+        await this.waitForWatcherRefreshIdle();
+    }
+
+    private async waitForWatcherRefreshIdle(): Promise<void> {
+        while (this.watcherFlushTimer !== undefined || this.refreshInFlight || this.refreshQueued) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+
+    private async refreshWorkspaceOmlDocuments(): Promise<void> {
+        const workspaceRoot = path.resolve(this.workspaceRoot);
+        const omlFiles = await findFilesByExtension(workspaceRoot, '.oml');
+        const changedUris = omlFiles.map((filePath) => URI.parse(pathToFileURL(filePath).toString()));
+        const documents = this.runtime.shared.workspace.LangiumDocuments;
+        const allDocs = documents.all ?? [];
+        const iterable: any[] = Array.isArray(allDocs)
+            ? allDocs
+            : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs as Iterable<any>));
+        const currentOmlUris = new Set<string>();
+        for (const document of iterable) {
+            const uri = String(document?.uri ?? '').trim();
+            if (!uri.toLowerCase().endsWith('.oml')) {
+                continue;
+            }
+            currentOmlUris.add(uri);
+        }
+        const changedUriStrings = new Set(changedUris.map((uri) => uri.toString()));
+        const deletedUris = [...currentOmlUris]
+            .filter((uri) => !changedUriStrings.has(uri))
+            .map((uri) => URI.parse(uri));
+        await Promise.all(changedUris.map((uri) => documents.getOrCreateDocument(uri)));
+        const builder = this.runtime.shared.workspace.DocumentBuilder;
+        await builder.update(changedUris, deletedUris);
+    }
+
+    private async ensureInitialized(): Promise<void> {
+        if (this.initPromise) {
+            await this.initPromise;
+            return;
+        }
+
+        if (this.useExternalRuntime) {
+            this.initPromise = (async () => {
+                const workspace = this.runtime.shared.workspace.WorkspaceManager;
+                await workspace.ready;
+            })();
+        } else {
+            const rootPath = path.resolve(this.workspaceRoot);
+            const rootUri = pathToFileURL(rootPath).toString();
+            this.initPromise = (async () => {
+                await withTimeout(this.clientConnection!.sendRequest('initialize', {
+                    processId: process.pid,
+                    rootUri,
+                    workspaceFolders: [{ uri: rootUri, name: path.basename(rootPath) }],
+                    capabilities: {},
+                    clientInfo: { name: 'oml-rest-server', version: '1.0' },
+                    initializationOptions: {},
+                }), this.requestTimeoutMs, 'initialize');
+                this.clientConnection!.sendNotification('initialized', {});
+            })();
+        }
+        await this.initPromise;
+    }
+}
+
+export async function startOmlRestServer(options: OmlRestServerOptions): Promise<{ server: http.Server; updateToken: (token: string) => void }> {
+    const workspaceRoot = options.workspaceRoot ? path.resolve(options.workspaceRoot) : process.cwd();
+    const client = new InMemoryJsonRpcLspClient(
+        workspaceRoot,
+        options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+        options.watchWorkspace === true,
+        options.runtime,
+    );
+    const openApiSpec = createOpenApiSpec(options.host, options.port);
+    let currentAccessToken: string | undefined = options.authToken;
+    const getAccessToken = (): string | undefined => currentAccessToken;
+
+    const server = http.createServer(async (req, res) => {
+        const requestId = randomUUID();
+        try {
+            const method = req.method ?? 'GET';
+            const rawUrl = req.url ?? '/';
+            const parsed = new URL(rawUrl, `http://${req.headers.host ?? 'localhost'}`);
+            const pathname = parsed.pathname;
+
+            if (method === 'GET' && pathname === '/health') {
+                jsonResponse(res, 200, {
+                    status: 'ok',
+                    service: 'oml-server',
+                    mode: 'rest',
+                    workspaceRoot,
+                    authenticated: getAccessToken() !== undefined,
+                    requestId,
+                });
+                return;
+            }
+
+            if (method === 'GET' && pathname === '/') {
+                htmlResponse(res, 200, createSparqlWorkbenchPage(workspaceRoot));
+                return;
+            }
+
+            if (method === 'GET' && pathname === '/openapi.json') {
+                jsonResponse(res, 200, openApiSpec);
+                return;
+            }
+
+            if (method === 'GET' && pathname === '/v0/models') {
+                const workspaceModelFiles = await listWorkspaceModelFiles(workspaceRoot);
+                jsonResponse(res, 200, {
+                    files: workspaceModelFiles,
+                    requestId,
+                });
+                return;
+            }
+
+            if (method === 'POST') {
+                const body = await readJsonBody(req);
+                const route = await dispatchRestRoute(method, pathname, body, client);
+                if (route) {
+                    jsonResponse(res, 200, {
+                        ok: true,
+                        method: `oml/rest/${route.operationId}`,
+                        result: route.result,
+                        requestId
+                    });
+                    return;
+                }
+            }
+
+            jsonResponse(res, 404, { error: `No route for ${method} ${pathname}.`, requestId });
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const status = error instanceof SyntaxError || message.includes('Request body exceeds') ? 400 : 500;
+            jsonResponse(res, status, { error: message, requestId });
+        }
+    });
+
+    server.on('close', () => {
+        void client.close();
+        currentAccessToken = undefined;
+    });
+
+    await new Promise<void>((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(options.port, options.host, () => resolve());
+    });
+
+    return {
+        server,
+        updateToken: (token: string) => { currentAccessToken = token; },
+    };
+}