design-constraint-validator 1.0.0

package/core/cross-axis-config.ts

@@ -0,0 +1,152 @@
+import fs from "node:fs";
+import { CrossAxisPlugin, type CrossAxisRule, type Ctx } from "./constraints/cross-axis.js";
+
+type When = { id: string; op: "<="|">="|"<"|">"|"=="|"!="; value: number };
+type Require = { id: string; op: "<="|">="|"<"|">"|"=="|"!="; ref?: string; fallback?: string|number };
+type Compare = { a: string; op: "<="|">="|"<"|">"|"=="|"!="; b: string; delta?: string|number };
+type RawRule = { id: string; level?: "error"|"warn"; where?: string; bp?: string; when?: When; require?: Require; compare?: Compare; };
+
+export function loadCrossAxisPlugin(
+  path: string,
+  bp?: string,
+  opts?: { debug?: boolean; knownIds?: Set<string> }
+) {
+  const debug = !!opts?.debug;
+  const known = opts?.knownIds ?? new Set<string>();
+  const log = (...args: any[]) => { if (debug) console.log("[cross-axis]", ...args); };
+
+  if (!fs.existsSync(path)) {
+    log(`no rules file at ${path} (bp=${bp ?? "global"})`);
+    return CrossAxisPlugin([], bp);
+  }
+
+  const raw = JSON.parse(fs.readFileSync(path, "utf8")) as { rules: RawRule[] };
+  const rules: CrossAxisRule[] = [];
+  const unknownIds = new Set<string>();
+  const skipped: Array<{ id?: string; reason: string }> = [];
+
+  // Fuzzy suggestion helpers (lightweight Levenshtein)
+  function levenshtein(a: string, b: string) {
+    const dp = Array(b.length + 1).fill(0).map((_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+      let prev = i - 1, cur = i;
+      for (let j = 1; j <= b.length; j++) {
+        const tmp = cur;
+        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+        cur = Math.min(dp[j] + 1, cur + 1, prev + cost);
+        dp[j] = tmp;
+        prev = tmp;
+      }
+      dp[b.length] = cur;
+    }
+    return dp[b.length];
+  }
+  function suggest(id: string, k = 3) {
+    return [...known].map(c => ({ id: c, d: levenshtein(id, c) }))
+      .sort((a, b) => a.d - b.d)
+      .slice(0, k);
+  }
+
+  const needId = (id?: string) => {
+    if (!id) return false;
+    if (!known.has(id)) { unknownIds.add(id); }
+    return true;
+  };
+
+  for (const r of raw.rules || []) {
+    if (r.bp && bp && r.bp !== bp) { continue; }
+    if (r.bp && !bp) { // rule targets specific breakpoint; skip in global run
+      continue;
+    }
+    try {
+      if (r.when && r.require) {
+        // Validate IDs
+        needId(r.when.id);
+        needId(r.require.id);
+        if (r.require.ref) needId(r.require.ref);
+
+        rules.push({
+          id: r.id, level: r.level, where: r.where,
+          when: { id: r.when.id, test: makeOp(r.when.op, r.when.value) },
+          require: {
+            id: r.require.id,
+            test: (v: number, ctx: Ctx) => {
+              const rhs = valueOrRef(ctx, r.require!.ref, r.require!.fallback);
+              return cmp(v, rhs, r.require!.op);
+            },
+            msg: (v: number, ctx: Ctx) => {
+              const rhs = valueOrRef(ctx, r.require!.ref, r.require!.fallback);
+              return `${r.require!.id} ${prettyFail(r.require!.op)} ${fmt(rhs)} (was ${fmt(v)})`;
+            }
+          }
+        });
+      } else if (r.compare) {
+        needId(r.compare.a);
+        needId(r.compare.b);
+
+        rules.push({
+          id: r.id, level: r.level, where: r.where,
+          when: { id: r.compare.a, test: () => true },
+          require: {
+            id: r.compare.a,
+            test: (_: number, ctx: Ctx) => {
+              const a = ctx.getPx(r.compare!.a) ?? NaN;
+              const b = ctx.getPx(r.compare!.b) ?? NaN;
+              const delta = px(r.compare!.delta ?? 0);
+              if (Number.isNaN(a) || Number.isNaN(b)) return true; // skip check if missing
+              return cmp(a, b + delta, r.compare!.op);
+            },
+            msg: (_: number, ctx: Ctx) => {
+              const a = ctx.getPx(r.compare!.a);
+              const b = ctx.getPx(r.compare!.b);
+              const delta = px(r.compare!.delta ?? 0);
+              return `${r.compare!.a} ${prettyFail(r.compare!.op)} ${fmt((b ?? 0) + delta)} (was ${fmt(a ?? NaN)})`;
+            }
+          }
+        });
+      } else {
+        skipped.push({ id: r.id, reason: "neither when+require nor compare present" });
+      }
+    } catch (e: any) {
+      skipped.push({ id: r.id, reason: `exception: ${e?.message ?? e}` });
+    }
+  }
+
+  log(`loaded ${rules.length} rule(s) from ${path}${bp ? ` [bp=${bp}]` : ""}`);
+  if (unknownIds.size) {
+    log(`unknown ids referenced:`, [...unknownIds].join(", "));
+    for (const u of unknownIds) {
+      const s = suggest(u, 3);
+      if (s.length) log(`  did you mean: ${s.map(x => `${x.id} (d=${x.d})`).join(', ')}`);
+    }
+  }
+  if (skipped.length) {
+    for (const s of skipped) log(`skipped rule ${s.id ?? "(no id)"} — ${s.reason}`);
+  }
+
+  // Extra hint for common anchor pitfall
+  for (const r of raw.rules || []) {
+    if (r.require?.ref && !known.has(r.require.ref)) {
+      log(`anchor missing: ${r.require.ref} → will use fallback=${JSON.stringify(r.require.fallback)} when evaluating`);
+    }
+  }
+
+  return CrossAxisPlugin(rules, bp);
+}
+
+// helpers
+const px = (v: string|number) => typeof v === "number" ? v : parseFloat(String(v)) * (String(v).trim().endsWith("rem") ? 16 : 1);
+const cmp = (a:number,b:number,op:When["op"]) =>
+  op === ">="? a>=b : op === ">"? a>b : op === "<="? a<=b : op === "<"? a<b : op === "=="? a===b : a!==b;
+const prettyFail = (op: string) => ({">=":"<",">":"≤","<=":">","<": "≥","==":"≠","!=":"="} as any)[op] || "≠";
+const fmt = (v:number|string) => Number.isFinite(Number(v)) ? `${Number(v)}px` : String(v);
+function valueOrRef(ctx: Ctx, ref?: string, fallback?: string|number) {
+  if (ref) {
+    const v = ctx.getPx(ref);
+    if (v != null) return v;
+  }
+  return typeof fallback === "number" ? fallback : px(fallback ?? 0);
+}
+function makeOp(op: When["op"], rhs: number) {
+  return (v: number) => cmp(v, rhs, op);
+}

package/core/engine.d.ts

@@ -0,0 +1,32 @@
+import type { TokenId, TokenValue } from "./flatten.js";
+export type ConstraintIssue = {
+    id: TokenId | string;
+    rule: string;
+    level: "error" | "warn";
+    message: string;
+    where?: string;
+};
+export type ConstraintPlugin = {
+    id: string;
+    evaluate(engine: Engine, candidates: Set<TokenId>): ConstraintIssue[];
+};
+export type Graph = Map<TokenId, Set<TokenId>>;
+export declare class Engine {
+    private values;
+    private graph;
+    private plugins;
+    constructor(initValues: Record<TokenId, TokenValue>, edges: Array<[TokenId, TokenId]>);
+    use(plugin: ConstraintPlugin): this;
+    get(id: TokenId): TokenValue | undefined;
+    set(id: TokenId, value: TokenValue): void;
+    /** All nodes that depend (directly/indirectly) on start. */
+    affected(start: TokenId): Set<TokenId>;
+    evaluate(candidates: Set<TokenId>): ConstraintIssue[];
+    /** Single change -> returns affected set, issues, and a patch you can feed to adapters. */
+    commit(id: TokenId, value: TokenValue): {
+        affected: string[];
+        issues: ConstraintIssue[];
+        patch: Record<string, TokenValue>;
+    };
+}
+//# sourceMappingURL=engine.d.ts.map

package/core/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,OAAO,GAAG,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IAEX,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,eAAe,EAAE,CAAC;CACvE,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAE/C,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,OAAO,CAA0B;gBAE7B,UAAU,EAAE,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IASrF,GAAG,CAAC,MAAM,EAAE,gBAAgB;IAE5B,GAAG,CAAC,EAAE,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS;IACxC,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU;IAElC,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;IAatC,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,OAAO,CAAC;IAIjC,2FAA2F;IAC3F,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU;;;;;CAQtC"}

package/core/engine.js

@@ -0,0 +1,46 @@
+export class Engine {
+    values = new Map();
+    graph = new Map();
+    plugins = [];
+    constructor(initValues, edges) {
+        for (const [k, v] of Object.entries(initValues))
+            this.values.set(k, v);
+        for (const [from, to] of edges) {
+            if (!this.graph.has(from))
+                this.graph.set(from, new Set());
+            this.graph.get(from).add(to);
+            if (!this.graph.has(to))
+                this.graph.set(to, new Set());
+        }
+    }
+    use(plugin) { this.plugins.push(plugin); return this; }
+    get(id) { return this.values.get(id); }
+    set(id, value) { this.values.set(id, value); }
+    /** All nodes that depend (directly/indirectly) on start. */
+    affected(start) {
+        const seen = new Set();
+        const stack = [start];
+        while (stack.length) {
+            const n = stack.pop();
+            if (seen.has(n))
+                continue;
+            seen.add(n);
+            for (const d of this.graph.get(n) ?? [])
+                stack.push(d);
+        }
+        seen.delete(start);
+        return seen;
+    }
+    evaluate(candidates) {
+        return this.plugins.flatMap(p => p.evaluate(this, candidates));
+    }
+    /** Single change -> returns affected set, issues, and a patch you can feed to adapters. */
+    commit(id, value) {
+        this.set(id, value);
+        const A = this.affected(id);
+        const candidates = new Set([id, ...A]);
+        const issues = this.evaluate(candidates);
+        const patch = { [id]: value };
+        return { affected: [...A], issues, patch };
+    }
+}

package/core/engine.ts

@@ -0,0 +1,65 @@
+import type { TokenId, TokenValue } from "./flatten.js";
+
+export type ConstraintIssue = {
+  id: TokenId | string;
+  rule: string;            // e.g., "wcag-contrast"
+  level: "error" | "warn";
+  message: string;
+  where?: string;          // optional hint (e.g., "body text on surface")
+};
+
+export type ConstraintPlugin = {
+  id: string;
+  // Called with the set of candidate IDs (changed + affected).
+  evaluate(engine: Engine, candidates: Set<TokenId>): ConstraintIssue[];
+};
+
+export type Graph = Map<TokenId, Set<TokenId>>; // id -> dependents
+
+export class Engine {
+  private values = new Map<TokenId, TokenValue>();
+  private graph: Graph = new Map();
+  private plugins: ConstraintPlugin[] = [];
+
+  constructor(initValues: Record<TokenId, TokenValue>, edges: Array<[TokenId, TokenId]>) {
+    for (const [k, v] of Object.entries(initValues)) this.values.set(k, v);
+    for (const [from, to] of edges) {
+      if (!this.graph.has(from)) this.graph.set(from, new Set());
+      this.graph.get(from)!.add(to);
+      if (!this.graph.has(to)) this.graph.set(to, new Set());
+    }
+  }
+
+  use(plugin: ConstraintPlugin) { this.plugins.push(plugin); return this; }
+
+  get(id: TokenId): TokenValue | undefined { return this.values.get(id); }
+  set(id: TokenId, value: TokenValue) { this.values.set(id, value); }
+
+  /** All nodes that depend (directly/indirectly) on start. */
+  affected(start: TokenId): Set<TokenId> {
+    const seen = new Set<TokenId>();
+    const stack = [start];
+    while (stack.length) {
+      const n = stack.pop()!;
+      if (seen.has(n)) continue;
+      seen.add(n);
+      for (const d of this.graph.get(n) ?? []) stack.push(d);
+    }
+    seen.delete(start);
+    return seen;
+  }
+
+  evaluate(candidates: Set<TokenId>) {
+    return this.plugins.flatMap(p => p.evaluate(this, candidates));
+  }
+
+  /** Single change -> returns affected set, issues, and a patch you can feed to adapters. */
+  commit(id: TokenId, value: TokenValue) {
+    this.set(id, value);
+    const A = this.affected(id);
+    const candidates = new Set<TokenId>([id, ...A]);
+    const issues = this.evaluate(candidates);
+    const patch: Record<TokenId, TokenValue> = { [id]: value };
+    return { affected: [...A], issues, patch };
+  }
+}

package/core/flatten.d.ts

@@ -0,0 +1,20 @@
+export type TokenId = string;
+export type TokenValue = string | number;
+export type TokenNode = {
+    $type?: string;
+    $value?: TokenValue;
+    [k: string]: TokenNode | string | number | undefined;
+};
+export type FlatToken = {
+    id: TokenId;
+    type: string;
+    value: TokenValue;
+    raw: TokenValue;
+    refs: TokenId[];
+};
+export type FlattenResult = {
+    flat: Record<TokenId, FlatToken>;
+    edges: Array<[from: TokenId, to: TokenId]>;
+};
+export declare function flattenTokens(root: TokenNode): FlattenResult;
+//# sourceMappingURL=flatten.d.ts.map

package/core/flatten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["flatten.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAC7B,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AACzC,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,UAAU,CAAC;IAChB,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACjC,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC;CAC5C,CAAC;AAIF,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,aAAa,CA4F5D"}

package/core/flatten.js

@@ -0,0 +1,80 @@
+const REF_RE = /\{([a-z0-9.-]+)\}/gi;
+export function flattenTokens(root) {
+    const flat = {};
+    const edges = [];
+    // First pass: collect all tokens
+    function walk(node, path = []) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (Object.prototype.hasOwnProperty.call(node, '$value')) {
+            const id = path.join('.');
+            const raw = node.$value;
+            if (raw === undefined)
+                return; // Skip tokens without values
+            const refs = [];
+            // Find all references in the value
+            if (typeof raw === 'string') {
+                const matches = raw.matchAll(REF_RE);
+                for (const match of matches) {
+                    refs.push(match[1]);
+                }
+            }
+            flat[id] = {
+                id,
+                type: String(node.$type ?? 'unknown'),
+                value: raw,
+                raw,
+                refs
+            };
+            // Add edges for dependencies
+            refs.forEach(refId => edges.push([refId, id]));
+            return;
+        }
+        // Recursively walk children
+        for (const key of Object.keys(node)) {
+            if (key.startsWith('$'))
+                continue;
+            const child = node[key];
+            if (typeof child === 'object' && child !== null) {
+                walk(child, path.concat(key));
+            }
+        }
+    }
+    walk(root);
+    // Second pass: resolve references iteratively
+    let changed = true;
+    let iterations = 0;
+    const maxIterations = Object.keys(flat).length * 2; // Safety limit
+    while (changed && iterations < maxIterations) {
+        changed = false;
+        iterations++;
+        for (const token of Object.values(flat)) {
+            if (typeof token.value === 'string' && token.value.includes('{')) {
+                let newValue = token.value;
+                let fullyResolved = true;
+                for (const refId of token.refs) {
+                    const refToken = flat[refId];
+                    if (!refToken) {
+                        throw new Error(`Could not resolve token ${refId}`);
+                    }
+                    // If the referenced token still has unresolved refs, skip this iteration
+                    if (typeof refToken.value === 'string' && refToken.value.includes('{')) {
+                        fullyResolved = false;
+                        break;
+                    }
+                    // Replace the reference with the resolved value
+                    const refPattern = new RegExp(`\\{${refId}\\}`, 'g');
+                    newValue = newValue.replace(refPattern, String(refToken.value));
+                }
+                if (fullyResolved && newValue !== token.value) {
+                    token.value = newValue;
+                    changed = true;
+                }
+            }
+        }
+    }
+    if (iterations >= maxIterations) {
+        throw new Error('Token resolution exceeded maximum iterations - possible circular reference');
+    }
+    return { flat, edges };
+}

