@oml/server 0.14.17 → 0.16.0

package/out/rest/server.js

@@ -14,20 +14,20 @@ import { DataFactory, Writer } from 'n3';
 import uFuzzy from '@leeoniya/ufuzzy';
 import { MarkdownHandlerRegistry, MarkdownPreviewRuntime, buildTemplateCatalog as buildNavigationTemplateCatalog, extractLeadingFrontMatter, resolveTemplateForNavigation, renderTemplate, MarkdownExecutor, } 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, } from '@oml/language';
+import { applyOmlUpdate, collectOntologyMembers, getIriForNode, getOntologyModelIndex, iriFragment, isDescription, isDescriptionBundle, isOntology, isVocabulary, isVocabularyBundle, tokenizeForFuzzy, } from '@oml/language';
 import { detectSparqlKind } from '@oml/owl';
 import { exportAssertedWorkspace, exportWorkspace } from './export.js';
 import { startOmlLanguageServer } from '../lsp/language-server.js';
 import { createOpenApiSpec, dispatchRestOperation, resolveRestOperationId } from './routes.js';
 import { buildTemplateCatalog, expandTemplateComposeBlocks, findFilesByExtension, frontMatterString, isTemplateMarkdownFile, normalizeContextOntologyIri, } from './template.js';
 import { lintWorkspace, validateWorkspace } from './validation.js';
+import { reindexWorkspaceShacl } from './shacl-index.js';
 import { OmlAccessError, requiredFeatureForRestOperation, } from '../auth/feature-policy.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 = 30000;
 const require = createModuleRequire();
