@oml/markdown 0.14.17 → 0.16.0

package/src/static/markdown-webview.css

@@ -43,10 +43,80 @@ pre > code.language-diagram,
 pre > code.language-list,
 pre > code.language-text,
 pre > code.language-matrix,
-pre > code.language-table-editor {
+pre > code.language-table-editor,
+pre > code.language-js,
+pre > code.language-javascript,
+pre > code.language-python,
+pre > code.language-r {
   display: none;
 }
 
+.oml-md-js-result {
+  margin: 1rem 0;
+}
+
+.oml-md-js-result:empty {
+  display: none;
+}
+
+pre.oml-md-js-text-output {
+  font-family: var(--vscode-editor-font-family, monospace);
+  font-size: 0.9em;
+  background: var(--vscode-textBlockQuote-background, var(--oml-static-background, #f6f8fa));
+  border: 1px solid var(--vscode-editorWidget-border, var(--oml-static-border, #d0d7de));
+  border-radius: 6px !important;
+  padding: 0.5rem 0.75rem !important;
+  margin: 0.25rem 0;
+  white-space: pre-wrap;
+  overflow: visible !important;
+  color: var(--vscode-editor-foreground, var(--oml-static-foreground, #24292f));
+}
+
+.oml-md-js-html-output {
+  margin: 0.25rem 0;
+  color: var(--vscode-editor-foreground, var(--oml-static-foreground, #24292f));
+}
+
+.oml-md-js-html-output ul,
+.oml-md-js-html-output ol {
+  padding-left: 2em;
+}
+
+.oml-md-js-html-output li {
+  color: var(--vscode-editor-foreground, var(--oml-static-foreground, #24292f));
+}
+
+.oml-md-js-error {
+  border: 1px solid var(--vscode-inputValidation-errorBorder, #f14c4c);
+  background: var(--vscode-inputValidation-errorBackground, rgba(241, 76, 76, 0.1));
+  color: var(--vscode-errorForeground, #f14c4c);
+  border-radius: 6px;
+  padding: 0.5rem 0.75rem;
+  margin: 0.25rem 0;
+  font-family: var(--vscode-editor-font-family, monospace);
+  font-size: 0.9em;
+  white-space: pre-wrap;
+}
+
+.oml-md-js-empty {
+  color: var(--vscode-descriptionForeground, #666);
+  font-style: italic;
+  margin: 0.25rem 0;
+}
+
+pre.oml-md-js-stderr {
+  font-family: var(--vscode-editor-font-family, monospace);
+  font-size: 0.85em;
+  color: var(--vscode-descriptionForeground, #888);
+  background: transparent;
+  border: none;
+  border-radius: 0 !important;
+  padding: 0 !important;
+  margin: 0;
+  white-space: pre-wrap;
+  overflow: visible !important;
+}
+
 h1,
 h2,
 h3,
@@ -349,6 +419,7 @@ pre {
   text-align: left;
   font-weight: 600;
   border-bottom: 1px solid var(--vscode-editorWidget-border);
+  border-right: 1px solid var(--vscode-editorWidget-border);
   padding: 8px 10px;
   background: var(--vscode-editor-background);
   cursor: pointer;
@@ -358,12 +429,21 @@ pre {
   user-select: none;
 }
 
+.oml-md-table thead th:last-child {
+  border-right: none;
+}
+
 .oml-md-table tbody td {
   border-bottom: 1px solid var(--vscode-editorWidget-border);
+  border-right: 1px solid var(--vscode-editorWidget-border);
   padding: 6px 10px;
   vertical-align: top;
 }
 
+.oml-md-table tbody td:last-child {
+  border-right: none;
+}
+
 .vscode-dark th {
   border-color: rgb(255 255 255 / 69%);
 }
@@ -726,6 +806,8 @@ pre {
   align-items: center;
   gap: 0.5rem;
   margin-left: auto;
+  font-family: var(--vscode-font-family, var(--markdown-font-family, -apple-system, BlinkMacSystemFont, "Segoe WPC", "Segoe UI", system-ui, "Ubuntu", "Droid Sans", sans-serif));
+  font-size: 0.85rem;
 }
 
 .oml-md-result .table-pagination {
@@ -745,6 +827,7 @@ pre {
   background: transparent;
   color: var(--vscode-foreground);
   cursor: pointer;
+  font-family: inherit;
   font-size: 1rem;
   font-weight: 600;
   line-height: 1;
@@ -764,6 +847,10 @@ pre {
 .oml-md-result .table-page-label {
   min-width: 36px;
   text-align: center;
+  font-family: inherit;
+  font-size: inherit;
+  font-weight: 400;
+  line-height: 1.2;
 }
 
 .oml-md-result .graph-canvas-root {

package/src/static/runtime-assets.ts

@@ -3,6 +3,9 @@
 export const STATIC_MARKDOWN_RUNTIME_BUNDLE_FILE = 'browser-runtime.bundle.js';
 
 export const STATIC_MARKDOWN_RUNTIME_CSS = `
+/* Prevent first-paint flicker before static runtime hydration restores content. */
+body { visibility: hidden; }
+
 .oml-md-result { margin: 1rem 0; }
 .oml-md-result-message {
   border: 1px solid #e5b567;

package/src/template/binder.ts

@@ -13,58 +13,188 @@ export function bindTemplateParameters(
     for (const parameter of parameters) {
         const explicit = explicitArgs[parameter.id];
         if (explicit !== undefined) {
-            values[parameter.id] = explicit;
+            values[parameter.id] = coerceParameterValue(parameter, explicit);
             continue;
         }
-        const bound = resolveValueFromContext(parameter, context);
-        if (bound !== undefined) {
-            values[parameter.id] = bound;
-            continue;
-        }
-        if (parameter.defaultValue !== undefined) {
-            values[parameter.id] = parameter.defaultValue;
+        const defaultValue = resolveTemplateDefaultValue(parameter.defaultValue, context);
+        if (defaultValue !== undefined) {
+            values[parameter.id] = coerceParameterValue(parameter, defaultValue);
             continue;
         }
         if (parameter.required) {
             missingRequired.push(parameter.id);
+            continue;
         }
+        values[parameter.id] = naturalDefaultValue(parameter.type);
     }
     return { values, missingRequired };
 }
 
-function resolveValueFromContext(
-    parameter: TemplateParameterDefinition,
+function resolveTemplateDefaultValue(
+    value: TemplateValue | undefined,
     context: TemplateInvocationContext
 ): TemplateValue | undefined {
-    switch (parameter.from) {
-        case 'context.member':
-            return context.focus?.memberIri;
-        case 'context.ontology':
-            return context.model?.ontologyIri;
-        case 'context.modelUri':
-            return context.model?.modelUri;
-        case 'context.selection[*]':
-            return context.selection?.iris ?? [];
-        default:
-            return resolveSelectionIndexedBinding(parameter.from, context);
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        return value;
     }
+    return interpolateContextExpression(value, context);
 }
 
-function resolveSelectionIndexedBinding(
-    source: TemplateParameterDefinition['from'],
-    context: TemplateInvocationContext
-): TemplateValue | undefined {
-    if (!source || !source.startsWith('context.selection[')) {
-        return undefined;
+function interpolateContextExpression(source: string, context: TemplateInvocationContext): string | undefined {
+    let unresolved = false;
+    const output = source.replace(/\$\{context\.([^}]+)\}/g, (_match, token: string) => {
+        const resolved = resolveContextToken(token.trim(), context);
+        if (resolved === undefined) {
+            unresolved = true;
+            return '';
+        }
+        return resolved;
+    });
+    return unresolved ? undefined : output;
+}
+
+function resolveContextToken(token: string, context: TemplateInvocationContext): string | undefined {
+    const indexedSelection = /^selection\[(\d+)]$/.exec(token);
+    if (indexedSelection) {
+        const index = Number.parseInt(indexedSelection[1] ?? '', 10);
+        if (!Number.isFinite(index) || index < 0) {
+            return undefined;
+        }
+        const selection = context.selection?.iris ?? [];
+        const value = selection[index];
+        return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
     }
-    const match = /^context\.selection\[(\d+)]$/.exec(source);
-    if (!match) {
-        return undefined;
+    const key = token;
+    const vars = context.vars ?? {};
+    const direct = vars[key];
+    if (typeof direct === 'string') {
+        return direct;
     }
-    const index = Number.parseInt(match[1] ?? '', 10);
-    if (!Number.isFinite(index) || index < 0) {
-        return undefined;
+    if (typeof direct === 'number' || typeof direct === 'boolean') {
+        return String(direct);
+    }
+    if (key === 'ontology') {
+        return context.model?.ontologyIri?.trim() || undefined;
+    }
+    if (key === 'member') {
+        return context.focus?.memberIri?.trim() || undefined;
+    }
+    if (key === 'selection') {
+        const selection = context.selection?.iris ?? [];
+        return selection.join(', ');
+    }
+    return undefined;
+}
+
+function coerceParameterValue(parameter: TemplateParameterDefinition, value: TemplateValue): TemplateValue {
+    switch (parameter.type) {
+        case 'string':
+        case 'iri':
+            return coerceString(parameter, value);
+        case 'number':
+            return coerceNumber(parameter, value);
+        case 'boolean':
+            return coerceBoolean(parameter, value);
+        case 'iri[]':
+            return coerceIriArray(parameter, value);
+        case 'json':
+            return coerceJson(parameter, value);
+    }
+}
+
+function coerceString(parameter: TemplateParameterDefinition, value: TemplateValue): string {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    throw new Error(`Template parameter '${parameter.id}' must be a string.`);
+}
+
+function coerceNumber(parameter: TemplateParameterDefinition, value: TemplateValue): number {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value.trim());
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    throw new Error(`Template parameter '${parameter.id}' must be a number.`);
+}
+
+function coerceBoolean(parameter: TemplateParameterDefinition, value: TemplateValue): boolean {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true') {
+            return true;
+        }
+        if (normalized === 'false') {
+            return false;
+        }
+    }
+    throw new Error(`Template parameter '${parameter.id}' must be a boolean.`);
+}
+
+function coerceIriArray(parameter: TemplateParameterDefinition, value: TemplateValue): string[] {
+    if (Array.isArray(value) && value.every((entry) => typeof entry === 'string')) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim();
+        if (!normalized) {
+            return [];
+        }
+        return normalized.split(',').map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    }
+    throw new Error(`Template parameter '${parameter.id}' must be an array of strings.`);
+}
+
+function coerceJson(parameter: TemplateParameterDefinition, value: TemplateValue): TemplateValue {
+    if (value === null || typeof value === 'object') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value) as unknown;
+            if (
+                parsed === null
+                || typeof parsed === 'string'
+                || typeof parsed === 'number'
+                || typeof parsed === 'boolean'
+                || (Array.isArray(parsed) && parsed.every((entry) => typeof entry === 'string'))
+                || (typeof parsed === 'object' && parsed !== null)
+            ) {
+                return parsed as TemplateValue;
+            }
+            throw new Error('unsupported-json');
+        } catch {
+            throw new Error(`Template parameter '${parameter.id}' must be valid JSON.`);
+        }
+    }
+    throw new Error(`Template parameter '${parameter.id}' must be JSON.`);
+}
+
+function naturalDefaultValue(type: TemplateParameterDefinition['type']): TemplateValue {
+    switch (type) {
+        case 'number':
+            return 0;
+        case 'boolean':
+            return false;
+        case 'iri[]':
+            return [];
+        case 'json':
+            return {};
+        case 'string':
+        case 'iri':
+            return '';
     }
-    const iris = context.selection?.iris ?? [];
-    return iris[index];
 }

package/src/template/compose.ts

@@ -1,48 +1,36 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
 import { parse } from 'yaml';
-import type { TemplateBindingSource, TemplateValue } from './types.js';
+import type { TemplateValue } from './types.js';
 
 export interface TemplateComposeDirective {
     id: string;
     args: Record<string, TemplateValue>;
-    bind: Record<string, TemplateBindingSource>;
 }
 
 export function parseTemplateComposeDirective(source: string): TemplateComposeDirective | undefined {
     const normalized = source.replace(/^\uFEFF/, '');
-    const frontMatterMatch = /^(---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*)([\s\S]*)$/.exec(normalized);
-    if (!frontMatterMatch) {
-        return undefined;
-    }
-    const trailing = frontMatterMatch[2] ?? '';
-    if (trailing.trim().length > 0) {
-        return undefined;
-    }
-    const yamlBody = frontMatterMatch[1]
-        .replace(/^---[ \t]*\r?\n/, '')
-        .replace(/\r?\n---[ \t]*$/, '');
-    const parsed = parse(yamlBody);
+    const parsed = parse(normalized);
     if (!isRecord(parsed)) {
         return undefined;
     }
-    const id = normalizeString(parsed.id);
+    const id = normalizeString(parsed.template);
     if (!id) {
         return undefined;
     }
-    const args = parseArgs(parsed.args);
-    const bind = parseBind(parsed.bind);
-    return { id, args, bind };
+    const args = parseArgs(parsed, ['template']);
+    return { id, args };
 }
 
-function parseArgs(value: unknown): Record<string, TemplateValue> {
+function parseArgs(value: unknown, excludedKeys: string[] = []): Record<string, TemplateValue> {
     if (!isRecord(value)) {
         return {};
     }
+    const excluded = new Set(excludedKeys);
     const args: Record<string, TemplateValue> = {};
     for (const [key, raw] of Object.entries(value)) {
         const normalizedKey = normalizeString(key);
-        if (!normalizedKey) {
+        if (!normalizedKey || excluded.has(normalizedKey)) {
             continue;
         }
         const converted = toTemplateValue(raw);
@@ -53,22 +41,6 @@ function parseArgs(value: unknown): Record<string, TemplateValue> {
     return args;
 }
 
-function parseBind(value: unknown): Record<string, TemplateBindingSource> {
-    if (!isRecord(value)) {
-        return {};
-    }
-    const bind: Record<string, TemplateBindingSource> = {};
-    for (const [key, raw] of Object.entries(value)) {
-        const normalizedKey = normalizeString(key);
-        const source = normalizeString(raw);
-        if (!normalizedKey || !source || !isTemplateBindingSource(source)) {
-            continue;
-        }
-        bind[normalizedKey] = source;
-    }
-    return bind;
-}
-
 function toTemplateValue(value: unknown): TemplateValue | undefined {
     if (value === null) {
         return null;
@@ -85,15 +57,6 @@ function toTemplateValue(value: unknown): TemplateValue | undefined {
     return undefined;
 }
 
-function isTemplateBindingSource(value: string): value is TemplateBindingSource {
-    return value === 'context.member'
-        || value === 'context.ontology'
-        || value === 'context.modelUri'
-        || value === 'context.selection[*]'
-        || value === 'user'
-        || /^context\.selection\[\d+]$/.test(value);
-}
-
 function normalizeString(value: unknown): string | undefined {
     if (typeof value !== 'string') {
         return undefined;

package/src/template/definition.ts

@@ -117,8 +117,6 @@ function parseTemplateParameters(raw: unknown): TemplateParameterDefinition[] {
             continue;
         }
         const required = typeof entry.required === 'boolean' ? entry.required : undefined;
-        const fromValue = typeof entry.from === 'string' ? entry.from.trim() : '';
-        const from = isSupportedBindingSource(fromValue) ? fromValue : undefined;
         const description = typeof entry.description === 'string' && entry.description.trim().length > 0
             ? entry.description.trim()
             : undefined;
@@ -126,7 +124,6 @@ function parseTemplateParameters(raw: unknown): TemplateParameterDefinition[] {
             id,
             type,
             required,
-            from,
             defaultValue: toTemplateValue(entry.defaultValue),
             description,
         });
@@ -143,15 +140,6 @@ function isSupportedParameterType(value: string): value is TemplateParameterDefi
         || value === 'json';
 }
 
-function isSupportedBindingSource(value: string): value is NonNullable<TemplateParameterDefinition['from']> {
-    return value === 'context.member'
-        || value === 'context.ontology'
-        || value === 'context.modelUri'
-        || value === 'context.selection[*]'
-        || /^context\.selection\[\d+]$/.test(value)
-        || value === 'user';
-}
-
 function toTemplateValue(value: unknown): TemplateValue | undefined {
     if (value === null) {
         return null;

package/src/template/engine.ts

@@ -28,7 +28,7 @@ export function interpolateTemplateBody(
 ): string {
     return source.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match: string, key: string): string => {
         if (!(key in values)) {
-            return '';
+            return _match;
         }
         const value = values[key];
         if (Array.isArray(value)) {

package/src/template/types.ts

@@ -10,19 +10,10 @@ export type TemplateParameterType =
     | 'iri[]'
     | 'json';
 
-export type TemplateBindingSource =
-    | 'context.member'
-    | 'context.ontology'
-    | 'context.modelUri'
-    | `context.selection[${number}]`
-    | 'context.selection[*]'
-    | 'user';
-
 export interface TemplateParameterDefinition {
     id: string;
     type: TemplateParameterType;
     required?: boolean;
-    from?: TemplateBindingSource;
     defaultValue?: TemplateValue;
     description?: string;
 }