@domandigital/craft 0.5.0 → 0.7.0

package/dist/chunk-YYC4EGER.js

@@ -0,0 +1,249 @@
+import {
+  CATALOGUE,
+  CATALOGUE_VERSION,
+  checkCopy,
+  fileKind,
+  scanSource
+} from "./chunk-3AP4PJMX.js";
+
+// src/character/cli.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative, resolve } from "path";
+
+// src/character/format.ts
+function formatReport(report, title) {
+  const lines = [];
+  let current = "";
+  for (const f of report.findings) {
+    if (f.path !== current) {
+      current = f.path;
+      lines.push("", f.path);
+    }
+    lines.push(`  ${String(f.line).padStart(4)}  ${f.tell} (gen ${f.generation}, ${f.severity})  ${f.message}`);
+    lines.push(`        ${f.excerpt}`);
+  }
+  const fixes = new Map(report.findings.map((f) => [f.tell, f.fix]));
+  if (fixes.size > 0) {
+    lines.push("", "What to do instead:");
+    for (const [tell, fix] of fixes) lines.push(`  ${tell}: ${fix}`);
+  }
+  for (const r of report.rejectedExceptions) {
+    lines.push("", `Exception not applied (${r.exception.tell}): ${r.reason}`);
+  }
+  for (const e of report.excepted) {
+    lines.push("", `Excepted: ${e.count} \xD7 ${e.tell}, because ${e.because}`);
+  }
+  if (report.suppressed.length > 0) {
+    lines.push("", `Suppressed: ${report.suppressed.length} marked copy-ok or craft-ok (${report.suppressed.map((s) => `${s.path}:${s.line}`).join(", ")})`);
+  }
+  const { summary } = report;
+  const gens = `gen 1: ${summary.byGeneration[1]}, gen 2: ${summary.byGeneration[2]}, gen 3: ${summary.byGeneration[3]}`;
+  lines.push(
+    "",
+    `${title}: ${summary.findings} finding${summary.findings === 1 ? "" : "s"} in ${summary.files} file${summary.files === 1 ? "" : "s"} (${gens}). Catalogue ${report.catalogueVersion}.`
+  );
+  return lines.join("\n").replace(/^\n/, "");
+}
+
+// src/character/cli.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", ".next", ".turbo", ".vercel", "coverage", "vendor", ".cache"]);
+var MAX_BYTES = 1e6;
+var NOT_SITE_COPY = /^(?:README|CHANGELOG|CLAUDE|AGENTS|CONTRIBUTING|LICENSE|CODE_OF_CONDUCT|SECURITY)(?:\.[a-z]+)?$/i;
+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...> [--json] [--strict] [--direction <file>]
+  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 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>]
+  craft null build --brief "<text>" --out <dir> [--runs 20] [--parallel 4] [--model <name>]
+  craft estate add <url | snapshot.json> --id <id> [--client <name>] [--estate <file>]
+  craft estate compare [<url | snapshot.json | id>] [--null <dir>] [--json] [--strict]
+  craft report <url | snapshot.json> [--repo <dir>] [--null <dir>] [--estate <file>] [--direction <file>] [--json] [--strict]
+  craft retrofit <url | snapshot.json> [the same] [--out RETROFIT.md]
+
+scan      Markup, component code and stylesheets (source and compiled CSS).
+          --staged reads the git index, for a pre-commit hook.
+copy      The prose in Markdown, markup and content files.
+tells     The catalogue this build judges against. harvest reads null models
+          for choices the model keeps making that the catalogue does not know.
+snapshot  Render a page in a browser and save what it looks like, as JSON.
+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).
+          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;
+          validate applies the reason rule; propose reads colours off the
+          sources' PNG photos and drafts choices for a person to confirm.
+null      The counterfactual: about 20 pages \`claude -p\` builds from the brief
+          alone, snapshotted and fingerprinted into null.json. Resumable.
+estate    The register of shipped sites (estate.json). add fingerprints a site;
+          compare lists the nearest, and marks siblings: two sites closer than
+          two pages Claude builds for one brief. --strict exits 1 on a sibling.
+report    Every signal for one site: tells, typicality, the estate, the reasons.
+          A verdict (default, mixed, decided, unproven) and what to do, in order.
+          Anything not given is "not measured", and never counts as a pass.
+retrofit  The report as a checklist: decide, then change type, colour, shape,
+          effects, motion and copy. Never the page grammar.
+
+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.`;
+var VALUE_FLAGS = {
+  "--direction": "direction",
+  "--out": "out",
+  "--repo": "repo",
+  "--width": "width",
+  "--height": "height",
+  "--snapshot": "snapshot",
+  "--estate": "estate",
+  "--client": "client",
+  "--brief": "brief",
+  "--runs": "runs",
+  "--parallel": "parallel",
+  "--model": "model",
+  "--share": "share",
+  "--null": "null",
+  "--id": "id"
+};
+function parseFlags(args) {
+  const flags = { positional: [], json: false, strict: false, staged: 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 in VALUE_FLAGS) {
+      const value = args[i + 1];
+      i += 1;
+      if (!value || value.startsWith("--")) return `${a} needs a value`;
+      flags[VALUE_FLAGS[a]] = value;
+    } else if (a.startsWith("--")) return `unknown option ${a}`;
+    else flags.positional.push(a);
+  }
+  return flags;
+}
+function walk(root, cwd, into, wanted, skipDir = (_) => 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 })) {
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRS.has(entry.name) && !skipDir(entry.name)) walk(join(root, entry.name), cwd, into, wanted, skipDir);
+    } else if (entry.isFile() && wanted(entry.name)) {
+      walk(join(root, entry.name), cwd, into, wanted, skipDir);
+    }
+  }
+}
+function readPaths(paths, cwd, wanted, skipDir) {
+  const files = [];
+  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);
+  }
+  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));
+  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 })
+  }));
+}
+function loadExceptions(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 [];
+  }
+  const data = JSON.parse(readFileSync(path, "utf8"));
+  return Array.isArray(data.exceptions) ? data.exceptions : [];
+}
+function finish(report, flags, title, io) {
+  io.out(flags.json ? JSON.stringify(report, null, 2) : formatReport(report, title));
+  if (report.summary.blocking > 0) return 1;
+  if (flags.strict && report.summary.findings > 0) return 1;
+  return 0;
+}
+var SOURCE_FILE = (p) => ["markup", "script", "css"].includes(fileKind(p)) && !/\.d\.ts$|\.min\.js$/.test(p);
+var COPY_FILE = (p) => (["markup", "prose", "script"].includes(fileKind(p)) || /\.jsonl?$/i.test(p)) && !NOT_SITE_COPY.test(p.split("/").pop() ?? p) && !/(?:^|\/)(?:package(?:-lock)?|tsconfig[\w.-]*|art-direction)\.json$/.test(p);
+var NOT_COPY_DIR = (name) => name.startsWith("_");
+function run(argv, io) {
+  const [command, ...rest] = argv;
+  if (command === "direction") {
+    return import("./cli-6Y5E32FS.js").then((m) => m.runDirection(rest, io));
+  }
+  if (command === "report" || command === "retrofit") {
+    return import("./cli-TM2HWYN7.js").then((m) => m.runReport(command, rest, io));
+  }
+  if (command === "estate") {
+    return import("./cli-IQT6QZ6U.js").then((m) => m.runEstate(rest, io));
+  }
+  if (command === "null") {
+    return import("./cli-MW3JAGX3.js").then((m) => m.runNull(rest, io));
+  }
+  if (command === "tells" && rest[0] === "harvest") {
+    return import("./cli-MW3JAGX3.js").then((m) => m.runHarvest(rest, io)).catch((error) => {
+      io.err(`craft: ${error.message}`);
+      return 2;
+    });
+  }
+  if (command === "snapshot" || command === "audit") {
+    return import("./cli-PD43TWX7.js").then((m) => m.runAudit(command, rest, io));
+  }
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    io.out(HELP);
+    return command ? 0 : 2;
+  }
+  try {
+    if (command === "tells") {
+      const flags = parseFlags(rest);
+      if (typeof flags === "string") throw new Error(flags);
+      if (flags.positional[0] !== "list") throw new Error("usage: craft tells list [--json] | craft tells harvest <null.json>...");
+      if (flags.json) {
+        const data = CATALOGUE.map(({ id, name, generation, surface, severity, why, fix }) => ({ id, name, generation, surface, severity, why, fix }));
+        io.out(JSON.stringify({ version: CATALOGUE_VERSION, tells: data }, null, 2));
+      } 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}`);
+      }
+      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 report = command === "scan" ? scanSource(files, { exceptions }) : checkCopy(files, { exceptions });
+      return finish(report, flags, command === "scan" ? "craft scan" : "craft copy", io);
+    }
+    throw new Error(`unknown command "${command}". Run craft --help.`);
+  } catch (error) {
+    io.err(`craft: ${error.message}`);
+    return 2;
+  }
+}
+
+export {
+  parseFlags,
+  readPaths,
+  loadExceptions,
+  finish,
+  SOURCE_FILE,
+  COPY_FILE,
+  NOT_COPY_DIR,
+  run
+};

package/dist/cli-6Y5E32FS.js

@@ -0,0 +1,334 @@
+import {
+  DIRECTION_VERSION,
+  validateDirection
+} from "./chunk-J2BOAIHJ.js";
+import {
+  parseFlags
+} from "./chunk-YYC4EGER.js";
+import {
+  fingerprint
+} from "./chunk-Q54JSNC5.js";
+import {
+  deltaEOk,
+  formatHex,
+  hexToOklch,
+  isAiViolet,
+  isCream,
+  oklchToRgb,
+  parseColour
+} from "./chunk-3AP4PJMX.js";
+
+// src/direction/cli.ts
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+
+// src/direction/init.ts
+var hex = (o) => {
+  const { r, g, b } = oklchToRgb(o);
+  const clamp = (n) => Math.min(1, Math.max(0, n));
+  return formatHex({ r: clamp(r), g: clamp(g), b: clamp(b) });
+};
+function initDirection(input) {
+  const fp = input.current;
+  const empty = (value) => ({ value, because: "", evidence: [] });
+  const choices = fp ? {
+    ...fp.accent ? { accent: empty(hex(fp.accent)) } : {},
+    ground: empty(hex(fp.ground)),
+    display: empty(fp.display.family),
+    body: empty(fp.body.family),
+    ...fp.roundness !== null ? { shape: empty(fp.roundness >= 0.45 ? "pill buttons" : fp.roundness <= 0.05 ? "square corners" : `corners at ${Math.round(fp.roundness * 100)}% of button height`) } : {}
+  } : {};
+  return {
+    $schema: "https://unpkg.com/@domandigital/craft/art-direction.schema.json",
+    version: DIRECTION_VERSION,
+    client: input.client ?? "",
+    brief: input.brief ?? "",
+    sources: [],
+    choices,
+    ...input.exceptions?.length ? { exceptions: input.exceptions } : {}
+  };
+}
+
+// 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 };
+}
+
+// src/direction/propose.ts
+var PROPOSED = "PROPOSED:";
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function toLab(r, g, b) {
+  const lr = srgbToLinear(r / 255);
+  const lg = srgbToLinear(g / 255);
+  const lb = srgbToLinear(b / 255);
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return [0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s, 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s, 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s];
+}
+function paletteFromPixels(rgba, k = 6, maxSamples = 2e4) {
+  const total = Math.floor(rgba.length / 4);
+  const step = Math.max(1, Math.floor(total / maxSamples));
+  const px = [];
+  for (let i = 0; i < total; i += step) {
+    const o = i * 4;
+    if (rgba[o + 3] < 128) continue;
+    px.push({ lab: toLab(rgba[o], rgba[o + 1], rgba[o + 2]), rgb: [rgba[o], rgba[o + 1], rgba[o + 2]] });
+  }
+  if (px.length === 0) return [];
+  const sorted = [...px].sort((a, b) => a.lab[0] - b.lab[0]);
+  const n = Math.min(k, px.length);
+  let centres = Array.from({ length: n }, (_, i) => sorted[Math.floor((i + 0.5) / n * sorted.length)].lab.slice());
+  let assign = new Array(px.length).fill(0);
+  for (let iter = 0; iter < 12; iter += 1) {
+    assign = px.map((p) => {
+      let best = 0;
+      let bestD = Infinity;
+      centres.forEach((c, j) => {
+        const d = (p.lab[0] - c[0]) ** 2 + (p.lab[1] - c[1]) ** 2 + (p.lab[2] - c[2]) ** 2;
+        if (d < bestD) {
+          bestD = d;
+          best = j;
+        }
+      });
+      return best;
+    });
+    centres = centres.map((c, j) => {
+      const members = px.filter((_, i) => assign[i] === j);
+      if (members.length === 0) return c;
+      return [0, 1, 2].map((d) => members.reduce((s, m) => s + m.lab[d], 0) / members.length);
+    });
+  }
+  return centres.map((_, j) => {
+    const members = px.filter((__, i) => assign[i] === j);
+    if (members.length === 0) return null;
+    const avg = [0, 1, 2].map((d) => members.reduce((s, m) => s + m.rgb[d], 0) / members.length / 255);
+    const hex2 = formatHex({ r: avg[0], g: avg[1], b: avg[2] });
+    return { hex: hex2, share: members.length / px.length, oklch: hexToOklch(hex2) };
+  }).filter((c) => c !== null).sort((a, b) => b.share - a.share);
+}
+var chromatic = (o) => o.c >= 0.04 && o.l >= 0.2 && o.l <= 0.85;
+function accentCandidates(input) {
+  const out = [];
+  for (const s of input.sources) {
+    for (const c of s.colours ?? []) {
+      const parsed = parseColour(c);
+      if (!parsed || !chromatic(parsed.oklch)) continue;
+      const o = parsed.oklch;
+      const siblings = (input.estate ?? []).map((e) => ({ id: e.id, d: e.fingerprint.accent ? deltaEOk(o, e.fingerprint.accent) : 1 }));
+      const nearest = siblings.sort((a, b) => a.d - b.d)[0];
+      const penalty = isAiViolet(o) ? 1 : 0;
+      out.push({
+        value: c.startsWith("#") ? c.toLowerCase() : c,
+        evidence: [s.id],
+        note: `from ${s.id} (${s.kind})${nearest ? `; nearest estate accent ${nearest.id} at \u0394E ${nearest.d.toFixed(2)}` : ""}${penalty ? "; in the reflex violet band" : ""}`,
+        score: (nearest ? Math.min(nearest.d, 0.3) : 0.3) - penalty + o.c
+      });
+    }
+  }
+  return out.sort((a, b) => b.score - a.score).map(({ score: _s, ...rest }) => rest);
+}
+function groundCandidates(input) {
+  const out = [];
+  for (const s of input.sources) {
+    for (const c of s.colours ?? []) {
+      const parsed = parseColour(c);
+      if (!parsed || parsed.oklch.l < 0.9) continue;
+      out.push({ value: c, evidence: [s.id], note: `a light colour from ${s.id}${isCream(parsed.oklch) ? "; reads as the cream tell, needs its reason" : ""}` });
+    }
+  }
+  return out;
+}
+function typeCandidates(input) {
+  return input.sources.filter((s) => s.lettering).map((s) => ({ value: "", evidence: [s.id], note: `find a face with the character of "${s.lettering}" on ${s.id}` }));
+}
+function propose(input) {
+  const proposals = [
+    { key: "accent", candidates: accentCandidates(input) },
+    { key: "ground", candidates: groundCandidates(input) },
+    { key: "display", candidates: typeCandidates(input) }
+  ];
+  const choices = {};
+  const draft = (p) => {
+    const top = p.candidates[0];
+    if (!top || !top.value) return void 0;
+    const source = input.sources.find((s) => s.id === top.evidence[0]);
+    return {
+      value: top.value,
+      because: `${PROPOSED} taken from the ${source.id}: ${source.note} Confirm it matches, then rewrite this in your own words.`,
+      evidence: top.evidence
+    };
+  };
+  for (const p of proposals) {
+    const c = draft(p);
+    if (c) choices[p.key] = c;
+  }
+  return {
+    proposals,
+    direction: { version: DIRECTION_VERSION, client: input.client, brief: input.brief, sources: input.sources, choices }
+  };
+}
+
+// src/direction/cli.ts
+var readJson = (path) => JSON.parse(readFileSync(path, "utf8"));
+function fingerprintFrom(path, cwd) {
+  return path ? fingerprint(readJson(resolve(cwd, path))) : void 0;
+}
+function estateFrom(dir, cwd) {
+  if (!dir) return [];
+  const root = resolve(cwd, dir);
+  if (root.endsWith(".json")) {
+    const register = readJson(root);
+    return (register.sites ?? []).map((s) => ({ id: s.id, fingerprint: s.fingerprint }));
+  }
+  return readdirSync(root).filter((f) => f.endsWith(".json")).flatMap((f) => {
+    try {
+      const snap = readJson(join(root, f));
+      return snap.version === 1 && snap.fonts ? [{ id: f.replace(/(\.snapshot)?\.json$/, ""), fingerprint: fingerprint(snap) }] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+function runDirection(args, io) {
+  try {
+    const flags = parseFlags(args);
+    if (typeof flags === "string") throw new Error(flags);
+    const [sub] = flags.positional;
+    const file = resolve(io.cwd, flags.direction ?? "art-direction.json");
+    const current = fingerprintFrom(flags.snapshot, io.cwd);
+    if (sub === "init") {
+      const out = resolve(io.cwd, flags.out ?? "art-direction.json");
+      if (existsSync(out) && !flags.out) {
+        const existing = readJson(out);
+        if (existing.version !== void 0) throw new Error(`${out} already records choices. Pass --out to write elsewhere.`);
+        const next = initDirection({ client: flags.client, current, exceptions: existing.exceptions });
+        writeFileSync(out, `${JSON.stringify(next, null, 2)}
+`);
+      } else {
+        writeFileSync(out, `${JSON.stringify(initDirection({ client: flags.client, current }), null, 2)}
+`);
+      }
+      io.out(`craft direction: wrote ${out}. Add the sources and a reason for every choice, then run craft direction validate.`);
+      return 0;
+    }
+    if (sub === "validate") {
+      if (!existsSync(file)) throw new Error(`no ${file}. Run craft direction init.`);
+      const report = validateDirection(readJson(file), {
+        fingerprint: current,
+        pathExists: (p) => existsSync(resolve(dirname(file), p))
+      });
+      if (flags.json) io.out(JSON.stringify(report, null, 2));
+      else {
+        for (const p of report.problems) io.out(`  ${p.severity === "error" ? "error" : "warn "}  ${p.at || "(file)"}  ${p.message}`);
+        io.out(`craft direction: ${report.valid ? "valid" : "not valid"}, ${report.decided} of 7 choices decided with a reason.`);
+      }
+      return report.valid ? 0 : 1;
+    }
+    if (sub === "propose") {
+      if (!existsSync(file)) throw new Error(`no ${file}. Run craft direction init and add the sources first.`);
+      const base = readJson(file);
+      const sources = (base.sources ?? []).map((s) => {
+        if (s.colours?.length || !s.path || !/\.png$/i.test(s.path)) return s;
+        const path = resolve(dirname(file), s.path);
+        if (!existsSync(path)) return s;
+        try {
+          const { rgba } = decodePng(readFileSync(path));
+          return { ...s, colours: paletteFromPixels(rgba).filter((c) => c.share >= 0.03).map((c) => c.hex) };
+        } catch (error) {
+          io.err(`craft direction: ${s.path}: ${error.message}`);
+          return s;
+        }
+      });
+      const result = propose({ client: base.client, brief: base.brief, sources, current, estate: estateFrom(flags.estate, io.cwd) });
+      const merged = { ...base, sources, choices: { ...result.direction.choices, ...stripUndecided(base.choices) }, ...base.exceptions ? { exceptions: base.exceptions } : {} };
+      const text = `${JSON.stringify(merged, null, 2)}
+`;
+      if (flags.out) writeFileSync(resolve(io.cwd, flags.out), text);
+      else io.out(text);
+      for (const p of result.proposals) {
+        io.err(`${p.key}: ${p.candidates.length ? p.candidates.map((c) => `${c.value || "?"} (${c.note})`).join("; ") : "nothing in the sources to draw on yet"}`);
+      }
+      return 0;
+    }
+    throw new Error("usage: craft direction init | validate | propose");
+  } catch (error) {
+    io.err(`craft: ${error.message}`);
+    return 2;
+  }
+}
+function stripUndecided(choices = {}) {
+  return Object.fromEntries(Object.entries(choices).filter(([, c]) => c && c.because && c.because.trim().length > 0));
+}
+export {
+  runDirection
+};

package/dist/cli-IQT6QZ6U.js

@@ -0,0 +1,16 @@
+import {
+  formatMatches,
+  formatPairs,
+  loadEstate,
+  runEstate
+} from "./chunk-CU5TZHOV.js";
+import "./chunk-GV3QOTQU.js";
+import "./chunk-YYC4EGER.js";
+import "./chunk-Q54JSNC5.js";
+import "./chunk-3AP4PJMX.js";
+export {
+  formatMatches,
+  formatPairs,
+  loadEstate,
+  runEstate
+};

package/dist/cli-MW3JAGX3.js

@@ -0,0 +1,21 @@
+import {
+  describeTypicality,
+  formatHarvest,
+  loadNull,
+  measureRun,
+  nullPath,
+  runHarvest,
+  runNull
+} from "./chunk-GV3QOTQU.js";
+import "./chunk-YYC4EGER.js";
+import "./chunk-Q54JSNC5.js";
+import "./chunk-3AP4PJMX.js";
+export {
+  describeTypicality,
+  formatHarvest,
+  loadNull,
+  measureRun,
+  nullPath,
+  runHarvest,
+  runNull
+};

package/dist/cli-PD43TWX7.js

@@ -0,0 +1,15 @@
+import {
+  describeFingerprint,
+  merge,
+  runAudit
+} from "./chunk-IQTZWNEK.js";
+import "./chunk-OA7SGPN4.js";
+import "./chunk-GV3QOTQU.js";
+import "./chunk-YYC4EGER.js";
+import "./chunk-Q54JSNC5.js";
+import "./chunk-3AP4PJMX.js";
+export {
+  describeFingerprint,
+  merge,
+  runAudit
+};