@intentius/behold 0.29.7 → 0.29.8

package/web/kiosk-vendor.js

@@ -0,0 +1,380 @@
+// behold#571: a kiosk page per tool, `/<tool>`, that the tool's maker can
+// share without it promoting a competitor (COMPETES). It shows that tool's scenarios
+// alone: its name (and its logo where its owner allows one), its runs only,
+// and a footer saying who makes it and that they don't endorse the demo.
+//
+// Live when demo.json's `tool` is this tool, as /kiosk shows it. Otherwise a
+// replay of the tool's newest cycle that ran to its reset
+// (`cycles/<tool>/latest.json`, which the loop driver publishes), stepped at
+// the pace it was recorded, until the tool's scenario starts again.
+//
+// Pure functions here; kiosk.js draws them.
+
+/**
+ * Each tool with a page: its name as its owner writes it, its owner, its
+ * official site, its logo when its owner's published rules allow one (else
+ * null, the name as text), and the footer's credit. `terms` are the words
+ * that name the tool or its owner. `kind` is what it competes as (see
+ * COMPETES): an `engine` plans and applies, an `orchestrator` drives an
+ * engine. Keep the keys in step with VENDOR_TOOLS in src/terragucci-demo.ts.
+ *
+ * - Terraform: HashiCorp's rules allow the name as text, with the mark noted.
+ * - Terragrunt: Gruntwork publishes logo files, but a logo on a page like
+ *   this reads as a partnership, so the name is text.
+ * - CDK Terrain: the Open Construct Foundation's continuation of CDKTF; its
+ *   site, cdktn.io, publishes no rules for its logo, so the name is text.
+ * - choudoufu: ours, logo and all.
+ */
+export const VENDORS = {
+  terraform: {
+    name: "Terraform",
+    owner: "HashiCorp",
+    url: "https://developer.hashicorp.com/terraform",
+    logo: null,
+    credit: "Terraform is a trademark of HashiCorp. HashiCorp makes Terraform and does not endorse this demo.",
+    kind: "engine",
+    terms: ["Terraform", "HashiCorp"],
+    // The demo's Terraform roots run in OpenTofu's image (terragucci's stack/demo.sh).
+    runsWith: ["opentofu"],
+  },
+  terragrunt: {
+    name: "Terragrunt",
+    owner: "Gruntwork, Inc.",
+    url: "https://terragrunt.com/",
+    logo: null,
+    credit: "Terragrunt is made by Gruntwork, Inc., who don't endorse this demo.",
+    kind: "orchestrator",
+    terms: ["Terragrunt", "Gruntwork"],
+    runsWith: [],
+  },
+  "cdk-terrain": {
+    name: "CDK Terrain",
+    owner: "the Open Construct Foundation",
+    url: "https://cdktn.io/",
+    logo: null,
+    credit: "CDK Terrain is made by the Open Construct Foundation, who don't endorse this demo.",
+    kind: "orchestrator",
+    terms: ["CDK Terrain", "CDKTN", "Open Construct"],
+    runsWith: [],
+  },
+  choudoufu: {
+    name: "choudoufu",
+    owner: "Intentius",
+    url: "https://intentius.io/choudoufu/",
+    logo: { src: "/vendors/choudoufu-64.png", src2x: "/vendors/choudoufu-128.png" },
+    credit: "choudoufu is made by Intentius, who also make this demo. It supports AWS and Kubernetes.",
+    kind: "engine",
+    terms: ["choudoufu"],
+    runsWith: [],
+  },
+};
+
+/** What a tool's scenarios run on, said on its page as the owner's rules allow ("works with OpenTofu"). */
+export const RUNS_WITH = {
+  opentofu: {
+    name: "OpenTofu",
+    url: "https://opentofu.org/",
+    words: "The pipeline here works with OpenTofu, which runs these roots.",
+    kind: "engine",
+    terms: ["OpenTofu"],
+  },
+};
+
+/**
+ * Tools with no page yet that a page still must not promote: orchestrators
+ * that compete with Terragrunt and CDK Terrain.
+ */
+export const COMPETITORS = {
+  atmos: { kind: "orchestrator", terms: ["Atmos", "Cloud Posse"] },
+  terramate: { kind: "orchestrator", terms: ["Terramate"] },
+};
+
+/**
+ * What competes with what. Engines compete with engines (Terraform, OpenTofu,
+ * choudoufu); orchestrators with orchestrators (Terragrunt, CDK Terrain,
+ * Atmos, Terramate). An orchestrator runs on an engine, so its page names the
+ * engine freely; an engine's page names no other engine, but for the one its
+ * scenarios really run with (`runsWith`).
+ */
+export const COMPETES = { engine: "engine", orchestrator: "orchestrator" };
+
+const own = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+
+/** A tool's entry, or null for a tool with no page. */
+export function vendorOf(tool) {
+  return typeof tool === "string" && own(VENDORS, tool) ? VENDORS[tool] : null;
+}
+
+/** The tool the page was served for (`<meta name="kiosk-tool">`, src/terragucci-demo.ts), or null on /kiosk. */
+export function pageTool(doc) {
+  const m = doc && doc.querySelector ? doc.querySelector('meta[name="kiosk-tool"]') : null;
+  const t = m ? m.getAttribute("content") : null;
+  return vendorOf(t) ? t : null;
+}
+
+/**
+ * The words no page for `tool` may show: each competitor's name and maker's,
+ * the competitors being the other tools of its kind, less what its scenarios
+ * run with. A page for no tool (/kiosk) has none.
+ */
+export function otherTerms(tool) {
+  const v = vendorOf(tool);
+  if (!v) return [];
+  const rivals = COMPETES[v.kind];
+  const out = [];
+  for (const [id, x] of [...Object.entries(VENDORS), ...Object.entries(RUNS_WITH), ...Object.entries(COMPETITORS)]) {
+    if (id === tool || x.kind !== rivals || v.runsWith.includes(id)) continue;
+    out.push(...x.terms);
+  }
+  return out;
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * Whether `text` names a competitor of `tool` or its maker, as a whole word
+ * in any case. A word inside an identifier is no brand: `terraform_data` is a
+ * resource type and `demo-terraform-state` a bucket.
+ */
+export function namesOther(text, tool) {
+  if (typeof text !== "string" || !text) return false;
+  return otherTerms(tool).some((t) => new RegExp(`(?<![\\w./-])${escapeRe(t)}(?![\\w/-])`, "i").test(text));
+}
+
+/**
+ * demo.json as a tool's page shows it: no count of the loop's scenarios or
+ * place in it (they would hint at the others), and any text the driver wrote
+ * that names a competitor left out: the intro, a card row, the title (the
+ * scenario's name instead), the step's line, the next action.
+ */
+export function scrubDemo(demo, tool) {
+  if (!demo) return demo;
+  const keep = (t) => (namesOther(t, tool) ? null : t);
+  const about = demo.about
+    ? Object.fromEntries(Object.entries(demo.about).filter(([, t]) => !namesOther(t, tool)))
+    : null;
+  const name = keep(demo.name);
+  return {
+    ...demo,
+    scenarios: null,
+    index: null,
+    intro: keep(demo.intro),
+    name,
+    title: keep(demo.title) ?? name ?? "",
+    label: keep(demo.label) ?? "",
+    about: about && Object.keys(about).length ? about : null,
+    next: demo.next ? { ...demo.next, action: keep(demo.next.action) ?? "the next step" } : null,
+  };
+}
+
+/**
+ * The tool a demo.json write is about. A driver before behold#571 wrote no
+ * `tool`, and ran Terraform scenarios only: a scenario the kiosk knows
+ * (`known`, kiosk.js SCENARIOS) is Terraform's then.
+ */
+export function demoTool(demo, known = {}) {
+  if (!demo) return null;
+  if (typeof demo.tool === "string" && demo.tool) return demo.tool;
+  return own(known, demo.scenario) ? "terraform" : null;
+}
+
+/** Whether demo.json is live for this tool's page: its scenario is the tool's, and it is no base. */
+export function liveFor(demo, tool, known = {}) {
+  return !!demo && demo.scenario !== "base" && demoTool(demo, known) === tool;
+}
+
+/**
+ * Whether a run belongs on the tool's page: a run of its repo. A run with no
+ * `repo` is matched by its `tool`; a run with neither comes from a driver
+ * before behold#571, which ran Terraform's repo alone.
+ */
+export function keepRun(run, { tool, repo }) {
+  if (!run) return false;
+  if (typeof run.repo === "string" && run.repo) return !!repo && run.repo === repo;
+  if (typeof run.tool === "string" && run.tool) return run.tool === tool;
+  return tool === "terraform";
+}
+
+/** The runs index with only the tool's runs; any other answer as it came. */
+export function filterIndex(index, which) {
+  if (!index || !index.doc || !Array.isArray(index.doc.runs)) return index;
+  return { ...index, doc: { ...index.doc, runs: index.doc.runs.filter((r) => keepRun(r, which)) } };
+}
+
+/**
+ * Whether this behold serves the repo: the reports' project (`<host>/<path>`)
+ * ends with the repo's `<owner>/<name>`. The graph frame and the plan's facts
+ * are the served repo's, so a page for another repo shows neither.
+ */
+export function servesRepo(project, repo) {
+  if (typeof project !== "string" || typeof repo !== "string" || !project || !repo) return false;
+  const p = project.replace(/\.git$/, "").toLowerCase();
+  const r = repo.toLowerCase();
+  return p === r || p.endsWith(`/${r}`);
+}
+
+// ---------------------------------------------------------------------------
+// The replay.
+
+/** How long the replay holds its last step (the reset) before it starts again: the driver's hold. */
+export const REPLAY_LAST_HOLD_MS = 20_000;
+
+/** How long each step of a cycle was shown, in ms, from the `at` of the next one; the last one the hold. */
+export function stepDurations(steps) {
+  return steps.map((s, i) => {
+    if (i === steps.length - 1) return REPLAY_LAST_HOLD_MS;
+    const d = Date.parse(steps[i + 1].at) - Date.parse(s.at);
+    return Number.isFinite(d) && d > 0 ? d : 0;
+  });
+}
+
+/**
+ * Where the replay is, `elapsed` ms after it started, looping: the step's
+ * index, and the time it stands for (the step's `at` plus the time into it),
+ * which the page reads as now while it replays. `{ index, at, loop }`.
+ */
+export function replayAt(steps, elapsed) {
+  const ds = stepDurations(steps);
+  const loop = ds.reduce((a, b) => a + b, 0);
+  let t = loop > 0 ? ((elapsed % loop) + loop) % loop : 0;
+  for (let i = 0; i < steps.length; i++) {
+    if (t < ds[i] || i === steps.length - 1) return { index: i, at: new Date(Date.parse(steps[i].at) + Math.min(t, ds[i])), loop };
+    t -= ds[i];
+  }
+  return { index: 0, at: new Date(Date.parse(steps[0].at)), loop };
+}
+
+const ms = (v) => (v ? Date.parse(v) : NaN);
+
+/** A job's or step's status at time `t`: queued before it started, running before it ended, then as it ended. */
+function statusAt(o, t) {
+  if (o.status === "skipped") return { status: "skipped", started_at: o.started_at ?? null, ended_at: o.ended_at ?? null };
+  const s = ms(o.started_at);
+  const e = ms(o.ended_at);
+  if (!Number.isNaN(s) && t < s) return { status: "queued", started_at: null, ended_at: null };
+  if (!Number.isNaN(e) && t < e) return { status: "running", started_at: o.started_at, ended_at: null };
+  return { status: o.status, started_at: o.started_at ?? null, ended_at: o.ended_at ?? null };
+}
+
+/**
+ * A run as it stood at time `t` (ms), from the copy made when it ended: each
+ * job and step queued before it started and running until it ended, a
+ * running step's log cut to the share of its time gone by.
+ */
+export function runAsOf(run, t) {
+  if (!run) return run;
+  const out = { ...run, ...statusAt(run, t) };
+  if (Array.isArray(run.jobs)) {
+    out.jobs = run.jobs.map((j) => {
+      const jo = { ...j, ...statusAt(j, t) };
+      if (Array.isArray(j.steps)) {
+        jo.steps = j.steps.map((st) => {
+          const so = { ...st, ...statusAt(st, t) };
+          const log = Array.isArray(st.log) ? st.log : [];
+          if (so.status === "queued") so.log = [];
+          else if (so.status === "running") {
+            const a = ms(st.started_at);
+            const b = ms(st.ended_at);
+            const share = b > a ? Math.min(1, Math.max(0, (t - a) / (b - a))) : 1;
+            so.log = log.slice(0, Math.ceil(log.length * share));
+          }
+          return so;
+        });
+      }
+      return jo;
+    });
+  }
+  return out;
+}
+
+/** The replay's runs index at time `t`: the cycle's runs that had been created by then, newest first, as they stood. */
+export function replayIndex(runs, t) {
+  const shown = runs.filter((r) => {
+    const c = ms(r.created_at || r.started_at);
+    return Number.isNaN(c) || c <= t;
+  });
+  return { doc: { schema: "demo.runs/v1", runs: shown.sort((a, b) => b.id - a.id).map((r) => runAsOf(r, t)) } };
+}
+
+/** "14:05", a time's hours and minutes in UTC; null for no time. */
+export function hhmm(iso) {
+  const t = Date.parse(iso || "");
+  if (Number.isNaN(t)) return null;
+  const d = new Date(t);
+  return `${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")}`;
+}
+
+const counted = (n) => Number.isInteger(n) && n > 0;
+
+/**
+ * About how many minutes until the tool's scenario is live again, from the
+ * loop's order and the length of the tool's latest cycle: what is left of
+ * the scenario live now, and a cycle's length for each scenario between it
+ * and the tool's. Null when the loop's order isn't known (no index, a base,
+ * or a loop of another length than the one the cycle ran in).
+ */
+export function liveEstimate(live, cycle, now = new Date()) {
+  if (!live || !cycle || !cycle.steps || !cycle.steps.length) return null;
+  const first = cycle.steps[0];
+  const n = live.scenarios;
+  const i = live.index;
+  const j = first.index;
+  if (!counted(n) || !counted(i) || !counted(j) || first.scenarios !== n || j > n || i > n) return null;
+  const len = ms(cycle.ended) - ms(cycle.started);
+  if (!(len > 0)) return null;
+  const into = now.getTime() - ms(live.started_at);
+  if (Number.isNaN(into)) return null;
+  const ahead = (j - i - 1 + n) % n;
+  const left = Math.max(0, len - into);
+  return Math.max(1, Math.round((left + ahead * len) / 60_000));
+}
+
+/** The replay's banner: "Replay of the run at 14:05 UTC · live again in about 6 min", without the estimate when there is none. */
+export function replayBanner(cycle, minutes) {
+  const at = hhmm(cycle && (cycle.started || (cycle.steps && cycle.steps[0] && cycle.steps[0].at)));
+  const head = at ? `Replay of the run at ${at} UTC` : "Replay of the latest run";
+  return Number.isInteger(minutes) && minutes > 0 ? `${head} · live again in about ${minutes} min` : head;
+}
+
+/** The page's words when the tool's scenario has no cycle yet. */
+export function notRunWords(vendor) {
+  return {
+    title: "This scenario hasn't run yet",
+    text: `The ${vendor.name} scenario shows here once it has run through the demo's pipeline.`,
+  };
+}
+
+/** The legend's words, without naming a competing engine on an engine's page. */
+export function rootWord(tool) {
+  return namesOther("Terraform", tool) ? "a root" : "a Terraform root";
+}
+
+/**
+ * A line of text with names in it made links: `[{ text }, { text, url }, …]`,
+ * the first time each name appears. Every name a page shows links to its
+ * official site.
+ */
+export function linkSegments(text, links) {
+  let out = [{ text }];
+  for (const l of links) {
+    const i = out.findIndex((x) => !x.url && x.text.includes(l.name));
+    if (i < 0) continue;
+    const x = out[i].text;
+    const at = x.indexOf(l.name);
+    const parts = [{ text: x.slice(0, at) }, { text: l.name, url: l.url }, { text: x.slice(at + l.name.length) }].filter((p) => p.text);
+    out = [...out.slice(0, i), ...parts, ...out.slice(i + 1)];
+  }
+  return out;
+}
+
+/** The footer's lines on a tool's page: the credit, and what its scenarios run with, each with its names linked. */
+export function creditLines(tool) {
+  const v = vendorOf(tool);
+  if (!v) return [];
+  const lines = [linkSegments(v.credit, [{ name: v.name, url: v.url }])];
+  for (const id of v.runsWith) {
+    const r = RUNS_WITH[id];
+    if (r) lines.push(linkSegments(r.words, [{ name: r.name, url: r.url }]));
+  }
+  return lines;
+}

package/web/kiosk-vendor.test.js

@@ -0,0 +1,265 @@
+// behold#571: the per-tool pages' pure parts: live or replay, the replay's pace, the runs kept, and the branding.
+import { describe, expect, it } from "vitest";
+import { VENDOR_TOOLS } from "../src/terragucci-demo.ts";
+import { logRows } from "./kiosk-runs.js";
+import { NO_GRAPH_WORDS, SCENARIOS, legendWords, scenarioHead } from "./kiosk.js";
+import {
+  REPLAY_LAST_HOLD_MS,
+  RUNS_WITH,
+  VENDORS,
+  creditLines,
+  demoTool,
+  filterIndex,
+  keepRun,
+  liveEstimate,
+  liveFor,
+  linkSegments,
+  namesOther,
+  notRunWords,
+  otherTerms,
+  replayAt,
+  replayBanner,
+  replayIndex,
+  rootWord,
+  runAsOf,
+  scrubDemo,
+  servesRepo,
+  stepDurations,
+} from "./kiosk-vendor.js";
+
+const demo = (extra = {}) => ({ cycle: 3, scenario: "b-waves", title: "A new subnet", step: "waiting", label: "Wave 2 waits", started_at: "2026-10-20T10:00:00Z", next: { action: "approve wave-2", at: null }, pull: 41, commit: "abc", about: null, intro: null, name: "a new subnet", scenarios: 3, index: 2, ...extra });
+
+describe("which tool a page is live for (behold#571)", () => {
+  it("is demo.json's tool, and Terraform's for a driver before it that ran a scenario the kiosk knows", () => {
+    expect(demoTool(demo({ tool: "terragrunt" }), SCENARIOS)).toBe("terragrunt");
+    expect(demoTool(demo(), SCENARIOS)).toBe("terraform");
+    expect(demoTool(demo({ scenario: "tg-new" }), SCENARIOS)).toBe(null);
+  });
+  it("is live only for the tool whose scenario runs, never on the base", () => {
+    expect(liveFor(demo({ tool: "terragrunt" }), "terragrunt", SCENARIOS)).toBe(true);
+    expect(liveFor(demo({ tool: "terragrunt" }), "terraform", SCENARIOS)).toBe(false);
+    expect(liveFor(demo({ tool: "terraform", scenario: "base" }), "terraform", SCENARIOS)).toBe(false);
+    expect(liveFor(null, "terraform", SCENARIOS)).toBe(false);
+  });
+});
+
+describe("the runs a tool's page keeps (behold#571)", () => {
+  const index = { doc: { schema: "demo.runs/v1", runs: [{ id: 3, repo: "admin/demo-terragrunt", tool: "terragrunt" }, { id: 2, repo: "admin/demo", tool: "terraform" }, { id: 1, tool: "terragrunt" }, { id: 0 }] } };
+  it("keeps the repo's runs, a run's tool without a repo, and a run with neither on Terraform's page alone", () => {
+    expect(filterIndex(index, { tool: "terragrunt", repo: "admin/demo-terragrunt" }).doc.runs.map((r) => r.id)).toEqual([3, 1]);
+    expect(filterIndex(index, { tool: "terraform", repo: "admin/demo" }).doc.runs.map((r) => r.id)).toEqual([2, 0]);
+    expect(keepRun({ id: 9, repo: "admin/demo" }, { tool: "terraform", repo: null })).toBe(false);
+  });
+  it("leaves an answer that is no index as it came", () => {
+    const absent = { doc: null, absent: "no runs" };
+    expect(filterIndex(absent, { tool: "terraform", repo: "x" })).toBe(absent);
+  });
+  it("shows the graph only for the repo this behold serves", () => {
+    expect(servesRepo("forgejo:3000/admin/demo", "admin/demo")).toBe(true);
+    expect(servesRepo("forgejo:3000/admin/demo", "admin/demo-terragrunt")).toBe(false);
+    expect(servesRepo("forgejo:3000/xadmin/demo", "admin/demo")).toBe(false);
+    expect(servesRepo(null, "admin/demo")).toBe(false);
+  });
+});
+
+describe("the replay's pace (behold#571)", () => {
+  const steps = [
+    { step: "pull-request", at: "2026-10-20T10:00:00Z" },
+    { step: "planned", at: "2026-10-20T10:00:40Z" },
+    { step: "merged", at: "2026-10-20T10:01:30Z" },
+    { step: "reset", at: "2026-10-20T10:03:00Z" },
+  ];
+  it("holds each step as long as it was recorded, and the last for the driver's hold", () => {
+    expect(stepDurations(steps)).toEqual([40_000, 50_000, 90_000, REPLAY_LAST_HOLD_MS]);
+  });
+  it("steps through at that pace, standing for the step's time plus the time into it, and loops", () => {
+    expect(replayAt(steps, 0).index).toBe(0);
+    expect(replayAt(steps, 39_999).index).toBe(0);
+    const p = replayAt(steps, 45_000);
+    expect(p.index).toBe(1);
+    expect(p.at.toISOString()).toBe("2026-10-20T10:00:45.000Z");
+    expect(replayAt(steps, 180_000).index).toBe(3);
+    const loop = 180_000 + REPLAY_LAST_HOLD_MS;
+    expect(replayAt(steps, 0).loop).toBe(loop);
+    expect(replayAt(steps, loop + 45_000).index).toBe(1);
+  });
+});
+
+describe("a run as it stood in the replay (behold#571)", () => {
+  const run = {
+    id: 7,
+    status: "success",
+    created_at: "2026-10-20T10:00:00Z",
+    started_at: "2026-10-20T10:00:00Z",
+    ended_at: "2026-10-20T10:01:40Z",
+    jobs: [
+      { id: 1, name: "plan", needs: [], status: "success", started_at: "2026-10-20T10:00:00Z", ended_at: "2026-10-20T10:01:40Z", steps: [{ name: "Plan", status: "success", started_at: "2026-10-20T10:00:00Z", ended_at: "2026-10-20T10:01:40Z", log: ["1", "2", "3", "4"] }] },
+      { id: 2, name: "fmt", needs: [], status: "skipped", started_at: null, ended_at: null, steps: [] },
+    ],
+  };
+  const t = (iso) => Date.parse(iso);
+  it("is queued before it started, running until it ended with its log so far, then as it ended", () => {
+    expect(runAsOf(run, t("2026-10-20T09:59:00Z")).jobs[0].status).toBe("queued");
+    const mid = runAsOf(run, t("2026-10-20T10:00:50Z"));
+    expect([mid.status, mid.ended_at, mid.jobs[0].status, mid.jobs[0].steps[0].log]).toEqual(["running", null, "running", ["1", "2"]]);
+    expect(mid.jobs[1].status).toBe("skipped");
+    const end = runAsOf(run, t("2026-10-20T10:02:00Z"));
+    expect([end.status, end.jobs[0].steps[0].log.length]).toEqual(["success", 4]);
+  });
+  it("lists the cycle's runs created by then, newest first", () => {
+    const later = { ...run, id: 8, created_at: "2026-10-20T10:05:00Z", started_at: "2026-10-20T10:05:00Z", ended_at: "2026-10-20T10:06:00Z" };
+    expect(replayIndex([run, later], t("2026-10-20T10:01:00Z")).doc.runs.map((r) => r.id)).toEqual([7]);
+    expect(replayIndex([run, later], t("2026-10-20T10:07:00Z")).doc.runs.map((r) => r.id)).toEqual([8, 7]);
+  });
+});
+
+describe("the replay's banner (behold#571)", () => {
+  const cycle = { started: "2026-10-20T14:05:00Z", ended: "2026-10-20T14:09:00Z", steps: [{ index: 3, scenarios: 3, at: "2026-10-20T14:05:00Z" }] };
+  it("says when the replayed run was, and about when the tool is live again", () => {
+    expect(replayBanner(cycle, 6)).toBe("Replay of the run at 14:05 UTC · live again in about 6 min");
+    expect(replayBanner(cycle, null)).toBe("Replay of the run at 14:05 UTC");
+  });
+  it("estimates from the loop's order and the cycle's length, and not without them", () => {
+    const now = new Date("2026-10-20T15:01:00Z");
+    // Scenario 1 of 3 started a minute ago; scenario 2 runs before the tool's 3rd: 3 min left, then 4.
+    expect(liveEstimate({ index: 1, scenarios: 3, started_at: "2026-10-20T15:00:00Z" }, cycle, now)).toBe(7);
+    // Scenario 2 is live: the tool's is next.
+    expect(liveEstimate({ index: 2, scenarios: 3, started_at: "2026-10-20T15:00:00Z" }, cycle, now)).toBe(3);
+    expect(liveEstimate({ index: null, scenarios: 3, started_at: "2026-10-20T15:00:00Z" }, cycle, now)).toBe(null);
+    expect(liveEstimate({ index: 1, scenarios: 4, started_at: "2026-10-20T15:00:00Z" }, cycle, now)).toBe(null);
+  });
+});
+
+describe("the branding table (behold#571)", () => {
+  it("has a page for every tool the server routes, and nothing else", () => {
+    expect(Object.keys(VENDORS)).toEqual([...VENDOR_TOOLS]);
+  });
+  it("links every name to an official https site, and shows a logo for choudoufu alone", () => {
+    for (const v of Object.values(VENDORS)) expect(v.url).toMatch(/^https:\/\//);
+    expect(Object.entries(VENDORS).filter(([, v]) => v.logo).map(([id]) => id)).toEqual(["choudoufu"]);
+    expect(VENDORS["cdk-terrain"].url).toBe("https://cdktn.io/");
+    expect(VENDORS.terraform.credit).toContain("Terraform is a trademark of HashiCorp.");
+  });
+  it("says on each page who makes the tool and that they don't endorse the demo, naming no other tool or maker", () => {
+    for (const tool of VENDOR_TOOLS) {
+      const v = VENDORS[tool];
+      const words = [v.name, ...creditLines(tool).map((l) => l.map((s) => s.text).join("")), ...Object.values(notRunWords(v)), legendWords("components", tool), legendWords("resources", tool)];
+      for (const w of words) expect(namesOther(w, tool), `${tool}: ${w}`).toBe(false);
+      // choudoufu is ours: its credit says so instead.
+      if (tool !== "choudoufu") expect(v.credit).toMatch(/(does not|don't) endorse this demo\./);
+    }
+    expect(VENDORS.choudoufu.credit).toMatch(/AWS and Kubernetes/);
+    expect(VENDORS.choudoufu.credit).not.toMatch(/experimental/i);
+  });
+  it("links each name in the footer, the tool's to its site and OpenTofu's where its scenarios run on it", () => {
+    const tf = creditLines("terraform");
+    expect(tf.flat().filter((s) => s.url).map((s) => [s.text, s.url])).toEqual([
+      ["Terraform", VENDORS.terraform.url],
+      ["OpenTofu", RUNS_WITH.opentofu.url],
+    ]);
+    expect(creditLines("terragrunt").flat().filter((s) => s.url).map((s) => s.text)).toEqual(["Terragrunt"]);
+    expect(linkSegments("a b a", [{ name: "a", url: "u" }])).toEqual([{ text: "a", url: "u" }, { text: " b a" }]);
+  });
+  it("counts as a competitor each other tool of the same kind: engines with engines, orchestrators with orchestrators", () => {
+    const matrix = Object.fromEntries(VENDOR_TOOLS.map((t) => [t, otherTerms(t)]));
+    expect(matrix).toEqual({
+      // OpenTofu is an engine too, but Terraform's scenarios really run on it.
+      terraform: ["choudoufu"],
+      terragrunt: ["CDK Terrain", "CDKTN", "Open Construct", "Atmos", "Cloud Posse", "Terramate"],
+      "cdk-terrain": ["Terragrunt", "Gruntwork", "Atmos", "Cloud Posse", "Terramate"],
+      choudoufu: ["Terraform", "HashiCorp", "OpenTofu"],
+    });
+    expect(otherTerms(null)).toEqual([]);
+  });
+  it("lets an orchestrator's page name the engines it runs on, and keeps an engine's page from naming another engine", () => {
+    expect(namesOther("Big Terraform setups run on OpenTofu", "terragrunt")).toBe(false);
+    expect(namesOther("Big Terraform setups", "cdk-terrain")).toBe(false);
+    expect(namesOther("compare with Atmos", "terragrunt")).toBe(true);
+    expect(namesOther("Terragrunt units", "cdk-terrain")).toBe(true);
+    expect(namesOther("Big Terraform setups", "choudoufu")).toBe(true);
+    expect(namesOther("Terraform.", "choudoufu")).toBe(true);
+    expect(namesOther("runs on choudoufu", "terraform")).toBe(true);
+    expect(namesOther("works with OpenTofu", "terraform")).toBe(false);
+    expect(rootWord("choudoufu")).toBe("a root");
+    expect(rootWord("terragrunt")).toBe("a Terraform root");
+  });
+  it("never counts a resource address, a bucket or a path as a brand", () => {
+    for (const t of ["terraform_data.app", "data.terraform_remote_state.network", "state in demo-terraform-state", "s3://demo-terraform-state/edge.tfstate", "developer.hashicorp.com/terraform", ".terraform.lock.hcl", "terragrunt-cache"]) {
+      expect(namesOther(t, "choudoufu"), t).toBe(false);
+      expect(namesOther(t, "cdk-terrain"), t).toBe(false);
+    }
+  });
+  it("leaves out the driver's words that name a competitor, and the loop's count", () => {
+    const d = scrubDemo(demo({ intro: "Big Terraform setups split", about: { changes: "A unit changes", watch: "Terramate plans", shows: "It waits" }, label: "Atmos applies wave 2", title: "CDK Terrain roots" }), "terragrunt");
+    expect([d.intro, d.label, d.title, d.scenarios, d.index]).toEqual(["Big Terraform setups split", "", "a new subnet", null, null]);
+    expect(d.about).toEqual({ changes: "A unit changes", shows: "It waits" });
+    expect(scenarioHead(d, { vendor: "terragrunt" })).toEqual({ kicker: "Scenario · a new subnet", title: "a new subnet" });
+    expect(scenarioHead(demo(), { vendor: "terraform" }).kicker).not.toMatch(/of 3|\d/);
+    expect(scrubDemo(demo({ intro: "Big Terraform setups split" }), "choudoufu").intro).toBe(null);
+  });
+  it("leaves a log line naming a competitor out, says how many, and keeps the engine's lines on an orchestrator's page", () => {
+    const rows = logRows(["plan ok", "Terramate binary", "Terraform v1.9", "edge: s3://demo-terraform-state/edge.tfstate"], { hide: (l) => namesOther(l, "terragrunt") });
+    expect(rows).toEqual([{ n: 1, text: "plan ok" }, { n: 3, text: "Terraform v1.9" }, { n: 4, text: "edge: s3://demo-terraform-state/edge.tfstate" }, { hidden: 1 }]);
+  });
+});
+
+describe("a tool's page, drawn (behold#571)", () => {
+  const fakeDocument = () => {
+    const make = (tag) => {
+      const n = { tagName: tag, className: "", textContent: "", children: [] };
+      n.appendChild = (c) => (n.children.push(c), c);
+      n.append = (...cs) => cs.forEach((c) => n.children.push(typeof c === "string" ? { tagName: "#text", textContent: c, children: [] } : c));
+      n.replaceChildren = () => (n.children = []);
+      return n;
+    };
+    return { createElement: make };
+  };
+  const text = (n) => (n.children && n.children.length ? n.children.map(text).join("") : n.textContent || "");
+  const all = (n) => [n, ...(n.children || []).flatMap(all)];
+  it("puts the tool's name before the scenario, the banner over it, and the credit in the foot, with no count", async () => {
+    const { renderKiosk } = await import("./kiosk.js");
+    const was = globalThis.document;
+    globalThis.document = fakeDocument();
+    try {
+      const bar = document.createElement("header");
+      const foot = document.createElement("footer");
+      const about = { changes: "A unit changes", watch: "Terramate would plan it too", shows: "It waits" };
+      const s = { vendor: "terragrunt", mode: "replay", replay: { banner: "Replay of the run at 14:05 UTC" }, noReports: true, demo: { demo: scrubDemo(demo({ tool: "terragrunt", intro: "Big Terraform setups", about }), "terragrunt") }, answer: null, progress: null };
+      renderKiosk(bar, s, new Date("2026-10-20T10:01:00Z"), foot);
+      expect(bar.children[0].className).toBe("k-replay");
+      const title = all(bar).find((n) => n.className === "k-title");
+      expect(title.children.map((c) => c.className)).toEqual(["k-brand", "k-kicker", "k-title-text"]);
+      const brand = title.children[0];
+      expect([brand.href, brand.target, brand.rel, text(brand)]).toEqual([VENDORS.terragrunt.url, "_blank", "noopener", "Terragrunt"]);
+      expect(text(bar)).not.toMatch(/of 3|Terramate/);
+      // behold#571: no intro band at a live step; the intro fills the card's box at reset.
+      expect(text(bar)).not.toContain("Big Terraform setups");
+      // The engine Terragrunt runs on is no competitor: the shared intro stays.
+      const reset = { ...s, demo: { demo: { ...s.demo.demo, step: "reset" } } };
+      const bar2 = document.createElement("header");
+      renderKiosk(bar2, reset, new Date("2026-10-20T10:01:00Z"), document.createElement("footer"));
+      expect(text(bar2)).toContain("Big Terraform setups");
+      // No graph of this repo here: one line in the header says so.
+      expect(all(bar).filter((n) => n.className === "k-nograph-note").map(text)).toEqual([NO_GRAPH_WORDS]);
+      expect(all(foot).filter((n) => n.className === "k-credit").map(text)).toEqual([VENDORS.terragrunt.credit]);
+    } finally {
+      globalThis.document = was;
+    }
+  });
+  it("says calmly that a tool's scenario hasn't run yet, with its name and link", async () => {
+    const { renderKiosk } = await import("./kiosk.js");
+    const was = globalThis.document;
+    globalThis.document = fakeDocument();
+    try {
+      const bar = document.createElement("header");
+      const foot = document.createElement("footer");
+      renderKiosk(bar, { vendor: "choudoufu", mode: "none", demo: null }, new Date(), foot);
+      expect(text(bar)).toContain("This scenario hasn't run yet");
+      const brand = all(bar).find((n) => n.className === "k-brand");
+      expect(brand.href).toBe(VENDORS.choudoufu.url);
+      expect(all(brand).some((n) => n.className === "k-brand-logo" && n.src === VENDORS.choudoufu.logo.src)).toBe(true);
+    } finally {
+      globalThis.document = was;
+    }
+  });
+});