@domandigital/craft 0.15.0 → 0.16.0

package/dist/{cli-FCKHYAVZ.js → chunk-NTIPJ5U7.js}

@@ -1,49 +1,3 @@
-import {
-  merge
-} from "./chunk-2IQ5OXFR.js";
-import "./chunk-OUQ25LY2.js";
-import "./chunk-JYNXGCYZ.js";
-import {
-  SIBLING_AT,
-  compareToEstate,
-  loadEstate
-} from "./chunk-QU6Q2QZZ.js";
-import {
-  PAGE_TYPES,
-  validateDirection
-} from "./chunk-YDURAOYR.js";
-import {
-  loadNull
-} from "./chunk-RXXRXV3V.js";
-import "./chunk-OQXTQQAU.js";
-import {
-  COPY_FILE,
-  NOT_COPY_DIR,
-  SOURCE_FILE,
-  applySeverity,
-  loadConfig,
-  loadExceptions,
-  parseFlags,
-  readPaths,
-  toJson
-} from "./chunk-MUVFECFC.js";
-import {
-  readSnapshot
-} from "./chunk-WUACK2HX.js";
-import {
-  CATALOGUE,
-  auditSnapshot,
-  checkCopy,
-  fingerprint,
-  scanSource,
-  typicality
-} from "./chunk-LFNSB6W7.js";
-import "./chunk-QYBAVU3P.js";
-
-// src/report/cli.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { dirname, resolve } from "path";
-
 // src/report/index.ts
 var TELL_HEAVY = 3;
 var MIN_DECIDED = 5;
@@ -199,144 +153,7 @@ function choiceOfShared(part) {
   return /running order/.test(part) ? void 0 : "motif";
 }
 
