@domandigital/craft 0.5.0 → 0.6.0

package/dist/cli-F7W4F3ER.js

@@ -0,0 +1,488 @@
+import {
+  fingerprint
+} from "./chunk-HYGFP3LB.js";
+import {
+  REFLEX_FONTS_1,
+  REFLEX_FONTS_2,
+  deltaEOk,
+  formatHex,
+  hexToOklch,
+  isAiViolet,
+  isCream,
+  normaliseFamily,
+  oklchToRgb,
+  parseColour,
+  parseFlags
+} from "./chunk-GWMSSRIQ.js";
+
+// src/direction/cli.ts
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+
+// src/direction/types.ts
+var DIRECTION_VERSION = 1;
+var SOURCE_KINDS = [
+  "livery",
+  "shopfront",
+  "signage",
+  "packaging",
+  "product",
+  "uniform",
+  "interior",
+  "place",
+  "material",
+  "trade",
+  "print",
+  "photo",
+  "founder"
+];
+var CHOICE_KEYS = ["accent", "ground", "display", "body", "shape", "motif", "signature"];
+
+// 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/validate.ts
+var PREFERENCE = /\b(?:client (?:likes|liked|wants|wanted|asked|chose|prefers?)|(?:we|they|i) (?:like|liked|love|loved|prefer)|on[- ]trend|trendy|popular|what (?:everyone|competitors) (?:uses?|does)|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 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"]);
+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"]);
+function words(text) {
+  return new Set((text.toLowerCase().match(/[a-z][a-z'-]{3,}/g) ?? []).map((w) => w.replace(/'s$/, "")).filter((w) => !STOP.has(w) && !VALUE_WORDS.has(w)));
+}
+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;
+}
+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 };
+  }
+  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 };
+  }
+  if (d.version !== DIRECTION_VERSION) err("version", `version must be ${DIRECTION_VERSION}`);
+  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 sources = Array.isArray(d.sources) ? d.sources : [];
+  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();
+  sources.forEach((s, i) => {
+    const at = `sources[${i}]`;
+    if (!s || typeof s !== "object") 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 && ctx.pathExists && !/^https?:/.test(s.path) && !ctx.pathExists(s.path)) err(`${at}.path`, `${s.path} does not exist`);
+    for (const [j, c] of (s.colours ?? []).entries()) if (!parseColour(c)) err(`${at}.colours[${j}]`, `"${c}" is not a colour`);
+  });
+  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(", ")}. Layout and navigation stay conventional.`);
+  }
+  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 because = typeof c.because === "string" ? c.because.trim() : "";
+    const evidence = Array.isArray(c.evidence) ? c.evidence : [];
+    if (because.split(/\s+/).filter(Boolean).length < 8) {
+      err(`${at}.because`, "a reason is at least a sentence. Without one this is a default, however good it looks.");
+      ok = false;
+    } else if (because.startsWith("PROPOSED:")) {
+      err(`${at}.because`, "a proposal, not yet a decision. Check it against the source, then rewrite the reason in your own words.");
+      ok = false;
+    } else {
+      if (PREFERENCE.test(because)) {
+        err(`${at}.because`, "that is a preference, not a reason. Say what in the client's world this comes from.");
+        ok = false;
+      }
+      const moods = because.match(MOOD) ?? [];
+      if (moods.length >= 2) {
+        err(`${at}.because`, `"${moods.join(", ")}" describes a mood, not a source. Name the thing it comes from.`);
+        ok = false;
+      }
+    }
+    if (evidence.length === 0) {
+      err(`${at}.evidence`, "cite at least one source");
+      ok = false;
+    }
+    for (const id of evidence) {
+      if (!ids.has(id)) {
+        err(`${at}.evidence`, `no source called "${id}"`);
+        ok = false;
+      }
+    }
+    if (ok) {
+      const cited = sources.filter((s) => evidence.includes(s.id));
+      const reasonWords = words(because);
+      const tied = cited.some((s) => reasonWords.has(s.id) || [...words(`${s.note} ${s.lettering ?? ""}`)].some((w) => reasonWords.has(w)));
+      if (!tied) {
+        err(`${at}.because`, `the reason does not mention what its evidence shows (${evidence.join(", ")}). Say what on it this comes from.`);
+        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;
+      }
+    }
+    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;
+  }
+  return { valid: problems.every((p) => p.severity !== "error"), problems, decided };
+}
+
+// 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);
+  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.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  run
+} from "./chunk-GWMSSRIQ.js";
+
+// src/cli.ts
+process.stdout.on("error", (error) => {
+  if (error.code === "EPIPE") process.exit(process.exitCode ?? 0);
+  throw error;
+});
+void Promise.resolve(
+  run(process.argv.slice(2), {
+    cwd: process.cwd(),
+    out: (text) => process.stdout.write(`${text}
+`),
+    err: (text) => process.stderr.write(`${text}
+`)
+  })
+).then((code) => {
+  process.exitCode = code;
+});