@domandigital/craft 0.13.0 → 0.15.0

package/dist/chunk-YDURAOYR.js

@@ -0,0 +1,711 @@
+import {
+  ACCENT_SHARED,
+  GROUND_SHARED,
+  REFLEX_FONTS_1,
+  REFLEX_FONTS_2,
+  SHARED_PART,
+  TRADE_NOUNS,
+  deltaEOk,
+  isAiViolet,
+  isCream,
+  levenshtein,
+  normaliseFamily,
+  parseColour
+} from "./chunk-LFNSB6W7.js";
+
+// src/direction/types.ts
+var DIRECTION_VERSION = 2;
+var DIRECTION_VERSIONS = [1, 2];
+var CUSTOMER_KINDS = ["review", "enquiry", "conversation", "search"];
+var SOURCE_KINDS = [
+  "livery",
+  "shopfront",
+  "signage",
+  "packaging",
+  "product",
+  "uniform",
+  "interior",
+  "place",
+  "material",
+  "trade",
+  "print",
+  "photo",
+  "founder",
+  ...CUSTOMER_KINDS,
+  "reference"
+];
+var CHOICE_KEYS = ["accent", "ground", "display", "body", "shape", "motif", "signature"];
+var CONSIDERATION = ["low", "considered", "high"];
+var PAGE_TYPES = ["home", "service", "about", "pricing", "booking", "contact", "article", "landing"];
+var HIERARCHY_FIELDS = ["primaryAction", "order", "lead", "journey"];
+
+// src/direction/research.ts
+function tradeOf(brief) {
+  const text = brief.toLowerCase();
+  return TRADE_NOUNS.filter((t) => new RegExp(`\\b${t.replace(/ /g, "\\s+")}s?\\b`).test(text));
+}
+function categoryMatchesBrief(category, brief) {
+  const known = tradeOf(category);
+  if (tradeOf(brief).some((t) => known.includes(t))) return true;
+  const label = category.trim().replace(/^(?:(?:a|an|the|local|independent)\s+)+/i, "");
+  if (!label) return false;
+  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, "\\s+");
+  return new RegExp(`\\b${escaped}s?\\b`, "i").test(brief);
+}
+function researchPrompt(input) {
+  const trade = tradeOf(input.brief);
+  const category = trade.length ? trade.join(", ") : "this kind of business";
+  const who = input.client ? `${input.client}: ${input.brief}` : input.brief;
+  const lines = [
+    "# Research brief: the customer's job",
+    "",
+    `The business: ${who}`,
+    "",
+    "Find out about the people who hire a business like this, not about the businesses. Answer each question with sources: reviews, forum threads, Q&A sites, complaints, search suggestions. Quote people's own words and link to where they said them.",
+    "",
+    "1. **The situation.** What has just happened, or is about to, when someone starts looking? What pressure are they under: time, money, safety, someone else waiting on them?",
+    '2. **The job.** What are they trying to get done, in one sentence that starts with a verb? What would "done" look like to them?',
+    "3. **Objections.** What do they worry about before getting in touch? What has gone wrong for them, or people they know, before?",
+    "4. **Their words.** The phrases they actually use for the problem and for what they want. Quote them exactly.",
+    "5. **Who else is involved.** Who do they have to explain or justify the choice to (a partner, a landlord, a tenant, a manager), and what would make them look good or bad to that person?",
+    "6. **Consideration.** Do they decide in minutes, days or months? What do they compare before deciding?",
+    "7. **Where they look.** What do they search for, and where do they ask?",
+    "",
+    "## Do not",
+    "",
+    `- Do not describe, list, rank or summarise what ${category} websites look like, or how they are laid out.`,
+    '- Do not suggest colours, fonts, layouts, sections or visual "inspiration" from this category.',
+    "- Do not summarise competitors' marketing. Their claims are the category average; the customer's words are the point.",
+    "- Do not invent quotes. If you cannot find a source for something, say so."
+  ];
+  if (input.visual) {
+    lines.push(
+      "",
+      "# Visual references, from outside the category",
+      "",
+      `Separately, and only from outside ${category}: find things this business already resembles or shares a world with. Print, signage, packaging, tools, vehicles, uniforms, places, materials, other trades and crafts. For each, say what it is, where it is from, and what about it could carry over.`,
+      "",
+      `Nothing from a ${category} website, and nothing from a web design gallery.`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/estate/direction.ts
+function summariseDirection(d) {
+  const c = d.choices ?? {};
+  const home = d.hierarchy?.home;
+  const s = {};
+  if (typeof c.accent?.value === "string" && c.accent.value) s.accent = c.accent.value;
+  if (typeof c.ground?.value === "string" && c.ground.value) s.ground = c.ground.value;
+  if (typeof c.display?.value === "string" && c.display.value) s.display = normaliseFamily(c.display.value);
+  if (typeof c.body?.value === "string" && c.body.value) s.body = normaliseFamily(c.body.value);
+  if (typeof c.shape?.value === "string" && c.shape.value) s.shape = c.shape.value;
+  if (Array.isArray(home?.order) && home.order.length) s.order = home.order.filter((o) => o && typeof o.role === "string").map((o) => o.role);
+  if (typeof home?.primaryAction?.value === "string" && home.primaryAction.value) {
+    s.primaryAction = home.primaryAction.value;
+    s.positions = Array.isArray(home.primaryAction.positions) ? [...home.primaryAction.positions] : [];
+  }
+  return s;
+}
+var delta = (a, b) => {
+  const x = a ? parseColour(a) : null;
+  const y = b ? parseColour(b) : null;
+  return x && y ? deltaEOk(x.oklch, y.oklch) : null;
+};
+var same = (a, b) => Boolean(a && b && a.trim().toLowerCase() === b.trim().toLowerCase());
+function compareDirections(a, b) {
+  const shared = [];
+  const accentDelta = delta(a.accent, b.accent);
+  const groundDelta = delta(a.ground, b.ground);
+  if (accentDelta !== null && accentDelta <= ACCENT_SHARED) shared.push(`accent (\u0394E ${accentDelta.toFixed(3)})`);
+  if (groundDelta !== null && groundDelta <= GROUND_SHARED) shared.push(`ground (\u0394E ${groundDelta.toFixed(3)})`);
+  if (a.display && b.display && same(normaliseFamily(a.display), normaliseFamily(b.display))) shared.push(`${normaliseFamily(a.display)} headline`);
+  if (a.body && b.body && same(normaliseFamily(a.body), normaliseFamily(b.body))) shared.push(`${normaliseFamily(a.body)} body`);
+  if (same(a.shape, b.shape)) shared.push(`shape "${a.shape}"`);
+  let orderDistance = null;
+  if (a.order?.length && b.order?.length) {
+    orderDistance = levenshtein(a.order, b.order) / Math.max(a.order.length, b.order.length);
+    if (orderDistance <= SHARED_PART) shared.push(orderDistance === 0 ? "the same section order" : "nearly the same section order");
+  }
+  if (same(a.primaryAction, b.primaryAction) && [...a.positions ?? []].sort().join(",") === [...b.positions ?? []].sort().join(",")) shared.push(`"${a.primaryAction}" asked in the same places`);
+  const surface = shared.filter((s) => /^(?:accent|ground|shape)|headline$/.test(s)).length;
+  const flagged = surface >= 2 || orderDistance !== null && orderDistance <= SHARED_PART;
+  return { shared, accentDelta, groundDelta, orderDistance, flagged };
+}
+function compareToDeclared(target, sites, exclude) {
+  return sites.filter((s) => s.direction && s.id !== exclude).map((s) => ({ id: s.id, ...compareDirections(target, s.direction) })).sort((x, y) => y.shared.length - x.shared.length || (x.accentDelta ?? 1) - (y.accentDelta ?? 1));
+}
+function formatDirectionMatches(label, matches) {
+  const lines = [`${label}: declared directions in the estate (ranked, not judged: no sibling line yet)`];
+  for (const m of matches) lines.push(`  ${m.id.padEnd(20)} ${m.flagged ? "LOOK  " : "      "}${m.shared.length ? `shares ${m.shared.join(", ")}` : "nothing shared"}`);
+  if (matches.length === 0) lines.push("  no site in the register has a declared direction yet: craft estate add --direction <file>");
+  return lines.join("\n");
+}
+
+// src/direction/reason.ts
+var PROPOSED = "PROPOSED:";
+var PREFERENCE = /\b(?:client (?:likes|liked|wants|wanted|asked|chose|prefers?)|(?:we|they|i) (?:like|liked|love|loved|prefer)|on[- ]trend|trendy|popular|brand (?:colou?r|font|guidelines?) (?:is|are|says?))\b/i;
+var MOOD = /\b(?:modern|clean|fresh|professional|trustworthy|premium|elegant|sleek|timeless|minimal(?:ist)?|bold|vibrant|friendly|approachable|luxur(?:y|ious)|sophisticated|contemporary|stylish|warm|inviting|high[- ]end)\b/gi;
+var CONVENTION = new RegExp(
+  [
+    // authority
+    String.raw`industry[- ]standard`,
+    String.raw`best[- ]practices?`,
+    String.raw`the norm\b`,
+    String.raw`standard (?:layout|structure|practice|pattern|format)`,
+    String.raw`tried[- ]and[- ]tested`,
+    String.raw`proven (?:layout|structure|pattern|format)`,
+    // the crowd
+    String.raw`(?:most|other|typical|many|all|similar)\s+(?:\w+\s+){0,2}(?:web)?sites\b`,
+    String.raw`competitors?(?:'|’)?s?\b`,
+    String.raw`(?:like|as) (?:everyone|everybody|all the others|the rest)\b`,
+    String.raw`commonly used`,
+    String.raw`(?:what|how) (?:everyone|others|the industry) (?:does|do|uses?)`,
+    // familiarity
+    String.raw`familiar (?:layout|structure|pattern|format|order|shape|design)`,
+    String.raw`recogni[sz]able (?:layout|structure|pattern|format|order)`,
+    String.raw`conventional(?:ly)?\b`,
+    String.raw`(?:visitors|users|people|customers|anyone) (?:are|is) used to`,
+    String.raw`feels? (?:at home|comfortable|familiar)(?: with)?(?: the)? (?:layout|site|page|structure|design)?`,
+    String.raw`intuitive(?:ly)?\b`,
+    String.raw`as usual\b`,
+    String.raw`what (?:visitors|users|people) expect\b`
+  ].join("|"),
+  "i"
+);
+var GENERIC = new Set(
+  "customer customers visitor visitors client clients people person someone business businesses service services website site page pages want wants need needs help first before after know feel time work good right sure make find look looking trust reason reasons thing things just really very able also".split(" ")
+);
+var STOP = /* @__PURE__ */ new Set(["with", "that", "this", "from", "their", "they", "have", "been", "were", "which", "what", "when", "where", "there", "about", "into", "onto", "over", "same", "each", "every", "your", "them", "then", "than", "will", "would", "could", "should", "because", "so", "the", "and"]);
+var VALUE_WORDS = /* @__PURE__ */ new Set(["green", "blue", "navy", "black", "white", "cream", "grey", "gray", "gold", "yellow", "orange", "purple", "violet", "pink", "brown", "teal", "bottle", "dark", "light", "deep", "pale", "bright", "colour", "color", "font", "face", "serif", "sans", "type", "lettering"]);
+function contentWords(text) {
+  return new Set(
+    (text.toLowerCase().match(/[a-z][a-z'’-]{3,}/g) ?? []).map((w) => w.replace(/['’]s$/, "").replace(/['’]/g, "")).filter((w) => !STOP.has(w) && !VALUE_WORDS.has(w) && !GENERIC.has(w))
+  );
+}
+var stem = (w) => w.replace(/(?:ing|ers|er|ed|es|s)$/, "");
+function shares(a, b) {
+  const bs = new Set([...b].map(stem));
+  return [...a].filter((w) => bs.has(stem(w)));
+}
+function jobWords(job) {
+  return contentWords(
+    [
+      job.statement?.verb,
+      job.statement?.object,
+      job.statement?.context,
+      job.functional?.value,
+      job.emotional?.value,
+      job.social?.value,
+      ...Array.isArray(job.objections) ? job.objections : [],
+      ...Array.isArray(job.language) ? job.language : []
+    ].filter((x) => typeof x === "string").join(" ")
+  );
+}
+var isCustomerVoice = (s) => Boolean(s && CUSTOMER_KINDS.includes(s.kind));
+function checkReason(input) {
+  const problems = [];
+  const err = (field, message) => problems.push({ severity: "error", at: `${input.at}.${field}`, message });
+  const because = typeof input.because === "string" ? input.because.trim() : "";
+  const evidence = Array.isArray(input.evidence) ? input.evidence.filter((e) => typeof e === "string") : [];
+  if (input.evidence !== void 0 && (!Array.isArray(input.evidence) || input.evidence.some((e) => typeof e !== "string"))) err("evidence", "evidence must be a list of source ids");
+  const ids = new Map(input.sources.filter((s) => s && typeof s.id === "string").map((s) => [s.id, s]));
+  if (because.split(/\s+/).filter(Boolean).length < 8) {
+    err("because", "a reason is at least a sentence. Without one this is a default, however good it looks.");
+    return problems;
+  }
+  if (because.startsWith(PROPOSED)) {
+    err("because", "a proposal, not yet a decision. Check it against the source, then rewrite the reason in your own words.");
+    return problems;
+  }
+  if (PREFERENCE.test(because)) err("because", "that is a preference, not a reason. Say what in the client's world this comes from.");
+  const moods = because.match(MOOD) ?? [];
+  if (moods.length >= 2) err("because", `"${moods.join(", ")}" describes a mood, not a source. Name the thing it comes from.`);
+  const convention = because.match(CONVENTION);
+  if (convention) {
+    err("because", `"${convention[0]}" is the category's default speaking, not a reason. Say what in this client's job or world it answers.`);
+  }
+  const needsEvidence = input.tie !== "job";
+  if (needsEvidence && evidence.length === 0) err("evidence", "cite at least one source");
+  for (const id of evidence) if (!ids.has(id)) err("evidence", `no source called "${id}"`);
+  if (input.tie === "customer") {
+    for (const id of evidence) {
+      if (ids.has(id) && !isCustomerVoice(ids.get(id))) err("evidence", `"${id}" is a ${ids.get(id).kind}. The job is evidenced by the customer's own words: ${CUSTOMER_KINDS.join(", ")}.`);
+    }
+  }
+  if (input.tie === "source") {
+    for (const id of evidence) {
+      if (isCustomerVoice(ids.get(id))) err("evidence", `"${id}" is customer voice. Token decisions need a physical source or an outside-category reference.`);
+    }
+  }
+  if (problems.length) return problems;
+  const words2 = contentWords(because);
+  if (input.tie === "job") {
+    if (!input.job) {
+      err("because", "a structural reason is checked against the job, and the file has no job map yet");
+    } else if (shares(words2, jobWords(input.job)).length === 0) {
+      err("because", "the reason does not use this client's job (its statement, objections or the customer's words). A reason that would fit any client's site is a default.");
+    }
+  } else {
+    const cited = evidence.map((id) => ids.get(id));
+    const tied = cited.some((s) => words2.has(s.id) || shares(words2, contentWords(`${s.note} ${s.lettering ?? ""}`)).length > 0);
+    if (!tied) err("because", `the reason does not mention what its evidence shows (${evidence.join(", ")}). Say what on it this comes from.`);
+  }
+  return problems;
+}
+
+// src/direction/hierarchy.ts
+var SECTION_ROLES = [
+  "hero",
+  "logos",
+  "stats",
+  "cards",
+  "marquee",
+  "text",
+  "other",
+  "cta-band",
+  "footer-cta",
+  "pricing",
+  "testimonials",
+  "faq",
+  "process",
+  "features",
+  "team",
+  "contact"
+];
+var POSITIONS = /* @__PURE__ */ new Set([...SECTION_ROLES, "header", "sticky"]);
+function considerationTied(because, job) {
+  const text = because.toLowerCase();
+  const level = job.consideration?.value;
+  if (level && new RegExp(`\\b${level}\\b`).test(text)) return true;
+  const said = contentWords(because);
+  return (Array.isArray(job.objections) ? job.objections : []).some((o) => typeof o === "string" && [...contentWords(o)].some((w) => said.has(w)));
+}
+function validateHierarchy(hierarchy, job, sources) {
+  const problems = [];
+  const err = (at, message) => problems.push({ severity: "error", at: `hierarchy${at}`, message });
+  const pages = [];
+  if (!hierarchy || typeof hierarchy !== "object" || Array.isArray(hierarchy)) {
+    err("", "no hierarchy: decide what the home page leads with, where it asks, and the order, each from the job");
+    return { problems, pages };
+  }
+  const h = hierarchy;
+  for (const key of Object.keys(h)) if (!PAGE_TYPES.includes(key)) err(`.${key}`, `not a page type craft knows. Page types are: ${PAGE_TYPES.join(", ")}`);
+  if (!h.home) err(".home", "no home page hierarchy: the home page is where most visitors start");
+  for (const page of PAGE_TYPES) {
+    const p = h[page];
+    if (!p) continue;
+    let decided = 0;
+    const at = (f) => `hierarchy.${page}.${f}`;
+    const reason = (where, because, evidence) => checkReason({ at: where, because, evidence, sources, tie: "job", job });
+    const count = (found) => {
+      problems.push(...found);
+      if (!found.some((x) => x.severity === "error")) decided += 1;
+    };
+    if (!p.primaryAction) err(`.${page}.primaryAction`, "not decided yet");
+    else {
+      const a = p.primaryAction;
+      const found = [];
+      if (typeof a.value !== "string" || !a.value.trim()) found.push({ severity: "error", at: `${at("primaryAction")}.value`, message: "what the visitor is asked to do" });
+      const positions = Array.isArray(a.positions) ? a.positions : [];
+      if (positions.length === 0) found.push({ severity: "error", at: `${at("primaryAction")}.positions`, message: 'where the ask sits: one place, or several ("hero", "footer-cta")' });
+      for (const pos of positions) if (!POSITIONS.has(pos)) found.push({ severity: "error", at: `${at("primaryAction")}.positions`, message: `"${pos}" is not a section role, "header" or "sticky"` });
+      const r = reason(at("primaryAction"), a.because, a.evidence);
+      found.push(...r);
+      if (r.length === 0 && job && typeof a.because === "string" && !considerationTied(a.because, job)) {
+        found.push({
+          severity: "error",
+          at: `${at("primaryAction")}.because`,
+          message: `say how the job's consideration (${job.consideration?.value ?? "not set"}) or one of its objections leads to asking here. Placement evidence is mixed, so the reason is what decides it.`
+        });
+      }
+      count(found);
+    }
+    const order = Array.isArray(p.order) ? p.order : [];
+    if (order.length < 2) err(`.${page}.order`, "the running order, two sections or more, each with why it sits there");
+    else {
+      const found = [];
+      order.forEach((o, i) => {
+        if (!o || !SECTION_ROLES.includes(o.role)) found.push({ severity: "error", at: `${at("order")}[${i}].role`, message: `a section role: ${SECTION_ROLES.join(", ")}` });
+        found.push(...reason(`${at("order")}[${i}]`, o?.because));
+      });
+      count(found);
+    }
+    if (!p.lead) err(`.${page}.lead`, "not decided yet");
+    else {
+      const found = [];
+      if (typeof p.lead.value !== "string" || !p.lead.value.trim()) found.push({ severity: "error", at: `${at("lead")}.value`, message: "what the page leads with" });
+      found.push(...reason(at("lead"), p.lead.because));
+      count(found);
+    }
+    const journey = Array.isArray(p.journey) ? p.journey : [];
+    if (journey.length < 2) err(`.${page}.journey`, "the stages the visitor goes through, two or more, each with why");
+    else {
+      const found = [];
+      journey.forEach((s, i) => {
+        if (!s || typeof s.stage !== "string" || !s.stage.trim()) found.push({ severity: "error", at: `${at("journey")}[${i}].stage`, message: "name the stage" });
+        found.push(...reason(`${at("journey")}[${i}]`, s?.because));
+      });
+      count(found);
+    }
+    pages.push({ page, decided, total: HIERARCHY_FIELDS.length });
+  }
+  return { problems, pages };
+}
+function renderedOrder(snapshot) {
+  const sections = snapshot.sections ?? [];
+  if (sections.length === 0 || !sections.every((s) => s.role)) return null;
+  return sections.map((s) => s.role).filter((r) => r !== "other");
+}
+function checkOrder(declared, page, snapshot, strict = false) {
+  if (!declared || !Array.isArray(declared.order)) return [{ severity: strict ? "error" : "warn", at: `hierarchy.${page}`, message: "no declared hierarchy for this page: its running order cannot be checked" }];
+  const rendered = renderedOrder(snapshot);
+  if (!rendered) return [{ severity: "warn", at: `hierarchy.${page}.order`, message: "the snapshot has no section roles (version 1): take a fresh one to check the order" }];
+  const said = declared.order.map((o) => o.role).filter((r) => r !== "other");
+  if (said.join(",") === rendered.join(",")) return [];
+  return [{ severity: strict ? "error" : "warn", at: `hierarchy.${page}.order`, message: `the page runs ${rendered.join(", ")}; the file says ${said.join(", ")}` }];
+}
+
+// src/direction/job.ts
+var JOB_VERBS = new Set(
+  "find choose pick book get fix stop avoid know feel understand compare decide keep protect prepare plan sort arrange replace repair learn prove show recover reduce save spend hire check see buy sell move start finish handle manage meet reach return treat look end make give take bring hand leave trust rely feel prove explain secure settle solve restore improve change become stay pass sign agree ask call reassure justify confirm".split(" ")
+);
+var LABEL_WORDS = /* @__PURE__ */ new Set(["website", "websites", "site", "sites", "page", "pages", "homepage", "web", "online", "presence", "company", "business", "services", "service", "local", "best", "good", "an", "a", "the", "for", "uk"]);
+var NOUNISH = /(?:tion|sion|ment|ness|ity|site|page)$/;
+var words = (s) => s.toLowerCase().match(/[a-z][a-z'’-]*/g) ?? [];
+function isCategoryLabel(object, brief = "") {
+  const trade = /* @__PURE__ */ new Set([...TRADE_NOUNS.flatMap((t) => t.split(" ")), ...words(brief).filter((w) => w.length > 3)]);
+  const ws = words(object);
+  return ws.length > 0 && ws.every((w) => LABEL_WORDS.has(w) || trade.has(w) || trade.has(w.replace(/s$/, "")));
+}
+var normalise = (s) => s.toLowerCase().replace(/[“”"‘’'.,!?;:()-]/g, " ").replace(/\s+/g, " ").trim();
+function validateJob(job, sources, ctx = {}) {
+  const problems = [];
+  const err = (at, message) => problems.push({ severity: "error", at: `job${at}`, message });
+  const warn = (at, message) => problems.push({ severity: "warn", at: `job${at}`, message });
+  if (!job || typeof job !== "object" || Array.isArray(job)) {
+    err("", "no job map: say what the visitor is trying to get done, in their words, before deciding structure or look");
+    return { problems, decided: false };
+  }
+  const j = job;
+  const ids = new Map(sources.map((s) => [s.id, s]));
+  const st = j.statement;
+  if (!st || typeof st !== "object") err(".statement", "a job statement is verb, object and context");
+  else {
+    const verb = typeof st.verb === "string" ? st.verb.trim().toLowerCase() : "";
+    if (!verb) err(".statement.verb", "what the visitor is trying to do, as a verb: find, choose, book, fix");
+    else if (verb.split(/\s+/).length > 3 || NOUNISH.test(verb) || TRADE_NOUNS.includes(verb)) err(".statement.verb", `"${st.verb}" is not a verb. A job starts with what the visitor is trying to do.`);
+    else if (!JOB_VERBS.has(verb.split(/\s+/)[0])) warn(".statement.verb", `"${st.verb}" is not a verb craft knows. Check it says what the visitor does, not what the site is.`);
+    const object = typeof st.object === "string" ? st.object.trim() : "";
+    if (words(object).length < 3) err(".statement.object", "the object needs a few words: what they are trying to get, and what makes it hard");
+    else if (isCategoryLabel(object, ctx.brief)) err(".statement.object", `"${object}" names the category, not the job. Say what the visitor needs from it: "an electrician they can trust with a dangerous fault".`);
+    if (typeof st.context !== "string" || words(st.context).length < 3) err(".statement.context", "the context: when, under what pressure, or what they are trying to avoid");
+  }
+  for (const part of ["functional", "emotional", "social"]) {
+    const p = j[part];
+    if (!p || typeof p !== "object") {
+      err(`.${part}`, `the ${part} side of the job, with the customer-voice source that shows it`);
+      continue;
+    }
+    if (typeof p.value !== "string" || words(p.value).length < 6) err(`.${part}.value`, "a sentence: what they need, in the terms they would use");
+    else problems.push(...checkReason({ at: `job.${part}`, because: p.value, evidence: p.evidence, sources, tie: "customer" }).map((x) => ({ ...x, at: x.at.replace(/\.because$/, ".value") })));
+  }
+  const c = j.consideration;
+  if (!c || typeof c !== "object") err(".consideration", `how long and how carefully they decide: ${CONSIDERATION.join(", ")}`);
+  else {
+    if (!CONSIDERATION.includes(c.value)) err(".consideration.value", `one of ${CONSIDERATION.join(", ")}`);
+    problems.push(...checkReason({ at: "job.consideration", because: c.because, evidence: c.evidence, sources, tie: "customer" }));
+  }
+  const objections = Array.isArray(j.objections) ? j.objections : [];
+  if (objections.length === 0) err(".objections", "what stops them: the worries they bring to the page");
+  objections.forEach((o, i) => {
+    if (typeof o !== "string" || words(o).length < 3) err(`.objections[${i}]`, "an objection is a few words: what they worry about");
+  });
+  const evidence = Array.isArray(j.evidence) ? j.evidence : [];
+  const voice = evidence.map((id) => ids.get(id)).filter(isCustomerVoice);
+  if (evidence.length === 0 || voice.length === 0) err(".evidence", "cite the reviews, enquiries or conversations the job comes from");
+  for (const id of evidence) if (!ids.has(id)) err(".evidence", `no source called "${id}"`);
+  const language = Array.isArray(j.language) ? j.language : [];
+  if (language.length === 0) err(".language", "quote the customer: the words they use for the problem");
+  const texts = voice.map((s) => normalise(`${s.note} ${ctx.readSource?.(s) ?? ""}`));
+  language.forEach((q, i) => {
+    if (typeof q !== "string" || !q.trim()) return err(`.language[${i}]`, "an empty quote");
+    const n = normalise(q);
+    if (!texts.some((t) => t.includes(n))) warn(`.language[${i}]`, `"${q}" is not in any cited source's note or file. Quote it from the source, or it may be invented.`);
+  });
+  return { problems, decided: problems.every((p) => p.severity !== "error") };
+}
+
+// src/direction/licences.ts
+var LICENCES = [
+  {
+    name: "Basteleur",
+    subject: "face",
+    licence: "OFL-1.1",
+    multiClient: "yes",
+    checked: "2026-09-24",
+    source: "https://velvetyne.fr/fonts/basteleur/",
+    note: "Velvetyne, designed by Keussel. Keep the OFL notice with the font files."
+  },
+  {
+    name: "Gulax",
+    subject: "face",
+    licence: "OFL-1.1",
+    multiClient: "yes",
+    checked: "2026-09-24",
+    source: "https://velvetyne.fr/fonts/gulax/",
+    note: "Velvetyne. Keep the OFL notice with the font files."
+  },
+  {
+    name: "Le Murmure",
+    subject: "face",
+    licence: "OFL-1.1",
+    multiClient: "yes",
+    checked: "2026-09-24",
+    source: "https://velvetyne.fr/fonts/le-murmure/",
+    note: "Velvetyne. Keep the OFL notice with the font files."
+  },
+  {
+    name: "Blaze Type",
+    subject: "foundry",
+    licence: "commercial",
+    multiClient: "per-site",
+    cap: 10,
+    checked: "2026-09-24",
+    source: "https://blazetype.eu/eula",
+    note: "The EULA sells a professional licence for 1 to 10 websites, and lets an agency buy in a client's name at the listed price. Its /license page says one licence covers every domain; the EULA is the contract, so buy per client."
+  },
+  {
+    name: "Power Type",
+    subject: "foundry",
+    licence: "commercial",
+    multiClient: "unverified",
+    checked: "2026-09-24",
+    source: "https://power-type.com/eula",
+    note: "Research on 2026-09-11 reported a Super License capped at 10 self-hosted domains. The EULA page did not load when checked; read it before relying on the cap."
+  },
+  {
+    name: "Grilli Type",
+    subject: "foundry",
+    licence: "commercial",
+    multiClient: "per-site",
+    checked: "2026-09-24",
+    source: "https://www.grillitype.com/information",
+    note: "Web licences cover any number of domains controlled by the licensee, priced by monthly visitors, so a client site needs the client's own licence. Unlimited tiers start at $10,000 per style."
+  },
+  {
+    name: "Phosphor",
+    subject: "icons",
+    licence: "MIT",
+    multiClient: "yes",
+    checked: "2026-09-24",
+    source: "https://github.com/phosphor-icons/core/blob/main/LICENSE",
+    note: "Six weights. The icon-tile tells treat it exactly as they treat Lucide: the library is not the tell, the tinted tile is."
+  },
+  {
+    name: "Tabler Icons",
+    subject: "icons",
+    licence: "MIT",
+    multiClient: "yes",
+    checked: "2026-09-24",
+    source: "https://github.com/tabler/tabler-icons/blob/main/LICENSE",
+    note: "One stroke grid across the set."
+  },
+  {
+    name: "Iconoir",
+    subject: "icons",
+    licence: "MIT",
+    multiClient: "yes",
+    checked: "2026-09-24",
+    source: "https://github.com/iconoir-icons/iconoir/blob/main/LICENSE",
+    note: "Smaller set, no paid tier."
+  },
+  {
+    name: "Unicons",
+    subject: "icons",
+    licence: "IconScout Simple License",
+    multiClient: "yes",
+    checked: "2026-09-24",
+    source: "https://github.com/Iconscout/unicons/blob/master/LICENSE",
+    note: "IconScout's free set, personal and commercial use, attribution optional."
+  },
+  {
+    name: "IconScout premium",
+    subject: "icons",
+    licence: "commercial",
+    multiClient: "per-site",
+    checked: "2026-09-24",
+    source: "https://iconscout.com/licenses",
+    note: "Each licence covers a single end product. Never in a tool, template or shared kit (create-site, craft, a house component library), even modified. Record the assets each site uses. Assets come from different contributors, so take one site's set from one contributor."
+  }
+];
+function faceLicence(family) {
+  const name = family.trim().toLowerCase();
+  return LICENCES.find((l) => l.subject === "face" && l.name.toLowerCase() === name);
+}
+
+// src/direction/validate.ts
+function tellFor(key, value) {
+  if (key === "accent") {
+    const c = parseColour(value);
+    return c && isAiViolet(c.oklch) ? "ai-violet" : null;
+  }
+  if (key === "ground") {
+    const c = parseColour(value);
+    return c && isCream(c.oklch) ? "cream-palette" : null;
+  }
+  if (key === "display" || key === "body") {
+    const name = normaliseFamily(value).toLowerCase();
+    if (REFLEX_FONTS_1.some((f) => f.toLowerCase() === name)) return "reflex-font";
+    if (REFLEX_FONTS_2.some((f) => f.toLowerCase() === name)) return "reflex-font-2";
+  }
+  return null;
+}
+var MIN_TOKENS = 5;
+var emptyLayers = () => ({ job: false, hierarchy: [], tokens: { decided: 0, total: CHOICE_KEYS.length }, complete: false });
+function validateDirection(input, ctx = {}) {
+  const problems = [];
+  const err = (at, message) => problems.push({ severity: "error", at, message });
+  const warn = (at, message) => problems.push({ severity: "warn", at, message });
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    err("", "art-direction.json must be a JSON object");
+    return { valid: false, problems, decided: 0, layers: emptyLayers() };
+  }
+  const d = input;
+  const legacy = d.version === void 0 && d.choices === void 0 && Array.isArray(d.exceptions);
+  if (legacy) {
+    warn("", "exceptions only: run craft direction init to record the choices and their reasons");
+    return { valid: true, problems, decided: 0, layers: emptyLayers() };
+  }
+  if (!DIRECTION_VERSIONS.includes(d.version)) err("version", `version must be ${DIRECTION_VERSIONS.join(" or ")}`);
+  else if (d.version === 1) warn("version", "version 1: the job map and the hierarchy are not recorded, so the site cannot be decided. Move to version 2 (craft direction init --out) and add them.");
+  if (typeof d.client !== "string" || !d.client.trim()) err("client", "name the client");
+  if (typeof d.brief !== "string" || d.brief.trim().split(/\s+/).length < 8) err("brief", "the brief needs a sentence: who, where, and what they do");
+  const rawSources = Array.isArray(d.sources) ? d.sources : [];
+  const sources = rawSources.filter((s) => Boolean(s && typeof s === "object" && !Array.isArray(s)));
+  if (!Array.isArray(d.sources)) err("sources", "sources must be a list");
+  if (sources.length === 0) err("sources", "no sources: a reason needs something in the client's world to point at");
+  const ids = /* @__PURE__ */ new Set();
+  rawSources.forEach((s, i) => {
+    const at = `sources[${i}]`;
+    if (!s || typeof s !== "object" || Array.isArray(s)) return err(at, "a source must be an object");
+    if (typeof s.id !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(s.id)) err(`${at}.id`, "id must be short kebab-case");
+    else if (ids.has(s.id)) err(`${at}.id`, `"${s.id}" is used twice`);
+    else ids.add(s.id);
+    if (!SOURCE_KINDS.includes(s.kind)) err(`${at}.kind`, `kind must be one of: ${SOURCE_KINDS.join(", ")}`);
+    if (typeof s.note !== "string" || s.note.trim().split(/\s+/).length < 3) err(`${at}.note`, "say what it is and where");
+    if (s.path !== void 0 && typeof s.path !== "string") err(`${at}.path`, "a path must be text");
+    if (typeof s.path === "string" && ctx.pathExists && !/^https?:/.test(s.path) && !ctx.pathExists(s.path)) err(`${at}.path`, `${s.path} does not exist`);
+    if (s.colours !== void 0 && !Array.isArray(s.colours)) err(`${at}.colours`, "colours must be a list");
+    for (const [j, c] of (Array.isArray(s.colours) ? s.colours : []).entries()) if (typeof c !== "string" || !parseColour(c)) err(`${at}.colours[${j}]`, `"${c}" is not a colour`);
+    if (s.kind === "reference") {
+      if (typeof s.category !== "string" || !s.category.trim()) err(`${at}.category`, "say where the reference comes from: print, a place, another trade");
+      else if (/\b(?:web ?sites?|web design|competitors?|dribbble|behance|awwwards|themeforest)\b/i.test(s.category) || categoryMatchesBrief(s.category, typeof d.brief === "string" ? d.brief : "")) {
+        err(`${at}.category`, `"${s.category}" is inside the client's category. A reference must come from outside it, or it hands back the category average.`);
+      }
+      if (typeof s.path === "string" && /^https?:/.test(s.path)) warn(`${at}.path`, "a web page as a reference: check it is not a site in the client's category");
+    }
+    if (/\bcompetitor(?:s|['’]s)?\b/i.test(`${s.note} ${s.category ?? ""}`)) err(at, "a source cannot be a competitor's website; use customer voice or a reference from outside the category");
+  });
+  const choices = d.choices && typeof d.choices === "object" ? d.choices : {};
+  if (!d.choices || typeof d.choices !== "object") err("choices", "choices must be an object");
+  const exceptions = Array.isArray(d.exceptions) ? d.exceptions : [];
+  let decided = 0;
+  for (const key of Object.keys(choices)) {
+    if (!CHOICE_KEYS.includes(key)) err(`choices.${key}`, `not a choice craft knows. Choices are: ${CHOICE_KEYS.join(", ")}. Record section order and the primary action in hierarchy.`);
+  }
+  for (const key of CHOICE_KEYS) {
+    const c = choices[key];
+    const at = `choices.${key}`;
+    if (!c) {
+      warn(at, "not decided yet");
+      continue;
+    }
+    let ok = true;
+    if (typeof c.value !== "string" || !c.value.trim()) {
+      err(`${at}.value`, "no value");
+      ok = false;
+    } else if ((key === "accent" || key === "ground") && !parseColour(c.value)) {
+      err(`${at}.value`, `"${c.value}" is not a colour`);
+      ok = false;
+    }
+    const reasons = checkReason({ at, because: c.because, evidence: c.evidence, sources, tie: "source" });
+    problems.push(...reasons);
+    if (reasons.length) ok = false;
+    if (typeof c.value === "string") {
+      const tell = tellFor(key, c.value);
+      if (tell && !exceptions.some((e) => e.tell === tell)) {
+        err(`${at}.value`, `${c.value} is on the tell catalogue (${tell}). Keep it only with an exception for ${tell}, carrying the same reason.`);
+        ok = false;
+      }
+    }
+    if ((key === "display" || key === "body") && typeof c.value === "string" && c.value.trim()) {
+      const family = normaliseFamily(c.value);
+      const entry = faceLicence(family);
+      if (!entry) {
+        warn(`${at}.value`, `${family}: licence not in craft's register. Read the licensor's own terms for use on this client's site, then add it to src/direction/licences.ts.`);
+      } else if (entry.multiClient === "unverified") {
+        warn(`${at}.value`, `${family}: licence unverified (${entry.note})`);
+      } else if (entry.multiClient === "capped" || entry.multiClient === "per-site") {
+        const scope = entry.multiClient === "capped" ? `covers up to ${entry.cap} sites` : "needs a licence for this site, in the client's name";
+        warn(`${at}.value`, `${family}: ${entry.licence} licence ${scope}. Record the purchase before launch.`);
+      }
+    }
+    const fp = ctx.fingerprint;
+    if (fp && typeof c.value === "string") {
+      if ((key === "accent" || key === "ground") && parseColour(c.value)) {
+        const declared = parseColour(c.value).oklch;
+        const measured = key === "accent" ? fp.accent : fp.ground;
+        if (measured && deltaEOk(declared, measured) > 0.08) {
+          warn(`${at}.value`, `the page does not show it: its ${key} measures oklch(${measured.l.toFixed(2)} ${measured.c.toFixed(3)} ${measured.h.toFixed(0)})`);
+        }
+      }
+      if (key === "display" || key === "body") {
+        const measured = key === "display" ? fp.display.family : fp.body.family;
+        if (normaliseFamily(c.value).toLowerCase() !== measured.toLowerCase()) warn(`${at}.value`, `the page sets ${measured}, not ${c.value}`);
+      }
+    }
+    if (ok) decided += 1;
+  }
+  let job = false;
+  let hierarchy = [];
+  if (d.version === 2) {
+    const j = validateJob(d.job, sources, { brief: typeof d.brief === "string" ? d.brief : "", readSource: ctx.readSource });
+    problems.push(...j.problems);
+    job = j.decided && d.job !== void 0;
+    const h = validateHierarchy(d.hierarchy, d.job, sources);
+    problems.push(...h.problems);
+    hierarchy = h.pages;
+    if (ctx.snapshot) problems.push(...checkOrder(d.hierarchy?.[ctx.page ?? "home"], ctx.page ?? "home", ctx.snapshot, ctx.strict));
+  }
+  if (ctx.estate?.length) {
+    for (const m of compareToDeclared(summariseDirection(d), ctx.estate, ctx.estateId)) {
+      if (m.flagged) warn("", `close to ${m.id}'s declared direction: shares ${m.shared.join(", ")}. Decide which of these should differ before either site is built.`);
+    }
+  }
+  if (ctx.strict) {
+    for (const p of problems) if (p.severity === "warn" && /the page (?:does not show|sets|runs)/.test(p.message)) p.severity = "error";
+  }
+  const home = hierarchy.find((p) => p.page === "home");
+  const complete = job && Boolean(home) && hierarchy.every((p) => p.decided === p.total) && decided >= MIN_TOKENS;
+  return {
+    valid: problems.every((p) => p.severity !== "error"),
+    problems,
+    decided,
+    layers: { job, hierarchy, tokens: { decided, total: CHOICE_KEYS.length }, complete: complete && problems.every((p) => p.severity !== "error") }
+  };
+}
+
+export {
+  DIRECTION_VERSION,
+  PAGE_TYPES,
+  PROPOSED,
+  researchPrompt,
+  summariseDirection,
+  compareDirections,
+  compareToDeclared,
+  formatDirectionMatches,
+  validateDirection
+};