-// src/report/retrofit.ts
-var HEADINGS = {
-  direction: "Decide first",
-  type: "Type",
-  colour: "Colour",
-  shape: "Shape",
-  effects: "Effects",
-  motion: "Motion",
-  layout: "How sections look (not where they sit)",
-  copy: "Copy"
-};
-var ORDER = ["direction", "type", "colour", "shape", "effects", "motion", "layout", "copy"];
-function target(a, direction) {
-  if (!a.choice || a.area === "direction") return "";
-  const c = direction?.choices?.[a.choice];
-  if (c && c.because && !c.because.startsWith("PROPOSED:")) return `
-  - Use: **${c.value}** for ${a.choice}. ${c.because}`;
-  return `
-  - Waits on: deciding **${a.choice}** in art-direction.json.`;
-}
-function retrofitPlan(report, direction) {
-  const lines = [
-    `# Retrofit: ${report.site}`,
-    "",
-    `**Now:** ${report.verdict}. ${report.summary}`,
-    "",
-    "| Signal | Raised | Reading |",
-    "|---|---|---|",
-    ...report.signals.map((s) => `| ${s.id} | ${s.raised === null ? "not measured" : s.raised ? "yes" : "no"} | ${s.detail} |`),
-    "",
-    "**Done when** `craft report` says *decided*: fewer than three design tells, typicality under 0.10 against this brief's null, no sibling in the estate, and at least five of the seven choices decided with a reason.",
-    ""
-  ];
-  let n = 0;
-  for (const area of ORDER) {
-    const list = report.actions.filter((a) => a.area === area);
-    if (list.length === 0) continue;
-    n += 1;
-    lines.push(`## ${n}. ${HEADINGS[area]}`, "");
-    for (const a of list) lines.push(`- [ ] ${a.what} *(${a.why})*${target(a, direction)}`);
-    lines.push("");
-  }
-  if (n === 0) lines.push("Nothing to change.", "");
-  lines.push(
-    "## Leave alone",
-    "",
-    "Navigation, the order of the sections, where the call to action sits, reading order and legibility. Change the look, never the page grammar. A layout tell above is about how a section looks: the icon tiles, the chip, the strip. The section stays where it is.",
-    ""
-  );
-  return lines.join("\n");
-}
-
-// src/report/cli.ts
-var USAGE = "usage: craft report|retrofit <url | snapshot.json> [--repo <dir>] [--null <dir>] [--estate <estate.json>] [--direction <file>] [--json] [--out <file>]";
-var sameUrl = (a, b) => a.replace(/\/+$/, "").toLowerCase() === b.replace(/\/+$/, "").toLowerCase();
-function formatCharacter(r) {
-  const lines = [`craft report ${r.site}`, "", `Verdict: ${r.verdict.toUpperCase()}. ${r.summary}`, ""];
-  for (const s of r.signals) lines.push(`  ${s.id.padEnd(11)} ${s.raised === null ? "\xB7" : s.raised ? "RAISED" : "ok"}  ${s.detail}`);
-  lines.push("", "What to do, in order:");
-  r.actions.slice(0, 12).forEach((a, i) => lines.push(`  ${String(i + 1).padStart(2)}. [${a.area}] ${a.what}`, `      ${a.why}`));
-  if (r.actions.length > 12) lines.push(`  ...and ${r.actions.length - 12} more: craft retrofit writes them all.`);
-  return lines.join("\n");
-}
-async function runReport(command, args, io) {
-  try {
-    const flags = parseFlags(args);
-    if (typeof flags === "string") throw new Error(flags);
-    const target2 = flags.positional[0];
-    if (!target2) throw new Error(USAGE);
-    const page = flags.page ?? "home";
-    if (!PAGE_TYPES.includes(page)) throw new Error(`--page takes one of ${PAGE_TYPES.join(", ")}`);
-    const local = resolve(io.cwd, target2);
-    let snap;
-    if (/\.json$/i.test(target2) && existsSync(local)) {
-      snap = readSnapshot(JSON.parse(readFileSync(local, "utf8")), target2);
-    } else {
-      const { snapshotUrl } = await import("./audit-MTUC24XU.js");
-      snap = await snapshotUrl(target2);
-    }
-    const fp = fingerprint(snap);
-    const repo = flags.repo ? resolve(io.cwd, flags.repo) : null;
-    const exceptions = loadExceptions(flags, repo ?? io.cwd);
-    const config = loadConfig(flags, repo ?? io.cwd);
-    let findings = auditSnapshot(snap, { exceptions });
-    if (repo) {
-      findings = merge(scanSource(readPaths(["."], repo, SOURCE_FILE, void 0, config.ignore), { exceptions }), findings);
-      const copyPaths = config.copyPaths ?? ["."];
-      findings = merge(findings, checkCopy(readPaths(copyPaths, repo, COPY_FILE, (d) => NOT_COPY_DIR(d) || d === "docs", config.ignore), { exceptions }));
-    }
-    findings = applySeverity(findings, config);
-    const nulls = flags.null ? flags.null.split(",").map((p) => loadNull(p.trim(), io.cwd)) : [];
-    const typical = nulls.length ? typicality(fp, nulls.flatMap((m, i) => m.runs.map((r) => nulls.length > 1 ? { ...r, id: `${i + 1}/${r.id}` } : r))) : null;
-    let estate = null;
-    if (flags.estate) {
-      const register = loadEstate(resolve(io.cwd, flags.estate));
-      const self = register.sites.find((s) => sameUrl(s.url, snap.url));
-      estate = compareToEstate(fp, register, { exclude: self?.id, siblingAt: SIBLING_AT });
-    }
-    const directionFile = resolve(repo ?? io.cwd, flags.direction ?? "art-direction.json");
-    let direction = null;
-    let directionReport = null;
-    if (existsSync(directionFile)) {
-      direction = JSON.parse(readFileSync(directionFile, "utf8"));
-      directionReport = validateDirection(direction, {
-        fingerprint: fp,
-        snapshot: snap,
-        page,
-        strict: flags.strict,
-        pathExists: (p) => existsSync(resolve(dirname(directionFile), p)),
-        readSource: (s) => {
-          if (!s.path || /^https?:/.test(s.path) || !/\.(?:txt|md|markdown|csv|json|html?)$/i.test(s.path)) return void 0;
-          const path = resolve(dirname(directionFile), s.path);
-          return existsSync(path) ? readFileSync(path, "utf8") : void 0;
-        }
-      });
-    } else if (flags.direction) {
-      throw new Error(`no such file: ${flags.direction}`);
-    }
-    const copyTells = new Set(CATALOGUE.filter((t) => t.surface === "copy").map((t) => t.id));
-    const report = characterReport({ site: snap.url, findings, typicality: typical, estate, direction: directionReport }, copyTells);
-    if (command === "retrofit") {
-      const plan = retrofitPlan(report, direction);
-      if (flags.out) {
-        writeFileSync(resolve(io.cwd, flags.out), plan);
-        io.out(`craft retrofit: ${report.actions.length} step${report.actions.length === 1 ? "" : "s"} for ${snap.url} in ${flags.out}`);
-      } else io.out(plan);
-      return 0;
-    }
-    io.out(flags.json ? toJson(report) : formatCharacter(report));
-    if (flags.out) writeFileSync(resolve(io.cwd, flags.out), `${toJson(report)}
-`);
-    return flags.strict && report.verdict !== "decided" ? 1 : 0;
-  } catch (error) {
-    io.err(`craft: ${error.message}`);
-    return 2;
-  }
-}
 export {
-  formatCharacter,
-  runReport
+  TELL_HEAVY,
+  characterReport
 };

