test(tools): pin the block catalog's rendered text to English

The showcase read as German to a German viewer. It is not: every string the
catalog sends is English, and what the product owner saw is Slack rendering
its own chrome in the reader's locale. "Morgen 7:00 Uhr" is the `<!date^…>`
token we deliberately send so each reader gets the time in their own timezone,
and "Button für <label>" wraps our English button labels in Slack's word for
"Button". Hardcoding English over either would break every other locale, so
neither is touched.

What is now pinned is the half we control. The sweep walks all three states a
reader can reach — page 1, page 2 before confirming, page 2 after confirming —
collects every human-readable string in the payload `renderSlackMessage` hands
to Slack, and rejects German diacritics and a bounded word deny-list. Keys
Slack keys off rather than draws are skipped, so an `action_id` cannot mask a
finding or invent one.

Three things keep it honest. The harvest is floored per state, because a sweep
over an empty harvest passes for free. Named strings from headings, container
titles, table cells, chart labels and task titles must be in reach, so the
walker cannot silently reach only the surface. And the detector is tested both
ways: it fires on "Zeitzone", "Morgen 7:00 Uhr" and "Kanal auswählen", and
stays quiet on "submit", "the tags we found" and "45 minutes" — the English
that merely contains those letters. Injecting German into a container title, a
page-2 label and a context note fails all three states with the path named.

Dates and numbers are checked separately, because German conventions survive an
all-English vocabulary: no `14.08.2026`, no decimal comma, the one hardcoded
date ISO, and the date token's fallback ISO too.

Live-verified against #bot-test: page 1 and page 2 with the confirmation both
delivered whole, and the readback carries no German of ours.

Author: lukasmoschitz

app/tools/__tests__/block-catalog.test.tsx

@@ -597,6 +597,175 @@ describe("what a click carries back", () => {
   });
 });
 
