@xgent-ai/skills 0.7.4 → 0.7.6

package/skills/archify/test/workflow-compiler.test.mjs

@@ -1,1163 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { compileWorkflow } from '../renderers/workflow/workflow-compiler.mjs';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const skillRoot = path.resolve(__dirname, '..');
-const cli = path.join(skillRoot, 'bin', 'archify.mjs');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-workflow-compiler-'));
-
-function readJson(file) {
-  return JSON.parse(fs.readFileSync(file, 'utf8'));
-}
-
-function clone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-function sha256(value) {
-  return createHash('sha256').update(value).digest('hex');
-}
-
-function attribute(tag, name) {
-  const value = tag.match(new RegExp(`\\b${name}="([^"]*)"`))?.[1];
-  assert.notEqual(value, undefined, `expected ${name} in ${tag}`);
-  return value;
-}
-
-function numericRect(attributes) {
-  return Object.fromEntries(['x', 'y', 'width', 'height'].map((name) => [
-    name,
-    Number(attribute(attributes, name)),
-  ]));
-}
-
-function nodeRect(svg, id) {
-  const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const attributes = svg.match(new RegExp(
-    `<g\\b[^>]*id="node-${escapedId}"[^>]*>[\\s\\S]*?<rect\\b([^>]*)>`,
-  ))?.[1];
-  assert.ok(attributes, `expected rendered node ${id}`);
-  return numericRect(attributes);
-}
-
-function edgePoints(svg, id) {
-  const tag = (svg.match(/<path\b[^>]*>/g) || []).find((candidate) => (
-    attributeOrUndefined(candidate, 'data-edge-id') === id
-  ));
-  assert.ok(tag, `expected rendered edge ${id}`);
-  return attribute(tag, 'data-composition-points')
-    .split(';')
-    .map((point) => point.split(',').map(Number));
-}
-
-function edgeLabelRect(svg, id) {
-  const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const attributes = svg.match(new RegExp(
-    `<g\\b(?=[^>]*data-edge-id="${escapedId}")(?=[^>]*data-edge-label=)[^>]*>[\\s\\S]*?<rect\\b([^>]*)>`,
-  ))?.[1];
-  assert.ok(attributes, `expected rendered label mask for edge ${id}`);
-  return numericRect(attributes);
-}
-
-function attributeOrUndefined(tag, name) {
-  return tag.match(new RegExp(`\\b${name}="([^"]*)"`))?.[1];
-}
-
-function svgViewBox(svg) {
-  const tag = svg.match(/<svg\b[^>]*>/)?.[0];
-  assert.ok(tag, 'expected an SVG root');
-  return attribute(tag, 'viewBox').split(/\s+/).map(Number);
-}
-
-function legendGeometry(svg) {
-  return svg.match(/<g data-legend-semantic-kind="[^"]+"[^>]*>/g) || [];
-}
-
-function assertRectInsideViewBox(rect, viewBox, message) {
-  const [minX, minY, width, height] = viewBox;
-  assert.ok(rect.x >= minX, `${message}: left edge ${rect.x} is outside ${minX}`);
-  assert.ok(rect.y >= minY, `${message}: top edge ${rect.y} is outside ${minY}`);
-  assert.ok(
-    rect.x + rect.width <= minX + width,
-    `${message}: right edge ${rect.x + rect.width} is outside ${minX + width}`,
-  );
-  assert.ok(
-    rect.y + rect.height <= minY + height,
-    `${message}: bottom edge ${rect.y + rect.height} is outside ${minY + height}`,
-  );
-}
-
-function assertRectInsideRect(rect, container, message) {
-  assert.ok(rect.x >= container.x, `${message}: left edge ${rect.x} is outside ${container.x}`);
-  assert.ok(rect.y >= container.y, `${message}: top edge ${rect.y} is outside ${container.y}`);
-  assert.ok(
-    rect.x + rect.width <= container.x + container.width,
-    `${message}: right edge ${rect.x + rect.width} is outside ${container.x + container.width}`,
-  );
-  assert.ok(
-    rect.y + rect.height <= container.y + container.height,
-    `${message}: bottom edge ${rect.y + rect.height} is outside ${container.y + container.height}`,
-  );
-}
-
-function groupFrameRect(svg, index = 0) {
-  const attributes = svg.match(new RegExp(
-    `<rect\\b(?=[^>]*data-composition-frame-kind="group")(?=[^>]*data-composition-frame-id="group-${index}")([^>]*)/>`,
-  ))?.[1];
-  assert.ok(attributes, `expected rendered group frame ${index}`);
-  return numericRect(attributes);
-}
-
-function asciiGroupLabelTextRect(svg, label) {
-  const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const attributes = svg.match(new RegExp(`<text\\b([^>]*)>${escapedLabel}</text>`))?.[1];
-  assert.ok(attributes, `expected rendered group label ${label}`);
-  return {
-    x: Number(attribute(attributes, 'x')),
-    y: Number(attribute(attributes, 'y')) - 10,
-    width: Array.from(label).length * 5.6,
-    height: 14,
-  };
-}
-
-function rectsOverlap(left, right) {
-  return !(
-    left.x + left.width <= right.x
-    || right.x + right.width <= left.x
-    || left.y + left.height <= right.y
-    || right.y + right.height <= left.y
-  );
-}
-
-function orthogonalSegmentIntersectsRect(start, end, rect) {
-  const left = rect.x;
-  const right = rect.x + rect.width;
-  const top = rect.y;
-  const bottom = rect.y + rect.height;
-  if (start[1] === end[1]) {
-    return start[1] >= top && start[1] <= bottom
-      && Math.max(start[0], end[0]) >= left
-      && Math.min(start[0], end[0]) <= right;
-  }
-  if (start[0] === end[0]) {
-    return start[0] >= left && start[0] <= right
-      && Math.max(start[1], end[1]) >= top
-      && Math.min(start[1], end[1]) <= bottom;
-  }
-  throw new Error(`expected an orthogonal route segment: ${JSON.stringify([start, end])}`);
-}
-
-function asciiLaneHeaderTextRect(label, { laneTop = 52, laneIndex = 0 } = {}) {
-  const prefix = String(laneIndex + 1).padStart(2, '0');
-  return {
-    x: 54,
-    y: laneTop + 12,
-    width: Array.from(`${prefix} / ${label}`).length * 6.2,
-    height: 14,
-  };
-}
-
-function compileSuccessfully(workflow, qualityProfile) {
-  const request = qualityProfile === undefined
-    ? { workflow }
-    : { workflow, qualityProfile };
-  const result = compileWorkflow(request);
-  assert.equal(
-    result.ok,
-    true,
-    `expected workflow compilation to succeed:\n${JSON.stringify(result.diagnostics, null, 2)}`,
-  );
-  assert.equal(typeof result.svg, 'string');
-  assert.match(result.svg, /^\s*<svg\b/, 'compiler should return one canonical renderer SVG');
-  assert.ok(result.receipt);
-  assert.deepEqual(result.receipt.diagnostics, []);
-  return result;
-}
-
-function adjacentWorkflow({
-  fromCol = 1,
-  toCol = fromCol + 1,
-  label,
-  widths = [92, 92],
-  nodeLabels = ['A', 'B'],
-  viewBox,
-  frames = false,
-} = {}) {
-  const workflow = {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: {
-      title: `Adjacent ranks ${fromCol} to ${toCol}`,
-      legend: { mode: 'hidden' },
-      ...(viewBox ? { viewBox } : {}),
-    },
-    lanes: [{ id: 'main', label: 'Main' }],
-    nodes: [
-      {
-        id: 'a', lane: 'main', col: fromCol, type: 'backend', label: nodeLabels[0], width: widths[0],
-      },
-      {
-        id: 'b', lane: 'main', col: toCol, type: 'backend', label: nodeLabels[1], width: widths[1],
-      },
-    ],
-    edges: [{ id: 'ab', from: 'a', to: 'b', ...(label ? { label } : {}) }],
-  };
-  if (frames) {
-    workflow.phases = [{
-      id: 'phase', label: 'P', fromCol, toCol,
-    }];
-    workflow.groups = [{
-      id: 'group', label: 'G', lane: 'main', fromCol, toCol,
-    }];
-  }
-  return workflow;
-}
-
-function assertReadableAdjacentResult(result, { label, widths = [92, 92] } = {}) {
-  assert.equal(result.receipt.contract, 'readable-v2');
-  assert.deepEqual(result.receipt.viewBox, svgViewBox(result.svg).slice(2));
-  assert.ok(Array.isArray(result.receipt.requiredViewBox));
-  assert.equal(result.receipt.columns.length, 6);
-  assert.ok(result.receipt.columns.every(Number.isFinite));
-  for (let index = 1; index < result.receipt.columns.length; index += 1) {
-    assert.ok(
-      result.receipt.columns[index] > result.receipt.columns[index - 1],
-      `column ${index} must be strictly after column ${index - 1}`,
-    );
-  }
-
-  const source = nodeRect(result.svg, 'a');
-  const target = nodeRect(result.svg, 'b');
-  assert.equal(source.width, widths[0]);
-  assert.equal(target.width, widths[1]);
-  assert.ok(source.x + source.width <= target.x, 'same-lane nodes must not overlap');
-
-  const points = edgePoints(result.svg, 'ab');
-  assert.deepEqual(points.length, 2, `adjacent facing nodes should use a direct route: ${JSON.stringify(points)}`);
-  assert.equal(points[0][0], source.x + source.width, 'edge must leave the source right side');
-  assert.equal(points[1][0], target.x, 'edge must enter the target left side');
-  assert.equal(points[0][1], points[1][1], 'direct route must be horizontal');
-  const directClearance = points[1][0] - points[0][0];
-  assert.ok(directClearance >= 28, `direct clearance ${directClearance}px must be at least 28px`);
-
-  if (label) {
-    const mask = edgeLabelRect(result.svg, 'ab');
-    assert.ok(
-      directClearance + 1e-9 >= mask.width + 8,
-      `labeled direct clearance ${directClearance}px must fit ${mask.width}px mask plus 8px breathing room`,
-    );
-    assertRectInsideViewBox(mask, svgViewBox(result.svg), 'edge label mask');
-  }
-}
-
-test('fixed-v1 compiler preserves the official workflow baseline SVG byte-for-byte', () => {
-  const workflow = readJson(path.join(__dirname, 'fixtures', 'v1-baseline', 'agent-tool-call.workflow.json'));
-  const result = compileSuccessfully(workflow);
-  assert.equal(result.receipt.contract, 'fixed-v1');
-  assert.equal(
-    sha256(result.svg),
-    '4e493db1977889675ce7b04bf9ba60fb97cb50f01fc0fd9e8446861282c65645',
-  );
-});
-
-test('fixed-v1 compiler preserves the exact 700x400 compatibility geometry', () => {
-  const workflow = readJson(path.join(
-    __dirname,
-    'fixtures',
-    'v1-workflow-700x400.workflow.json',
-  ));
-
-  const result = compileSuccessfully(workflow);
-  assert.equal(result.receipt.contract, 'fixed-v1');
-  assert.deepEqual(result.receipt.viewBox, [700, 400]);
-  assert.deepEqual(svgViewBox(result.svg), [0, 0, 700, 400]);
-  assert.equal(
-    sha256(result.svg),
-    '28b0167460d16c55ae6bf38bde41368248671a78b3a49133da05ed1efb4354af',
-    'the v1 compiler extraction must not move or reserialize legacy geometry',
-  );
-});
-
-test('fixed-v1 keeps valid phase and group spans independent of label measurement', () => {
-  const workflow = {
-    schema_version: 1,
-    diagram_type: 'workflow',
-    meta: { title: 'Fixed v1 frame geometry', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'main', label: 'Main' }],
-    phases: [{ id: 'phase', label: 'P'.repeat(17), fromCol: 0, toCol: 0 }],
-    groups: [{
-      id: 'group', label: 'G'.repeat(30), lane: 'main', fromCol: 0, toCol: 0,
-    }],
-    nodes: [{ id: 'a', lane: 'main', col: 0, type: 'backend', label: 'A' }],
-    edges: [],
-  };
-
-  const result = compileSuccessfully(workflow);
-  assert.match(
-    result.svg,
-    /<line x1="42" y1="35" x2="134" y2="35"/,
-    'v1 phase spans must retain the legacy fixed 46px padding',
-  );
-  assert.match(
-    result.svg,
-    /data-composition-frame-kind="group"[^>]* x="38" y="90" width="100"/,
-    'v1 group spans must retain the legacy fixed 50px padding',
-  );
-});
-
-test('fixed-v1 reports one causal column-capacity diagnostic for issue #126', () => {
-  const workflow = {
-    schema_version: 1,
-    diagram_type: 'workflow',
-    meta: { title: 'Issue 126 causal diagnostic', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'main', label: 'Main' }],
-    nodes: [
-      { id: 'a', lane: 'main', col: 1, type: 'backend', label: 'A' },
-      { id: 'b', lane: 'main', col: 2, type: 'backend', label: 'B' },
-    ],
-    edges: [{ id: 'ab', from: 'a', to: 'b', label: 'liga' }],
-  };
-
-  const result = compileWorkflow({ workflow, qualityProfile: 'showcase' });
-  assert.equal(result.ok, false);
-  assert.equal(result.diagnostics.length, 1, JSON.stringify(result.diagnostics, null, 2));
-  assert.deepEqual(result.receipt.diagnostics, result.diagnostics);
-
-  const [diagnostic] = result.diagnostics;
-  assert.equal(diagnostic.code, 'workflow/column-capacity');
-  assert.equal(diagnostic.subject.edge, 'ab');
-  assert.equal(diagnostic.subject.from, 'a');
-  assert.equal(diagnostic.subject.to, 'b');
-  assert.equal(diagnostic.subject.fromCol, 1);
-  assert.equal(diagnostic.subject.toCol, 2);
-  assert.deepEqual(diagnostic.evidence, {
-    centerDistancePx: 80,
-    nodeWidthsPx: [92, 92],
-    actualSignedClearancePx: -12,
-    requiredDirectClearancePx: 28,
-  });
-  assert.deepEqual(diagnostic.suppresses, [
-    'workflow/short-edge',
-    'clean-flow/endpoint-side-direction',
-    'workflow/label-node-overlap',
-  ]);
-  assert.ok(diagnostic.supportedFixes.some((fix) => /schema_version 2/.test(fix)));
-  assert.ok(diagnostic.supportedFixes.some((fix) => /column 3/.test(fix)));
-  assert.ok(diagnostic.supportedFixes.some((fix) => /width/i.test(fix)));
-  assert.doesNotMatch(
-    diagnostic.supportedFixes.join('\n'),
-    /drop|remove|omit|unlabel|channel/i,
-    'a causal overlap diagnostic must not propose a label or routing non-fix',
-  );
-});
-
-test('fixed-v1 verifies the real coordinate migration before advertising it', () => {
-  const workflow = {
-    schema_version: 1,
-    diagram_type: 'workflow',
-    meta: {
-      title: 'Pinned issue 126 migration',
-      viewBox: [720, 400],
-      legend: { mode: 'hidden' },
-    },
-    lanes: [{ id: 'main', label: 'Main' }],
-    nodes: [
-      { id: 'a', lane: 'main', col: 1, type: 'backend', label: 'A' },
-      { id: 'b', lane: 'main', col: 2, type: 'backend', label: 'B' },
-    ],
-    edges: [{
-      id: 'ab',
-      from: 'a',
-      to: 'b',
-      fromSide: 'top',
-      toSide: 'top',
-      via: [[220, 60], [300, 60]],
-    }],
-  };
-
-  const result = compileWorkflow({ workflow, qualityProfile: 'showcase' });
-  assert.equal(result.ok, false);
-  assert.equal(result.diagnostics[0].code, 'workflow/column-capacity');
-  assert.ok(
-    result.diagnostics[0].supportedFixes.includes('migrate this workflow to schema_version 2'),
-    JSON.stringify(result.diagnostics[0], null, 2),
-  );
-});
-
-test('readable-v2 supports every adjacent rank with and without a semantic label', () => {
-  for (const qualityProfile of ['standard', 'showcase']) {
-    for (let fromCol = 0; fromCol < 5; fromCol += 1) {
-      for (const label of [undefined, 'liga']) {
-        const result = compileSuccessfully(adjacentWorkflow({ fromCol, label }), qualityProfile);
-        assertReadableAdjacentResult(result, { label });
-      }
-    }
-  }
-});
-
-test('readable-v2 satisfies the complete adjacent-rank acceptance matrix', () => {
-  let cases = 0;
-  for (const qualityProfile of ['standard', 'showcase']) {
-    for (let fromCol = 0; fromCol < 5; fromCol += 1) {
-      for (const label of [undefined, 'liga']) {
-        for (const frames of [false, true]) {
-          for (const width of [900, 1080, 1400, 1600]) {
-            const result = compileSuccessfully(adjacentWorkflow({
-              fromCol,
-              label,
-              frames,
-              viewBox: [width, 420],
-            }), qualityProfile);
-            assert.deepEqual(result.receipt.viewBox, [width, 420]);
-            assertReadableAdjacentResult(result, { label });
-            if (frames) assert.match(result.svg, /data-composition-frame-kind="group"/);
-            cases += 1;
-          }
-        }
-      }
-    }
-  }
-  assert.equal(cases, 160);
-});
-
-test('readable-v2 phase and group frames derive from solved ranks without moving the core geometry', () => {
-  for (const qualityProfile of ['standard', 'showcase']) {
-    for (let fromCol = 0; fromCol < 5; fromCol += 1) {
-      const plain = compileSuccessfully(adjacentWorkflow({ fromCol, label: 'liga' }), qualityProfile);
-      const framed = compileSuccessfully(
-        adjacentWorkflow({ fromCol, label: 'liga', frames: true }),
-        qualityProfile,
-      );
-
-      assert.deepEqual(framed.receipt.columns, plain.receipt.columns);
-      assert.deepEqual(nodeRect(framed.svg, 'a'), nodeRect(plain.svg, 'a'));
-      assert.deepEqual(nodeRect(framed.svg, 'b'), nodeRect(plain.svg, 'b'));
-      assert.deepEqual(edgePoints(framed.svg, 'ab'), edgePoints(plain.svg, 'ab'));
-      assert.match(framed.svg, /data-composition-frame-kind="group"/);
-      assertReadableAdjacentResult(framed, { label: 'liga' });
-    }
-  }
-});
-
-test('readable-v2 treats the phase header mask as a routing obstacle', () => {
-  const document = {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: { title: 'Phase route obstacle', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'top', label: 'Top' }, { id: 'bottom', label: 'Bottom' }],
-    nodes: [
-      { id: 'a', lane: 'top', col: 0, type: 'backend', label: 'A' },
-      { id: 'b', lane: 'bottom', col: 4, type: 'backend', label: 'B' },
-    ],
-    edges: [{
-      id: 'ab', from: 'a', to: 'b', fromSide: 'top', toSide: 'top',
-    }],
-  };
-
-  const withoutPhase = compileSuccessfully(clone(document), 'showcase');
-  assert.ok(withoutPhase.receipt.edges.find(({ id }) => id === 'ab'));
-
-  const withPhaseDocument = clone(document);
-  withPhaseDocument.phases = [{ id: 'p', label: 'Phase', fromCol: 0, toCol: 5 }];
-  const withPhase = compileSuccessfully(withPhaseDocument, 'showcase');
-  const columns = withPhase.receipt.columns;
-  const phaseMask = {
-    x: columns[0] - 46,
-    y: 27,
-    width: (columns[5] + 46) - (columns[0] - 46),
-    height: 16,
-  };
-  const points = withPhase.receipt.edges.find(({ id }) => id === 'ab').points;
-  for (let index = 0; index < points.length - 1; index += 1) {
-    assert.equal(
-      orthogonalSegmentIntersectsRect(points[index], points[index + 1], phaseMask),
-      false,
-      `edge ab segment ${index} must clear the phase mask: ${JSON.stringify(points)}`,
-    );
-  }
-});
-
-test('readable-v2 never routes through a single-rank group label', () => {
-  const groupLabel = 'Very long group label';
-  const document = {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: { title: 'Group label route obstacle', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'top', label: 'Top' }, { id: 'bottom', label: 'Bottom' }],
-    groups: [{ id: 'g', label: groupLabel, lane: 'top', fromCol: 2, toCol: 2 }],
-    nodes: [
-      { id: 'a', lane: 'top', col: 2, type: 'backend', label: 'A' },
-      { id: 'b', lane: 'bottom', col: 4, type: 'database', label: 'B' },
-    ],
-    edges: [{
-      id: 'ab', from: 'a', to: 'b', fromSide: 'top', toSide: 'top',
-    }],
-  };
-
-  const first = compileWorkflow({ workflow: document, qualityProfile: 'showcase' });
-  const second = compileWorkflow({ workflow: clone(document), qualityProfile: 'showcase' });
-  assert.deepEqual(second, first, 'repeated compilation must be deterministic');
-
-  assert.equal(first.ok, false);
-  assert.equal(first.svg, undefined);
-  assert.equal(first.diagnostics.length, 1, JSON.stringify(first.diagnostics, null, 2));
-  const [diagnostic] = first.diagnostics;
-  assert.equal(diagnostic.code, 'workflow/explicit-pin-conflict');
-  assert.equal(diagnostic.subject.path, '/edges/0/fromSide');
-  assert.equal(
-    diagnostic.evidence.invariant,
-    'readable route feasibility with authored endpoint sides',
-  );
-  assert.deepEqual(diagnostic.evidence.conflictingPins, [{
-    edge: 'ab',
-    field: 'fromSide',
-    path: '/edges/0/fromSide',
-    value: 'top',
-  }]);
-  assert.ok(diagnostic.supportedFixes.length > 0);
-  assert.deepEqual(first.receipt.diagnostics, first.diagnostics);
-
-  const repaired = clone(document);
-  delete repaired.edges[0].fromSide;
-  const rendered = compileWorkflow({ workflow: repaired, qualityProfile: 'showcase' });
-  assert.equal(rendered.ok, true, JSON.stringify(rendered.diagnostics, null, 2));
-
-  const escapedLabel = groupLabel.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const attributes = rendered.svg.match(new RegExp(
-    `<text\\b([^>]*)>${escapedLabel}</text>`,
-  ))?.[1];
-  assert.ok(attributes, 'expected the rendered group label');
-  const groupLabelRect = {
-    x: Number(attribute(attributes, 'x')),
-    y: Number(attribute(attributes, 'y')) - 10,
-    width: Array.from(groupLabel).length * 5.6,
-    height: 14,
-  };
-  const points = rendered.receipt.edges.find(({ id }) => id === 'ab').points;
-  for (let index = 0; index < points.length - 1; index += 1) {
-    assert.equal(
-      orthogonalSegmentIntersectsRect(points[index], points[index + 1], groupLabelRect),
-      false,
-      `edge ab segment ${index} must clear the group label: ${JSON.stringify(points)}`,
-    );
-  }
-});
-
-test('readable-v2 shifts top-side routes beyond lane header text deterministically', () => {
-  const makeDocument = (topLaneLabel) => ({
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: { title: 'Lane header route obstacle', legend: { mode: 'hidden' } },
-    lanes: [
-      { id: 'top', label: topLaneLabel },
-      { id: 'bottom', label: 'Bottom' },
-    ],
-    nodes: [
-      { id: 'a', lane: 'top', col: 0, type: 'backend', label: 'A' },
-      { id: 'b', lane: 'bottom', col: 4, type: 'database', label: 'B' },
-    ],
-    edges: [{
-      id: 'ab', from: 'a', to: 'b', fromSide: 'top', toSide: 'top',
-    }],
-  });
-
-  const compiled = new Map();
-  for (const label of ['Responsibility owner', 'R']) {
-    const first = compileSuccessfully(makeDocument(label), 'showcase');
-    const second = compileSuccessfully(makeDocument(label), 'showcase');
-    assert.deepEqual(second, first, `${label}: repeated compilation must be deterministic`);
-
-    const points = first.receipt.edges.find(({ id }) => id === 'ab').points;
-    const headerRect = asciiLaneHeaderTextRect(label);
-    for (let index = 0; index < points.length - 1; index += 1) {
-      assert.equal(
-        orthogonalSegmentIntersectsRect(points[index], points[index + 1], headerRect),
-        false,
-        `${label}: edge ab segment ${index} must clear the top lane header: ${JSON.stringify(points)}`,
-      );
-    }
-    compiled.set(label, first);
-  }
-
-  assert.ok(
-    compiled.get('Responsibility owner').receipt.columns[0]
-      > compiled.get('R').receipt.columns[0],
-    'the wider lane header must move the col-0 top-side corridor farther right',
-  );
-});
-
-test('explicit viewBox width is containment capacity and never stretches readable-v2 geometry', () => {
-  for (const qualityProfile of ['standard', 'showcase']) {
-    for (let fromCol = 0; fromCol < 5; fromCol += 1) {
-      const intrinsic = compileSuccessfully(adjacentWorkflow({
-        fromCol,
-        label: 'liga',
-      }), qualityProfile);
-      const expectedGeometry = {
-        columns: intrinsic.receipt.columns,
-        source: nodeRect(intrinsic.svg, 'a'),
-        target: nodeRect(intrinsic.svg, 'b'),
-        edge: edgePoints(intrinsic.svg, 'ab'),
-      };
-
-      for (const width of [900, 1080, 1400, 1600]) {
-        const result = compileSuccessfully(adjacentWorkflow({
-          fromCol,
-          label: 'liga',
-          viewBox: [width, 420],
-        }), qualityProfile);
-        assert.deepEqual(result.receipt.viewBox, [width, 420]);
-        assert.deepEqual(svgViewBox(result.svg), [0, 0, width, 420]);
-        assert.deepEqual(result.receipt.requiredViewBox, intrinsic.receipt.requiredViewBox);
-        assert.deepEqual(result.receipt.columns, expectedGeometry.columns);
-        assert.deepEqual(nodeRect(result.svg, 'a'), expectedGeometry.source);
-        assert.deepEqual(nodeRect(result.svg, 'b'), expectedGeometry.target);
-        assert.deepEqual(edgePoints(result.svg, 'ab'), expectedGeometry.edge);
-        assertReadableAdjacentResult(result, { label: 'liga' });
-      }
-    }
-  }
-});
-
-test('capacity-only viewBox failures preserve the intrinsic routes, labels, and requirement', () => {
-  const document = {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: { title: 'capacity', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'top', label: 'Top' }, { id: 'bottom', label: 'Bottom' }],
-    nodes: [
-      { id: 'n0', lane: 'top', col: 0, type: 'backend', label: 'N0' },
-      { id: 'n1', lane: 'bottom', col: 1, type: 'backend', label: 'N1' },
-      { id: 'n2', lane: 'top', col: 1, type: 'database', label: 'N2' },
-      { id: 'n3', lane: 'bottom', col: 3, type: 'database', label: 'N3' },
-    ],
-    edges: [
-      { id: 'e0', from: 'n3', to: 'n0' },
-      {
-        id: 'e1',
-        from: 'n1',
-        to: 'n2',
-        label: 'ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ',
-      },
-    ],
-  };
-  const intrinsic = compileSuccessfully(clone(document), 'showcase');
-
-  const insufficientDocument = clone(document);
-  insufficientDocument.meta.viewBox = [900, 1000];
-  const insufficient = compileWorkflow({
-    workflow: insufficientDocument,
-    qualityProfile: 'showcase',
-  });
-  assert.equal(insufficient.ok, false);
-  assert.equal(insufficient.svg, undefined);
-  assert.equal(insufficient.diagnostics.length, 1, JSON.stringify(insufficient.diagnostics, null, 2));
-  const [capacity] = insufficient.diagnostics;
-  assert.equal(capacity.code, 'workflow/viewbox-capacity');
-  assert.deepEqual(capacity.evidence.actualViewBox, [900, 1000]);
-  assert.deepEqual(capacity.evidence.requiredViewBox, intrinsic.receipt.requiredViewBox);
-
-  const sufficientDocument = clone(document);
-  sufficientDocument.meta.viewBox = [intrinsic.receipt.requiredViewBox[0], 1000];
-  const sufficient = compileSuccessfully(sufficientDocument, 'showcase');
-  assert.deepEqual(sufficient.receipt.requiredViewBox, intrinsic.receipt.requiredViewBox);
-  assert.deepEqual(sufficient.receipt.edges, intrinsic.receipt.edges);
-  assert.deepEqual(sufficient.receipt.labels, intrinsic.receipt.labels);
-});
-
-test('explicit viewBox capacity names the rank and label constraints that require more width', () => {
-  const result = compileWorkflow({
-    workflow: adjacentWorkflow({ fromCol: 1, label: 'liga', viewBox: [700, 420] }),
-    qualityProfile: 'showcase',
-  });
-  assert.equal(result.ok, false);
-  const diagnostic = result.diagnostics.find(({ code }) => code === 'workflow/viewbox-capacity');
-  assert.ok(diagnostic, JSON.stringify(result.diagnostics, null, 2));
-  assert.ok(diagnostic.evidence.contributors.includes('rank 1→2 direct clearance'));
-  assert.ok(diagnostic.evidence.contributors.includes('edge ab label mask'));
-});
-
-test('explicit viewBox capacity names the rank and authored node widths that require more width', () => {
-  const result = compileWorkflow({
-    workflow: adjacentWorkflow({
-      fromCol: 1,
-      widths: [240, 240],
-      viewBox: [700, 420],
-    }),
-    qualityProfile: 'showcase',
-  });
-  assert.equal(result.ok, false);
-  const diagnostic = result.diagnostics.find(({ code }) => code === 'workflow/viewbox-capacity');
-  assert.ok(diagnostic, JSON.stringify(result.diagnostics, null, 2));
-  const contributors = diagnostic.evidence.contributors;
-  assert.ok(
-    contributors.some((contributor) => /rank 1→2/i.test(contributor) && /clearance/i.test(contributor)),
-    `contributors must name the rank 1→2 width constraint: ${JSON.stringify(contributors)}`,
-  );
-  for (const nodeId of ['a', 'b']) {
-    assert.ok(
-      contributors.some((contributor) => (
-        new RegExp(`node ${nodeId}\\b`, 'i').test(contributor) && /width/i.test(contributor)
-      )),
-      `contributors must name node ${nodeId}'s authored width: ${JSON.stringify(contributors)}`,
-    );
-  }
-});
-
-test('explicit viewBox height capacity names the authored tall node without naming a hidden legend', () => {
-  const result = compileWorkflow({
-    workflow: {
-      schema_version: 2,
-      diagram_type: 'workflow',
-      meta: {
-        title: 'Tall node height capacity',
-        legend: { mode: 'hidden' },
-        viewBox: [1200, 280],
-      },
-      lanes: [{ id: 'main', label: 'M' }],
-      nodes: [{
-        id: 'tall', lane: 'main', col: 0, type: 'backend', label: 'Tall', height: 160,
-      }],
-      edges: [],
-    },
-    qualityProfile: 'showcase',
-  });
-
-  assert.equal(result.ok, false);
-  assert.equal(result.svg, undefined);
-  assert.equal(result.diagnostics.length, 1, JSON.stringify(result.diagnostics, null, 2));
-  const [diagnostic] = result.diagnostics;
-  assert.equal(diagnostic.code, 'workflow/viewbox-capacity');
-  assert.deepEqual(diagnostic.evidence.actualViewBox, [1200, 280]);
-  assert.equal(diagnostic.evidence.requiredViewBox[1], 374);
-  const contributors = diagnostic.evidence.contributors;
-  assert.ok(
-    contributors.some((contributor) => (
-      /node tall\b/i.test(contributor)
-      && /height/i.test(contributor)
-      && /160px/i.test(contributor)
-    )),
-    `contributors must name tall's authored 160px height: ${JSON.stringify(contributors)}`,
-  );
-  assert.equal(
-    contributors.some((contributor) => /legend/i.test(contributor)),
-    false,
-    `a hidden legend must not be named as a height contributor: ${JSON.stringify(contributors)}`,
-  );
-});
-
-test('readable-v2 measures asymmetric custom widths and CJK edge labels', () => {
-  const cases = [
-    { widths: [32, 92], label: '同步', nodeLabels: ['甲', '乙'] },
-    { widths: [102, 124], label: '資料 ready', nodeLabels: ['入口', '出口'] },
-    { widths: [132, 160], label: '审批通过', nodeLabels: ['请求', '执行'] },
-    { widths: [92, 240], label: '结果 ✅ 回传', nodeLabels: ['工具', '外部服务'] },
-  ];
-
-  for (const current of cases) {
-    const result = compileSuccessfully(adjacentWorkflow({
-      fromCol: 1,
-      label: current.label,
-      widths: current.widths,
-      nodeLabels: current.nodeLabels,
-      viewBox: [1600, 420],
-    }), 'showcase');
-    assertReadableAdjacentResult(result, current);
-  }
-});
-
-test('readable-v2 compares long-label gutter growth with a legal automatic channel', () => {
-  const automaticDocument = adjacentWorkflow({
-    fromCol: 3,
-    label: 'L'.repeat(80),
-  });
-  const automatic = compileSuccessfully(automaticDocument, 'showcase');
-  const forcedStraightDocument = clone(automaticDocument);
-  forcedStraightDocument.edges[0].route = 'straight';
-  const forcedStraight = compileSuccessfully(forcedStraightDocument, 'showcase');
-
-  assert.ok(edgePoints(automatic.svg, 'ab').length > 2, 'the compact plan must use a legal channel');
-  assert.ok(
-    automatic.receipt.requiredViewBox[0] < forcedStraight.receipt.requiredViewBox[0],
-    'the selected channel must require less canvas than forcing the direct gutter',
-  );
-  assertRectInsideViewBox(
-    edgeLabelRect(automatic.svg, 'ab'),
-    svgViewBox(automatic.svg),
-    'long automatic edge label',
-  );
-
-  const leftRankDocument = adjacentWorkflow({ fromCol: 0, label: 'X'.repeat(100) });
-  const leftRank = compileSuccessfully(leftRankDocument, 'showcase');
-  assertRectInsideViewBox(
-    edgeLabelRect(leftRank.svg, 'ab'),
-    svgViewBox(leftRank.svg),
-    'left-rank long automatic edge label',
-  );
-});
-
-test('readable-v2 property matrix satisfies every adjacent rank across supported representative widths', () => {
-  const widths = [32, 92, 102, 124, 132, 160, 240];
-  for (let fromCol = 0; fromCol < 5; fromCol += 1) {
-    for (const sourceWidth of widths) {
-      for (const targetWidth of widths) {
-        const result = compileSuccessfully(adjacentWorkflow({
-          fromCol,
-          label: '同步 ✅',
-          widths: [sourceWidth, targetWidth],
-        }), 'showcase');
-        assertReadableAdjacentResult(result, {
-          label: '同步 ✅',
-          widths: [sourceWidth, targetWidth],
-        });
-      }
-    }
-  }
-});
-
-test('readable-v2 expands rank spans for measured phase and group label capacity', () => {
-  const workflow = adjacentWorkflow({ fromCol: 0, frames: true });
-  workflow.phases[0].label = 'P'.repeat(50);
-  workflow.groups[0].label = 'G'.repeat(50);
-
-  const result = compileSuccessfully(workflow, 'showcase');
-  assert.ok(result.receipt.columns[1] - result.receipt.columns[0] > 120);
-  assertReadableAdjacentResult(result);
-});
-
-test('readable-v2 contains a long single-rank group label in its frame and intrinsic canvas', () => {
-  const workflow = {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: { title: 'Single-rank group capacity', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'main', label: 'Main' }],
-    groups: [{
-      id: 'long-group',
-      label: 'X'.repeat(120),
-      lane: 'main',
-      fromCol: 5,
-      toCol: 5,
-    }],
-    nodes: [
-      { id: 'outside', lane: 'main', col: 2, type: 'database', label: 'Outside' },
-      { id: 'node', lane: 'main', col: 5, type: 'backend', label: 'Node' },
-    ],
-    edges: [],
-  };
-
-  const result = compileSuccessfully(workflow, 'showcase');
-  assert.ok(result.receipt.requiredViewBox[0] > 768);
-  const groupAttributes = result.svg.match(
-    /<rect\b(?=[^>]*data-composition-frame-id="group-0")[^>]*\b(x="[^"]+"[^>]*)\/>/,
-  )?.[1];
-  assert.ok(groupAttributes);
-  const group = numericRect(groupAttributes);
-  assert.ok(group.width >= 120 * 5.6 + 20, `group width ${group.width} must contain its label`);
-  const outside = nodeRect(result.svg, 'outside');
-  assert.ok(group.x >= outside.x + outside.width, 'single-rank group must not cover an unrelated rank');
-  const labelBaseline = Number(result.svg.match(/<text\b[^>]*\by="([^"]+)"[^>]*>X{120}<\/text>/)?.[1]);
-  assert.ok(labelBaseline <= nodeRect(result.svg, 'node').y - 4, 'group label must remain above its node');
-});
-
-test('readable-v2 group frames contain custom-width member rectangles on every side', () => {
-  const workflow = {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: { title: 'Wide group member', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'main', label: 'Main' }],
-    groups: [{ id: 'group', label: 'G', lane: 'main', fromCol: 2, toCol: 2 }],
-    nodes: [{
-      id: 'wide', lane: 'main', col: 2, type: 'backend', label: 'Wide', width: 240,
-    }],
-    edges: [],
-  };
-
-  const result = compileSuccessfully(workflow, 'showcase');
-  assertRectInsideRect(
-    nodeRect(result.svg, 'wide'),
-    groupFrameRect(result.svg),
-    'custom-width group member',
-  );
-});
-
-test('readable-v2 group frames contain tagged and tall members away from the label rail', () => {
-  const cases = [
-    ['tagged member', { tag: 'TAG' }],
-    ['120px-tall member', { height: 120 }],
-  ];
-
-  for (const [description, authoredGeometry] of cases) {
-    const workflow = {
-      schema_version: 2,
-      diagram_type: 'workflow',
-      meta: { title: description, legend: { mode: 'hidden' } },
-      lanes: [{ id: 'main', label: 'Main' }],
-      groups: [{ id: 'group', label: 'G', lane: 'main', fromCol: 0, toCol: 1 }],
-      nodes: [{
-        id: 'member',
-        lane: 'main',
-        col: 1,
-        type: 'backend',
-        label: 'Member',
-        ...authoredGeometry,
-      }],
-      edges: [],
-    };
-
-    const result = compileSuccessfully(workflow, 'showcase');
-    const member = nodeRect(result.svg, 'member');
-    const groupLabel = asciiGroupLabelTextRect(result.svg, 'G');
-    assert.ok(
-      member.x >= groupLabel.x + groupLabel.width,
-      `${description}: fixture must keep the member horizontally clear of its group label`,
-    );
-    assertRectInsideRect(member, groupFrameRect(result.svg), description);
-  }
-});
-
-test('readable-v2 keeps a first-rank group label mask clear of its lane header mask', () => {
-  const workflow = {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: { title: 'First-rank group labels', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'main', label: 'Main' }],
-    groups: [{ id: 'group', label: 'G', lane: 'main', fromCol: 0, toCol: 0 }],
-    nodes: [{ id: 'member', lane: 'main', col: 0, type: 'backend', label: 'Member' }],
-    edges: [],
-  };
-
-  const result = compileSuccessfully(workflow, 'showcase');
-  const laneHeader = asciiLaneHeaderTextRect('Main');
-  const groupLabel = asciiGroupLabelTextRect(result.svg, 'G');
-  assert.equal(
-    rectsOverlap(laneHeader, groupLabel),
-    false,
-    `lane header ${JSON.stringify(laneHeader)} must not overlap group label ${JSON.stringify(groupLabel)}`,
-  );
-});
-
-test('readable-v2 measures multi-row legends into intrinsic and explicit viewBox capacity', () => {
-  const workflow = adjacentWorkflow({ fromCol: 0 });
-  workflow.meta.legend = {
-    mode: 'all',
-    entries: Object.fromEntries([
-      'frontend', 'backend', 'security', 'messagebus', 'database', 'cloud', 'external',
-    ].map((kind) => [kind, { label: `${kind} contract evidence` }])),
-  };
-  const hiddenDocument = clone(workflow);
-  hiddenDocument.meta.legend = { mode: 'hidden' };
-  const hidden = compileSuccessfully(hiddenDocument, 'showcase');
-  const intrinsic = compileSuccessfully(workflow, 'showcase');
-  assert.ok(intrinsic.receipt.requiredViewBox[1] > hidden.receipt.requiredViewBox[1]);
-
-  const tooShortDocument = clone(workflow);
-  tooShortDocument.meta.viewBox = [
-    intrinsic.receipt.requiredViewBox[0],
-    hidden.receipt.requiredViewBox[1],
-  ];
-  const tooShort = compileWorkflow({ workflow: tooShortDocument, qualityProfile: 'showcase' });
-  assert.equal(tooShort.ok, false);
-  assert.ok(tooShort.diagnostics.some(({ code }) => code === 'workflow/viewbox-capacity'));
-
-  const sufficientDocument = clone(workflow);
-  sufficientDocument.meta.viewBox = [...intrinsic.receipt.requiredViewBox];
-  const sufficient = compileSuccessfully(sufficientDocument, 'showcase');
-  assert.deepEqual(sufficient.receipt.viewBox, intrinsic.receipt.requiredViewBox);
-
-  const expectedGeometry = {
-    requiredViewBox: intrinsic.receipt.requiredViewBox,
-    columns: intrinsic.receipt.columns,
-    nodes: intrinsic.receipt.nodes,
-    edges: intrinsic.receipt.edges,
-    labels: intrinsic.receipt.labels,
-    legend: legendGeometry(intrinsic.svg),
-  };
-  for (const width of [900, 1400]) {
-    const explicitDocument = clone(workflow);
-    explicitDocument.meta.viewBox = [width, 1000];
-    const explicit = compileSuccessfully(explicitDocument, 'showcase');
-    assert.deepEqual(explicit.receipt.requiredViewBox, expectedGeometry.requiredViewBox);
-    assert.deepEqual(explicit.receipt.columns, expectedGeometry.columns);
-    assert.deepEqual(explicit.receipt.nodes, expectedGeometry.nodes);
-    assert.deepEqual(explicit.receipt.edges, expectedGeometry.edges);
-    assert.deepEqual(explicit.receipt.labels, expectedGeometry.labels);
-    assert.deepEqual(legendGeometry(explicit.svg), expectedGeometry.legend);
-  }
-});
-
-test('a wide node in an unrelated lane does not expand the adjacent-rank gap', () => {
-  const baselineDocument = adjacentWorkflow({
-    fromCol: 1,
-    label: 'liga',
-    viewBox: [1600, 520],
-  });
-  baselineDocument.lanes.push({ id: 'other', label: 'Other' });
-  const baseline = compileSuccessfully(baselineDocument, 'showcase');
-
-  const withUnrelatedWideNode = clone(baselineDocument);
-  withUnrelatedWideNode.nodes.push({
-    id: 'wide', lane: 'other', col: 1, type: 'database', label: 'Wide', width: 240,
-  });
-  const widened = compileSuccessfully(withUnrelatedWideNode, 'showcase');
-
-  assert.equal(
-    widened.receipt.columns[2] - widened.receipt.columns[1],
-    baseline.receipt.columns[2] - baseline.receipt.columns[1],
-  );
-});
-
-test('explicit labelAt participates in readable-v2 viewBox containment', () => {
-  const workflow = adjacentWorkflow({
-    fromCol: 0,
-    label: 'outside',
-    viewBox: [900, 420],
-  });
-  workflow.nodes[1].col = 5;
-  workflow.edges[0].labelAt = [563, 539];
-
-  const result = compileWorkflow({ workflow, qualityProfile: 'showcase' });
-  assert.equal(result.ok, false);
-  assert.equal(result.diagnostics.length, 1, JSON.stringify(result.diagnostics, null, 2));
-  const [diagnostic] = result.diagnostics;
-  assert.equal(diagnostic.code, 'workflow/viewbox-capacity');
-  assert.deepEqual(diagnostic.evidence.actualViewBox, [900, 420]);
-  assert.ok(diagnostic.evidence.requiredViewBox[1] > 420);
-  assert.ok(
-    diagnostic.evidence.contributors.some((contributor) => /edge ab label/i.test(contributor)),
-    JSON.stringify(diagnostic.evidence.contributors),
-  );
-  assert.doesNotMatch(diagnostic.supportedFixes.join('\n'), /drop|remove (?:the )?label|unlabel/i);
-});
-
-test('sanitized downstream fixtures cover labels, explicit routes, custom widths, and explicit viewBoxes', () => {
-  const fixtureRoot = path.join(__dirname, 'fixtures', 'issue-126');
-
-  const labels = compileSuccessfully(readJson(path.join(fixtureRoot, 'labels.workflow.json')), 'showcase');
-  assertRectInsideViewBox(
-    edgeLabelRect(labels.svg, 'request-result'),
-    svgViewBox(labels.svg),
-    'sanitized semantic label',
-  );
-
-  const explicitRoute = compileSuccessfully(
-    readJson(path.join(fixtureRoot, 'explicit-route.workflow.json')),
-    'showcase',
-  );
-  assert.ok(
-    edgePoints(explicitRoute.svg, 'producer-consumer').some(([x]) => x === 720),
-    'the authored channelX pin must remain exact',
-  );
-
-  const customWidths = compileSuccessfully(
-    readJson(path.join(fixtureRoot, 'custom-widths.workflow.json')),
-    'showcase',
-  );
-  assert.equal(nodeRect(customWidths.svg, 'compact').width, 32);
-  assert.equal(nodeRect(customWidths.svg, 'wide').width, 240);
-
-  const explicitViewBox = compileSuccessfully(
-    readJson(path.join(fixtureRoot, 'explicit-viewbox.workflow.json')),
-    'showcase',
-  );
-  assert.deepEqual(explicitViewBox.receipt.viewBox, [1600, 520]);
-});
-
-test('readable-v2 SVG and receipt bytes are deterministic across repeated and reordered input', () => {
-  const workflow = {
-    schema_version: 2,
-    diagram_type: 'workflow',
-    meta: { title: 'Deterministic workflow', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'main', label: 'Main' }],
-    nodes: [
-      { id: 'a', lane: 'main', col: 0, type: 'frontend', label: 'A' },
-      { id: 'b', lane: 'main', col: 2, type: 'backend', label: 'B' },
-      { id: 'c', lane: 'main', col: 4, type: 'database', label: 'C' },
-    ],
-    edges: [
-      { id: 'ab', from: 'a', to: 'b', label: 'one' },
-      { id: 'bc', from: 'b', to: 'c', label: 'two' },
-    ],
-  };
-
-  const first = compileSuccessfully(clone(workflow), 'showcase');
-  for (let iteration = 0; iteration < 3; iteration += 1) {
-    const repeated = compileSuccessfully(clone(workflow), 'showcase');
-    assert.equal(repeated.svg, first.svg);
-    assert.equal(JSON.stringify(repeated.receipt), JSON.stringify(first.receipt));
-  }
-
-  const reordered = clone(workflow);
-  reordered.nodes.reverse();
-  reordered.edges.reverse();
-  const reorderedResult = compileSuccessfully(reordered, 'showcase');
-  assert.equal(reorderedResult.svg, first.svg);
-  assert.equal(JSON.stringify(reorderedResult.receipt), JSON.stringify(first.receipt));
-});
-
-test('CLI validate workflow --layout-json prints the stable compiler receipt', () => {
-  const input = path.join(tmp, 'layout-json.workflow.json');
-  fs.writeFileSync(input, JSON.stringify(adjacentWorkflow({
-    fromCol: 3,
-    label: 'liga',
-    viewBox: [1080, 420],
-  })));
-
-  const result = spawnSync(process.execPath, [
-    cli,
-    'validate',
-    'workflow',
-    input,
-    '--layout-json',
-    '--quality',
-    'standard',
-  ], { encoding: 'utf8' });
-
-  assert.equal(result.status, 0, result.stderr);
-  const receipt = JSON.parse(result.stdout);
-  assert.equal(receipt.contract, 'readable-v2');
-  assert.deepEqual(receipt.viewBox, [1080, 420]);
-  assert.ok(Array.isArray(receipt.requiredViewBox));
-  assert.equal(receipt.columns.length, 6);
-  assert.deepEqual(receipt.diagnostics, []);
-});
-
-test('CLI validate workflow --layout-json returns only the causal compiler failure receipt', () => {
-  const input = path.join(tmp, 'layout-json-failure.workflow.json');
-  fs.writeFileSync(input, JSON.stringify({
-    schema_version: 1,
-    diagram_type: 'workflow',
-    meta: { title: 'Issue 126 failure receipt', legend: { mode: 'hidden' } },
-    lanes: [{ id: 'main', label: 'Main' }],
-    nodes: [
-      { id: 'a', lane: 'main', col: 1, type: 'backend', label: 'A' },
-      { id: 'b', lane: 'main', col: 2, type: 'backend', label: 'B' },
-    ],
-    edges: [{ id: 'ab', from: 'a', to: 'b' }],
-  }));
-
-  const result = spawnSync(process.execPath, [
-    cli,
-    'validate',
-    'workflow',
-    input,
-    '--layout-json',
-    '--json',
-  ], { encoding: 'utf8' });
-
-  assert.equal(result.status, 1);
-  assert.equal(result.stderr, '');
-  const receipt = JSON.parse(result.stdout);
-  assert.equal(receipt.contract, 'fixed-v1');
-  assert.equal(receipt.diagnostics.length, 1, JSON.stringify(receipt.diagnostics, null, 2));
-  assert.equal(receipt.diagnostics[0].code, 'workflow/column-capacity');
-});
-
-process.on('exit', () => fs.rmSync(tmp, { recursive: true, force: true }));