package/dist/{chunk-2IQ5OXFR.js → chunk-TQKDCA4V.js}

@@ -1,11 +1,11 @@
 import {
   snapshotUrl,
   snapshotUrls
-} from "./chunk-OUQ25LY2.js";
+} from "./chunk-YK2FFL6Z.js";
 import {
   describeTypicality,
   loadNull
-} from "./chunk-RXXRXV3V.js";
+} from "./chunk-LWVGIJ5A.js";
 import {
   SOURCE_FILE,
   finish,
@@ -15,7 +15,7 @@ import {
   prepareReport,
   readPaths,
   toJson
-} from "./chunk-MUVFECFC.js";
+} from "./chunk-LXDNIJFG.js";
 import {
   readSnapshot
 } from "./chunk-WUACK2HX.js";
@@ -25,7 +25,7 @@ import {
   fingerprint,
   scanSource,
   typicality
-} from "./chunk-LFNSB6W7.js";
+} from "./chunk-B2MJLGF6.js";
 
 // src/audit/cli.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-YDURAOYR.js → chunk-WAV6AKR4.js}

@@ -11,7 +11,7 @@ import {
   levenshtein,
   normaliseFamily,
   parseColour
-} from "./chunk-LFNSB6W7.js";
+} from "./chunk-B2MJLGF6.js";
 
 // src/direction/types.ts
 var DIRECTION_VERSION = 2;

package/dist/{chunk-OUQ25LY2.js → chunk-YK2FFL6Z.js}

@@ -4,7 +4,7 @@ import {
 import {
   auditSnapshot,
   fingerprint
-} from "./chunk-LFNSB6W7.js";
+} from "./chunk-B2MJLGF6.js";
 import {
   SNAPSHOT_VERSION
 } from "./chunk-QYBAVU3P.js";

package/dist/cli-3GQROFCB.js