-const REST_DEBUG_ENABLED = false;
 const SWAGGER_ASSET_FILES = new Set([
     'swagger-ui.css',
     'swagger-ui-bundle.js',
@@ -43,6 +43,162 @@ const SWAGGER_CONTENT_TYPES = {
 let swaggerAssetValidationError;
 let markdownStaticEntryFileCache;
 const swaggerAssetPathCache = new Map();
+function positionToOffset(text, position) {
+    let line = 0;
+    let index = 0;
+    while (line < position.line && index < text.length) {
+        const nl = text.indexOf('\n', index);
+        if (nl < 0) {
+            return text.length;
+        }
+        index = nl + 1;
+        line += 1;
+    }
+    return Math.min(text.length, index + Math.max(0, position.character));
+}
+function applyTextEditsToContent(content, edits) {
+    const normalized = [...edits].sort((left, right) => {
+        const leftStart = left.range.start.line === right.range.start.line
+            ? left.range.start.character - right.range.start.character
+            : left.range.start.line - right.range.start.line;
+        if (leftStart !== 0) {
+            return -leftStart;
+        }
+        const leftEnd = left.range.end.line === right.range.end.line
+            ? left.range.end.character - right.range.end.character
+            : left.range.end.line - right.range.end.line;
+        return -leftEnd;
+    });
+    let current = content;
+    for (const edit of normalized) {
+        const start = positionToOffset(current, edit.range.start);
+        const end = positionToOffset(current, edit.range.end);
+        current = `${current.slice(0, start)}${edit.newText}${current.slice(end)}`;
+    }
+    return current;
+}
+async function applyWorkspaceEditToFiles(edit) {
+    const byUri = new Map();
+    const changedFiles = [];
+    if (edit.changes) {
+        for (const [uri, edits] of Object.entries(edit.changes)) {
+            byUri.set(uri, [...(byUri.get(uri) ?? []), ...edits]);
+        }
+    }
+    if (Array.isArray(edit.documentChanges)) {
+        for (const change of edit.documentChanges) {
+            if (change?.kind === 'delete' && typeof change.uri === 'string') {
+                if (change.uri.startsWith('file://')) {
+                    const filePath = fileURLToPath(change.uri);
+                    await fs.rm(filePath, { force: true });
+                    changedFiles.push(change.uri);
+                }
+                continue;
+            }
+            const uri = change?.textDocument?.uri;
+            const edits = change?.edits;
+            if (!uri || !Array.isArray(edits)) {
+                continue;
+            }
+            byUri.set(uri, [...(byUri.get(uri) ?? []), ...edits]);
+        }
+    }
+    for (const [uri, edits] of byUri.entries()) {
+        if (!uri.startsWith('file://')) {
+            continue;
+        }
+        const filePath = fileURLToPath(uri);
+        const current = await fs.readFile(filePath, 'utf-8').catch((error) => {
+            if (error?.code === 'ENOENT') {
+                return '';
+            }
+            throw error;
+        });
+        const next = applyTextEditsToContent(current, edits);
+        if (next !== current) {
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, next, 'utf-8');
+            changedFiles.push(uri);
+        }
+    }
+    return changedFiles;
+}
+function collectWorkspaceEditChangedFiles(edit) {
+    const changed = new Set();
+    if (edit.changes) {
+        for (const uri of Object.keys(edit.changes)) {
+            if (uri.startsWith('file://')) {
+                changed.add(uri);
+            }
+        }
+    }
+    if (Array.isArray(edit.documentChanges)) {
+        for (const change of edit.documentChanges) {
+            if (change?.kind === 'delete' && typeof change?.uri === 'string' && change.uri.startsWith('file://')) {
+                changed.add(change.uri);
+                continue;
+            }
+            const uri = change?.textDocument?.uri;
+            if (typeof uri === 'string' && uri.startsWith('file://')) {
+                changed.add(uri);
+            }
+        }
+    }
+    return [...changed];
+}
+function collectWorkspaceEditReloadUris(edit) {
+    const uris = new Set();
+    if (edit.changes) {
+        for (const uri of Object.keys(edit.changes)) {
+            if (uri.startsWith('file://')) {
+                uris.add(uri);
+            }
+        }
+    }
+    if (Array.isArray(edit.documentChanges)) {
+        for (const change of edit.documentChanges) {
+            if (change?.kind === 'delete') {
+                if (typeof change?.uri === 'string' && change.uri.startsWith('file://')) {
+                    uris.add(change.uri);
+                }
+                continue;
+            }
+            const uri = change?.textDocument?.uri;
+            if (typeof uri === 'string' && uri.startsWith('file://')) {
+                uris.add(uri);
+            }
+        }
+    }
+    return [...uris].map((uri) => URI.parse(uri));
+}
+function normalizeUpdateOperation(operation) {
+    if (!operation || typeof operation !== 'object' || Array.isArray(operation)) {
+        return operation;
+    }
+    const record = operation;
+    const keys = Object.keys(record);
+    if (keys.length !== 1) {
+        return operation;
+    }
+    const kind = keys[0];
+    const payload = record[kind];
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return operation;
+    }
+    return {
+        kind,
+        ...payload,
+    };
+}
+function normalizeUpdateRequest(params) {
+    const operations = Array.isArray(params.operations)
+        ? params.operations.map((operation) => normalizeUpdateOperation(operation))
+        : [];
+    return {
+        ...params,
+        operations,
+    };
+}
 function createModuleRequire() {
     if (typeof __filename === 'string' && path.isAbsolute(__filename)) {
         return createRequire(__filename);
@@ -53,16 +209,6 @@ function createModuleRequire() {
     }
     throw new Error('Unable to initialize module-anchored require() in @oml/server REST runtime.');
 }
-function debugRest(event, details = {}) {
-    if (!REST_DEBUG_ENABLED) {
-        return;
-    }
-    const fields = Object.entries(details)
-        .map(([key, value]) => `${key}=${String(value)}`)
-        .join(' ');
-    const suffix = fields.length > 0 ? ` ${fields}` : '';
-    process.stderr.write(`[oml-rest][debug] ${new Date().toISOString()} pid=${process.pid} event=${event}${suffix}\n`);
-}
 const SUPPORTED_MD_BLOCK_KINDS = new Set([
     'table',
     'tree',
@@ -74,6 +220,70 @@ const SUPPORTED_MD_BLOCK_KINDS = new Set([
     'matrix',
     'table-editor'
 ]);
+function getOntologiesFromRuntime(runtime) {
+    const reasoningService = runtime.Oml.reasoning.ReasoningService;
+    const importGraph = reasoningService.getImportGraph();
+    const ontologyIndex = getOntologyModelIndex(runtime.shared);
+    const langiumDocuments = runtime.shared.workspace.LangiumDocuments;
+    // Collect all unique model URIs from the import graph
+    const modelUris = new Set();
+    for (const [importer, importedSet] of importGraph.imports.entries()) {
+        modelUris.add(importer);
+        for (const imported of importedSet) {
+            modelUris.add(imported);
+        }
+    }
+    // Also include model URIs that are importers but not imported by anyone
+    for (const importer of importGraph.importedBy.keys()) {
+        modelUris.add(importer);
+    }
+    const ontologies = [];
+    for (const modelUri of modelUris) {
+        // Get ontology IRI
+        const ontologyIri = ontologyIndex.resolveOntologyIri(modelUri);
+        if (!ontologyIri)
+            continue;
+        // Get oml:type by loading the document
+        let omlType = 'http://opencaesar.io/oml#Vocabulary'; // default
+        try {
+            const uri = URI.parse(modelUri);
+            const document = langiumDocuments.getDocument(uri);
+            if (document?.parseResult?.value) {
+                const ontology = document.parseResult.value;
+                if (isOntology(ontology)) {
+                    if (isVocabulary(ontology)) {
+                        omlType = 'http://opencaesar.io/oml#Vocabulary';
+                    }
+                    else if (isVocabularyBundle(ontology)) {
+                        omlType = 'http://opencaesar.io/oml#VocabularyBundle';
+                    }
+                    else if (isDescription(ontology)) {
+                        omlType = 'http://opencaesar.io/oml#Description';
+                    }
+                    else if (isDescriptionBundle(ontology)) {
+                        omlType = 'http://opencaesar.io/oml#DescriptionBundle';
+                    }
+                }
+            }
+        }
+        catch {
+            // Keep default oml:type if document can't be loaded
+        }
+        // Get imports
+        const importedUris = importGraph.directImportsOf(modelUri);
+        const imports = [];
+        for (const importedUri of importedUris) {
+            const importedOntologyIri = ontologyIndex.resolveOntologyIri(importedUri);
+            if (importedOntologyIri) {
+                imports.push(importedOntologyIri);
+            }
+        }
+        ontologies.push({ ontology: ontologyIri, modelUri, oml_type: omlType, imports });
+    }
+    // Sort by ontology IRI
+    ontologies.sort((a, b) => a.ontology.localeCompare(b.ontology));
+    return ontologies;
+}
 class RestHttpError extends Error {
     constructor(statusCode, message) {
         super(message);
@@ -253,34 +463,6 @@ function escapeHtml(value) {
         .replace(/"/g, '&quot;')
         .replace(/'/g, '&#39;');
 }
-async function listWorkspaceModelFiles(workspaceRoot) {
-    const entries = [];
-    const ignoredNames = new Set(['.git', 'node_modules', 'dist', 'build', 'out']);
-    const visit = async (currentDir) => {
-        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) {
     const escapedWorkspaceRoot = escapeHtml(defaultWorkspaceRoot);
     return `<!DOCTYPE html>
@@ -799,8 +981,8 @@ function createSparqlWorkbenchPage(defaultWorkspaceRoot) {
                 </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>
+                        <span class="field-label">OML Ontology</span>
+                        <input id="ontologyIri" type="text" spellcheck="false" placeholder="Select an OML ontology from Browse" readonly>
                     </label>
                     <button id="browseModelsButton" class="ghost" type="button">Browse</button>
                 </div>
@@ -859,13 +1041,13 @@ LIMIT 25</textarea>
         <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 class="dialog-title">Workspace OML Ontologies</div>
+                    <div class="dialog-subtitle">Select the ontology 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">
+                <input id="browseFilter" type="text" placeholder="Filter ontologies by IRI" spellcheck="false">
                 <div id="browseStatus" class="status">Loading...</div>
                 <div id="browseList" class="browse-list"></div>
             </div>
@@ -873,7 +1055,7 @@ LIMIT 25</textarea>
     </dialog>
 
     <script>
-        const modelUriInput = document.getElementById('modelUri');
+        const ontologyIriInput = document.getElementById('ontologyIri');
         const sparqlInput = document.getElementById('sparql');
         const runButton = document.getElementById('runQueryButton');
         const browseModelsButton = document.getElementById('browseModelsButton');
@@ -891,7 +1073,7 @@ LIMIT 25</textarea>
         const browseFilter = document.getElementById('browseFilter');
 
         let browseEntries = [];
-        let selectedModelId = '';
+        let selectedOntologyIri = '';
         let currentTableColumns = [];
         let currentTableRows = [];
         let currentPageIndex = 0;
@@ -995,20 +1177,30 @@ LIMIT 25</textarea>
             renderTablePage();
         }
 
+        function ontologyIriToModelId(iri) {
+            try {
+                const url = new URL(iri);
+                const rawPath = url.pathname.replace(/[/]+$/, '');
+                const segments = rawPath.split('/').filter(Boolean);
+                const stem = segments[segments.length - 1] || 'index';
+                const dirSegs = url.host ? [url.host, ...segments.slice(0, -1)] : segments.slice(0, -1);
+                return [...dirSegs, stem].join('/');
+            } catch {
+                return iri;
+            }
+        }
+
         function renderBrowseEntries(entries) {
             if (entries.length === 0) {
-                browseList.innerHTML = '<div class="empty">No OML files found for the current filter.</div>';
+                browseList.innerHTML = '<div class="empty">No OML ontologies found for the current filter.</div>';
                 return;
             }
             browseList.innerHTML = entries.map((entry) => {
-                const normalizedPath = String(entry.path || '').trim();
-                const modelId = normalizedPath.toLowerCase().endsWith('.oml')
-                    ? normalizedPath.slice(0, -4)
-                    : normalizedPath;
-                const isSelected = selectedModelId && selectedModelId === modelId;
+                const iri = String(entry.ontology || '').trim();
+                const isSelected = selectedOntologyIri && selectedOntologyIri === iri;
                 const selectedClass = isSelected ? ' selected' : '';
-                return '<button type="button" class="browse-entry' + selectedClass + '" data-model-id="' + escapeClientHtml(modelId) + '" data-path="' + escapeClientHtml(entry.path) + '">'
-                    + '<div class="browse-entry-path" title="' + escapeClientHtml(entry.path) + '">' + escapeClientHtml(entry.path) + '</div>'
+                return '<button type="button" class="browse-entry' + selectedClass + '" data-ontology-iri="' + escapeClientHtml(iri) + '">'
+                    + '<div class="browse-entry-path" title="' + escapeClientHtml(iri) + '">' + escapeClientHtml(iri) + '</div>'
                     + '</button>';
             }).join('');
         }
@@ -1017,52 +1209,50 @@ LIMIT 25</textarea>
             const filter = (browseFilter.value || '').trim().toLowerCase();
             const filtered = filter.length === 0
                 ? browseEntries
-                : browseEntries.filter((entry) => entry.path.toLowerCase().includes(filter));
+                : browseEntries.filter((entry) => String(entry.ontology || '').toLowerCase().includes(filter));
             renderBrowseEntries(filtered);
         }
 
         async function loadWorkspaceModels() {
-            browseStatus.textContent = 'Loading workspace OML files...';
+            browseStatus.textContent = 'Loading workspace OML ontologies...';
             browseStatus.className = 'status';
             try {
-                const response = await fetch(routeUrl('v0/models'));
+                const response = await fetch(routeUrl('v0/ontologies'));
                 const payload = await response.json();
                 if (!response.ok) {
-                    throw new Error(payload.error || 'Unable to list workspace OML files.');
+                    throw new Error(payload.error || 'Unable to list workspace OML ontologies.');
                 }
-                browseEntries = Array.isArray(payload.files) ? payload.files : [];
-                browseStatus.textContent = 'Loaded ' + browseEntries.length + ' workspace OML file(s).';
+                browseEntries = Array.isArray(payload.ontologies) ? payload.ontologies : [];
+                browseStatus.textContent = 'Loaded ' + browseEntries.length + ' workspace ontolog' + (browseEntries.length === 1 ? 'y' : 'ies') + '.';
                 browseStatus.className = 'status success';
                 applyBrowseFilter();
             } catch (error) {
                 browseEntries = [];
-                browseList.innerHTML = '<div class="empty">Unable to load workspace OML files.</div>';
+                browseList.innerHTML = '<div class="empty">Unable to load workspace OML ontologies.</div>';
                 browseStatus.textContent = error instanceof Error ? error.message : String(error);
                 browseStatus.className = 'status error';
             }
         }
 
-        function validateModelId(modelId) {
-            if (!modelId) {
-                return 'OML file is required.';
-            }
-            if (modelId.toLowerCase().endsWith('.md')) {
-                return 'Markdown files are not queryable directly. Choose an .oml file.';
+        function validateOntologyIri(iri) {
+            if (!iri) {
+                return 'OML ontology is required.';
             }
             return undefined;
         }
 
         async function executeQuery() {
-            const modelId = selectedModelId.trim();
+            const iri = selectedOntologyIri.trim();
             const sparql = sparqlInput.value.trim();
-            const modelIdError = validateModelId(modelId);
-            if (modelIdError) {
-                setStatus(modelIdError, 'error');
-                rawOutput.textContent = JSON.stringify({ error: modelIdError }, null, 2);
-                resetTable('Choose a valid OML model file to run a query.');
+            const iriError = validateOntologyIri(iri);
+            if (iriError) {
+                setStatus(iriError, 'error');
+                rawOutput.textContent = JSON.stringify({ error: iriError }, null, 2);
+                resetTable('Choose a valid OML ontology to run a query.');
                 browseModelsButton.focus();
                 return;
             }
+            const modelId = ontologyIriToModelId(iri);
             if (!sparql) {
                 setStatus('Query is required.', 'error');
                 rawOutput.textContent = JSON.stringify({ error: 'Query is required.' }, null, 2);
@@ -1142,18 +1332,17 @@ LIMIT 25</textarea>
         });
 
         browseList.addEventListener('click', (event) => {
-            const target = event.target && event.target.closest ? event.target.closest('button[data-model-id]') : null;
+            const target = event.target && event.target.closest ? event.target.closest('button[data-ontology-iri]') : null;
             if (!target) {
                 return;
             }
-            const modelId = target.getAttribute('data-model-id');
-            const relativePath = target.getAttribute('data-path');
-            if (!modelId) {
+            const iri = target.getAttribute('data-ontology-iri');
+            if (!iri) {
                 return;
             }
-            selectedModelId = modelId;
-            modelUriInput.value = relativePath || '';
-            setStatus('Selected workspace OML file.', 'success');
+            selectedOntologyIri = iri;
+            ontologyIriInput.value = iri;
+            setStatus('Selected OML ontology.', 'success');
             applyBrowseFilter();
             if (browseDialog.open) {
                 browseDialog.close();
@@ -1233,47 +1422,36 @@ function resolveSparqlModelPathFromRoute(pathname) {
  * optionally with `.oml` extension) to a canonical `file://` URI.
  * Throws a plain Error if the path escapes the workspace root.
  */
-function normalizeModelUri(workspaceRoot, input) {
-    const trimmed = input.trim();
-    const normalizedWorkspace = path.resolve(workspaceRoot);
-    if (trimmed.startsWith('file://')) {
-        const filePath = fileURLToPath(trimmed);
-        if (filePath !== normalizedWorkspace && !filePath.startsWith(`${normalizedWorkspace}${path.sep}`)) {
-            throw new Error('Model URI escapes the workspace root.');
-        }
-        return trimmed;
-    }
-    const relative = trimmed.replace(/^\/+/, '');
-    if (!relative) {
-        throw new Error('Empty model path.');
-    }
-    const candidate = path.resolve(workspaceRoot, relative);
-    if (candidate !== normalizedWorkspace && !candidate.startsWith(`${normalizedWorkspace}${path.sep}`)) {
-        throw new Error('Model path escapes the workspace root.');
-    }
-    return pathToFileURL(candidate).toString();
+function ontologyIriToModelId(ontologyIri) {
+    const iri = new URL(ontologyIri);
+    const rawPath = iri.pathname.replace(/\/+$/, '');
+    const segments = rawPath.split('/').filter(Boolean);
+    const stem = segments.at(-1) || 'index';
+    const dirSegs = iri.host ? [iri.host, ...segments.slice(0, -1)] : segments.slice(0, -1);
+    return [...dirSegs, stem].join('/');
 }
-function resolveModelUriFromRouteModelPath(workspaceRoot, routeModelPath) {
-    const normalized = routeModelPath.trim().replace(/^\/+|\/+$/g, '');
+function resolveModelUriFromIriModelId(docs, ontologyIndex, modelId) {
+    const normalized = modelId.trim().replace(/^\/+|\/+$/g, '');
     if (!normalized) {
-        throw new RestHttpError(400, 'Missing model path in SPARQL endpoint route.');
-    }
-    if (path.isAbsolute(normalized)) {
-        throw new RestHttpError(400, 'SPARQL model path must be workspace-relative.');
+        throw new RestHttpError(400, 'Missing model ID in SPARQL endpoint route.');
     }
-    if (normalized.toLowerCase().endsWith('.oml')) {
-        throw new RestHttpError(400, "SPARQL model path must not include '.oml'. Use workspace-relative path without extension.");
-    }
-    const candidate = path.resolve(workspaceRoot, `${normalized}.oml`);
-    const normalizedWorkspace = path.resolve(workspaceRoot);
-    if (candidate !== normalizedWorkspace && !candidate.startsWith(`${normalizedWorkspace}${path.sep}`)) {
-        throw new RestHttpError(400, 'SPARQL model path escapes the workspace root.');
+    for (const doc of docs) {
+        const modelUri = String(doc?.uri ?? '').trim();
+        if (!modelUri)
+            continue;
+        const ontologyIri = ontologyIndex.resolveOntologyIri?.(modelUri);
+        if (!ontologyIri)
+            continue;
+        try {
+            const derived = ontologyIriToModelId(ontologyIri);
+            if (derived === normalized)
+                return modelUri;
+        }
+        catch {
+            // skip unparseable IRIs
+        }
     }
-    return pathToFileURL(candidate).toString();
-}
-async function assertModelUriExists(modelUri) {
-    const filePath = fileURLToPath(modelUri);
-    await fs.access(filePath, fsSync.constants.F_OK);
+    throw new RestHttpError(404, `No OML ontology found for model ID '${normalized}'.`);
 }
 function parseSparqlQueryFromRequest(req, parsedUrl, bodyText) {
     const method = (req.method ?? 'GET').toUpperCase();
@@ -1393,14 +1571,7 @@ function normalizeOntologyNamespace(value) {
     return normalized.length > 0 ? normalized : undefined;
 }
 function resolveOutputPathFromOntologyIriString(ontologyIri, format) {
-    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}`);
+    return ontologyIriToModelId(ontologyIri).split('/').join(path.sep) + '.' + format;
 }
 function normalizeRdfSerializationFormat(value) {
     const normalized = String(value ?? 'ttl').trim().toLowerCase();
@@ -1409,7 +1580,27 @@ function normalizeRdfSerializationFormat(value) {
     }
     return 'ttl';
 }
-async function serializeQuads(quads, format, pretty = false) {
+function filterPrefixesForQuads(quads, workspacePrefixes) {
+    const usedNs = new Set();
+    for (const quad of quads) {
+        for (const term of [quad.subject, quad.predicate, quad.object]) {
+            if (term?.termType === 'NamedNode') {
+                const iri = term.value;
+                const h = iri.lastIndexOf('#');
+                const ns = h >= 0 ? iri.slice(0, h + 1) : iri.slice(0, iri.lastIndexOf('/') + 1);
+                if (ns)
+                    usedNs.add(ns);
+            }
+        }
+    }
+    const result = {};
+    for (const [px, ns] of Object.entries(workspacePrefixes)) {
+        if (usedNs.has(ns))
+            result[px] = ns;
+    }
+    return result;
+}
+async function serializeQuads(quads, format, pretty = false, prefixes) {
     const writer = new Writer({
         format: format === 'ttl'
             ? 'text/turtle'
@@ -1418,6 +1609,7 @@ async function serializeQuads(quads, format, pretty = false) {
                 : (format === 'nt'
                     ? 'N-Triples'
                     : (format === 'nq' ? 'N-Quads' : 'application/n3'))),
+        ...(prefixes && Object.keys(prefixes).length > 0 ? { prefixes } : {}),
     });
     writer.addQuads(quads);
     const serialized = await new Promise((resolve, reject) => {
@@ -1470,6 +1662,60 @@ function isRecord(value) {
 function toMdBlockKind(language) {
     return SUPPORTED_MD_BLOCK_KINDS.has(language) ? language : undefined;
 }
+const SCRIPT_LANGUAGES = new Set(['javascript', 'js', 'python', 'r']);
+function extractScriptQueryStrings(code) {
+    const seen = new Set();
+    const patterns = [
+        /\bquery\s*\(\s*`([\s\S]*?)`\s*\)/g,
+        /\bquery\s*\(\s*"""([\s\S]*?)"""\s*\)/g,
+        /\bquery\s*\(\s*'''([\s\S]*?)'''\s*\)/g,
+        /\bquery\s*\(\s*"((?:[^"\\]|\\[\s\S])*)"\s*\)/g,
+        /\bquery\s*\(\s*'((?:[^'\\]|\\[\s\S])*)'\s*\)/g,
+    ];
+    for (const re of patterns) {
+        let m;
+        while ((m = re.exec(code)) !== null) {
+            const sparql = (m[1] ?? '').replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, '\\');
+            if (sparql.trim()) {
+                seen.add(sparql);
+            }
+        }
+    }
+    return [...seen];
+}
+async function buildScriptSparqlCache(codeBlocks, query) {
+    const cache = {};
+    for (const block of codeBlocks) {
+        if (!SCRIPT_LANGUAGES.has(block.language)) {
+            continue;
+        }
+        const queryStrings = extractScriptQueryStrings(block.content);
+        if (queryStrings.length === 0) {
+            continue;
+        }
+        const blockCache = {};
+        for (const sparql of queryStrings) {
+            try {
+                const result = await query(sparql);
+                if (result.success && result.rows) {
+                    const columns = result.rows.length > 0 ? [...result.rows[0].keys()] : [];
+                    const rows = result.rows.map((row) => Object.fromEntries(columns.map((c) => [c, row.get(c)?.value ?? ''])));
+                    blockCache[sparql] = { success: true, columns, rows };
+                }
+                else {
+                    blockCache[sparql] = { success: false, columns: [], rows: [], error: result.error ?? 'Query failed' };
+                }
+            }
+            catch (e) {
+                blockCache[sparql] = { success: false, columns: [], rows: [], error: e instanceof Error ? e.message : String(e) };
+            }
+        }
+        if (Object.keys(blockCache).length > 0) {
+            cache[block.id] = blockCache;
+        }
+    }
+    return cache;
+}
 function toExecutableBlocks(codeBlocks) {
     const executable = [];
     for (const block of codeBlocks) {
@@ -1682,11 +1928,12 @@ function sanitizeBlockId(value) {
     return trimmed.replace(/[^a-zA-Z0-9._-]/g, '_');
 }
 async function writeBlockArtifacts(outputFile, results) {
+    const blockDirName = `${path.basename(outputFile, '.html')}.blocks`;
+    const blockDir = path.join(path.dirname(outputFile), blockDirName);
+    await fs.rm(blockDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     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 = [];
     for (const result of results) {
@@ -1852,36 +2099,46 @@ function buildIriAliasMapForPage(aliasesByIri, outputFile) {
     }
     return aliases;
 }
-function wrapHtml(content, runtimeScriptPath, stylesheetPath, blockManifest, blockResults, wikiLinkHrefByKey, iriAliasByIri) {
+function wrapHtml(content, runtimeScriptPath, stylesheetPath, blockManifest, blockResults, wikiLinkHrefByKey, iriAliasByIri, scriptSparqlCache) {
     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 }));
+    const escapedScriptCache = escapeJsonForScript(JSON.stringify(scriptSparqlCache));
     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>
+  <script>
+    document.documentElement.classList.add('oml-md-booting');
+  </script>
   <link rel="stylesheet" href="${escapeAttribute(stylesheetPath)}">
+  <style>
+    html.oml-md-booting body { visibility: hidden; }
+    body.oml-md-booting #oml-md-content { visibility: hidden; }
+  </style>
 </head>
-<body>
-${content}
+<body class="oml-md-booting">
+<div id="oml-md-content"></div>
+<template id="oml-md-initial-content">${content}</template>
 <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 id="oml-md-script-sparql-cache" type="application/json">${escapedScriptCache}</script>
 <script src="${escapeAttribute(runtimeScriptPath)}"></script>
 </body>
 </html>
 `;
 }
 class InMemoryJsonRpcLspClient {
-    constructor(workspaceRoot, requestTimeoutMs, watchWorkspace, runtime) {
+    constructor(workspaceRoot, requestTimeoutMs, runtime) {
         this.watchers = new Set();
         this.watcherActive = false;
         this.refreshInFlight = false;
@@ -1890,13 +2147,6 @@ class InMemoryJsonRpcLspClient {
         this.workspaceRoot = workspaceRoot;
         this.requestTimeoutMs = requestTimeoutMs;
         this.useExternalRuntime = runtime !== undefined;
-        this.watchWorkspace = runtime ? false : watchWorkspace;
-        debugRest('client.constructor', {
-            workspaceRoot: path.resolve(workspaceRoot),
-            requestTimeoutMs,
-            useExternalRuntime: this.useExternalRuntime,
-            watchWorkspace: this.watchWorkspace,
-        });
         if (runtime) {
             this.runtime = runtime;
         }
@@ -1913,9 +2163,17 @@ class InMemoryJsonRpcLspClient {
             this.clientConnection = createConnection(this.serverToClient, this.clientToServer);
             this.clientConnection.listen();
         }
-        if (this.watchWorkspace) {
-            this.startWorkspaceWatcher();
+        this.startWorkspaceWatcher();
+    }
+    getWorkspacePrefixes() {
+        const prefixes = {};
+        for (const doc of this.getWorkspaceOmlDocuments()) {
+            const root = doc?.parseResult?.value;
+            if (root?.namespace && root?.prefix) {
+                prefixes[root.prefix] = root.namespace;
+            }
         }
+        return prefixes;
     }
     getWorkspaceOmlDocuments() {
         const documents = this.runtime.shared.workspace.LangiumDocuments;
@@ -1927,206 +2185,38 @@ class InMemoryJsonRpcLspClient {
             .filter((doc) => String(doc?.uri ?? '').trim().toLowerCase().endsWith('.oml'))
             .sort((left, right) => String(left?.uri ?? '').localeCompare(String(right?.uri ?? '')));
     }
-    summarizeDiagnostics(docs) {
-        let diagnostics = 0;
-        let errors = 0;
-        let warnings = 0;
-        let unresolved = 0;
-        const unresolvedSamples = [];
-        for (const doc of docs) {
-            const uri = String(doc?.uri ?? '').trim();
-            const docDiagnostics = Array.isArray(doc?.diagnostics) ? doc.diagnostics : [];
-            for (const diagnostic of docDiagnostics) {
-                diagnostics += 1;
-                const severity = Number(diagnostic?.severity ?? 0);
-                if (severity === 1) {
-                    errors += 1;
-                }
-                else if (severity === 2) {
-                    warnings += 1;
-                }
-                const message = String(diagnostic?.message ?? '');
-                if (message.includes('Could not resolve reference')) {
-                    unresolved += 1;
-                    if (unresolvedSamples.length < 8) {
-                        const line = Number(diagnostic?.range?.start?.line ?? 0) + 1;
-                        const column = Number(diagnostic?.range?.start?.character ?? 0) + 1;
-                        unresolvedSamples.push(`${uri}:${line}:${column}:${message}`);
-                    }
-                }
-            }
-        }
-        return {
-            docs: docs.length,
-            diagnostics,
-            errors,
-            warnings,
-            unresolved,
-            unresolvedSamples,
-        };
+    async waitForValidatedWithTrace() {
+        await this.runtime.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated);
     }
-    summarizeDocumentStates(docs) {
-        const summary = {
-            changed: 0,
-            parsed: 0,
-            indexedContent: 0,
-            computedScopes: 0,
-            linked: 0,
-            indexedReferences: 0,
-            validated: 0,
-        };
-        for (const doc of docs) {
-            const state = Number(doc?.state ?? -1);
-            if (state >= DocumentState.Changed)
-                summary.changed += 1;
-            if (state >= DocumentState.Parsed)
-                summary.parsed += 1;
-            if (state >= DocumentState.IndexedContent)
-                summary.indexedContent += 1;
-            if (state >= DocumentState.ComputedScopes)
-                summary.computedScopes += 1;
-            if (state >= DocumentState.Linked)
-                summary.linked += 1;
-            if (state >= DocumentState.IndexedReferences)
-                summary.indexedReferences += 1;
-            if (state >= DocumentState.Validated)
-                summary.validated += 1;
-        }
-        return summary;
-    }
-    async waitForValidatedWithTrace(reason, targetUris) {
-        const builder = this.runtime.shared.workspace.DocumentBuilder;
-        if (!REST_DEBUG_ENABLED) {
-            await builder.waitUntil(DocumentState.Validated);
-            return;
-        }
-        const startedAt = Date.now();
-        const seenValidated = new Set();
-        const beforeDocs = this.getWorkspaceOmlDocuments();
-        const beforeStates = this.summarizeDocumentStates(beforeDocs);
-        const beforeByUri = new Map(beforeDocs.map((doc) => [String(doc?.uri ?? '').trim(), Number(doc?.state ?? -1)]));
-        const targetList = targetUris
-            ? [...targetUris].filter((uri) => uri.toLowerCase().endsWith('.oml'))
-            : [...beforeByUri.keys()];
-        const alreadyValidatedBeforeWait = targetList.filter((uri) => (beforeByUri.get(uri) ?? -1) >= DocumentState.Validated).length;
-        const pendingBeforeWait = targetList.filter((uri) => (beforeByUri.get(uri) ?? -1) < DocumentState.Validated);
-        const listener = builder.onDocumentPhase(DocumentState.Validated, (doc) => {
-            const uri = String(doc?.uri ?? '').trim();
-            if (!uri) {
-                return;
-            }
-            if (targetUris && !targetUris.has(uri)) {
-                return;
-            }
-            if (seenValidated.has(uri)) {
-                return;
-            }
-            seenValidated.add(uri);
-            const count = seenValidated.size;
-            if (count <= 5 || count % 25 === 0) {
-                debugRest('workspace.validated.doc', { reason, count, uri });
-            }
-        });
-        try {
-            debugRest('workspace.validated.wait.begin', {
-                reason,
-                targetCount: targetUris ? targetUris.size : -1,
-                docs: beforeDocs.length,
-                stateChanged: beforeStates.changed,
-                stateParsed: beforeStates.parsed,
-                stateIndexedContent: beforeStates.indexedContent,
-                stateComputedScopes: beforeStates.computedScopes,
-                stateLinked: beforeStates.linked,
-                stateIndexedReferences: beforeStates.indexedReferences,
-                stateValidated: beforeStates.validated,
-                alreadyValidatedBeforeWait,
-                pendingBeforeWait: pendingBeforeWait.length,
-                pendingBeforeWaitSample: pendingBeforeWait.slice(0, 8).join(' || '),
-            });
-            await builder.waitUntil(DocumentState.Validated);
-            const afterDocs = this.getWorkspaceOmlDocuments();
-            const afterStates = this.summarizeDocumentStates(afterDocs);
-            const afterByUri = new Map(afterDocs.map((doc) => [String(doc?.uri ?? '').trim(), Number(doc?.state ?? -1)]));
-            const pendingAfterWait = targetList.filter((uri) => (afterByUri.get(uri) ?? -1) < DocumentState.Validated);
-            debugRest('workspace.validated.wait.end', {
-                reason,
-                elapsedMs: Math.max(0, Date.now() - startedAt),
-                observedValidatedDocs: seenValidated.size,
-                docs: afterDocs.length,
-                stateChanged: afterStates.changed,
-                stateParsed: afterStates.parsed,
-                stateIndexedContent: afterStates.indexedContent,
-                stateComputedScopes: afterStates.computedScopes,
-                stateLinked: afterStates.linked,
-                stateIndexedReferences: afterStates.indexedReferences,
-                stateValidated: afterStates.validated,
-                pendingAfterWait: pendingAfterWait.length,
-                pendingAfterWaitSample: pendingAfterWait.slice(0, 8).join(' || '),
-            });
-        }
-        finally {
-            listener.dispose();
-        }
-    }
-    async lintWorkspace(_params = {}) {
-        const preDocs = this.getWorkspaceOmlDocuments();
-        const preSummary = this.summarizeDiagnostics(preDocs);
-        const preStates = this.summarizeDocumentStates(preDocs);
-        debugRest('lint.begin', {
-            workspaceRoot: path.resolve(this.workspaceRoot),
-            docs: preSummary.docs,
-            diagnostics: preSummary.diagnostics,
-            errors: preSummary.errors,
-            warnings: preSummary.warnings,
-            unresolved: preSummary.unresolved,
-            unresolvedSample: preSummary.unresolvedSamples.join(' || '),
-            stateChanged: preStates.changed,
-            stateParsed: preStates.parsed,
-            stateIndexedContent: preStates.indexedContent,
-            stateComputedScopes: preStates.computedScopes,
-            stateLinked: preStates.linked,
-            stateIndexedReferences: preStates.indexedReferences,
-            stateValidated: preStates.validated,
-        });
+    async lintWorkspace(params = {}) {
         const context = {
             workspaceRoot: this.workspaceRoot,
             runtime: this.runtime,
             ensureInitialized: () => this.ensureInitialized(),
-            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceSettled(false),
+            waitForValidated: () => this.waitForValidatedWithTrace(),
             getWorkspaceOmlDocuments: () => this.getWorkspaceOmlDocuments(),
         };
-        const result = await lintWorkspace(context);
-        const postDocs = this.getWorkspaceOmlDocuments();
-        const postStates = this.summarizeDocumentStates(postDocs);
-        debugRest('lint.end', {
-            filesChecked: result.filesChecked,
-            errors: result.errors,
-            warnings: result.warnings,
-            problems: result.problems.length,
-            elapsedMs: result.elapsedMs,
-            stateValidated: postStates.validated,
-            stateLinked: postStates.linked,
-            stateComputedScopes: postStates.computedScopes,
-        });
+        const result = await lintWorkspace(context, params);
         return result;
     }
     async queryWorkspaceRaw(modelUri, sparql) {
         await this.ensureInitialized();
-        await this.ensureWorkspaceCurrent();
+        await this.ensureWorkspaceSettled(false);
         const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
         await reasoningService.ensureQueryContext(modelUri);
         return await reasoningService.getSparqlService().query(modelUri, sparql);
     }
     async askWorkspaceRaw(modelUri, sparql) {
         await this.ensureInitialized();
-        await this.ensureWorkspaceCurrent();
+        await this.ensureWorkspaceSettled(false);
         const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
         await reasoningService.ensureQueryContext(modelUri);
         return await reasoningService.getSparqlService().ask(modelUri, sparql);
     }
     async constructWorkspaceRaw(modelUri, sparql) {
         await this.ensureInitialized();
-        await this.ensureWorkspaceCurrent();
+        await this.ensureWorkspaceSettled(false);
         const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
         await reasoningService.ensureQueryContext(modelUri);
         return await reasoningService.getSparqlService().construct(modelUri, sparql);
@@ -2197,7 +2287,8 @@ class InMemoryJsonRpcLspClient {
     }
     async updateWorkspace(params) {
         await this.ensureInitialized();
-        await this.ensureWorkspaceCurrent();
+        await this.ensureWorkspaceSettled(false);
+        const preview = params.preview === true;
         const lint = await this.lintWorkspace({});
         if (lint.errors > 0 || lint.warnings > 0) {
             return {
@@ -2208,11 +2299,125 @@ class InMemoryJsonRpcLspClient {
                 error: `lint failed with ${lint.errors} error(s) and ${lint.warnings} warning(s).`,
             };
         }
-        return await applyOmlUpdate(this.runtime.shared, params, (message) => this.logError(message));
+        const result = await applyOmlUpdate(this.runtime.shared, normalizeUpdateRequest(params), (message) => this.logError(message), pathToFileURL(this.workspaceRoot).toString(), preview);
+        const errors = Array.isArray(result?.errors) ? result.errors : [];
+        if (errors.length > 0) {
+            return result;
+        }
+        const edit = result?.edit;
+        const changedFiles = [];
+        if (edit) {
+            if (preview) {
+                changedFiles.push(...collectWorkspaceEditChangedFiles(edit));
+                const changedUris = collectWorkspaceEditReloadUris(edit);
+                if (changedUris.length > 0) {
+                    await this.runtime.shared.workspace.DocumentBuilder.update(changedUris, []);
+                    await this.waitForValidatedWithTrace();
+                }
+            }
+            else {
+                try {
+                    const deletedUriStrings = new Set((edit.documentChanges ?? [])
+                        .filter((change) => change?.kind === 'delete' && typeof change?.uri === 'string')
+                        .map((change) => String(change.uri)));
+                    changedFiles.push(...await applyWorkspaceEditToFiles(edit));
+                    if (changedFiles.length > 0) {
+                        const changedUris = changedFiles
+                            .filter((uri) => !deletedUriStrings.has(uri))
+                            .map((uri) => URI.parse(uri));
+                        const deletedUris = [...deletedUriStrings].map((uri) => URI.parse(uri));
+                        await this.runtime.shared.workspace.DocumentBuilder.update(changedUris, deletedUris);
+                        await this.waitForValidatedWithTrace();
+                        if (changedUris.length > 0) {
+                            await this.forceRevalidateUris(changedUris);
+                        }
+                        // Force one canonical workspace refresh cycle so diagnostics are computed
+                        // from the latest on-disk snapshot, not a transient intermediate version.
+                        await this.refreshWorkspaceOmlDocuments();
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    return {
+                        ...result,
+                        errors: [{ operationIndex: -1, message }],
+                        error: message,
+                    };
+                }
+            }
+        }
+        if (preview) {
+            const diagnostics = await this.lintWorkspaceStable({});
+            return {
+                ...result,
+                changedFiles,
+                diagnostics: {
+                    filesChecked: diagnostics.filesChecked,
+                    errors: diagnostics.errors,
+                    warnings: diagnostics.warnings,
+                    problems: diagnostics.problems,
+                },
+                success: true,
+                preview: true,
+            };
+        }
+        const diagnostics = await this.lintWorkspaceStable({});
+        return {
+            ...result,
+            changedFiles,
+            diagnostics: {
+                filesChecked: diagnostics.filesChecked,
+                errors: diagnostics.errors,
+                warnings: diagnostics.warnings,
+                problems: diagnostics.problems,
+            },
+            success: true,
+        };
+    }
+    lintFingerprint(lint) {
+        const problems = lint.problems
+            .map((problem) => [
+            problem.uri,
+            problem.line,
+            problem.column,
+            problem.severity,
+            problem.kind,
+            problem.source ?? '',
+            problem.code ?? '',
+            problem.message,
+        ].join('|'))
+            .join('\n');
+        return `${lint.filesChecked}|${lint.errors}|${lint.warnings}\n${problems}`;
+    }
+    async lintWorkspaceStable(params) {
+        let previous;
+        let previousFingerprint = '';
+        for (let i = 0; i < 6; i += 1) {
+            await this.waitForWatcherRefreshIdle();
+            await this.waitForValidatedWithTrace();
+            const current = await this.lintWorkspace(params);
+            const currentFingerprint = this.lintFingerprint(current);
+            if (previous && previousFingerprint === currentFingerprint) {
+                return current;
+            }
+            previous = current;
+            previousFingerprint = currentFingerprint;
+        }
+        return previous ?? await this.lintWorkspace(params);
+    }
+    async forceRevalidateUris(changedUris) {
+        const documents = this.runtime.shared.workspace.LangiumDocuments;
+        const builder = this.runtime.shared.workspace.DocumentBuilder;
+        const docs = await Promise.all(changedUris.map((uri) => documents.getOrCreateDocument(uri)));
+        if (docs.length === 0) {
+            return;
+        }
+        await builder.build(docs, { validation: true });
+        await this.waitForValidatedWithTrace();
     }
     async fuzzySearchWorkspace(params) {
         await this.ensureInitialized();
-        await this.ensureWorkspaceCurrent();
+        await this.ensureWorkspaceSettled(false);
         try {
             const text = (typeof params.text === 'string' ? params.text : '').trim();
             if (!text) {
@@ -2229,7 +2434,9 @@ class InMemoryJsonRpcLspClient {
             const candidateByIri = new Map();
             for (const doc of iterable) {
                 const root = doc?.parseResult?.value;
-                if (!root || !isOntology(root) || (!isVocabulary(root) && !isDescription(root))) {
+                const ontologyOk = !!root && isOntology(root);
+                const vocabOrDescOk = ontologyOk && (isVocabulary(root) || isDescription(root));
+                if (!vocabOrDescOk) {
                     continue;
                 }
                 modelUris.push(doc.uri.toString());
@@ -2284,7 +2491,7 @@ class InMemoryJsonRpcLspClient {
                     }
                 }
                 return {
-                    iri: entry.iri,
+                    member: entry.iri,
                     label: entry.label,
                     score: ranked.length - index,
                     diagnostics: {
@@ -2311,7 +2518,7 @@ class InMemoryJsonRpcLspClient {
     }
     async assertionsWorkspace(params) {
         await this.ensureInitialized();
-        await this.ensureWorkspaceCurrent();
+        await this.ensureWorkspaceSettled(false);
         const lint = await this.lintWorkspace({});
         if (lint.errors > 0 || lint.warnings > 0) {
             return {
@@ -2324,23 +2531,24 @@ class InMemoryJsonRpcLspClient {
                 error: `lint failed with ${lint.errors} error(s) and ${lint.warnings} warning(s).`,
             };
         }
-        const modelUriFilterRaw = typeof params.modelUri === 'string' ? params.modelUri.trim() : '';
+        const ontologyIriFilterRaw = typeof params.ontologyIri === 'string' ? params.ontologyIri.trim() : '';
         let modelUriFilter = '';
-        if (modelUriFilterRaw.length > 0) {
-            try {
-                modelUriFilter = normalizeModelUri(this.workspaceRoot, modelUriFilterRaw);
-            }
-            catch (e) {
+        if (ontologyIriFilterRaw.length > 0) {
+            const ontologyIndex = getOntologyModelIndex(this.runtime.shared);
+            const resolved = ontologyIndex.resolveModelUri(ontologyIriFilterRaw);
+            if (!resolved) {
                 return {
                     success: false,
                     files: [],
-                    error: e instanceof Error ? e.message : String(e),
+                    error: `No model found for ontology IRI '${ontologyIriFilterRaw}'.`,
                 };
             }
+            modelUriFilter = resolved;
         }
         const format = normalizeRdfSerializationFormat(params.format);
         const pretty = params.pretty === true;
         const docs = this.getWorkspaceOmlDocuments();
+        const workspacePrefixes = this.getWorkspacePrefixes();
         const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
         const store = reasoningService.getStore().getStore();
         const files = [];
@@ -2360,8 +2568,7 @@ class InMemoryJsonRpcLspClient {
             files.push({
                 modelUri,
                 ontologyIri,
-                path: resolveOutputPathFromOntologyIriString(ontologyIri, format).split(path.sep).join('/'),
-                content: await serializeQuads(quads, format, pretty),
+                content: await serializeQuads(quads, format, pretty, filterPrefixesForQuads(quads, workspacePrefixes)),
             });
         }
         files.sort((left, right) => left.ontologyIri.localeCompare(right.ontologyIri));
@@ -2373,6 +2580,7 @@ class InMemoryJsonRpcLspClient {
     async writeWorkspaceAssertedOwl(outputDir, format, pretty) {
         const entries = [];
         const docs = this.getWorkspaceOmlDocuments();
+        const workspacePrefixes = this.getWorkspacePrefixes();
         const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
         const store = reasoningService.getStore().getStore();
         for (const doc of docs) {
@@ -2387,7 +2595,7 @@ class InMemoryJsonRpcLspClient {
                 .map((quad) => 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');
+            await fs.writeFile(owlPath, await serializeQuads(quads, format, pretty, filterPrefixesForQuads(quads, workspacePrefixes)), 'utf-8');
             entries.push({ modelUri, ontologyIri, owlPath });
         }
         entries.sort((left, right) => left.ontologyIri.localeCompare(right.ontologyIri));
@@ -2398,7 +2606,8 @@ class InMemoryJsonRpcLspClient {
             workspaceRoot: this.workspaceRoot,
             runtime: this.runtime,
             ensureInitialized: () => this.ensureInitialized(),
-            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceSettled(true),
+            waitForValidated: () => this.waitForValidatedWithTrace(),
             getWorkspaceOmlDocuments: () => this.getWorkspaceOmlDocuments(),
         };
         return await validateWorkspace(context, params);
@@ -2418,7 +2627,7 @@ class InMemoryJsonRpcLspClient {
         const context = {
             workspaceRoot: this.workspaceRoot,
             ensureInitialized: () => this.ensureInitialized(),
-            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceSettled(false),
             writeWorkspaceAssertedOwl: (outputDir, format, pretty) => this.writeWorkspaceAssertedOwl(outputDir, format, pretty),
             exportAssertedWorkspace: (options) => exportAssertedWorkspace(context, options),
         };
@@ -2528,7 +2737,7 @@ class InMemoryJsonRpcLspClient {
         const context = {
             workspaceRoot: this.workspaceRoot,
             ensureInitialized: () => this.ensureInitialized(),
-            ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
+            ensureWorkspaceCurrent: () => this.ensureWorkspaceSettled(false),
             writeWorkspaceAssertedOwl: (outputDir, format, pretty) => this.writeWorkspaceAssertedOwl(outputDir, format, pretty),
             exportAssertedWorkspace: (options) => exportAssertedWorkspace(context, options),
         };
@@ -2536,7 +2745,7 @@ class InMemoryJsonRpcLspClient {
     }
     async renderWorkspace(params) {
         await this.ensureInitialized();
-        await this.ensureWorkspaceCurrent();
+        await this.ensureWorkspaceSettled(false);
         const lint = await this.lintWorkspace({});
         if (lint.errors > 0 || lint.warnings > 0) {
             return {
@@ -2554,9 +2763,7 @@ class InMemoryJsonRpcLspClient {
         const outputFromOptions = 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);
-        if (params.clean === true) {
-            await fs.rm(outputDir, { recursive: true, force: true });
-        }
+        await fs.rm(outputDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
         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)));
@@ -2603,7 +2810,7 @@ class InMemoryJsonRpcLspClient {
                 continue;
             }
             const frontMatter = extractLeadingFrontMatter(markdown);
-            const contextOntologyIri = normalizeContextOntologyIri(frontMatter?.contextOntologyIri
+            const contextOntologyIri = normalizeContextOntologyIri(frontMatter?.ontology
                 ?? frontMatterString(frontMatter?.data, 'ontologyIri')
                 ?? frontMatterString(frontMatter?.data, 'ontology'));
             const contextMemberIri = frontMatterString(frontMatter?.data, 'memberIri')
@@ -2659,16 +2866,21 @@ class InMemoryJsonRpcLspClient {
             const blockArtifacts = await writeBlockArtifacts(htmlPath, rewrittenBlockResults);
             blockArtifactFiles += blockArtifacts.count;
             const wikiLinkHrefByKey = buildWikiLinkHrefMapForPage(wikiPageIndex, htmlPath);
+            const scriptSparqlCache = contextModelUri
+                ? await buildScriptSparqlCache(prepared.codeBlocks, (sparql) => reasoningService.getSparqlService().query(contextModelUri, sparql))
+                : {};
             renderJobs.push({
                 htmlPath,
                 renderedHtml: rewriteResult.html,
                 blockManifest: blockArtifacts.manifest,
                 blockResults: rewrittenBlockResults,
                 wikiLinkHrefByKey,
+                scriptSparqlCache,
             });
             filesRendered += 1;
         }
         const renderedNavigationPages = new Set();
+        const navTasks = [];
         for (const modelUri of contextModelUris) {
             await reasoningService.ensureQueryContext(modelUri);
             const membersToTypes = await queryMemberTypes(reasoningService, modelUri);
@@ -2717,59 +2929,66 @@ class InMemoryJsonRpcLspClient {
                 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]));
-                const blockResults = executableBlocks.length === 0
-                    ? []
-                    : (await executor.executeBlocks({
-                        markdownUri: sourceDocumentUri,
-                        modelUri,
-                        blocks: executableBlocks,
-                    })).results.map((result) => ({
-                        ...result,
-                        options: optionsByBlockId.get(result.blockId),
-                    }));
-                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),
+                navTasks.push(async () => {
+                    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]));
+                    const blockResults = executableBlocks.length === 0
+                        ? []
+                        : (await executor.executeBlocks({
+                            markdownUri: sourceDocumentUri,
+                            modelUri,
+                            blocks: executableBlocks,
+                        })).results.map((result) => ({
+                            ...result,
+                            options: optionsByBlockId.get(result.blockId),
+                        }));
+                    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;
+                    const scriptSparqlCache = await buildScriptSparqlCache(prepared.codeBlocks, (sparql) => reasoningService.getSparqlService().query(modelUri, sparql));
+                    renderJobs.push({
+                        htmlPath: targetFile,
+                        renderedHtml: rewriteResult.html,
+                        blockManifest: blockArtifacts.manifest,
+                        blockResults: rewrittenBlockResults,
+                        wikiLinkHrefByKey: buildWikiLinkHrefMapForPage(wikiPageIndex, targetFile),
+                        scriptSparqlCache,
+                    });
+                    filesRendered += 1;
                 });
-                filesRendered += 1;
             }
         }
+        for (const task of navTasks) {
+            await task();
+        }
         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));
+            const html = wrapHtml(job.renderedHtml, runtimeScriptRelative, stylesheetRelative, job.blockManifest, job.blockResults, job.wikiLinkHrefByKey, buildIriAliasMapForPage(aliasesByIri, job.htmlPath), job.scriptSparqlCache);
             await fs.mkdir(path.dirname(job.htmlPath), { recursive: true });
             await fs.writeFile(job.htmlPath, html, 'utf-8');
         }
@@ -2799,35 +3018,145 @@ class InMemoryJsonRpcLspClient {
         }
         return { success: true, filesRendered, outputDir, blockArtifactFiles };
     }
-    async ensureWorkspaceCurrent() {
-        debugRest('workspace.current.begin', {
-            useExternalRuntime: this.useExternalRuntime,
-            watchWorkspace: this.watchWorkspace,
-            initialWorkspaceSyncCompleted: this.initialWorkspaceSyncCompleted,
-        });
-        if (this.useExternalRuntime) {
-            debugRest('workspace.current.skip.external');
-            return;
+    async ontologiesWorkspace() {
+        await this.ensureInitialized();
+        await this.ensureWorkspaceSettled(false);
+        return getOntologiesFromRuntime(this.runtime);
+    }
+    resolveModelUriForSparqlModelId(modelId) {
+        const ontologyIndex = getOntologyModelIndex(this.runtime.shared);
+        const docs = this.getWorkspaceOmlDocuments();
+        return resolveModelUriFromIriModelId(docs, ontologyIndex, modelId);
+    }
+    async shapesWorkspace(params) {
+        await this.ensureInitialized();
+        await this.ensureWorkspaceSettled(true);
+        const typeIri = typeof params.type === 'string' ? params.type.trim() : '';
+        if (!typeIri) {
+            return {
+                success: false,
+                error: 'Missing required parameter: type',
+            };
         }
-        if (!this.watchWorkspace) {
-            if (!this.initialWorkspaceSyncCompleted) {
-                await this.bootstrapWorkspaceOmlDocuments();
-                this.initialWorkspaceSyncCompleted = true;
-                debugRest('workspace.current.initial.bootstrap.complete');
+        try {
+            const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
+            const reasoningStoreWrapper = reasoningService.getStore();
+            const store = reasoningStoreWrapper.getStore();
+            const OML_CONTEXT_ONTOLOGY = 'http://opencaesar.io/oml#contextOntology';
+            const SH_NS = 'http://www.w3.org/ns/shacl#';
+            const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+            const shapeEntries = [];
+            // Find all markdown graph URIs
+            const markdownGraphs = new Set();
+            const contextQuads = store.getQuads(null, DataFactory.namedNode(OML_CONTEXT_ONTOLOGY), null, null);
+            for (const quad of contextQuads) {
+                if (quad.subject.termType === 'NamedNode' && quad.object.termType === 'NamedNode') {
+                    markdownGraphs.add(quad.subject.value);
+                }
             }
-            else {
-                await this.refreshWorkspaceOmlDocuments();
+            // Query each markdown graph for shapes matching the type
+            for (const graphUri of markdownGraphs) {
+                const graphNode = DataFactory.namedNode(graphUri);
+                const ontologyQuad = store.getQuads(DataFactory.namedNode(graphUri), DataFactory.namedNode(OML_CONTEXT_ONTOLOGY), null, null)[0];
+                if (!ontologyQuad || ontologyQuad.object.termType !== 'NamedNode') {
+                    continue;
+                }
+                const ontologyIri = ontologyQuad.object.value;
+                // Find NodeShapes in this graph
+                const nodeShapeQuads = store.getQuads(null, DataFactory.namedNode(RDF_TYPE), DataFactory.namedNode(`${SH_NS}NodeShape`), graphNode);
+                for (const shapeQuad of nodeShapeQuads) {
+                    if (shapeQuad.subject.termType !== 'NamedNode') {
+                        continue;
+                    }
+                    const shapeIri = shapeQuad.subject.value;
+                    // Check if this shape targets our type (sh:targetClass)
+                    const targetClassQuads = store.getQuads(shapeQuad.subject, DataFactory.namedNode(`${SH_NS}targetClass`), DataFactory.namedNode(typeIri), graphNode);
+                    if (targetClassQuads.length > 0) {
+                        shapeEntries.push({ ontology: ontologyIri, shape: shapeIri, graphUri });
+                        continue;
+                    }
+                    // Check if any property shape has sh:class matching our type
+                    const propertyQuads = store.getQuads(shapeQuad.subject, DataFactory.namedNode(`${SH_NS}property`), null, graphNode);
+                    for (const propQuad of propertyQuads) {
+                        if (propQuad.object.termType === 'NamedNode' || propQuad.object.termType === 'BlankNode') {
+                            const classQuads = store.getQuads(propQuad.object, DataFactory.namedNode(`${SH_NS}class`), DataFactory.namedNode(typeIri), graphNode);
+                            if (classQuads.length > 0) {
+                                shapeEntries.push({ ontology: ontologyIri, shape: shapeIri, graphUri });
+                                break;
+                            }
+                        }
+                    }
+                }
             }
-            debugRest('workspace.current.refreshed.nowatch');
-            return;
+            // Helper to collect all axioms for a shape (including blank nodes)
+            const collectShapeAxioms = (shapeIri, graphUri) => {
+                const graphNode = DataFactory.namedNode(graphUri);
+                const visited = new Set();
+                const axioms = [];
+                const writer = new Writer({ format: 'N-Triples' });
+                const collectNode = (node) => {
+                    const nodeKey = node.termType === 'BlankNode' ? `_:${node.value}` : node.value;
+                    if (visited.has(nodeKey))
+                        return;
+                    visited.add(nodeKey);
+                    const quads = store.getQuads(node, null, null, graphNode);
+                    for (const quad of quads) {
+                        // Convert quad to triple (without graph)
+                        writer.addQuad(DataFactory.quad(quad.subject, quad.predicate, quad.object));
+                        // If object is a blank node, recursively collect its triples
+                        if (quad.object.termType === 'BlankNode') {
+                            collectNode(quad.object);
+                        }
+                    }
+                };
+                collectNode(DataFactory.namedNode(shapeIri));
+                // Get serialized triples
+                writer.end((error, result) => {
+                    if (!error && result) {
+                        const lines = result.trim().split('\n').filter((line) => line.trim().length > 0);
+                        axioms.push(...lines);
+                    }
+                });
+                return axioms;
+            };
+            // Group by ontology and collect axioms
+            const grouped = new Map();
+            for (const entry of shapeEntries) {
+                const axioms = collectShapeAxioms(entry.shape, entry.graphUri);
+                const shapes = grouped.get(entry.ontology) ?? [];
+                shapes.push({ shape: entry.shape, axioms });
+                grouped.set(entry.ontology, shapes);
+            }
+            const results = Array.from(grouped.entries())
+                .map(([ontology, shapes]) => ({
+                ontology,
+                shapes: shapes.sort((a, b) => a.shape.localeCompare(b.shape)),
+            }))
+                .sort((a, b) => a.ontology.localeCompare(b.ontology));
+            return {
+                success: true,
+                results,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
         }
+    }
+    async ensureWorkspaceSettled(includeShacl) {
         if (!this.initialWorkspaceSyncCompleted) {
             await this.bootstrapWorkspaceOmlDocuments();
             this.initialWorkspaceSyncCompleted = true;
-            debugRest('workspace.current.initial.bootstrap.complete');
         }
         await this.waitForWatcherRefreshIdle();
-        debugRest('workspace.current.end');
+        if (this.useExternalRuntime) {
+            await this.waitForValidatedWithTrace();
+        }
+        if (includeShacl) {
+            await this.reindexWorkspaceShacl();
+        }
     }
     async waitForWatcherRefreshIdle() {
         while (this.watcherFlushTimer !== undefined || this.refreshInFlight || this.refreshQueued) {
@@ -2855,18 +3184,10 @@ class InMemoryJsonRpcLspClient {
         const deletedUris = [...currentOmlUris]
             .filter((uri) => !changedUriStrings.has(uri))
             .map((uri) => URI.parse(uri));
-        debugRest('workspace.refresh.plan', {
-            workspaceRoot,
-            changed: changedUris.length,
-            deleted: deletedUris.length,
-            current: currentOmlUris.size,
-        });
         await Promise.all(changedUris.map((uri) => documents.getOrCreateDocument(uri)));
         const builder = this.runtime.shared.workspace.DocumentBuilder;
         await builder.update(changedUris, deletedUris);
-        await this.waitForValidatedWithTrace('refresh', changedUriStrings);
-        const postDocs = this.getWorkspaceOmlDocuments();
-        debugRest('workspace.refresh.done', { docsAfter: postDocs.length });
+        await this.waitForValidatedWithTrace();
     }
     async bootstrapWorkspaceOmlDocuments() {
         const workspaceRoot = path.resolve(this.workspaceRoot);
@@ -2874,38 +3195,32 @@ class InMemoryJsonRpcLspClient {
         const documents = this.runtime.shared.workspace.LangiumDocuments;
         const builder = this.runtime.shared.workspace.DocumentBuilder;
         const docs = await Promise.all(omlFiles.map(async (filePath) => documents.getOrCreateDocument(URI.parse(pathToFileURL(filePath).toString()))));
-        debugRest('workspace.bootstrap.plan', {
-            workspaceRoot,
-            files: docs.length,
-        });
         if (docs.length > 0) {
             await builder.build(docs, { validation: true });
-            await this.waitForValidatedWithTrace('bootstrap', new Set(docs.map((doc) => String(doc?.uri ?? '').trim())));
+            await this.waitForValidatedWithTrace();
         }
-        const postDocs = this.getWorkspaceOmlDocuments();
-        debugRest('workspace.bootstrap.done', { docsAfter: postDocs.length });
+    }
+    async reindexWorkspaceShacl() {
+        await reindexWorkspaceShacl({
+            workspaceRoot: this.workspaceRoot,
+            runtime: this.runtime,
+        });
     }
     async ensureInitialized() {
         if (this.initPromise) {
-            debugRest('initialize.await.existing');
             await this.initPromise;
             return;
         }
         if (this.useExternalRuntime) {
             this.initPromise = (async () => {
-                const begin = Date.now();
-                debugRest('initialize.external.begin');
                 const workspace = this.runtime.shared.workspace.WorkspaceManager;
                 await workspace.ready;
-                debugRest('initialize.external.ready', { elapsedMs: Math.max(0, Date.now() - begin) });
             })();
         }
         else {
             const rootPath = path.resolve(this.workspaceRoot);
             const rootUri = pathToFileURL(rootPath).toString();
             this.initPromise = (async () => {
-                const begin = Date.now();
-                debugRest('initialize.internal.begin', { rootPath, rootUri });
                 await withTimeout(this.clientConnection.sendRequest('initialize', {
                     processId: process.pid,
                     rootUri,
@@ -2919,14 +3234,13 @@ class InMemoryJsonRpcLspClient {
                 // before lint/query calls trigger document refresh and diagnostics.
                 const workspace = this.runtime.shared.workspace.WorkspaceManager;
                 await workspace.ready;
-                debugRest('initialize.internal.ready', { elapsedMs: Math.max(0, Date.now() - begin) });
             })();
         }
         await this.initPromise;
     }
 }
 export async function runOmlWorkspaceLocalOperation(options) {
-    const client = new InMemoryJsonRpcLspClient(options.workspaceRoot ? path.resolve(options.workspaceRoot) : process.cwd(), options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS, options.watchWorkspace === true, options.runtime);
+    const client = new InMemoryJsonRpcLspClient(options.workspaceRoot ? path.resolve(options.workspaceRoot) : process.cwd(), options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS, options.runtime);
     try {
         const params = options.params ?? {};
         switch (options.operation) {
@@ -2950,16 +3264,7 @@ export async function runOmlWorkspaceLocalOperation(options) {
 }
 export async function startOmlRestServer(options) {
     const workspaceRoot = options.workspaceRoot ? path.resolve(options.workspaceRoot) : process.cwd();
-    debugRest('rest.start.options', {
-        host: options.host,
-        requestedPort: options.port,
-        workspaceRoot,
-        watchWorkspace: options.watchWorkspace === true,
-        hasRuntime: options.runtime !== undefined,
-        hasAuthToken: Boolean(options.authToken),
-        hasFeatureGate: Boolean(options.featureGate),
-    });
-    const client = new InMemoryJsonRpcLspClient(workspaceRoot, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS, options.watchWorkspace === true, options.runtime);
+    const client = new InMemoryJsonRpcLspClient(workspaceRoot, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS, options.runtime);
     let openApiSpec = createOpenApiSpec(options.host, options.port);
     let currentAccessToken = options.authToken;
     const featureGate = options.featureGate;
@@ -2972,17 +3277,6 @@ export async function startOmlRestServer(options) {
         const requestId = randomUUID();
         const method = req.method ?? 'GET';
         const rawUrl = req.url ?? '/';
-        const requestStartedAt = Date.now();
-        debugRest('request.begin', { requestId, method, rawUrl });
-        res.once('finish', () => {
-            debugRest('request.end', {
-                requestId,
-                method,
-                rawUrl,
-                statusCode: res.statusCode,
-                elapsedMs: Math.max(0, Date.now() - requestStartedAt),
-            });
-        });
         try {
             const parsed = new URL(rawUrl, `http://${req.headers.host ?? 'localhost'}`);
             const pathname = parsed.pathname;
@@ -3029,20 +3323,22 @@ export async function startOmlRestServer(options) {
                 return;
             }
             if (method === 'GET' && pathname === '/v0/workspace') {
+                const ontologies = await client.ontologiesWorkspace();
+                const allImported = new Set(ontologies.flatMap((o) => o.imports));
+                const roots = ontologies
+                    .filter((o) => !allImported.has(o.ontology))
+                    .map((o) => o.ontology);
                 jsonResponse(res, 200, {
-                    workspaceRoot,
                     workspaceUri: pathToFileURL(workspaceRoot).toString(),
+                    roots,
                     requestId,
                 });
                 return;
             }
-            if (method === 'GET' && pathname === '/v0/models') {
-                const requiredFeature = requiredFeatureForRestOperation('models');
-                const workspaceModelFiles = (featureGate && requiredFeature)
-                    ? await featureGate.runWithFeature(requiredFeature, () => listWorkspaceModelFiles(workspaceRoot), { transport: 'rest', operationId: 'models' })
-                    : await listWorkspaceModelFiles(workspaceRoot);
+            if (method === 'GET' && pathname === '/v0/ontologies') {
+                const ontologies = await client.ontologiesWorkspace();
                 jsonResponse(res, 200, {
-                    files: workspaceModelFiles,
+                    ontologies,
                     requestId,
                 });
                 return;
@@ -3053,13 +3349,7 @@ export async function startOmlRestServer(options) {
                     if (!routeModelPath) {
                         throw new RestHttpError(404, `No route for ${method} ${pathname}.`);
                     }
-                    const modelUri = resolveModelUriFromRouteModelPath(workspaceRoot, routeModelPath);
-                    try {
-                        await assertModelUriExists(modelUri);
-                    }
-                    catch {
-                        throw new RestHttpError(404, `No OML model found for '${routeModelPath}'.`);
-                    }
+                    const modelUri = client.resolveModelUriForSparqlModelId(routeModelPath);
                     const bodyText = method === 'POST' ? await readTextBody(req) : '';
                     const sparql = parseSparqlQueryFromRequest(req, parsed, bodyText);
                     if (!sparql) {
@@ -3087,7 +3377,7 @@ export async function startOmlRestServer(options) {
                     if (!graphFormat) {
                         throw new RestHttpError(406, 'Not Acceptable for graph results.');
                     }
-                    const serialized = await serializeQuads(queryResult.result.quads, graphFormat.format, false);
+                    const serialized = await serializeQuads(queryResult.result.quads, graphFormat.format, false, filterPrefixesForQuads(queryResult.result.quads, client.getWorkspacePrefixes()));
                     textResponse(res, 200, graphFormat.contentType, serialized);
                 };
                 const requiredFeature = requiredFeatureForRestOperation('query');
@@ -3120,7 +3410,6 @@ export async function startOmlRestServer(options) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            debugRest('request.error', { requestId, method, rawUrl, message });
             if (error instanceof OmlAccessError) {
                 jsonResponse(res, error.statusCode, accessErrorPayload(error, requestId));
                 return;
@@ -3143,18 +3432,15 @@ export async function startOmlRestServer(options) {
         server.listen(options.port, options.host, () => resolve());
     });
     const listeningPort = resolveListeningPort(server);
-    debugRest('rest.start.listening', { host: options.host, requestedPort: options.port, listeningPort });
     openApiSpec = createOpenApiSpec(options.host, listeningPort);
     return {
         server,
         updateToken: async (token) => {
-            debugRest('token.update.begin', { tokenProvided: Boolean(token) });
             currentAccessToken = token;
             featureGate?.setAccessToken(token);
             if (featureGate) {
                 await featureGate.primeEntitlements();
             }
-            debugRest('token.update.end');
         },
     };
 }