@domandigital/craft 0.10.0 → 0.12.0

package/dist/{chunk-JKIDWHG3.js → chunk-J3QUROJ5.js}

@@ -1,20 +1,210 @@
 import {
   CATALOGUE,
   CATALOGUE_VERSION,
+  HOUSE_LOCKED,
   applyHouseGate,
   checkCopy,
   extractCopy,
   extractStrings,
   fileKind,
+  holdHouseBlocks,
   houseRule,
   scanSource
-} from "./chunk-3NGWXZZE.js";
+} from "./chunk-AL6MRG6V.js";
+
+// src/character/config.ts
+var DEFAULT_IGNORE = [".claude", ".agents", ".cursor"];
+var KEYS = /* @__PURE__ */ new Set(["$schema", "ignore", "copyPaths", "severity"]);
+var LEVELS = /* @__PURE__ */ new Set(["warn", "block", "off"]);
+var MIN_BECAUSE = 12;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isStringArray = (v) => Array.isArray(v) && v.every((s) => typeof s === "string");
+function parseCraftConfig(data, knownTells, source = "craft.config.json") {
+  if (!isRecord(data)) throw new Error(`${source}: expected an object`);
+  for (const key of Object.keys(data)) if (!KEYS.has(key)) throw new Error(`${source}: unknown key "${key}"`);
+  const ignore = data.ignore ?? [];
+  if (!isStringArray(ignore)) throw new Error(`${source}: "ignore" must be an array of glob strings`);
+  if (data.copyPaths !== void 0 && !isStringArray(data.copyPaths)) throw new Error(`${source}: "copyPaths" must be an array of paths`);
+  const severity = {};
+  const raw = data.severity ?? {};
+  if (!isRecord(raw)) throw new Error(`${source}: "severity" must map a tell id to { level, because }`);
+  for (const [tell, value] of Object.entries(raw)) {
+    if (!knownTells.has(tell)) throw new Error(`${source}: severity names no tell called "${tell}"`);
+    if (!isRecord(value) || !LEVELS.has(value.level)) {
+      throw new Error(`${source}: severity.${tell} needs a level of "warn", "block" or "off"`);
+    }
+    if (typeof value.because !== "string" || value.because.trim().length < MIN_BECAUSE) {
+      throw new Error(`${source}: severity.${tell} needs a because of at least a sentence`);
+    }
+    severity[tell] = { level: value.level, because: value.because };
+  }
+  return { ignore, severity, ...data.copyPaths ? { copyPaths: data.copyPaths } : {} };
+}
+function globToRegExp(glob) {
+  const pattern = glob.replace(/^\.\//, "").replace(/\/$/, "").replace(/\/\*\*$/, "");
+  let body = "";
+  for (let i = 0; i < pattern.length; i += 1) {
+    const c = pattern[i];
+    if (c === "*" && pattern[i + 1] === "*") {
+      const slash = pattern[i + 2] === "/";
+      body += slash ? "(?:.*/)?" : ".*";
+      i += slash ? 2 : 1;
+    } else if (c === "*") body += "[^/]*";
+    else if (c === "?") body += "[^/]";
+    else body += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  const anywhere = !pattern.includes("/");
+  return new RegExp(`^${anywhere ? "(?:.*/)?" : ""}${body}(?:/.*)?$`);
+}
+function ignoreMatcher(patterns) {
+  const res = patterns.map(globToRegExp);
+  return (path) => {
+    const p = path.replace(/\\/g, "/").replace(/^\.\//, "");
+    return res.some((re) => re.test(p));
+  };
+}
+function severityExceptions(config) {
+  return Object.entries(config.severity).filter(([, o]) => o.level === "off").map(([tell, o]) => ({ tell, because: `craft.config.json: ${o.because}` }));
+}
+function applySeverity(report, config) {
+  const findings = report.findings.map((f) => {
+    const o = config.severity[f.tell];
+    return o && o.level !== "off" ? { ...f, severity: o.level } : f;
+  });
+  return { ...report, findings, summary: { ...report.summary, blocking: findings.filter((f) => f.severity === "block").length } };
+}
+
+// src/character/json.ts
+var JSON_SCHEMA_VERSION = 1;
+function toJson(data) {
+  return JSON.stringify({ schemaVersion: JSON_SCHEMA_VERSION, ...data }, null, 2);
+}
 
 // src/character/cli.ts
 import { execFileSync } from "child_process";
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
 import { join, relative, resolve } from "path";
 
+// src/character/baseline.ts
+var BASELINE_VERSION = 1;
+function fnv1a(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+var excerptHash = (f) => fnv1a(f.excerpt.replace(/\s+/g, " ").trim());
+var keyOf = (tell, path, excerpt) => `${tell}\0${path}\0${excerpt}`;
+function findingKey(f) {
+  return keyOf(f.tell, f.path, excerptHash(f));
+}
+function createBaseline(report) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const f of report.findings) {
+    const excerpt = excerptHash(f);
+    const key = keyOf(f.tell, f.path, excerpt);
+    const entry = counts.get(key);
+    if (entry) entry.count += 1;
+    else counts.set(key, { tell: f.tell, path: f.path, excerpt, count: 1 });
+  }
+  const entries = [...counts.values()].sort((a, b) => a.path.localeCompare(b.path) || a.tell.localeCompare(b.tell) || a.excerpt.localeCompare(b.excerpt));
+  return { version: BASELINE_VERSION, catalogueVersion: report.catalogueVersion, entries };
+}
+function parseBaseline(data, source = "baseline") {
+  const b = data;
+  if (!b || typeof b !== "object" || b.version !== BASELINE_VERSION || !Array.isArray(b.entries)) {
+    throw new Error(`${source}: not a craft baseline (version ${BASELINE_VERSION})`);
+  }
+  for (const e of b.entries) {
+    if (typeof e?.tell !== "string" || typeof e.path !== "string" || typeof e.excerpt !== "string" || !Number.isInteger(e.count) || e.count < 1) {
+      throw new Error(`${source}: malformed entry ${JSON.stringify(e)}`);
+    }
+  }
+  return b;
+}
+function recount(report, findings) {
+  const byGeneration = { 1: 0, 2: 0, 3: 0 };
+  const byTell = {};
+  for (const f of findings) {
+    byGeneration[f.generation] += 1;
+    byTell[f.tell] = (byTell[f.tell] ?? 0) + 1;
+  }
+  return {
+    ...report,
+    findings,
+    summary: { ...report.summary, findings: findings.length, byGeneration, byTell, blocking: findings.filter((f) => f.severity === "block").length }
+  };
+}
+function applyBaseline(report, baseline) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const e of baseline.entries) {
+    const key = keyOf(e.tell, e.path, e.excerpt);
+    remaining.set(key, (remaining.get(key) ?? 0) + e.count);
+  }
+  const kept = [];
+  let baselined = 0;
+  for (const f of report.findings) {
+    const key = findingKey(f);
+    const left = remaining.get(key) ?? 0;
+    if (left > 0) {
+      remaining.set(key, left - 1);
+      baselined += 1;
+    } else kept.push(f);
+  }
+  return { ...recount(report, kept), baselined };
+}
+
+// src/character/sarif.ts
+var isUrl = (path) => /^[a-z][a-z0-9+.-]*:\/\//i.test(path);
+function toSarif(report, options) {
+  const byId = new Map(options.tells.map((t) => [t.id, t]));
+  const ids = [...new Set(report.findings.map((f) => f.tell))].sort();
+  const index = new Map(ids.map((id, i) => [id, i]));
+  const rules = ids.map((id) => {
+    const t = byId.get(id);
+    return {
+      id,
+      name: t?.name ?? id,
+      shortDescription: { text: t?.name ?? id },
+      ...t ? { fullDescription: { text: t.why }, help: { text: t.fix } } : {}
+    };
+  });
+  const results = report.findings.map((f) => ({
+    ruleId: f.tell,
+    ruleIndex: index.get(f.tell),
+    level: f.severity === "block" ? "error" : "warning",
+    message: { text: `${f.message}. ${f.fix}` },
+    locations: [
+      {
+        physicalLocation: {
+          artifactLocation: { uri: isUrl(f.path) ? f.path : f.path.replace(/\\/g, "/") },
+          ...f.line > 0 ? { region: { startLine: f.line, snippet: { text: f.excerpt } } } : {}
+        }
+      }
+    ],
+    partialFingerprints: { "craftFinding/v1": fnv1a(findingKey(f)) }
+  }));
+  return {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "craft",
+            version: report.catalogueVersion,
+            informationUri: options.informationUri ?? "https://www.npmjs.com/package/@domandigital/craft",
+            rules
+          }
+        },
+        results
+      }
+    ]
+  };
+}
+
 // src/character/facts.ts
 var MONTH = "(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)";
 var PATTERNS = [
@@ -252,14 +442,15 @@ var NOT_SITE_COPY = /^(?:README|CHANGELOG|CLAUDE|AGENTS|CONTRIBUTING|LICENSE|COD
 var HELP = `craft: find the AI look and say what to do instead.
 
 Usage
-  craft scan [paths...] [--staged] [--json] [--strict] [--direction <file>]
-  craft copy <paths...> [--gate] [--json] [--strict] [--direction <file>]
+  craft scan [paths...] [--staged] [--json] [--strict] [--direction <file>] [ci options]
+  craft copy [paths...] [--gate] [--json] [--strict] [--direction <file>] [ci options]
   craft copy compare <before> <after> [--json]
   craft copy claims <paths...> [--json]
   craft tells list [--json]
   craft tells harvest <null.json | dir>... [--share 0.25] [--json]
   craft snapshot <url> [--out <file>] [--width <px>] [--height <px>]
-  craft audit <url | snapshot.json> [--repo <dir>] [--null <null.json>] [--out <file>] [--json] [--strict]
+  craft audit <url | snapshot.json> [--repo <dir>] [--null <null.json>] [--out <file>] [--json] [--strict] [ci options]
+  craft audit --pages <sitemap.xml | urls.txt> [--viewport 390,768,1440] [the same]
   craft direction init [--snapshot <file>] [--client <name>] [--out <file>]
   craft direction validate [--snapshot <file>] [--direction <file>] [--json]
   craft direction propose [--snapshot <file>] [--estate <estate.json | dir>] [--out <file>]
@@ -287,6 +478,8 @@ audit     Judge a rendered page (live, or a saved snapshot) and fingerprint it.
           --repo also scans that site's source, so one report covers both.
           --null scores how typical it is against a null model (comma-separate
           several to pool them).
+          --pages audits every URL in a sitemap (a URL or a file) or a file of
+          URLs, one per line. --viewport audits each page at these widths.
           snapshot and audit need Playwright: npm i -D playwright.
 direction The site's art-direction.json: every choice with a reason from the
           client's world. init writes today's choices with empty reasons;
@@ -303,8 +496,18 @@ report    Every signal for one site: tells, typicality, the estate, the reasons.
 retrofit  The report as a checklist: decide, then change type, colour, shape,
           effects, motion and copy. Never the page grammar.
 
+ci options (scan, copy, audit)
+  --baseline <file>     Report only findings the baseline does not already
+                        hold. Keyed on tell, path and excerpt, not line.
+  --update-baseline     Write every current finding to --baseline, exit 0.
+  --sarif <file>        Also write SARIF 2.1.0, for GitHub code scanning.
+  --config <file>       craft.config.json, default: the working directory.
+
 Exceptions come from art-direction.json in the working directory, or --direction.
-Every tell ships as warn: exit 1 only on a block, or on any finding with --strict.`;
+craft.config.json holds ignore globs, copyPaths, and severity changes, each
+with a because. .claude, .agents and .cursor are never walked.
+Every tell ships as warn: exit 1 only on a block, or on any finding with --strict.
+--json output always carries schemaVersion.`;
 var VALUE_FLAGS = {
   "--direction": "direction",
   "--out": "out",
@@ -320,16 +523,22 @@ var VALUE_FLAGS = {
   "--model": "model",
   "--share": "share",
   "--null": "null",
-  "--id": "id"
+  "--id": "id",
+  "--config": "config",
+  "--baseline": "baseline",
+  "--sarif": "sarif",
+  "--pages": "pages",
+  "--viewport": "viewport"
 };
 function parseFlags(args) {
-  const flags = { positional: [], json: false, strict: false, staged: false, gate: false };
+  const flags = { positional: [], json: false, strict: false, staged: false, gate: false, updateBaseline: false };
   for (let i = 0; i < args.length; i += 1) {
     const a = args[i];
     if (a === "--json") flags.json = true;
     else if (a === "--strict") flags.strict = true;
     else if (a === "--staged") flags.staged = true;
     else if (a === "--gate") flags.gate = true;
+    else if (a === "--update-baseline") flags.updateBaseline = true;
     else if (a in VALUE_FLAGS) {
       const value = args[i + 1];
       i += 1;
@@ -340,48 +549,86 @@ function parseFlags(args) {
   }
   return flags;
 }
-function walk(root, cwd, into, wanted, skipDir = (_) => false) {
+function walk(root, cwd, into, wanted, skipDir = (_) => false, ignored = (_) => false) {
   const stat = statSync(root);
   if (stat.isFile()) {
     if (stat.size <= MAX_BYTES) into.push({ path: relative(cwd, root) || root, text: readFileSync(root, "utf8") });
     return;
   }
   for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const path = join(root, entry.name);
+    if (ignored(relative(cwd, path))) continue;
     if (entry.isDirectory()) {
-      if (!SKIP_DIRS.has(entry.name) && !skipDir(entry.name)) walk(join(root, entry.name), cwd, into, wanted, skipDir);
+      if (!SKIP_DIRS.has(entry.name) && !skipDir(entry.name)) walk(path, cwd, into, wanted, skipDir, ignored);
     } else if (entry.isFile() && wanted(entry.name)) {
-      walk(join(root, entry.name), cwd, into, wanted, skipDir);
+      walk(path, cwd, into, wanted, skipDir, ignored);
     }
   }
 }
-function readPaths(paths, cwd, wanted, skipDir) {
+function readPaths(paths, cwd, wanted, skipDir, ignore = []) {
   const files = [];
+  const ignored = ignoreMatcher([...DEFAULT_IGNORE, ...ignore]);
   for (const p of paths) {
     const abs = resolve(cwd, p);
     if (!existsSync(abs)) throw new Error(`no such path: ${p}`);
-    walk(abs, cwd, files, wanted, skipDir);
+    walk(abs, cwd, files, wanted, skipDir, ignored);
   }
   return files;
 }
-function readStaged(cwd, wanted) {
-  const names = execFileSync("git", ["diff", "--cached", "--name-only", "--diff-filter=ACMR", "-z"], { cwd, encoding: "utf8" }).split("\0").filter((p) => p && wanted(p));
+function readStaged(cwd, wanted, ignore) {
+  const ignored = ignoreMatcher([...DEFAULT_IGNORE, ...ignore]);
+  const names = execFileSync("git", ["diff", "--cached", "--name-only", "--diff-filter=ACMR", "-z"], { cwd, encoding: "utf8" }).split("\0").filter((p) => p && wanted(p) && !ignored(p));
   return names.map((path) => ({
     path,
     // The index, not the working tree: the commit is what gets checked.
     text: execFileSync("git", ["show", `:${path}`], { cwd, encoding: "utf8", maxBuffer: MAX_BYTES * 4 })
   }));
 }
+var NO_CONFIG = { ignore: [], severity: {} };
+function loadConfig(flags, root) {
+  const path = resolve(root, flags.config ?? "craft.config.json");
+  if (!existsSync(path)) {
+    if (flags.config) throw new Error(`no such file: ${flags.config}`);
+    return NO_CONFIG;
+  }
+  return parseCraftConfig(JSON.parse(readFileSync(path, "utf8")), new Set(CATALOGUE.map((t) => t.id)), flags.config ?? "craft.config.json");
+}
 function loadExceptions(flags, cwd) {
+  const fromConfig = severityExceptions(loadConfig(flags, cwd));
   const path = resolve(cwd, flags.direction ?? "art-direction.json");
   if (!existsSync(path)) {
     if (flags.direction) throw new Error(`no such file: ${flags.direction}`);
-    return [];
+    return fromConfig;
   }
   const data = JSON.parse(readFileSync(path, "utf8"));
-  return Array.isArray(data.exceptions) ? data.exceptions : [];
+  return [...Array.isArray(data.exceptions) ? data.exceptions : [], ...fromConfig];
+}
+function prepareReport(report, flags, io, config) {
+  let result = applySeverity(report, config);
+  if (flags.updateBaseline) {
+    if (!flags.baseline) throw new Error("--update-baseline needs --baseline <file>");
+    const baseline = createBaseline(result);
+    writeFileSync(resolve(io.cwd, flags.baseline), `${JSON.stringify(baseline, null, 2)}
+`);
+    io.out(`craft: baseline of ${result.findings.length} finding${result.findings.length === 1 ? "" : "s"} written to ${flags.baseline}`);
+    return null;
+  }
+  if (flags.baseline) {
+    const path = resolve(io.cwd, flags.baseline);
+    if (!existsSync(path)) throw new Error(`no such file: ${flags.baseline} (create it with --update-baseline)`);
+    result = applyBaseline(result, parseBaseline(JSON.parse(readFileSync(path, "utf8")), flags.baseline));
+  }
+  if (flags.sarif) {
+    writeFileSync(resolve(io.cwd, flags.sarif), `${JSON.stringify(toSarif(result, { tells: CATALOGUE }), null, 2)}
+`);
+  }
+  return result;
 }
 function finish(report, flags, title, io) {
-  io.out(flags.json ? JSON.stringify(report, null, 2) : formatReport(report, title));
+  io.out(flags.json ? toJson(report) : formatReport(report, title));
+  if (!flags.json && report.baselined) {
+    io.out(`${report.baselined} known finding${report.baselined === 1 ? "" : "s"} not shown: already in ${flags.baseline}.`);
+  }
   if (report.summary.blocking > 0) return 1;
   if (flags.strict && report.summary.findings > 0) return 1;
   return 0;
@@ -392,25 +639,25 @@ var NOT_COPY_DIR = (name) => name.startsWith("_");
 function run(argv, io) {
   const [command, ...rest] = argv;
   if (command === "direction") {
-    return import("./cli-2WBGTBKD.js").then((m) => m.runDirection(rest, io));
+    return import("./cli-ZPJIWVEP.js").then((m) => m.runDirection(rest, io));
   }
   if (command === "report" || command === "retrofit") {
-    return import("./cli-ADQQURNR.js").then((m) => m.runReport(command, rest, io));
+    return import("./cli-ZB2VJ7CY.js").then((m) => m.runReport(command, rest, io));
   }
   if (command === "estate") {
-    return import("./cli-VQUNNIZM.js").then((m) => m.runEstate(rest, io));
+    return import("./cli-2DY3V3SF.js").then((m) => m.runEstate(rest, io));
   }
   if (command === "null") {
-    return import("./cli-PRWTNFVP.js").then((m) => m.runNull(rest, io));
+    return import("./cli-C3JLFXMG.js").then((m) => m.runNull(rest, io));
   }
   if (command === "tells" && rest[0] === "harvest") {
-    return import("./cli-PRWTNFVP.js").then((m) => m.runHarvest(rest, io)).catch((error) => {
+    return import("./cli-C3JLFXMG.js").then((m) => m.runHarvest(rest, io)).catch((error) => {
       io.err(`craft: ${error.message}`);
       return 2;
     });
   }
   if (command === "snapshot" || command === "audit") {
-    return import("./cli-EK3GSAOW.js").then((m) => m.runAudit(command, rest, io));
+    return import("./cli-QM2AQQMF.js").then((m) => m.runAudit(command, rest, io));
   }
   if (!command || command === "help" || command === "--help" || command === "-h") {
     io.out(HELP);
@@ -432,7 +679,7 @@ function run(argv, io) {
           fix,
           ...surface === "copy" ? { house: houseRule(id, name).tier, houseLabel: houseRule(id, name).label } : {}
         }));
-        io.out(JSON.stringify({ version: CATALOGUE_VERSION, tells: data }, null, 2));
+        io.out(toJson({ version: CATALOGUE_VERSION, tells: data }));
       } else {
         io.out(`Catalogue ${CATALOGUE_VERSION}`);
         for (const t of CATALOGUE) io.out(`  ${t.id.padEnd(24)} gen ${t.generation}  ${t.surface.padEnd(6)}  ${t.name}`);
@@ -449,7 +696,7 @@ function run(argv, io) {
         return visibleText({ path: p, text: readFileSync(abs, "utf8") });
       });
       const result = compareFacts(before, after);
-      io.out(flags.json ? JSON.stringify(result, null, 2) : formatComparison(result, flags.positional[0], flags.positional[1]));
+      io.out(flags.json ? toJson(result) : formatComparison(result, flags.positional[0], flags.positional[1]));
       return result.lost.length || result.added.length ? 1 : 0;
     }
     if (command === "copy" && rest[0] === "claims") {
@@ -457,19 +704,35 @@ function run(argv, io) {
       if (typeof flags === "string") throw new Error(flags);
       if (flags.positional.length === 0) throw new Error("usage: craft copy claims <paths...> [--json]");
       const report = findClaims(readPaths(flags.positional, io.cwd, COPY_FILE, NOT_COPY_DIR));
-      io.out(flags.json ? JSON.stringify(report, null, 2) : formatClaims(report));
+      io.out(flags.json ? toJson(report) : formatClaims(report));
       return 0;
     }
     if (command === "scan" || command === "copy") {
       const flags = parseFlags(rest);
       if (typeof flags === "string") throw new Error(flags);
       const wanted = command === "scan" ? SOURCE_FILE : COPY_FILE;
-      if (command === "copy" && flags.positional.length === 0 && !flags.staged) throw new Error("usage: craft copy <paths...>");
-      const files = flags.staged ? readStaged(io.cwd, wanted) : readPaths(flags.positional.length > 0 ? flags.positional : ["."], io.cwd, wanted, command === "copy" ? NOT_COPY_DIR : void 0);
-      const exceptions = loadExceptions(flags, io.cwd);
+      const config = loadConfig(flags, io.cwd);
+      const paths = flags.positional.length > 0 ? flags.positional : command === "copy" ? config.copyPaths ?? [] : ["."];
+      if (command === "copy" && paths.length === 0 && !flags.staged) throw new Error("usage: craft copy <paths...> (or copyPaths in craft.config.json)");
+      const files = flags.staged ? readStaged(io.cwd, wanted, config.ignore) : readPaths(paths, io.cwd, wanted, command === "copy" ? NOT_COPY_DIR : void 0, config.ignore);
+      let exceptions = loadExceptions(flags, io.cwd);
+      let effective = config;
+      let refused = [];
+      if (command === "copy" && flags.gate) {
+        const held = holdHouseBlocks(exceptions, config.severity);
+        exceptions = held.exceptions;
+        effective = { ...config, severity: held.severity };
+        const warned = held.refusedSeverity.filter((tell) => config.severity[tell].level === "warn").map((tell) => ({ tell, because: `craft.config.json: ${config.severity[tell].because}` }));
+        refused = [...held.refused, ...warned];
+      }
       let report = command === "scan" ? scanSource(files, { exceptions }) : checkCopy(files, { exceptions });
-      if (command === "copy" && flags.gate) report = applyHouseGate(report);
-      return finish(report, flags, command === "scan" ? "craft scan" : "craft copy", io);
+      if (command === "copy" && flags.gate) {
+        report = applyHouseGate(report);
+        report = { ...report, rejectedExceptions: [...report.rejectedExceptions, ...refused.map((exception) => ({ exception, reason: HOUSE_LOCKED }))] };
+      }
+      const prepared = prepareReport(report, flags, io, effective);
+      if (!prepared) return 0;
+      return finish(prepared, flags, command === "scan" ? "craft scan" : "craft copy", io);
     }
     throw new Error(`unknown command "${command}". Run craft --help.`);
   } catch (error) {
@@ -479,9 +742,13 @@ function run(argv, io) {
 }
 
 export {
+  applySeverity,
+  toJson,
   parseFlags,
   readPaths,
+  loadConfig,
   loadExceptions,
+  prepareReport,
   finish,
   SOURCE_FILE,
   COPY_FILE,

package/dist/chunk-JYNXGCYZ.js

@@ -0,0 +1,75 @@
+// src/direction/png.ts
+import { inflateSync } from "zlib";
+function decodePng(buf) {
+  const sig = [137, 80, 78, 71, 13, 10, 26, 10];
+  if (!sig.every((b, i) => buf[i] === b)) throw new Error("not a PNG");
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let pos = 8;
+  let width = 0;
+  let height = 0;
+  let depth = 0;
+  let colour = 0;
+  let interlace = 0;
+  const idat = [];
+  while (pos < buf.length) {
+    const len = view.getUint32(pos);
+    const type = String.fromCharCode(...buf.subarray(pos + 4, pos + 8));
+    const data = buf.subarray(pos + 8, pos + 8 + len);
+    if (type === "IHDR") {
+      width = view.getUint32(pos + 8);
+      height = view.getUint32(pos + 12);
+      depth = data[8];
+      colour = data[9];
+      interlace = data[12];
+    } else if (type === "IDAT") idat.push(data);
+    else if (type === "IEND") break;
+    pos += 12 + len;
+  }
+  const channels = { 0: 1, 2: 3, 4: 2, 6: 4 }[colour];
+  if (depth !== 8 || !channels || interlace !== 0) throw new Error(`unsupported PNG (depth ${depth}, colour type ${colour}${interlace ? ", interlaced" : ""}); export it as 8-bit RGB`);
+  const raw = inflateSync(Buffer.concat(idat.map((d) => Buffer.from(d))));
+  const stride = width * channels;
+  const out = new Uint8Array(width * height * 4);
+  const prev = new Uint8Array(stride);
+  const line = new Uint8Array(stride);
+  for (let y = 0; y < height; y += 1) {
+    const filter = raw[y * (stride + 1)];
+    const src = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+    for (let x = 0; x < stride; x += 1) {
+      const a = x >= channels ? line[x - channels] : 0;
+      const b = prev[x];
+      const c = x >= channels ? prev[x - channels] : 0;
+      let v = src[x];
+      if (filter === 1) v += a;
+      else if (filter === 2) v += b;
+      else if (filter === 3) v += a + b >> 1;
+      else if (filter === 4) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c);
+        v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+      }
+      line[x] = v & 255;
+    }
+    for (let x = 0; x < width; x += 1) {
+      const i = x * channels;
+      const o = (y * width + x) * 4;
+      if (channels >= 3) {
+        out[o] = line[i];
+        out[o + 1] = line[i + 1];
+        out[o + 2] = line[i + 2];
+        out[o + 3] = channels === 4 ? line[i + 3] : 255;
+      } else {
+        out[o] = out[o + 1] = out[o + 2] = line[i];
+        out[o + 3] = channels === 2 ? line[i + 1] : 255;
+      }
+    }
+    prev.set(line);
+  }
+  return { width, height, rgba: out };
+}
+
+export {
+  decodePng
+};

package/dist/{chunk-APO4BT2F.js → chunk-LHGY43LL.js}

@@ -1,10 +1,14 @@
 import {
-  parseFlags
-} from "./chunk-JKIDWHG3.js";
+  readSnapshot
+} from "./chunk-ZKVJ7K6X.js";
+import {
+  parseFlags,
+  toJson
+} from "./chunk-J3QUROJ5.js";
 import {
   fingerprint,
   fingerprintDistance
-} from "./chunk-QMYERCBB.js";
+} from "./chunk-PZ4MF2VV.js";
 import {
   CATALOGUE_VERSION,
   REFLEX_FONTS_1,
@@ -18,7 +22,7 @@ import {
   isCream,
   oklchToRgb,
   scanSource
-} from "./chunk-3NGWXZZE.js";
+} from "./chunk-AL6MRG6V.js";
 
 // src/null/cli.ts
 import { spawn } from "child_process";
@@ -352,7 +356,7 @@ async function build(flags, io) {
   const toShoot = ids.filter((id) => existsSync(join(pages, `${id}.html`)) && !existsSync(join(shots, `${id}.json`)));
   if (toShoot.length) {
     io.out(`craft null: snapshotting ${toShoot.length} page${toShoot.length === 1 ? "" : "s"}`);
-    const { snapshotUrls } = await import("./audit-EGDNWSQB.js");
+    const { snapshotUrls } = await import("./audit-5QWFLZ6L.js");
     const results = await snapshotUrls(toShoot.map((id) => pathToFileURL(join(pages, `${id}.html`)).href));
     results.forEach((r, i) => {
       const id = toShoot[i];
@@ -361,7 +365,7 @@ async function build(flags, io) {
       else failed.push(`${id}: the page would not render: ${r.error}`);
     });
   }
-  const measured = ids.filter((id) => existsSync(join(pages, `${id}.html`)) && existsSync(join(shots, `${id}.json`))).map((id) => measureRun(id, readFileSync(join(pages, `${id}.html`), "utf8"), readJson(join(shots, `${id}.json`))));
+  const measured = ids.filter((id) => existsSync(join(pages, `${id}.html`)) && existsSync(join(shots, `${id}.json`))).map((id) => measureRun(id, readFileSync(join(pages, `${id}.html`), "utf8"), readSnapshot(readJson(join(shots, `${id}.json`)), `${id}.json`)));
   const model = {
     version: NULL_VERSION,
     brief: brief.trim(),
@@ -439,7 +443,7 @@ function runHarvest(args, io) {
   const minShare = flags.share === void 0 ? void 0 : Number(flags.share);
   if (minShare !== void 0 && !(minShare > 0 && minShare <= 1)) throw new Error("--share needs a number above 0 and at most 1");
   const candidates = harvest(models, { minShare, copyTell });
-  io.out(flags.json ? JSON.stringify({ briefs: models.map((m) => m.brief), candidates }, null, 2) : formatHarvest(candidates, models));
+  io.out(flags.json ? toJson({ briefs: models.map((m) => m.brief), candidates }) : formatHarvest(candidates, models));
   return 0;
 }