@@ -0,0 +1,241 @@
+import {
+  TELL_HEAVY
+} from "./chunk-NTIPJ5U7.js";
+import {
+  expandNullTargets,
+  loadNull
+} from "./chunk-LWVGIJ5A.js";
+import "./chunk-OQXTQQAU.js";
+import {
+  parseFlags,
+  toJson
+} from "./chunk-LXDNIJFG.js";
+import {
+  readSnapshot
+} from "./chunk-WUACK2HX.js";
+import {
+  CATALOGUE,
+  auditSnapshot,
+  fingerprint,
+  scanSource,
+  typicality
+} from "./chunk-B2MJLGF6.js";
+import {
+  SNAPSHOT_VERSION
+} from "./chunk-QYBAVU3P.js";
+
+// src/calibrate/cli.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, relative, resolve } from "path";
+import { pathToFileURL } from "url";
+
+// src/calibrate/index.ts
+var LABELS = ["ai", "ai-looking", "human"];
+var FLAGGED_TARGET = 0.9;
+var HUMAN_TYPICAL_TARGET = 0.1;
+var SURFACE = new Map(CATALOGUE.map((t) => [t.id, t.surface]));
+function designTells(tells) {
+  return tells.filter((t) => SURFACE.has(t) && SURFACE.get(t) !== "copy");
+}
+function isFlagged(page) {
+  return Boolean(page.typicality?.typical) || designTells(page.tells).length >= TELL_HEAVY;
+}
+var positive = (label) => label !== "human";
+var round = (n) => Math.round(n * 100) / 100;
+var share = (n, of) => `${n} of ${of} (${Math.round(100 * n / of)}%)`;
+function summarise(label, pages, typicality2) {
+  const mine = pages.filter((p) => p.label === label);
+  return {
+    label,
+    pages: mine.length,
+    // A set measured partly against the null would count the same page two ways.
+    flagged: mine.filter((p) => typicality2 ? isFlagged(p) : designTells(p.tells).length >= TELL_HEAVY).length,
+    typical: typicality2 ? mine.filter((p) => p.typicality?.typical).length : null,
+    tellHeavy: mine.filter((p) => designTells(p.tells).length >= TELL_HEAVY).length,
+    blocking: mine.reduce((s, p) => s + p.blocking, 0)
+  };
+}
+function flaggedTarget(target, s, missing) {
+  const note = missing ? `; ${missing} not measured, counted neither way` : "";
+  if (s.pages === 0) return { target, met: null, detail: `no page measured${note}` };
+  return { target, met: s.flagged / s.pages >= FLAGGED_TARGET, detail: `${share(s.flagged, s.pages)} flagged, target ${FLAGGED_TARGET * 100}% or more${note}` };
+}
+function calibrate(pages, unmeasured = []) {
+  const typicality2 = pages.length > 0 && pages.every((p) => p.typicality !== void 0);
+  const labels = LABELS.map((l) => summarise(l, pages, typicality2));
+  const byLabel = Object.fromEntries(labels.map((s) => [s.label, s]));
+  const missing = (l) => unmeasured.filter((u) => u.label === l).length;
+  const positives = pages.filter((p) => positive(p.label)).length;
+  const fired = new Set(pages.flatMap((p) => p.tells));
+  const tells = [...fired].map((tell) => {
+    const hits = Object.fromEntries(LABELS.map((l) => [l, pages.filter((p) => p.label === l && p.tells.includes(tell)).length]));
+    const on = hits.ai + hits["ai-looking"];
+    return { tell, hits, precision: round(on / (on + hits.human)), recall: positives ? round(on / positives) : null };
+  }).sort((a, b) => b.hits.ai + b.hits["ai-looking"] + b.hits.human - (a.hits.ai + a.hits["ai-looking"] + a.hits.human) || a.tell.localeCompare(b.tell));
+  const human = byLabel.human;
+  const humanNote = missing("human") ? `; ${missing("human")} not measured, counted neither way` : "";
+  const targets = [
+    flaggedTarget("1. Generated pages get caught", byLabel.ai, missing("ai")),
+    human.pages === 0 ? { target: "2. Good human sites don't get caught", met: null, detail: `no page measured${humanNote}` } : {
+      target: "2. Good human sites don't get caught",
+      // A block hit fails it outright; without null models the other half is not known.
+      met: human.blocking > 0 ? false : human.typical === null ? null : human.typical / human.pages <= HUMAN_TYPICAL_TARGET,
+      detail: `${human.blocking} block hits, target 0; ${human.typical === null ? "typicality not measured (no null models)" : `${share(human.typical, human.pages)} typical, target ${HUMAN_TYPICAL_TARGET * 100}% or fewer`}${humanNote}`
+    },
+    flaggedTarget("3. Sites a person labelled AI-looking get caught", byLabel["ai-looking"], missing("ai-looking"))
+  ];
+  return {
+    pages: pages.length,
+    typicality: typicality2,
+    labels,
+    tells,
+    silent: CATALOGUE.map((t) => t.id).filter((id) => !fired.has(id)),
+    targets,
+    unmeasured
+  };
+}
+function formatCalibration(c, notes = []) {
+  const counts = c.labels.map((s) => `${s.pages} ${s.label}`).join(", ");
+  const lines = [`craft calibrate: ${c.pages} pages measured (${counts})`, ...notes];
+  if (!c.typicality) lines.push("No null models: flagged means tell-heavy only.");
+  if (c.unmeasured.length) {
+    lines.push("", `Not measured: ${c.unmeasured.length}. A page not measured never counts as a pass.`);
+    for (const u of c.unmeasured) lines.push(`  ${u.id} (${u.label}): ${u.reason}`);
+  }
+  lines.push("", "Targets");
+  for (const t of c.targets) lines.push(`  ${t.target.padEnd(50)} ${t.met === null ? "not known" : t.met ? "met" : "NOT MET"}`, `    ${t.detail}`);
+  lines.push("", `  ${"label".padEnd(11)} ${"pages".padStart(5)} ${"flagged".padStart(8)} ${"typical".padStart(8)} ${"tell-heavy".padStart(11)} ${"blocking".padStart(9)}`);
+  for (const s of c.labels) {
+    lines.push(`  ${s.label.padEnd(11)} ${String(s.pages).padStart(5)} ${String(s.flagged).padStart(8)} ${String(s.typical ?? "-").padStart(8)} ${String(s.tellHeavy).padStart(11)} ${String(s.blocking).padStart(9)}`);
+  }
+  lines.push("", "Per tell. A hit on ai or ai-looking counts for the tell; a hit on human counts against it.");
+  lines.push(`  ${"tell".padEnd(28)} ${"ai".padStart(7)} ${"ai-looking".padStart(10)} ${"human".padStart(7)} ${"precision".padStart(9)} ${"recall".padStart(7)}`);
+  const of = (l) => c.labels.find((s) => s.label === l)?.pages ?? 0;
+  for (const t of c.tells) {
+    lines.push(
+      `  ${t.tell.padEnd(28)} ${`${t.hits.ai}/${of("ai")}`.padStart(7)} ${`${t.hits["ai-looking"]}/${of("ai-looking")}`.padStart(10)} ${`${t.hits.human}/${of("human")}`.padStart(7)} ${t.precision.toFixed(2).padStart(9)} ${(t.recall === null ? "-" : t.recall.toFixed(2)).padStart(7)}`
+    );
+  }
+  if (!c.tells.length) lines.push("  no tell fired");
+  lines.push("", `Never fired on this set: ${c.silent.length} of ${CATALOGUE.length} catalogue tells.`);
+  return lines.join("\n");
+}
+
+// src/calibrate/cli.ts
+var LABELS_VERSION = 1;
+var USAGE = "usage: craft calibrate <labels.json> [--out <dir>] [--fresh] [--json]";
+function parseLabels(raw, name) {
+  const file = raw;
+  if (!file || typeof file !== "object" || file.version !== LABELS_VERSION) throw new Error(`${name}: needs "version": ${LABELS_VERSION}`);
+  if (!Array.isArray(file.pages) || file.pages.length === 0) throw new Error(`${name}: "pages" needs at least one page`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const [i, p] of file.pages.entries()) {
+    const at = `${name}: pages[${i}]`;
+    if (typeof p?.id !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(p.id)) throw new Error(`${at}: "id" needs lower case, digits and hyphens`);
+    if (seen.has(p.id)) throw new Error(`${at}: "${p.id}" is listed twice`);
+    seen.add(p.id);
+    if (!LABELS.includes(p.label)) throw new Error(`${at} (${p.id}): "label" is one of ${LABELS.join(", ")}`);
+    if (!p.skip && !p.snapshot && !p.source && !p.url) throw new Error(`${at} (${p.id}): needs a snapshot, a source or a url, or a skip saying why not`);
+  }
+  if (file.null !== void 0 && (!Array.isArray(file.null) || file.null.some((n) => typeof n !== "string"))) throw new Error(`${name}: "null" is a list of paths`);
+  return file;
+}
+var readJson = (path) => JSON.parse(readFileSync(path, "utf8"));
+async function runCalibrate(args, io) {
+  try {
+    const flags = parseFlags(args);
+    if (typeof flags === "string") throw new Error(flags);
+    const [target] = flags.positional;
+    if (!target || flags.positional.length > 1) throw new Error(USAGE);
+    const path = resolve(io.cwd, target);
+    if (!existsSync(path)) throw new Error(`no labels file at ${target}`);
+    const labels = parseLabels(readJson(path), target);
+    const base = dirname(path);
+    const out = flags.out ? resolve(io.cwd, flags.out) : void 0;
+    const models = expandNullTargets(labels.null ?? [], base).map((p) => loadNull(p, base));
+    const pool = models.flatMap((m, i) => m.runs.map((r) => ({ ...r, id: `${i}/${r.id}` })));
+    const snapshots = /* @__PURE__ */ new Map();
+    const unmeasured = [];
+    const toTake = [];
+    for (const entry of labels.pages) {
+      if (entry.skip) {
+        unmeasured.push({ id: entry.id, label: entry.label, reason: entry.skip });
+        continue;
+      }
+      const pinned = entry.snapshot ? resolve(base, entry.snapshot) : void 0;
+      if (pinned && existsSync(pinned) && !flags.fresh) {
+        snapshots.set(entry.id, readSnapshot(readJson(pinned), entry.snapshot ?? entry.id));
+        continue;
+      }
+      const cached = out ? join(out, "snapshots", `${entry.id}.json`) : void 0;
+      if (cached && existsSync(cached)) {
+        snapshots.set(entry.id, readSnapshot(readJson(cached), `${entry.id}.json`));
+        continue;
+      }
+      const url = entry.source ? pathToFileURL(resolve(base, entry.source)).href : entry.url;
+      if (!url) {
+        const why = flags.fresh ? "--fresh" : `no snapshot at ${entry.snapshot}`;
+        unmeasured.push({ id: entry.id, label: entry.label, reason: `${why}, and no source or url to take one from` });
+        continue;
+      }
+      toTake.push({ entry, url, keep: flags.fresh ? cached : pinned ?? cached });
+    }
+    if (toTake.length) {
+      io.err(`craft calibrate: taking ${toTake.length} snapshot${toTake.length === 1 ? "" : "s"}`);
+      try {
+        const { snapshotUrls } = await import("./audit-UJCUWORL.js");
+        const results = await snapshotUrls(toTake.map((t) => t.url));
+        results.forEach((r, i) => {
+          const { entry, keep } = toTake[i];
+          if (!r.snapshot) return void unmeasured.push({ id: entry.id, label: entry.label, reason: `would not render: ${r.error}` });
+          snapshots.set(entry.id, r.snapshot);
+          if (keep) {
+            mkdirSync(dirname(keep), { recursive: true });
+            writeFileSync(keep, `${JSON.stringify(r.snapshot, null, 2)}
+`);
+          }
+        });
+      } catch (error) {
+        for (const { entry } of toTake) unmeasured.push({ id: entry.id, label: entry.label, reason: `no browser: ${error.message}` });
+      }
+    }
+    const measured = labels.pages.filter((e) => snapshots.has(e.id)).map((entry) => {
+      const snap = snapshots.get(entry.id);
+      const rendered = auditSnapshot(snap);
+      const source = entry.source && existsSync(resolve(base, entry.source)) ? scanSource([{ path: entry.source, text: readFileSync(resolve(base, entry.source), "utf8") }]) : void 0;
+      const tells = new Set([...rendered.findings, ...source?.findings ?? []].map((f) => f.tell));
+      const t = pool.length ? typicality(fingerprint(snap), pool) : void 0;
+      return {
+        id: entry.id,
+        label: entry.label,
+        tells: [...tells].sort(),
+        blocking: rendered.summary.blocking + (source?.summary.blocking ?? 0),
+        ...t ? { typicality: { score: t.score, typical: t.typical } } : {}
+      };
+    });
+    const result = calibrate(measured, unmeasured);
+    const older = [...snapshots.values()].filter((s) => s.migratedFrom !== void 0).length;
+    const notes = [
+      ...models.length ? [`Typicality against ${pool.length} null pages from ${models.length} brief${models.length === 1 ? "" : "s"}, pooled.`] : [],
+      ...older ? [`${older} of ${snapshots.size} snapshots are older than version ${SNAPSHOT_VERSION}: tells that read newer fields cannot fire on them. --fresh takes them again.`] : []
+    ];
+    const pages = Object.fromEntries(measured.map((m) => [m.id, m]));
+    if (out) {
+      mkdirSync(out, { recursive: true });
+      writeFileSync(join(out, "results.json"), `${toJson({ labelsFile: relative(out, path), notes, ...result, pages })}
+`);
+    }
+    io.out(flags.json ? toJson({ notes, ...result, pages }) : formatCalibration(result, notes));
+    if (out && !flags.json) io.out(`
+Written to ${relative(io.cwd, join(out, "results.json")) || "results.json"}`);
+    return 0;
+  } catch (error) {
+    io.err(`craft: ${error.message}`);
+    return 2;
+  }
+}
+export {
+  LABELS_VERSION,
+  parseLabels,
+  runCalibrate
+};

