@olomonhelpdesk2/helpdesk 0.1.0

package/helpdesk-seed.mjs

@@ -0,0 +1,1373 @@
+#!/usr/bin/env node
+// adapters/seed-bin.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+// core/cli-package.ts
+var HELPDESK_CLI_PACKAGE = "@olomonhelpdesk2/helpdesk";
+function helpdeskCommand(command, args = []) {
+  const parts = ["npx", "--yes", "-p", HELPDESK_CLI_PACKAGE, command, ...args];
+  return parts.join(" ");
+}
+
+// core/seed/cassette.ts
+var CASSETTE_SCHEMA = "olomon.seed-cassette/1";
+var DROP_HEADERS = /* @__PURE__ */ new Set([
+  "set-cookie",
+  "authorization",
+  "proxy-authorization",
+  "www-authenticate",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "content-length",
+  "content-encoding",
+  "upgrade",
+  "trailer",
+  "te",
+  "alt-svc",
+  "strict-transport-security",
+  "report-to",
+  "nel"
+]);
+var CACHE_BUSTERS = /* @__PURE__ */ new Set(["_", "cb", "cachebust", "cache_bust", "_t", "__ts", "nocache"]);
+function keepHeaders(headers) {
+  const kept = {};
+  for (const [name, value] of Object.entries(headers)) {
+    const lower = name.toLowerCase();
+    if (DROP_HEADERS.has(lower) || value === void 0) continue;
+    kept[lower] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return Object.fromEntries(Object.entries(kept).sort(([a], [b]) => a.localeCompare(b)));
+}
+function significantQuery(query) {
+  const kept = Object.entries(query).filter(([name]) => !CACHE_BUSTERS.has(name)).sort(([a], [b]) => a.localeCompare(b));
+  return Object.fromEntries(kept);
+}
+function interactionKey(args) {
+  const query = significantQuery(args.query ?? {});
+  const search = Object.entries(query).map(([name, value]) => `${name}=${value}`).join("&");
+  return `${args.method.toUpperCase()} ${args.path}${search ? `?${search}` : ""}`;
+}
+function looksLikeIdentifier(segment) {
+  if (!segment) return false;
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(segment)) return true;
+  if (/^\d+$/.test(segment)) return true;
+  if (/^[0-9a-f]{8,}$/i.test(segment)) return true;
+  if (segment.length >= 20) return true;
+  return /\d/.test(segment) && segment.length >= 3;
+}
+function templatise(paths) {
+  const split = paths.map((path2) => path2.split("/").filter(Boolean));
+  const depth = Math.max(0, ...split.map((segments) => segments.length));
+  const parameters = /* @__PURE__ */ new Set();
+  const prefixOf = (segments, upTo) => {
+    const parts = [];
+    for (let index = 0; index < upTo; index += 1) {
+      parts.push(parameters.has(`${parts.join("/")}\0${index}`) ? ":" : segments[index]);
+    }
+    return parts.join("/");
+  };
+  for (let index = 0; index < depth; index += 1) {
+    const groups = /* @__PURE__ */ new Map();
+    const children = /* @__PURE__ */ new Map();
+    for (const segments of split) {
+      if (segments.length <= index) continue;
+      const prefix = prefixOf(segments, index);
+      const value = segments[index];
+      (groups.get(prefix) ?? groups.set(prefix, /* @__PURE__ */ new Set()).get(prefix)).add(value);
+      const perGroup = children.get(prefix) ?? children.set(prefix, /* @__PURE__ */ new Map()).get(prefix);
+      const seen = perGroup.get(value) ?? perGroup.set(value, /* @__PURE__ */ new Set()).get(value);
+      if (segments.length > index + 1) seen.add(segments[index + 1]);
+    }
+    for (const [prefix, values] of groups) {
+      if (values.size < 2) continue;
+      const identifier = [...values].some(looksLikeIdentifier);
+      const parallel = leadsToTheSamePlaces(children.get(prefix));
+      if (identifier || parallel) parameters.add(`${prefix}\0${index}`);
+    }
+  }
+  const templates = /* @__PURE__ */ new Map();
+  for (const [index, segments] of split.entries()) {
+    const named = [];
+    let templated = false;
+    for (let position = 0; position < segments.length; position += 1) {
+      if (parameters.has(`${prefixOf(segments, position)}\0${position}`)) {
+        named.push(`:${parameterName(segments, position)}`);
+        templated = true;
+      } else {
+        named.push(segments[position]);
+      }
+    }
+    if (templated) templates.set(paths[index], `/${named.join("/")}`);
+  }
+  return templates;
+}
+function leadsToTheSamePlaces(children) {
+  if (!children || children.size < 2) return false;
+  const sets = [...children.values()].map((set) => [...set].sort().join("\0"));
+  return sets.every((set) => set && set === sets[0]);
+}
+function parameterName(segments, depth) {
+  const parent = depth > 0 ? segments[depth - 1] : "";
+  const base = parent && !parent.startsWith(":") ? singular(parent) : "id";
+  return base.replace(/[^a-z0-9]+/gi, "") || "id";
+}
+function singular(word) {
+  const lower = word.toLowerCase();
+  if (/(analysis|status|address|series|species)$/.test(lower)) return lower;
+  if (lower.endsWith("ies")) return `${lower.slice(0, -3)}y`;
+  if (/(ch|sh|ss|x|z)es$/.test(lower)) return lower.slice(0, -2);
+  if (lower.endsWith("s") && !lower.endsWith("ss")) return lower.slice(0, -1);
+  return lower;
+}
+function serialiseCassette(cassette) {
+  const interactions = [...cassette.interactions].sort(
+    (a, b) => interactionKey(a).localeCompare(interactionKey(b))
+  );
+  return `${JSON.stringify({ ...cassette, interactions }, null, 2)}
+`;
+}
+function parseCassette(text) {
+  const parsed = JSON.parse(text);
+  if (parsed.schema !== CASSETTE_SCHEMA) {
+    throw new Error(`Cassette schema ${JSON.stringify(parsed.schema)} is not one this understands.`);
+  }
+  return parsed;
+}
+var CassetteIndex = class {
+  constructor(cassette) {
+    this.cassette = cassette;
+    for (const interaction of cassette.interactions) {
+      this.exact.set(interactionKey(interaction), interaction);
+      if (interaction.template) {
+        const key = interactionKey({ ...interaction, path: interaction.template });
+        if (!this.byTemplate.has(key)) this.byTemplate.set(key, interaction);
+      }
+    }
+  }
+  exact = /* @__PURE__ */ new Map();
+  byTemplate = /* @__PURE__ */ new Map();
+  get anchor() {
+    return this.cassette.anchor;
+  }
+  get size() {
+    return this.exact.size;
+  }
+  find(args) {
+    const direct = this.exact.get(interactionKey(args));
+    if (direct) return direct;
+    const templates = new Set(
+      this.cassette.interactions.map((interaction) => interaction.template).filter(Boolean)
+    );
+    for (const template of [...templates].sort()) {
+      if (!matchesTemplate(template, args.path)) continue;
+      const found = this.byTemplate.get(interactionKey({ ...args, path: template }));
+      if (found) return found;
+    }
+    return void 0;
+  }
+};
+function matchesTemplate(template, path2) {
+  const wanted = template.split("/").filter(Boolean);
+  const actual = path2.split("/").filter(Boolean);
+  if (wanted.length !== actual.length) return false;
+  return wanted.every((segment, index) => segment.startsWith(":") || segment === actual[index]);
+}
+
+// core/seed/gaps.ts
+function gapsFrom(misses, cassette) {
+  const known = cassette?.interactions.map((interaction) => interaction.path) ?? [];
+  const templates = templatise([...known, ...misses.map((miss) => miss.path)]);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const miss of misses) {
+    const path2 = templates.get(miss.path) ?? miss.path;
+    const key = interactionKey({ method: miss.method, path: path2, ...miss.query ? { query: miss.query } : {} });
+    const existing = grouped.get(key);
+    if (existing) {
+      existing.asked += 1;
+      if (miss.from && !existing.broke.includes(miss.from)) existing.broke.push(miss.from);
+      continue;
+    }
+    grouped.set(key, {
+      method: miss.method.toUpperCase(),
+      path: path2,
+      asked: 1,
+      broke: miss.from ? [miss.from] : [],
+      example: miss.path
+    });
+  }
+  return [...grouped.values()].sort((a, b) => b.asked - a.asked || a.path.localeCompare(b.path));
+}
+function gapReport(gaps2) {
+  if (!gaps2.length) return ["The recording answered everything this run asked for."];
+  const lines = [
+    `${gaps2.length} endpoint(s) are missing from the recording. Until they are in it, the screens below have no data:`,
+    ""
+  ];
+  for (const gap of gaps2) {
+    const broke = gap.broke.length ? ` \u2014 breaks ${gap.broke.join(", ")}` : "";
+    lines.push(`  ${gap.method} ${gap.path}${broke}`);
+    if (gap.path !== gap.example) lines.push(`      for example ${gap.example}`);
+  }
+  lines.push(
+    "",
+    "Record them by running the product against the recording proxy once more and visiting those screens."
+  );
+  return lines;
+}
+function parametersFrom(cassette) {
+  const templates = templatise(cassette.interactions.map((interaction) => interaction.path));
+  const found = /* @__PURE__ */ new Map();
+  for (const interaction of cassette.interactions) {
+    const template = interaction.template ?? templates.get(interaction.path);
+    if (!template) continue;
+    const wanted = template.split("/").filter(Boolean);
+    const actual = interaction.path.split("/").filter(Boolean);
+    if (wanted.length !== actual.length) continue;
+    const perTemplate = found.get(template) ?? /* @__PURE__ */ new Map();
+    for (const [index, segment] of wanted.entries()) {
+      if (!segment.startsWith(":")) continue;
+      const name = segment.slice(1);
+      const values = perTemplate.get(name) ?? [];
+      const value = actual[index];
+      if (!values.includes(value)) values.push(value);
+      perTemplate.set(name, values);
+    }
+    found.set(template, perTemplate);
+  }
+  return found;
+}
+function exampleRoutes(cassette) {
+  const routes2 = /* @__PURE__ */ new Set();
+  for (const [template, parameters] of parametersFrom(cassette)) {
+    let filled = template;
+    for (const [name, values] of parameters) {
+      filled = filled.replace(`:${name}`, values[0]);
+    }
+    routes2.add(filled);
+  }
+  return [...routes2].sort();
+}
+
+// core/seed/cast.ts
+var GIVEN = [
+  "Marion",
+  "Aurelio",
+  "Delphine",
+  "Kwabena",
+  "Ingrid",
+  "Rafael",
+  "Solveig",
+  "Tobias",
+  "Anouk",
+  "Emeka",
+  "Beatriz",
+  "Lars",
+  "Yuki",
+  "Nadia",
+  "Cormac",
+  "Priya",
+  "Halvard",
+  "Esperanza",
+  "Dimitri",
+  "Fenella",
+  "Osric",
+  "Amara",
+  "Bastien",
+  "Wilhelmina"
+];
+var FAMILY = [
+  "Whitfield",
+  "Aldergrove",
+  "Marchetti",
+  "Osei",
+  "Lindqvist",
+  "Barrandon",
+  "Fairweather",
+  "Nakamura",
+  "Oyelaran",
+  "Castellan",
+  "Thornbury",
+  "Vasilenko",
+  "Merriweather",
+  "Adeyemi",
+  "Blackwood",
+  "Ferreira",
+  "Kowalczyk",
+  "Ravensworth",
+  "Duguid",
+  "Sandoval",
+  "Haverford",
+  "Ingleby",
+  "Petrossian",
+  "Wrenfield"
+];
+var STREETS = [
+  "Calderwood Row",
+  "Harrowgate Lane",
+  "Pentland Rise",
+  "Ashcombe Way",
+  "Marlowe Crescent",
+  "Belforte Street",
+  "Kirkstall Green",
+  "Windermere Close",
+  "Thackeray Walk",
+  "Ossington Mews"
+];
+var CITIES = [
+  "Ashbourne",
+  "Fenwick",
+  "Marlbury",
+  "Kesterton",
+  "Ravensfield",
+  "Holbeck",
+  "Danforth",
+  "Wexbury",
+  "Alderney Green",
+  "Portstow"
+];
+var COMPANIES = [
+  "Ambervale",
+  "Northgate Works",
+  "Calder & Roe",
+  "Fenwick Holdings",
+  "Kestrel Union",
+  "Ossington Trading",
+  "Pentland Group",
+  "Thornbury Mills",
+  "Wexford Rail",
+  "Alderney Supply"
+];
+var EMAIL_DOMAIN = "example.invalid";
+var PHONE_PREFIX = "555-01";
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var Cast = class {
+  random;
+  assigned = /* @__PURE__ */ new Map();
+  people = /* @__PURE__ */ new Map();
+  issued = 0;
+  constructor(seed = 20240101) {
+    this.random = mulberry32(seed);
+  }
+  /**
+   * The whole person behind an anchor.
+   *
+   * The anchor is whatever real value identified them first — an email if the
+   * record had one, otherwise a name or an id. Every field of that record then
+   * comes from the person this returns, which is what makes the email match
+   * the name rather than merely coexist with it.
+   */
+  person(anchor) {
+    const already = this.people.get(anchor);
+    if (already) return already;
+    const index = this.issued;
+    this.issued += 1;
+    const given = GIVEN[index % GIVEN.length];
+    const family = FAMILY[(index * 7 + Math.floor(index / FAMILY.length)) % FAMILY.length];
+    const suffix = index >= GIVEN.length ? String(index) : "";
+    const person = {
+      given,
+      family,
+      full: `${given} ${family}`,
+      email: `${given}.${family}${suffix}@${EMAIL_DOMAIN}`.toLowerCase(),
+      phone: `${PHONE_PREFIX}${String(index % 100).padStart(2, "0")}`,
+      street: `${1 + index % 90} ${STREETS[index % STREETS.length]}`,
+      city: CITIES[index % CITIES.length],
+      postcode: `ZZ${String(10 + index % 89)} ${String(1 + index % 9)}QQ`
+    };
+    this.people.set(anchor, person);
+    return person;
+  }
+  /**
+   * One field, replaced consistently.
+   *
+   * `within` is the record the field belongs to, and it is what makes this a
+   * graph rather than a dictionary: two people who happen to share a first
+   * name stay two people, and one person mentioned on four screens stays one.
+   */
+  value(kind, real, within) {
+    const key = `${kind}\0${real}`;
+    const already = this.assigned.get(key);
+    if (already) return already;
+    const synthetic = this.mint(kind, real, within ?? real);
+    this.assigned.set(key, synthetic);
+    return synthetic;
+  }
+  mint(kind, real, anchor) {
+    const person = this.person(anchor);
+    switch (kind) {
+      case "given-name":
+        return person.given;
+      case "family-name":
+        return person.family;
+      case "full-name":
+        return person.full;
+      case "email":
+        return person.email;
+      case "phone":
+        return person.phone;
+      case "street":
+        return person.street;
+      case "city":
+        return person.city;
+      case "postcode":
+        return person.postcode;
+      case "company":
+        return COMPANIES[this.assigned.size % COMPANIES.length];
+      case "note":
+        return redactedNote(real, this.random);
+      case "amount":
+        return recastAmount(real, this.random);
+    }
+  }
+  /** What was replaced with what. Held by the caller, never written beside the cassette. */
+  mapping() {
+    return {
+      entries: [...this.assigned.entries()].map(([key, to]) => {
+        const [kind, from] = key.split("\0");
+        return { kind, from, to };
+      }).sort((a, b) => a.from.localeCompare(b.from))
+    };
+  }
+  get size() {
+    return this.assigned.size;
+  }
+};
+var NOTES = [
+  "Reviewed the quarterly position and confirmed the settlement dates with operations.",
+  "Statement reconciled against the ledger. No further action required this period.",
+  "Contact prefers email. Documentation is complete and filed.",
+  "Awaiting countersigned paperwork before the transfer can be scheduled.",
+  "Adjustment applied after the reporting close; the balances agree.",
+  "Annual review completed on schedule and signed off internally."
+];
+function redactedNote(real, random) {
+  const wanted = real.trim().split(/\s+/).length;
+  const chosen = [];
+  let words = 0;
+  let index = Math.floor(random() * NOTES.length);
+  do {
+    const sentence = NOTES[index % NOTES.length];
+    chosen.push(sentence);
+    words += sentence.split(" ").length;
+    index += 1;
+  } while (words < wanted * 0.7 && chosen.length < NOTES.length);
+  return chosen.join(" ");
+}
+var FIELDS = [
+  { pattern: /(^|_|\.)(given[_-]?name|first[_-]?name|forename)$/i, kind: "given-name" },
+  { pattern: /(^|_|\.)(family[_-]?name|last[_-]?name|surname)$/i, kind: "family-name" },
+  { pattern: /(^|_|\.)(email|email[_-]?address|e[_-]?mail)$/i, kind: "email" },
+  { pattern: /(^|_|\.)(phone|telephone|phone[_-]?number|mobile|cell)$/i, kind: "phone" },
+  { pattern: /(^|_|\.)(street|address|address[_-]?line[_-]?1|line1)$/i, kind: "street" },
+  { pattern: /(^|_|\.)(city|town|locality)$/i, kind: "city" },
+  { pattern: /(^|_|\.)(postcode|postal[_-]?code|zip|zip[_-]?code)$/i, kind: "postcode" },
+  // `held_at`, `custodian` and `provider` are the keys a real institution
+  // actually arrives under, and an institution in a published frame implies a
+  // partnership. Where the key says what the value is, replace it; where it
+  // does not, the text pass flags it and a person decides.
+  {
+    pattern: /(^|_|\.)(company|organisation|organization|employer|institution|custodian|provider|bank|broker|held[_-]?at|held[_-]?by)$/i,
+    kind: "company"
+  },
+  { pattern: /(^|_|\.)(note|notes|comment|comments|memo|description|bio)$/i, kind: "note" },
+  {
+    // A person, whatever this product calls the part they are playing.
+    pattern: /(^|_|\.)(name|full[_-]?name|display[_-]?name|owner|contact|customer|client|member|patient|assignee|assigned[_-]?to|reporter|reviewer|approver|author|editor|manager|supervisor|clinician|practitioner|physician|doctor|nurse|therapist|teacher|student|tutor|technician|engineer|driver|courier|recipient|sender|guest|attendee|participant|applicant|candidate|tenant[_-]?name|landlord|beneficiary|guardian|next[_-]?of[_-]?kin|emergency[_-]?contact)$/i,
+    kind: "full-name"
+  }
+];
+function kindOfField(key, extra = []) {
+  const named = extra.find((field) => new RegExp(`(^|_|\\.)${escapeKey(field.key)}$`, "i").test(key));
+  if (named) return named.kind;
+  return FIELDS.find((field) => field.pattern.test(key))?.kind;
+}
+function escapeKey(key) {
+  return key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function recastJson(value, cast, options = {}) {
+  const path2 = options.path ?? "";
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => recastJson(entry, cast, { ...options, path: `${path2}[${index}]` }));
+  }
+  if (value === null || typeof value !== "object") return value;
+  const record2 = value;
+  const anchor = anchorOf(record2, path2);
+  const out = {};
+  for (const [key, entry] of Object.entries(record2)) {
+    const kind = kindOfField(key, options.fields ?? []);
+    if (kind && typeof entry === "string" && entry.trim()) {
+      note(options.seen, key, entry, kind);
+      out[key] = cast.value(kind, entry, anchor);
+      continue;
+    }
+    if (kind === "amount" && typeof entry === "number" && Number.isFinite(entry)) {
+      note(options.seen, key, String(entry), kind);
+      out[key] = Number(cast.value(kind, String(entry), anchor));
+      continue;
+    }
+    if (entry !== null && typeof entry !== "object") note(options.seen, key, String(entry));
+    out[key] = recastJson(entry, cast, { ...options, path: path2 ? `${path2}.${key}` : key });
+  }
+  return out;
+}
+function recastAmount(real, random) {
+  const negative = real.trim().startsWith("-");
+  const [whole = "0", fraction] = real.trim().replace(/^-/, "").split(".");
+  const digits = Math.max(1, whole.replace(/\D/g, "").length);
+  const low = digits > 1 ? 10 ** (digits - 1) : 0;
+  const span = 10 ** digits - low;
+  const invented = String(low + Math.floor(random() * span));
+  const places = fraction === void 0 ? "" : `.${fraction.replace(/\d/g, () => String(Math.floor(random() * 10)))}`;
+  return `${negative ? "-" : ""}${invented}${places}`;
+}
+function note(seen, key, value, kind) {
+  if (!seen) return;
+  const held = seen.get(key);
+  if (held) {
+    held.count += 1;
+    return;
+  }
+  seen.set(key, { key, count: 1, example: value.length > 60 ? `${value.slice(0, 57)}\u2026` : value, ...kind ? { kind } : {} });
+}
+function anchorOf(record2, path2) {
+  for (const key of ["email", "emailAddress", "email_address"]) {
+    const value = record2[key];
+    if (typeof value === "string" && value.trim()) return `email:${value.toLowerCase()}`;
+  }
+  for (const key of ["name", "fullName", "full_name", "displayName"]) {
+    const value = record2[key];
+    if (typeof value === "string" && value.trim()) return `name:${value.toLowerCase()}`;
+  }
+  for (const key of ["id", "uuid", "userId", "user_id"]) {
+    const value = record2[key];
+    if (typeof value === "string" || typeof value === "number") return `id:${String(value)}`;
+  }
+  return `at:${path2}`;
+}
+
+// core/seed/clock.ts
+var DEFAULT_ANCHOR = "2024-05-14T10:37:00.000Z";
+var ISO = /\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}:?\d{2})?\b/g;
+var DATE_ONLY = /\b\d{4}-\d{2}-\d{2}\b/g;
+var TIME_KEYS = /(^|_|\.)(.*_at|.*At|time|timestamp|ts|date|expires|expiry|exp|iat|nbf|created|updated|modified|deleted|seen|due|start|end|since|until)$/i;
+function instantsIn(value, key = "") {
+  if (typeof value === "number") {
+    return TIME_KEYS.test(key) ? epochToMs(value).map((ms) => ms) : [];
+  }
+  if (typeof value === "string") {
+    const found = value.match(ISO) ?? [];
+    const parsed = found.map((text) => Date.parse(text)).filter((ms) => Number.isFinite(ms));
+    if (parsed.length) return parsed;
+    if (TIME_KEYS.test(key)) {
+      const dates = (value.match(DATE_ONLY) ?? []).map((text) => Date.parse(`${text}T00:00:00.000Z`));
+      return dates.filter((ms) => Number.isFinite(ms));
+    }
+    return [];
+  }
+  if (Array.isArray(value)) return value.flatMap((entry) => instantsIn(entry, key));
+  if (value && typeof value === "object") {
+    return Object.entries(value).flatMap(([name, entry]) => instantsIn(entry, name));
+  }
+  return [];
+}
+function epochToMs(value) {
+  if (!Number.isFinite(value) || value <= 0) return [];
+  if (value > 1e12) return [value];
+  if (value > 1e9) return [value * 1e3];
+  return [];
+}
+function shiftFor(instants, anchor = DEFAULT_ANCHOR) {
+  const target = Date.parse(anchor);
+  if (!Number.isFinite(target)) throw new Error(`Anchor ${JSON.stringify(anchor)} is not an instant.`);
+  if (!instants.length) return { offsetMs: 0, latest: void 0, anchor };
+  const latest = Math.max(...instants);
+  return { offsetMs: target - latest, latest: new Date(latest).toISOString(), anchor };
+}
+function shiftTime(value, shift, key = "") {
+  if (!shift.offsetMs) return value;
+  if (typeof value === "number") {
+    if (!TIME_KEYS.test(key)) return value;
+    if (value > 1e12) return value + shift.offsetMs;
+    if (value > 1e9) return value + Math.round(shift.offsetMs / 1e3);
+    return value;
+  }
+  if (typeof value === "string") {
+    let out = value.replace(ISO, (text) => {
+      const ms = Date.parse(text);
+      if (!Number.isFinite(ms)) return text;
+      return inShapeOf(text, ms + shift.offsetMs);
+    });
+    if (out === value && TIME_KEYS.test(key)) {
+      out = value.replace(DATE_ONLY, (text) => {
+        const ms = Date.parse(`${text}T00:00:00.000Z`);
+        if (!Number.isFinite(ms)) return text;
+        return new Date(ms + shift.offsetMs).toISOString().slice(0, 10);
+      });
+    }
+    return out;
+  }
+  if (Array.isArray(value)) return value.map((entry) => shiftTime(entry, shift, key));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([name, entry]) => [name, shiftTime(entry, shift, name)])
+    );
+  }
+  return value;
+}
+function inShapeOf(original, ms) {
+  const iso = new Date(ms).toISOString();
+  const hasMillis = /\.\d{1,9}/.test(original);
+  const spaced = original.includes(" ") && !original.includes("T");
+  const offset = /[+-]\d{2}:?\d{2}$/.exec(original)?.[0];
+  let out = hasMillis ? iso : `${iso.slice(0, 19)}Z`;
+  if (offset) {
+    const minutes = offsetMinutes(offset);
+    const local = new Date(ms + minutes * 6e4).toISOString();
+    out = `${hasMillis ? local.slice(0, 23) : local.slice(0, 19)}${offset}`;
+  } else if (!original.endsWith("Z") && !offset) {
+    out = hasMillis ? iso.slice(0, 23) : iso.slice(0, 19);
+  }
+  return spaced ? out.replace("T", " ") : out;
+}
+function offsetMinutes(offset) {
+  const sign = offset.startsWith("-") ? -1 : 1;
+  const digits = offset.slice(1).replace(":", "");
+  return sign * (Number(digits.slice(0, 2)) * 60 + Number(digits.slice(2)));
+}
+
+// core/capture/scrub.ts
+var BRANDS = [
+  "Chase",
+  "JPMorgan",
+  "J.P. Morgan",
+  "Bank of America",
+  "Wells Fargo",
+  "Citibank",
+  "Citigroup",
+  "Goldman Sachs",
+  "Morgan Stanley",
+  "Schwab",
+  "Charles Schwab",
+  "Fidelity",
+  "Vanguard",
+  "BlackRock",
+  "Merrill",
+  "Merrill Lynch",
+  "TD Ameritrade",
+  "E*TRADE",
+  "Robinhood",
+  "Coinbase",
+  "American Express",
+  "Amex",
+  "Capital One",
+  "PNC",
+  "US Bank",
+  "Truist",
+  "HSBC",
+  "Barclays",
+  "Northern Trust",
+  "State Street",
+  "Pershing",
+  "LPL Financial",
+  "Raymond James",
+  "Edward Jones",
+  "Plaid",
+  "Yodlee",
+  "Addepar",
+  "Orion",
+  "Envestnet",
+  "eMoney",
+  "MoneyGuidePro"
+];
+var SAFE_EMAIL_DOMAIN = "example.invalid";
+var ALREADY_SAFE = [
+  // RFC 2606 and RFC 6761 reserve these precisely so they can never resolve.
+  { kind: "email", regex: /@[A-Za-z0-9.-]*\.(invalid|test|example|localhost)$/i },
+  { kind: "email", regex: /@(example\.(com|net|org))$/i },
+  // 555-01xx is reserved for fiction and cannot reach a telephone.
+  { kind: "phone", regex: /^(\+?1[-. ]?)?\(?555\)?[-. ]?01\d{2}$/ },
+  /*
+   * This module's own replacements, which it must not report a second time.
+   *
+   * Without these it is not idempotent, and idempotence is not a nicety here:
+   * a scrubbed fixture is scrubbed AGAIN on the way into a screenshot, and a
+   * zeroed account number matching the long-digit-run rule means the gate
+   * refuses a screen this module already made safe. Nothing is wrong, nothing
+   * can be done about it, and the run stops — which is the precise way a check
+   * teaches people to ignore it.
+   *
+   * No real account, card or identification number is all zeroes.
+   */
+  { kind: "account-number", regex: /^0+$/ },
+  { kind: "account-number", regex: /^XX0+$/ },
+  { kind: "national-id", regex: /^000-00-0000$/ },
+  { kind: "national-id", regex: /^AA0{6}A$/ },
+  { kind: "tax-id", regex: /^00-0000000$/ },
+  { kind: "passport", regex: /^[A-Z]{1,2}0+$/ },
+  { kind: "date-of-birth", regex: /^1970-01-01$/ }
+];
+function alreadySafe(kind, value) {
+  return ALREADY_SAFE.some((entry) => entry.kind === kind && entry.regex.test(value));
+}
+var PATTERNS = [
+  {
+    kind: "email",
+    regex: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+    because: "a real address can receive mail from a fixture",
+    replace: (_match, index) => `person${index + 1}@${SAFE_EMAIL_DOMAIN}`
+  },
+  {
+    kind: "national-id",
+    // US SSN shape. Deliberately narrow: a looser rule matches dates and
+    // phone numbers, and a scrub that cries wolf gets click-throughed.
+    regex: /\b(?!000|666|9\d\d)\d{3}-(?!00)\d{2}-(?!0000)\d{4}\b/g,
+    because: "a national identification number",
+    replace: () => "000-00-0000"
+  },
+  {
+    kind: "tax-id",
+    regex: /\b\d{2}-\d{7}\b/g,
+    because: "an employer or tax identification number",
+    replace: () => "00-0000000"
+  },
+  {
+    kind: "national-id",
+    // UK National Insurance. Two letters, six digits, one suffix letter.
+    // Every product with a UK employee or patient holds one of these, which is
+    // why it sits beside the US shape rather than in a finance-specific list.
+    regex: /\b[A-CEGHJ-PR-TW-Z]{2}\s?\d{2}\s?\d{2}\s?\d{2}\s?[A-D]\b/g,
+    because: "the shape of a UK National Insurance number",
+    replace: () => "AA000000A"
+  },
+  {
+    kind: "account-number",
+    // IBAN. Checked before the bare digit run below, because an IBAN carries
+    // its country and bank in the leading letters and zeroing only the digits
+    // would leave those standing.
+    regex: /\b[A-Z]{2}\d{2}[A-Z0-9]{11,30}\b/g,
+    because: "an international bank account number",
+    replace: (match) => `XX00${"0".repeat(match.length - 4)}`
+  },
+  {
+    kind: "account-number",
+    // Long digit runs. Card numbers, account numbers, routing numbers.
+    regex: /\b\d{9,19}\b/g,
+    because: "long enough to be an account, card or routing number",
+    replace: (match) => "0".repeat(match.length)
+  },
+  {
+    kind: "date-of-birth",
+    regex: /\b(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])\b/g,
+    because: "a full date \u2014 if it is a birth date it identifies somebody",
+    replace: () => "1970-01-01"
+  },
+  {
+    kind: "passport",
+    regex: /\b[A-Z]{1,2}\d{6,9}\b/g,
+    because: "the shape of a passport or licence number",
+    replace: (match) => `${match.slice(0, 1)}${"0".repeat(match.length - 1)}`
+  },
+  {
+    kind: "phone",
+    regex: /\b(?:\+?1[-. ]?)?\(?\d{3}\)?[-. ]\d{3}[-. ]\d{4}\b/g,
+    because: "a telephone number",
+    replace: () => "555-0100"
+  }
+];
+function scrub(text, options = {}) {
+  const findings = [];
+  const where = options.where ?? "fixture";
+  let output = text;
+  for (const pattern of PATTERNS) {
+    const seen = /* @__PURE__ */ new Map();
+    output = output.replace(pattern.regex, (match) => {
+      if (alreadySafe(pattern.kind, match)) return match;
+      const already = seen.get(match);
+      if (already) return already;
+      const replacement = pattern.replace(match, seen.size);
+      seen.set(match, replacement);
+      findings.push({ kind: pattern.kind, found: match, replacement, where, because: pattern.because });
+      return replacement;
+    });
+  }
+  for (const brand of [...BRANDS, ...options.brands ?? []]) {
+    const regex = new RegExp(`\\b${escapeRegExp(brand)}\\b`, "gi");
+    if (regex.test(output)) {
+      findings.push({
+        kind: "brand",
+        found: brand,
+        replacement: brand,
+        where,
+        because: "a real institution in a published screenshot implies a partnership \u2014 a legal review item, not a design nit"
+      });
+    }
+  }
+  return { scrubbed: output, findings, needsReview: findings.length > 0 };
+}
+function describeScrub(result) {
+  if (!result.findings.length) return "Nothing that looks like real data was found.";
+  const byKind = /* @__PURE__ */ new Map();
+  for (const finding of result.findings) {
+    const list = byKind.get(finding.kind) ?? [];
+    list.push(finding);
+    byKind.set(finding.kind, list);
+  }
+  const lines = [`${result.findings.length} thing(s) found. Nothing publishes until you confirm.`, ""];
+  for (const [kind, group] of byKind) {
+    lines.push(`  ${kind.toUpperCase().replace(/-/g, " ")} \u2014 ${group[0].because}`);
+    for (const finding of group.slice(0, 5)) {
+      lines.push(
+        kind === "brand" ? `    ${finding.found}  (left as-is: decide whether this frame can ship)` : `    ${finding.found}  \u2192  ${finding.replacement}`
+      );
+    }
+    if (group.length > 5) lines.push(`    \u2026and ${group.length - 5} more`);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// core/seed/seed.ts
+function sealCassette(cassette, options = {}) {
+  const cast = new Cast(options.seed ?? 20240101);
+  const anchor = options.anchor ?? DEFAULT_ANCHOR;
+  const findings = [];
+  const seen = /* @__PURE__ */ new Map();
+  const recast = cassette.interactions.map((interaction) => {
+    if (interaction.encoding === "base64") return interaction;
+    const decoded = decodeJson(interaction.body);
+    if (decoded === void 0) return interaction;
+    return {
+      ...interaction,
+      body: JSON.stringify(recastJson(decoded, cast, { seen, ...options.fields ? { fields: options.fields } : {} }))
+    };
+  });
+  const learned = knownValues(cast);
+  const swept = recast.map(
+    (interaction) => interaction.encoding === "base64" ? interaction : { ...interaction, body: sweep(interaction.body, learned) }
+  );
+  const cleaned = swept.map((interaction) => {
+    if (interaction.encoding === "base64") return interaction;
+    const reviewed = scrub(interaction.body, {
+      where: `${interaction.method} ${interaction.path}`,
+      ...options.brands ? { brands: options.brands } : {}
+    });
+    findings.push(...reviewed.findings);
+    return { ...interaction, body: reviewed.scrubbed };
+  });
+  const instants = cleaned.flatMap((interaction) => {
+    const decoded = decodeJson(interaction.body);
+    return decoded === void 0 ? [] : instantsIn(decoded);
+  });
+  const shift = shiftFor(instants, anchor);
+  const frozen = cleaned.map((interaction) => {
+    const headers = { ...interaction.headers };
+    if (headers["date"]) {
+      const parsed = Date.parse(headers["date"]);
+      if (Number.isFinite(parsed)) headers["date"] = new Date(parsed + shift.offsetMs).toUTCString();
+    }
+    if (interaction.encoding === "base64") return { ...interaction, headers };
+    const decoded = decodeJson(interaction.body);
+    return {
+      ...interaction,
+      headers,
+      body: decoded === void 0 ? interaction.body : JSON.stringify(shiftTime(decoded, shift))
+    };
+  });
+  const register = [...seen.values()].sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+  return {
+    cassette: withTemplates({ ...cassette, anchor, interactions: frozen }),
+    mapping: cast.mapping(),
+    shift,
+    findings,
+    carried: register.filter((field) => !field.kind),
+    recast: register.filter((field) => field.kind)
+  };
+}
+function knownValues(cast) {
+  return cast.mapping().entries.map((entry) => [entry.from, entry.to]).filter(([from]) => from.trim().length >= 3).sort(([a], [b]) => b.length - a.length);
+}
+function sweep(body, learned) {
+  let out = body;
+  for (const [from, to] of learned) {
+    if (!out.includes(from)) continue;
+    out = out.split(from).join(to);
+  }
+  return out;
+}
+function withTemplates(cassette) {
+  const templates = templatise(cassette.interactions.map((interaction) => interaction.path));
+  return {
+    ...cassette,
+    interactions: cassette.interactions.map((interaction) => {
+      const template = templates.get(interaction.path);
+      return template ? { ...interaction, template } : interaction;
+    })
+  };
+}
+function recordInteraction(args) {
+  const headers = keepHeaders(args.headers);
+  const text = args.body.toString("utf8");
+  const isText = Buffer.compare(Buffer.from(text, "utf8"), args.body) === 0;
+  return {
+    method: args.method.toUpperCase(),
+    path: args.path,
+    ...args.query && Object.keys(args.query).length ? { query: args.query } : {},
+    status: args.status,
+    headers,
+    body: isText ? text : args.body.toString("base64"),
+    ...isText ? {} : { encoding: "base64" }
+  };
+}
+function decodeJson(body) {
+  if (!body.trim()) return void 0;
+  try {
+    const parsed = JSON.parse(body);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// adapters/seed-proxy.ts
+import { createServer, request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+
+// core/capture/contract.ts
+var CAPTURE_CONTRACT = {
+  /** Same for every shot, so type is the same size across the whole set. */
+  viewport: { width: 1600, height: 1e3 },
+  /** Stills render at 2x → 3200x2000. */
+  stillScale: 2,
+  /** Clips at 1x; video is resampled downstream anyway. */
+  clipScale: 1,
+  /** Below this a frame is a failed shot rather than a small one. */
+  minStillWidth: 2300,
+  /**
+   * Clip length.
+   *
+   * A CAP rather than a target, and inherited from a marketing site's autoplay
+   * loop — which is not this product's constraint. A help-center clip showing a
+   * multi-step task may well want twenty seconds, so the window is the contract
+   * and the number is configurable.
+   */
+  clipSeconds: { min: 6, target: 9, max: 10 },
+  maxClipBytes: 2 * 1024 * 1024,
+  /** Everything renders as though it were this instant. */
+  pinnedClock: "2026-01-15T09:00:00.000Z",
+  /**
+   * Injected before every shot. Necessary, not sufficient — see above.
+   */
+  motionOff: "*,*::before,*::after{animation:none!important;transition:none!important;caret-color:transparent!important}"
+};
+var RECORDING_MISS_STATUS = 599;
+
+// adapters/seed-proxy.ts
+var MISS_STATUS = RECORDING_MISS_STATUS;
+function bodyOf(message) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    message.on("data", (chunk) => chunks.push(chunk));
+    message.on("end", () => resolve(Buffer.concat(chunks)));
+    message.on("error", reject);
+  });
+}
+function listen(server, port) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      const address = server.address();
+      resolve(typeof address === "object" && address ? address.port : port);
+    });
+  });
+}
+function shut(server) {
+  return new Promise((resolve) => {
+    server.closeAllConnections?.();
+    server.close(() => resolve());
+  });
+}
+function splitUrl(url) {
+  const [path2, search] = url.split("?");
+  const query = {};
+  for (const [name, value] of new URLSearchParams(search ?? "")) query[name] = value;
+  return { path: path2 ?? "/", query };
+}
+async function recordThrough(options) {
+  const upstream = new URL(options.upstream);
+  const send = upstream.protocol === "https:" ? httpsRequest : httpRequest;
+  const interactions = [];
+  const screens = /* @__PURE__ */ new Set();
+  const server = createServer((incoming, outgoing) => {
+    void (async () => {
+      const { path: path2, query } = splitUrl(incoming.url ?? "/");
+      const requestBody = await bodyOf(incoming);
+      const from = incoming.headers["referer"] ?? incoming.headers["x-seed-page"];
+      if (typeof from === "string") screens.add(pageOf(from));
+      const forwarded = send(
+        {
+          protocol: upstream.protocol,
+          hostname: upstream.hostname,
+          port: upstream.port || (upstream.protocol === "https:" ? 443 : 80),
+          method: incoming.method,
+          path: incoming.url,
+          headers: { ...incoming.headers, host: upstream.host }
+        },
+        (response) => {
+          void (async () => {
+            const body = await bodyOf(response);
+            const interaction = recordInteraction({
+              method: incoming.method ?? "GET",
+              path: path2,
+              query,
+              status: response.statusCode ?? 200,
+              headers: response.headers,
+              body
+            });
+            interactions.push(interaction);
+            options.onRecord?.(interaction);
+            outgoing.writeHead(response.statusCode ?? 200, response.headers);
+            outgoing.end(body);
+          })();
+        }
+      );
+      forwarded.on("error", (error) => {
+        outgoing.writeHead(502, { "content-type": "text/plain" });
+        outgoing.end(`The backend at ${options.upstream} could not be reached: ${error.message}`);
+      });
+      forwarded.end(requestBody);
+    })();
+  });
+  const port = await listen(server, options.port ?? 0);
+  return {
+    url: `http://127.0.0.1:${port}`,
+    port,
+    cassette: () => ({
+      schema: "olomon.seed-cassette/1",
+      recordedAgainst: options.upstream,
+      anchor: "",
+      screens: [...screens].sort(),
+      interactions: [...interactions]
+    }),
+    close: () => shut(server)
+  };
+}
+async function replayFrom(options) {
+  const index = new CassetteIndex(options.cassette);
+  const misses = [];
+  const served = /* @__PURE__ */ new Set();
+  const server = createServer((incoming, outgoing) => {
+    void (async () => {
+      const { path: path2, query } = splitUrl(incoming.url ?? "/");
+      await bodyOf(incoming);
+      const found = index.find({ method: incoming.method ?? "GET", path: path2, query });
+      if (!found) {
+        const from = incoming.headers["referer"] ?? incoming.headers["x-seed-page"];
+        const miss = {
+          method: incoming.method ?? "GET",
+          path: path2,
+          ...Object.keys(query).length ? { query } : {},
+          ...typeof from === "string" ? { from: pageOf(from) } : {}
+        };
+        misses.push(miss);
+        options.onMiss?.(miss);
+        outgoing.writeHead(MISS_STATUS, { "content-type": "application/json" });
+        outgoing.end(
+          JSON.stringify({
+            error: "not in the recording",
+            method: miss.method,
+            path: miss.path,
+            hint: "Record this endpoint, or the screen that needs it has no data."
+          })
+        );
+        return;
+      }
+      served.add(`${found.method} ${found.path}`);
+      const body = found.encoding === "base64" ? Buffer.from(found.body, "base64") : Buffer.from(found.body, "utf8");
+      outgoing.writeHead(found.status, { ...found.headers, "content-length": String(body.byteLength) });
+      outgoing.end(body);
+    })();
+  });
+  const port = await listen(server, options.port ?? 0);
+  return {
+    url: `http://127.0.0.1:${port}`,
+    port,
+    misses,
+    served,
+    close: () => shut(server)
+  };
+}
+function pageOf(referer) {
+  try {
+    return new URL(referer).pathname;
+  } catch {
+    return referer;
+  }
+}
+
+// adapters/seed-bin.ts
+var KINDS = [
+  "given-name",
+  "family-name",
+  "full-name",
+  "email",
+  "phone",
+  "street",
+  "city",
+  "postcode",
+  "company",
+  "note",
+  "amount"
+];
+function parseSensitive(value) {
+  const [key, kind] = value.split("=");
+  if (!key || !kind) return `--sensitive wants key=kind, as in --sensitive diagnosis=note. Got "${value}".`;
+  if (!KINDS.includes(kind)) {
+    return `"${kind}" is not something this can invent. Choose one of: ${KINDS.join(", ")}.`;
+  }
+  return { key, kind };
+}
+function parse(argv) {
+  const args = { command: argv[0] ?? "", cassette: "./seed-cassette.json", port: 0, brands: [], fields: [] };
+  for (let index = 1; index < argv.length; index += 1) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (flag === "--upstream" && value) args.upstream = value, index += 1;
+    else if (flag === "--cassette" && value) args.cassette = value, index += 1;
+    else if (flag === "--port" && value) args.port = Number(value), index += 1;
+    else if (flag === "--anchor" && value) args.anchor = value, index += 1;
+    else if (flag === "--seed" && value) args.seed = Number(value), index += 1;
+    else if (flag === "--brand" && value) args.brands.push(value), index += 1;
+    else if (flag === "--mapping" && value) args.mapping = value, index += 1;
+    else if (flag === "--sensitive" && value) {
+      const field = parseSensitive(value);
+      if (typeof field === "string") return field;
+      args.fields.push(field);
+      index += 1;
+    }
+  }
+  if (!["record", "replay", "gaps", "routes"].includes(args.command)) {
+    return [
+      "Usage: helpdesk-seed <record|replay|gaps|routes> [--upstream <url>] [--cassette <file>] [--port <n>]",
+      "",
+      "  --brand <name>          an institution of yours that must not appear in a screenshot",
+      "  --sensitive <key=kind>  a key your product uses that holds something real,",
+      "                          as in --sensitive diagnosis=note --sensitive clinician=full-name"
+    ].join("\n");
+  }
+  if (args.command === "record" && !args.upstream) {
+    return "record needs --upstream <the address your product calls for data>";
+  }
+  return args;
+}
+async function main(argv) {
+  const parsed = parse(argv);
+  if (typeof parsed === "string") {
+    console.error(parsed);
+    return 2;
+  }
+  if (parsed.command === "record") return record(parsed);
+  if (parsed.command === "replay") return replay(parsed);
+  if (parsed.command === "gaps") return gaps(parsed);
+  return routes(parsed);
+}
+async function record(args) {
+  const proxy = await recordThrough({
+    upstream: args.upstream,
+    port: args.port,
+    onRecord: (interaction) => console.log(`  ${interaction.status} ${interaction.method} ${interaction.path}`)
+  });
+  console.log(
+    [
+      `Recording everything sent to ${args.upstream}.`,
+      "",
+      "Point your product's backend address at this and use it \u2014 sign in, open the screens",
+      "you want documented, and make the errors happen if you can. What you visit is what",
+      "the recording will be able to replay.",
+      "",
+      `  ${proxy.url}`,
+      "",
+      "Use a development or staging backend and a throwaway account. This is passing real",
+      "responses through to your product, so whatever that account holds is what gets",
+      "written down before anything is scrubbed.",
+      "",
+      "Ctrl-C when you are done.",
+      ""
+    ].join("\n")
+  );
+  await new Promise((resolve) => {
+    process.on("SIGINT", resolve);
+    process.on("SIGTERM", resolve);
+  });
+  await proxy.close();
+  const raw = proxy.cassette();
+  if (!raw.interactions.length) {
+    console.log("\nNothing was recorded. Was your product actually pointed at the address above?");
+    return 1;
+  }
+  const sealed = sealCassette(raw, {
+    ...args.anchor ? { anchor: args.anchor } : {},
+    ...args.seed === void 0 ? {} : { seed: args.seed },
+    ...args.brands.length ? { brands: args.brands } : {},
+    ...args.fields.length ? { fields: args.fields } : {}
+  });
+  await mkdir(path.dirname(path.resolve(args.cassette)), { recursive: true });
+  await writeFile(args.cassette, serialiseCassette(sealed.cassette), "utf8");
+  console.log(
+    `
+${sealed.cassette.interactions.length} interaction(s) written to ${args.cassette}.
+${sealed.mapping.entries.length} real value(s) replaced with a synthetic cast.` + (sealed.shift.latest ? `
+Time moved from ${sealed.shift.latest} to ${sealed.cassette.anchor}, intervals intact.` : "\nNo timestamps found, so nothing was moved.")
+  );
+  if (args.mapping) {
+    await writeFile(args.mapping, `${JSON.stringify(sealed.mapping, null, 2)}
+`, "utf8");
+    console.log(
+      `
+The real-to-synthetic mapping is in ${args.mapping}. It is the personal data you just
+removed, in its most convenient possible form. Do not commit it.`
+    );
+  }
+  console.log(`
+${carriedReport(sealed.carried, args.cassette).join("\n")}`);
+  if (sealed.findings.length) {
+    console.log(`
+${describeScrub({ scrubbed: "", findings: sealed.findings, needsReview: true })}`);
+    console.log(
+      "\nThese survived the field pass, which means they were in free text or under a key nothing\nrecognised. Read them before you commit this."
+    );
+    return 1;
+  }
+  console.log("\nNothing SHAPED like real data survived into the recording.");
+  return 0;
+}
+function carriedReport(carried, cassette) {
+  if (!carried.length) return ["Every key in the recording was recognised and rewritten."];
+  const ranked = [...carried].sort((a, b) => score(b) - score(a) || b.count - a.count);
+  const width = Math.max(...ranked.map((field) => field.key.length));
+  const worth = ranked.filter((field) => score(field) > 0);
+  return [
+    `${carried.length} key(s) were carried through untouched:`,
+    "",
+    ...ranked.map(
+      (field) => `  ${field.key.padEnd(width)}  ${String(field.count).padStart(4)}\xD7  ${field.example}`
+    ),
+    "",
+    "That is not automatically wrong \u2014 an id, a status or a currency is meant to survive.",
+    "But this package only knows the words every product shares: people, their contact",
+    "details, their address, and the role each one is playing. Whatever your product holds",
+    "that no other product does is on the list above, and it was not touched.",
+    "",
+    ...worth.length ? [
+      "If any of these hold something real, name them and record again:",
+      "",
+      `  ${helpdeskCommand("helpdesk-seed", ["record", "--upstream <url>", `--cassette ${cassette}`])} \\`,
+      ...worth.slice(0, 4).map((field, index) => `    --sensitive ${field.key}=${suggest(field)}${index === Math.min(worth.length, 4) - 1 ? "" : " \\"}`),
+      "",
+      "  kinds: given-name, family-name, full-name, email, phone, street, city, postcode,",
+      "         company, note, amount",
+      "",
+      "  note invents a sentence of about the same length, for anything free-text.",
+      "  amount invents a different figure of the same size, for a salary or a balance \u2014",
+      "  a number is never detectable by shape, so naming it is the only way it is caught."
+    ] : []
+  ];
+}
+function score(field) {
+  const value = field.example;
+  if (/^\d+(\.\d+)?$/.test(value)) return 0;
+  if (!/[A-Za-z]/.test(value)) return 0;
+  if (value.length < 12 && value === value.toLowerCase()) return 0;
+  const prose = value.includes(" ") ? 2 : 0;
+  const proper = /\b[A-Z][a-z]+\b/.test(value) ? 1 : 0;
+  return prose + proper + (value.length > 30 ? 1 : 0);
+}
+function suggest(field) {
+  const words = field.example.trim().split(/\s+/);
+  const name = words.length <= 3 && words.every((word) => /^[A-Z][\w'’-]*$/.test(word));
+  return name ? "full-name" : "note";
+}
+async function replay(args) {
+  const cassette = parseCassette(await readFile(args.cassette, "utf8"));
+  const misses = [];
+  const proxy = await replayFrom({
+    cassette,
+    port: args.port,
+    onMiss: (miss) => console.log(`  MISS ${miss.method} ${miss.path}${miss.from ? ` (from ${miss.from})` : ""}`)
+  });
+  console.log(
+    [
+      `Replaying ${cassette.interactions.length} interaction(s) from ${args.cassette}.`,
+      `Every timestamp in here sits relative to ${cassette.anchor}.`,
+      "",
+      `  ${proxy.url}`,
+      "",
+      "The real backend is not reachable from here on purpose. Anything the recording does",
+      "not have comes back as a miss rather than quietly fetching the truth, because a",
+      "recording that reaches past itself puts real data in a screenshot.",
+      "",
+      "Ctrl-C when you are done.",
+      ""
+    ].join("\n")
+  );
+  await new Promise((resolve) => {
+    process.on("SIGINT", resolve);
+    process.on("SIGTERM", resolve);
+  });
+  misses.push(...proxy.misses);
+  await proxy.close();
+  const found = gapsFrom(misses, cassette);
+  console.log(`
+${gapReport(found).join("\n")}`);
+  if (found.length) {
+    await writeFile(missFile(args.cassette), `${JSON.stringify(misses, null, 2)}
+`, "utf8");
+    console.log(`
+The full miss log is in ${missFile(args.cassette)}.`);
+  }
+  const unused = cassette.interactions.filter(
+    (interaction) => !proxy.served.has(`${interaction.method} ${interaction.path}`)
+  );
+  if (unused.length) {
+    console.log(`
+${unused.length} recorded interaction(s) were never asked for during this run.`);
+  }
+  return found.length ? 1 : 0;
+}
+async function gaps(args) {
+  const cassette = parseCassette(await readFile(args.cassette, "utf8"));
+  const log = await readFile(missFile(args.cassette), "utf8").catch(() => "[]");
+  console.log(gapReport(gapsFrom(JSON.parse(log), cassette)).join("\n"));
+  return 0;
+}
+async function routes(args) {
+  const cassette = parseCassette(await readFile(args.cassette, "utf8"));
+  const found = exampleRoutes(cassette);
+  if (!found.length) {
+    console.log("The recording holds no parameterised routes, so there are no example ids to offer.");
+    return 0;
+  }
+  console.log("Routes the recording can answer, with an identifier it has already served:\n");
+  for (const route of found) console.log(`  ${route}`);
+  return 0;
+}
+function missFile(cassette) {
+  return cassette.replace(/\.json$/, "") + ".misses.json";
+}
+export {
+  carriedReport,
+  main
+};