@oml/server 0.14.0 → 0.14.2

package/{src/rest/server.ts → out/rest/server.js}

@@ -1,5 +1,4 @@
 // 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';
@@ -10,57 +9,24 @@ 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 { createConnection } 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 { 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,
-    type OmlEditRequest,
-    type OmlEditResponse,
-    type OmlFuzzyIndexedEntry,
-} from '@oml/language';
+import { applyOmlUpdate, collectOntologyMembers, getIriForNode, getOntologyModelIndex, iriFragment, isDescription, isOntology, isVocabulary, tokenizeForFuzzy, } 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';
-
+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, reasonWorkspace, validateWorkspace } from './validation.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 = 30_000;
-
-const SUPPORTED_MD_BLOCK_KINDS = new Set<MdBlockKind>([
+const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+const SUPPORTED_MD_BLOCK_KINDS = new Set([
     'table',
     'tree',
     'graph',
@@ -71,22 +37,6 @@ const SUPPORTED_MD_BLOCK_KINDS = new Set<MdBlockKind>([
     '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',
@@ -95,37 +45,31 @@ const BUILT_IN_ONTOLOGIES = new Set([
     'http://www.w3.org/2003/11/swrl',
     'http://www.w3.org/2003/11/swrlb',
 ]);
-
-
-function jsonResponse(res: http.ServerResponse, status: number, payload: unknown): void {
+function jsonResponse(res, status, payload) {
     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 htmlResponse(res, status, body) {
+    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;');
+function escapeHtml(value) {
+    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[] = [];
+async function listWorkspaceModelFiles(workspaceRoot) {
+    const entries = [];
     const ignoredNames = new Set(['.git', 'node_modules', 'dist', 'build', 'out']);
-
-    const visit = async (currentDir: string): Promise<void> => {
+    const visit = async (currentDir) => {
         const children = await fs.readdir(currentDir, { withFileTypes: true });
         for (const child of children) {
             const childPath = path.join(currentDir, child.name);
@@ -146,13 +90,11 @@ async function listWorkspaceModelFiles(workspaceRoot: string): Promise<Workspace
             });
         }
     };
-
     await visit(workspaceRoot);
     entries.sort((left, right) => left.path.localeCompare(right.path));
     return entries;
 }
-
-function createSparqlWorkbenchPage(defaultWorkspaceRoot: string): string {
+function createSparqlWorkbenchPage(defaultWorkspaceRoot) {
     const escapedWorkspaceRoot = escapeHtml(defaultWorkspaceRoot);
     return `<!DOCTYPE html>
 <html lang="en">
@@ -991,9 +933,8 @@ LIMIT 25</textarea>
 </body>
 </html>`;
 }
-
-async function readJsonBody(req: http.IncomingMessage): Promise<Record<string, unknown>> {
-    const chunks: Buffer[] = [];
+async function readJsonBody(req) {
+    const chunks = [];
     let total = 0;
     for await (const chunk of req) {
         const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -1007,36 +948,30 @@ async function readJsonBody(req: http.IncomingMessage): Promise<Record<string, u
         return {};
     }
     const parsed = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
-    return typeof parsed === 'object' && parsed !== null ? parsed as Record<string, unknown> : {};
+    return typeof parsed === 'object' && parsed !== null ? parsed : {};
 }
-
-function withTimeout<T>(promise: Promise<T>, timeoutMs: number, method: string): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
+function withTimeout(promise, timeoutMs, method) {
+    return new Promise((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);
-            },
-        );
+        void promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
     });
 }
-
-function normalizeOntologyNamespace(value: string | undefined): string | undefined {
+function normalizeOntologyNamespace(value) {
     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 {
+function resolveOutputPathFromOntologyIriString(ontologyIri, format) {
     const iri = new URL(ontologyIri);
     const rawPath = iri.pathname.replace(/\/+$/, '');
     const pathSegments = rawPath.split('/').filter(Boolean);
@@ -1046,12 +981,7 @@ function resolveOutputPathFromOntologyIriString(ontologyIri: string, format: 'tt
         : 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> {
+async function serializeQuads(quads, format, pretty = false) {
     const writer = new Writer({
         format: format === 'ttl'
             ? 'text/turtle'
@@ -1062,7 +992,7 @@ async function serializeQuads(
                     : (format === 'nq' ? 'N-Quads' : 'application/n3'))),
     });
     writer.addQuads(quads);
-    const serialized = await new Promise<string>((resolve, reject) => {
+    const serialized = await new Promise((resolve, reject) => {
         writer.end((error, result) => {
             if (error) {
                 reject(error);
@@ -1073,13 +1003,12 @@ async function serializeQuads(
     });
     return pretty ? prettyPrintRdf(serialized, format) : serialized;
 }
-
-function prettyPrintRdf(serialized: string, format: 'ttl' | 'trig' | 'nt' | 'nq' | 'n3'): string {
+function prettyPrintRdf(serialized, format) {
     if (format !== 'ttl' && format !== 'trig') {
         return serialized;
     }
     const lines = serialized.split('\n');
-    const out: string[] = [];
+    const out = [];
     for (let i = 0; i < lines.length; i += 1) {
         const line = lines[i];
         out.push(line);
@@ -1092,19 +1021,8 @@ function prettyPrintRdf(serialized: string, format: 'ttl' | 'trig' | 'nt' | 'nq'
     }
     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;
-    }> = {};
+function toSparqlRowDto(row) {
+    const result = {};
     for (const [key, term] of row.entries()) {
         if (!term) {
             continue;
@@ -1118,29 +1036,14 @@ function toSparqlRowDto(row: Map<string, any>): Record<string, {
     }
     return result;
 }
-
-function isRecord(value: unknown): value is Record<string, unknown> {
+function isRecord(value) {
     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 toMdBlockKind(language) {
+    return SUPPORTED_MD_BLOCK_KINDS.has(language) ? language : 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[] = [];
+function toExecutableBlocks(codeBlocks) {
+    const executable = [];
     for (const block of codeBlocks) {
         const kind = toMdBlockKind(block.language);
         if (!kind) {
@@ -1158,8 +1061,7 @@ function toExecutableBlocks(codeBlocks: ReadonlyArray<{
     }
     return executable;
 }
-
-function splitHref(href: string): { path: string; query: string; fragment: string } {
+function splitHref(href) {
     const hashIndex = href.indexOf('#');
     const pathAndQuery = hashIndex >= 0 ? href.slice(0, hashIndex) : href;
     const fragment = hashIndex >= 0 ? href.slice(hashIndex) : '';
@@ -1170,8 +1072,7 @@ function splitHref(href: string): { path: string; query: string; fragment: strin
         fragment
     };
 }
-
-function resolveWorkspacePath(workspaceRoot: string, hrefPath: string): string | undefined {
+function resolveWorkspacePath(workspaceRoot, hrefPath) {
     const relative = hrefPath.slice('workspace:/'.length).replace(/^\/+/, '');
     const resolved = path.resolve(workspaceRoot, relative);
     const relativeToWorkspace = path.relative(workspaceRoot, resolved);
@@ -1180,27 +1081,17 @@ function resolveWorkspacePath(workspaceRoot: string, hrefPath: string): string |
     }
     return resolved;
 }
-
-function toRelativeWebPath(fromDir: string, toFile: string): string {
+function toRelativeWebPath(fromDir, toFile) {
     const relative = path.relative(fromDir, toFile).split(path.sep).join('/');
     if (!relative || relative === '.') {
         return '.';
     }
     return relative.startsWith('.') ? relative : `./${relative}`;
 }
-
-function isImagePath(filePath: string): boolean {
+function isImagePath(filePath) {
     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 {
+function resolveAssetTargetPath(resolvedFile, context) {
     const workspaceRelative = path.relative(context.workspaceRoot, resolvedFile);
     const markdownRelative = path.relative(context.inputRoot, resolvedFile);
     const isInsideMarkdownRoot = !markdownRelative.startsWith('..') && !path.isAbsolute(markdownRelative);
@@ -1211,18 +1102,7 @@ function resolveAssetTargetPath(
     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 {
+function rewriteHref(href, context, workspaceAssets) {
     const parts = splitHref(href);
     if (!parts.path) {
         return href;
@@ -1240,10 +1120,7 @@ function rewriteHref(
             workspaceAssets.add(resolved);
         }
         const targetInOutput = resolved.toLowerCase().endsWith('.md')
-            ? path.join(
-                context.outputRoot,
-                path.relative(context.inputRoot, resolved).replace(/\.md$/i, '.html')
-            )
+            ? 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}`;
@@ -1259,10 +1136,7 @@ function rewriteHref(
                 workspaceAssets.add(resolved);
             }
             const targetInOutput = resolved.toLowerCase().endsWith('.md')
-                ? path.join(
-                    context.outputRoot,
-                    path.relative(context.inputRoot, resolved).replace(/\.md$/i, '.html')
-                )
+                ? 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}`;
@@ -1273,38 +1147,15 @@ function rewriteHref(
         : 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) => {
+function rewriteRenderedLinks(content, context) {
+    const workspaceAssets = new Set();
+    const html = content.replace(/(\b(?:href|src)\s*=\s*)(["'])([^"']+)\2/gi, (_match, prefix, quote, rawHref) => {
         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 } {
+function rewriteAssetReference(rawValue, context) {
     const trimmed = rawValue.trim();
     if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('data:') || trimmed.startsWith('//')) {
         return { rewritten: rawValue };
@@ -1312,16 +1163,18 @@ function rewriteAssetReference(
     if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed) && !trimmed.startsWith('workspace:/')) {
         return { rewritten: rawValue };
     }
-    let resolved: string | undefined;
+    let resolved;
     if (trimmed.startsWith('workspace:/')) {
         resolved = resolveWorkspacePath(context.workspaceRoot, trimmed);
-    } else if (trimmed.startsWith('/')) {
+    }
+    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 {
+    }
+    else {
         const candidate = path.resolve(path.dirname(context.sourceFile), trimmed);
         const relative = path.relative(context.workspaceRoot, candidate);
         if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
@@ -1341,18 +1194,7 @@ function rewriteAssetReference(
         sourceAsset: resolved,
     };
 }
-
-function rewriteBlockResultAssetPaths(
-    result: RenderedBlockResult,
-    context: {
-        workspaceRoot: string;
-        inputRoot: string;
-        sourceFile: string;
-        outputRoot: string;
-        outputFile: string;
-    },
-    workspaceAssets: Set<string>,
-): RenderedBlockResult {
+function rewriteBlockResultAssetPaths(result, context, workspaceAssets) {
     if (!result.options || result.kind !== 'diagram') {
         return result;
     }
@@ -1366,7 +1208,7 @@ function rewriteBlockResultAssetPaths(
             return entry;
         }
         let entryChanged = false;
-        const icon = { ...entry.style.icon } as Record<string, unknown>;
+        const icon = { ...entry.style.icon };
         for (const key of ['href', 'xlinkHref', 'xlink:href']) {
             const value = icon[key];
             if (typeof value !== 'string') {
@@ -1404,26 +1246,21 @@ function rewriteBlockResultAssetPaths(
         },
     };
 }
-
-function sanitizeBlockId(value: string): string {
+function sanitizeBlockId(value) {
     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 }>;
-}> {
+async function writeBlockArtifacts(outputFile, results) {
     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 }> = [];
+    const manifest = [];
     for (const result of results) {
         const safeId = sanitizeBlockId(result.blockId);
         const fileName = `${safeId}.json`;
@@ -1436,33 +1273,29 @@ async function writeBlockArtifacts(outputFile: string, results: ReadonlyArray<Re
     }
     return { count: results.length, manifest };
 }
-
-async function loadStaticRuntimeBundle(): Promise<string> {
+async function loadStaticRuntimeBundle() {
     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 {
+    }
+    catch {
         throw new Error(`Unable to load markdown static runtime bundle at '${bundlePath}'.`);
     }
 }
-
-async function loadCodeBlockStylesheet(): Promise<string> {
+async function loadCodeBlockStylesheet() {
     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 {
+    }
+    catch {
         throw new Error(`Unable to load markdown webview stylesheet at '${stylesheetPath}'.`);
     }
 }
-
-async function writeStaticAssets(outputRoot: string): Promise<{
-    runtimeScriptFile: string;
-    stylesheetFile: string;
-}> {
+async function writeStaticAssets(outputRoot) {
     const runtimeBundle = await loadStaticRuntimeBundle();
     const sourceStylesheet = await loadCodeBlockStylesheet();
     const mergedStylesheet = `${sourceStylesheet}\n\n${STATIC_MARKDOWN_RUNTIME_CSS}\n`;
@@ -1475,8 +1308,7 @@ async function writeStaticAssets(outputRoot: string): Promise<{
     await fs.writeFile(stylesheetFile, mergedStylesheet, 'utf-8');
     return { runtimeScriptFile: runtimeFile, stylesheetFile };
 }
-
-function escapeAttribute(value: string): string {
+function escapeAttribute(value) {
     return value
         .replace(/&/g, '&amp;')
         .replace(/</g, '&lt;')
@@ -1484,12 +1316,10 @@ function escapeAttribute(value: string): string {
         .replace(/"/g, '&quot;')
         .replace(/'/g, '&#39;');
 }
-
-function escapeJsonForScript(value: string): string {
+function escapeJsonForScript(value) {
     return value.replace(/</g, '\\u003c');
 }
-
-function normalizeWikiPathKey(raw: string): string {
+function normalizeWikiPathKey(raw) {
     const normalized = raw.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+/g, '/');
     if (!normalized) {
         return '';
@@ -1497,9 +1327,8 @@ function normalizeWikiPathKey(raw: string): string {
     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>();
+function buildWikiPageIndex(markdownFiles, inputRoot, outputRoot) {
+    const index = new Map();
     for (const markdownFile of markdownFiles) {
         const relativeInput = path.relative(inputRoot, markdownFile).split(path.sep).join('/');
         const normalizedRelative = normalizeWikiPathKey(relativeInput.replace(/\.md$/i, ''));
@@ -1511,23 +1340,17 @@ function buildWikiPageIndex(markdownFiles: ReadonlyArray<string>, inputRoot: str
     }
     return index;
 }
-
-function buildWikiLinkHrefMapForPage(
-    wikiPageIndex: ReadonlyMap<string, string>,
-    outputFile: string
-): Record<string, string> {
-    const map: Record<string, string> = {};
+function buildWikiLinkHrefMapForPage(wikiPageIndex, outputFile) {
+    const map = {};
     for (const [key, targetFile] of wikiPageIndex.entries()) {
         map[key] = toRelativeWebPath(path.dirname(outputFile), targetFile);
     }
     return map;
 }
-
-function normalizeIri(value: string): string {
+function normalizeIri(value) {
     return value.trim().replace(/^<|>$/g, '');
 }
-
-function inferOntologyIriFromMemberIri(memberIri: string): string | undefined {
+function inferOntologyIriFromMemberIri(memberIri) {
     const normalized = normalizeIri(memberIri);
     if (!normalized) {
         return undefined;
@@ -1543,13 +1366,13 @@ function inferOntologyIriFromMemberIri(memberIri: string): string | undefined {
     }
     return normalized.replace(/[\/#]+$/, '');
 }
-
-function memberIriToOutputFile(outputRoot: string, memberIri: string): string | undefined {
+function memberIriToOutputFile(outputRoot, memberIri) {
     const normalized = normalizeIri(memberIri);
-    let parsed: URL;
+    let parsed;
     try {
         parsed = new URL(normalized);
-    } catch {
+    }
+    catch {
         return undefined;
     }
     const host = (parsed.hostname || '').trim().toLowerCase();
@@ -1569,11 +1392,7 @@ function memberIriToOutputFile(outputRoot: string, memberIri: string): string |
         : 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[]>> {
+async function queryMemberTypes(reasoningService, modelUri) {
     const queryResult = await reasoningService.getSparqlService().query(modelUri, `
         PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
         SELECT DISTINCT ?member ?type
@@ -1585,44 +1404,29 @@ async function queryMemberTypes(
         }
     `);
     if (!queryResult?.success || !Array.isArray(queryResult.rows)) {
-        return new Map<string, string[]>();
+        return new Map();
     }
-    const byMember = new Map<string, Set<string>>();
-    for (const row of queryResult.rows as Array<Map<string, { value: string } | undefined>>) {
+    const byMember = new Map();
+    for (const row of queryResult.rows) {
         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>();
+        const existing = byMember.get(member) ?? new Set();
         existing.add(type);
         byMember.set(member, existing);
     }
-    return new Map<string, string[]>(
-        Array.from(byMember.entries()).map(([member, types]) => [member, Array.from(types)])
-    );
+    return new Map(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> = {};
+function buildIriAliasMapForPage(aliasesByIri, outputFile) {
+    const aliases = {};
     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 {
+function wrapHtml(content, runtimeScriptPath, stylesheetPath, blockManifest, blockResults, wikiLinkHrefByKey, iriAliasByIri) {
     const escapedManifest = escapeJsonForScript(JSON.stringify(blockManifest));
     const inlineResults = Object.fromEntries(blockResults.map((result) => [result.blockId, result]));
     const escapedInlineResults = escapeJsonForScript(JSON.stringify(inlineResults));
@@ -1650,33 +1454,21 @@ ${content}
 </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) {
+    constructor(workspaceRoot, requestTimeoutMs, watchWorkspace, runtime) {
+        this.watchers = new Set();
+        this.watcherActive = false;
+        this.refreshInFlight = false;
+        this.refreshQueued = false;
+        this.initialWorkspaceSyncCompleted = false;
         this.workspaceRoot = workspaceRoot;
         this.requestTimeoutMs = requestTimeoutMs;
         this.useExternalRuntime = runtime !== undefined;
         this.watchWorkspace = runtime ? false : watchWorkspace;
         if (runtime) {
             this.runtime = runtime;
-        } else {
+        }
+        else {
             this.clientToServer = new PassThrough();
             this.serverToClient = new PassThrough();
             this.serverConnection = createConnection(this.clientToServer, this.serverToClient);
@@ -1693,20 +1485,18 @@ class InMemoryJsonRpcLspClient {
             this.startWorkspaceWatcher();
         }
     }
-
-    private getWorkspaceOmlDocuments(): any[] {
+    getWorkspaceOmlDocuments() {
         const documents = this.runtime.shared.workspace.LangiumDocuments;
         const allDocs = documents.all ?? [];
-        const iterable: any[] = Array.isArray(allDocs)
+        const iterable = Array.isArray(allDocs)
             ? allDocs
-            : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs as Iterable<any>));
+            : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs));
         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 = {
+    async lintWorkspace(params = {}) {
+        const context = {
             workspaceRoot: this.workspaceRoot,
             runtime: this.runtime,
             ensureInitialized: () => this.ensureInitialized(),
@@ -1716,8 +1506,7 @@ class InMemoryJsonRpcLspClient {
         };
         return await lintWorkspace(context, params);
     }
-
-    async queryWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+    async queryWorkspace(params) {
         await this.ensureInitialized();
         await this.ensureWorkspaceCurrent();
         const modelUri = typeof params.modelUri === 'string' ? params.modelUri.trim() : '';
@@ -1731,7 +1520,7 @@ class InMemoryJsonRpcLspClient {
             };
         }
         try {
-            const reasoningService = this.runtime.Oml.reasoning.ReasoningService as any;
+            const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
             const kind = detectSparqlKind(sparql);
             await reasoningService.ensureQueryContext(modelUri);
             const sparqlService = reasoningService.getSparqlService();
@@ -1741,7 +1530,7 @@ class InMemoryJsonRpcLspClient {
                     success: result.success,
                     kind,
                     warnings: result.warnings ?? [],
-                    rows: result.rows.map((row: Map<string, any>) => toSparqlRowDto(row)),
+                    rows: result.rows.map((row) => toSparqlRowDto(row)),
                     error: result.error,
                 };
             }
@@ -1761,7 +1550,7 @@ class InMemoryJsonRpcLspClient {
                     success: result.success,
                     kind,
                     warnings: result.warnings ?? [],
-                    quads: result.quads.map((quad: any) => ({
+                    quads: result.quads.map((quad) => ({
                         subject: quad.subject.value,
                         predicate: quad.predicate.value,
                         object: quad.object.value,
@@ -1776,7 +1565,8 @@ class InMemoryJsonRpcLspClient {
                 warnings: [],
                 error: 'Unsupported or unknown SPARQL query kind.',
             };
-        } catch (error) {
+        }
+        catch (error) {
             return {
                 success: false,
                 kind: detectSparqlKind(sparql),
@@ -1785,18 +1575,12 @@ class InMemoryJsonRpcLspClient {
             };
         }
     }
-
-    async updateWorkspace(params: Record<string, unknown>): Promise<OmlEditResponse> {
+    async updateWorkspace(params) {
         await this.ensureInitialized();
         await this.ensureWorkspaceCurrent();
-        return await applyOmlUpdate(
-            this.runtime.shared,
-            params as OmlEditRequest,
-            (message) => this.logError(message),
-        );
+        return await applyOmlUpdate(this.runtime.shared, params, (message) => this.logError(message));
     }
-
-    async fuzzySearchWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+    async fuzzySearchWorkspace(params) {
         await this.ensureInitialized();
         await this.ensureWorkspaceCurrent();
         try {
@@ -1805,14 +1589,14 @@ class InMemoryJsonRpcLspClient {
                 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 ontologyIndex = getOntologyModelIndex(this.runtime.shared);
+            const langiumDocuments = this.runtime.shared.workspace.LangiumDocuments;
             const allDocs = langiumDocuments.all ?? [];
-            const iterable: any[] = Array.isArray(allDocs)
+            const iterable = 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 }>();
+                : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs));
+            const modelUris = [];
+            const candidateByIri = new Map();
             for (const doc of iterable) {
                 const root = doc?.parseResult?.value;
                 if (!root || !isOntology(root) || (!isVocabulary(root) && !isDescription(root))) {
@@ -1833,8 +1617,7 @@ class InMemoryJsonRpcLspClient {
                 entry.label = label;
                 candidateByIri.set(iri, entry);
             }
-
-            const indexedEntries: OmlFuzzyIndexedEntry[] = [...candidateByIri.values()].map((entry) => ({
+            const indexedEntries = [...candidateByIri.values()].map((entry) => ({
                 iri: entry.iri,
                 label: entry.label,
                 fragment: iriFragment(entry.iri),
@@ -1850,11 +1633,11 @@ class InMemoryJsonRpcLspClient {
             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]!)
+                .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 entry = indexedEntries[entryIndex];
                 const fragment = entry.fragment.toLowerCase();
                 const lowerLabel = (entry.label ?? '').toLowerCase();
                 const lowerInput = text.toLowerCase();
@@ -1887,7 +1670,8 @@ class InMemoryJsonRpcLspClient {
                 };
             });
             return { success: true, candidates };
-        } catch (error) {
+        }
+        catch (error) {
             return {
                 success: false,
                 candidates: [],
@@ -1895,26 +1679,21 @@ class InMemoryJsonRpcLspClient {
             };
         }
     }
-
-    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 }> = [];
+    async writeWorkspaceAssertedOwl(outputDir, format, pretty) {
+        const entries = [];
         const docs = this.getWorkspaceOmlDocuments();
-        const reasoningService = this.runtime.Oml.reasoning.ReasoningService as any;
+        const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
         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 root = doc?.parseResult?.value;
             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));
+                .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');
@@ -1923,9 +1702,8 @@ class InMemoryJsonRpcLspClient {
         entries.sort((left, right) => left.ontologyIri.localeCompare(right.ontologyIri));
         return entries;
     }
-
-    async reasonWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
-        const context: RestValidationContext = {
+    async reasonWorkspace(params) {
+        const context = {
             workspaceRoot: this.workspaceRoot,
             runtime: this.runtime,
             ensureInitialized: () => this.ensureInitialized(),
@@ -1935,9 +1713,8 @@ class InMemoryJsonRpcLspClient {
         };
         return await reasonWorkspace(context, params);
     }
-
-    async validateWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
-        const context: RestValidationContext = {
+    async validateWorkspace(params) {
+        const context = {
             workspaceRoot: this.workspaceRoot,
             runtime: this.runtime,
             ensureInitialized: () => this.ensureInitialized(),
@@ -1947,9 +1724,8 @@ class InMemoryJsonRpcLspClient {
         };
         return await validateWorkspace(context, params);
     }
-
-    async exportWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
-        const context: RestExportContext = {
+    async exportWorkspace(params) {
+        const context = {
             workspaceRoot: this.workspaceRoot,
             ensureInitialized: () => this.ensureInitialized(),
             ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
@@ -1958,13 +1734,13 @@ class InMemoryJsonRpcLspClient {
         };
         return await exportWorkspace(context, params);
     }
-
-    async close(): Promise<void> {
+    async close() {
         this.stopWorkspaceWatcher();
         if (!this.useExternalRuntime) {
             try {
                 this.clientConnection?.sendNotification('exit');
-            } catch {
+            }
+            catch {
                 // Ignore close-time notification failures.
             }
             this.clientConnection?.dispose();
@@ -1973,24 +1749,21 @@ class InMemoryJsonRpcLspClient {
             this.serverToClient?.destroy();
         }
     }
-
-    private logError(message: string): void {
+    logError(message) {
         if (this.clientConnection?.console?.error) {
             this.clientConnection.console.error(message);
             return;
         }
         console.error(`[oml-rest] ${message}`);
     }
-
-    private startWorkspaceWatcher(): void {
+    startWorkspaceWatcher() {
         if (this.watcherActive) {
             return;
         }
         this.watcherActive = true;
         this.watchDirectory(this.workspaceRoot);
     }
-
-    private stopWorkspaceWatcher(): void {
+    stopWorkspaceWatcher() {
         this.watcherActive = false;
         if (this.watcherFlushTimer) {
             clearTimeout(this.watcherFlushTimer);
@@ -2001,8 +1774,7 @@ class InMemoryJsonRpcLspClient {
         }
         this.watchers.clear();
     }
-
-    private watchDirectory(dirPath: string): void {
+    watchDirectory(dirPath) {
         const basename = path.basename(dirPath);
         if (basename.startsWith('.') || basename === 'node_modules' || basename === 'out' || basename === 'build') {
             return;
@@ -2019,10 +1791,10 @@ class InMemoryJsonRpcLspClient {
                 this.scheduleWorkspaceRefresh();
             });
             this.watchers.add(watcher);
-        } catch {
+        }
+        catch {
             return;
         }
-
         try {
             const entries = fsSync.readdirSync(dirPath, { withFileTypes: true });
             for (const entry of entries) {
@@ -2030,22 +1802,21 @@ class InMemoryJsonRpcLspClient {
                     this.watchDirectory(path.join(dirPath, entry.name));
                 }
             }
-        } catch {
+        }
+        catch {
             // Ignore unreadable directories.
         }
     }
-
-    private scheduleWorkspaceRefresh(): void {
+    scheduleWorkspaceRefresh() {
         if (this.watcherFlushTimer) {
             return;
         }
         this.watcherFlushTimer = setTimeout(() => {
             this.watcherFlushTimer = undefined;
-            void this.refreshWorkspaceOmlDocumentsQueued().catch(() => {});
+            void this.refreshWorkspaceOmlDocumentsQueued().catch(() => { });
         }, 100);
     }
-
-    private async refreshWorkspaceOmlDocumentsQueued(): Promise<void> {
+    async refreshWorkspaceOmlDocumentsQueued() {
         if (this.refreshInFlight) {
             this.refreshQueued = true;
             return;
@@ -2053,7 +1824,8 @@ class InMemoryJsonRpcLspClient {
         this.refreshInFlight = true;
         try {
             await this.refreshWorkspaceOmlDocuments();
-        } finally {
+        }
+        finally {
             this.refreshInFlight = false;
         }
         if (this.refreshQueued) {
@@ -2061,9 +1833,8 @@ class InMemoryJsonRpcLspClient {
             await this.refreshWorkspaceOmlDocumentsQueued();
         }
     }
-
-    async exportAssertedWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
-        const context: RestExportContext = {
+    async exportAssertedWorkspace(params) {
+        const context = {
             workspaceRoot: this.workspaceRoot,
             ensureInitialized: () => this.ensureInitialized(),
             ensureWorkspaceCurrent: () => this.ensureWorkspaceCurrent(),
@@ -2072,8 +1843,7 @@ class InMemoryJsonRpcLspClient {
         };
         return await exportAssertedWorkspace(context, params);
     }
-
-    async renderWorkspace(params: Record<string, unknown>): Promise<Record<string, unknown>> {
+    async renderWorkspace(params) {
         await this.ensureInitialized();
         await this.ensureWorkspaceCurrent();
         if (params.only !== true) {
@@ -2095,14 +1865,8 @@ class InMemoryJsonRpcLspClient {
         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 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);
@@ -2111,12 +1875,10 @@ class InMemoryJsonRpcLspClient {
             : 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 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 reasoningService = this.runtime.Oml.reasoning.ReasoningService;
+        const ontologyIndex = getOntologyModelIndex(this.runtime.shared);
         const executor = new MarkdownExecutor({
             ensureContext: (modelUri) => reasoningService.ensureQueryContext(modelUri),
             resolveContextIri: (modelUri) => reasoningService.getContextIri(modelUri),
@@ -2126,16 +1888,10 @@ class InMemoryJsonRpcLspClient {
         });
         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>();
+        const workspaceAssetFiles = new Set();
+        const aliasesByIri = new Map();
+        const renderJobs = [];
+        const contextModelUris = new Set();
         let filesRendered = 0;
         let blockArtifactFiles = 0;
         for (const markdownPath of markdownFiles) {
@@ -2144,11 +1900,9 @@ class InMemoryJsonRpcLspClient {
                 continue;
             }
             const frontMatter = extractLeadingFrontMatter(markdown);
-            const contextOntologyIri = normalizeContextOntologyIri(
-                frontMatter?.contextOntologyIri
-                    ?? frontMatterString(frontMatter?.data, 'ontologyIri')
-                    ?? frontMatterString(frontMatter?.data, 'ontology')
-            );
+            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();
@@ -2181,7 +1935,7 @@ class InMemoryJsonRpcLspClient {
                 workspaceAssetFiles.add(asset);
             }
             const executableBlocks = toExecutableBlocks(prepared.codeBlocks);
-            const optionsByBlockId = new Map(prepared.codeBlocks.map((block) => [block.id, block.options] as const));
+            const optionsByBlockId = new Map(prepared.codeBlocks.map((block) => [block.id, block.options]));
             const blockResults = executableBlocks.length === 0 || !contextModelUri
                 ? []
                 : (await executor.executeBlocks({
@@ -2191,7 +1945,7 @@ class InMemoryJsonRpcLspClient {
                 })).results.map((result) => ({
                     ...result,
                     options: optionsByBlockId.get(result.blockId),
-                } as RenderedBlockResult));
+                }));
             const rewrittenBlockResults = blockResults.map((result) => rewriteBlockResultAssetPaths(result, {
                 workspaceRoot,
                 inputRoot: inputDir,
@@ -2211,7 +1965,7 @@ class InMemoryJsonRpcLspClient {
             });
             filesRendered += 1;
         }
-        const renderedNavigationPages = new Set<string>();
+        const renderedNavigationPages = new Set();
         for (const modelUri of contextModelUris) {
             await reasoningService.ensureQueryContext(modelUri);
             const membersToTypes = await queryMemberTypes(reasoningService, modelUri);
@@ -2231,7 +1985,7 @@ class InMemoryJsonRpcLspClient {
                 renderedNavigationPages.add(targetFile);
                 const contextOntologyIri = inferOntologyIriFromMemberIri(memberIri);
                 const sourceDocumentUri = resolution.template.sourceUri?.trim() || pathToFileURL(path.join(workspaceRoot, 'index.md')).toString();
-                const invocation: TemplateInvocation = {
+                const invocation = {
                     templateId: resolution.template.id,
                     mode: 'navigation',
                     context: {
@@ -2279,7 +2033,7 @@ class InMemoryJsonRpcLspClient {
                     workspaceAssetFiles.add(asset);
                 }
                 const executableBlocks = toExecutableBlocks(prepared.codeBlocks);
-                const optionsByBlockId = new Map(prepared.codeBlocks.map((block) => [block.id, block.options] as const));
+                const optionsByBlockId = new Map(prepared.codeBlocks.map((block) => [block.id, block.options]));
                 const blockResults = executableBlocks.length === 0
                     ? []
                     : (await executor.executeBlocks({
@@ -2289,7 +2043,7 @@ class InMemoryJsonRpcLspClient {
                     })).results.map((result) => ({
                         ...result,
                         options: optionsByBlockId.get(result.blockId),
-                    } as RenderedBlockResult));
+                    }));
                 const rewrittenBlockResults = blockResults.map((result) => rewriteBlockResultAssetPaths(result, {
                     workspaceRoot,
                     inputRoot: inputDir,
@@ -2312,15 +2066,7 @@ class InMemoryJsonRpcLspClient {
         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));
             await fs.mkdir(path.dirname(job.htmlPath), { recursive: true });
             await fs.writeFile(job.htmlPath, html, 'utf-8');
         }
@@ -2340,8 +2086,9 @@ class InMemoryJsonRpcLspClient {
             await fs.mkdir(path.dirname(target), { recursive: true });
             try {
                 await fs.copyFile(file, target);
-            } catch (error) {
-                const code = (error as NodeJS.ErrnoException).code;
+            }
+            catch (error) {
+                const code = error.code;
                 if (code !== 'ENOENT') {
                     throw error;
                 }
@@ -2349,8 +2096,7 @@ class InMemoryJsonRpcLspClient {
         }
         return { success: true, filesRendered, outputDir, blockArtifactFiles };
     }
-
-    private async ensureWorkspaceCurrent(): Promise<void> {
+    async ensureWorkspaceCurrent() {
         if (this.useExternalRuntime) {
             return;
         }
@@ -2364,23 +2110,21 @@ class InMemoryJsonRpcLspClient {
         }
         await this.waitForWatcherRefreshIdle();
     }
-
-    private async waitForWatcherRefreshIdle(): Promise<void> {
+    async waitForWatcherRefreshIdle() {
         while (this.watcherFlushTimer !== undefined || this.refreshInFlight || this.refreshQueued) {
             await new Promise((resolve) => setTimeout(resolve, 10));
         }
     }
-
-    private async refreshWorkspaceOmlDocuments(): Promise<void> {
+    async refreshWorkspaceOmlDocuments() {
         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)
+        const iterable = Array.isArray(allDocs)
             ? allDocs
-            : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs as Iterable<any>));
-        const currentOmlUris = new Set<string>();
+            : (typeof allDocs?.toArray === 'function' ? allDocs.toArray() : Array.from(allDocs));
+        const currentOmlUris = new Set();
         for (const document of iterable) {
             const uri = String(document?.uri ?? '').trim();
             if (!uri.toLowerCase().endsWith('.oml')) {
@@ -2396,23 +2140,22 @@ class InMemoryJsonRpcLspClient {
         const builder = this.runtime.shared.workspace.DocumentBuilder;
         await builder.update(changedUris, deletedUris);
     }
-
-    private async ensureInitialized(): Promise<void> {
+    async ensureInitialized() {
         if (this.initPromise) {
             await this.initPromise;
             return;
         }
-
         if (this.useExternalRuntime) {
             this.initPromise = (async () => {
                 const workspace = this.runtime.shared.workspace.WorkspaceManager;
                 await workspace.ready;
             })();
-        } else {
+        }
+        else {
             const rootPath = path.resolve(this.workspaceRoot);
             const rootUri = pathToFileURL(rootPath).toString();
             this.initPromise = (async () => {
-                await withTimeout(this.clientConnection!.sendRequest('initialize', {
+                await withTimeout(this.clientConnection.sendRequest('initialize', {
                     processId: process.pid,
                     rootUri,
                     workspaceFolders: [{ uri: rootUri, name: path.basename(rootPath) }],
@@ -2420,25 +2163,23 @@ class InMemoryJsonRpcLspClient {
                     clientInfo: { name: 'oml-rest-server', version: '1.0' },
                     initializationOptions: {},
                 }), this.requestTimeoutMs, 'initialize');
-                this.clientConnection!.sendNotification('initialized', {});
+                this.clientConnection.sendNotification('initialized', {});
             })();
         }
         await this.initPromise;
     }
 }
-
-export async function startOmlRestServer(options: OmlRestServerOptions): Promise<{ server: http.Server; updateToken: (token: string) => void }> {
+export async function startOmlRestServer(options) {
     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 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;
-
+    let currentAccessToken = options.authToken;
+    const featureGate = options.featureGate;
+    if (featureGate && currentAccessToken) {
+        featureGate.setAccessToken(currentAccessToken);
+        await featureGate.primeEntitlements();
+    }
+    const getAccessToken = () => currentAccessToken;
     const server = http.createServer(async (req, res) => {
         const requestId = randomUUID();
         try {
@@ -2446,7 +2187,6 @@ export async function startOmlRestServer(options: OmlRestServerOptions): Promise
             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',
@@ -2458,17 +2198,14 @@ export async function startOmlRestServer(options: OmlRestServerOptions): Promise
                 });
                 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, {
@@ -2477,41 +2214,51 @@ export async function startOmlRestServer(options: OmlRestServerOptions): Promise
                 });
                 return;
             }
-
             if (method === 'POST') {
                 const body = await readJsonBody(req);
-                const route = await dispatchRestRoute(method, pathname, body, client);
-                if (route) {
+                const operationId = resolveRestOperationId(method, pathname);
+                if (operationId) {
+                    const requiredFeature = requiredFeatureForRestOperation(operationId);
+                    const result = (featureGate && requiredFeature)
+                        ? await featureGate.runWithFeature(requiredFeature, () => dispatchRestOperation(operationId, body, client), { transport: 'rest', operationId })
+                        : await dispatchRestOperation(operationId, body, client);
                     jsonResponse(res, 200, {
                         ok: true,
-                        method: `oml/rest/${route.operationId}`,
-                        result: route.result,
+                        method: `oml/rest/${operationId}`,
+                        result,
                         requestId
                     });
                     return;
                 }
             }
-
             jsonResponse(res, 404, { error: `No route for ${method} ${pathname}.`, requestId });
-        } catch (error) {
+        }
+        catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            const status = error instanceof SyntaxError || message.includes('Request body exceeds') ? 400 : 500;
+            const status = error instanceof OmlAccessError
+                ? error.statusCode
+                : (error instanceof SyntaxError || message.includes('Request body exceeds') ? 400 : 500);
             jsonResponse(res, status, { error: message, requestId });
         }
     });
-
     server.on('close', () => {
         void client.close();
+        void featureGate?.dispose();
         currentAccessToken = undefined;
     });
-
-    await new Promise<void>((resolve, reject) => {
+    await new Promise((resolve, reject) => {
         server.once('error', reject);
         server.listen(options.port, options.host, () => resolve());
     });
-
     return {
         server,
-        updateToken: (token: string) => { currentAccessToken = token; },
+        updateToken: async (token) => {
+            currentAccessToken = token;
+            featureGate?.setAccessToken(token);
+            if (featureGate) {
+                await featureGate.primeEntitlements();
+            }
+        },
     };
 }
+//# sourceMappingURL=server.js.map