design-constraint-validator 1.0.0 → 1.1.0

package/cli/commands/graph.js

@@ -1,6 +1,8 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { flattenTokens } from '../../core/flatten.js';
 import { exportGraphImage } from '../../core/image-export.js';
+import { attachRuntimeConstraints } from '../constraints-loader.js';
+import { loadConfig } from '../config.js';
 // Local helper for non-poset dependency graphs
 function generateDependencyGraph(edges, format) {
     switch (format) {
@@ -103,12 +105,14 @@ export async function graphCommand(options) {
                     const { Engine } = await import('../../core/engine.js');
                     const { MonotonicPlugin, parseSize } = await import('../../core/constraints/monotonic.js');
                     const { MonotonicLightness } = await import('../../core/constraints/monotonic-lightness.js');
-                    const { ThresholdPlugin } = await import('../../core/constraints/threshold.js');
-                    const { flat, edges } = flattenTokens(tokens);
+                    const { flat, edges: depEdges } = flattenTokens(tokens);
                     const init = {};
-                    Object.values(flat).forEach(t => { const ft = t; init[ft.id] = ft.value; });
-                    const engine = new Engine(init, edges);
-                    const allIdsInHasse = new Set([...h.keys(), ...Array.from(h.values()).flatMap(s => [...s])]);
+                    Object.values(flat).forEach((t) => {
+                        const ft = t;
+                        init[ft.id] = ft.value;
+                    });
+                    const engine = new Engine(init, depEdges);
+                    const allIdsInHasse = new Set([...h.keys(), ...Array.from(h.values()).flatMap((s) => [...s])]);
                     let issues = [];
                     if (name === 'color') {
                         const colorOrders = order;
@@ -118,10 +122,20 @@ export async function graphCommand(options) {
                         const numericOrders = order;
                         issues = MonotonicPlugin(numericOrders, parseSize, 'monotonic').evaluate(engine, allIdsInHasse);
                     }
-                    const thresholdIssues = ThresholdPlugin([{ id: 'control.size.min', op: '>=', valuePx: 44, where: 'Touch target (WCAG / Apple HIG)' }]).evaluate(engine, allIdsInHasse);
-                    issues.push(...thresholdIssues);
+                    // Attach threshold (and any other runtime constraints) respecting config flags
+                    const cfgRes = loadConfig(undefined);
+                    if (cfgRes.ok) {
+                        const config = cfgRes.value;
+                        const knownIds = new Set(Object.keys(flat));
+                        attachRuntimeConstraints(engine, { config, knownIds, bp: breakpoint });
+                        const runtimeIssues = engine.evaluate(allIdsInHasse);
+                        issues.push(...runtimeIssues);
+                    }
                     const severityRank = { error: 2, warn: 1 };
-                    const filteredIssues = issues.filter(it => { const level = it.level || 'error'; return severityRank[level] >= severityRank[minSeverity]; });
+                    const filteredIssues = issues.filter((it) => {
+                        const level = it.level || 'error';
+                        return severityRank[level] >= severityRank[minSeverity];
+                    });
                     const edgeViol = new Set();
                     const nodeViol = new Set();
                     if (labelViolations)
@@ -134,13 +148,15 @@ export async function graphCommand(options) {
                             nodeViol.add(b);
                             if (labelViolations && edgeLabels) {
                                 let label = it.message ?? 'violation';
-                                if (labelTruncate > 0 && label.length > labelTruncate)
+                                if (labelTruncate > 0 && label.length > labelTruncate) {
                                     label = label.slice(0, labelTruncate - 1) + '…';
+                                }
                                 edgeLabels.set(`${a}|${b}`, label);
                             }
                         }
-                        else if (typeof it.id === 'string')
+                        else if (typeof it.id === 'string') {
                             nodeViol.add(it.id);
+                        }
                     }
                     highlight = { nodes: nodeViol, edges: edgeViol, color: violationColor };
                     if (onlyViolations) {

package/cli/commands/graph.ts

@@ -1,137 +1,180 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import type { GraphOptions } from '../types.js';
-import { flattenTokens, type FlatToken } from '../../core/flatten.js';
-import { exportGraphImage } from '../../core/image-export.js';
-
-// Local helper for non-poset dependency graphs
-function generateDependencyGraph(edges: Array<[string, string]>, format: string): string {
-  switch (format) {
-    case 'dot': {
-      const dotNodes = new Set<string>(); edges.forEach(([f,t]) => { dotNodes.add(f); dotNodes.add(t); });
-      let dot = 'digraph tokens {\n  rankdir=LR;\n  node [shape=box, style=rounded];\n\n';
-      dotNodes.forEach(n => { dot += `  "${n}";\n`; });
-      dot += '\n'; edges.forEach(([f,t]) => { dot += `  "${f}" -> "${t}";\n`; });
-      return dot + '}\n'; }
-    case 'mermaid': {
-      let mermaid = 'graph LR\n'; const mermaidNodes = new Set<string>();
-      edges.forEach(([from,to]) => { const fromId = from.replace(/[^a-zA-Z0-9]/g,'_'); const toId = to.replace(/[^a-zA-Z0-9]/g,'_');
-        if (!mermaidNodes.has(fromId)) { mermaid += `  ${fromId}["${from}"]\n`; mermaidNodes.add(fromId); }
-        if (!mermaidNodes.has(toId)) { mermaid += `  ${toId}["${to}"]\n`; mermaidNodes.add(toId); }
-        mermaid += `  ${fromId} --> ${toId}\n`; });
-      return mermaid; }
-    case 'json':
-    default: return JSON.stringify({ nodes: Array.from(new Set(edges.flat())), edges }, null, 2);
-  }
-}
-
-export async function graphCommand(options: GraphOptions): Promise<void> {
-  const { parseBreakpoints } = await import('../../core/breakpoints.js');
-  const bps = parseBreakpoints(process.argv);
-  const plan = bps.length ? bps : [undefined];
-  if (options.hasse) {
-    const name = options.hasse;
-  const bundle = (options as any).bundle;
-  const fmt = (options.format === 'json' ? 'mermaid' : options.format) as 'mermaid' | 'dot' | 'svg' | 'png';
-    const imageFrom = options.imageFrom || 'mermaid';
-    const filterPrefixes = options.filterPrefix ? options.filterPrefix.split(',').map(s=>s.trim()).filter(Boolean) : [];
-    const excludePrefixes = options.excludePrefix ? options.excludePrefix.split(',').map(s=>s.trim()).filter(Boolean) : [];
-    const onlyViolations = options.onlyViolations || false;
-    const highlightViolations = options.highlightViolations || false;
-    const violationColor = options.violationColor || '#ff2d55';
-    const labelViolations = options.labelViolations || false;
-    const labelTruncate = Math.max(0, options.labelTruncate || 0);
-    const minSeverity = options.minSeverity || 'warn';
-    const focus = options.focus; const radius = Math.max(0, options.radius || 1);
-    for (const breakpoint of plan) {
-      const suffixParts: string[] = [];
-      if (breakpoint) suffixParts.push(breakpoint);
-      if (filterPrefixes.length) suffixParts.push(filterPrefixes.join('_'));
-      if (excludePrefixes.length) suffixParts.push('not-' + excludePrefixes.join('_'));
-      if (focus) suffixParts.push(`focus-${focus.replace(/[^\w.*-]/g,'_')}-r${radius}`);
-      if (onlyViolations) suffixParts.push('violations'); else if (highlightViolations) suffixParts.push('highlight-violations');
-      if (labelViolations) suffixParts.push('labeled');
-      const suffix = suffixParts.length ? '-' + suffixParts.map(s=>s.replace(/[^\w.-]/g,'_')).join('__') : '';
-      const baseFmt = fmt === 'svg' || fmt === 'png' ? (imageFrom === 'dot' ? 'dot' : 'mermaid') : fmt;
-      const ext = baseFmt === 'mermaid' ? 'mmd' : 'dot';
-      const outDir = 'dist/graphs'; const baseFile = `${outDir}/${name}${suffix}-hasse.${ext}`;
-      try {
-        const src = `themes/${name}.order.json`;
-        if (!existsSync(src)) { console.error(`❌ Order constraint file not found: ${src}`); process.exit(1); }
-        const { order } = JSON.parse(readFileSync(src, 'utf8'));
-        const { buildPoset, transitiveReduction, toMermaidHasseStyled, toDotHasseStyled, filterByPrefix, filterExcludePrefix, khopSubgraph, pickSeedsByPattern } = await import('../../core/poset.js');
-        let g = buildPoset(order);
-        if (filterPrefixes.length) g = filterByPrefix(g, filterPrefixes);
-        if (excludePrefixes.length) g = filterExcludePrefix(g, excludePrefixes);
-        let h = transitiveReduction(g);
-        if (focus) { const nodes = new Set<string>([...h.keys(), ...Array.from(h.values()).flatMap(s=>[...s])]); const seeds = pickSeedsByPattern(nodes, focus); h = khopSubgraph(h, seeds, radius); }
-        let highlight: { nodes: Set<string>; edges: Set<string>; color?: string } | undefined; let edgeLabels: Map<string,string> | undefined;
-        if (onlyViolations || highlightViolations || labelViolations) {
-          const { loadTokensWithBreakpoint } = await import('../../core/breakpoints.js');
-            const tokens = loadTokensWithBreakpoint(breakpoint); const { flattenTokens } = await import('../../core/flatten.js');
-            const { Engine } = await import('../../core/engine.js');
-            const { MonotonicPlugin, parseSize } = await import('../../core/constraints/monotonic.js');
-            const { MonotonicLightness } = await import('../../core/constraints/monotonic-lightness.js');
-            const { ThresholdPlugin } = await import('../../core/constraints/threshold.js');
-            const { flat, edges } = flattenTokens(tokens); const init: Record<string,string|number> = {}; Object.values(flat).forEach(t => { const ft = t as FlatToken; init[ft.id] = ft.value; });
-            const engine = new Engine(init, edges);
-            const allIdsInHasse = new Set<string>([...h.keys(), ...Array.from(h.values()).flatMap(s=>[...s])]);
-            let issues: any[] = [];
-            if (name === 'color') {
-              const colorOrders = order as [string, '<='|'>=', string][]; issues = MonotonicLightness(colorOrders).evaluate(engine, allIdsInHasse);
-            } else {
-              const numericOrders = order as [string, '<='|'>=', string][]; issues = MonotonicPlugin(numericOrders, parseSize, 'monotonic').evaluate(engine, allIdsInHasse);
-            }
-            const thresholdIssues = ThresholdPlugin([{ id: 'control.size.min', op: '>=', valuePx: 44, where: 'Touch target (WCAG / Apple HIG)' }]).evaluate(engine, allIdsInHasse); issues.push(...thresholdIssues);
-            const severityRank = { error: 2, warn: 1 } as const;
-            const filteredIssues = issues.filter(it => { const level = (it.level as 'warn'|'error') || 'error'; return severityRank[level] >= severityRank[minSeverity]; });
-            const edgeViol = new Set<string>(); const nodeViol = new Set<string>(); if (labelViolations) edgeLabels = new Map<string,string>();
-            for (const it of filteredIssues) {
-              if (typeof it.id === 'string' && it.id.includes('|')) { const [a,b] = it.id.split('|'); edgeViol.add(`${a}|${b}`); nodeViol.add(a); nodeViol.add(b); if (labelViolations && edgeLabels) { let label = it.message ?? 'violation'; if (labelTruncate > 0 && label.length > labelTruncate) label = label.slice(0, labelTruncate - 1) + '…'; edgeLabels.set(`${a}|${b}`, label); } }
-              else if (typeof it.id === 'string') nodeViol.add(it.id);
-            }
-            highlight = { nodes: nodeViol, edges: edgeViol, color: violationColor };
-            if (onlyViolations) {
-              const pruned: Map<string, Set<string>> = new Map();
-              for (const [u, vs] of h) {
-                for (const v of vs) {
-                  if (edgeViol.has(`${u}|${v}`) || nodeViol.has(u) || nodeViol.has(v)) { if (!pruned.has(u)) pruned.set(u, new Set()); pruned.get(u)!.add(v); if (!pruned.has(v)) pruned.set(v, new Set()); }
-                }
-              }
-              h = pruned;
-            }
-        }
-        const bpLabel = breakpoint ? ` @${breakpoint}` : '';
-        const title = `${name}${suffix ? ' ' + suffix : ''}${bpLabel} (Hasse)`;
-        const mermaidContent = toMermaidHasseStyled(h, { title, highlight, labels: edgeLabels });
-        const dotContent = toDotHasseStyled(h, { title, highlight, labels: edgeLabels });
-        mkdirSync(outDir, { recursive: true });
-        if (bundle) {
-          const mFile = baseFile.replace(/\.dot$/,'-bundle.mmd').replace(/\.mmd$/,'-bundle.mmd');
-          const dFile = baseFile.replace(/\.mmd$/,'-bundle.dot').replace(/\.dot$/,'-bundle.dot');
-          writeFileSync(mFile, mermaidContent);
-          writeFileSync(dFile, dotContent);
-        }
-        const baseContent = baseFmt === 'mermaid' ? mermaidContent : dotContent;
-        writeFileSync(baseFile, baseContent);
-        if (fmt === 'svg' || fmt === 'png') {
-          const imgFile = `${outDir}/${name}${suffix}-hasse.${fmt}`;
-          const { ok, hint } = exportGraphImage(baseFile, imgFile, fmt, imageFrom);
-          if (ok) console.log(`✓ Wrote ${baseFile} and ${imgFile}`); else console.log(`✓ Wrote ${baseFile} (image export skipped). ${hint}`);
-        } else {
-          const hasViolations = highlight && (highlight.edges.size > 0 || highlight.nodes.size > 0);
-          const message = (onlyViolations || highlightViolations) && !hasViolations ? `✓ Wrote ${baseFile} (no violations in slice)` : `✓ Wrote ${baseFile}`;
-          console.log(message);
-        }
-      } catch (error) { console.error(`❌ Error generating Hasse diagram for ${breakpoint}:`, error); process.exit(1); }
-    }
-    return; }
-  for (const breakpoint of plan) {
-    const { loadTokensWithBreakpoint } = await import('../../core/breakpoints.js');
-    const tokens = loadTokensWithBreakpoint(breakpoint); const { edges } = flattenTokens(tokens);
-    let filteredEdges = edges;
-    if (options.filter) { const filterRegex = new RegExp(options.filter); filteredEdges = edges.filter(([from,to]) => filterRegex.test(from) || filterRegex.test(to)); }
-    const format = options.format || 'json'; const graph = generateDependencyGraph(filteredEdges, format);
-    if (options.output) { const bpSuffix = breakpoint ? `.${breakpoint}` : ''; const outputPath = options.output.replace(/(\.[^.]+)$/ , `${bpSuffix}$1`); writeFileSync(outputPath, graph, 'utf8'); console.log(`Dependency graph written to: ${outputPath}`); }
-    else { if (breakpoint) console.log(`\n=== ${breakpoint.toUpperCase()} ===`); console.log(graph); }
-  }
-}
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import type { GraphOptions } from '../types.js';
+import { flattenTokens, type FlatToken } from '../../core/flatten.js';
+import { exportGraphImage } from '../../core/image-export.js';
+import { attachRuntimeConstraints } from '../constraints-loader.js';
+import { loadConfig } from '../config.js';
+
+// Local helper for non-poset dependency graphs
+function generateDependencyGraph(edges: Array<[string, string]>, format: string): string {
+  switch (format) {
+    case 'dot': {
+      const dotNodes = new Set<string>(); edges.forEach(([f,t]) => { dotNodes.add(f); dotNodes.add(t); });
+      let dot = 'digraph tokens {\n  rankdir=LR;\n  node [shape=box, style=rounded];\n\n';
+      dotNodes.forEach(n => { dot += `  "${n}";\n`; });
+      dot += '\n'; edges.forEach(([f,t]) => { dot += `  "${f}" -> "${t}";\n`; });
+      return dot + '}\n'; }
+    case 'mermaid': {
+      let mermaid = 'graph LR\n'; const mermaidNodes = new Set<string>();
+      edges.forEach(([from,to]) => { const fromId = from.replace(/[^a-zA-Z0-9]/g,'_'); const toId = to.replace(/[^a-zA-Z0-9]/g,'_');
+        if (!mermaidNodes.has(fromId)) { mermaid += `  ${fromId}["${from}"]\n`; mermaidNodes.add(fromId); }
+        if (!mermaidNodes.has(toId)) { mermaid += `  ${toId}["${to}"]\n`; mermaidNodes.add(toId); }
+        mermaid += `  ${fromId} --> ${toId}\n`; });
+      return mermaid; }
+    case 'json':
+    default: return JSON.stringify({ nodes: Array.from(new Set(edges.flat())), edges }, null, 2);
+  }
+}
+
+export async function graphCommand(options: GraphOptions): Promise<void> {
+  const { parseBreakpoints } = await import('../../core/breakpoints.js');
+  const bps = parseBreakpoints(process.argv);
+  const plan = bps.length ? bps : [undefined];
+  if (options.hasse) {
+    const name = options.hasse;
+  const bundle = (options as any).bundle;
+  const fmt = (options.format === 'json' ? 'mermaid' : options.format) as 'mermaid' | 'dot' | 'svg' | 'png';
+    const imageFrom = options.imageFrom || 'mermaid';
+    const filterPrefixes = options.filterPrefix ? options.filterPrefix.split(',').map(s=>s.trim()).filter(Boolean) : [];
+    const excludePrefixes = options.excludePrefix ? options.excludePrefix.split(',').map(s=>s.trim()).filter(Boolean) : [];
+    const onlyViolations = options.onlyViolations || false;
+    const highlightViolations = options.highlightViolations || false;
+    const violationColor = options.violationColor || '#ff2d55';
+    const labelViolations = options.labelViolations || false;
+    const labelTruncate = Math.max(0, options.labelTruncate || 0);
+    const minSeverity = options.minSeverity || 'warn';
+    const focus = options.focus; const radius = Math.max(0, options.radius || 1);
+    for (const breakpoint of plan) {
+      const suffixParts: string[] = [];
+      if (breakpoint) suffixParts.push(breakpoint);
+      if (filterPrefixes.length) suffixParts.push(filterPrefixes.join('_'));
+      if (excludePrefixes.length) suffixParts.push('not-' + excludePrefixes.join('_'));
+      if (focus) suffixParts.push(`focus-${focus.replace(/[^\w.*-]/g,'_')}-r${radius}`);
+      if (onlyViolations) suffixParts.push('violations'); else if (highlightViolations) suffixParts.push('highlight-violations');
+      if (labelViolations) suffixParts.push('labeled');
+      const suffix = suffixParts.length ? '-' + suffixParts.map(s=>s.replace(/[^\w.-]/g,'_')).join('__') : '';
+      const baseFmt = fmt === 'svg' || fmt === 'png' ? (imageFrom === 'dot' ? 'dot' : 'mermaid') : fmt;
+      const ext = baseFmt === 'mermaid' ? 'mmd' : 'dot';
+      const outDir = 'dist/graphs'; const baseFile = `${outDir}/${name}${suffix}-hasse.${ext}`;
+      try {
+        const src = `themes/${name}.order.json`;
+        if (!existsSync(src)) { console.error(`❌ Order constraint file not found: ${src}`); process.exit(1); }
+        const { order } = JSON.parse(readFileSync(src, 'utf8'));
+        const { buildPoset, transitiveReduction, toMermaidHasseStyled, toDotHasseStyled, filterByPrefix, filterExcludePrefix, khopSubgraph, pickSeedsByPattern } = await import('../../core/poset.js');
+        let g = buildPoset(order);
+        if (filterPrefixes.length) g = filterByPrefix(g, filterPrefixes);
+        if (excludePrefixes.length) g = filterExcludePrefix(g, excludePrefixes);
+        let h = transitiveReduction(g);
+        if (focus) { const nodes = new Set<string>([...h.keys(), ...Array.from(h.values()).flatMap(s=>[...s])]); const seeds = pickSeedsByPattern(nodes, focus); h = khopSubgraph(h, seeds, radius); }
+        let highlight: { nodes: Set<string>; edges: Set<string>; color?: string } | undefined; let edgeLabels: Map<string,string> | undefined;
+        if (onlyViolations || highlightViolations || labelViolations) {
+          const { loadTokensWithBreakpoint } = await import('../../core/breakpoints.js');
+          const tokens = loadTokensWithBreakpoint(breakpoint);
+          const { flattenTokens } = await import('../../core/flatten.js');
+          const { Engine } = await import('../../core/engine.js');
+          const { MonotonicPlugin, parseSize } = await import('../../core/constraints/monotonic.js');
+          const { MonotonicLightness } = await import('../../core/constraints/monotonic-lightness.js');
+
+          const { flat, edges: depEdges } = flattenTokens(tokens);
+          const init: Record<string, string | number> = {};
+          Object.values(flat).forEach((t) => {
+            const ft = t as FlatToken;
+            init[ft.id] = ft.value;
+          });
+          const engine = new Engine(init, depEdges);
+
+          const allIdsInHasse = new Set<string>([...h.keys(), ...Array.from(h.values()).flatMap((s) => [...s])]);
+          let issues: any[] = [];
+          if (name === 'color') {
+            const colorOrders = order as [string, '<=' | '>=', string][];
+            issues = MonotonicLightness(colorOrders).evaluate(engine, allIdsInHasse);
+          } else {
+            const numericOrders = order as [string, '<=' | '>=', string][];
+            issues = MonotonicPlugin(numericOrders, parseSize, 'monotonic').evaluate(engine, allIdsInHasse);
+          }
+
+          // Attach threshold (and any other runtime constraints) respecting config flags
+          const cfgRes = loadConfig(undefined);
+          if (cfgRes.ok) {
+            const config = cfgRes.value;
+            const knownIds = new Set(Object.keys(flat as Record<string, FlatToken>));
+            attachRuntimeConstraints(engine, { config, knownIds, bp: breakpoint });
+            const runtimeIssues = engine.evaluate(allIdsInHasse);
+            issues.push(...runtimeIssues);
+          }
+
+          const severityRank = { error: 2, warn: 1 } as const;
+          const filteredIssues = issues.filter((it) => {
+            const level = (it.level as 'warn' | 'error') || 'error';
+            return severityRank[level] >= severityRank[minSeverity];
+          });
+          const edgeViol = new Set<string>();
+          const nodeViol = new Set<string>();
+          if (labelViolations) edgeLabels = new Map<string, string>();
+          for (const it of filteredIssues) {
+            if (typeof it.id === 'string' && it.id.includes('|')) {
+              const [a, b] = it.id.split('|');
+              edgeViol.add(`${a}|${b}`);
+              nodeViol.add(a);
+              nodeViol.add(b);
+              if (labelViolations && edgeLabels) {
+                let label = it.message ?? 'violation';
+                if (labelTruncate > 0 && label.length > labelTruncate) {
+                  label = label.slice(0, labelTruncate - 1) + '…';
+                }
+                edgeLabels.set(`${a}|${b}`, label);
+              }
+            } else if (typeof it.id === 'string') {
+              nodeViol.add(it.id);
+            }
+          }
+          highlight = { nodes: nodeViol, edges: edgeViol, color: violationColor };
+          if (onlyViolations) {
+            const pruned: Map<string, Set<string>> = new Map();
+            for (const [u, vs] of h) {
+              for (const v of vs) {
+                if (edgeViol.has(`${u}|${v}`) || nodeViol.has(u) || nodeViol.has(v)) {
+                  if (!pruned.has(u)) pruned.set(u, new Set());
+                  pruned.get(u)!.add(v);
+                  if (!pruned.has(v)) pruned.set(v, new Set());
+                }
+              }
+            }
+            h = pruned;
+          }
+        }
+        const bpLabel = breakpoint ? ` @${breakpoint}` : '';
+        const title = `${name}${suffix ? ' ' + suffix : ''}${bpLabel} (Hasse)`;
+        const mermaidContent = toMermaidHasseStyled(h, { title, highlight, labels: edgeLabels });
+        const dotContent = toDotHasseStyled(h, { title, highlight, labels: edgeLabels });
+        mkdirSync(outDir, { recursive: true });
+        if (bundle) {
+          const mFile = baseFile.replace(/\.dot$/,'-bundle.mmd').replace(/\.mmd$/,'-bundle.mmd');
+          const dFile = baseFile.replace(/\.mmd$/,'-bundle.dot').replace(/\.dot$/,'-bundle.dot');
+          writeFileSync(mFile, mermaidContent);
+          writeFileSync(dFile, dotContent);
+        }
+        const baseContent = baseFmt === 'mermaid' ? mermaidContent : dotContent;
+        writeFileSync(baseFile, baseContent);
+        if (fmt === 'svg' || fmt === 'png') {
+          const imgFile = `${outDir}/${name}${suffix}-hasse.${fmt}`;
+          const { ok, hint } = exportGraphImage(baseFile, imgFile, fmt, imageFrom);
+          if (ok) console.log(`✓ Wrote ${baseFile} and ${imgFile}`); else console.log(`✓ Wrote ${baseFile} (image export skipped). ${hint}`);
+        } else {
+          const hasViolations = highlight && (highlight.edges.size > 0 || highlight.nodes.size > 0);
+          const message = (onlyViolations || highlightViolations) && !hasViolations ? `✓ Wrote ${baseFile} (no violations in slice)` : `✓ Wrote ${baseFile}`;
+          console.log(message);
+        }
+      } catch (error) { console.error(`❌ Error generating Hasse diagram for ${breakpoint}:`, error); process.exit(1); }
+    }
+    return; }
+  for (const breakpoint of plan) {
+    const { loadTokensWithBreakpoint } = await import('../../core/breakpoints.js');
+    const tokens = loadTokensWithBreakpoint(breakpoint); const { edges } = flattenTokens(tokens);
+    let filteredEdges = edges;
+    if (options.filter) { const filterRegex = new RegExp(options.filter); filteredEdges = edges.filter(([from,to]) => filterRegex.test(from) || filterRegex.test(to)); }
+    const format = options.format || 'json'; const graph = generateDependencyGraph(filteredEdges, format);
+    if (options.output) { const bpSuffix = breakpoint ? `.${breakpoint}` : ''; const outputPath = options.output.replace(/(\.[^.]+)$/ , `${bpSuffix}$1`); writeFileSync(outputPath, graph, 'utf8'); console.log(`Dependency graph written to: ${outputPath}`); }
+    else { if (breakpoint) console.log(`\n=== ${breakpoint.toUpperCase()} ===`); console.log(graph); }
+  }
+}

package/cli/commands/index.ts

@@ -1,7 +1,7 @@
-export { setCommand } from './set.js';
-export { buildCommand } from './build.js';
-export { validateCommand } from './validate.js';
-export { graphCommand } from './graph.js';
-export { whyCommand } from './why.js';
-export { patchCommand } from './patch.js';
-export { patchApplyCommand } from './patch-apply.js';
+export { setCommand } from './set.js';
+export { buildCommand } from './build.js';
+export { validateCommand } from './validate.js';
+export { graphCommand } from './graph.js';
+export { whyCommand } from './why.js';
+export { patchCommand } from './patch.js';
+export { patchApplyCommand } from './patch-apply.js';

package/cli/commands/patch-apply.ts

@@ -1,80 +1,80 @@
-import { loadTokens, outputResult } from './utils.js';
-import type { PatchApplyOptions } from '../types.js';
-import type { TokenNode } from '../../core/flatten.js';
-import fs from 'node:fs';
-import { flattenTokens } from '../../core/flatten.js';
-import { createHash } from 'node:crypto';
-
-interface PatchDocumentV1 {
-  version: 1;
-  changes: Array<{ id: string; from: any; to: any; type: 'modify'|'add'|'remove' }>;
-  patch: Record<string, any>;
-  baseTokensHash?: string;
-}
-
-function applyChange(root: any, id: string, to: any, type: 'modify'|'add'|'remove') {
-  const parts = id.split('.');
-  let cur: any = root;
-  for (let i = 0; i < parts.length; i++) {
-    const p = parts[i];
-    if (i === parts.length - 1) {
-      if (type === 'remove') {
-        if (cur[p] && typeof cur[p] === 'object') {
-          delete cur[p].$value; // delete leaf value
-        }
-      } else {
-        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
-        cur[p].$value = to;
-      }
-    } else {
-      if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
-      cur = cur[p];
-    }
-  }
-}
-
-export async function patchApplyCommand(opts: PatchApplyOptions): Promise<void> {
-  const tokens: TokenNode = loadTokens(opts.tokens || 'tokens/tokens.example.json');
-  // Compute current base tokens hash for drift detection (same logic as buildPatch)
-  function computeBaseHash(toks: TokenNode): string {
-    const flat = flattenTokens(JSON.parse(JSON.stringify(toks))).flat as Record<string, any>;
-    const values: Record<string, any> = {};
-    Object.keys(flat).sort().forEach(id => { values[id] = flat[id]?.value; });
-    // Keep deterministic ordering
-    const ordered = Object.keys(values).sort().reduce((acc, k) => { acc[k] = values[k]; return acc; }, {} as Record<string, any>);
-    return createHash('sha256').update(JSON.stringify(ordered)).digest('hex');
-  }
-  // Parse patch
-  let patchDoc: PatchDocumentV1;
-  if (fs.existsSync(opts.patch)) {
-    patchDoc = JSON.parse(fs.readFileSync(opts.patch, 'utf8'));
-  } else if (opts.patch.trim().startsWith('{')) {
-    patchDoc = JSON.parse(opts.patch);
-  } else {
-    throw new Error(`Patch not found: ${opts.patch}`);
-  }
-  if (patchDoc.version !== 1) throw new Error('Unsupported patch version');
-  if (patchDoc.baseTokensHash) {
-    const currentHash = computeBaseHash(tokens);
-    if (currentHash !== patchDoc.baseTokensHash) {
-      console.warn(`⚠ Base tokens hash mismatch. Patch built against ${patchDoc.baseTokensHash} but current base is ${currentHash}. Proceeding (use --dry-run to inspect first).`);
-    }
-  }
-
-  // Apply changes
-  for (const c of patchDoc.changes) {
-    applyChange(tokens, c.id, c.to, c.type);
-  }
-
-  if (opts.dryRun) {
-    outputResult(tokens, 'json');
-    return;
-  }
-
-  if (opts.output) {
-    fs.writeFileSync(opts.output, JSON.stringify(tokens, null, 2));
-    if (!opts.quiet) console.log(`✔ Patch applied to ${opts.output}`);
-  } else {
-    outputResult(tokens, 'json');
-  }
-}
+import { loadTokens, outputResult } from './utils.js';
+import type { PatchApplyOptions } from '../types.js';
+import type { TokenNode } from '../../core/flatten.js';
+import fs from 'node:fs';
+import { flattenTokens } from '../../core/flatten.js';
+import { createHash } from 'node:crypto';
+
+interface PatchDocumentV1 {
+  version: 1;
+  changes: Array<{ id: string; from: any; to: any; type: 'modify'|'add'|'remove' }>;
+  patch: Record<string, any>;
+  baseTokensHash?: string;
+}
+
+function applyChange(root: any, id: string, to: any, type: 'modify'|'add'|'remove') {
+  const parts = id.split('.');
+  let cur: any = root;
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    if (i === parts.length - 1) {
+      if (type === 'remove') {
+        if (cur[p] && typeof cur[p] === 'object') {
+          delete cur[p].$value; // delete leaf value
+        }
+      } else {
+        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+        cur[p].$value = to;
+      }
+    } else {
+      if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+      cur = cur[p];
+    }
+  }
+}
+
+export async function patchApplyCommand(opts: PatchApplyOptions): Promise<void> {
+  const tokens: TokenNode = loadTokens(opts.tokens || 'tokens/tokens.example.json');
+  // Compute current base tokens hash for drift detection (same logic as buildPatch)
+  function computeBaseHash(toks: TokenNode): string {
+    const flat = flattenTokens(JSON.parse(JSON.stringify(toks))).flat as Record<string, any>;
+    const values: Record<string, any> = {};
+    Object.keys(flat).sort().forEach(id => { values[id] = flat[id]?.value; });
+    // Keep deterministic ordering
+    const ordered = Object.keys(values).sort().reduce((acc, k) => { acc[k] = values[k]; return acc; }, {} as Record<string, any>);
+    return createHash('sha256').update(JSON.stringify(ordered)).digest('hex');
+  }
+  // Parse patch
+  let patchDoc: PatchDocumentV1;
+  if (fs.existsSync(opts.patch)) {
+    patchDoc = JSON.parse(fs.readFileSync(opts.patch, 'utf8'));
+  } else if (opts.patch.trim().startsWith('{')) {
+    patchDoc = JSON.parse(opts.patch);
+  } else {
+    throw new Error(`Patch not found: ${opts.patch}`);
+  }
+  if (patchDoc.version !== 1) throw new Error('Unsupported patch version');
+  if (patchDoc.baseTokensHash) {
+    const currentHash = computeBaseHash(tokens);
+    if (currentHash !== patchDoc.baseTokensHash) {
+      console.warn(`⚠ Base tokens hash mismatch. Patch built against ${patchDoc.baseTokensHash} but current base is ${currentHash}. Proceeding (use --dry-run to inspect first).`);
+    }
+  }
+
+  // Apply changes
+  for (const c of patchDoc.changes) {
+    applyChange(tokens, c.id, c.to, c.type);
+  }
+
+  if (opts.dryRun) {
+    outputResult(tokens, 'json');
+    return;
+  }
+
+  if (opts.output) {
+    fs.writeFileSync(opts.output, JSON.stringify(tokens, null, 2));
+    if (!opts.quiet) console.log(`✔ Patch applied to ${opts.output}`);
+  } else {
+    outputResult(tokens, 'json');
+  }
+}