@fringetools/cli 0.0.0-stage → 0.1.0

package/dist/chunk-AOUZJDQL.js

@@ -0,0 +1,1353 @@
+// src/index.ts
+import { randomUUID } from "crypto";
+import { readFileSync as readFileSync8 } from "fs";
+import { resolve } from "path";
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/check.ts
+import { readFileSync as readFileSync5 } from "fs";
+
+// src/config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+var DEFAULT_CONFIG = {
+  ignore: ["node_modules/**", "dist/**", "build/**", "out/**", "coverage/**", ".fringe/**", "*.min.*"],
+  disable: [],
+  weights: { error: 10, review: 3, signal: 1 }
+};
+var TOKEN_SOURCE_KINDS = ["css-vars", "theme-factory", "design-tokens-json"];
+function loadConfig(root) {
+  try {
+    const raw = readFileSync(join(root, "fringe.config.json"), "utf8");
+    const user = JSON.parse(raw);
+    const cfg = {
+      ignore: Array.isArray(user.ignore) ? user.ignore : [...DEFAULT_CONFIG.ignore],
+      disable: Array.isArray(user.disable) ? user.disable : [...DEFAULT_CONFIG.disable],
+      weights: { ...DEFAULT_CONFIG.weights, ...user.weights ?? {} }
+    };
+    validateWeights(cfg.weights);
+    if (user.tokenSource !== void 0) {
+      cfg.tokenSource = validateTokenSource(user.tokenSource);
+    }
+    return cfg;
+  } catch (e) {
+    if (e.code === "ENOENT") return structuredClone(DEFAULT_CONFIG);
+    if (e instanceof SyntaxError) throw new Error("fringe.config.json: invalid JSON");
+    throw e;
+  }
+}
+function validateTokenSource(ts) {
+  let problem = null;
+  if (!ts || typeof ts !== "object" || !TOKEN_SOURCE_KINDS.includes(ts.kind)) {
+    problem = `tokenSource.kind must be one of: ${TOKEN_SOURCE_KINDS.join(", ")}`;
+  } else if (ts.kind === "design-tokens-json" && (typeof ts.path !== "string" || ts.path.trim() === "")) {
+    problem = "tokenSource.path is required when kind is design-tokens-json";
+  }
+  if (problem) throw new Error("fringe.config.json: " + problem);
+  return ts;
+}
+function validateWeights(weights) {
+  try {
+    for (const k of ["error", "review", "signal"]) {
+      if (typeof weights[k] !== "number" || Number.isNaN(weights[k]))
+        throw new Error(`weights.${k} must be a number`);
+    }
+  } catch (e) {
+    throw new Error("fringe.config.json: " + (e instanceof Error ? e.message : String(e)));
+  }
+}
+
+// src/detect.ts
+import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage"]);
+function findFile(dir, match, depth) {
+  if (depth > 6) return false;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const e of entries) {
+    if (e.name.startsWith(".") || SKIP_DIRS.has(e.name)) continue;
+    if (e.isDirectory()) {
+      if (findFile(join2(dir, e.name), match, depth + 1)) return true;
+    } else if (match(e.name)) return true;
+  }
+  return false;
+}
+function detectStack(root) {
+  let deps = {};
+  try {
+    const pkg = JSON.parse(readFileSync2(join2(root, "package.json"), "utf8"));
+    deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  } catch {
+  }
+  const has = (...names) => names.some((n) => deps[n]);
+  return {
+    jsx: has("react", "react-dom", "preact", "solid-js") || findFile(root, (n) => n.endsWith(".jsx") || n.endsWith(".tsx"), 0),
+    tailwind: has("tailwindcss"),
+    vue: has("vue", "nuxt"),
+    svelte: has("svelte"),
+    html: findFile(root, (n) => n.endsWith(".html"), 0)
+  };
+}
+
+// src/walk.ts
+import { readdirSync as readdirSync2 } from "fs";
+import { join as join3, relative } from "path";
+var EXTS = [".jsx", ".tsx", ".js", ".ts", ".html", ".css", ".vue", ".svelte", ".astro", ".scss"];
+function globToRegex(g) {
+  const esc2 = g.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*");
+  return new RegExp("^" + esc2 + "$");
+}
+function walk(root, cfg) {
+  const ignores = cfg.ignore.map(globToRegex);
+  const out = [];
+  const rec = (dir, depth) => {
+    if (depth > 12) return;
+    for (const e of readdirSync2(dir, { withFileTypes: true })) {
+      if (e.name.startsWith(".") || e.name === "node_modules") continue;
+      const p = join3(dir, e.name);
+      const rel = relative(root, p);
+      if (e.isDirectory()) rec(p, depth + 1);
+      else if (EXTS.some((x) => e.name.endsWith(x)) && !ignores.some((r) => r.test(rel))) out.push(p);
+    }
+  };
+  rec(root, 0);
+  return out;
+}
+
+// src/parse/jsx.ts
+import { parse } from "@babel/parser";
+function attrValue(v) {
+  if (v == null) return "true";
+  if (v.type === "StringLiteral") return v.value;
+  if (v.type === "JSXExpressionContainer" && v.expression?.type === "StringLiteral") return v.expression.value;
+  return "{\u2026}";
+}
+function collectText(node) {
+  let t = "";
+  for (const c of node.children ?? []) {
+    if (c.type === "JSXText") t += c.value;
+    else if (c.type === "JSXExpressionContainer" && c.expression?.type === "StringLiteral") t += c.expression.value;
+    else if (c.type === "JSXExpressionContainer" && c.expression?.type !== "JSXEmptyExpression") t += "{\u2026}";
+    else if (c.type === "JSXElement") t += collectText(c);
+  }
+  return t.trim();
+}
+function parseJsx(file, source) {
+  let ast;
+  try {
+    ast = parse(source, { sourceType: "unambiguous", plugins: ["jsx", "typescript"], errorRecovery: false });
+  } catch (e) {
+    throw new Error(`parse-skip: ${e.message}`);
+  }
+  const elems = [];
+  (function walkNode(node, parent) {
+    if (!node || typeof node.type !== "string") return;
+    let nextParent = parent;
+    if (node.type === "JSXElement") {
+      const nameNode = node.openingElement.name;
+      const tag2 = nameNode.type === "JSXIdentifier" ? nameNode.name : `${nameNode.object?.name ?? ""}.${nameNode.property?.name ?? ""}`;
+      const attrs = {};
+      for (const a of node.openingElement.attributes) {
+        if (a.type === "JSXAttribute") attrs[a.name.name] = attrValue(a.value);
+      }
+      const el = { tag: tag2, attrs, text: collectText(node), loc: { file, line: node.loc?.start.line ?? 0, col: node.loc?.start.column ?? 0 } };
+      if (parent) el.parentTag = parent.tag;
+      if (parent?.inLabel) el.inLabel = true;
+      if (parent?.attrs?.className !== void 0) el.parentClass = parent.attrs.className;
+      elems.push(el);
+      nextParent = { tag: tag2, attrs, inLabel: tag2 === "label" || parent?.inLabel };
+    }
+    for (const k of Object.keys(node)) {
+      const c = node[k];
+      if (Array.isArray(c)) c.forEach((x) => typeof x === "object" && x && typeof x.type === "string" && walkNode(x, nextParent));
+      else if (c && typeof c === "object" && typeof c.type === "string") walkNode(c, nextParent);
+    }
+  })(ast.program);
+  return elems;
+}
+
+// src/parse/html.ts
+import { parse as parse2 } from "parse5";
+var textOf = (n) => n.nodeName === "#text" ? n.value : (n.childNodes ?? []).map(textOf).join("");
+function parseHtml(file, source) {
+  const doc = parse2(source, { sourceCodeLocationInfo: true });
+  const elems = [];
+  (function walkNode(node, parent) {
+    if (node?.tagName) {
+      const attrs = {};
+      for (const a of node.attrs ?? []) attrs[a.name] = a.value;
+      const text = textOf(node).trim();
+      const el = { tag: node.tagName, attrs, text, loc: { file, line: node.sourceCodeLocation?.startLine ?? 0, col: node.sourceCodeLocation?.startCol ?? 0 } };
+      if (parent) el.parentTag = parent.tag;
+      if (parent?.inLabel) el.inLabel = true;
+      if (parent?.attrs?.class !== void 0) el.parentClass = parent.attrs.class;
+      elems.push(el);
+      for (const c of node.childNodes ?? []) walkNode(c, { tag: node.tagName, attrs, inLabel: node.tagName === "label" || parent?.inLabel });
+      return;
+    }
+    for (const c of node?.childNodes ?? []) walkNode(c, parent);
+  })(doc);
+  return elems;
+}
+
+// src/parse/css.ts
+import postcss from "postcss";
+function parseCss(file, source) {
+  const decls = [];
+  const rec = (node, selector) => {
+    for (const child of node.nodes ?? []) {
+      if (child.type === "decl") {
+        decls.push({ prop: child.prop, value: String(child.value), selector, loc: { file, line: child.source?.start?.line ?? 0, col: child.source?.start?.column ?? 0 } });
+      } else if (child.type === "rule" || child.type === "atrule") {
+        rec(child, child.type === "rule" ? child.selector : selector);
+      }
+    }
+  };
+  try {
+    rec(postcss.parse(source), "");
+  } catch (e) {
+    throw new Error(`parse-skip: ${e.message}`);
+  }
+  return decls;
+}
+
+// src/rules/fr201.ts
+var fr201 = {
+  id: "FR-201",
+  rung: 2,
+  severity: "error",
+  check: (ctx) => ctx.elems.filter((e) => e.tag === "img" && e.attrs.alt === void 0).map((e) => ({ rule: "FR-201", severity: "error", message: `<img> missing alt text`, hint: `add alt="description" (or alt="" if decorative)`, loc: e.loc, wcag: "1.1.1" }))
+};
+
+// src/rules/fr202.ts
+var NAME_ATTRS = ["aria-label", "aria-labelledby", "title"];
+var fr202 = {
+  id: "FR-202",
+  rung: 2,
+  severity: "error",
+  check: (ctx) => ctx.elems.filter((e) => ["button", "a"].includes(e.tag) && e.attrs["aria-hidden"] !== "true").filter((e) => !e.text && !NAME_ATTRS.some((a) => e.attrs[a])).map((e) => ({ rule: "FR-202", severity: "error", message: `<${e.tag}> has no accessible name`, hint: `add text content or aria-label`, loc: e.loc, wcag: "4.1.2" }))
+};
+
+// src/rules/fr203.ts
+var fr203 = {
+  id: "FR-203",
+  rung: 2,
+  severity: "error",
+  check: (ctx) => ctx.elems.filter((e) => e.tag === "input" && e.attrs.type !== "hidden" && !e.inLabel && e.attrs.hidden === void 0).filter((e) => {
+    const labeled = e.attrs["aria-label"] || e.attrs["aria-labelledby"] || e.attrs.id && new RegExp(`(htmlFor|for)=["'\`{]${e.attrs.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'\`}]`).test(ctx.source);
+    return !labeled;
+  }).map((e) => ({ rule: "FR-203", severity: "error", message: `input not associated with a label`, hint: `add id + <label htmlFor>, or aria-label`, loc: e.loc, wcag: "3.3.2" }))
+};
+
+// src/rules/fr204.ts
+var fr204 = {
+  id: "FR-204",
+  rung: 2,
+  severity: "error",
+  check: (ctx) => {
+    const out = [];
+    let prev = 0;
+    let seenH1 = false;
+    for (const e of ctx.elems.filter((el) => /^h[1-6]$/.test(el.tag))) {
+      const lvl = Number(e.tag[1]);
+      if (lvl === 1 && seenH1) out.push({ rule: "FR-204", severity: "error", message: `multiple <h1> in file`, hint: `use one h1 per page`, loc: e.loc, wcag: "1.3.1" });
+      if (lvl === 1) seenH1 = true;
+      if (prev && lvl > prev + 1) out.push({ rule: "FR-204", severity: "error", message: `heading skips from h${prev} to h${lvl}`, hint: `don't skip heading levels for visual size`, loc: e.loc, wcag: "1.3.1" });
+      if (!prev || lvl <= prev + 1) prev = lvl;
+    }
+    return out;
+  }
+};
+
+// src/rules/fr205.ts
+var fr205 = {
+  id: "FR-205",
+  rung: 2,
+  severity: "error",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (/\boutline-(none|0)\b/.test(cls) && !cls.includes("focus-visible:"))
+        out.push({ rule: "FR-205", severity: "error", message: `outline removed without focus-visible alternative`, hint: `add focus-visible:outline-* or a custom focus ring`, loc: e.loc, wcag: "2.4.7" });
+    }
+    for (const d of ctx.css) {
+      if (d.prop === "outline" && /^(none|0)/.test(d.value) && !d.selector.includes(":focus-visible") && !ctx.source.includes(":focus-visible"))
+        out.push({ rule: "FR-205", severity: "error", message: `outline: none without :focus-visible alternative`, hint: `add a :focus-visible rule with visible outline`, loc: d.loc, wcag: "2.4.7" });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr206.ts
+var fr206 = {
+  id: "FR-206",
+  rung: 2,
+  severity: "error",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems.filter((el) => ["div", "span"].includes(el.tag) && (el.attrs.onClick ?? el.attrs.onclick) !== void 0 && el.attrs.role === void 0 && (el.attrs.tabIndex ?? el.attrs.tabindex) === void 0)) {
+      out.push({ rule: "FR-206", severity: "error", message: `onClick on non-interactive <${e.tag}>`, hint: `use a <button>/<a> or add role and tabIndex`, loc: e.loc, wcag: "2.1.1" });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr207.ts
+var JSX_FORM = /tabIndex=\{\s*(\d+)\s*\}/g;
+var HTML_FORM = /tabindex=["']([1-9]\d*)["']/gi;
+var fr207 = {
+  id: "FR-207",
+  rung: 2,
+  severity: "error",
+  check: (ctx) => {
+    const out = [];
+    ctx.source.split("\n").forEach((line, i) => {
+      for (const m of line.matchAll(JSX_FORM)) {
+        if (Number(m[1]) > 0)
+          out.push({ rule: "FR-207", severity: "error", message: `tabIndex=${m[1]} > 0 disrupts natural tab order`, hint: `use tabIndex={0} and place in DOM order`, loc: { file: ctx.file, line: i + 1, col: m.index ?? 0 }, wcag: "2.4.3" });
+      }
+      for (const m of line.matchAll(HTML_FORM)) {
+        out.push({ rule: "FR-207", severity: "error", message: `tabIndex=${m[1]} > 0 disrupts natural tab order`, hint: `use tabIndex={0} and place in DOM order`, loc: { file: ctx.file, line: i + 1, col: m.index ?? 0 }, wcag: "2.4.3" });
+      }
+    });
+    return out;
+  }
+};
+
+// src/rules/fr208.ts
+var FETCH = /useQuery|useSWR|useMutation|useFetcher|useInfiniteQuery|\bfetch\(|axios|createResource|loader/i;
+var STATES = /isLoading|isPending|isError|isFetching|loading|empty|isEmpty|\berror\b|\bcatch\b|skeleton|spinner|fallback|onError|Suspense/i;
+var fr208 = {
+  id: "FR-208",
+  rung: 2,
+  severity: "review",
+  check: (ctx) => {
+    if (!FETCH.test(ctx.source) || STATES.test(ctx.source)) return [];
+    return [{ rule: "FR-208", severity: "review", message: `data is fetched but no loading/empty/error handling found`, hint: `render loading, empty, and error states \u2014 heuristic, verify by hand`, loc: { file: ctx.file, line: 1, col: 0 } }];
+  }
+};
+
+// src/rules/fr209.ts
+var VALID_ARIA = /* @__PURE__ */ new Set(["aria-label", "aria-labelledby", "aria-describedby", "aria-hidden", "aria-expanded", "aria-controls", "aria-current", "aria-live", "aria-disabled", "aria-invalid", "aria-required", "aria-selected", "aria-checked", "aria-valuenow", "aria-orientation", "aria-placeholder", "aria-pressed", "aria-roledescription", "aria-atomic", "aria-relevant", "aria-dropeffect", "aria-grabbed", "aria-level", "aria-multiline", "aria-multiselectable", "aria-readonly", "aria-sort", "aria-valuemax", "aria-valuemin", "aria-valuetext", "aria-busy", "aria-colcount", "aria-rowcount", "aria-details", "aria-errormessage", "aria-flowto", "aria-owns", "aria-posinset", "aria-setsize", "aria-modal", "aria-activedescendant", "aria-haspopup", "aria-autocomplete", "aria-keyshortcuts", "aria-colspan", "aria-colindex", "aria-rowspan", "aria-rowindex", "aria-description", "aria-braillelabel", "aria-brailleroledescription"]);
+var fr209 = {
+  id: "FR-209",
+  rung: 2,
+  severity: "error",
+  check: (ctx) => ctx.elems.flatMap((e) => Object.keys(e.attrs).filter((a) => a.startsWith("aria-") && !VALID_ARIA.has(a)).map((a) => ({ rule: "FR-209", severity: "error", message: `unknown aria attribute '${a}'`, hint: `check spelling against the ARIA spec`, loc: e.loc, wcag: "4.1.2" })))
+};
+
+// src/rules/fr210.ts
+var fr210 = {
+  id: "FR-210",
+  rung: 2,
+  severity: "review",
+  check: (ctx) => {
+    const out = [];
+    ctx.source.split("\n").forEach((line, i) => {
+      for (const m of line.matchAll(/(hurry|expires?|offer ends|ending soon)[^<>\n]{0,60}\d{1,2}:\d{2}/gi)) {
+        out.push({ rule: "FR-210", severity: "review", message: `urgency wording paired with a countdown ('${m[0]}') pressures rushed decisions`, hint: `avoid manufactured urgency \u2014 state the plain expiry instead of a ticking clock`, loc: { file: ctx.file, line: i + 1, col: m.index ?? 0 } });
+      }
+    });
+    return out;
+  }
+};
+
+// src/rules/fr211.ts
+var CHECKED_INPUT = /<input[^>]*type=["']checkbox["'][^>]*defaultChecked[^>]*>/;
+var CONSENT_ID = /id=["'][^"']*(?:consent|agree|terms|subscribe|opt[- ]?in)/i;
+var CONSENT_ANY = /consent|agree|terms|subscribe|opt[- ]?in/i;
+var fr211 = {
+  id: "FR-211",
+  rung: 2,
+  severity: "review",
+  check: (ctx) => {
+    const out = [];
+    ctx.source.split("\n").forEach((line, i) => {
+      const m = line.match(CHECKED_INPUT);
+      const hit = m ? CONSENT_ID.test(m[0]) || CONSENT_ANY.test(ctx.source) : /defaultChecked/.test(line) && CONSENT_ANY.test(ctx.source);
+      if (!hit) return;
+      const col = m?.index ?? Math.max(line.indexOf("defaultChecked"), 0);
+      out.push({ rule: "FR-211", severity: "review", message: `pre-checked checkbox near consent/agreement wording may trick users into opting in`, hint: `leave consent checkboxes unchecked by default`, loc: { file: ctx.file, line: i + 1, col } });
+    });
+    return out;
+  }
+};
+
+// src/rules/fr212.ts
+var fr212 = {
+  id: "FR-212",
+  rung: 2,
+  severity: "review",
+  check: (ctx) => {
+    const out = [];
+    ctx.source.split("\n").forEach((line, i) => {
+      for (const m of line.matchAll(/no thanks[^<>\n]{0,50}(hate|don'?t (want|like|need)|prefer paying|pay full|miss out)/gi)) {
+        out.push({ rule: "FR-212", severity: "review", message: `decline option shames the user ('${m[0]}')`, hint: `make declining a neutral choice \u2014 no guilt-tripping copy`, loc: { file: ctx.file, line: i + 1, col: m.index ?? 0 } });
+      }
+    });
+    return out;
+  }
+};
+
+// src/rules/fr213.ts
+var TRIGGER = /(infinite[- ]?scroll|load[- ]?more.{0,40}scroll|IntersectionObserver)/i;
+var OPT_OUT = /load more|loadMore|show more/i;
+var fr213 = {
+  id: "FR-213",
+  rung: 2,
+  severity: "review",
+  check: (ctx) => {
+    if (OPT_OUT.test(ctx.source)) return [];
+    const out = [];
+    ctx.source.split("\n").forEach((line, i) => {
+      const m = line.match(TRIGGER);
+      if (m && out.length === 0)
+        out.push({ rule: "FR-213", severity: "review", message: `infinite scroll with no visible 'load more'/'show more' opt-out`, hint: `offer pagination or an explicit load-more control so users can stop`, loc: { file: ctx.file, line: i + 1, col: m.index ?? 0 } });
+    });
+    return out;
+  }
+};
+
+// src/rules/fr214.ts
+var fr214 = {
+  id: "FR-214",
+  rung: 2,
+  severity: "review",
+  check: (ctx) => {
+    const out = [];
+    ctx.source.split("\n").forEach((line, i) => {
+      for (const m of line.matchAll(/(free|\$0)[^<>\n]{0,30}(then|after|later)[^<>\n]{0,30}\$\d+/gi)) {
+        out.push({ rule: "FR-214", severity: "review", message: `price framed as free but a cost follows ('${m[0]}')`, hint: `show the full price up front \u2014 drip pricing erodes trust`, loc: { file: ctx.file, line: i + 1, col: m.index ?? 0 } });
+      }
+    });
+    return out;
+  }
+};
+
+// src/rules/fr215.ts
+var ERROR_MARKER = /(isError|\berror\b|catch)/;
+var GENERIC_COPY = /something went wrong|an error occurred|oops|whoops/i;
+var RECOVERY = /(retry|try again|reload|contact support|support team)/i;
+var fr215 = {
+  id: "FR-215",
+  rung: 2,
+  severity: "review",
+  check: (ctx) => {
+    if (ERROR_MARKER.test(ctx.source) && GENERIC_COPY.test(ctx.source) && !RECOVERY.test(ctx.source)) {
+      return [{ rule: "FR-215", severity: "review", message: "generic error copy with no recovery action", hint: "tell users what failed and give them a next step (retry, link, contact)", loc: { file: ctx.file, line: 1, col: 0 } }];
+    }
+    return [];
+  }
+};
+
+// src/color.ts
+var clamp255 = (n) => Math.min(255, Math.max(0, Math.round(n)));
+function splitArgs(argStr) {
+  const [colorPart] = argStr.split("/");
+  const values = colorPart.trim().split(/[\s,]+/).filter(Boolean);
+  if (values.length < 3 || values.length > 4) return null;
+  return { values: values.slice(0, 3) };
+}
+function numericChannel(v) {
+  const m = v.match(/^([+-]?\d*\.?\d+)(%)?$/);
+  if (!m) return null;
+  const n = parseFloat(m[1]);
+  return m[2] ? n / 100 * 255 : n;
+}
+function hslChannel(v, isHue) {
+  const m = v.match(/^([+-]?\d*\.?\d+)(deg|%)?$/);
+  if (!m) return null;
+  const n = parseFloat(m[1]);
+  return isHue ? n : n / 100;
+}
+function hslToRgb(h, s, l) {
+  const hue = (h % 360 + 360) % 360;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+  const m = l - c / 2;
+  const [r1, g1, b1] = hue < 60 ? [c, x, 0] : hue < 120 ? [x, c, 0] : hue < 180 ? [0, c, x] : hue < 240 ? [0, x, c] : hue < 300 ? [x, 0, c] : [c, 0, x];
+  return { r: clamp255((r1 + m) * 255), g: clamp255((g1 + m) * 255), b: clamp255((b1 + m) * 255) };
+}
+function parseColor(input) {
+  const s = input.trim().toLowerCase();
+  if (!s) return null;
+  if (/^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(s)) {
+    const hex = s.slice(1);
+    if (hex.length === 3) {
+      return {
+        r: parseInt(hex[0] + hex[0], 16),
+        g: parseInt(hex[1] + hex[1], 16),
+        b: parseInt(hex[2] + hex[2], 16)
+      };
+    }
+    return { r: parseInt(hex.slice(0, 2), 16), g: parseInt(hex.slice(2, 4), 16), b: parseInt(hex.slice(4, 6), 16) };
+  }
+  const rgb = s.match(/^rgba?\(([^)]*)\)$/);
+  if (rgb) {
+    const args = splitArgs(rgb[1]);
+    if (!args) return null;
+    const nums = args.values.map(numericChannel);
+    if (nums.some((n) => n === null)) return null;
+    const [r, g, b] = nums;
+    return { r: clamp255(r), g: clamp255(g), b: clamp255(b) };
+  }
+  const hsl = s.match(/^hsla?\(([^)]*)\)$/);
+  if (hsl) {
+    const args = splitArgs(hsl[1]);
+    if (!args) return null;
+    const hue = hslChannel(args.values[0], true);
+    const sat = hslChannel(args.values[1], false);
+    const lig = hslChannel(args.values[2], false);
+    if (hue === null || sat === null || lig === null) return null;
+    return hslToRgb(hue, Math.min(1, Math.max(0, sat)), Math.min(1, Math.max(0, lig)));
+  }
+  return null;
+}
+function relativeLuminance({ r, g, b }) {
+  const lin = (c) => {
+    const x = c / 255;
+    return x <= 0.03928 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
+  };
+  return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  const [l1, l2] = la >= lb ? [la, lb] : [lb, la];
+  return (l1 + 0.05) / (l2 + 0.05);
+}
+
+// src/rules/fr301.ts
+var ARBITRARY_TW = /\b(?:bg|text|border|from|to|via|ring|fill|stroke)-\[#[0-9a-fA-F]{3,8}\]/g;
+var PALETTE_TW = /\b(?:bg|text|border|from|to|via|ring|fill|stroke)-(?:slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d{2,3}\b/g;
+var COLOR_PROP = /color|^background$|border/;
+var count = (source, re) => (source.match(re) ?? []).length;
+var fr301 = {
+  id: "FR-301",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const hardcoded = count(ctx.source, ARBITRARY_TW) + ctx.css.filter((d) => !d.prop.startsWith("--") && COLOR_PROP.test(d.prop) && parseColor(d.value) !== null).length;
+    const tokenUses = count(ctx.source, /var\(--/g) + count(ctx.source, PALETTE_TW);
+    if (!(hardcoded > 3 && hardcoded > tokenUses)) return [];
+    return [{
+      rule: "FR-301",
+      severity: "signal",
+      message: `${hardcoded} hardcoded colors vs ${tokenUses} token uses in this file`,
+      hint: `use design tokens / Tailwind palette instead of raw hex (tokenSource: ${ctx.tokenColors.length} colors found)`,
+      loc: { file: ctx.file, line: 1, col: 0 }
+    }];
+  }
+};
+
+// src/rules/fr302.ts
+var ARBITRARY_SIZE = /\btext-\[(?!#|color:)[^\]]+\]/g;
+var fr302 = {
+  id: "FR-302",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      for (const m of cls.matchAll(ARBITRARY_SIZE))
+        out.push({
+          rule: "FR-302",
+          severity: "signal",
+          message: `font size off the type scale: ${m[0]}`,
+          hint: `use the type scale (text-xs..text-6xl) or extend the theme`,
+          loc: e.loc
+        });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr303.ts
+var ARBITRARY_SPACE = /\b(?:p|m|px|py|pt|pb|pl|pr|mt|mb|ml|mr|mx|my|gap|w|h)-\[[^\]]+\]/g;
+var fr303 = {
+  id: "FR-303",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      for (const m of cls.matchAll(ARBITRARY_SPACE))
+        out.push({
+          rule: "FR-303",
+          severity: "signal",
+          message: `spacing/dimension off the scale: ${m[0]}`,
+          hint: `use spacing scale utilities (1 unit = 0.25rem) or extend the theme`,
+          loc: e.loc
+        });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr304.ts
+function translucent(raw) {
+  const s = raw.trim().toLowerCase();
+  if (/^#[0-9a-f]{8}$/.test(s)) return parseInt(s.slice(7, 9), 16) < 255;
+  const fn = s.match(/^(?:rgba?|hsla?)\(([^)]*)\)$/);
+  if (!fn) return false;
+  const [colorPart, slashAlpha] = fn[1].split("/");
+  const alpha = slashAlpha !== void 0 ? slashAlpha.trim() : colorPart.trim().split(/[\s,]+/).filter(Boolean)[3];
+  if (alpha === void 0) return false;
+  const m = alpha.match(/^([+-]?\d*\.?\d+)(%)?$/);
+  if (!m) return false;
+  const n = parseFloat(m[1]);
+  return (m[2] ? n / 100 : n) < 1;
+}
+var fr304 = {
+  id: "FR-304",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    const bySelector = /* @__PURE__ */ new Map();
+    for (const d of ctx.css) {
+      const group = bySelector.get(d.selector) ?? [];
+      group.push(d);
+      bySelector.set(d.selector, group);
+    }
+    for (const [selector, decls] of bySelector) {
+      if (!selector) continue;
+      const last = (prop) => {
+        const matches = decls.filter((d) => d.prop === prop);
+        return matches[matches.length - 1];
+      };
+      const colorDecl = last("color");
+      const bgDecl = last("background-color") ?? decls.filter((d) => d.prop === "background" && parseColor(d.value) !== null).pop();
+      if (!colorDecl || !bgDecl) continue;
+      if (translucent(colorDecl.value) || translucent(bgDecl.value)) continue;
+      const fg = parseColor(colorDecl.value);
+      const bg = parseColor(bgDecl.value);
+      if (!fg || !bg) continue;
+      const ratio = contrastRatio(fg, bg);
+      if (ratio < 4.5)
+        out.push({
+          rule: "FR-304",
+          severity: "signal",
+          message: `contrast ${colorDecl.value.trim()} on ${bgDecl.value.trim()} is ${ratio.toFixed(1)}:1 (< 4.5:1)`,
+          hint: `darken the text or lighten the background to reach AA 4.5:1`,
+          loc: colorDecl.loc,
+          wcag: "1.4.3"
+        });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr305.ts
+var TINY_TEXT = /\btext-xs\b/;
+var ADEQUATE_PADDING = /(?:^|\s)(?:p|py)-([2-9]|10)\b/;
+var fr305 = {
+  id: "FR-305",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      if (e.tag !== "button" && e.tag !== "a") continue;
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (!TINY_TEXT.test(cls) || ADEQUATE_PADDING.test(cls)) continue;
+      out.push({
+        rule: "FR-305",
+        severity: "signal",
+        message: `tiny hit area: text-xs interactive element without adequate padding`,
+        hint: `add py-2+ padding or a larger text size (WCAG 2.5.8 target size)`,
+        loc: e.loc,
+        wcag: "2.5.8"
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr361.ts
+var ITALIC = /\bitalic\b/;
+var SERIF = /\b(?:font-)?serif\b/;
+var DISPLAY_SIZE = /\btext-(?:3xl|4xl|5xl|6xl)\b/;
+var fr361 = {
+  id: "FR-361",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (!ITALIC.test(cls) || !SERIF.test(cls) || !DISPLAY_SIZE.test(cls)) continue;
+      out.push({
+        rule: "FR-361",
+        severity: "signal",
+        message: `italic serif display type \u2014 the AI-tell headline`,
+        hint: `choose a display treatment that isn't italic serif`,
+        loc: e.loc
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr362.ts
+var UPPERCASE = /\buppercase\b/;
+var TRACKING = /\btracking-(?:widest|wider)\b/;
+var PILL = /\brounded-full\b/;
+var MAX_TEXT_LENGTH = 40;
+var fr362 = {
+  id: "FR-362",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (!UPPERCASE.test(cls) || !TRACKING.test(cls) || !PILL.test(cls)) continue;
+      if (e.text.trim().length > MAX_TEXT_LENGTH) continue;
+      out.push({
+        rule: "FR-362",
+        severity: "signal",
+        message: `hero eyebrow chip`,
+        hint: `eyebrow chips above headings are a template tell; integrate context into the heading`,
+        loc: e.loc
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr363.ts
+var CARD_ROUNDING = /rounded-(lg|xl|2xl)/;
+var BORDER_TOKEN = /(?:^|\s)border/;
+var SURFACE = /shadow-|bg-/;
+var cardish = (cls) => CARD_ROUNDING.test(cls) && (BORDER_TOKEN.test(cls) || SURFACE.test(cls));
+var fr363 = {
+  id: "FR-363",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (!cardish(cls) || !e.parentClass || !cardish(e.parentClass)) continue;
+      out.push({
+        rule: "FR-363",
+        severity: "signal",
+        message: `card inside a card`,
+        hint: `one containment level: let whitespace, not boxes, group content`,
+        loc: e.loc
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr364.ts
+var TILE_ROUNDING = /rounded-(lg|xl|2xl)/;
+var isTile = (cls, text) => TILE_ROUNDING.test(cls) && /bg-/.test(cls) && /flex/.test(cls) && text === "";
+var fr364 = {
+  id: "FR-364",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    let n = 0;
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (isTile(cls, e.text)) n++;
+    }
+    if (n < 3) return [];
+    return [{
+      rule: "FR-364",
+      severity: "signal",
+      message: `icon-tile stack (${n} tiles)`,
+      hint: `rows of icon tiles with verb labels are a landing-page tell`,
+      loc: { file: ctx.file, line: 1, col: 0 }
+    }];
+  }
+};
+
+// src/rules/fr366.ts
+var PILL2 = /rounded-full/;
+var CHIP_SIZE = /(?:px-2|px-2\.5|text-xs)/;
+var isChip = (cls, text) => PILL2.test(cls) && CHIP_SIZE.test(cls) && text !== "";
+var fr366 = {
+  id: "FR-366",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    let n = 0;
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (isChip(cls, e.text)) n++;
+    }
+    if (n < 5) return [];
+    return [{
+      rule: "FR-366",
+      severity: "signal",
+      message: `status-chip soup (${n} chips)`,
+      hint: `chips everywhere dilute meaning; reserve them for state`,
+      loc: { file: ctx.file, line: 1, col: 0 }
+    }];
+  }
+};
+
+// src/rules/fr365.ts
+var THIN_BORDER = /(?:^|\s)border(?!-0\b)(?:-[1-9])?\b/;
+var WIDE_SHADOW = /\bshadow-(?:xl|2xl)\b/;
+var fr365 = {
+  id: "FR-365",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (!THIN_BORDER.test(cls) || !WIDE_SHADOW.test(cls)) continue;
+      out.push({
+        rule: "FR-365",
+        severity: "signal",
+        message: `thin border with wide shadow`,
+        hint: `pair elevation with weight: heavier border or tighter shadow`,
+        loc: e.loc
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr367.ts
+var SMALL_TEXT = /\btext-(?:xs|sm)\b/;
+var NUMBERED_LABEL = /^\d{1,2}\s+\S+/;
+var fr367 = {
+  id: "FR-367",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (!SMALL_TEXT.test(cls) || !NUMBERED_LABEL.test(e.text)) continue;
+      out.push({
+        rule: "FR-367",
+        severity: "signal",
+        message: `numbered section label ("01 Discover" style)`,
+        hint: `let hierarchy come from typography, not index numbers`,
+        loc: e.loc
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr368.ts
+var GRADIENT_UTILITY = /\bbg-gradient-to-\w+/;
+var PURPLE_STOP = /\bfrom-(?:violet|purple|indigo|fuchsia)-\d{3,4}\b/;
+var PURPLE_HEX = /#(?:8b5cf6|a78bfa|7c3aed|818cf8|6366f1|9333ea|c084fc)/i;
+var BACKGROUND_PROP = /^background(?:-image)?$/;
+var fr368 = {
+  id: "FR-368",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      const cls = e.attrs.className ?? e.attrs.class ?? "";
+      if (!GRADIENT_UTILITY.test(cls) || !PURPLE_STOP.test(cls)) continue;
+      out.push({
+        rule: "FR-368",
+        severity: "signal",
+        message: `the purple AI gradient`,
+        hint: `pick a palette that isn't the LLM default`,
+        loc: e.loc
+      });
+    }
+    for (const d of ctx.css) {
+      if (!BACKGROUND_PROP.test(d.prop) || !/linear-gradient/i.test(d.value) || !PURPLE_HEX.test(d.value)) continue;
+      out.push({
+        rule: "FR-368",
+        severity: "signal",
+        message: `the purple AI gradient`,
+        hint: `pick a palette that isn't the LLM default`,
+        loc: d.loc
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/fr369.ts
+var HEADING = /^h[1-6]$/;
+var EMOJI = /\p{Extended_Pictographic}/u;
+var fr369 = {
+  id: "FR-369",
+  rung: 3,
+  severity: "signal",
+  check: (ctx) => {
+    const out = [];
+    for (const e of ctx.elems) {
+      if (!HEADING.test(e.tag) || !EMOJI.test(e.text)) continue;
+      out.push({
+        rule: "FR-369",
+        severity: "signal",
+        message: `emoji in heading`,
+        hint: `emoji in headings read as template output; use typography instead`,
+        loc: e.loc
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/registry.ts
+var ALL_RULES = [];
+ALL_RULES.push(fr201, fr202, fr203, fr204, fr205, fr206, fr207, fr208, fr209, fr210, fr211, fr212, fr213, fr214, fr215, fr301, fr302, fr303, fr304, fr305, fr361, fr362, fr363, fr364, fr366, fr365, fr367, fr368, fr369);
+function activeRules(cfg) {
+  return ALL_RULES.filter((r) => !cfg.disable.includes(r.id));
+}
+
+// src/score.ts
+var BASELINE_FILES = 10;
+var KNEE = 75;
+function score(counts, weights, files = BASELINE_FILES) {
+  const raw = counts.error * weights.error + counts.review * weights.review + counts.signal * weights.signal;
+  const penalty = raw * BASELINE_FILES / Math.max(files, BASELINE_FILES);
+  return Math.round(penalty <= KNEE ? 100 - penalty : (100 - KNEE) * KNEE / penalty);
+}
+
+// src/tokens.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { isAbsolute, join as join4 } from "path";
+var CSS_VAR_RE = /--[\w-]+\s*:\s*([^;}]+)/g;
+function gatherTokenColors(root, cfg, cssSources) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (raw) => {
+    const value = raw.trim();
+    if (!value || seen.has(value) || parseColor(value) === null) return;
+    seen.add(value);
+    out.push(value);
+  };
+  const kind = cfg.tokenSource?.kind;
+  if (kind === "design-tokens-json") {
+    const rel = cfg.tokenSource?.path ?? "";
+    const file = isAbsolute(rel) ? rel : join4(root, rel);
+    let json;
+    try {
+      json = JSON.parse(readFileSync3(file, "utf8"));
+    } catch {
+      return out;
+    }
+    collectJsonColors(json, add);
+    return out;
+  }
+  if (kind !== "css-vars" && kind !== "theme-factory") return out;
+  for (const { source } of cssSources) {
+    for (const m of source.matchAll(CSS_VAR_RE)) add(m[1]);
+  }
+  return out;
+}
+function collectJsonColors(node, add) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) collectJsonColors(item, add);
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "$value" && typeof value === "string") add(value);
+    else collectJsonColors(value, add);
+  }
+}
+
+// src/baseline.ts
+import { existsSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { join as join5, relative as relative2 } from "path";
+var path = (root) => join5(root, "fringe.baseline.json");
+var keyOf = (root, f) => `${f.rule}|${relative2(root, f.loc.file)}|${f.message}`;
+function writeBaseline(root, findings) {
+  writeFileSync(path(root), JSON.stringify(findings.map((f) => keyOf(root, f)).sort(), null, 2) + "\n");
+}
+function applyBaseline(root, findings) {
+  if (!existsSync(path(root))) return { fresh: findings, known: 0 };
+  let keys;
+  try {
+    keys = JSON.parse(readFileSync4(path(root), "utf8"));
+    if (!Array.isArray(keys)) throw 0;
+  } catch {
+    throw new Error("fringe.baseline.json is not a JSON array \u2014 rerun with --update-baseline");
+  }
+  const left = /* @__PURE__ */ new Map();
+  for (const k of keys) left.set(k, (left.get(k) ?? 0) + 1);
+  const fresh = findings.filter((f) => {
+    const k = keyOf(root, f), n = left.get(k) ?? 0;
+    if (n > 0) {
+      left.set(k, n - 1);
+      return false;
+    }
+    return true;
+  });
+  return { fresh, known: findings.length - fresh.length };
+}
+
+// src/suppress.ts
+var MARK = /fringe-ignore\s+((?:FR-\d+[\s,]*)+)/;
+function suppressedIds(lines, line) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const l of [lines[line - 1], lines[line - 2]]) {
+    const m = l && MARK.exec(l);
+    if (m) for (const id of m[1].match(/FR-\d+/g) ?? []) ids.add(id);
+  }
+  return ids;
+}
+
+// src/check.ts
+async function runCheck(root, cfg = loadConfig(root), useBaseline = true) {
+  const stack = detectStack(root);
+  const files = walk(root, cfg);
+  const rules = activeRules(cfg);
+  const findings = [];
+  const skipped = [];
+  const cssSources = [];
+  const contexts = [];
+  for (const file of files) {
+    let source = "";
+    try {
+      source = readFileSync5(file, "utf8");
+    } catch {
+      skipped.push(file);
+      continue;
+    }
+    const ctx = { file, source, elems: [], css: [], tokenColors: [] };
+    try {
+      if (/\.(jsx|tsx|js|ts)$/.test(file)) ctx.elems = parseJsx(file, source);
+      else if (/\.html$/.test(file)) ctx.elems = parseHtml(file, source);
+      else if (/\.(css|scss)$/.test(file)) {
+        ctx.css = parseCss(file, source);
+        cssSources.push({ file, source });
+      }
+    } catch (e) {
+      if (e.message.startsWith("parse-skip")) {
+        skipped.push(file);
+        continue;
+      }
+      throw e;
+    }
+    contexts.push(ctx);
+  }
+  const tokenColors = gatherTokenColors(root, cfg, cssSources);
+  for (const ctx of contexts) ctx.tokenColors = tokenColors;
+  for (const ctx of contexts) {
+    for (const rule of rules) findings.push(...rule.check(ctx));
+  }
+  const lines = new Map(contexts.map((c) => [c.file, c.source.split("\n")]));
+  const live = findings.filter((f) => !suppressedIds(lines.get(f.loc.file) ?? [], f.loc.line).has(f.rule));
+  const suppressed = findings.length - live.length;
+  const { fresh, known } = useBaseline ? applyBaseline(root, live) : { fresh: live, known: 0 };
+  const counts = { error: 0, review: 0, signal: 0 };
+  for (const f of fresh) counts[f.severity]++;
+  return { stack, files: files.length, skipped, findings: fresh, counts, score: score(counts, cfg.weights, files.length), ...known ? { baselined: known } : {}, ...suppressed ? { suppressed } : {} };
+}
+
+// src/report/json.ts
+function toJson(r) {
+  return JSON.stringify({ schema: "fringe/check.v1", ...r }, null, 2);
+}
+
+// src/report/hook.ts
+import { relative as relative3 } from "path";
+var RANK = { error: 0, review: 1, signal: 2 };
+function topFinding(r) {
+  return [...r.findings].sort((a, b) => {
+    if (RANK[a.severity] !== RANK[b.severity]) return RANK[a.severity] - RANK[b.severity];
+    if (a.loc.file !== b.loc.file) return a.loc.file < b.loc.file ? -1 : 1;
+    return a.loc.line - b.loc.line;
+  })[0];
+}
+function toHook(r) {
+  const top = topFinding(r);
+  const reason = top ? `${top.rule}: ${top.message} (${top.loc.file}:${top.loc.line})` : "no findings";
+  return JSON.stringify({
+    schema: "fringe/hook.v1",
+    errors: r.counts.error,
+    review: r.counts.review,
+    signals: r.counts.signal,
+    block: r.counts.error > 0,
+    reason
+  });
+}
+function toClaudeHook(r, root) {
+  const errs = r.findings.filter((f) => f.severity === "error");
+  if (errs.length === 0) return "";
+  const shown = errs.slice(0, 8).map((f) => `- ${f.rule} ${relative3(root, f.loc.file)}:${f.loc.line} \u2014 ${f.message} (${f.hint})`);
+  const more = errs.length > shown.length ? `
+\u2026and ${errs.length - shown.length} more (run \`fringe check\`).` : "";
+  return JSON.stringify({
+    decision: "block",
+    reason: `Fringe found ${errs.length} accessibility error(s). Fix them before finishing:
+${shown.join("\n")}${more}
+Use a fringe-ignore comment only for a genuine false positive, and say so.`
+  });
+}
+
+// src/report/pretty.ts
+var RANK2 = { error: 0, review: 1, signal: 2 };
+function tag(s) {
+  return `[${s.toUpperCase()}]`;
+}
+function stackList(stack) {
+  const keys = Object.keys(stack);
+  const on = keys.filter((k) => stack[k]);
+  return on.length > 0 ? on.join(",") : "none";
+}
+function toPretty(r) {
+  const lines = [
+    `fringe \xB7 stack ${stackList(r.stack)} \xB7 ${r.files} files` + (r.skipped.length > 0 ? ` \xB7 ${r.skipped.length} skipped` : "")
+  ];
+  const sorted = [...r.findings].sort((a, b) => {
+    if (RANK2[a.severity] !== RANK2[b.severity]) return RANK2[a.severity] - RANK2[b.severity];
+    if (a.loc.file !== b.loc.file) return a.loc.file < b.loc.file ? -1 : 1;
+    return a.loc.line - b.loc.line;
+  });
+  for (const f of sorted) {
+    lines.push(`${tag(f.severity)} ${f.rule} ${f.loc.file}:${f.loc.line} \u2014 ${f.message} (${f.hint})`);
+  }
+  lines.push(
+    `health ${r.score}/100 \xB7 ${r.counts.error} errors \xB7 ${r.counts.review} review \xB7 ${r.counts.signal} signals` + (r.baselined ? ` \xB7 ${r.baselined} baselined` : "") + (r.suppressed ? ` \xB7 ${r.suppressed} suppressed` : "")
+  );
+  if (r.skipped.length > 0) {
+    lines.push(
+      `legend ${tag("error")} must fix \xB7 ${tag("review")} needs judgment \xB7 ${tag("signal")} info \xB7 skipped: ${r.skipped.join(", ")}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/ledger.ts
+import { appendFileSync, mkdirSync, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+function ledgerPath(root) {
+  return join6(root, ".fringe", "ledger.jsonl");
+}
+function appendRecord(root, rec) {
+  mkdirSync(join6(root, ".fringe"), { recursive: true });
+  appendFileSync(ledgerPath(root), JSON.stringify(rec) + "\n");
+}
+function readLedger(root) {
+  let raw;
+  try {
+    raw = readFileSync6(ledgerPath(root), "utf8");
+  } catch {
+    return { records: [], corrupt: 0 };
+  }
+  const records = [];
+  let corrupt = 0;
+  for (const line of raw.split("\n")) {
+    if (line.trim() === "") continue;
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      corrupt++;
+    }
+  }
+  return { records, corrupt };
+}
+
+// src/board.ts
+import { createServer } from "http";
+var esc = (s) => s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+function renderBoard(records, corrupt = 0) {
+  const rows = [...records].reverse().map((r) => {
+    const flows = (r.manifest?.flows ?? []).map((f) => `<li>${esc(f.action)}: ${esc(f.what)} <small>(${esc(f.evidence)}) \u2014 judged</small></li>`).join("");
+    return `<tr><td>${esc(r.ts)}</td><td>${r.score}</td><td>${r.counts.error}</td><td>${r.counts.review}</td><td>${r.counts.signal}</td><td>${r.files}</td><td>${r.suppressed ?? 0}</td><td>${flows ? `<ul>${flows}</ul>` : ""}</td></tr>`;
+  }).join("");
+  const body = records.length === 0 ? "<p>No runs yet. Run <code>fringe check --record</code> and reload.</p>" : `<table><tr><th>When</th><th>Health</th><th>Errors</th><th>Review</th><th>Signals</th><th>Files</th><th>Suppressed</th><th>Flow cuts</th></tr>${rows}</table>`;
+  const warn = corrupt ? `<p>${corrupt} unreadable ledger line(s) skipped.</p>` : "";
+  return `<!doctype html><html lang="en"><meta charset="utf-8"><title>Fringe ledger</title><style>body{font:16px system-ui;margin:2rem;max-width:70rem}td,th{padding:.4rem .8rem;text-align:left;vertical-align:top}</style><h1>Fringe ledger</h1>${warn}${body}</html>`;
+}
+function startBoard(root, port) {
+  const server = createServer((_req, res) => {
+    const { records, corrupt } = readLedger(root);
+    res.setHeader("content-type", "text/html; charset=utf-8");
+    res.end(renderBoard(records, corrupt));
+  });
+  return new Promise((ok, fail) => {
+    server.once("error", fail);
+    server.listen(port, "127.0.0.1", () => ok(server));
+  });
+}
+
+// src/init.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2, copyFileSync } from "fs";
+import { dirname, join as join7 } from "path";
+import { fileURLToPath } from "url";
+var HOOK = "npx -y @fringetools/cli check --claude-hook";
+var SKILL = fileURLToPath(new URL("../skill/SKILL.md", import.meta.url));
+function initProject(root) {
+  const done = [];
+  const settingsPath = join7(root, ".claude", "settings.json");
+  let settings = {};
+  if (existsSync2(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync7(settingsPath, "utf8"));
+    } catch {
+      throw new Error(`${settingsPath} is not valid JSON \u2014 fix it and rerun`);
+    }
+  }
+  const post = (settings.hooks ??= {}).PostToolUse ??= [];
+  if (/(fringe|@fringetools\/cli) check/.test(JSON.stringify(post))) done.push("hook already present");
+  else {
+    post.push({ matcher: "Edit|Write", hooks: [{ type: "command", command: HOOK }] });
+    mkdirSync2(dirname(settingsPath), { recursive: true });
+    writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    done.push(`hook added to ${settingsPath}`);
+  }
+  const skillPath = join7(root, ".claude", "skills", "fringe", "SKILL.md");
+  if (existsSync2(skillPath)) done.push("skill already present");
+  else {
+    mkdirSync2(dirname(skillPath), { recursive: true });
+    copyFileSync(SKILL, skillPath);
+    done.push(`skill installed at ${skillPath}`);
+  }
+  return done;
+}
+
+// src/index.ts
+var log = (o) => o.log ?? ((s) => console.log(s));
+var err = (o) => o.err ?? ((s) => process.stderr.write(s));
+function readManifest(path2, warn) {
+  let raw;
+  try {
+    raw = readFileSync8(path2, "utf8");
+  } catch {
+    warn(`fringe: warning: manifest not found at ${path2} \u2014 continuing without
+`);
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.flows)) throw new Error("missing flows");
+    return parsed;
+  } catch {
+    warn(`fringe: warning: manifest at ${path2} is not valid '{ flows: [...] }' JSON \u2014 continuing without
+`);
+    return void 0;
+  }
+}
+var HELP = `fringe check [--json] [--hook] [--record] [--manifest <path>] [path]
+fringe check --claude-hook [path]       for Claude Code hooks (feeds errors back to the agent)
+fringe check --update-baseline [path]   accept today's findings; only new ones gate
+fringe init [path]                       add the Claude Code hook + skill
+fringe open [path] [--port <n>]   serve the .fringe ledger on 127.0.0.1
+fringe --help | --version`;
+var KNOWN_FLAGS = /* @__PURE__ */ new Set(["--json", "--hook", "--claude-hook", "--record", "--manifest", "--update-baseline"]);
+function parseArgs(rest, warn) {
+  const paths = [];
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--manifest") {
+      i++;
+      continue;
+    }
+    if (a.startsWith("--")) {
+      if (!KNOWN_FLAGS.has(a)) warn(`fringe: warning: unknown flag '${a}' \u2014 ignored
+`);
+      continue;
+    }
+    paths.push(a);
+  }
+  return paths;
+}
+async function runCli(argv, opts = {}) {
+  const [cmd, ...rest] = argv;
+  if (cmd === "--version" || cmd === "-v") {
+    log(opts)(VERSION);
+    return 0;
+  }
+  if (cmd === "check") {
+    try {
+      const paths = parseArgs(rest, err(opts));
+      const cwd = opts.cwd ?? process.cwd();
+      const root = paths.length > 0 ? resolve(cwd, paths[0]) : cwd;
+      const cfg = loadConfig(root);
+      if (rest.includes("--update-baseline")) {
+        const all = await runCheck(root, cfg, false);
+        writeBaseline(root, all.findings);
+        log(opts)(`fringe: baseline written \u2014 ${all.findings.length} known findings in fringe.baseline.json (commit it); only new ones gate from now on`);
+        return 0;
+      }
+      const result = await runCheck(root, cfg);
+      if (rest.includes("--claude-hook")) {
+        const out = toClaudeHook(result, root);
+        if (out) log(opts)(out);
+        return 0;
+      }
+      if (rest.includes("--hook")) log(opts)(toHook(result));
+      else if (rest.includes("--json")) log(opts)(toJson(result));
+      else log(opts)(toPretty(result));
+      if (rest.includes("--record")) {
+        const rec = {
+          id: randomUUID(),
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          stack: result.stack,
+          files: result.files,
+          counts: result.counts,
+          score: result.score,
+          byRule: result.findings.reduce((m, f) => (m[f.rule] = (m[f.rule] ?? 0) + 1, m), {}),
+          suppressed: result.suppressed,
+          tokenSource: cfg.tokenSource?.kind
+        };
+        const mIdx = rest.indexOf("--manifest");
+        if (mIdx !== -1 && rest[mIdx + 1] !== void 0) rec.manifest = readManifest(rest[mIdx + 1], err(opts));
+        appendRecord(root, rec);
+      }
+      return result.counts.error > 0 ? 1 : 0;
+    } catch (e) {
+      err(opts)(`fringe: internal error: ${e.message}
+`);
+      return 2;
+    }
+  }
+  if (cmd === "init") {
+    try {
+      for (const line of initProject(resolve(opts.cwd ?? process.cwd(), rest[0] ?? "."))) log(opts)(`fringe: ${line}`);
+      return 0;
+    } catch (e) {
+      err(opts)(`fringe: ${e.message}
+`);
+      return 2;
+    }
+  }
+  if (cmd === "open") {
+    try {
+      const port = Number(rest[rest.indexOf("--port") + 1]) || 4173;
+      const path2 = rest.find((a, i) => !a.startsWith("--") && rest[i - 1] !== "--port");
+      await startBoard(resolve(opts.cwd ?? process.cwd(), path2 ?? "."), port);
+      log(opts)(`fringe: ledger at http://127.0.0.1:${port} \u2014 Ctrl+C to stop`);
+      return await new Promise(() => {
+      });
+    } catch (e) {
+      err(opts)(`fringe: internal error: ${e.message}
+`);
+      return 2;
+    }
+  }
+  if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+    log(opts)(HELP);
+    return 0;
+  }
+  log(opts)(`fringe: unknown command '${cmd ?? ""}' \u2014 try 'fringe check --help'`);
+  return 2;
+}
+
+export {
+  runCli
+};