package/core/flatten.ts

@@ -0,0 +1,116 @@
+export type TokenId = string; // e.g. "color.palette.brand.600"
+export type TokenValue = string | number;
+export type TokenNode = { 
+  $type?: string; 
+  $value?: TokenValue; 
+  [k: string]: TokenNode | string | number | undefined;
+};
+
+export type FlatToken = {
+  id: TokenId;
+  type: string;
+  value: TokenValue;       // resolved (if ref)
+  raw: TokenValue;         // original $value
+  refs: TokenId[];         // referenced token IDs found in raw
+};
+
+export type FlattenResult = {
+  flat: Record<TokenId, FlatToken>;
+  edges: Array<[from: TokenId, to: TokenId]>; // from ref -> to dependent
+};
+
+const REF_RE = /\{([a-z0-9.-]+)\}/gi;
+
+export function flattenTokens(root: TokenNode): FlattenResult {
+  const flat: Record<TokenId, FlatToken> = {};
+  const edges: Array<[TokenId, TokenId]> = [];
+
+  // First pass: collect all tokens
+  function walk(node: TokenNode, path: string[] = []) {
+    if (!node || typeof node !== 'object') return;
+    
+    if (Object.prototype.hasOwnProperty.call(node, '$value')) {
+      const id = path.join('.');
+      const raw = node.$value;
+      if (raw === undefined) return; // Skip tokens without values
+      
+      const refs: TokenId[] = [];
+      
+      // Find all references in the value
+      if (typeof raw === 'string') {
+        const matches = raw.matchAll(REF_RE);
+        for (const match of matches) {
+          refs.push(match[1]);
+        }
+      }
+      
+      flat[id] = { 
+        id, 
+        type: String(node.$type ?? 'unknown'), 
+        value: raw,
+        raw, 
+        refs 
+      };
+      
+      // Add edges for dependencies
+      refs.forEach(refId => edges.push([refId, id]));
+      return;
+    }
+    
+    // Recursively walk children
+    for (const key of Object.keys(node)) {
+      if (key.startsWith('$')) continue;
+      const child = node[key];
+      if (typeof child === 'object' && child !== null) {
+        walk(child as TokenNode, path.concat(key));
+      }
+    }
+  }
+
+  walk(root);
+
+  // Second pass: resolve references iteratively
+  let changed = true;
+  let iterations = 0;
+  const maxIterations = Object.keys(flat).length * 2; // Safety limit
+  
+  while (changed && iterations < maxIterations) {
+    changed = false;
+    iterations++;
+    
+    for (const token of Object.values(flat)) {
+      if (typeof token.value === 'string' && token.value.includes('{')) {
+        let newValue = token.value;
+        let fullyResolved = true;
+        
+        for (const refId of token.refs) {
+          const refToken = flat[refId];
+          if (!refToken) {
+            throw new Error(`Could not resolve token ${refId}`);
+          }
+          
+          // If the referenced token still has unresolved refs, skip this iteration
+          if (typeof refToken.value === 'string' && refToken.value.includes('{')) {
+            fullyResolved = false;
+            break;
+          }
+          
+          // Replace the reference with the resolved value
+          const refPattern = new RegExp(`\\{${refId}\\}`, 'g');
+          newValue = newValue.replace(refPattern, String(refToken.value));
+        }
+        
+        if (fullyResolved && newValue !== token.value) {
+          token.value = newValue;
+          changed = true;
+        }
+      }
+    }
+  }
+  
+  if (iterations >= maxIterations) {
+    throw new Error('Token resolution exceeded maximum iterations - possible circular reference');
+  }
+
+  return { flat, edges };
+}

