@oml/markdown 0.16.0 → 0.16.2

package/src/static/browser-runtime.ts

@@ -1,7 +1,26 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
 import { createMarkdownRendererRegistry } from '../renderers/registry.js';
-import { setIriLabelSnapshot } from '../renderers/renderer.js';
+import { setIriLabelSnapshot, displayLabelFromIri } from '../renderers/renderer.js';
+
+// Replace [[iri]] tokens in an HTML string with wikilink anchors, skipping content inside tags.
+function expandWikilinksInHtml(html: string): string {
+    return html.replace(/(<[^>]*>)|\[\[([^\]]+)\]\]/g, (match, tag: string | undefined, iri: string | undefined) => {
+        if (tag !== undefined) {
+            // Only pass through real HTML tags: <tagname, </tagname, <!-- , <!doctype, <?.
+            // Tag names are letters/digits/hyphens only — no colons or slashes.
+            // <http://...> fails because ':' immediately follows the tag name letters.
+            if (/^<[!?]/.test(tag) || /^<\/?[a-zA-Z][a-zA-Z0-9-]*(?:[\s>\/]|$)/.test(tag)) return tag;
+            return tag.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        }
+        const trimmed = (iri ?? '').trim();
+        if (!trimmed) return match;
+        const label = displayLabelFromIri(trimmed);
+        const safeIri = trimmed.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+        const safeLabel = label.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        return `<a class="wikilink" iri="${safeIri}" href="#" title="${safeIri}">${safeLabel}</a>`;
+    });
+}
 
 const SUPPORTED = new Set(['table', 'tree', 'graph', 'chart', 'diagram', 'list', 'text', 'matrix', 'table-editor']);
 
@@ -626,9 +645,9 @@ function getScriptSparqlCache(): Record<string, Record<string, QueryResult>> {
     return parseJsonNode<Record<string, Record<string, QueryResult>>>('oml-md-script-sparql-cache', {});
 }
 
-const PYTHON_PANEL_CACHE_STORAGE_KEY = 'oml-md-python-panel-cache-v1';
-const R_PANEL_CACHE_STORAGE_KEY = 'oml-md-r-panel-cache-v1';
-const JS_PANEL_CACHE_STORAGE_KEY = 'oml-md-js-panel-cache-v1';
+const PYTHON_PANEL_CACHE_STORAGE_KEY = 'oml-md-python-panel-cache-v2';
+const R_PANEL_CACHE_STORAGE_KEY = 'oml-md-r-panel-cache-v2';
+const JS_PANEL_CACHE_STORAGE_KEY = 'oml-md-js-panel-cache-v2';
 const MAX_PYTHON_PANEL_CACHE_ENTRIES = 64;
 const MAX_R_PANEL_CACHE_ENTRIES = 64;
 const MAX_JS_PANEL_CACHE_ENTRIES = 64;
