@tokenoftrust/cli 2.0.28 → 2.1.1

package/src/go-live-report.mjs

@@ -0,0 +1,1064 @@
+/**
+ * Pure report builder for a store's go-live readiness report (`tot report go-live`).
+ *
+ * This is the artifact a MERCHANT reads before cutover, so it answers three questions in
+ * their terms: what was done, what is proven, and what still needs a person. It is generated
+ * from measurement rather than authored, because a hand-written status page drifts from the
+ * gates and the drift is invisible — the same failure the parity gate exists to prevent.
+ *
+ * Three framing rules, all deliberate:
+ *
+ * 1. HOT-STANDBY MEANS RISKS, NOT SHOW-STOPPERS. While the lifecycle is hot-standby nothing
+ *    here blocks anyone: the live site is untouched and the migration is a parallel build. So
+ *    an open human gate is reported as an AREA OF RISK carrying a decision, never as a
+ *    failure. Calling a pending signature a blocker at this stage is both false and the kind
+ *    of thing that stalls a migration nobody was actually blocked on.
+ *
+ * 2. THE WINS ARE THE POINT AND THEY MUST BE QUANTIFIED. A merchant deciding whether to go
+ *    live is buying an outcome. `41 → 87` on their own homepage is the argument; "performance
+ *    improved" is not. Every number here is measured against the source site captured before
+ *    cutover, so the comparison is real and survives scrutiny.
+ *
+ * 3. NOTHING BELOW THE BAR IS HIDDEN. A report that only sells is not trusted twice. Anything
+ *    that misses the standard is stated with what it would take to close, so the merchant
+ *    makes the call rather than discovering it later.
+ */
+
+/**
+ * Lighthouse dimensions in the order a reader cares about them.
+ *
+ * All FIVE categories Lighthouse 13 scores. `agentic-browsing` is the one that is easy to miss —
+ * it is new in 13, and an older captured baseline will not have it. That is handled, not
+ * special-cased: judgeParity already treats a dimension absent from the baseline as `unmeasured`,
+ * which never fails a run.
+ */
+const DIMENSIONS = ["performance", "accessibility", "best-practices", "seo", "agentic-browsing"];
+
+const DIMENSION_LABEL = {
+  performance: "Speed",
+  "agentic-browsing": "Agent readiness",
+  accessibility: "Accessibility",
+  "best-practices": "Best practices",
+  seo: "SEO",
+};
+
+/**
+ * What each add-on stage would buy, in merchant terms. Keyed to the register in
+ * docs/architecture/migration-add-on-stages.md — core is the parity obligation and is never
+ * an add-on, so it is absent here by construction.
+ */
+export const ADD_ON_CATALOG = {
+  seo: {
+    label: "SEO enhancement",
+    buys: "Generated titles, descriptions and structured data where the source had none — "
+      + "the migration copies what exists; this adds what never did.",
+  },
+  "visual-fidelity": {
+    label: "Visual fidelity review",
+    buys: "A human review that the migrated pages LOOK like the brand, not merely that they "
+      + "carry the same content. Deliberately not automated.",
+  },
+  lookAndFeel: {
+    label: "Look and feel",
+    buys: "Chrome variants, header/footer treatment and theme tokens tuned beyond the "
+      + "reconstruction.",
+  },
+  branding: {
+    label: "Branding adoption",
+    buys: "Logo, palette and brand voice carried through the whole system rather than "
+      + "page by page.",
+  },
+  analytics: {
+    label: "Analytics adapter",
+    buys: "A reviewed measurement adapter and destination id, so the new site reports into "
+      + "the same analytics the merchant already trusts.",
+  },
+  storefront: {
+    label: "Storefront (the platform itself)",
+    buys: "Going live on Storefront is what this migration delivers: hosted regulated commerce "
+      + "with checkout, the product catalog, compliance notices, legacy URL redirects, theme "
+      + "tokens and product reviews included. Checkout activation is the cutover step that turns "
+      + "the standby site into the live store.",
+  },
+  "storefront-verification": {
+    label: "Age and identity verification",
+    buys: "Token of Trust age and identity verification wired into the storefront — the "
+      + "compliance layer a regulated merchant needs at the door and at checkout, rather than a "
+      + "third-party gate bolted on.",
+  },
+  "storefront-excise": {
+    label: "Excise tax engine",
+    buys: "Per-SKU excise tax calculated correctly at checkout, fed by per-SKU tax metadata. "
+      + "Regulated categories get taxed right instead of approximately.",
+  },
+  "storefront-reporting": {
+    label: "Reporting",
+    buys: "Reporting across your orders and catalog.",
+  },
+  "custom-theme": {
+    label: "Custom theme",
+    buys: "A theme designed for your brand rather than rebuilt from the old site. The migration "
+      + "carries your current look across; this is the chance to improve on it.",
+  },
+  "custom-apps": {
+    label: "Custom apps and plugins",
+    buys: "Custom storefront behaviour built as a reviewed app or plugin, so it keeps working "
+      + "through future platform updates.",
+  },
+  "additional-stores": {
+    label: "Additional store migrations",
+    buys: "The same migration for your other brands or regional stores, at lower cost now that the "
+      + "groundwork is done.",
+  },
+  "managed-support": {
+    label: "Managed support and SLA",
+    buys: "A guaranteed response time for a store your revenue now depends on.",
+  },
+  "own-your-exit": {
+    label: "Own Your Exit (single-tenant extraction)",
+    buys: "Your site, handed over as a repository you own outright — so staying with us is always "
+      + "your choice rather than a constraint.",
+  },
+  custom: {
+    label: "Custom migration work",
+    buys: "Anything your store needs that the standard migration does not cover — a bespoke page "
+      + "type, an integration you want kept, an unusual URL scheme. Quoted per item so you "
+      + "always see what it costs before it is built.",
+  },
+};
+
+
+/**
+ * The commerce checklist a storefront must clear to become a live store.
+ *
+ * Sourced from this platform's own cutover scope (checkout activation, catalog graduation,
+ * public publication/DNS, monitoring, rollback, source retirement — docs/recipes/
+ * migration-overview.md:96-98 and site-port.md Step 9) plus the items every ecommerce launch
+ * checklist in this category carries: a payment gateway that has actually taken a transaction,
+ * a confirmed end-to-end checkout, tax and shipping configured, and order email that arrives.
+ *
+ * NONE of these is verifiable from a site validation run — they are integrations, credentials
+ * and human confirmations. So each is recorded, absent means NOT CONFIRMED, and the report says
+ * so rather than implying a clean sheet. `key` maps to `goLive.<key>` in the tenant's
+ * migration-state.
+ */
+export const GO_LIVE_CHECKLIST = [
+  { key: "paymentGateway", label: "Payment gateway connected",
+    why: "Live payments have to run through your own gateway account, with credentials in place." },
+  { key: "checkoutConfirmed", label: "Checkout confirmed end to end",
+    why: "A real order placed and received — the single proof that the store can take money." },
+  { key: "taxConfigured", label: "Tax and excise configured",
+    why: "Regulated products are taxed per item; wrong tax at checkout is a compliance exposure, not a rounding error." },
+  { key: "shippingConfigured", label: "Shipping rates and zones",
+    why: "Rates, zones and any shipping restrictions have to match what you actually ship." },
+  { key: "orderEmail", label: "Order confirmation email",
+    why: "Your customers need the receipt and you need the notification — an email that does not arrive is a broken store." },
+  { key: "domainReady", label: "Domain, SSL and DNS cutover plan",
+    why: "The hostname move is the cutover; it needs a scheduled plan and a certificate ready before it happens." },
+  { key: "redirectsVerified", label: "Legacy URL redirects verified",
+    why: "Your old links keep their search value only if every retired URL lands somewhere correct." },
+  { key: "analyticsLive", label: "Analytics reporting",
+    why: "Launch day is when you most need to see traffic and orders." },
+  { key: "monitoringReady", label: "Monitoring and alerting",
+    why: "Somebody has to be told when a live store stops taking orders." },
+  { key: "rollbackPlan", label: "Rollback plan agreed",
+    why: "Cutover is reversible by reverting the hostname mapping — agreeing that in advance is what makes it fast." },
+  { key: "sourceRetirement", label: "Old store retirement plan",
+    why: "Your previous store needs a decision: kept read-only, redirected, or switched off." },
+];
+
+/**
+ * Add-ons move through three states and only the last one means anything on launch day:
+ * SELECTED (the merchant bought it), CONFIGURED (it is set up), LIVE (it is confirmed working).
+ * Reporting a selected-but-unconfigured add-on as ready is how a merchant discovers at cutover
+ * that something they paid for was never switched on.
+ */
+export function addOnLifecycle(addOns = {}) {
+  const chosen = Object.entries(addOns).filter(([, v]) => v === "selected" || v === "configured"
+    || v === "live" || v === "done");
+  return chosen.map(([id, state]) => ({
+    id,
+    label: ADD_ON_CATALOG[id]?.label ?? id,
+    state: state === "done" ? "live" : state,
+    live: state === "live" || state === "done",
+  }));
+}
+
+/**
+ * Which milestone an open item actually blocks.
+ *
+ * These are different questions with different urgency, and merging them is how a merchant ends
+ * up believing their standby site is broken when it is fine. HOT STANDBY asks whether the
+ * parallel build is faithful, serving, AND able to take over: routes resolve, the commerce
+ * boundary holds, no secrets leak, the reconstruction is complete, and order sync and product
+ * sync are proven. GO-LIVE asks whether it is ready to become the public store with checkout
+ * on: polish, sign-offs, merchant-supplied evidence.
+ *
+ * COMMERCE SYNC BELONGS TO HOT STANDBY, not to go-live. A standby store that cannot move orders
+ * or products is not standing by for anything — it is a website. Proving it at cutover is
+ * proving it at the one moment the answer cannot be acted on, so an unproven sync is a BLOCKER
+ * here rather than a decision deferred to later.
+ *
+ * Anything unrecognised is treated as blocking HOT STANDBY on purpose — the conservative
+ * default, because the claim this report exists to support is "standby is solid", and an
+ * unclassified failure must never quietly strengthen that claim.
+ */
+const GO_LIVE_ONLY_AREAS = new Set([
+  "Style guide", "Ecommerce style-guide bar", "Performance", "Mobile and UX", "Accessibility",
+]);
+
+/** @param {string} area */
+export function blocksHotStandby(area) {
+  return !GO_LIVE_ONLY_AREAS.has(String(area ?? "").trim());
+}
+
+/**
+ * What buying a Lighthouse dimension actually delivers, in merchant terms.
+ *
+ * Every dimension is offerable, ALWAYS — including the ones this run could not measure. The
+ * catalogue used to carry `seo` alone, which is why performance, the dimension merchants care
+ * about most and the one Google ranks on, was the single thing they could not see they could buy.
+ * A hand-written catalogue omits by accident; deriving one per dimension cannot.
+ */
+export const LIGHTHOUSE_ADDON = {
+  performance: "Faster pages: deferred third-party scripts, tuned images, fewer render-blocking "
+    + "resources. Google ranks on real-visit Core Web Vitals, so this one is revenue-bearing "
+    + "rather than cosmetic.",
+  accessibility: "Contrast, focus order, labels, landmarks and tap targets taken past the "
+    + "baseline — reaching more customers, and reducing ADA exposure on a regulated storefront.",
+  "best-practices": "Modern APIs, clean console, correct image sizing and no deprecated "
+    + "platform calls — the hygiene layer auditors and enterprise buyers check first.",
+  seo: "Generated titles, descriptions and structured data where the source had none. The "
+    + "migration copies the SEO that exists; this adds the SEO that never did.",
+  "agentic-browsing": "Whether an AI agent can actually shop this store: a clean agent "
+    + "accessibility tree, WebMCP tools registered with valid schemas, forms an agent can "
+    + "complete, and an llms.txt. This is the SEO of agent-mediated commerce — the merchants who "
+    + "are legible to agents early will be the ones agents transact with.",
+};
+
+/**
+ * Turn the run's own results into the offer list.
+ *
+ * Three families, because they are bought differently: a dimension lift is measured and
+ * quantified, an open item is work someone already knows is outstanding, and the standing
+ * catalogue is what we offer every tenant. Derived rather than hand-listed so a gap found at
+ * Step 8 becomes offerable in the same pass instead of waiting for someone to remember it.
+ */
+/**
+ * @param {{
+ *   parity?: {dimensions?: {dimension: string, migrated: number}[], measured?: number},
+ *   unsourcedComponents?: string[],
+ *   styleGuideApproved?: boolean,
+ *   syncRows?: {label: string, confirmed: boolean, notApplicable: boolean}[],
+ *   addOns?: Record<string, string>,
+ *   opportunities?: {categories?: string[]}[],
+ * }} input
+ */
+export function deriveAddOns(input) {
+  const {
+    parity = { dimensions: [] }, unsourcedComponents = [], styleGuideApproved = false,
+    syncRows = [], addOns = {}, opportunities = [],
+  } = input;
+  const byDim = new Map((parity.dimensions ?? []).map((d) => [d.dimension, d]));
+  const oppCount = (dim) => opportunities.filter((o) => (o.categories ?? []).includes(dim)).length;
+
+  const dimensionRows = DIMENSIONS.map((dim) => {
+    const measured = byDim.get(dim);
+    // Headroom is to 100 because that is the only ceiling Lighthouse has. It is deliberately NOT
+    // the parity band: parity is what the migration OWED, and this section is about what can be
+    // bought beyond it. A dimension already delivering free value still has room above it.
+    const headroom = measured ? Math.max(0, 100 - measured.migrated) : null;
+    const found = oppCount(dim);
+    return {
+      dimension: dim,
+      label: DIMENSION_LABEL[dim] ?? dim,
+      today: measured ? measured.migrated : null,
+      headroom,
+      buys: LIGHTHOUSE_ADDON[dim],
+      opportunities: found,
+      // An unmeasured dimension is offerable but honest about it: we cannot quote a lift we
+      // never measured, and saying "not measured" is the difference between an estimate and a
+      // guess dressed as one.
+      state: measured == null
+        ? "not measured this run"
+        : (headroom === 0 ? "already at 100" : `+${headroom} available`),
+    };
+  });
+
+  const openItems = [];
+  for (const row of syncRows.filter((r) => !r.confirmed && !r.notApplicable)) {
+    openItems.push({
+      item: `${row.label} activation`,
+      why: "Builder-facing integration that site validation cannot see, with no check recorded.",
+      delivers: `Wire and exercise ${row.label.toLowerCase()} end to end against the merchant's `
+        + "store, and record the evidence so cutover is not where it gets tested.",
+    });
+  }
+  if (!styleGuideApproved) {
+    openItems.push({
+      item: "Style-guide sign-off",
+      why: "No approval recorded for the visual standard the site is built to.",
+      delivers: "A guided review session ending in a recorded approval — or the visual-fidelity "
+        + "review below if the merchant wants the standard raised first, not merely approved.",
+    });
+  }
+  for (const component of unsourcedComponents) {
+    openItems.push({
+      item: `Source the ${component}`,
+      why: "Ships as a placeholder because it makes a claim to customers that we will not invent.",
+      delivers: "Collect the real evidence from the merchant, verify it is substantiated, and "
+        + "publish it — on a regulated storefront a fabricated claim is a compliance exposure.",
+    });
+  }
+
+  const standing = Object.entries(ADD_ON_CATALOG)
+    .filter(([id]) => addOns[id] !== "done" && addOns[id] !== "selected")
+    .map(([id, a]) => ({
+      id,
+      label: a.label,
+      buys: a.buys,
+      status: addOns[id] === "not-selected" ? "not selected" : (addOns[id] ?? "available"),
+    }));
+
+  return { dimensionRows, openItems, standing };
+}
+
+/** A Lighthouse finding is an add-on opportunity only when it is OURS to fix and not a metric. */
+const OPPORTUNITY_EXCLUDE = new Set([
+  // Pure metrics: outcomes, not actions. Reporting "Largest Contentful Paint" as an
+  // opportunity tells a merchant nothing they can buy.
+  "first-contentful-paint", "largest-contentful-paint", "speed-index",
+  "total-blocking-time", "cumulative-layout-shift", "max-potential-fid",
+  "interactive", "server-response-time-insight",
+]);
+
+/** Effort guess per finding id. Absent = unknown, which prints as "—" rather than a made-up size. */
+const OPPORTUNITY_EFFORT = {
+  "unused-css-rules": "S",
+  "render-blocking-insight": "S",
+  "bf-cache": "S",
+  "unused-javascript": "S",
+  deprecations: "M",
+  "errors-in-console": "S",
+  "network-dependency-tree-insight": "M",
+  "document-latency-insight": "M",
+  "cache-insight": "S",
+  "server-response-time": "M",
+  "landmark-one-main": "S",
+  "page-has-heading-one": "S",
+};
+
+/**
+ * Collapse the per-page Lighthouse runs into one proof-of-value view.
+ *
+ * Averaging is deliberate over picking a headline page: a single flattering page is the kind
+ * of number that does not survive a merchant checking a second URL themselves.
+ */
+export function summariseParity(pages) {
+  const measured = pages.filter((p) => p.dimensions && Object.keys(p.dimensions).length > 0);
+  // The bands the RUN used, never a constant here: the report must not describe a standard
+  // the gate is not enforcing. Defaults match lighthouse-parity.mjs only as a last resort.
+  const tolerance = measured.find((p) => p.tolerance != null)?.tolerance ?? 3;
+  const ceiling = measured.find((p) => p.ceiling != null)?.ceiling ?? 5;
+  if (measured.length === 0) {
+    return { measured: 0, dimensions: [], verdicts: {}, tolerance, ceiling };
+  }
+  /** @type {{dimension: string, label: string, source: number, migrated: number, delta: number, improved: boolean, pages: number, verdict?: string}[]} */
+  const dimensions = [];
+  for (const dim of DIMENSIONS) {
+    const rows = measured.map((p) => p.dimensions[dim]).filter(Boolean);
+    if (rows.length === 0) continue;
+    const avg = (key) => Math.round(rows.reduce((t, r) => t + (r[key] ?? 0), 0) / rows.length);
+    const source = avg("source");
+    const migrated = avg("migrated");
+    dimensions.push({
+      dimension: dim,
+      label: DIMENSION_LABEL[dim] ?? dim,
+      source,
+      migrated,
+      delta: migrated - source,
+      // A dimension is only "improved" if it beat the source on the AVERAGE; one good page
+      // does not earn the claim.
+      improved: migrated > source,
+      pages: rows.length,
+    });
+  }
+  const verdicts = {};
+  for (const p of measured) {
+    for (const [dim, d] of Object.entries(p.dimensions)) {
+      verdicts[dim] ??= { giveaway: 0, parity: 0, regression: 0 };
+      if (d.verdict && verdicts[dim][d.verdict] !== undefined) verdicts[dim][d.verdict] += 1;
+    }
+  }
+  // Roll each dimension's per-page verdicts into one. A REGRESSION anywhere outranks
+  // everything — a merchant losing something on one page has lost it, and averaging that
+  // away is exactly the dishonesty this report must not commit. Giveaway only when it beat
+  // the ceiling on balance.
+  for (const d of dimensions) {
+    const v = verdicts[d.dimension] ?? {};
+    d.verdict = v.regression > 0 ? "regression"
+      : (d.delta > ceiling ? "giveaway" : "parity");
+  }
+  return { measured: measured.length, dimensions, verdicts, tolerance, ceiling };
+}
+
+/**
+ * Lighthouse findings → add-on opportunities, deduped across pages and ranked by reach.
+ *
+ * Only `owner: platform` findings become opportunities: a provider-owned one (a CDN's own
+ * challenge script, say) is not something the merchant can buy from us, and listing it as an
+ * opportunity would be selling work we cannot do.
+ */
+export function opportunitiesFromFindings(pages) {
+  const byId = new Map();
+  for (const page of pages) {
+    for (const f of page.findings ?? []) {
+      if (f.owner !== "platform") continue;
+      if (OPPORTUNITY_EXCLUDE.has(f.id)) continue;
+      // A channel-exemption or harness note describes the MEASUREMENT, not the site.
+      if (String(f.kind ?? "").startsWith("lighthouse-")) continue;
+      const entry = byId.get(f.id) ?? {
+        id: f.id,
+        title: f.title ?? f.id,
+        categories: f.categories ?? [],
+        pages: new Set(),
+        effort: OPPORTUNITY_EFFORT[f.id] ?? null,
+      };
+      entry.pages.add(page.slug);
+      byId.set(f.id, entry);
+    }
+  }
+  return [...byId.values()]
+    .map((e) => ({ ...e, pageCount: e.pages.size, pages: [...e.pages].sort() }))
+    .sort((a, b) => b.pageCount - a.pageCount || a.id.localeCompare(b.id));
+}
+
+/**
+ * Split the readiness checks into what is proven and what needs a person.
+ *
+ * The lifecycle decides the LANGUAGE, not the contents: in hot-standby an unmet check is an
+ * area of risk carrying a decision, because nothing is live and nobody is blocked. At cutover
+ * the same check is a blocker. Same measurement, honest framing for the stage.
+ */
+export function classifyChecks(checks, { lifecycle }) {
+  const hotStandby = lifecycle === "hot-standby";
+  const confirmed = [];
+  const risks = [];
+  for (const c of checks ?? []) {
+    if (c.status === "PASS") confirmed.push(c);
+    else if (c.status !== "UNKNOWN" || !hotStandby) risks.push(c);
+  }
+  return { confirmed, risks, hotStandby };
+}
+
+function table(rows, header, align = []) {
+  const sep = header.map((_, i) => (align[i] === "r" ? "---:" : "---"));
+  return [`| ${header.join(" | ")} |`, `|${sep.join("|")}|`, ...rows.map((r) => `| ${r.join(" | ")} |`)]
+    .join("\n");
+}
+
+
+/**
+ * Areas only the MERCHANT can close, because they need evidence or a decision we cannot supply.
+ * Everything else is our work, and saying so is the difference between a report that reads as a
+ * status update and one that reads as a bill of work landing on the reader's desk.
+ */
+const MERCHANT_CLOSES = new Set(["Ecommerce style-guide bar", "Style guide"]);
+
+/** What the check protects, in the reader's terms — the check's own declared scope. */
+function whyItMatters(check) {
+  return String(check?.why ?? "").replace(/\|/g, "/")
+    || "Part of the pre-launch quality bar.";
+}
+
+/**
+ * Who closes it, in outcome terms. The gates' own `fix` text is written for whoever runs the
+ * migration — it names gate counts, CSS structure and tooling — so it belongs in the implementor
+ * report, not in front of a merchant deciding whether to launch.
+ */
+function whoCloses(check) {
+  return MERCHANT_CLOSES.has(String(check?.area ?? "").trim())
+    ? "Needs input from you — see **Turning the store on** below."
+    : "Our team closes this before go-live; no action needed from you.";
+}
+
+
+/**
+ * The same comparison, split by device class.
+ *
+ * Phone and desktop are judged against baselines captured on their own kind of device, because a
+ * desktop run compared to a phone number is not a comparison at all — different viewport,
+ * throttling and CPU multiplier. Averaging them would hide exactly the difference a merchant
+ * cares about: their customers are mostly on phones, and the two numbers can diverge sharply.
+ */
+export function summariseByProfile(pages) {
+  const names = [...new Set(pages.flatMap((p) => Object.keys(p.profiles ?? {})))];
+  const LABEL = { mobile: "Phone", desktop: "Desktop" };
+  return names.map((name) => {
+    const runs = pages.map((p) => p.profiles?.[name]).filter(Boolean);
+    const dimensions = [];
+    for (const dim of DIMENSIONS) {
+      const rows = runs.map((r) => r.dimensions?.[dim]).filter((d) => d && typeof d.source === "number"
+        && typeof d.migrated === "number");
+      if (rows.length === 0) continue;
+      const avg = (key) => Math.round(rows.reduce((t, r) => t + r[key], 0) / rows.length);
+      const source = avg("source");
+      const migrated = avg("migrated");
+      dimensions.push({ dimension: dim, label: DIMENSION_LABEL[dim] ?? dim, source, migrated,
+        delta: migrated - source });
+    }
+    return { name, label: LABEL[name] ?? name, dimensions };
+  }).filter((p) => p.dimensions.length > 0);
+}
+
+/** The whole report. Pure: every input is data, so the output is testable byte-for-byte. */
+export function buildGoLiveReport(input) {
+  const {
+    tenant, generatedAt, lifecycle = "hot-standby", pages = [], checks = [],
+    unsourcedComponents = [], styleGuideApproved = false, addOns = {}, totals = {},
+    baselineRoutes = 0, baselineCapturedAt = null,
+    // Commerce plumbing. Step 8 CANNOT verify these — order-sync and product-sync are
+    // builder-facing jobs on the public MCP, not storefront gates — so they arrive as recorded
+    // confirmations or not at all. Absent means UNCONFIRMED, which is reported as unconfirmed:
+    // never as passing, and never by silent omission.
+    commerceSync = {},
+    // Recorded go-live checklist confirmations, keyed by GO_LIVE_CHECKLIST.key.
+    goLive = {},
+  } = input;
+
+  const parity = summariseParity(pages);
+  const { confirmed, risks, hotStandby } = classifyChecks(checks, { lifecycle });
+  const opportunities = opportunitiesFromFindings(pages);
+  const wins = parity.dimensions.filter((d) => d.improved);
+
+  const out = [];
+  // The title states the LIFECYCLE, not the gate number. "Step 8" is an internal position in a
+  // playbook and means nothing to the merchant reading this; what they need to know is that the
+  // standby site is built and running, and that this is the readiness case for cutting over.
+  out.push(hotStandby
+    ? `# Hot standby active — go-live readiness for ${tenant}`
+    : `# Go-live readiness — ${tenant}`);
+  out.push("");
+  out.push(`_Prepared ${generatedAt} from an automated validation run of your new site. Every `
+    + `number below is measured on your real pages, not estimated._`);
+  out.push("");
+
+  if (hotStandby) {
+    out.push("> **This migration is in HOT STANDBY.** The merchant's live site is untouched and "
+      + "serving normally. Everything here is a parallel build, so nothing in this report blocks "
+      + "anyone today — the open items are **decisions to make before cutover**, not faults to "
+      + "clear before work continues.");
+    out.push("");
+  }
+
+  // ---- The headline. Lead with the outcome, in their numbers.
+  out.push("## What the merchant gets");
+  out.push("");
+  if (wins.length > 0) {
+    out.push(`Measured against **their own site**, captured before any change, across `
+      + `${parity.measured} page(s):`);
+    out.push("");
+    out.push(table(
+      parity.dimensions.map((d) => [
+        d.label,
+        String(d.source),
+        `**${d.migrated}**`,
+        d.delta > 0 ? `**+${d.delta}**` : String(d.delta),
+        d.improved ? "better" : (d.delta === 0 ? "held" : "below source"),
+      ]),
+      ["", "Their site today", "Migrated", "Change", ""],
+      ["", "r", "r", "r", ""],
+    ));
+    out.push("");
+    const best = [...wins].sort((a, b) => b.delta - a.delta)[0];
+    out.push(`The headline: **${best.label.toLowerCase()} ${best.source} → ${best.migrated}** `
+      + `on the same pages, same tests. That gap is the argument for cutting over.`);
+    out.push("");
+    const byProfile = summariseByProfile(pages);
+    if (byProfile.length > 0) {
+      out.push("#### Phone and desktop, measured separately");
+      out.push("");
+      out.push("_Each is compared against a baseline captured on the same kind of device. They "
+        + "are different measurements and are never averaged together._");
+      out.push("");
+      out.push(table(
+        byProfile.flatMap((p) => p.dimensions.map((d, i) => [
+          i === 0 ? `**${p.label}**` : "",
+          d.label, String(d.source), `**${d.migrated}**`,
+          d.delta > 0 ? `**+${d.delta}**` : String(d.delta),
+        ])),
+        ["", "", "Their site", "Migrated", "Change"],
+        ["", "", "r", "r", "r"],
+      ));
+    }
+    out.push("");
+    // The STANDARD, stated from the run's own bands rather than a constant here — otherwise the
+    // report can describe a bar the gate is not enforcing. The obligation is parity with their
+    // own site; anything above it is value they did not have.
+    out.push(`<sub>The bar is their own site: the migration owed parity within `
+      + `${parity.tolerance} point(s), and anything more than ${parity.ceiling} above it is value `
+      + `they did not have before.</sub>`);
+  } else if (parity.measured === 0 && baselineRoutes > 0) {
+    // The baseline EXISTS; this run just did not measure the migrated side (a --no-lighthouse
+    // fast pass). Saying "no baseline" here would send someone to capture one, and re-capturing
+    // after cutover overwrites a real source reading with a post-cutover one — destroying the
+    // only unrecoverable artifact in the whole migration to fix a problem that was never there.
+    out.push(`_This run did not measure the migrated side, so no before/after can be shown. The `
+      + `source baseline is intact (${baselineRoutes} route(s)) — do NOT re-capture it. Re-run `
+      + `validation with Lighthouse enabled to fill this section._`);
+  } else if (parity.measured === 0) {
+    out.push("_No source baseline was available for comparison, so the before/after claim cannot "
+      + "be made. Capture it BEFORE cutover — once the domain moves, the original is gone and "
+      + "this becomes unanswerable._");
+  } else {
+    out.push("_The migration holds parity with the source; no dimension improved on average._");
+  }
+  out.push("");
+
+  // THE BAR IS THEIR OWN MEASURED SITE, not a number we invented. The migration's obligation
+  // is parity: the merchant keeps what they had, within a tolerance. Anything further is value
+  // they never had. An absolute floor would judge them against a standard they may never have
+  // met and would mislabel free value as a shortfall — measured here, best-practices 73 -> 81
+  // is EIGHT POINTS DELIVERED FREE, and an invented 90 floor reported it as "9 short".
+  //
+  // So the bands come from the run's own verdicts (see lighthouse-parity.mjs): below
+  // source-tolerance is a regression and the only real failure; within the band is the
+  // obligation met; above source+ceiling is a giveaway, which is the upsell proof.
+  const byVerdict = (v) => parity.dimensions.filter((d) => d.verdict === v);
+  const giveaways = byVerdict("giveaway");
+  // LOST means the number went DOWN. A dimension that tied is not a loss and must never be
+  // listed as one — a merchant reading "below what they have today" against 94 -> 94 stops
+  // believing the rest of the page, and rightly. The per-page verdict can be `regression` while
+  // the site-wide average ties, so the average is what this section reports on.
+  const regressions = byVerdict("regression").filter((d) => d.migrated < d.source);
+
+  // No separate "delivered free" table: it restated the same rows the comparison above already
+  // shows, and a second pass over identical numbers reads as selling rather than reporting.
+  if (regressions.length > 0) {
+    out.push("### Below what they have today — must be decided");
+    out.push("");
+    out.push("_These are the only numbers that represent something LOST. Everything else either "
+      + "held or improved._");
+    out.push("");
+    out.push(table(
+      regressions.map((d) => [
+        d.label, String(d.source), `**${d.migrated}**`, String(d.migrated - d.source),
+      ]),
+      ["", "Their site today", "Migrated", "Change"],
+      ["", "r", "r", "r"],
+    ));
+    out.push("");
+  }
+
+  if (baselineRoutes > 0) {
+    out.push(`<sub>Source baseline: ${baselineRoutes} route(s)`
+      + `${baselineCapturedAt ? `, captured ${baselineCapturedAt}` : ""}. `
+      + `Not re-derivable after cutover.</sub>`);
+    out.push("");
+  }
+
+  // ---- What is proven.
+  out.push("## What is confirmed");
+  out.push("");
+  if (confirmed.length > 0) {
+    out.push(table(
+      confirmed
+        // "No open LOW-risk issues" is not a confirmation, it is the absence of the least
+        // important thing. The severity table below says what is actually open.
+        .filter((c) => !/low-risk/i.test(String(c.area ?? "")))
+        // "All 8 page checks passed" says nothing about WHAT passed. Every check already carries
+        // a `why` describing its scope; printing the result without it makes a real audit read
+        // like a progress bar.
+        .map((c) => [
+          c.area,
+          String(c.why ?? "").replace(/\|/g, "/") || "—",
+          String(c.problem ?? "").replace(/\|/g, "/"),
+        ]),
+      ["Checked", "What it covers", "Result"],
+    ));
+  } else {
+    out.push("_This validation run did not complete. Treat the report as incomplete — we will "
+      + "re-run it before anything is decided._");
+  }
+  out.push("");
+
+  // SEVERITY, NOT ABSENCE-OF-TRIVIA. This used to report "no open low-risk issues" — an
+  // absence at the bottom of the severity scale, printed as reassurance, while 8 HIGH issues
+  // sat unmentioned in the same totals object. A reader takes "nothing open" from it and is
+  // wrong in the most expensive direction, so the counts that matter are stated first and the
+  // clean case has to EARN its sentence.
+  if (totals.pages) {
+    out.push(`<sub>${totals.pages} page(s) validated end to end: routing, SEO, security headers, `
+      + `accessibility, mobile layout and the commerce boundary.</sub>`);
+    out.push("");
+  }
+
+  // ---- What is open, split by WHICH MILESTONE IT BLOCKS.
+  //
+  // A single list forces the merchant to work out for themselves whether their standby site is
+  // in trouble or merely unpolished. Those are opposite conclusions, and the severity counts
+  // belong with the split rather than floating above it: "8 high" means one thing if it blocks
+  // the parallel build and something much smaller if it is go-live polish.
+  // PROVENANCE IS PART OF THE STATUS, not a footnote. "A machine checked this five minutes ago"
+  // and "someone typed yes last month" are different claims with different decay, and collapsing
+  // them is how a stale hand-entered tick ends up justifying a cutover. `detected` is reserved
+  // for a real automated check; until one exists, every record here is `recorded` and says so.
+  const syncRow = (key, label, required) => {
+    const rec = commerceSync[key] ?? {};
+    const confirmed = rec.status === "confirmed";
+    const notApplicable = rec.status === "not-selected";
+    const via = rec.detectedAt ? "detected" : (confirmed ? "recorded by a person" : null);
+    return {
+      key, label, required, confirmed, notApplicable, via,
+      state: confirmed ? "Confirmed" : (notApplicable ? "Not selected" : "NOT CONFIRMED"),
+      evidence: rec.evidence ?? null,
+      at: rec.detectedAt ?? rec.confirmedAt ?? null,
+    };
+  };
+  const syncRows = [
+    syncRow("orderSync", "Order sync", true),
+    syncRow("productSync", "Product sync", true),
+  ];
+  // Required sync that is not proven. Unproven is not a soft state here: hot standby's
+  // whole claim is that this store could take over, and it cannot if commerce does not move.
+  const unprovenSync = syncRows.filter((r) => r.required && !r.confirmed);
+
+  // Sync is reported under HOT STANDBY, where it blocks. It is deliberately absent here:
+  // listing it in both places is the duplication this merge existed to remove.
+  const gates = [];
+  for (const row of syncRows.filter((r) => r.confirmed || r.notApplicable)) {
+    const status = row.confirmed
+      ? `**${row.state}**${row.via ? ` (${row.via}${row.at ? `, ${String(row.at).slice(0, 10)}` : ""})` : ""}`
+      : row.state;
+    gates.push([
+      `${row.label}${row.required ? " — **required**" : " — optional"}`,
+      status,
+      row.confirmed
+        ? (row.evidence ? String(row.evidence).replace(/\|/g, "/") : "Confirmed; nothing outstanding.")
+        : (row.notApplicable
+          ? "Not selected for your store."
+          : `This connects to your existing store rather than the new site, so our automated site `
+            + `checks cannot confirm it. It needs ${row.label.toLowerCase()} run end to end — test `
+            + `mode is fine at this stage — and the result recorded, so launch day is not where it `
+            + `first gets tested.`),
+    ]);
+  }
+  if (!styleGuideApproved) {
+    gates.push([
+      "Style-guide sign-off",
+      "NOT APPROVED",
+      "Someone needs to approve the visual standard your site is built to. Nothing is wrong "
+        + "with it — no approval has been recorded yet. One reviewer closes this.",
+    ]);
+  }
+  if (unsourcedComponents.length > 0) {
+    gates.push([
+      "Merchant-supplied trust content",
+      `${unsourcedComponents.length} awaiting your content`,
+      `${unsourcedComponents.join(", ")} currently show as placeholders. These make claims to `
+        + "your customers, so they need real evidence behind them and we will not invent it. "
+        + "Send us the genuine rating, badge, guarantee terms, testimonial or logos and we will "
+        + "publish them.",
+    ]);
+  }
+
+  const issues = totals.issues ?? {};
+  // Unproven required sync IS a blocker, so it must appear in the blocker count. Printing
+  // "0 blocker" directly above two rows labelled BLOCKER is the kind of self-contradiction that
+  // costs a reader their trust in every other number on the page.
+  const blocker = (issues.blocker ?? 0) + unprovenSync.length;
+  const high = issues.high ?? 0;
+  const medium = issues.medium ?? 0;
+  const standbyRisks = risks.filter((c) => blocksHotStandby(c.area));
+  const goLiveRisks = risks.filter((c) => !blocksHotStandby(c.area));
+
+  out.push("## What is open");
+  out.push("");
+  if (blocker + high + medium > 0 || issues.total) {
+    out.push(`Across ${totals.pages ?? 0} page(s): **${blocker} blocker**, **${high} high**, `
+      + `${medium} medium. `
+      + (blocker === 0 && high === 0
+        ? "Nothing at blocker or high severity is open."
+        : "The high-severity items are the ones worth a person's time; the specific audits behind "
+          + "them are itemised under **Raise a score**."));
+    out.push("");
+  }
+
+  out.push("### Blocks hot standby");
+  out.push("");
+  const standbyRows = [
+    ...unprovenSync.map((r) => [
+      `**${r.label} — BLOCKER**`,
+      `${r.state}. A standby store that cannot move ${r.label.toLowerCase().replace(" sync", "s")} `
+        + "is not standing by for anything.",
+      "Run it end to end against your existing store and record the result. Our automated "
+        + "checks cannot confirm this for you today, so it has to be demonstrated and signed off "
+        + "by a person before the standby store can be considered ready.",
+    ]),
+    ...standbyRisks.map((c) => [c.area, whyItMatters(c), whoCloses(c)]),
+  ];
+  if (standbyRows.length === 0) {
+    out.push("**Nothing.** The parallel site is built, faithful and serving: routes resolve, the "
+      + "commerce boundary holds, no secrets leak, SEO and sitemap are intact, and commerce sync "
+      + "is proven. Hot standby is not at risk from anything in this run.");
+  } else {
+    out.push(`**Hot standby is NOT cleared.** ${standbyRows.length} item(s) below must be closed `
+      + "first — these affect whether the standby site is a faithful, serving copy that could "
+      + "actually take over, which is the whole claim hot standby makes.");
+    out.push("");
+    out.push(table(standbyRows, ["Item", "What we found", "What closes it"]));
+  }
+  out.push("");
+
+  // WHAT IS ALREADY WORKING. A list of only the broken things is not a status report — it is a
+  // complaint, and it leaves the merchant with no sense of how much of their store already
+  // stands up. Every row here is something this run actually confirmed.
+  const workingRows = confirmed
+    .filter((c) => !/low-risk/i.test(String(c.area ?? "")))
+    .map((c) => [c.area, whyItMatters(c)]);
+  if (workingRows.length > 0) {
+    out.push("### Already working on the standby store");
+    out.push("");
+    out.push("_Live and confirmed on your standby site right now — measured in this run, not "
+      + "assumed._");
+    out.push("");
+    out.push(table(workingRows, ["Working", "What that means for you"]));
+    out.push("");
+  }
+
+  out.push("### Blocks Storefront go-live");
+  out.push("");
+  if (goLiveRisks.length === 0) {
+    out.push("**Nothing.** Every go-live check passed.");
+  } else {
+    out.push(hotStandby
+      ? "_None of these stop work today — the live site is untouched. Each is a decision to "
+        + "settle before the domain moves and checkout is switched on, and each is cheaper to "
+        + "settle now than after._"
+      : "_These must clear before the domain moves._");
+    out.push("");
+    out.push(table(
+      goLiveRisks.map((c) => [c.area, whyItMatters(c), whoCloses(c)]),
+      ["Area", "Why it matters", "What closes it"],
+    ));
+  }
+  out.push("");
+
+  // COMMERCE READINESS IS PART OF GO-LIVE, not a section of its own. It was a separate heading
+  // listing the same kind of thing — work that must be closed before the store can open — so a
+  // reader had to hold two lists and de-duplicate them mentally. One list, one place.
+  out.push("#### Turning the store on");
+  out.push("");
+  out.push("_None of this can be confirmed by inspecting the site: these are integrations, "
+    + "credentials and decisions. NOT CONFIRMED means no one has recorded a check yet — it does "
+    + "not mean broken, and it does not mean working._");
+  out.push("");
+  const goLiveRows = [
+    ...gates.map((g) => [g[0], g[1], g[2]]),
+    ...GO_LIVE_CHECKLIST.map((item) => {
+      const rec = goLive[item.key] ?? {};
+      const done = rec.status === "confirmed" || rec.status === "live";
+      const na = rec.status === "not-applicable";
+      return [
+        item.label,
+        done ? "**Confirmed**" : (na ? "Not applicable" : "NOT CONFIRMED"),
+        done
+          ? (rec.evidence ? String(rec.evidence).replace(/\|/g, "/") : "Confirmed; nothing outstanding.")
+          : (na ? "Not applicable to your store." : item.why),
+      ];
+    }),
+  ];
+  out.push(table(goLiveRows, ["Item", "Status", "What closes it"]));
+  out.push("");
+
+  const lifecycle_rows = addOnLifecycle(addOns);
+  if (lifecycle_rows.length > 0) {
+    out.push("#### Add-ons you have selected");
+    out.push("");
+    out.push("_Selected is not the same as live. Each has to be configured and then confirmed "
+      + "working, or launch day is when you find out something you paid for was never switched "
+      + "on._");
+    out.push("");
+    out.push(table(
+      lifecycle_rows.map((a) => [
+        a.label,
+        a.live ? "**Live**" : (a.state === "configured" ? "Configured — awaiting confirmation" : "Selected — not yet configured"),
+        a.live ? "Confirmed working." : "We complete this before go-live and confirm it back to you.",
+      ]),
+      ["Add-on", "Status", "What happens next"],
+    ));
+    out.push("");
+  }
+  out.push("");
+
+  // ---- Commerce plumbing. The site being fast is not the business question; whether ORDERS
+  // FLOW is. A hot-standby tenant is non-public and processes no live transactions by contract,
+  // so the question here is never "is it live" — it is "is it PROVEN before we flip", because
+  // cutover is the worst possible moment to discover order sync was never exercised.
+
+  // ONE table. The sync rows and the human gates were two tables in which "order sync" appeared
+  // twice — once as a status and again as a task — so the reader had to work out it was a single
+  // thing. Status, why it is open, and what closes it are three columns of one row, not two
+  // tables joined by the reader.
+
+
+  // ---- Add-ons: what we could do next, priced in effort.
+  out.push("## Additional options");
+  out.push("");
+  out.push("_The migration's obligation is parity: the merchant keeps everything they had. "
+    + "Everything below is value they never had, so it is optional and separately scoped._");
+  out.push("");
+  const offers = deriveAddOns({
+    parity, unsourcedComponents, styleGuideApproved, syncRows, addOns, opportunities,
+  });
+
+  // The measured audit items ARE the scope of a score lift, so they belong inside the dimension
+  // they would raise — not in a separate list a reader has to cross-reference. "Speed +8
+  // available" is a claim; "+8 available, and here are the six audits that get you there" is a
+  // quote someone can act on.
+  const byCategory = (dim) => opportunities.filter((o) => (o.categories ?? []).includes(dim));
+  out.push("### Raise a score");
+  out.push("");
+  out.push("_Every dimension is listed, measured or not. Headroom is the distance to 100 on this "
+    + "run — what is still buyable above what the migration already delivered. The work named is "
+    + "what this site's own audit found, not a generic list._");
+  out.push("");
+  out.push(table(
+    offers.dimensionRows.map((d) => {
+      const found = byCategory(d.dimension);
+      const work = found.length === 0
+        ? "—"
+        : found.slice(0, 4).map((o) => `${o.title.replace(/\|/g, "/")} (${o.pageCount}p`
+          + `${o.effort ? `, ${o.effort}` : ""})`).join("; ")
+          + (found.length > 4 ? `; +${found.length - 4} more` : "");
+      return [d.label, d.today == null ? "—" : String(d.today), d.state, d.buys, work];
+    }),
+    ["Dimension", "Today", "Headroom", "What buying it delivers", "The work this site needs"],
+    ["", "r", "", "", ""],
+  ));
+  out.push("");
+  if (opportunities.length > 0) {
+    out.push("<sub>Work items are this run's own audit findings, with page reach and a rough "
+      + "size. Projections are deliberately absent: a rough number that reads as a commitment is "
+      + "worse than no number.</sub>");
+    out.push("");
+  }
+
+  if (offers.standing.length > 0) {
+    out.push("### Platform and services");
+    out.push("");
+    out.push(table(
+      offers.standing.map((a) => [a.label, a.buys, a.status]),
+      ["Option", "What it buys", "Status"],
+    ));
+    out.push("");
+  }
+
+  out.push("---");
+  out.push("");
+  out.push("<sub>Generated automatically from a full validation run of the standby site. "
+    + "Figures refresh on every run.</sub>");
+  return `${out.join("\n")}\n`;
+}
+
+/**
+ * The IMPLEMENTOR's companion report.
+ *
+ * The merchant-facing report answers "should we launch, and what do you need from me". This
+ * answers "what exactly failed and what do I run" — gate counts, CSS structure, tooling names,
+ * verbatim remediation. Both are generated from the same run so they cannot disagree; splitting
+ * them is what lets the merchant document speak plainly without deleting the detail somebody
+ * actually needs to close the work.
+ */
+export function buildImplementorReport(input) {
+  const {
+    tenant, generatedAt, lifecycle = "hot-standby", checks = [], totals = {},
+    pages = [], commerceSync = {},
+  } = input;
+  const { confirmed, risks } = classifyChecks(checks, { lifecycle });
+  const issues = totals.issues ?? {};
+  const out = [];
+
+  out.push(`# Implementor detail — ${tenant}`);
+  out.push("");
+  out.push(`_Generated ${generatedAt}. Companion to \`go-live-report.md\`, which is the `
+    + "merchant-facing document — this one carries the verbatim gate output. Both come from the "
+    + "same run; regenerate rather than hand-editing either._");
+  out.push("");
+  out.push(`Lifecycle: **${lifecycle}** · pages ${totals.pages ?? 0} `
+    + `(${totals.passing ?? 0} passing, ${totals.failing ?? 0} failing) · issues `
+    + `${issues.total ?? 0} (blocker ${issues.blocker ?? 0}, high ${issues.high ?? 0}, `
+    + `medium ${issues.medium ?? 0}, low ${issues.low ?? 0})`);
+  out.push("");
+
+  out.push("## Open gates — verbatim");
+  out.push("");
+  if (risks.length === 0) {
+    out.push("_No open gates._");
+  } else {
+    out.push(table(
+      risks.map((c) => [
+        c.area,
+        blocksHotStandby(c.area) ? "**hot standby**" : "go-live",
+        String(c.status ?? "").replace(/\|/g, "/"),
+        String(c.problem ?? "").replace(/\|/g, "/"),
+        String(c.fix ?? "").replace(/\|/g, "/"),
+      ]),
+      ["Area", "Blocks", "Status", "Problem", "Fix"],
+    ));
+  }
+  out.push("");
+
+  out.push("## Commerce sync records");
+  out.push("");
+  out.push(table(
+    ["orderSync", "productSync"].map((key) => {
+      const rec = commerceSync[key] ?? {};
+      return [
+        key,
+        rec.status ?? "(absent)",
+        rec.detectedAt ? `detected ${rec.detectedAt}` : (rec.confirmedAt ? `recorded ${rec.confirmedAt}` : "—"),
+        rec.evidence ? String(rec.evidence).replace(/\|/g, "/") : "—",
+      ];
+    }),
+    ["Key", "status", "provenance", "evidence"],
+  ));
+  out.push("");
+  out.push("_Written to the store checkout's `.tot/migration-state.json` under `commerceSync`. Both are "
+    + "REQUIRED for hot standby. No automated status read exists yet — tracked as a critical "
+    + "platform gap, so today this is a recorded human confirmation._");
+  out.push("");
+
+  out.push("## Per-page measurement");
+  out.push("");
+  const measured = pages.filter((p) => p && p.slug);
+  if (measured.length === 0) {
+    out.push("_No per-page Lighthouse artifacts in this run._");
+  } else {
+    out.push(table(
+      measured.map((p) => {
+        const dims = p.dimensions ?? {};
+        const verdicts = Object.entries(dims)
+          .filter(([, d]) => d?.verdict && d.verdict !== "parity")
+          .map(([k, d]) => `${k}:${d.verdict}`);
+        return [
+          p.slug,
+          Object.entries(p.scores ?? {}).map(([k, v]) => `${k.slice(0, 4)} ${v}`).join(", ") || "—",
+          verdicts.join(", ") || "all parity",
+          p.unmeasured ? `**${p.unmeasured}**` : "—",
+        ];
+      }),
+      ["Slug", "Scores", "Non-parity verdicts", "Unmeasured"],
+    ));
+  }
+  out.push("");
+
+  out.push("## Passing gates");
+  out.push("");
+  out.push(confirmed.length > 0
+    ? table(confirmed.map((c) => [c.area, String(c.problem ?? "").replace(/\|/g, "/")]),
+      ["Area", "Result"])
+    : "_None passed._");
+  out.push("");
+  return `${out.join("\n")}\n`;
+}