package/dist/{cli-5ACKICBO.js → cli-52M62QBN.js}

@@ -4,14 +4,14 @@ import {
   merge,
   resolvePages,
   runAudit
-} from "./chunk-2IQ5OXFR.js";
-import "./chunk-OUQ25LY2.js";
+} from "./chunk-TQKDCA4V.js";
+import "./chunk-YK2FFL6Z.js";
 import "./chunk-JYNXGCYZ.js";
-import "./chunk-RXXRXV3V.js";
+import "./chunk-LWVGIJ5A.js";
 import "./chunk-OQXTQQAU.js";
-import "./chunk-MUVFECFC.js";
+import "./chunk-LXDNIJFG.js";
 import "./chunk-WUACK2HX.js";
-import "./chunk-LFNSB6W7.js";
+import "./chunk-B2MJLGF6.js";
 import "./chunk-QYBAVU3P.js";
 export {
   describeComponents,

package/dist/{cli-FLG3ZCAF.js → cli-AVYNHBFJ.js}

@@ -1,23 +1,29 @@
 import {
   describeTypicality,
+  expandNullTargets,
+  findImportPages,
   formatHarvest,
   loadNull,
   measureRun,
   nullPath,
   runHarvest,
-  runNull
-} from "./chunk-RXXRXV3V.js";
+  runNull,
+  serveDir
+} from "./chunk-LWVGIJ5A.js";
 import "./chunk-OQXTQQAU.js";
-import "./chunk-MUVFECFC.js";
+import "./chunk-LXDNIJFG.js";
 import "./chunk-WUACK2HX.js";
-import "./chunk-LFNSB6W7.js";
+import "./chunk-B2MJLGF6.js";
 import "./chunk-QYBAVU3P.js";
 export {
   describeTypicality,
+  expandNullTargets,
+  findImportPages,
   formatHarvest,
   loadNull,
   measureRun,
   nullPath,
   runHarvest,
-  runNull
+  runNull,
+  serveDir
 };