@alfacapital-tech/c4builder 0.4.0-rc.4 → 0.5.0-rc.1

package/dist/core/render/bpmnrenderer.js

@@ -0,0 +1,522 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import chalk from 'chalk';
+import { DEFAULT_FONT_NAME } from "./fonts.js";
+import { getResvg, resvgFontOptions } from "./pngraster.js";
+// Третий бэкенд рендера: BPMN 2.0 XML без координат → валидация (bpmnlint) → раскладка
+// (bpmn-auto-layout) → рендер bpmn-js в jsdom → SVG. Все пакеты — optionalDependencies,
+// грузятся лениво при первом .bpmn: проекты без BPMN их не трогают (как D2).
+const require = createRequire(import.meta.url);
+// Версии этих пакетов идут в ключ кэша (render/diagrams): сдвиг раскладки, рендера или
+// правил валидации обязан перерисовать диаграмму.
+export const BPMN_CACHE_PACKAGES = ['bpmn-js', 'bpmn-auto-layout', 'bpmnlint'];
+// Ошибка конвейера: problems — по строке на нарушение без пути файла (check печатает их
+// как `✗ <file>: <problem>`), message — те же строки с путём для сборки.
+export class BpmnError extends Error {
+    problems;
+    constructor(file, problems) {
+        super(problems.map((p) => `${file}: ${p}`).join('\n'));
+        this.problems = problems;
+    }
+}
+// Имя пакета переменной: у пакетов нет типов, а import() по литералу потребовал бы их.
+const load = (name) => import(__rewriteRelativeImportExtension(name));
+// Набор правил фиксирован (design §4): recommended без no-bpmndi (DI в источнике не нужен
+// и всё равно отбрасывается) + правила c4builder. Проектного .bpmnlintrc нет сознательно:
+// что проверил агент через check, то же проверит CI.
+const lintConfig = (recommended) => ({
+    rules: {
+        ...recommended,
+        'no-bpmndi': 'off',
+        'c4builder/lane-membership': 'error',
+        'c4builder/sequence-flow-in-pool': 'error',
+        'c4builder/message-flow-between-pools': 'error',
+        'c4builder/gateway-flow-labels': 'warn'
+    }
+});
+const processOf = (el) => {
+    let cur = el;
+    while (cur && !cur.$instanceOf('bpmn:Process'))
+        cur = cur.$parent;
+    return cur;
+};
+// Листовые дорожки: у вложенной дорожки родитель по стандарту перечисляет те же узлы.
+const leafLanes = (laneSets = []) => laneSets
+    .flatMap((s) => s.lanes ?? [])
+    .flatMap((l) => (l.childLaneSet?.lanes?.length ? leafLanes([l.childLaneSet]) : [l]));
+const C4BUILDER_RULES = {
+    'lane-membership': () => ({
+        check(node, reporter) {
+            if (!node.$instanceOf('bpmn:Process'))
+                return;
+            const lanes = leafLanes(node.laneSets);
+            if (!lanes.length)
+                return;
+            const member = new Map();
+            for (const lane of lanes)
+                for (const ref of lane.flowNodeRef ?? [])
+                    member.set(ref, [...(member.get(ref) ?? []), lane.id]);
+            for (const el of node.flowElements ?? []) {
+                if (!el.$instanceOf('bpmn:FlowNode'))
+                    continue;
+                const of = member.get(el) ?? [];
+                // Граничное событие рисуется на границе своей задачи — дорожку берёт от неё.
+                if (!of.length && !el.$instanceOf('bpmn:BoundaryEvent'))
+                    reporter.report(el.id, 'Flow node is not in any lane of its process');
+                if (of.length > 1)
+                    reporter.report(el.id, `Flow node is in several lanes: ${of.join(', ')}`);
+            }
+        }
+    }),
+    'sequence-flow-in-pool': () => ({
+        check(node, reporter) {
+            if (!node.$instanceOf('bpmn:SequenceFlow'))
+                return;
+            const own = processOf(node);
+            if (processOf(node.sourceRef) !== own || processOf(node.targetRef) !== own)
+                reporter.report(node.id, 'Sequence flow crosses a pool boundary; connect pools with a message flow');
+        }
+    }),
+    'message-flow-between-pools': () => ({
+        check(node, reporter) {
+            if (!node.$instanceOf('bpmn:MessageFlow'))
+                return;
+            const participants = node.$parent?.participants ?? [];
+            const poolOf = (el) => el?.$instanceOf('bpmn:Participant')
+                ? el
+                : participants.find((p) => p.processRef && p.processRef === processOf(el));
+            const source = poolOf(node.sourceRef);
+            if (source && source === poolOf(node.targetRef))
+                reporter.report(node.id, 'Message flow connects elements of the same pool; use a sequence flow');
+        }
+    }),
+    'gateway-flow-labels': () => ({
+        check(node, reporter) {
+            if (!node.$instanceOf('bpmn:ExclusiveGateway') && !node.$instanceOf('bpmn:InclusiveGateway'))
+                return;
+            const outgoing = node.outgoing ?? [];
+            if (outgoing.length < 2)
+                return;
+            for (const flow of outgoing)
+                if (!flow.name?.trim() && flow !== node.default)
+                    reporter.report(flow.id, 'Outgoing flow of a diverging gateway has no label');
+        }
+    })
+};
+// Ширины строк для переноса подписей: diagram-js меряет текст только через
+// canvas.measureText, а jsdom канваса не умеет. Меряем вендорный Nimbus Sans тем же
+// resvg, что растрирует PNG: ширина = bbox «|текст|» минус bbox «||» — так получается
+// advance-ширина с пробелами по краям, а не ширина чернил. Режим системных шрифтов на
+// BPMN не влияет (как и на D2): детерминизм важнее.
+const widthMemo = new Map();
+const escapeXml = (s) => s.replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' })[c]);
+const inkWidth = (text, size) => {
+    const { Resvg } = getResvg();
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="1" height="1"><text y="${size}" ` +
+        `font-family="${DEFAULT_FONT_NAME}" font-size="${size}" xml:space="preserve">${escapeXml(text)}</text></svg>`;
+    return new Resvg(svg, { font: resvgFontOptions(false) }).getBBox()?.width ?? 0;
+};
+const textWidth = (text, size) => {
+    const key = `${size}\0${text}`;
+    let width = widthMemo.get(key);
+    if (width === undefined) {
+        // Округление гасит f32-шум resvg между платформами: координаты текста в SVG
+        // считаются из этой ширины и должны совпадать побайтно.
+        width = Math.round((inkWidth(`|${text}|`, size) - inkWidth('||', size)) * 100) / 100;
+        widthMemo.set(key, width);
+    }
+    return width;
+};
+// hhea Nimbus Sans Regular: ascender 729, descender −271 на 1000 единиц (vendor/fonts).
+const ASCENT = 0.729;
+const DESCENT = 0.271;
+// Полифилы окна jsdom: ровно то, что bpmn-js зовёт при импорте и saveSVG. Трансформации
+// пишутся в атрибут сразу — сериализатор берёт атрибуты, а не baseVal.
+const installPolyfills = (window) => {
+    class Matrix {
+        a;
+        b;
+        c;
+        d;
+        e;
+        f;
+        constructor(a = 1, b = 0, c = 0, d = 1, e = 0, f = 0) {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+            this.d = d;
+            this.e = e;
+            this.f = f;
+        }
+        multiply(m) {
+            return new Matrix(this.a * m.a + this.c * m.b, this.b * m.a + this.d * m.b, this.a * m.c + this.c * m.d, this.b * m.c + this.d * m.d, this.a * m.e + this.c * m.f + this.e, this.b * m.e + this.d * m.f + this.f);
+        }
+    }
+    class Transform {
+        matrix = new Matrix();
+        setMatrix(m) {
+            this.matrix = new Matrix(m.a, m.b, m.c, m.d, m.e, m.f);
+        }
+        setTranslate(x, y) {
+            this.matrix = new Matrix(1, 0, 0, 1, x, y);
+        }
+        setScale(x, y) {
+            this.matrix = new Matrix(x, 0, 0, y);
+        }
+        setRotate(angle) {
+            const r = (angle * Math.PI) / 180;
+            this.matrix = new Matrix(Math.cos(r), Math.sin(r), -Math.sin(r), Math.cos(r));
+        }
+    }
+    const fromMatrix = (m) => {
+        const t = new Transform();
+        t.setMatrix(m);
+        return t;
+    };
+    // -0 и хвосты плавающей точки в атрибуте дали бы разный текст для одинаковой геометрии.
+    const num = (v) => Number(v.toFixed(6)) || 0;
+    class TransformList {
+        el;
+        items = [];
+        constructor(el) {
+            this.el = el;
+        }
+        clear() {
+            this.items = [];
+            this.el.removeAttribute('transform');
+        }
+        appendItem(t) {
+            this.items.push(t);
+            const m = this.items.reduce((acc, i) => acc.multiply(i.matrix), new Matrix());
+            this.el.setAttribute('transform', `matrix(${[m.a, m.b, m.c, m.d, m.e, m.f].map(num).join(' ')})`);
+            return t;
+        }
+        createSVGTransformFromMatrix = fromMatrix;
+        consolidate() {
+            return this.items.length
+                ? fromMatrix(this.items.reduce((acc, i) => acc.multiply(i.matrix), new Matrix()))
+                : null;
+        }
+    }
+    const polyline = (el) => {
+        const pts = [...(el.getAttribute('d') ?? '').matchAll(/[MLC]([^MLCZ]+)/gi)].map((m) => {
+            const n = m[1]
+                .trim()
+                .split(/[\s,]+/)
+                .map(Number);
+            return { x: n[n.length - 2], y: n[n.length - 1] };
+        });
+        const seg = pts.slice(1).map((p, i) => Math.hypot(p.x - pts[i].x, p.y - pts[i].y));
+        return {
+            length: seg.reduce((a, b) => a + b, 0),
+            pointAt(at) {
+                let rest = at;
+                for (const [i, len] of seg.entries()) {
+                    if (rest <= len && len > 0) {
+                        const t = rest / len;
+                        return {
+                            x: pts[i].x + (pts[i + 1].x - pts[i].x) * t,
+                            y: pts[i].y + (pts[i + 1].y - pts[i].y) * t
+                        };
+                    }
+                    rest -= len;
+                }
+                return pts[pts.length - 1] ?? { x: 0, y: 0 };
+            }
+        };
+    };
+    const lists = new WeakMap();
+    const svgProto = window.SVGElement.prototype;
+    Object.defineProperty(svgProto, 'transform', {
+        get() {
+            const list = lists.get(this) ?? new TransformList(this);
+            lists.set(this, list);
+            return { baseVal: list };
+        }
+    });
+    Object.assign(svgProto, {
+        createSVGMatrix: () => new Matrix(),
+        createSVGTransform: () => new Transform(),
+        createSVGTransformFromMatrix: fromMatrix,
+        getCTM: () => new Matrix(),
+        getScreenCTM: () => new Matrix(),
+        // saveSVG зовёт его для viewBox, который пересчитывается из DI (finalizeSvg).
+        // ponytail: подпись messageRef на message flow центрируется по getBBox и съезжает
+        // на полширины вправо — честный bbox текста добавить, если такие подписи пойдут в ход.
+        getBBox: () => ({ x: 0, y: 0, width: 0, height: 0 }),
+        // Середина message flow для конверта messageRef: ломаная по концам сегментов
+        // M/L/C пути diagram-js (скругления углов заменяются хордой).
+        getTotalLength() {
+            return polyline(this).length;
+        },
+        getPointAtLength(at) {
+            return polyline(this).pointAt(at);
+        }
+    });
+    window.SVGMatrix = Matrix;
+    window.structuredClone = structuredClone;
+    const ctx = {
+        font: '12px sans-serif',
+        measureText(text) {
+            const size = Number(/([\d.]+)px/.exec(this.font)?.[1] ?? 12);
+            return {
+                width: textWidth(text, size),
+                fontBoundingBoxAscent: ASCENT * size,
+                fontBoundingBoxDescent: DESCENT * size
+            };
+        }
+    };
+    window.HTMLCanvasElement.prototype.getContext = () => ctx;
+};
+let enginePromise = null;
+const getEngine = () => {
+    enginePromise ??= (async () => {
+        let BpmnModdle;
+        let LinterClass;
+        let layoutProcess;
+        let JSDOM;
+        let VirtualConsole;
+        let bundlePath;
+        // Последовательно, не Promise.all: bpmnlint (CJS) делает require() ESM-зависимостей,
+        // которые параллельный import() ещё не догрузил, — Node падает на гонке.
+        try {
+            ({ BpmnModdle } = await load('bpmn-moddle'));
+            ({ Linter: LinterClass } = await load('bpmnlint'));
+            ({ layoutProcess } = await load('bpmn-auto-layout'));
+            ({ JSDOM, VirtualConsole } = await load('jsdom'));
+            bundlePath = require.resolve('bpmn-js/dist/bpmn-viewer.production.min.js');
+        }
+        catch (err) {
+            enginePromise = null; // провал импорта не кешируем — даём повторить
+            throw new Error('Rendering .bpmn diagrams requires the optional packages bpmn-js, bpmn-moddle, bpmnlint, ' +
+                'bpmn-auto-layout and jsdom.\n' +
+                'Reinstall without --omit=optional: npm i -g @alfacapital-tech/c4builder\n' +
+                `Original error: ${err.message || err}`);
+        }
+        const recommended = require('bpmnlint/config/recommended')
+            .rules;
+        const resolver = {
+            resolveRule: (pkg, name) => pkg === 'bpmnlint' ? require(`bpmnlint/rules/${name}`) : C4BUILDER_RULES[name],
+            resolveConfig: () => null
+        };
+        // Бандл Viewer исполняется внутри окна: глобальные объекты процесса Node не трогаются.
+        // Консоль окна глушим: сбои импорта bpmn-js пишет туда, мы берём их из warnings.
+        const { window } = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+            runScripts: 'outside-only',
+            virtualConsole: new VirtualConsole()
+        });
+        installPolyfills(window);
+        window.eval(readFileSync(bundlePath, 'utf8'));
+        return {
+            moddle: new BpmnModdle(),
+            // Линтер — на каждый прогон: правила bpmnlint (no-duplicate-sequence-flows и др.)
+            // копят состояние в замыкании фабрики, и повторный lint тем же инстансом
+            // объявил бы дубликатами все потоки.
+            createLinter: () => new LinterClass({ config: lintConfig(recommended), resolver }),
+            layoutProcess,
+            window
+        };
+    })();
+    return enginePromise;
+};
+// Окно jsdom одно на процесс; закрывается после одиночной сборки и в check (как воркер
+// D2), чтобы CLI завершался. Не бросает — иначе затёр бы исходную причину падения.
+export const teardownBpmn = async () => {
+    if (!enginePromise)
+        return;
+    const pending = enginePromise;
+    enginePromise = null;
+    widthMemo.clear();
+    try {
+        (await pending).window.close();
+    }
+    catch {
+        // движок не поднялся — закрывать нечего
+    }
+};
+const visit = (el, fn) => {
+    fn(el);
+    for (const child of el.flowElements ?? [])
+        visit(child, fn);
+};
+// Разбор и нормализация (design §3.1). bpmnlint и раскладчик опираются на
+// incoming/outgoing, а агент пишет только sourceRef/targetRef — восстанавливаем их по
+// потокам, иначе каскад ложных no-disconnected. DI источника отбрасываем всегда.
+export const parseBpmn = async (xml, file) => {
+    const { moddle } = await getEngine();
+    let parsed;
+    try {
+        parsed = await moddle.fromXML(xml.replace(/^/, ''));
+    }
+    catch (err) {
+        throw new BpmnError(file, [`invalid BPMN XML: ${oneLine(err.message)}`]);
+    }
+    if (parsed.warnings.length)
+        throw new BpmnError(file, parsed.warnings.map((w) => `${w.element?.id ? `${w.element.id}: ` : ''}${oneLine(w.message)}`));
+    const definitions = parsed.rootElement;
+    const elements = [];
+    for (const root of definitions.rootElements ?? [])
+        visit(root, (el) => elements.push(el));
+    for (const el of elements)
+        if (el.$instanceOf('bpmn:FlowNode')) {
+            el.incoming = [];
+            el.outgoing = [];
+        }
+    for (const flow of elements)
+        if (flow.$instanceOf('bpmn:SequenceFlow')) {
+            flow.sourceRef?.outgoing?.push(flow);
+            flow.targetRef?.incoming?.push(flow);
+        }
+    definitions.diagrams = [];
+    return definitions;
+};
+const oneLine = (s) => s.replace(/\s*\n\s*/g, ', ');
+export const lintBpmn = async (definitions) => {
+    const linter = (await getEngine()).createLinter();
+    const errors = [];
+    const warnings = [];
+    for (const [rule, reports] of Object.entries(await linter.lint(definitions)))
+        for (const r of reports)
+            (r.category === 'warn' ? warnings : errors).push(`${r.id ?? '-'} [${rule}] ${r.message}`);
+    return { errors, warnings };
+};
+// Элементы, которые обязаны получить фигуру в DI (защита от bpmn-auto-layout#154:
+// раскладчик молча теряет узлы и рёбра при пустых warnings).
+const expectedDi = (definitions) => {
+    const out = [];
+    const lanes = (sets = []) => {
+        for (const lane of sets.flatMap((s) => s.lanes ?? [])) {
+            out.push(lane);
+            if (lane.childLaneSet)
+                lanes([lane.childLaneSet]);
+        }
+    };
+    for (const root of definitions.rootElements ?? []) {
+        out.push(...(root.participants ?? []), ...(root.messageFlows ?? []));
+        if (!root.$instanceOf('bpmn:Process'))
+            continue;
+        visit(root, (el) => {
+            lanes(el.laneSets);
+            if (el.$instanceOf('bpmn:FlowNode') || el.$instanceOf('bpmn:SequenceFlow'))
+                out.push(el);
+        });
+    }
+    return out;
+};
+export const layoutBpmn = async (definitions, file, layout) => {
+    const engine = await getEngine();
+    let result;
+    try {
+        result = await (layout ?? engine.layoutProcess)((await engine.moddle.toXML(definitions)).xml);
+    }
+    catch (err) {
+        const e = err;
+        throw new BpmnError(file, [
+            `layout failed: ${e.elementId ? `${e.elementId}: ` : ''}${oneLine(e.message || String(e))}`
+        ]);
+    }
+    const laidOut = (await engine.moddle.fromXML(result.xml)).rootElement;
+    const drawn = new Set((laidOut.diagrams ?? []).flatMap((d) => (d.plane?.planeElement ?? []).map((p) => p.bpmnElement?.id)));
+    const lost = expectedDi(laidOut)
+        .map((el) => el.id)
+        .filter((id) => !drawn.has(id));
+    if (lost.length)
+        throw new BpmnError(file, [
+            `layout lost ${lost.length} element(s): ${lost.join(', ')} (bpmn-auto-layout defect; ` +
+                'simplify or split the model)'
+        ]);
+    return {
+        xml: result.xml,
+        warnings: result.warnings.map((w) => `${w.elementId ?? '-'} [layout${w.code ? `:${w.code}` : ''}] ${oneLine(w.message)}`)
+    };
+};
+// Постобработка SVG (design §3.5): viewBox по DI вместо getBBox, детерминированные id
+// маркеров (bpmn-js генерирует случайные) и url(#…) без кавычек — resvg ссылки в
+// кавычках игнорирует, и стрелки в PNG пропадают.
+const PADDING = 10;
+const finalizeSvg = (svg, elements) => {
+    let [x0, y0, x1, y1] = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const el of elements) {
+        const points = el.waypoints ??
+            (el.x === undefined || el.y === undefined
+                ? []
+                : [
+                    { x: el.x, y: el.y },
+                    { x: el.x + (el.width ?? 0), y: el.y + (el.height ?? 0) }
+                ]);
+        for (const p of points) {
+            x0 = Math.min(x0, p.x);
+            y0 = Math.min(y0, p.y);
+            x1 = Math.max(x1, p.x);
+            y1 = Math.max(y1, p.y);
+        }
+    }
+    if (x0 === Infinity)
+        [x0, y0, x1, y1] = [0, 0, 0, 0];
+    const x = Math.floor(x0) - PADDING;
+    const y = Math.floor(y0) - PADDING;
+    const w = Math.ceil(x1) - Math.floor(x0) + 2 * PADDING;
+    const h = Math.ceil(y1) - Math.floor(y0) + 2 * PADDING;
+    const ids = new Map();
+    for (const [, id] of svg.matchAll(/id="(marker-[^"]+)"/g))
+        if (!ids.has(id))
+            ids.set(id, `marker-${ids.size + 1}`);
+    return svg
+        .replace(/ width="[^"]*" height="[^"]*" viewBox="[^"]*"/, ` width="${w}" height="${h}" viewBox="${x} ${y} ${w} ${h}"`)
+        .replace(/marker-[0-9a-z]+/g, (m) => ids.get(m) ?? m)
+        .replace(/url\('#([^']+)'\)/g, 'url(#$1)');
+};
+const renderSvg = async (xml) => {
+    const { window } = await getEngine();
+    const container = window.document.createElement('div');
+    window.document.body.appendChild(container);
+    const viewer = new window.BpmnJS({
+        container,
+        // Nimbus Sans метрически совместим с Helvetica/Arial: в браузере без него SVG
+        // показывается ими с теми же переносами.
+        textRenderer: { defaultStyle: { fontFamily: `${DEFAULT_FONT_NAME}, Helvetica, Arial, sans-serif` } }
+    });
+    try {
+        // Элемент, который bpmn-js не смог нарисовать, иначе молча пропал бы из картинки.
+        const { warnings } = await viewer.importXML(xml);
+        if (warnings.length)
+            throw new Error(warnings
+                .map((w) => `${w.element?.id ? `${w.element.id}: ` : ''}${oneLine(w.message)}`)
+                .join('; '));
+        const { svg } = await viewer.saveSVG();
+        return finalizeSvg(svg, viewer.get('elementRegistry').getAll());
+    }
+    finally {
+        viewer.destroy();
+        container.remove();
+    }
+};
+// Полный конвейер одного файла — общий для сборки и `c4builder check`. file — путь для
+// сообщений; предупреждения валидации и раскладки печатаются, но рендер не прерывают.
+export const renderBpmn = async (xml, file) => {
+    const definitions = await parseBpmn(xml, file);
+    const lint = await lintBpmn(definitions);
+    for (const w of lint.warnings)
+        console.log(chalk.yellow(`⚠ ${file}: ${w}`));
+    if (lint.errors.length)
+        throw new BpmnError(file, lint.errors);
+    const laidOut = await layoutBpmn(definitions, file);
+    for (const w of laidOut.warnings)
+        console.log(chalk.yellow(`⚠ ${file}: ${w}`));
+    let svg;
+    try {
+        svg = await renderSvg(laidOut.xml);
+    }
+    catch (err) {
+        throw new BpmnError(file, [`render failed: ${oneLine(err.message || String(err))}`]);
+    }
+    return Buffer.from(svg, 'utf8');
+};

package/dist/core/render/d2renderer.js

@@ -18,9 +18,9 @@ const getD2 = () => {
         catch (err) {
             d2Promise = null; // провал импорта не кешируем — даём повторить
             const e = err;
-            throw new Error('Для рендера .d2-диаграмм нужен пакет @terrastruct/d2 (опциональная зависимость, ~60 МБ).\n' +
-                'Установите его: npm install @terrastruct/d2\n' +
-                `Исходная ошибка: ${e.message || e}`);
+            throw new Error('Rendering .d2 diagrams requires the @terrastruct/d2 package (optional dependency, ~60 MB).\n' +
+                'Install it: npm install @terrastruct/d2\n' +
+                `Original error: ${e.message || e}`);
         }
         return new mod.D2();
     })();
@@ -114,7 +114,7 @@ const collectFiles = (entryAbs, acc = new Map(), seed) => {
 // buildCompileRequest (рендер) иначе читают один и тот же граф с диска дважды.
 // Ключ — абсолютный путь входного файла. Сбрасывается clearD2FileCache() на границах
 // build(), иначе watch-режим отдавал бы устаревшее содержимое. Возвращаемую Map
-// потребители НЕ мутируют (foldD2Imports исключает входной файл фильтром, не delete).
+// потребители НЕ мутируют (d2LocalImports исключает входной файл фильтром, не delete).
 let filesMemo = null;
 const clearD2FileCache = () => {
     filesMemo = null;
@@ -151,7 +151,7 @@ const buildCompileRequest = (entryAbs, seed) => {
     // Пустой граф = не прочитался сам входной файл (удалён/недоступен — гонка в watch).
     // Без guard'а commonAncestor([]) давал бы сырой TypeError (Math.min()=Infinity).
     if (files.size === 0) {
-        throw new Error(`D2: не удалось прочитать ${entryAbs} (файл удалён или недоступен?)`);
+        throw new Error(`D2: failed to read ${entryAbs} (file deleted or unavailable?)`);
     }
     const root = commonAncestor([...files.keys()]);
     const toKey = (abs) => path.relative(root, abs).split(path.sep).join('/');
@@ -181,7 +181,7 @@ const renderD2 = async (entryAbs, { layout = 'dagre', seed } = {}) => {
     }
     catch (err) {
         const e = err;
-        throw new Error(`Ошибка компиляции D2 (${entryAbs}):\n${d2ErrorText(e.message || String(e))}`);
+        throw new Error(`D2 compile error (${entryAbs}):\n${d2ErrorText(e.message || String(e))}`);
     }
     let svg;
     try {
@@ -189,27 +189,27 @@ const renderD2 = async (entryAbs, { layout = 'dagre', seed } = {}) => {
     }
     catch (err) {
         const e = err;
-        throw new Error(`Ошибка рендера D2 (${entryAbs}):\n${e.message || e}`);
+        throw new Error(`D2 render error (${entryAbs}):\n${e.message || e}`);
     }
     return Buffer.from(svg, 'utf8');
 };
-// Материал импортов для чексуммы кэша (без самого входного файла — его контент
-// хэшируется отдельно). Правка импортируемого .d2 меняет чексумму зависимой
-// диаграммы — аналог foldIncludes для PlantUML.
+// Локальные импорты .d2 рекурсивно, без самого входного файла. Один граф на рендер,
+// чексумму кэша (foldD2Imports) и приложение llms-full.txt.
+const d2LocalImports = (entryAbs, seed) => {
+    const abs = path.resolve(entryAbs);
+    return [...collectFilesCached(entryAbs, seed).entries()].filter(([p]) => p !== abs);
+};
+// Материал импортов для чексуммы кэша (входной файл хэшируется отдельно). Правка
+// импортируемого .d2 меняет чексумму зависимой диаграммы — аналог foldIncludes для PlantUML.
 // Путь в материале — относительный к cwd, posix-разделители: чексумма не зависит
-// от машины/чекаута/ОС (абсолютный путь делал кеш непереносимым).
+// от машины/чекаута/ОС (абсолютный путь делал кеш непереносимым). Сортировка по
+// относительному ключу — тому же, что уходит в материал.
 const foldD2Imports = (entryAbs, seed) => {
-    const abs = path.resolve(entryAbs);
-    const files = collectFilesCached(entryAbs, seed);
     const rel = (p) => path.relative(process.cwd(), p).split(path.sep).join('/');
-    // Мемоизированную Map не мутируем (её же использует buildCompileRequest) —
-    // входной файл исключаем фильтром, а не delete. Сортировка по относительному
-    // ключу — тому же, что уходит в материал.
-    return [...files.entries()]
-        .filter(([p]) => p !== abs)
+    return d2LocalImports(entryAbs, seed)
         .map(([p, content]) => [rel(p), content])
         .sort((a, b) => a[0].localeCompare(b[0]))
         .map(([p, content]) => ` ${p} ${content}`)
         .join('');
 };
-export { renderD2, foldD2Imports, teardownD2, clearD2FileCache };
+export { renderD2, foldD2Imports, d2LocalImports, teardownD2, clearD2FileCache };