+/**
+ * Keys Slack keys off rather than draws: ids, block and element types, urls,
+ * enum values. Skipping them keeps the sweep below on the text a reader
+ * actually reads, so neither a `value` of `"30m"` nor an `action_id` can mask a
+ * real finding or invent a false one.
+ */
+const STRUCTURAL_KEYS = new Set([
+  "type",
+  "block_id",
+  "action_id",
+  "task_id",
+  "value",
+  "url",
+  "image_url",
+  "video_url",
+  "title_url",
+  "thumbnail_url",
+  "style",
+  "icon",
+  "status",
+  "initial_date",
+  "trigger_actions_on",
+]);
+
+/** Every string a reader can see in a rendered payload, each with its path. */
+function humanStrings(node: unknown, path = "blocks"): [string, string][] {
+  if (typeof node === "string") return [[path, node]];
+  if (Array.isArray(node)) {
+    return node.flatMap((value, i) => humanStrings(value, `${path}[${i}]`));
+  }
+  if (node && typeof node === "object") {
+    return Object.entries(node).flatMap(([key, value]) =>
+      STRUCTURAL_KEYS.has(key) ? [] : humanStrings(value, `${path}.${key}`),
+    );
+  }
+  return [];
+}
+
+/** The cheapest tell, and one with no English hits at all. */
+const GERMAN_DIACRITIC = /[äöüßÄÖÜ]/;
+
+/**
+ * German that survives without a diacritic, each word bounded by a letter
+ * lookaround so an English word cannot carry it in — `submit` must not read
+ * as `mit`, nor `found` as `und`. Words that are German *and* English —
+ * `Text`, `Video`, `Team`, `Tag`, `Minute`, `Links`, `Region` — are
+ * deliberately absent: they would fail on the English copy this message ships.
+ */
+const GERMAN_WORD =
+  /(?<!\p{L})(und|oder|nicht|für|fuer|mit|Uhr|Uhrzeit|Zeit|Zeitzone|Datum|Kanal|Kanäle|Auswahl|auswählen|wählen|Woche|Wochen|Monat|Monate|Stunde|Stunden|Minuten|Sekunden|bestätigen|bestätigt|Bestätigung|Einladung|Besprechung|Termin|senden|gesendet|zeigen|Beispiel|Beispiele|Überschrift|Trennlinie|Knopf|Feld|Felder|Nachricht|Seite|Seiten|zurück|weiter|Absenden|Abbrechen|Dauer|Länge|Empfänger|Adresse|Betreff|morgen|heute|gestern|jetzt|Kalender|Buchung|buchen|Antwort|Frage|Fragen|Benutzer|Übersicht|Zusammenfassung|Währung|Rechnung|Zahlung|Vertrag|Prüfung|prüfen|erstellen|löschen|ändern|speichern|öffnen|schließen)(?!\p{L})/iu;
+
+const isGerman = (text: string) =>
+  GERMAN_DIACRITIC.test(text) || GERMAN_WORD.test(text);
+
+/**
+ * The product owner read "Zeitzone" and "Morgen 7:00 Uhr" off the rendered
+ * confirmation. Both are Slack's own localisation — a `<!date^…>` token and
+ * the date picker's chrome are drawn in the *reader's* locale from a payload
+ * that carries no German at all — so the fix is not to hardcode English over
+ * them but to guard the half we control: every human-readable string we send.
+ */
+describe("nothing we send is German", () => {
+  /**
+   * Every state a reader can reach. Page 2 appears twice because the
+   * confirmation exists only after Confirm, and it is the one place a value is
+   * formatted into prose rather than passed straight through.
+   */
+  const STATES: [string, Partial<CatalogState>][] = [
+    ["page 1", { page: 0 }],
+    ["page 2 before confirming", { page: 1 }],
+    [
+      "page 2 after confirming",
+      { page: 1, booking: BOOKING, confirmed: BOOKING },
+    ],
+  ];
+
+  it.each(STATES)("carries no German on %s", (_label, state) => {
+    const strings = humanStrings(page(state));
+
+    // A sweep over an empty harvest passes for free. Page 2 before confirming
+    // is the thinnest state and still renders fourteen reader-facing strings.
+    expect(strings.length).toBeGreaterThanOrEqual(14);
+    for (const [where, text] of strings) {
+      expect(isGerman(text) ? `${where} → ${text}` : null).toBeNull();
+    }
+  });
+
+  it("harvests the strings a reader really reads, not a thin slice of them", () => {
+    const texts = humanStrings(page({ page: 0 })).map(([, text]) => text);
+
+    // Headings, container titles, table cells, chart labels, button labels and
+    // task titles all have to be in reach, or the sweep proves nothing.
+    expect(texts.length).toBeGreaterThan(120);
+    expect(texts).toContain("Where completion stands");
+    expect(texts).toContain("Renewal rate by month");
+    expect(texts).toContain("Ember Support Desk");
+    expect(texts).toContain("Confirm the security review dates");
+    expect(texts).toContain("Next · book a meeting →");
+  });
+
+  it("catches German when there is German to catch", () => {
+    // What a German reader saw, plus the wording this message would most
+    // plausibly regress into.
+    for (const sample of [
+      "Zeitzone",
+      "Morgen 7:00 Uhr",
+      "Bestätigung senden",
+      "Länge der Besprechung",
+      "Kanal auswählen",
+      "Seite 1 von 2",
+    ]) {
+      expect(isGerman(sample)).toBe(true);
+    }
+
+    // And does not fire on English that merely contains those letters.
+    for (const sample of [
+      "submit the form",
+      "the tags we found",
+      "A video that plays in place",
+      "45 minutes",
+      "Page 1 of 2",
+      "Region",
+      "Not useful",
+    ]) {
+      expect(isGerman(sample)).toBe(false);
+    }
+  });
+
+  it("leaves Slack's own localisation to Slack", () => {
+    const when = humanStrings(
+      page({ page: 1, booking: BOOKING, confirmed: BOOKING }),
+    )
+      .map(([, text]) => text)
+      .find((text) => text.includes("<!date^"));
+
+    // A `<!date^…>` token and a `<#C…>` mention are what a German client
+    // turns into "Morgen 7:00 Uhr" and a channel name. Sending the token is
+    // the point: hardcoding an English date would break every other locale.
+    expect(when).toContain("<!date^1786451118^{date_long_pretty} at {time}|");
+    expect(when).toContain("<#C0BM9JJK6E8>");
+    expect(isGerman(when!)).toBe(false);
+
+    // The date-and-time picker carries no text of ours beyond its label, so the
+    // timezone hint under it is Slack's chrome and not ours to restate.
+    const picker = page({ page: 1 }).find(
+      (block) =>
+        (block as { element?: { type?: string } }).element?.type ===
+        "datetimepicker",
+    ) as { element: Record<string, unknown> };
+
+    expect(Object.keys(picker.element)).toEqual(["type"]);
+  });
+
+  it("formats the dates and numbers we choose ourselves language-neutrally", () => {
+    const raw = STATES.map(([, state]) => JSON.stringify(page(state))).join(
+      "\n",
+    );
+
+    // `14.08.2026` and a decimal comma are the German conventions that survive
+    // an entirely English vocabulary.
+    expect(raw).not.toMatch(/\d{1,2}\.\d{1,2}\.\d{4}/);
+    expect(raw).not.toMatch(/\d+,\d+/);
+    // The one date we hardcode is ISO, and the one time is a Slack token whose
+    // fallback is ISO too.
+    expect(raw).toContain('"initial_date":"2026-09-12"');
+    expect(raw).toContain("|2026-08-11 12:25 UTC>");
+  });
+});
+
 describe("OPENTAG_SHOW_BLOCK_CATALOG", () => {
   const names = (env: NodeJS.ProcessEnv) =>
     createAppTools("OpenTag", env).map(({ name }) => name);