@@ -737,7 +756,7 @@ function rememberJsPanelCache(key: string, html: string): void {
 
 function buildPythonPanelCacheKey(blockId: string, source: string, blockCache: Record<string, QueryResult>): string {
     const page = `${window.location.origin}${window.location.pathname}${window.location.search}`;
-    return `python|${page}|${blockId}|${hash32(source)}|${hash32(JSON.stringify(blockCache))}`;
+    return `python-v2|${page}|${blockId}|${hash32(source)}|${hash32(JSON.stringify(blockCache))}`;
 }
 
 function buildRPanelCacheKey(blockId: string, source: string, blockCache: Record<string, QueryResult>): string {
@@ -841,7 +860,7 @@ async function executeJsCode(
         const el = document.createElement('div');
         el.className = 'oml-md-js-html-output';
         el.style.color = window.getComputedStyle(document.body).color;
-        el.innerHTML = html;
+        el.innerHTML = expandWikilinksInHtml(html);
         container.appendChild(el);
     };
     const appendText = (text: string): void => {
@@ -852,13 +871,26 @@ async function executeJsCode(
         container.appendChild(pre);
     };
     const display = (content: unknown): void => {
-        if (typeof content === 'string') { appendHtml(content); } else { appendText(String(content)); }
+        if (typeof content === 'string') {
+            appendHtml(content);
+        } else if (content instanceof Node) {
+            clearStatus();
+            const el = document.createElement('div');
+            el.className = 'oml-md-js-html-output';
+            el.style.color = window.getComputedStyle(document.body).color;
+            el.appendChild(content);
+            container.appendChild(el);
+        } else {
+            appendText(String(content));
+        }
     };
     const query = async (sparql: string): Promise<QueryResult> => {
         return blockCache[sparql] ?? { success: false, columns: [], rows: [], error: 'SPARQL not pre-fetched for this query' };
     };
     const table = (result: QueryResult): string => sparqlResultToHtmlTable(result);
     const load = async (url: string): Promise<void> => loadScript(url);
+    const update = async (_ops: unknown): Promise<{ errors?: unknown[] }> => ({});
+    const interactive = (html: string, _ops: unknown): string => html;
 
     const savedLog = console.log;
     const savedWarn = console.warn;
@@ -874,8 +906,8 @@ async function executeJsCode(
     };
     try {
         const AsyncFunction = Object.getPrototypeOf(async function () { /* */ }).constructor as new (...a: string[]) => (...a: unknown[]) => Promise<void>;
-        const fn = new AsyncFunction('display', 'query', 'table', 'load', code);
-        await fn(display, query, table, load);
+        const fn = new AsyncFunction('display', 'query', 'table', 'load', 'update', 'interactive', code);
+        await fn(display, query, table, load, update, interactive);
         clearStatus();
         return {};
     } catch (error) {
@@ -914,6 +946,9 @@ async function applyJsBlocks(): Promise<void> {
             const panel = makeScriptPanel();
             pre.replaceWith(panel);
             const result = await executeJsCode(source, blockCache, panel);
+            if (!panel.isConnected) {
+                continue;
+            }
             appendResult(panel, result);
             if (!result.error) {
                 rememberJsPanelCache(cacheKey, panel.innerHTML);
@@ -1065,6 +1100,20 @@ def table(data):
         for r in rows
     )
     display(f'<div class="oml-md-table-wrapper"><table class="oml-md-table"><thead><tr>{hdr}</tr></thead><tbody>{bdy}</tbody></table></div>')
+
+async def update(_operations):
+    return {}
+
+def interactive(html, _operations):
+    return str(html)
+
+async def js(code, **kwargs):
+    code = code.replace('{{', '\x01').replace('}}', '\x02')
+    for k, v in kwargs.items():
+        code = code.replace(f'{{{k}}}', str(v))
+    code = code.replace('\x01', '{').replace('\x02', '}')
+    result = await _js_eval(code)
+    return result.to_py() if hasattr(result, 'to_py') else result
 `;
 
 let pyodideExecQueue: Promise<unknown> = Promise.resolve();
@@ -1101,7 +1150,7 @@ async function _executePyCode(
         const el = document.createElement('div');
         el.className = 'oml-md-js-html-output';
         el.style.color = window.getComputedStyle(document.body).color;
-        el.innerHTML = html;
+        el.innerHTML = expandWikilinksInHtml(html);
         container.appendChild(el);
     };
     const appendText = (text: string): void => {
@@ -1128,6 +1177,12 @@ async function _executePyCode(
     pyodide.globals.set('_js_display', appendHtml);
     pyodide.globals.set('_js_query', (sparql: string) =>
         blockCache[sparql] ?? { success: false, columns: [], rows: [], error: 'SPARQL not pre-fetched' });
+    pyodide.globals.set('_js_update', async (_opsJson: string) => ({}));
+    pyodide.globals.set('_js_eval', async (code: string) => {
+        // eslint-disable-next-line no-new-func
+        const AsyncFunction = Object.getPrototypeOf(async function () { /* */ }).constructor as new (...a: string[]) => () => Promise<unknown>;
+        return new AsyncFunction(code)();
+    });
     pyodide.setStdout({ batched: appendText });
     pyodide.setStderr({ batched: () => { /* suppress library noise */ } });
     try {
@@ -1158,6 +1213,9 @@ async function applyPyBlocks(): Promise<void> {
         const panel = makeScriptPanel();
         pre.replaceWith(panel);
         const result = await executePyCode(source, blockCache, panel);
+        if (!panel.isConnected) {
+            continue;
+        }
         appendResult(panel, result);
         if (!result.error) {
             rememberPythonPanelCache(cacheKey, panel.innerHTML);
@@ -1221,6 +1279,18 @@ load <- function(pkg) {
     if (!requireNamespace(pkg, quietly=TRUE)) { webr::install(pkg) }
     library(pkg, character.only=TRUE)
 }
+interactive <- function(html, operations) as.character(html)
+js <- function(code, ...) {
+    args <- list(...)
+    code <- gsub('{{', '\x01', code, fixed=TRUE)
+    code <- gsub('}}', '\x02', code, fixed=TRUE)
+    for (nm in names(args)) {
+        code <- gsub(paste0('{', nm, '}'), as.character(args[[nm]]), code, fixed=TRUE)
+    }
+    code <- gsub('\x01', '{', code, fixed=TRUE)
+    code <- gsub('\x02', '}', code, fixed=TRUE)
+    webr::eval_js(paste0('(async()=>{\n', code, '\n})()'))
+}
 `;
 
 function buildRDataFrameCode(result: QueryResult, varName: string): string {
@@ -1298,7 +1368,7 @@ async function executeRCode(
         const el = document.createElement('div');
         el.className = 'oml-md-js-html-output';
         el.style.color = window.getComputedStyle(document.body).color;
-        el.innerHTML = html;
+        el.innerHTML = expandWikilinksInHtml(html);
         container.appendChild(el);
     };
     const appendText = (text: string): void => {
@@ -1367,6 +1437,9 @@ async function applyRBlocks(): Promise<void> {
         const panel = makeScriptPanel();
         pre.replaceWith(panel);
         const result = await executeRCode(source, blockCache, panel);
+        if (!panel.isConnected) {
+            continue;
+        }
         appendResult(panel, result);
         if (!result.error) {
             rememberRPanelCache(cacheKey, panel.innerHTML);

package/src/template/binder.ts

@@ -8,8 +8,13 @@ export function bindTemplateParameters(
     explicitArgs: Readonly<Record<string, TemplateValue>> = {}
 ): TemplateBindResult {
     const values: Record<string, TemplateValue> = {};
-    const missingRequired: string[] = [];
     const parameters = template.parameters ?? [];
+    const declaredIds = new Set(parameters.map((p) => p.id));
+    for (const argId of Object.keys(explicitArgs)) {
+        if (!declaredIds.has(argId)) {
+            throw new Error(`Unknown template parameter: ${argId}`);
+        }
+    }
     for (const parameter of parameters) {
         const explicit = explicitArgs[parameter.id];
         if (explicit !== undefined) {
@@ -22,12 +27,11 @@ export function bindTemplateParameters(
             continue;
         }
         if (parameter.required) {
-            missingRequired.push(parameter.id);
-            continue;
+            throw new Error(`Missing required template parameter: ${parameter.id}`);
         }
         values[parameter.id] = naturalDefaultValue(parameter.type);
     }
-    return { values, missingRequired };
+    return { values };
 }
 
 function resolveTemplateDefaultValue(
@@ -92,8 +96,9 @@ function resolveContextToken(token: string, context: TemplateInvocationContext):
 function coerceParameterValue(parameter: TemplateParameterDefinition, value: TemplateValue): TemplateValue {
     switch (parameter.type) {
         case 'string':
-        case 'iri':
             return coerceString(parameter, value);
+        case 'iri':
+            return coerceIri(parameter, value);
         case 'number':
             return coerceNumber(parameter, value);
         case 'boolean':
@@ -115,6 +120,18 @@ function coerceString(parameter: TemplateParameterDefinition, value: TemplateVal
     throw new Error(`Template parameter '${parameter.id}' must be a string.`);
 }
 
+function coerceIri(parameter: TemplateParameterDefinition, value: TemplateValue): string {
+    if (typeof value !== 'string') {
+        throw new Error(`Template parameter '${parameter.id}' must be a valid IRI.`);
+    }
+    try {
+        new URL(value);
+    } catch {
+        throw new Error(`Template parameter '${parameter.id}' must be a valid IRI, got: ${value}`);
+    }
+    return value;
+}
+
 function coerceNumber(parameter: TemplateParameterDefinition, value: TemplateValue): number {
     if (typeof value === 'number' && Number.isFinite(value)) {
         return value;
@@ -144,18 +161,30 @@ function coerceBoolean(parameter: TemplateParameterDefinition, value: TemplateVa
     throw new Error(`Template parameter '${parameter.id}' must be a boolean.`);
 }
 
+function validateIriArrayEntries(parameter: TemplateParameterDefinition, entries: string[]): string[] {
+    for (const entry of entries) {
+        try {
+            new URL(entry);
+        } catch {
+            throw new Error(`Template parameter '${parameter.id}' contains an invalid IRI: ${entry}`);
+        }
+    }
+    return entries;
+}
+
 function coerceIriArray(parameter: TemplateParameterDefinition, value: TemplateValue): string[] {
     if (Array.isArray(value) && value.every((entry) => typeof entry === 'string')) {
-        return value;
+        return validateIriArrayEntries(parameter, value as string[]);
     }
     if (typeof value === 'string') {
         const normalized = value.trim();
         if (!normalized) {
             return [];
         }
-        return normalized.split(',').map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+        const entries = normalized.split(',').map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+        return validateIriArrayEntries(parameter, entries);
     }
-    throw new Error(`Template parameter '${parameter.id}' must be an array of strings.`);
+    throw new Error(`Template parameter '${parameter.id}' must be an array of IRIs.`);
 }
 
 function coerceJson(parameter: TemplateParameterDefinition, value: TemplateValue): TemplateValue {

package/src/template/engine.ts

@@ -6,7 +6,6 @@ import type { TemplateDefinition, TemplateInvocation, TemplateValue } from './ty
 export interface TemplateRenderResult {
     output: string;
     values: Record<string, TemplateValue>;
-    missingRequired: string[];
 }
 
 export function renderTemplate(
@@ -18,7 +17,6 @@ export function renderTemplate(
     return {
         output,
         values: bound.values,
-        missingRequired: bound.missingRequired
     };
 }
 
@@ -26,13 +24,14 @@ export function interpolateTemplateBody(
     source: string,
     values: Readonly<Record<string, TemplateValue>>
 ): string {
-    return source.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match: string, key: string): string => {
+    return source.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?:\|([^|}]*)(?:\|([^}]*))?)?\}/g, (_match: string, key: string, delimiter: string | undefined, entryTemplate: string | undefined): string => {
         if (!(key in values)) {
             return _match;
         }
         const value = values[key];
         if (Array.isArray(value)) {
-            return value.map((entry) => String(entry)).join(', ');
+            const format = (entry: string) => entryTemplate ? entryTemplate.replace('%s', entry) : entry;
+            return value.map((entry) => format(String(entry))).join(delimiter ?? ', ');
         }
         if (value === null || value === undefined) {
             return '';

package/src/template/types.ts

@@ -97,5 +97,4 @@ export interface TemplateResolutionResult {
 
 export interface TemplateBindResult {
     values: Record<string, TemplateValue>;
-    missingRequired: string[];
 }