@peter.prib/renderengine 0.14.0 → 0.15.1

package/src/charting/templates/SwimlaneTemplate.js

@@ -1,18 +1,19 @@
-import { RectangleTemplate } from './RectangleTemplate.js';
-import { svgEl } from './svg.js';
-
-/** SwimlaneTemplate — lane / pool / partition: large box with a title band. */
-export class SwimlaneTemplate extends RectangleTemplate {
-    static defaults = { width: 420, height: 160, fillColor: '#f8fafc' };
-
-    get cornerRadius() { return 0; }
-
-    get headerHeight() { return Math.min(26, this.height / 4); }
-
-    get labelAnchor() { return { x: this.x, y: this.top + this.headerHeight / 2 }; }
-
-    shapeElements(doc) {
-        const y = this.top + this.headerHeight;
-        return [...super.shapeElements(doc), svgEl('line', this.line({ x1: this.left, y1: y, x2: this.right, y2: y }), doc)];
-    }
-}
+import { RectangleTemplate } from './RectangleTemplate.js';
+import { svgEl } from './svg.js';
+
+/** SwimlaneTemplate — lane / pool / partition: large box with a title band. */
+export class SwimlaneTemplate extends RectangleTemplate {
+    static isContainer = true;
+    static defaults = { width: 420, height: 160, fillColor: '#f8fafc' };
+
+    get cornerRadius() { return 0; }
+
+    get headerHeight() { return Math.min(26, this.height / 4); }
+
+    get labelAnchor() { return { x: this.x, y: this.top + this.headerHeight / 2 }; }
+
+    shapeElements(doc) {
+        const y = this.top + this.headerHeight;
+        return [...super.shapeElements(doc), svgEl('line', this.line({ x1: this.left, y1: y, x2: this.right, y2: y }), doc)];
+    }
+}

package/src/charting/templates/Template.js