package/core/image-export.d.ts

@@ -0,0 +1,10 @@
+export type ImageFmt = "svg" | "png";
+export type Renderer = "mermaid" | "dot";
+export declare function exportGraphImage(inputPath: string, // .mmd or .dot we just wrote
+outPath: string, // .svg or .png to write
+fmt: ImageFmt, // "svg" | "png"
+renderer: Renderer): {
+    ok: boolean;
+    hint?: string;
+};
+//# sourceMappingURL=image-export.d.ts.map

package/core/image-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-export.d.ts","sourceRoot":"","sources":["image-export.ts"],"names":[],"mappings":"AAmBA,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;AACrC,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,KAAK,CAAC;AAEzC,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EAAe,6BAA6B;AAC7D,OAAO,EAAE,MAAM,EAAiB,wBAAwB;AACxD,GAAG,EAAE,QAAQ,EAAmB,gBAAgB;AAChD,QAAQ,EAAE,QAAQ,GACjB;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAoBhC"}

package/core/image-export.js

@@ -0,0 +1,43 @@
+// core/image-export.ts
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+function which(cmd) {
+    const paths = (process.env.PATH || "").split(path.delimiter);
+    for (const p of paths) {
+        const full = path.join(p, cmd + (process.platform === "win32" ? ".cmd" : ""));
+        try {
+            fs.accessSync(full, fs.constants.X_OK);
+            return full;
+        }
+        catch {
+            // File not accessible, continue to next path
+        }
+    }
+    return null;
+}
+export function exportGraphImage(inputPath, // .mmd or .dot we just wrote
+outPath, // .svg or .png to write
+fmt, // "svg" | "png"
+renderer // "mermaid" | "dot"
+) {
+    if (renderer === "mermaid") {
+        const mmdc = which("mmdc");
+        if (!mmdc) {
+            return { ok: false, hint: "Install @mermaid-js/mermaid-cli (mmdc) to render images. Fallback written: .mmd" };
+        }
+        const args = ["-i", inputPath, "-o", outPath, "-t", "default", "-b", "transparent"];
+        if (fmt === "png")
+            args.push("-p", "puppeteer-config.json"); // optional, if you keep one
+        const res = spawnSync(mmdc, args, { stdio: "inherit" });
+        return { ok: res.status === 0, hint: res.status !== 0 ? "mmdc failed; see logs." : undefined };
+    }
+    // renderer === "dot"
+    const dot = which("dot");
+    if (!dot) {
+        return { ok: false, hint: "Install Graphviz (dot) to render images. Fallback written: .dot" };
+    }
+    const argFmt = fmt === "svg" ? "-Tsvg" : "-Tpng";
+    const res = spawnSync(dot, [argFmt, inputPath, "-o", outPath], { stdio: "inherit" });
+    return { ok: res.status === 0, hint: res.status !== 0 ? "dot failed; see logs." : undefined };
+}

