@domandigital/craft 0.5.0 → 0.7.0

package/dist/chunk-CU5TZHOV.js

@@ -0,0 +1,163 @@
+import {
+  groundName,
+  hueName,
+  loadNull,
+  shapeName
+} from "./chunk-GV3QOTQU.js";
+import {
+  parseFlags
+} from "./chunk-YYC4EGER.js";
+import {
+  fingerprint,
+  fingerprintDistance
+} from "./chunk-Q54JSNC5.js";
+import {
+  SNAPSHOT_VERSION,
+  auditSnapshot
+} from "./chunk-3AP4PJMX.js";
+
+// src/estate/cli.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+
+// src/estate/index.ts
+var ESTATE_VERSION = 1;
+var SIBLING_AT = 0.31;
+function emptyEstate() {
+  return { version: ESTATE_VERSION, sites: [] };
+}
+function addSite(register, site) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(site.id)) throw new Error(`site id "${site.id}" must be short kebab-case`);
+  const sites = [...register.sites.filter((s) => s.id !== site.id), site].sort((a, b) => a.id.localeCompare(b.id));
+  return { version: ESTATE_VERSION, sites };
+}
+function sharedParts(a, b, d = fingerprintDistance(a, b)) {
+  const out = [];
+  const close = (k) => d.parts[k] <= 0.2;
+  if (close("accent")) out.push(a.accent || b.accent ? `${hueName(a.accent)} accent` : "no accent");
+  if (close("type")) {
+    if (a.display.family === b.display.family) out.push(`${a.display.family} headline`);
+    if (a.body.family === b.body.family) out.push(`${a.body.family} body`);
+  }
+  if (close("ground")) out.push(`${groundName(a.ground)} ground`);
+  if (close("shape")) out.push(`${shapeName(a.roundness)} buttons`);
+  if (close("motion")) out.push(a.motion > 0 || b.motion > 0 ? "scroll reveals" : "no reveals");
+  if (close("effects") && a.effects.length) out.push(a.effects.filter((e) => b.effects.includes(e)).join(", "));
+  if (close("layout")) out.push("running order");
+  return out;
+}
+function compareToEstate(target, register, options = {}) {
+  const at = options.siblingAt ?? SIBLING_AT;
+  return register.sites.filter((s) => s.id !== options.exclude).map((s) => {
+    const d = fingerprintDistance(target, s.fingerprint);
+    return { id: s.id, distance: d.total, sibling: d.total < at, shared: sharedParts(target, s.fingerprint, d) };
+  }).sort((a, b) => a.distance - b.distance);
+}
+function estatePairs(register, siblingAt = SIBLING_AT) {
+  const out = [];
+  const s = register.sites;
+  for (let i = 0; i < s.length; i += 1) {
+    for (let j = i + 1; j < s.length; j += 1) {
+      const d = fingerprintDistance(s[i].fingerprint, s[j].fingerprint);
+      out.push({ a: s[i].id, b: s[j].id, distance: d.total, sibling: d.total < siblingAt, shared: sharedParts(s[i].fingerprint, s[j].fingerprint, d) });
+    }
+  }
+  return out.sort((x, y) => x.distance - y.distance);
+}
+function siblingLine(briefs) {
+  const d = [];
+  for (const runs of briefs) {
+    for (let i = 0; i < runs.length; i += 1) for (let j = i + 1; j < runs.length; j += 1) d.push(fingerprintDistance(runs[i], runs[j]).total);
+  }
+  if (d.length === 0) throw new Error("no null pages to measure the sibling line from");
+  d.sort((a, b) => a - b);
+  const mid = Math.floor(d.length / 2);
+  const m = d.length % 2 ? d[mid] : (d[mid - 1] + d[mid]) / 2;
+  return Math.round(m * 1e3) / 1e3;
+}
+
+// src/estate/cli.ts
+var USAGE = "usage: craft estate add <url | snapshot.json> --id <id> [--client <name>] | craft estate compare [<url | snapshot.json | id>] [--null <dir>] [--json] [--strict]";
+function loadEstate(path) {
+  if (!existsSync(path)) return emptyEstate();
+  const data = JSON.parse(readFileSync(path, "utf8"));
+  if (data.version !== ESTATE_VERSION || !Array.isArray(data.sites)) throw new Error(`${path} is not an estate register (version ${ESTATE_VERSION})`);
+  return data;
+}
+async function snapshotOf(target, cwd) {
+  const local = resolve(cwd, target);
+  if (/\.json$/i.test(target) && existsSync(local)) {
+    const snap = JSON.parse(readFileSync(local, "utf8"));
+    if (snap.version !== SNAPSHOT_VERSION) throw new Error(`${target} is not a snapshot`);
+    return snap;
+  }
+  if (!/^https?:\/\//.test(target)) throw new Error(`${target} is neither a URL, a snapshot file, nor a site in the register`);
+  const { snapshotUrl } = await import("./audit-YNODYB3U.js");
+  return snapshotUrl(target);
+}
+var line = (distance, sibling, shared) => `${distance.toFixed(2)}${sibling ? "  SIBLING" : ""}${shared.length ? `  shares ${shared.join(", ")}` : ""}`;
+function formatMatches(label, matches, at) {
+  const lines = [`${label}: nearest sites in the estate (siblings below ${at.toFixed(2)})`];
+  for (const m of matches) lines.push(`  ${m.id.padEnd(20)} ${line(m.distance, m.sibling, m.shared)}`);
+  if (matches.length === 0) lines.push("  the register is empty");
+  return lines.join("\n");
+}
+function formatPairs(pairs, at, sites) {
+  const siblings = pairs.filter((p) => p.sibling).length;
+  const lines = [`craft estate: ${sites} sites, ${pairs.length} pair${pairs.length === 1 ? "" : "s"}, ${siblings} sibling pair${siblings === 1 ? "" : "s"} (below ${at.toFixed(2)})`];
+  for (const p of pairs) lines.push(`  ${`${p.a} + ${p.b}`.padEnd(34)} ${line(p.distance, p.sibling, p.shared)}`);
+  return lines.join("\n");
+}
+async function runEstate(args, io) {
+  try {
+    const flags = parseFlags(args);
+    if (typeof flags === "string") throw new Error(flags);
+    const [sub, target] = flags.positional;
+    const file = resolve(io.cwd, flags.estate ?? "estate.json");
+    const register = loadEstate(file);
+    const at = flags.null ? siblingLine(flags.null.split(",").map((p) => loadNull(p.trim(), io.cwd).runs.map((r) => r.fingerprint))) : SIBLING_AT;
+    if (sub === "add") {
+      if (!target || !flags.id) throw new Error(USAGE);
+      const snap = await snapshotOf(target, io.cwd);
+      const fp = fingerprint(snap);
+      const next = addSite(register, {
+        id: flags.id,
+        client: flags.client ?? flags.id,
+        url: snap.url,
+        fingerprint: fp,
+        tells: [...new Set(auditSnapshot(snap).findings.map((f) => f.tell))].sort(),
+        addedAt: snap.capturedAt
+      });
+      writeFileSync(file, `${JSON.stringify(next, null, 2)}
+`);
+      io.out(`craft estate: ${flags.id} ${register.sites.some((s) => s.id === flags.id) ? "updated" : "added"}, ${next.sites.length} sites in ${flags.estate ?? "estate.json"}`);
+      io.out(formatMatches(flags.id, compareToEstate(fp, next, { exclude: flags.id, siblingAt: at }).slice(0, 3), at));
+      return 0;
+    }
+    if (sub === "compare") {
+      if (!target) {
+        const pairs = estatePairs(register, at);
+        io.out(flags.json ? JSON.stringify({ siblingAt: at, pairs }, null, 2) : formatPairs(pairs, at, register.sites.length));
+        return flags.strict && pairs.some((p) => p.sibling) ? 1 : 0;
+      }
+      const known = register.sites.find((s) => s.id === target);
+      const fp = known ? known.fingerprint : fingerprint(await snapshotOf(target, io.cwd));
+      const matches = compareToEstate(fp, register, { exclude: known?.id, siblingAt: at });
+      io.out(flags.json ? JSON.stringify({ siblingAt: at, matches }, null, 2) : formatMatches(known?.id ?? target, matches, at));
+      return flags.strict && matches.some((m) => m.sibling) ? 1 : 0;
+    }
+    throw new Error(USAGE);
+  } catch (error) {
+    io.err(`craft: ${error.message}`);
+    return 2;
+  }
+}
+
+export {
+  SIBLING_AT,
+  compareToEstate,
+  loadEstate,
+  formatMatches,
+  formatPairs,
+  runEstate
+};

package/dist/chunk-GV3QOTQU.js

@@ -0,0 +1,458 @@
+import {
+  parseFlags
+} from "./chunk-YYC4EGER.js";
+import {
+  fingerprint,
+  fingerprintDistance
+} from "./chunk-Q54JSNC5.js";
+import {
+  CATALOGUE_VERSION,
+  REFLEX_FONTS_1,
+  REFLEX_FONTS_2,
+  auditSnapshot,
+  checkCopy,
+  deltaEOk,
+  extractStrings,
+  formatHex,
+  isAiViolet,
+  isCream,
+  oklchToRgb,
+  scanSource
+} from "./chunk-3AP4PJMX.js";
+
+// src/null/cli.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join, relative, resolve } from "path";
+import { pathToFileURL } from "url";
+
+// src/null/index.ts
+var NULL_VERSION = 1;
+function nullPrompt(brief) {
+  return [
+    `Build the home page for this business: ${brief.trim()}`,
+    "",
+    "Write it as one complete, self-contained HTML file. You may load fonts and libraries from a CDN. Use real copy, not placeholder text. Reply with the HTML only."
+  ].join("\n");
+}
+function extractHtml(reply) {
+  const start = reply.search(/<!doctype html|<html[\s>]/i);
+  if (start < 0) return null;
+  const end = reply.toLowerCase().lastIndexOf("</html>");
+  const html = end > start ? reply.slice(start, end + "</html>".length) : reply.slice(start).replace(/\s*```\s*$/, "");
+  return html.length > 200 ? html : null;
+}
+var MIN_RUNS = 5;
+var TYPICAL_AT = 0.1;
+function meanNearest(distances, k) {
+  const sorted = [...distances].sort((a, b) => a - b).slice(0, k);
+  return sorted.reduce((s, d) => s + d, 0) / sorted.length;
+}
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function typicality(target, runs, k = 3) {
+  if (runs.length < MIN_RUNS) throw new Error(`a null model needs at least ${MIN_RUNS} runs; this one has ${runs.length}`);
+  const kk = Math.min(k, runs.length - 1);
+  const toTarget = runs.map((r) => ({ id: r.id, distance: fingerprintDistance(target, r.fingerprint).total }));
+  const distance = meanNearest(
+    toTarget.map((t) => t.distance),
+    kk
+  );
+  const loo = runs.map(
+    (r, i) => meanNearest(
+      runs.filter((_, j) => j !== i).map((o) => fingerprintDistance(r.fingerprint, o.fingerprint).total),
+      kk
+    )
+  );
+  const score = loo.filter((d) => d >= distance).length / loo.length;
+  return {
+    score: Math.round(score * 100) / 100,
+    typical: score >= TYPICAL_AT,
+    distance: Math.round(distance * 1e3) / 1e3,
+    baseline: Math.round(median(loo) * 1e3) / 1e3,
+    nearest: toTarget.sort((a, b) => a.distance - b.distance).slice(0, kk),
+    shared: sharedChoices(target, runs)
+  };
+}
+var HUES = [
+  ["red", 0, 45],
+  ["orange", 45, 75],
+  ["yellow", 75, 110],
+  ["green", 110, 165],
+  ["teal", 165, 215],
+  ["blue", 215, 265],
+  ["violet", 265, 315],
+  ["pink", 315, 360]
+];
+function hueName(o) {
+  if (!o) return "none";
+  if (o.c < 0.03) return "neutral";
+  return HUES.find(([, lo, hi]) => o.h >= lo && o.h < hi)?.[0] ?? "red";
+}
+function groundName(o) {
+  if (o.l < 0.3) return "dark";
+  if (isCream(o)) return "cream";
+  if (o.l >= 0.97 && o.c < 0.012) return "white";
+  return o.c < 0.02 ? "grey" : "tinted";
+}
+function shapeName(roundness) {
+  if (roundness === null) return "no buttons";
+  if (roundness >= 0.45) return "pill";
+  return roundness >= 0.15 ? "soft" : "square";
+}
+function choicesOf(fp) {
+  return {
+    display: [fp.display.family],
+    body: [fp.body.family],
+    accent: [hueName(fp.accent)],
+    ground: [groundName(fp.ground)],
+    shape: [shapeName(fp.roundness)],
+    motion: [fp.motion >= 0.6 ? "reveals most sections" : fp.motion > 0 ? "reveals some sections" : "no scroll reveals"],
+    effects: fp.effects,
+    opening: [fp.layout.slice(0, 3).join(" > ") || "none"]
+  };
+}
+function sharedChoices(target, runs) {
+  const mine = choicesOf(target);
+  const all = runs.map((r) => choicesOf(r.fingerprint));
+  const out = [];
+  for (const [part, values] of Object.entries(mine)) {
+    for (const value of values) {
+      const count = all.filter((c) => c[part].includes(value)).length;
+      if (count / runs.length >= 0.25) out.push({ part, value, runs: count, of: runs.length });
+    }
+  }
+  return out.sort((a, b) => b.runs - a.runs);
+}
+var REFLEX_1 = new Set(REFLEX_FONTS_1.map((f) => f.toLowerCase()));
+var REFLEX_2 = new Set(REFLEX_FONTS_2.map((f) => f.toLowerCase()));
+function knownFor(kind, value, sample) {
+  if (kind === "face") return REFLEX_1.has(value.toLowerCase()) ? "reflex-font" : REFLEX_2.has(value.toLowerCase()) ? "reflex-font-2" : null;
+  if (kind === "accent" && value === "violet") return sample.some((f) => f.accent && isAiViolet(f.accent)) ? "ai-violet" : null;
+  if (kind === "ground" && value === "cream") return "cream-palette";
+  if (kind === "shape" && value === "pill") return "pill-everything";
+  if (kind === "motion" && value === "reveals most sections") return "reveal-everywhere";
+  if (kind === "tell") return value;
+  if (kind === "opening" && /^hero > (?:logos|stats)/.test(value)) return "hero-then-proof";
+  return null;
+}
+var STOP = new Set(
+  "a an the and or but of to in on for with at by from as is are be we our you your us it its this that these those will can all more get has have not no any".split(" ")
+);
+function grams(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const clause of text.toLowerCase().replace(/[’']/g, "'").split(/[.!?;:|()\u2013\u2014\u00b7•]+|,\s/)) {
+    const words = clause.match(/[a-z][a-z'-]*/g) ?? [];
+    for (let n = 2; n <= 4; n += 1) {
+      for (let i = 0; i + n <= words.length; i += 1) {
+        const g = words.slice(i, i + n);
+        if (STOP.has(g[0]) || STOP.has(g[n - 1])) continue;
+        if (g.filter((w) => !STOP.has(w)).length < 2) continue;
+        out.add(g.join(" "));
+      }
+    }
+  }
+  return out;
+}
+var GRAMMAR = /* @__PURE__ */ new Set([
+  "privacy policy",
+  "cookie policy",
+  "rights reserved",
+  "all rights reserved",
+  "terms of service",
+  "terms and conditions",
+  "terms conditions",
+  "how it works",
+  "what we do",
+  "about us",
+  "contact us",
+  "get in touch",
+  "opening hours",
+  "read more",
+  "learn more",
+  "book now",
+  "free quote",
+  "our services",
+  "quick links",
+  "email address",
+  "phone number",
+  "full name",
+  "first name",
+  "last name",
+  "your name",
+  "your email",
+  "send message"
+]);
+var LEGAL = /©|&copy;|\bregistered (?:in|office|number)\b|\bcompany (?:no|number|reg)|\bvat (?:no|number|reg)/i;
+var NOISE = /\S+@\S+|https?:\/\/\S+|\b[\w-]+(?:\.[\w-]+)*\.(?:co\.uk|com|org|net|uk|io)\b|\b\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm)\b|\d+/gi;
+function textGrams(text) {
+  if (LEGAL.test(text)) return /* @__PURE__ */ new Set();
+  const out = grams(text.replace(NOISE, " | "));
+  for (const g of out) if (GRAMMAR.has(g)) out.delete(g);
+  return out;
+}
+function properNouns(brief) {
+  return new Set((brief.match(/\b[A-Z][a-z]+/g) ?? []).map((w) => w.toLowerCase()).filter((w) => !STOP.has(w)));
+}
+function harvest(models, options = {}) {
+  const minShare = options.minShare ?? 0.25;
+  const runs = models.flatMap((m, b) => m.runs.map((r) => ({ ...r, brief: b })));
+  const of = runs.length;
+  if (of === 0) return [];
+  const multiBrief = models.length > 1;
+  const sample = runs.map((r) => r.fingerprint);
+  const tally = /* @__PURE__ */ new Map();
+  const add = (kind, value, run, brief, example) => {
+    const key = `${kind}\0${value}`;
+    const t = tally.get(key) ?? { kind, value, runs: /* @__PURE__ */ new Set(), briefs: /* @__PURE__ */ new Set(), example };
+    t.runs.add(run);
+    t.briefs.add(brief);
+    tally.set(key, t);
+  };
+  runs.forEach((r, i) => {
+    const c = choicesOf(r.fingerprint);
+    for (const f of /* @__PURE__ */ new Set([...c.display, ...c.body])) add("face", f, i, r.brief);
+    add("accent", c.accent[0], i, r.brief);
+    add("ground", c.ground[0], i, r.brief);
+    add("shape", c.shape[0], i, r.brief);
+    add("motion", c.motion[0], i, r.brief);
+    add("opening", c.opening[0], i, r.brief);
+    for (const t of r.tells) add("tell", t, i, r.brief);
+  });
+  const out = [];
+  for (const t of tally.values()) {
+    if (t.runs.size / of < minShare) continue;
+    if (t.kind === "accent" && (t.value === "none" || t.value === "neutral")) continue;
+    if (t.kind === "shape" && t.value === "no buttons") continue;
+    if (t.kind === "ground" && (t.value === "white" || t.value === "grey")) continue;
+    if (t.kind === "motion" && t.value === "no scroll reveals") continue;
+    out.push({ kind: t.kind, value: t.value, runs: t.runs.size, of, briefs: t.briefs.size, known: knownFor(t.kind, t.value, sample) });
+  }
+  const phraseMin = Math.max(3, Math.ceil(of * minShare * 0.4));
+  const names = models.map((m) => properNouns(m.brief));
+  const phrases = /* @__PURE__ */ new Map();
+  runs.forEach((r, i) => {
+    for (const text of r.copy) {
+      for (const g of textGrams(text)) {
+        if (g.split(" ").some((w) => names[r.brief].has(w))) continue;
+        const p = phrases.get(g) ?? { runs: /* @__PURE__ */ new Set(), briefs: /* @__PURE__ */ new Set(), example: text.trim().slice(0, 140) };
+        p.runs.add(i);
+        p.briefs.add(r.brief);
+        phrases.set(g, p);
+      }
+    }
+  });
+  const kept = [...phrases].filter(([, p]) => p.runs.size >= phraseMin && (!multiBrief || p.briefs.size >= 2)).sort((a, b) => b[1].runs.size - a[1].runs.size || b[0].length - a[0].length);
+  const maximal = kept.filter(([g, p]) => !kept.some(([h, q]) => h !== g && h.includes(g) && q.runs.size >= 0.8 * p.runs.size));
+  for (const [g, p] of maximal.slice(0, 40)) {
+    out.push({ kind: "phrase", value: g, runs: p.runs.size, of, briefs: p.briefs.size, known: options.copyTell?.(g) ?? null, example: p.example });
+  }
+  const order = ["face", "accent", "ground", "shape", "motion", "opening", "tell", "phrase"];
+  return out.sort((a, b) => order.indexOf(a.kind) - order.indexOf(b.kind) || b.runs - a.runs);
+}
+function hueSwatch(runs, hue) {
+  const hits = runs.map((r) => r.fingerprint.accent).filter((o) => !!o && hueName(o) === hue);
+  if (hits.length === 0) return null;
+  const centre = hits.reduce((best, o) => hits.reduce((s, p) => s + deltaEOk(o, p), 0) < hits.reduce((s, p) => s + deltaEOk(best, p), 0) ? o : best);
+  return formatHex(oklchToRgb(centre));
+}
+
+// src/null/cli.ts
+var readJson = (path) => JSON.parse(readFileSync(path, "utf8"));
+var pad = (n) => String(n).padStart(2, "0");
+function generate(prompt, model) {
+  const bin = process.env.CRAFT_CLAUDE ?? "claude";
+  const args = ["-p", "--tools", "", "--no-session-persistence", "--disable-slash-commands", "--setting-sources", "", "--strict-mcp-config", ...model ? ["--model", model] : [], prompt];
+  const cwd = mkdtempSync(join(tmpdir(), "craft-null-"));
+  return new Promise((done, fail) => {
+    const child = spawn(bin, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (d) => out += d.toString());
+    child.stderr.on("data", (d) => err += d.toString());
+    child.on("error", (e) => fail(new Error(`${bin}: ${e.message}. Install Claude Code, or set CRAFT_CLAUDE.`)));
+    child.on("close", (code) => {
+      rmSync(cwd, { recursive: true, force: true });
+      if (code === 0) done(out);
+      else fail(new Error(`${bin} exited ${code}: ${(err || out).trim().slice(0, 200)}`));
+    });
+  });
+}
+async function pool(items, size, work) {
+  const queue = [...items];
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(size, queue.length)) }, async () => {
+    for (let item = queue.shift(); item !== void 0; item = queue.shift()) await work(item);
+  }));
+}
+function nullPath(target, cwd) {
+  const abs = resolve(cwd, target);
+  return existsSync(abs) && statSync(abs).isDirectory() ? join(abs, "null.json") : abs;
+}
+function loadNull(target, cwd) {
+  const path = nullPath(target, cwd);
+  if (!existsSync(path)) throw new Error(`no null model at ${target}. Build one with craft null build.`);
+  const model = readJson(path);
+  if (model.version !== NULL_VERSION) throw new Error(`${target} is null model version ${String(model.version)}; this craft reads ${NULL_VERSION}`);
+  return model;
+}
+function measureRun(id, html, snapshot) {
+  const file = { path: `${id}.html`, text: html };
+  const tells = new Set([...auditSnapshot(snapshot).findings, ...scanSource([file]).findings].map((f) => f.tell));
+  const copy = [...new Set(extractStrings(file).filter((b) => !b.literal).map((b) => b.text.replace(/\s+/g, " ").trim()).filter(Boolean))];
+  return { id, fingerprint: fingerprint(snapshot), tells: [...tells].sort(), copy };
+}
+async function build(flags, io) {
+  const brief = flags.brief ?? (flags.direction ? readJson(resolve(io.cwd, flags.direction)).brief : void 0);
+  if (!brief || brief.trim().split(/\s+/).length < 5) throw new Error('usage: craft null build --brief "<who, where, what they do>" --out <dir> [--runs 20] [--parallel 4]');
+  if (!flags.out) throw new Error("--out <dir> is where the pages and null.json go");
+  const runs = Number(flags.runs ?? 20);
+  const parallel = Number(flags.parallel ?? 4);
+  if (!Number.isInteger(runs) || runs < 5) throw new Error("--runs needs a whole number, 5 or more");
+  const dir = resolve(io.cwd, flags.out);
+  const pages = join(dir, "pages");
+  const shots = join(dir, "snapshots");
+  mkdirSync(pages, { recursive: true });
+  mkdirSync(shots, { recursive: true });
+  const prompt = nullPrompt(brief);
+  const ids = Array.from({ length: runs }, (_, i) => pad(i + 1));
+  for (const id of ids) {
+    const path = join(pages, `${id}.html`);
+    if (!existsSync(path)) continue;
+    const raw = readFileSync(path, "utf8");
+    const html = extractHtml(raw);
+    if (!html) {
+      writeFileSync(join(pages, `${id}.reply.txt`), raw);
+      rmSync(path);
+      rmSync(join(shots, `${id}.json`), { force: true });
+      io.out(`  ${id} was a reply, not a page: kept as ${id}.reply.txt and generated again`);
+    } else if (html !== raw) writeFileSync(path, html);
+  }
+  const missing = ids.filter((id) => !existsSync(join(pages, `${id}.html`)));
+  const failed = [];
+  if (missing.length) io.out(`craft null: generating ${missing.length} page${missing.length === 1 ? "" : "s"}, ${parallel} at a time`);
+  await pool(missing, parallel, async (id) => {
+    try {
+      const reply = await generate(prompt, flags.model);
+      const html = extractHtml(reply);
+      if (!html) {
+        writeFileSync(join(pages, `${id}.reply.txt`), reply);
+        failed.push(`${id}: the reply held no HTML page (kept as ${id}.reply.txt)`);
+        return;
+      }
+      writeFileSync(join(pages, `${id}.html`), html);
+      io.out(`  ${id} written`);
+    } catch (error) {
+      failed.push(`${id}: ${error.message}`);
+    }
+  });
+  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-YNODYB3U.js");
+    const results = await snapshotUrls(toShoot.map((id) => pathToFileURL(join(pages, `${id}.html`)).href));
+    results.forEach((r, i) => {
+      const id = toShoot[i];
+      if (r.snapshot) writeFileSync(join(shots, `${id}.json`), `${JSON.stringify({ ...r.snapshot, url: `pages/${id}.html` }, null, 2)}
+`);
+      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 model = {
+    version: NULL_VERSION,
+    brief: brief.trim(),
+    prompt,
+    model: flags.model ?? "default",
+    catalogueVersion: CATALOGUE_VERSION,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    runs: measured
+  };
+  writeFileSync(join(dir, "null.json"), `${JSON.stringify(model, null, 2)}
+`);
+  io.out(`craft null: ${measured.length} of ${runs} pages in ${relative(io.cwd, join(dir, "null.json")) || "null.json"}`);
+  for (const f of failed) io.err(`  ${f}`);
+  if (measured.length < runs) {
+    io.err(`craft null: ${runs - measured.length} missing. Run the same command again to fill them in.`);
+    return 1;
+  }
+  return 0;
+}
+function copyTell(phrase) {
+  const text = `We found that ${phrase} was there.`;
+  const hit = checkCopy([{ path: "phrase.md", text }]).findings[0];
+  return hit ? hit.tell : null;
+}
+function formatHarvest(candidates, models) {
+  const lines = [`craft tells harvest: ${models.reduce((s, m) => s + m.runs.length, 0)} null pages from ${models.length} brief${models.length === 1 ? "" : "s"}`];
+  const fresh = candidates.filter((c) => !c.known);
+  const known = candidates.filter((c) => c.known);
+  const runs = models.flatMap((m) => m.runs);
+  const line = (c) => {
+    const swatch = c.kind === "accent" ? hueSwatch(runs, c.value) : null;
+    const where = models.length > 1 ? `, ${c.briefs} brief${c.briefs === 1 ? "" : "s"}` : "";
+    return `  ${c.kind.padEnd(8)} ${`${c.value}${swatch ? ` (${swatch})` : ""}`.padEnd(44)} ${c.runs} of ${c.of}${where}${c.known ? `  caught by ${c.known}` : ""}`;
+  };
+  lines.push("", "Not on the catalogue: candidates for the next generation. A person decides.");
+  lines.push(...fresh.length ? fresh.map(line) : ["  none"]);
+  lines.push("", "Already caught: the catalogue still describes what the model builds.");
+  lines.push(...known.length ? known.map(line) : ["  none"]);
+  return lines.join("\n");
+}
+function describeTypicality(t, pages, briefs) {
+  const pct = Math.round(t.score * 100);
+  return [
+    `Typicality against ${pages} null pages from ${briefs} brief${briefs === 1 ? "" : "s"}`,
+    `  score      ${t.score.toFixed(2)}: ${t.typical ? "typical" : "not typical"}. ${pct}% of the model's own pages sit further from the rest than this one.`,
+    `  distance   ${t.distance.toFixed(3)} to its nearest null pages; the null's own median is ${t.baseline.toFixed(3)}`,
+    `  nearest    ${t.nearest.map((n) => `${n.id} ${n.distance.toFixed(2)}`).join(", ")}`,
+    `  shares     ${t.shared.map((s) => `${s.part} ${s.value} (${s.runs} of ${s.of})`).join(", ") || "no choice with a quarter of the null"}`
+  ].join("\n");
+}
+async function runNull(args, io) {
+  try {
+    const flags = parseFlags(args);
+    if (typeof flags === "string") throw new Error(flags);
+    if (flags.positional[0] !== "build") throw new Error('usage: craft null build --brief "<text>" --out <dir> [--runs 20] [--parallel 4] [--model <name>]');
+    return await build(flags, io);
+  } catch (error) {
+    io.err(`craft: ${error.message}`);
+    return 2;
+  }
+}
+function runHarvest(args, io) {
+  const flags = parseFlags(args);
+  if (typeof flags === "string") throw new Error(flags);
+  const targets = flags.positional.slice(1);
+  if (targets.length === 0) throw new Error("usage: craft tells harvest <null.json | dir>... [--share 0.25] [--json]");
+  const paths = targets.flatMap((t) => {
+    const abs = resolve(io.cwd, t);
+    if (existsSync(abs) && statSync(abs).isDirectory() && !existsSync(join(abs, "null.json"))) {
+      return readdirSync(abs).map((d) => join(abs, d, "null.json")).filter((p) => existsSync(p));
+    }
+    return [t];
+  });
+  const models = paths.map((p) => loadNull(p, io.cwd));
+  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));
+  return 0;
+}
+
+export {
+  typicality,
+  hueName,
+  groundName,
+  shapeName,
+  nullPath,
+  loadNull,
+  measureRun,
+  formatHarvest,
+  describeTypicality,
+  runNull,
+  runHarvest
+};