@@ -1,212 +1,219 @@
-import { svgEl } from './svg.js';
-import { rayExitDistance, rotateVector } from './outline.js';
-import { TextStyle, TEXT_STYLE_KEYS } from '../TextStyle.js';
-
-/**
- * Template — abstract base for diagram shapes.
- *
- * Owns everything shapes have in common: geometry/paint state, the element
- * group, rotation, label and editor wiring. A subclass supplies only its
- * outline via shapeElements(), so the canvas and the palette preview are
- * drawn by the same code and cannot drift apart.
- *
- * Geometry is centre-based: (x, y) is the centre of a width x height box.
- */
-export class Template {
-    /** Per-shape construction defaults; subclasses override. */
-    static defaults = { width: 120, height: 60 };
-
-    /** Whether the editor offers a rotate handle for this kind of shape. */
-    static rotatable = true;
-
-    /** What the format painter copies from a shape and gives to another: its paint and text style. */
-    static formatKeys = Object.freeze(['fillColor', 'strokeColor', 'strokeWidth', 'textColor', ...TEXT_STYLE_KEYS]);
-
-    /**
-     * The shape's format (`formatKeys`), as it holds it: a value it takes from
-     * elsewhere (an ArchiMate shape's layer colour) is left unset, so pasting
-     * it gives the other shape its own default too.
-     * @returns {Object}
-     */
-    format() {
-        const own = typeof this.ownProperty === 'function' ? (k) => this.ownProperty(k) : (k) => this[k];
-        return Object.fromEntries(this.constructor.formatKeys.map(k => [k, own(k)]));
-    }
-
-    constructor(id, name, options = {}) {
-        if (new.target === Template) throw new TypeError('Template is abstract — subclass it');
-        this.id = id;
-        this.rotation = options.rotation ?? 0;
-        this.connections = options.connections || [];
-        this._initState(name, options);
-    }
-
-    /**
-     * Set the name, placement and paint this shape keeps as its own fields. A
-     * subclass that keeps them elsewhere (an ArchiMate element keeps them on
-     * its view instance and model element) overrides this.
-     * @protected
-     */
-    _initState(name, options) {
-        const d = this.constructor.defaults;
-        this.name = name;
-        this.x = options.x ?? 0;
-        this.y = options.y ?? 0;
-        this.zIndex = options.zIndex ?? 0;
-        this.visible = options.visible !== false;
-        this.width = options.width ?? d.width;
-        this.height = options.height ?? d.height;
-        this.fillColor = options.fillColor ?? d.fillColor ?? '#e8f4f8';
-        this.fillOpacity = options.fillOpacity ?? d.fillOpacity ?? 1;
-        this.strokeColor = options.strokeColor ?? d.strokeColor ?? '#333';
-        this.strokeWidth = options.strokeWidth ?? d.strokeWidth ?? 2;
-        this.textColor = options.textColor ?? d.textColor ?? '#333';
-        // Text style (TextStyle): unset ones are left off, so the default applies.
-        for (const key of TEXT_STYLE_KEYS) {
-            const value = options[key] ?? d[key];
-            if (value !== undefined && value !== null && value !== '') this[key] = value;
-        }
-    }
-
-    /** The text style this shape's name is drawn in (TextStyle). */
-    get textStyle() {
-        return Object.fromEntries(TEXT_STYLE_KEYS.map(k => [k, this[k]]).filter(([, v]) => v !== undefined));
-    }
-
-    get left() { return this.x - this.width / 2; }
-    get right() { return this.x + this.width / 2; }
-    get top() { return this.y - this.height / 2; }
-    get bottom() { return this.y + this.height / 2; }
-
-    /**
-     * The visible outline as a closed polygon in unrotated canvas coordinates
-     * (curves sampled). Edges attach to it, so it must match shapeElements().
-     */
-    outline() {
-        return [[this.left, this.top], [this.right, this.top], [this.right, this.bottom], [this.left, this.bottom]];
-    }
-
-    /**
-     * Where a line heading out from the centre in screen direction (dx, dy)
-     * meets the outline, with rotation applied.
-     * @returns {{x: number, y: number}}
-     */
-    boundaryPoint(dx, dy) {
-        const len = Math.hypot(dx, dy);
-        if (!len) return { x: this.x, y: this.y };
-        const ux = dx / len, uy = dy / len;
-        // Rotation preserves length, so the exit distance found in the shape's own
-        // frame is the distance along the on-screen direction too.
-        const [lx, ly] = rotateVector(ux, uy, -this.rotation);
-        const t = rayExitDistance(this.outline(), this.x, this.y, lx, ly);
-        return { x: this.x + ux * t, y: this.y + uy * t };
-    }
-
-    /**
-     * Where a line from (px, py), a point inside the shape, heading in
-     * direction (dx, dy) leaves its outline (the shape unrotated).
-     * @returns {{x: number, y: number}}
-     */
-    exitPoint(px, py, dx, dy) {
-        const t = rayExitDistance(this.outline(), px, py, dx, dy);
-        return { x: px + dx * t, y: py + dy * t };
-    }
-
-    /** Centre of the name text; the z-index line sits just below it. */
-    get labelAnchor() { return { x: this.x, y: this.y - 8 }; }
-
-    /**
-     * SVG nodes forming the outline, positioned in canvas coordinates.
-     * @param {Document} doc
-     * @returns {SVGElement[]}
-     */
-    shapeElements(doc) {
-        throw new Error(`${this.constructor.name} must implement shapeElements()`);
-    }
-
-    /** Fill/stroke attributes for the main outline, merged with `extra`. */
-    paint(extra = {}) {
-        return {
-            fill: this.fillColor,
-            'fill-opacity': this.fillOpacity === 1 ? null : this.fillOpacity,
-            stroke: this.strokeColor,
-            'stroke-width': this.strokeWidth,
-            ...extra,
-        };
-    }
-
-    /** Stroke-only attributes for interior detail lines. */
-    line(extra = {}) {
-        return { fill: 'none', stroke: this.strokeColor, 'stroke-width': Math.max(1, this.strokeWidth - 0.5), ...extra };
-    }
-
-    /** Draw into the editor's element group and wire interaction. */
-    render({ group, editor }) {
-        const g = this.renderElement(group.ownerDocument);
-        editor.attachElementHandlers(this.id, g);
-        group.appendChild(g);
-    }
-
-    /** Build the complete element group (outline + label) without attaching it. */
-    renderElement(doc = document) {
-        const g = svgEl('g', { 'data-id': this.id, 'data-template-id': this.id }, doc);
-        if (this.rotation) g.setAttribute('transform', `rotate(${this.rotation} ${this.x} ${this.y})`);
-        for (const node of this.shapeElements(doc)) g.appendChild(node);
-        this._renderLabel(g, doc);
-        return g;
-    }
-
-    /** Standalone thumbnail of the outline, scaled to fit a size x size box. */
-    renderPreview(size = 40, doc = document) {
-        const pad = this.strokeWidth + 2;
-        const svg = svgEl('svg', {
-            width: size,
-            height: size,
-            viewBox: `${this.left - pad} ${this.top - pad} ${this.width + pad * 2} ${this.height + pad * 2}`,
-            preserveAspectRatio: 'xMidYMid meet',
-        }, doc);
-        for (const node of this.shapeElements(doc)) svg.appendChild(node);
-        return svg;
-    }
-
-    _renderLabel(g, doc) {
-        const { x, y } = this.labelAnchor;
-        const text = (attrs, content) => {
-            const t = svgEl('text', {
-                'text-anchor': 'middle', 'dominant-baseline': 'middle', 'pointer-events': 'none', ...attrs,
-            }, doc);
-            t.textContent = content;
-            g.appendChild(t);
-        };
-        const style = this.textStyle;
-        const font = TextStyle.svgAttributes(style, { defaultPixels: 12 });
-        if (TextStyle.placesText(style)) {
-            // Placed in the shape's box by its alignment and position (centred, middle where unset).
-            const at = TextStyle.block(style, this, 1, { pixels: font['font-size'], defaults: { textAlign: 'center', textPosition: 'middle' } });
-            const placed = { 'text-anchor': at.textAnchor, 'dominant-baseline': 'auto' };
-            if (this.name) text({ x: at.x, y: at.baseline, ...font, ...placed, fill: this.textColor }, this.name);
-            return;
-        }
-        if (this.name) text({ x, y, ...font, fill: this.textColor }, this.name);
-    }
-
-    serialize() {
-        return {
-            id: this.id,
-            name: this.name,
-            x: this.x,
-            y: this.y,
-            zIndex: this.zIndex,
-            visible: this.visible,
-            width: this.width,
-            height: this.height,
-            rotation: this.rotation,
-            fillColor: this.fillColor,
-            fillOpacity: this.fillOpacity,
-            strokeColor: this.strokeColor,
-            strokeWidth: this.strokeWidth,
-            textColor: this.textColor,
-            ...this.textStyle,
-        };
-    }
-}
+import { svgEl } from './svg.js';
+import { rayExitDistance, rotateVector } from './outline.js';
+import { TextStyle, TEXT_STYLE_KEYS } from '../TextStyle.js';
+
+/**
+ * Template — abstract base for diagram shapes.
+ *
+ * Owns everything shapes have in common: geometry/paint state, the element
+ * group, rotation, label and editor wiring. A subclass supplies only its
+ * outline via shapeElements(), so the canvas and the palette preview are
+ * drawn by the same code and cannot drift apart.
+ *
+ * Geometry is centre-based: (x, y) is the centre of a width x height box.
+ */
+export class Template {
+    /** Per-shape construction defaults; subclasses override. */
+    static defaults = { width: 120, height: 60 };
+
+    /** Whether the editor offers a rotate handle for this kind of shape. */
+    static rotatable = true;
+
+    /** What the format painter copies from a shape and gives to another: its paint and text style. */
+    static formatKeys = Object.freeze(['fillColor', 'fillOpacity', 'strokeColor', 'strokeWidth', 'strokeOpacity', 'gradient', 'textColor', ...TEXT_STYLE_KEYS]);
+
+    /**
+     * The shape's format (`formatKeys`), as it holds it: a value it takes from
+     * elsewhere (an ArchiMate shape's layer colour) is left unset, so pasting
+     * it gives the other shape its own default too.
+     * @returns {Object}
+     */
+    format() {
+        const own = typeof this.ownProperty === 'function' ? (k) => this.ownProperty(k) : (k) => this[k];
+        return Object.fromEntries(this.constructor.formatKeys.map(k => [k, own(k)]));
+    }
+
+    constructor(id, name, options = {}) {
+        if (new.target === Template) throw new TypeError('Template is abstract — subclass it');
+        this.id = id;
+        this.rotation = options.rotation ?? 0;
+        this.connections = options.connections || [];
+        this._initState(name, options);
+    }
+
+    /**
+     * Set the name, placement and paint this shape keeps as its own fields. A
+     * subclass that keeps them elsewhere (an ArchiMate element keeps them on
+     * its view instance and model element) overrides this.
+     * @protected
+     */
+    _initState(name, options) {
+        const d = this.constructor.defaults;
+        this.name = name;
+        this.x = options.x ?? 0;
+        this.y = options.y ?? 0;
+        this.zIndex = options.zIndex ?? 0;
+        this.visible = options.visible !== false;
+        this.width = options.width ?? d.width;
+        this.height = options.height ?? d.height;
+        this.fillColor = options.fillColor ?? d.fillColor ?? '#e8f4f8';
+        this.fillOpacity = options.fillOpacity ?? d.fillOpacity ?? 1;
+        this.strokeColor = options.strokeColor ?? d.strokeColor ?? '#333';
+        this.strokeWidth = options.strokeWidth ?? d.strokeWidth ?? 2;
+        this.strokeOpacity = options.strokeOpacity ?? d.strokeOpacity ?? 1;
+        this.gradient = options.gradient ?? d.gradient ?? null;
+        this.textColor = options.textColor ?? d.textColor ?? '#333';
+        this.parentId = options.parentId ?? null;
+        this.isContainer = options.isContainer ?? this.constructor.isContainer ?? false;
+        // Text style (TextStyle): unset ones are left off, so the default applies.
+        for (const key of TEXT_STYLE_KEYS) {
+            const value = options[key] ?? d[key];
+            if (value !== undefined && value !== null && value !== '') this[key] = value;
+        }
+    }
+
+    /** The text style this shape's name is drawn in (TextStyle). */
+    get textStyle() {
+        return Object.fromEntries(TEXT_STYLE_KEYS.map(k => [k, this[k]]).filter(([, v]) => v !== undefined));
+    }
+
+    get left() { return this.x - this.width / 2; }
+    get right() { return this.x + this.width / 2; }
+    get top() { return this.y - this.height / 2; }
+    get bottom() { return this.y + this.height / 2; }
+
+    /**
+     * The visible outline as a closed polygon in unrotated canvas coordinates
+     * (curves sampled). Edges attach to it, so it must match shapeElements().
+     */
+    outline() {
+        return [[this.left, this.top], [this.right, this.top], [this.right, this.bottom], [this.left, this.bottom]];
+    }
+
+    /**
+     * Where a line heading out from the centre in screen direction (dx, dy)
+     * meets the outline, with rotation applied.
+     * @returns {{x: number, y: number}}
+     */
+    boundaryPoint(dx, dy) {
+        const len = Math.hypot(dx, dy);
+        if (!len) return { x: this.x, y: this.y };
+        const ux = dx / len, uy = dy / len;
+        // Rotation preserves length, so the exit distance found in the shape's own
+        // frame is the distance along the on-screen direction too.
+        const [lx, ly] = rotateVector(ux, uy, -this.rotation);
+        const t = rayExitDistance(this.outline(), this.x, this.y, lx, ly);
+        return { x: this.x + ux * t, y: this.y + uy * t };
+    }
+
+    /**
+     * Where a line from (px, py), a point inside the shape, heading in
+     * direction (dx, dy) leaves its outline (the shape unrotated).
+     * @returns {{x: number, y: number}}
+     */
+    exitPoint(px, py, dx, dy) {
+        const t = rayExitDistance(this.outline(), px, py, dx, dy);
+        return { x: px + dx * t, y: py + dy * t };
+    }
+
+    /** Centre of the name text; the z-index line sits just below it. */
+    get labelAnchor() { return { x: this.x, y: this.y - 8 }; }
+
+    /**
+     * SVG nodes forming the outline, positioned in canvas coordinates.
+     * @param {Document} doc
+     * @returns {SVGElement[]}
+     */
+    shapeElements(doc) {
+        throw new Error(`${this.constructor.name} must implement shapeElements()`);
+    }
+
+    /** Fill/stroke attributes for the main outline, merged with `extra`. */
+    paint(extra = {}) {
+        return {
+            fill: this.fillColor,
+            'fill-opacity': this.fillOpacity === 1 ? null : this.fillOpacity,
+            stroke: this.strokeColor,
+            'stroke-width': this.strokeWidth,
+            'stroke-opacity': this.strokeOpacity === 1 ? null : this.strokeOpacity,
+            ...extra,
+        };
+    }
+
+    /** Stroke-only attributes for interior detail lines. */
+    line(extra = {}) {
+        return { fill: 'none', stroke: this.strokeColor, 'stroke-width': Math.max(1, this.strokeWidth - 0.5), ...extra };
+    }
+
+    /** Draw into the editor's element group and wire interaction. */
+    render({ group, editor }) {
+        const g = this.renderElement(group.ownerDocument);
+        editor.attachElementHandlers(this.id, g);
+        group.appendChild(g);
+    }
+
+    /** Build the complete element group (outline + label) without attaching it. */
+    renderElement(doc = document) {
+        const g = svgEl('g', { 'data-id': this.id, 'data-template-id': this.id }, doc);
+        if (this.rotation) g.setAttribute('transform', `rotate(${this.rotation} ${this.x} ${this.y})`);
+        for (const node of this.shapeElements(doc)) g.appendChild(node);
+        this._renderLabel(g, doc);
+        return g;
+    }
+
+    /** Standalone thumbnail of the outline, scaled to fit a size x size box. */
+    renderPreview(size = 40, doc = document) {
+        const pad = this.strokeWidth + 2;
+        const svg = svgEl('svg', {
+            width: size,
+            height: size,
+            viewBox: `${this.left - pad} ${this.top - pad} ${this.width + pad * 2} ${this.height + pad * 2}`,
+            preserveAspectRatio: 'xMidYMid meet',
+        }, doc);
+        for (const node of this.shapeElements(doc)) svg.appendChild(node);
+        return svg;
+    }
+
+    _renderLabel(g, doc) {
+        const { x, y } = this.labelAnchor;
+        const text = (attrs, content) => {
+            const t = svgEl('text', {
+                'text-anchor': 'middle', 'dominant-baseline': 'middle', 'pointer-events': 'none', ...attrs,
+            }, doc);
+            t.textContent = content;
+            g.appendChild(t);
+        };
+        const style = this.textStyle;
+        const font = TextStyle.svgAttributes(style, { defaultPixels: 12 });
+        if (TextStyle.placesText(style)) {
+            // Placed in the shape's box by its alignment and position (centred, middle where unset).
+            const at = TextStyle.block(style, this, 1, { pixels: font['font-size'], defaults: { textAlign: 'center', textPosition: 'middle' } });
+            const placed = { 'text-anchor': at.textAnchor, 'dominant-baseline': 'auto' };
+            if (this.name) text({ x: at.x, y: at.baseline, ...font, ...placed, fill: this.textColor }, this.name);
+            return;
+        }
+        if (this.name) text({ x, y, ...font, fill: this.textColor }, this.name);
+    }
+
+    serialize() {
+        return {
+            id: this.id,
+            name: this.name,
+            x: this.x,
+            y: this.y,
+            zIndex: this.zIndex,
+            visible: this.visible,
+            width: this.width,
+            height: this.height,
+            rotation: this.rotation,
+            fillColor: this.fillColor,
+            fillOpacity: this.fillOpacity,
+            strokeColor: this.strokeColor,
+            strokeWidth: this.strokeWidth,
+            textColor: this.textColor,
+            ...(this.parentId ? { parentId: this.parentId } : {}),
+            ...(this.isContainer ? { isContainer: true } : {}),
+            ...this.textStyle,
+        };
+    }
+}