package/core/image-export.ts

@@ -0,0 +1,48 @@
+// core/image-export.ts
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+function which(cmd: string): string | null {
+  const paths = (process.env.PATH || "").split(path.delimiter);
+  for (const p of paths) {
+    const full = path.join(p, cmd + (process.platform === "win32" ? ".cmd" : ""));
+    try { 
+      fs.accessSync(full, fs.constants.X_OK); 
+      return full; 
+    } catch {
+      // File not accessible, continue to next path
+    }
+  }
+  return null;
+}
+
+export type ImageFmt = "svg" | "png";
+export type Renderer = "mermaid" | "dot";
+
+export function exportGraphImage(
+  inputPath: string,              // .mmd or .dot we just wrote
+  outPath: string,                // .svg or .png to write
+  fmt: ImageFmt,                  // "svg" | "png"
+  renderer: Renderer              // "mermaid" | "dot"
+): { ok: boolean; hint?: string } {
+  if (renderer === "mermaid") {
+    const mmdc = which("mmdc");
+    if (!mmdc) {
+      return { ok: false, hint: "Install @mermaid-js/mermaid-cli (mmdc) to render images. Fallback written: .mmd" };
+    }
+    const args = ["-i", inputPath, "-o", outPath, "-t", "default", "-b", "transparent"];
+    if (fmt === "png") args.push("-p", "puppeteer-config.json"); // optional, if you keep one
+    const res = spawnSync(mmdc, args, { stdio: "inherit" });
+    return { ok: res.status === 0, hint: res.status !== 0 ? "mmdc failed; see logs." : undefined };
+  }
+
+  // renderer === "dot"
+  const dot = which("dot");
+  if (!dot) {
+    return { ok: false, hint: "Install Graphviz (dot) to render images. Fallback written: .dot" };
+  }
+  const argFmt = fmt === "svg" ? "-Tsvg" : "-Tpng";
+  const res = spawnSync(dot, [argFmt, inputPath, "-o", outPath], { stdio: "inherit" });
+  return { ok: res.status === 0, hint: res.status !== 0 ? "dot failed; see logs." : undefined };
+}

