Skip to content

Turn any idea, plan, or codebase into a beautiful interactive diagram. An agent skill for Claude Code, Codex, and more.

fix(workflow): explain rejected route presets

tt-a1i5a8f94a5d386
diff --git a/archify/references/authoring-defaults.md b/archify/references/authoring-defaults.md
index 42390a73..915d30f5 100644
--- a/archify/references/authoring-defaults.md
+++ b/archify/references/authoring-defaults.md
@@ -36,6 +36,6 @@ Use one primary authored language from the user's choice or the request/conversa
Omit `meta.visual_preset` for classic, `meta.subtitle` for a title-only header, `meta.legend` for truthful auto, and `meta.engineering_profile` for an ordinary system overview. Explicit styles and a subtitle require a user request. Use legend or deployment ownership under the [legend](authoring-contract.md#legend-contract) or [engineering profile](authoring-contract.md#engineering-profile-default) contracts. Branding is optional and explicit when a node names a real product; [Brand marks](brand-marks.md) gives lookup and capture rules for that branch. Never let a badge replace semantic type, label, or relationship facts. Set required `meta.output` to a portable POSIX-relative `.html` path within the working directory; see [Output path contracts](delivery-contract.md#output-path-contracts) for native path exceptions.
-For new Workflow use schema v2, preserving v1 for a fixed legacy source; use its [layout contracts](../renderers/workflow/README.md#layout-contracts) when lane or group geometry needs detail. For Sequence omit `meta.column_fit` for spread columns on both automatic and authored canvases; preserve an authored `meta.viewBox`. Set `meta.column_fit: "fixed"` explicitly when historical fixed coordinates are required; use `spread` when a wide viewBox leaves unused horizontal space or meaningful labels need width. Describe a participant's internal action in a note on its surrounding real cross-participant message, preserving its meaning and order; Sequence self-message loops are not supported. For a fresh Dataflow start with the stage/row grid and follow the canonical [Dataflow canvas and showcase defaults](authoring-contract.md#dataflow); add dimensions or route controls for supplied geometry or a measured constraint. For Lifecycle use schema v3: list the happy path in `mainPath` and author every transition, including the main path; the renderer places all other states and routes. Give an exit shared by several consecutive phases the same label so it draws once, and keep transition labels short; a recoverable failure needs a real transition back. Read [Mode placement](authoring-contract.md#mode-placement) when a mode-specific placement or viewport problem needs more detail.
+For a fresh Workflow use schema v2 and omit `meta.viewBox` so the compiler measures the real footprint; do not add empty canvas just to satisfy a viewport ratio. Preserve supplied fixed geometry and v1 sources. Use its [layout contracts](../renderers/workflow/README.md#layout-contracts) when lane or group geometry needs detail. For Sequence omit `meta.column_fit` for spread columns on both automatic and authored canvases; preserve an authored `meta.viewBox`. Set `meta.column_fit: "fixed"` explicitly when historical fixed coordinates are required; use `spread` when a wide viewBox leaves unused horizontal space or meaningful labels need width. Describe a participant's internal action in a note on its surrounding real cross-participant message, preserving its meaning and order; Sequence self-message loops are not supported. For a fresh Dataflow start with the stage/row grid and follow the canonical [Dataflow canvas and showcase defaults](authoring-contract.md#dataflow); add dimensions or route controls for supplied geometry or a measured constraint. For Lifecycle use schema v3: list the happy path in `mainPath` and author every transition, including the main path; the renderer places all other states and routes. Give an exit shared by several consecutive phases the same label so it draws once, and keep transition labels short; a recoverable failure needs a real transition back. Read [Mode placement](authoring-contract.md#mode-placement) when a mode-specific placement or viewport problem needs more detail.
`finalize` performs the browser gate. Keep the complete drawing comfortably readable on desktop, with zero horizontal overflow. Use meaningful vertical rows and intrinsic-height page scroll when necessary. The 6px projected-text check is a failure floor; at 1440px, aim for ordinary context text around 7.5px or larger. See [Automated browser evidence](delivery-contract.md#automated-browser-evidence) when viewport evidence fails.
diff --git a/archify/references/delivery-contract.md b/archify/references/delivery-contract.md
index b85c0a4b..8898da14 100644
--- a/archify/references/delivery-contract.md
+++ b/archify/references/delivery-contract.md
@@ -6,7 +6,9 @@
For a validation failure, edit the existing JSON in the connected neighborhood named by diagnostics before rerunning a command. Preserve requested semantics, meaningful labels, source evidence, and fixed or agreed topology. Several routes sharing nodes call for one placement repair; read [Architecture layout repair](architecture-layout-repair.md) for that case. Reflow a blocked main path rather than nudging unrelated labels. Keep unrelated geometry when its composition already reads clearly. Use `--layout-json` before editing only when compact evidence lacks needed measurements. Workflow v2 uses its stable compiler receipt, not solver internals, as authoring evidence.
-After the edit, rerun the complete `finalize` command with `--quality showcase` and, for repository-backed work, `--repo-root <repo-root>`. If the output path already has browser evidence from another candidate, use a fresh `--out-dir <output-stem>.review-<revision>` for both the new `finalize` and any `visual-check`. Omit an earlier `--candidate-sha256` after editing because it binds the previous candidate. Compare diagnostics by code, subject, stage, and evidence, never by declining error count alone. If an issue survives two focused repairs, inspect measured geometry or the relevant contract; after one evidence-based retry, report the concrete gap.
+Keep the best candidate that cleared route checks before a viewport repair. If that repair introduces new route collisions, restore the measured layout and address its remaining canvas or text constraint.
+
+After the edit, rerun the complete `finalize` command with `--quality showcase` and, for repository-backed work, `--repo-root <repo-root>`. If the output path already has browser evidence from another candidate, use a fresh `--out-dir <output-stem>.review-<revision>` for both the new `finalize` and any `visual-check`. Omit an earlier `--candidate-sha256` after editing because it binds the previous candidate. Compare diagnostics by code, subject, stage, and evidence, never by declining error count alone. Track the repair limit per persistent issue, using that code, subject, stage, and evidence: a newly exposed issue starts its own repair sequence. If an issue survives two focused repairs, inspect measured geometry or the relevant contract; after one evidence-based retry, report the concrete gap.
Use standalone `validate` only for focused diagnosis, passing `--repo-root` for repository-backed work. Its passing receipt marks `candidateFrozen: true`; run `nextAction.arguments`, replacing only `<output.html>`, without editing, revalidating, or rereading the candidate. Retry later environmental or evidence failures against those frozen bytes. A measured reason to edit creates a new candidate and calls for the complete `finalize` without the old hash.
diff --git a/archify/renderers/workflow/README.md b/archify/renderers/workflow/README.md
index 9fb72290..4033b427 100644
--- a/archify/renderers/workflow/README.md
+++ b/archify/renderers/workflow/README.md
@@ -196,6 +196,12 @@ silently moved. `fromSide` and `toSide` remain direction constraints. A route
preset restricts the automatic candidate family but is not itself an absolute
coordinate pin. When either endpoint side is omitted, the v2 compiler chooses
a feasible side; an authored side restricts that endpoint to the named port.
+An infeasible preset returns `workflow/route-preset-conflict` with the actual
+rejected `evidence.invariant`. For node clearance it also identifies the node,
+segment, endpoint role, and required clearance. Use that obstacle to revise
+the connected placement or route constraints, then revalidate; minimum segment
+lengths alone do not establish a clear path. Advertised `supportedFixes` are
+verified against the complete workflow.
## Design Rules
diff --git a/archify/renderers/workflow/workflow-compiler.mjs b/archify/renderers/workflow/workflow-compiler.mjs
index 8e231b7d..613711e7 100644
--- a/archify/renderers/workflow/workflow-compiler.mjs
+++ b/archify/renderers/workflow/workflow-compiler.mjs
@@ -3361,7 +3361,38 @@ function labelRouteClearanceDeficit(edge, points, threshold = 8) {
return deficit;
}
-function routeClearsPlacedLabels(edge, points) {
+function placedLabelConflictEvidence(edge, candidateLabel, item, conflictType, points, segmentIndex, clearance) {
+ const edgeEvidence = (relation) => ({
+ edge: relation.id ?? null, from: relation.from, to: relation.to,
+ path: `/edges/${sourceIndexes.edges.get(relation)}`,
+ });
+ const labelEvidence = (relation, rect) => ({
+ label: relation.label,
+ rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+ });
+ return {
+ conflictType,
+ candidateEdge: edgeEvidence(edge),
+ otherEdge: edgeEvidence(item.edge),
+ ...(candidateLabel ? { candidateLabel: labelEvidence(edge, candidateLabel) } : {}),
+ ...(item.kind === 'label' ? { otherLabel: labelEvidence(item.edge, item.rect) } : {}),
+ ...(segmentIndex !== undefined ? {
+ segment: {
+ edge: conflictType === 'route-label' ? 'candidate' : 'other',
+ index: segmentIndex, from: [...points[segmentIndex]], to: [...points[segmentIndex + 1]],
+ },
+ measuredClearancePx: clearance, requiredClearancePx: 4,
+ } : {
+ rectangleMarginPx: -2,
+ overlapPx: {
+ x: Math.min(candidateLabel.x + candidateLabel.width, item.rect.x + item.rect.width) - Math.max(candidateLabel.x, item.rect.x),
+ y: Math.min(candidateLabel.y + candidateLabel.height, item.rect.y + item.rect.height) - Math.max(candidateLabel.y, item.rect.y),
+ },
+ }),
+ };
+}
+
+function routeClearsPlacedLabels(edge, points, evidence = null) {
const candidateLabel = candidateLabelRect(edge, points);
const candidateExtent = routeBounds(points);
const queryBox = {
@@ -3377,7 +3408,10 @@ function routeClearsPlacedLabels(edge, points) {
for (const item of obstacleGrid.query(queryBox)) {
// A label may sit far from the route it annotates, so both boxes are queried.
if (item.kind === 'label') {
- if (candidateLabel && rectsOverlap(candidateLabel, item.rect, -2)) return false;
+ if (candidateLabel && rectsOverlap(candidateLabel, item.rect, -2)) {
+ if (evidence) Object.assign(evidence, placedLabelConflictEvidence(edge, candidateLabel, item, 'label-label'));
+ return false;
+ }
const rect = item.rect;
// Either axis further than the minimum clearance means no segment can reach it.
if (Math.max(rect.x - candidateExtent.maxX, candidateExtent.minX - (rect.x + rect.width)) >= 4
@@ -3387,7 +3421,10 @@ function routeClearsPlacedLabels(edge, points) {
start: points[index],
end: points[index + 1],
}, rect);
- if (clearance != null && clearance + 0.0001 < 4) return false;
+ if (clearance != null && clearance + 0.0001 < 4) {
+ if (evidence) Object.assign(evidence, placedLabelConflictEvidence(edge, candidateLabel, item, 'route-label', points, index, clearance));
+ return false;
+ }
}
} else if (item.kind === 'route' && candidateLabel) {
const otherBounds = item.bounds;
@@ -3399,7 +3436,10 @@ function routeClearsPlacedLabels(edge, points) {
start: otherPoints[index],
end: otherPoints[index + 1],
}, candidateLabel);
- if (clearance != null && clearance + 0.0001 < 4) return false;
+ if (clearance != null && clearance + 0.0001 < 4) {
+ if (evidence) Object.assign(evidence, placedLabelConflictEvidence(edge, candidateLabel, item, 'label-route', otherPoints, index, clearance));
+ return false;
+ }
}
}
}
@@ -3508,6 +3548,56 @@ function readableCandidateIsFeasible(edge, points, from, to, fromSide, toSide) {
&& routeClearsLegend(edge, points);
}
+// Inspect only a rejected preset. Keep successful routing and automatic
+// candidate enumeration on the short-circuit feasibility path above.
+function readablePresetRejection(edge, points, from, to, fromSide, toSide) {
+ const checks = [
+ ['route endpoints', () => points.length >= 2],
+ ['orthogonal non-zero segments', () => orthogonalRoute(points)],
+ ['readable segment rhythm', () => routeMeetsHardRhythm(points)],
+ ['perpendicular endpoint-side direction', () => routeHonorsEndpointSides(points, fromSide, toSide)],
+ ['node clearance', () => routeClearsEndpointNodes(points, from, to)],
+ ['edge-label node clearance', () => routeLabelClearsNodes(edge, points)],
+ ['lane/phase/group label clearance', () => routeClearsSceneLabelObstacles(edge, points)],
+ ['node clearance', () => routeClearsUnrelatedNodes(edge, points)],
+ ['placed edge-label clearance', () => routeClearsPlacedLabels(edge, points)],
+ ['canvas origin', () => routeFitsCanvasOrigin(edge, points)],
+ ['structural-frame border clearance', () => routeClearsFrameBorders(points)],
+ ['legend clearance', () => routeClearsLegend(edge, points)],
+ ['route preset compatibility', () => routeMatchesPresetFamily(edge.route, points, from, to)],
+ ];
+ const invariant = checks.find(([, accepts]) => !accepts())?.[0];
+ if (invariant === 'placed edge-label clearance') {
+ const evidence = {};
+ routeClearsPlacedLabels(edge, points, evidence);
+ return { invariant, ...evidence };
+ }
+ if (invariant === 'node clearance') {
+ return { invariant, ...firstRouteNodeCollision(edge, points) };
+ }
+ if (invariant === 'readable segment rhythm') {
+ const segmentIndex = points.slice(0, -1).findIndex((point, index) => {
+ const minimum = points.length === 2 ? 28 : index === 0 || index === points.length - 2 ? 8 : 16;
+ return Math.hypot(points[index + 1][0] - point[0], points[index + 1][1] - point[1]) + 0.0001 < minimum;
+ });
+ return {
+ invariant,
+ segmentIndex,
+ actualSegmentPx: Math.hypot(
+ points[segmentIndex + 1][0] - points[segmentIndex][0],
+ points[segmentIndex + 1][1] - points[segmentIndex][1],
+ ),
+ requiredSegmentPx: points.length === 2 ? 28 : segmentIndex === 0 || segmentIndex === points.length - 2 ? 8 : 16,
+ };
+ }
+ if (invariant === 'edge-label node clearance') {
+ const labelRect = candidateLabelRect(edge, points);
+ const obstacle = [...nodes.values()].find((node) => rectsOverlap(labelRect, node, -2));
+ return { invariant, labelRect, obstacleNode: obstacle?.id };
+ }
+ return { invariant };
+}
+
function corridorViaY(start, end, fromSide, toSide, y) {
const startStub = outwardStub(start, fromSide);
const endStub = outwardStub(end, toSide);
@@ -3904,7 +3994,11 @@ function readablePresetVia(edge, from, to, start, end, fromSide, toSide) {
&& routeMatchesPresetFamily(preset, points, from, to)) {
return points.slice(1, -1);
}
- const message = `Workflow edge "${workflowEdgeName(edge)}" cannot satisfy route preset "${preset}" under readable-v2 constraints (minimum 8px endpoint stubs, 16px interior turns, and 28px direct clearance).`;
+ const rejection = readablePresetRejection(edge, points, from, to, fromSide, toSide);
+ const obstacle = rejection.obstacleNode
+ ? `: ${rejection.segmentIndex === undefined ? 'its label' : `segment ${rejection.segmentIndex}`} intersects node "${rejection.obstacleNode}"`
+ : '';
+ const message = `Workflow edge "${workflowEdgeName(edge)}" cannot satisfy route preset "${preset}": candidate violates ${rejection.invariant}${obstacle}.`;
const edgeIndex = workflow.edges.indexOf(edge);
const edgeName = workflowEdgeName(edge);
const supportedFixes = [];
@@ -3933,6 +4027,7 @@ function readablePresetVia(edge, from, to, start, end, fromSide, toSide) {
route: preset,
},
evidence: {
+ ...rejection,
attemptedCandidateFamily: preset,
points,
fromSide,
diff --git a/test/workflow-compiler-hard-contract.test.mjs b/test/workflow-compiler-hard-contract.test.mjs
index 7dbc0d1a..cfed2d3b 100644
--- a/test/workflow-compiler-hard-contract.test.mjs
+++ b/test/workflow-compiler-hard-contract.test.mjs
@@ -763,9 +763,59 @@ test('readable-v2 never accepts a same-lane drop through the preset-only fallbac
assert.equal(result.svg, undefined);
assert.ok(result.diagnostics.some(({ code }) => code === 'workflow/route-preset-conflict'));
assert.ok(result.diagnostics.every(({ code }) => code !== 'workflow/explicit-pin-conflict'));
+ assert.equal(result.diagnostics[0].evidence.invariant, 'route preset compatibility');
}
});
+test('readable-v2 preset diagnostics identify the blocked node rather than blaming segment rhythm', () => {
+ const document = workflow({
+ lanes: [{ id: 'upper', label: 'Upper' }, { id: 'lower', label: 'Lower' }],
+ nodes: [
+ { id: 'blocker', lane: 'upper', col: 0, type: 'backend', label: 'Blocker' },
+ { id: 'target', lane: 'upper', col: 2, type: 'backend', label: 'Target' },
+ { id: 'source', lane: 'lower', col: 0, type: 'backend', label: 'Source' },
+ ],
+ edges: [{ id: 'return', from: 'source', to: 'target', route: 'up-channel', fromSide: 'top', toSide: 'top' }],
+ });
+ for (const qualityProfile of ['standard', 'showcase']) {
+ const result = compileWorkflow({ workflow: clone(document), qualityProfile });
+ assert.equal(result.ok, false);
+ const diagnostic = result.diagnostics.find(({ code }) => code === 'workflow/route-preset-conflict');
+ assert.ok(diagnostic);
+ assert.equal(diagnostic.evidence.invariant, 'node clearance');
+ assert.equal(diagnostic.evidence.obstacleNode, 'blocker');
+ assert.equal(diagnostic.evidence.obstacleRole, 'unrelated');
+ assert.equal(diagnostic.evidence.segmentIndex, 0);
+ assert.equal(diagnostic.evidence.clearancePx, 2);
+ assert.deepEqual(diagnostic.evidence.from, diagnostic.evidence.points[0]);
+ assert.deepEqual(diagnostic.evidence.to, diagnostic.evidence.points[1]);
+ assert.match(diagnostic.message, /segment 0 intersects node "blocker"/);
+ assert.doesNotMatch(diagnostic.message, /minimum 8px/);
+ assert.deepEqual(document.edges[0], {
+ id: 'return', from: 'source', to: 'target', route: 'up-channel', fromSide: 'top', toSide: 'top',
+ });
+ }
+});
+
+test('readable-v2 preset diagnostics measure the segment that actually violates rhythm', () => {
+ const document = workflow({
+ lanes: [{ id: 'main', label: 'Main' }],
+ nodes: [
+ { id: 'a', lane: 'main', col: 0, type: 'backend', label: 'A', yOffset: -30 },
+ { id: 'b', lane: 'main', col: 0, type: 'backend', label: 'B', yOffset: 30 },
+ ],
+ edges: [{ id: 'ab', from: 'a', to: 'b', route: 'straight', fromSide: 'bottom', toSide: 'top' }],
+ });
+ const result = compileWorkflow({ workflow: document, qualityProfile: 'standard' });
+ assert.equal(result.ok, false);
+ const diagnostic = result.diagnostics.find(({ code }) => code === 'workflow/route-preset-conflict');
+ assert.ok(diagnostic);
+ assert.equal(diagnostic.evidence.invariant, 'readable segment rhythm');
+ assert.equal(diagnostic.evidence.segmentIndex, 0);
+ assert.equal(diagnostic.evidence.actualSegmentPx, 8);
+ assert.equal(diagnostic.evidence.requiredSegmentPx, 28);
+});
+
test('readable-v2 never silently ignores coordinate pins that conflict with a route preset', () => {
const cases = [
{
diff --git a/test/workflow-placed-label-evidence.test.mjs b/test/workflow-placed-label-evidence.test.mjs
new file mode 100644
index 00000000..8ca87dcd
--- /dev/null
+++ b/test/workflow-placed-label-evidence.test.mjs
@@ -0,0 +1,78 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { compileWorkflow } from '../archify/renderers/workflow/workflow-compiler.mjs';
+import { rectsOverlap, segmentRectClearance } from '../archify/renderers/shared/geometry.mjs';
+
+function fixture(kind, offset) {
+ return {
+ schema_version: 2, diagram_type: 'workflow',
+ meta: { title: 'Measured label collision', output: 'fixture.html', 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: 'top', col: 2, type: 'backend', label: 'B' },
+ { id: 'c', lane: 'bottom', col: 0, type: 'backend', label: 'C' },
+ { id: 'd', lane: 'bottom', col: 2, type: 'backend', label: 'D' },
+ ],
+ edges: [
+ { ...(kind === 'label-route' ? {} : { id: 'a-placed', label: 'Placed', labelDy: offset ?? (kind === 'label-label' ? 124 : 138) }), from: 'a', to: 'b', route: 'straight' },
+ { id: 'z-candidate', from: 'c', to: 'd', route: 'straight', label: 'Candidate', ...(kind === 'label-route' ? { labelDy: offset ?? -110 } : {}) },
+ ],
+ };
+}
+
+for (const kind of ['label-label', 'route-label', 'label-route']) {
+ for (const qualityProfile of ['standard', 'showcase']) {
+ test(`${qualityProfile} placed-label diagnostics expose the actual ${kind} conflict`, () => {
+ const document = fixture(kind);
+ // Reverse authorship to verify evidence pointers survive canonical routing order.
+ document.edges.reverse();
+ const result = compileWorkflow({ workflow: document, qualityProfile });
+ assert.equal(result.ok, false);
+ const diagnostic = result.diagnostics.find(({ code }) => code === 'workflow/route-preset-conflict');
+ assert.ok(diagnostic);
+ const evidence = diagnostic.evidence;
+ assert.equal(evidence.invariant, 'placed edge-label clearance');
+ assert.equal(evidence.conflictType, kind);
+ assert.deepEqual(evidence.candidateEdge, { edge: 'z-candidate', from: 'c', to: 'd', path: '/edges/0' });
+ assert.deepEqual(evidence.otherEdge, { edge: kind === 'label-route' ? null : 'a-placed', from: 'a', to: 'b', path: '/edges/1' });
+ assert.equal(evidence.candidateLabel.label, 'Candidate');
+ assert.deepEqual(evidence.candidateLabel.rect, { x: 187.4, y: kind === 'label-route' ? 113 : 223, width: 53.199999999999996, height: 14 });
+ if (kind === 'label-label') {
+ assert.equal(evidence.otherLabel.label, 'Placed');
+ assert.equal(evidence.rectangleMarginPx, -2);
+ assert.equal(evidence.overlapPx.y, 14);
+ assert.ok(rectsOverlap(evidence.candidateLabel.rect, evidence.otherLabel.rect, evidence.rectangleMarginPx));
+ assert.equal(evidence.segment, undefined);
+ assert.equal(evidence.measuredClearancePx, undefined);
+ } else {
+ assert.equal(evidence.segment.edge, kind === 'route-label' ? 'candidate' : 'other');
+ assert.equal(evidence.segment.index, 0);
+ assert.deepEqual(evidence.segment.from, [140, kind === 'route-label' ? 243 : 119]);
+ assert.deepEqual(evidence.segment.to, [288, kind === 'route-label' ? 243 : 119]);
+ const rect = kind === 'route-label' ? evidence.otherLabel.rect : evidence.candidateLabel.rect;
+ assert.equal(evidence.measuredClearancePx, segmentRectClearance({ start: evidence.segment.from, end: evidence.segment.to }, rect));
+ assert.equal(evidence.measuredClearancePx, 0);
+ assert.equal(evidence.requiredClearancePx, 4);
+ if (kind === 'label-route') assert.equal(evidence.otherLabel, undefined, 'an unlabeled obstacle route must not acquire a fabricated label');
+ }
+ for (const fix of diagnostic.supportedFixes) {
+ const repaired = structuredClone(document);
+ const preset = fix.match(/verified preset "([^"]+)"/)?.[1];
+ if (preset) repaired.edges[0].route = preset;
+ else delete repaired.edges[0].route;
+ assert.equal(compileWorkflow({ workflow: repaired, qualityProfile }).ok, true, fix);
+ }
+ });
+ }
+}
+
+test('placed-label acceptance retains the 2px overlap tolerance and 4px route clearance boundary', () => {
+ for (const qualityProfile of ['standard', 'showcase']) {
+ for (const [kind, offset] of [['label-label', 112], ['route-label', 148], ['label-route', -122]]) {
+ const result = compileWorkflow({ workflow: fixture(kind, offset), qualityProfile });
+ assert.equal(result.ok, true, JSON.stringify(result.diagnostics));
+ assert.match(result.svg, /Candidate/);
+ }
+ }
+});