package/src/cli.js

@@ -0,0 +1,146 @@
+import { parseArchiFile, toArchiFile } from './archimateArchive.js';
+import { toArchimateModel, toArchiExport } from './archimateArchiFormat.js';
+import { parseExchangeModel, toExchangeXML } from './archimateExchangeFormat.js';
+import { ArchimateModelChecker } from './charting/diagrams/ArchimateModelChecker.js';
+import { reportHtml } from './charting/report/reportHtml.js';
+
+/**
+ * CLI and headless automation helpers: load, save, check and report
+ * ArchiMate models without a browser.
+ */
+
+/**
+ * Load an ArchiMate model from a file path or in-memory bytes/string.
+ * Supports .archimate (XML and zip archives with pictures) and
+ * Open Group Exchange Format (.xml).
+ *
+ * @param {string|Uint8Array|ArrayBuffer} input - File path, XML string, or archive bytes
+ * @param {Object} [options]
+ * @param {'auto'|'archi'|'exchange'} [options.format='auto']
+ * @returns {ArchimateModel}
+ */
+export function loadModel(input, { format = 'auto' } = {}) {
+    let data = input;
+    if (typeof input === 'string' && !input.includes('<') && !input.includes('{')) {
+        try {
+            const fs = globalThis.process?.getBuiltinModule ? globalThis.process.getBuiltinModule('node:fs') : null;
+            if (fs && fs.existsSync(input)) {
+                data = fs.readFileSync(input);
+            }
+        } catch {}
+    }
+
+    const isExchange = format === 'exchange' || (format === 'auto' && typeof data === 'string'
+        ? /opengroup\.org\/xsd\/archimate/.test(data)
+        : (data instanceof Uint8Array || Buffer.isBuffer(data)) && /opengroup\.org\/xsd\/archimate/.test(new TextDecoder().decode(data.slice(0, 4000))));
+
+    if (isExchange) {
+        const text = typeof data === 'string' ? data : new TextDecoder().decode(data);
+        return toArchimateModel(parseExchangeModel(text));
+    }
+
+    return toArchimateModel(parseArchiFile(data));
+}
+
+/**
+ * Run model validation checks over an ArchiMate model.
+ *
+ * @param {ArchimateModel} model
+ * @param {Object} [options]
+ * @param {string} [options.severity] - Filter by severity ('error', 'warning', 'info')
+ * @returns {{ findings: Array<Object>, summary: { total: number, errors: number, warnings: number, infos: number } }}
+ */
+export function checkModel(model, { severity = null } = {}) {
+    const checker = new ArchimateModelChecker(model);
+    let findings = checker.run();
+
+    if (severity) {
+        findings = findings.filter(f => f.severity === severity);
+    }
+
+    const summary = {
+        total: findings.length,
+        errors: findings.filter(f => f.severity === 'error').length,
+        warnings: findings.filter(f => f.severity === 'warning').length,
+        infos: findings.filter(f => f.severity === 'info' || !f.severity).length,
+    };
+
+    return { findings, summary };
+}
+
+/**
+ * Save an ArchiMate model to Archi format, Open Group Exchange format, or JSON.
+ *
+ * @param {ArchimateModel} model
+ * @param {Object} [options]
+ * @param {'archi'|'exchange'|'json'} [options.format='archi']
+ * @returns {{ data: string|Uint8Array, mimeType: string, archive: boolean }}
+ */
+export function saveModel(model, { format = 'archi' } = {}) {
+    const fmt = String(format).toLowerCase();
+    if (fmt === 'exchange' || fmt === 'xml-exchange') {
+        const xml = toExchangeXML(...toArchiExport(model));
+        return { data: xml, mimeType: 'application/xml', archive: false };
+    }
+    if (fmt === 'json') {
+        const payload = typeof model.toJSON === 'function'
+            ? model.toJSON()
+            : {
+                id: model.id,
+                name: model.name,
+                documentation: model.documentation,
+                elements: typeof model.elements === 'function' ? model.elements() : model.elements,
+                relationships: typeof model.relationships === 'function' ? model.relationships() : model.relationships,
+                views: typeof model.views === 'function'
+                    ? model.views().map(v => (typeof v.toJSON === 'function' ? v.toJSON() : v))
+                    : model.views,
+            };
+        const json = JSON.stringify(payload, null, 2);
+        return { data: json, mimeType: 'application/json', archive: false };
+    }
+    // Default: Archi format (.archimate: plain XML or zip archive with pictures)
+    return toArchiFile(...toArchiExport(model));
+}
+
+/**
+ * Generate a standalone HTML report of the model.
+ *
+ * @param {ArchimateModel} model
+ * @param {Object} [options]
+ * @param {string} [options.title]
+ * @returns {string} HTML content
+ */
+export function reportModel(model, { title = model.name || 'Model Report' } = {}) {
+    const reportData = model.report({ title }).data();
+    return reportHtml(reportData);
+}
+
+/**
+ * Format check findings into a human-readable string.
+ *
+ * @param {Array<Object>} findings
+ * @param {Object} [summary]
+ * @returns {string}
+ */
+export function formatFindings(findings, summary = null) {
+    if (!findings.length) {
+        return 'No issues found. Model is clean.';
+    }
+
+    const lines = [];
+    const iconOf = (s) => (s === 'error' ? '✖ [ERROR]' : s === 'warning' ? '▲ [WARN] ' : 'ℹ [INFO] ');
+
+    for (const f of findings) {
+        const sev = iconOf(f.severity);
+        const code = f.code ? ` (${f.code})` : '';
+        const ids = f.ids?.length ? ` [${f.ids.join(', ')}]` : '';
+        lines.push(`${sev}${code} ${f.message}${ids}`);
+    }
+
+    if (summary) {
+        lines.push('');
+        lines.push(`Total issues: ${summary.total} (${summary.errors} errors, ${summary.warnings} warnings, ${summary.infos} infos)`);
+    }
+
+    return lines.join('\n');
+}