package/core/index.d.ts

@@ -0,0 +1,31 @@
+export type TokenId = string;
+export type TokenValue = string | number;
+export type Graph = Map<TokenId, Set<TokenId>>;
+export type ConstraintIssue = {
+    id: TokenId;
+    rule: string;
+    level: "error" | "warn";
+    message: string;
+};
+export type ConstraintPlugin = {
+    id: string;
+    evaluate(engine: Engine, candidates: Set<TokenId>): ConstraintIssue[];
+};
+export declare class Engine {
+    private values;
+    private graph;
+    private plugins;
+    constructor(initValues: Record<TokenId, TokenValue>, edges: Array<[TokenId, TokenId]>);
+    set(id: TokenId, value: TokenValue): void;
+    get(id: TokenId): TokenValue | undefined;
+    use(plugin: ConstraintPlugin): this;
+    affected(start: TokenId): Set<TokenId>;
+    evaluate(ids: Iterable<TokenId>): ConstraintIssue[];
+    /** Apply a single change and return a batch: affected set + issues + patch */
+    commit(id: TokenId, value: TokenValue): {
+        affected: string[];
+        issues: ConstraintIssue[];
+        patch: Record<string, TokenValue>;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAC7B,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AACzC,MAAM,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAE/C,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,eAAe,EAAE,CAAC;CACvE,CAAC;AAEF,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,OAAO,CAA0B;gBAE7B,UAAU,EAAE,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IASrF,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU;IAClC,GAAG,CAAC,EAAE,EAAE,OAAO;IAEf,GAAG,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAKnC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;IAYtC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,eAAe,EAAE;IAYnD,8EAA8E;IAC9E,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU;;;;;CAQtC"}