Reaktionen: Vorschlaege, ganzer Katalog, eigene Favoriten

Filipe: "soll viel besser und geiler sein und man soll auch auswaehlen
koennen, also paar als vorschlaege mit der moeglichkeit andere
auszuwaehlen und als favoriten zu speichern."

Aus einem Streifen mit sechs Zeichen ist eine Karte geworden:
Vorschlaege oben, Suchfeld, darunter der Katalog in sechs Gruppen --
82 Zeichen, jedes mit deutschen Suchwoertern. Wer "feuer" tippt, muss
nicht scrollen.

DREI LISTEN, DREI FRAGEN, und sie werden gern verwechselt:
  KATALOG    Was gibt es?              fest, workspace-reaktionen.js
  VORSCHLAG  Was steht vorn, solange   fest -- bis jemand eigene
             ich nichts gewaehlt habe? Favoriten hat
  FAVORITEN  Was hat DIESER Mensch     in der Datenbank
             sich gemerkt?

Nur der Katalog entscheidet, was ANGENOMMEN wird. Vorschlag und
Favoriten sind Reihenfolge, keine Erlaubnis -- sonst koennte man sich
ueber einen Favoriten etwas erlauben, das im Katalog nicht steht. Die
erlaubte Menge wird aus dem Katalog ABGELEITET; eine zweite Liste
daneben waere die, in der ein Zeichen fehlt, das die Oberflaeche
anbietet.

FAVORITEN HAENGEN AM MENSCHEN, NICHT AM GERAET. Im Browser abgelegt
waeren sie am Handy andere als am Rechner und beim naechsten Loeschen
der Seitendaten weg.

DER STERN SCHALTET EINEN MODUS, statt an jedem Zeichen einen zweiten
Knopf zu haben: Am Handy gibt es kein "daneben zeigen". Im Merk-Modus
faerbt sich die ganze Tafel, damit niemand reagiert, wenn er merken
wollte. Die Tafel bleibt dabei offen -- acht Favoriten waeren sonst
acht Mal Aufmachen -- und die Vorschlagszeile aendert sich sofort mit.

DIE GRENZE SAGT BESCHEID, statt still den aeltesten wegzuwerfen: Wer
einen neunten merken will, bekommt "nimm erst einen weg". Ein Favorit,
der ohne Ansage verschwindet, sieht wie ein Fehler aus.

Eine Selbstpruefung beim Laden meldet doppelte Zeichen im Katalog und
Vorschlaege, die nicht darin stehen -- beides waere in der Tafel still.

pruef-chat-aufloesen 85 -> 115. Gemessen wird, was PASSIERT, nicht dass
es Elemente gibt: dass die Suche wirklich eingrenzt (1 statt 82) und
das Richtige findet, dass ein Fehlgriff "Nichts zu ... gefunden" sagt
statt eine leere Flaeche zu zeigen, und vor allem, dass im Merk-Modus
KEINE Reaktion entsteht -- an der Zahl der Reaktionen gemessen, nicht
an der Absicht.

NEBENBEFUND AUS DER EIGENEN PRUEFUNG: pruef-css-klassen hat meine
Gruppenueberschrift mit 10,56 px abgelehnt (Grenze 11,5). Richtig so --
eine gesperrte Versalzeile ist ohnehin schwerer zu lesen, die darf
nicht auch noch die kleinste sein. Auf .72rem angehoben, statt die
Grundlinie zu verschieben.

Co-Authored-By: Claude Opus 5 <[email protected]>

server/pruef-chat-aufloesen.mjs

@@ -412,6 +412,96 @@ console.log("=== Reaktionen ===");
   const zaehle = () => d.prepare(
     "SELECT COUNT(*) AS n FROM chat_reaktionen WHERE nachricht_id = ?").get(nid).n;
 
+  /* ---- KATALOG UND FAVORITEN (14.09.2026) -------------------------
+     Filipe: "paar als vorschlaege mit der moeglichkeit andere
+     auszuwaehlen und als favoriten zu speichern."
+
+     DREI LISTEN, DREI FRAGEN -- und sie werden gern verwechselt:
+     Katalog (was gibt es?), Vorschlag (was steht vorn?), Favoriten
+     (was hat DIESER Mensch gewaehlt?). Geprueft wird, dass sie
+     zusammenhaengen, ohne dasselbe zu sein. */
+  const aus1 = await holen(eins.keks, "/workspace/api/chat/reaktionen/auswahl");
+  ok(Array.isArray(aus1.katalog) && aus1.katalog.length >= 4,
+    `der Katalog hat ${(aus1.katalog || []).length} Gruppen`);
+  const alleZeichen = (aus1.katalog || []).flatMap((g) => g.zeichen.map((z) => z[0]));
+  ok(alleZeichen.length >= 50, `und ${alleZeichen.length} Zeichen insgesamt`);
+  ok(new Set(alleZeichen).size === alleZeichen.length,
+    "keines davon doppelt -- ein doppeltes waere in der Tafel still");
+  ok((aus1.katalog || []).every((g) => g.zeichen.every(([, w]) => typeof w === "string" && w.length > 2)),
+    "jedes Zeichen hat deutsche Suchwoerter");
+  ok(aus1.eigene === false && aus1.zeichen.length === 6,
+    `ohne eigene Favoriten stehen die sechs Vorgaben vorn (${aus1.zeichen.length})`);
+  ok(aus1.zeichen.every((z) => alleZeichen.includes(z)),
+    "und jeder Vorschlag steht auch im Katalog");
+
+  /* ---- Einen Favoriten merken ------------------------------------- */
+  const exot = alleZeichen.find((z) => !aus1.zeichen.includes(z));
+  const f1 = await (await rufe(eins.keks, "/workspace/api/chat/reaktionen/favorit",
+    { zeichen: exot }, "PUT")).json();
+  ok(f1.favoriten?.length === 1 && f1.favoriten[0] === exot,
+    `ein Zeichen wird gemerkt (${f1.favoriten?.join(" ")})`);
+  ok(f1.zeichen?.length === 1,
+    "und steht ab jetzt ALLEIN vorn -- Favoriten ersetzen die Vorgabe");
+
+  /* ---- Sie bleiben, auch nach dem Neuladen ------------------------- */
+  const aus2 = await holen(eins.keks, "/workspace/api/chat/reaktionen/auswahl");
+  ok(aus2.eigene === true && aus2.favoriten[0] === exot,
+    "beim naechsten Aufruf sind sie noch da");
+
+  /* ---- Und sie gehoeren EINEM Menschen ----------------------------- */
+  const ausBen = await holen(zwei.keks, "/workspace/api/chat/reaktionen/auswahl");
+  ok(ausBen.eigene === false,
+    "Ben hat davon nichts -- Favoriten sind persoenlich");
+
+  /* ---- Zweimal dasselbe nimmt es weg ------------------------------- */
+  const f2 = await (await rufe(eins.keks, "/workspace/api/chat/reaktionen/favorit",
+    { zeichen: exot }, "PUT")).json();
+  ok(f2.favoriten?.length === 0 && f2.gesetzt === false,
+    "noch einmal darauf nimmt den Favoriten wieder weg");
+  const aus3 = await holen(eins.keks, "/workspace/api/chat/reaktionen/auswahl");
+  ok(aus3.eigene === false && aus3.zeichen.length === 6,
+    "und die Vorgabe steht wieder vorn");
+
+  /* ---- Die Grenze sagt Bescheid, statt still zu schlucken ---------- */
+  const acht = alleZeichen.slice(0, aus1.favoriten_max);
+  for (const z of acht) {
+    await rufe(eins.keks, "/workspace/api/chat/reaktionen/favorit", { zeichen: z }, "PUT");
+  }
+  const voll = await rufe(eins.keks, "/workspace/api/chat/reaktionen/favorit",
+    { zeichen: alleZeichen[aus1.favoriten_max] }, "PUT");
+  const vollD = await voll.json();
+  ok(voll.status === 409 && /Favoriten/.test(vollD.fehler || ""),
+    `der neunte wird abgelehnt und begruendet (HTTP ${voll.status})`);
+  ok((vollD.favoriten || []).length === aus1.favoriten_max,
+    `die acht bleiben unangetastet (${(vollD.favoriten || []).length})`);
+
+  /* GEGENPROBE: Nach dem Wegnehmen eines Favoriten geht wieder einer
+     hinein. Ohne sie hiesse das oben nur, dass ab acht gar nichts mehr
+     geht. */
+  await rufe(eins.keks, "/workspace/api/chat/reaktionen/favorit",
+    { zeichen: acht[0] }, "PUT");
+  const platzFrei = await rufe(eins.keks, "/workspace/api/chat/reaktionen/favorit",
+    { zeichen: alleZeichen[aus1.favoriten_max] }, "PUT");
+  ok(platzFrei.status === 200,
+    `nach dem Wegnehmen passt wieder einer (HTTP ${platzFrei.status})`);
+
+  /* ---- Ein Favorit ist keine Erlaubnis ----------------------------- */
+  const erfunden = await rufe(eins.keks, "/workspace/api/chat/reaktionen/favorit",
+    { zeichen: "nicht-im-katalog" }, "PUT");
+  ok(erfunden.status === 400,
+    `ein Zeichen ausserhalb des Katalogs wird nicht gemerkt (HTTP ${erfunden.status})`);
+
+  /* ---- Der ganze Katalog ist auch zum Reagieren erlaubt ------------ */
+  const weit = alleZeichen[alleZeichen.length - 1];
+  const gr = await (await rufe(eins.keks, "/workspace/api/chat/gruppe",
+    { mit: [idZwei], name: "Katalogtest" }, "POST")).json();
+  const nn = await (await rufe(eins.keks,
+    `/workspace/api/chat/raeume/${gr.raum_id}/nachrichten`, { text: "x" }, "POST")).json();
+  const mitExot = await rufe(eins.keks,
+    `/workspace/api/chat/nachrichten/${nn.nachricht.id}/reaktion`, { zeichen: weit }, "PUT");
+  ok(mitExot.status === 200,
+    `auch das letzte Zeichen des Katalogs laesst sich geben (${weit})`);
+
   /* ---- Setzen ---------------------------------------------------- */
   const a1 = await (await rufe(zwei.keks,
     `/workspace/api/chat/nachrichten/${nid}/reaktion`, { zeichen: daumen }, "PUT")).json();
@@ -601,6 +691,101 @@ console.log("=== Das Neu-Fenster ===");
   const tafel = await seite.$$eval(".reagieren-tafel__zeichen",
     (b) => b.map((x) => x.textContent.trim()));
   ok(tafel.length >= 4, `die Auswahl klappt auf (${tafel.length} Zeichen)`);
+
+  /* ---- DIE TAFEL: Vorschlaege, Suche, Katalog, Favoriten ----------
+     (14.09.2026) Filipe: "soll viel besser und geiler sein und man
+     soll auch auswaehlen koennen."
+
+     Gemessen wird, was auf dem Bildschirm PASSIERT -- nicht, dass es
+     Elemente gibt. Eine Tafel, die aufklappt und deren Suche nichts
+     tut, haette alle Anwesenheitspruefungen bestanden. */
+  const teile = await seite.evaluate(() => ({
+    schnell: document.querySelectorAll(".reagieren-tafel__schnell .reagieren-tafel__zeichen").length,
+    gruppen: document.querySelectorAll(".reagieren-tafel__gruppe").length,
+    katalog: document.querySelectorAll(".reagieren-tafel__katalog .reagieren-tafel__zeichen").length,
+    suche: !!document.querySelector(".reagieren-tafel__suche"),
+    stern: !!document.querySelector(".reagieren-tafel__stern"),
+  }));
+  ok(teile.schnell === 6, `sechs Vorschlaege stehen oben (${teile.schnell})`);
+  ok(teile.gruppen >= 4 && teile.katalog >= 50,
+    `darunter der Katalog: ${teile.gruppen} Gruppen, ${teile.katalog} Zeichen`);
+  ok(teile.suche && teile.stern, "Suchfeld und Favoriten-Schalter sind da");
+
+  if (process.env.SCHIRM) {
+    await seite.locator(".chat-nachricht").last().screenshot(
+      { path: join(HIER_BILD, "pruef-chat-tafel.png") });
+  }
+
+  /* ---- Die Suche muss SUCHEN --------------------------------------- */
+  await seite.fill(".reagieren-tafel__suche", "feuer");
+  await seite.waitForTimeout(400);
+  const gefunden = await seite.evaluate(() => ({
+    zahl: document.querySelectorAll(".reagieren-tafel__katalog .reagieren-tafel__zeichen").length,
+    erstes: document.querySelector(".reagieren-tafel__katalog .reagieren-tafel__zeichen")?.textContent,
+  }));
+  ok(gefunden.zahl >= 1 && gefunden.zahl < teile.katalog,
+    `"feuer" grenzt ein: ${gefunden.zahl} statt ${teile.katalog}`);
+  ok(gefunden.erstes === "\u{1F525}", `und findet das Richtige (${gefunden.erstes})`);
+
+  /* Ein Wort, das es nicht gibt, sagt das -- statt eine leere Flaeche
+     zu zeigen, die wie ein Fehler aussieht. */
+  await seite.fill(".reagieren-tafel__suche", "zwiebelkuchen");
+  await seite.waitForTimeout(400);
+  const leer = await seite.evaluate(() =>
+    document.querySelector(".reagieren-tafel__leer")?.textContent || "");
+  ok(leer.includes("Nichts zu"), `ein Fehlgriff wird gesagt ("${leer.slice(0, 40)}")`);
+  await seite.fill(".reagieren-tafel__suche", "");
+  await seite.waitForTimeout(400);
+
+  /* ---- Der Favoriten-Modus ----------------------------------------- */
+  await seite.click(".reagieren-tafel__stern");
+  await seite.waitForTimeout(300);
+  const anModus = await seite.evaluate(() => ({
+    merken: document.querySelector(".reagieren-tafel")?.dataset.merken,
+    hinweis: document.querySelector(".reagieren-tafel__hinweis")?.textContent || "",
+  }));
+  ok(anModus.merken === "ja", "der Stern schaltet den Merk-Modus ein");
+  ok(anModus.hinweis.includes("merkt"),
+    `und sagt, was ein Antippen jetzt tut ("${anModus.hinweis.slice(0, 44)}…")`);
+
+  /* Ein Zeichen im Merk-Modus antippen REAGIERT NICHT, es merkt. Das
+     ist der Unterschied, der schiefgehen kann -- und er wird hier an
+     der Zahl der Reaktionen gemessen, nicht an der Absicht. */
+  const vorher = await seite.$$eval(".reaktionen__stueck", (b) => b.length);
+  await seite.click(".reagieren-tafel__katalog .reagieren-tafel__zeichen");
+  await seite.waitForTimeout(700);
+  const nachher = await seite.evaluate(() => ({
+    reaktionen: document.querySelectorAll(".reaktionen__stueck").length,
+    gemerkt: document.querySelectorAll('.reagieren-tafel__zeichen[data-favorit="ja"]').length,
+    offen: !!document.querySelector(".reagieren-tafel"),
+    hinweis: document.querySelector(".reagieren-tafel__hinweis")?.textContent || "",
+  }));
+  ok(nachher.reaktionen === vorher,
+    `im Merk-Modus entsteht KEINE Reaktion (${vorher} -> ${nachher.reaktionen})`);
+  ok(nachher.gemerkt >= 1, `sondern ein Favorit (${nachher.gemerkt} markiert)`);
+  ok(nachher.offen, "und die Tafel bleibt offen -- sonst achtmal aufmachen");
+  ok(nachher.hinweis.includes("gemerkt"),
+    `der Hinweis zaehlt mit ("${nachher.hinweis.slice(0, 34)}…")`);
+
+  if (process.env.SCHIRM) {
+    await seite.locator(".chat-nachricht").last().screenshot(
+      { path: join(HIER_BILD, "pruef-chat-favoriten.png") });
+  }
+
+  /* Und der Favorit steht danach VORN -- ohne die Tafel neu zu oeffnen. */
+  const vornDrin = await seite.evaluate(() => {
+    const merk = [...document.querySelectorAll('.reagieren-tafel__katalog .reagieren-tafel__zeichen[data-favorit="ja"]')]
+      .map((b) => b.dataset.zeichen);
+    const vorn = [...document.querySelectorAll(".reagieren-tafel__schnell .reagieren-tafel__zeichen")]
+      .map((b) => b.dataset.zeichen);
+    return merk.every((z) => vorn.includes(z)) && vorn.length > 0;
+  });
+  ok(vornDrin, "der frisch gemerkte steht sofort in der Vorschlagszeile");
+
+  /* Modus wieder aus, dann wirklich reagieren. */
+  await seite.click(".reagieren-tafel__stern");
+  await seite.waitForTimeout(250);
+
   const tafelLage = await seite.evaluate(() => {
     const t = document.querySelector(".reagieren-tafel");
     const z = document.querySelector(".reagieren-tafel__zeichen");

server/workspace-chat.js

@@ -47,6 +47,8 @@ import {
   fuehrtTeamDogi, MODI_KATEGORIEN, ROLLEN_GRUPPE,
 } from "./workspace.js";
 
+import { KATALOG, ERLAUBT, VORSCHLAG, FAVORITEN_MAX } from "./workspace-reaktionen.js";
+
 export const chatRouter = express.Router();
 
 const TEXT_MAX = 4000;
@@ -1223,13 +1225,97 @@ function darfAufloesen(raum, person) {
    -- und die zweite Fassung waere die, in der ein Zeichen fehlt, das
    der Server noch annimmt.
    ===================================================================== */
-export const REAKTIONEN = ["👍", "❤️", "😂", "😮", "🔥", "🙏"];
+/* Die drei Listen stehen in workspace-reaktionen.js -- Katalog,
+   Vorschlag, erlaubte Zeichen. Hier stehen nur die Wege dorthin. */
 
+/** Die Favoriten EINES Menschen, in seiner Reihenfolge. */
+function favoritenVon(personId) {
+  return db().prepare(
+    "SELECT zeichen FROM chat_reaktion_favoriten WHERE person_id = ? ORDER BY platz, zeichen")
+    .all(personId).map((z) => z.zeichen)
+    /* Was nicht mehr im Katalog steht, faellt still weg -- aber nur
+       beim LESEN. Die Zeile bleibt stehen; kaeme das Zeichen zurueck,
+       ist der Favorit wieder da. Ein Loeschen waere eine Entscheidung
+       ueber fremde Daten wegen einer Katalogaenderung. */
+    .filter((z) => ERLAUBT.has(z));
+}
+
+/* WAS DIE OBERFLAECHE BRAUCHT, IN EINER ANTWORT: die Vorschlagszeile,
+   den ganzen Katalog mit Suchwoertern und die eigenen Favoriten.
+
+   Drei Abrufe daraus zu machen waere sparsamer aussehend und in
+   Wahrheit teurer: Die Tafel kann erst erscheinen, wenn alle drei da
+   sind. */
 chatRouter.get("/workspace/api/chat/reaktionen/auswahl", (req, res) => {
-  res.json({ zeichen: REAKTIONEN });
+  try {
+    const favoriten = favoritenVon(req.person.id);
+    res.json({
+      /* Die Vorschlagszeile sind die FAVORITEN, sobald es welche gibt
+         -- sonst die Vorgabe. Beides an einer Stelle entschieden,
+         damit die Oberflaeche nicht selbst waehlen muss. */
+      zeichen: favoriten.length ? favoriten : VORSCHLAG,
+      eigene: favoriten.length > 0,
+      favoriten,
+      favoriten_max: FAVORITEN_MAX,
+      katalog: KATALOG,
+    });
+  } catch (fehler) {
+    console.error("[chat] Auswahl:", fehler?.message);
+    res.status(503).json({ fehler: "nicht_verfuegbar" });
+  }
 });
 
-/** Alle Reaktionen zu einer Menge von Nachrichten -- in EINER Abfrage.
+/* EINEN FAVORITEN SETZEN ODER WEGNEHMEN -- wieder ein Umschalter,
+   wie das Reagieren selbst. Ein eigener Weg zum Entfernen waere ein
+   zweiter Weg, den man absichern muss. */
+chatRouter.put("/workspace/api/chat/reaktionen/favorit", gleicheHerkunft,
+  express.json({ limit: "2kb" }), (req, res) => {
+    try {
+      const zeichen = String(req.body?.zeichen ?? "");
+      if (!ERLAUBT.has(zeichen)) return res.status(400).json({ fehler: "unbekanntes_zeichen" });
+
+      const d = db();
+      const da = d.prepare(
+        "SELECT 1 FROM chat_reaktion_favoriten WHERE person_id = ? AND zeichen = ?")
+        .get(req.person.id, zeichen);
+
+      if (da) {
+        d.prepare("DELETE FROM chat_reaktion_favoriten WHERE person_id = ? AND zeichen = ?")
+          .run(req.person.id, zeichen);
+      } else {
+        const wieViele = d.prepare(
+          "SELECT COUNT(*) AS n FROM chat_reaktion_favoriten WHERE person_id = ?")
+          .get(req.person.id).n;
+        if (wieViele >= FAVORITEN_MAX) {
+          /* NICHT STILL DEN AELTESTEN WEGWERFEN. Wer neun ablegen will,
+             soll erfahren, dass acht das Maximum sind -- und selbst
+             entscheiden, welcher geht. Ein Favorit, der ohne Ansage
+             verschwindet, sieht wie ein Fehler aus. */
+          return res.status(409).json({
+            fehler: `Mehr als ${FAVORITEN_MAX} Favoriten passen nicht in die Zeile. `
+              + "Nimm erst einen weg.",
+            favoriten: favoritenVon(req.person.id),
+          });
+        }
+        /* Ans ENDE, nicht an den Anfang: Die vorhandenen sollen nicht
+           wandern -- man greift sonst daneben. */
+        const platz = (d.prepare(
+          "SELECT COALESCE(MAX(platz), 0) AS p FROM chat_reaktion_favoriten WHERE person_id = ?")
+          .get(req.person.id).p) + 1;
+        d.prepare(`INSERT INTO chat_reaktion_favoriten (person_id, zeichen, platz)
+           VALUES (?,?,?)`).run(req.person.id, zeichen, platz);
+      }
+
+      const favoriten = favoritenVon(req.person.id);
+      res.json({ favoriten, gesetzt: !da,
+        zeichen: favoriten.length ? favoriten : VORSCHLAG });
+    } catch (fehler) {
+      console.error("[chat] Favorit:", fehler?.message);
+      res.status(503).json({ fehler: "nicht_verfuegbar" });
+    }
+  });
+
+/** Alle Reaktionen zu einer Menge von Nachrichten/** Alle Reaktionen zu einer Menge von Nachrichten -- in EINER Abfrage.
  *
  *  Je Nachricht einzeln zu fragen waere bei 200 Nachrichten 200
  *  Abfragen fuer eine Ansicht. Zurueck kommt eine Karte:
@@ -1275,7 +1361,7 @@ chatRouter.put("/workspace/api/chat/nachrichten/:id/reaktion", gleicheHerkunft,
       const id = Number(req.params.id);
       if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
       const zeichen = String(req.body?.zeichen ?? "");
-      if (!REAKTIONEN.includes(zeichen)) {
+      if (!ERLAUBT.has(zeichen)) {
         return res.status(400).json({ fehler: "unbekanntes_zeichen" });
       }
 

server/workspace-reaktionen.js

@@ -0,0 +1,187 @@
+/* =====================================================================
+   DIE ZEICHEN ZUM REAGIEREN — Katalog, Vorschläge, Favoriten
+   (14.09.2026)
+
+   Filipe: "soll viel besser und geiler sein und man soll auch auswählen
+   können, also paar als vorschläge mit der möglichkeit andere
+   auszuwählen und als favoriten zu speichern."
+
+   ---------------------------------------------------------------------
+   DREI LISTEN, DREI FRAGEN — und sie werden gern verwechselt:
+
+     KATALOG    Was gibt es zur Auswahl?      (fest, hier)
+     VORSCHLAG  Was steht vorn, wenn ich      (fest, hier — bis jemand
+                noch nichts gewählt habe?     eigene Favoriten hat)
+     FAVORITEN  Was hat DIESER Mensch         (in der Datenbank)
+                sich gemerkt?
+
+   Nur der Katalog entscheidet, was angenommen wird. Vorschläge und
+   Favoriten sind Reihenfolge, keine Erlaubnis — sonst könnte man sich
+   über einen Favoriten etwas erlauben, das im Katalog nicht steht.
+
+   ---------------------------------------------------------------------
+   WARUM EIN KATALOG UND NICHT "JEDES EMOJI"
+
+   Ein freies Feld nähme alles: 4-KB-Zeichenketten, unsichtbare
+   Steuerzeichen, Flaggen aus zwei zusammengesetzten Zeichen, die auf
+   dem einen Gerät eine Flagge sind und auf dem anderen zwei Buchstaben.
+   Was hier nicht drinsteht, kommt nicht in die Datenbank — und was
+   drinsteht, sieht überall gleich aus.
+
+   Der Katalog ist trotzdem groß genug, dass niemand etwas vermisst:
+   über hundert Zeichen in sechs Gruppen, jedes mit deutschen
+   Suchwörtern. Die Suche ist der eigentliche Unterschied zu einer
+   Tafel: Wer "feuer" tippt, muss nicht scrollen.
+   ===================================================================== */
+
+/** Jede Zeile: [Zeichen, Suchwörter (deutsch, durch Leerzeichen)].
+ *  Die Suchwörter sind das, wonach jemand WIRKLICH sucht — nicht der
+ *  offizielle Unicode-Name ("grinsendes Gesicht mit lachenden Augen"). */
+export const KATALOG = [
+  {
+    name: "Zustimmung",
+    zeichen: [
+      ["\u{1F44D}", "daumen hoch gut ok super ja"],
+      ["\u{1F44E}", "daumen runter schlecht nein"],
+      ["\u{1F44C}", "ok perfekt passt"],
+      ["\u{1F64C}", "hurra jubel super geschafft"],
+      ["\u{1F44F}", "klatschen applaus respekt bravo"],
+      ["\u{1F91D}", "handschlag deal abgemacht"],
+      ["✊", "faust power stark"],
+      ["\u{1F4AA}", "muskel stark kraft"],
+      ["\u{1F64F}", "danke bitte gebet respekt"],
+      ["✅", "haken erledigt fertig"],
+      ["\u{1F195}", "neu new"],
+      ["\u{1F3AF}", "treffer ziel genau"],
+    ],
+  },
+  {
+    name: "Gefühl",
+    zeichen: [
+      ["❤️", "herz liebe lieb"],
+      ["\u{1F9E1}", "herz orange"],
+      ["\u{1F49B}", "herz gelb"],
+      ["\u{1F49A}", "herz gruen"],
+      ["\u{1F499}", "herz blau"],
+      ["\u{1F49C}", "herz lila"],
+      ["\u{1F5A4}", "herz schwarz"],
+      ["\u{1F60D}", "verliebt herzaugen toll"],
+      ["\u{1F970}", "suess niedlich lieb"],
+      ["\u{1F618}", "kuss bussi"],
+      ["\u{1F917}", "umarmung knuddel"],
+      ["✨", "funkeln glanz besonders"],
+    ],
+  },
+  {
+    name: "Lachen",
+    zeichen: [
+      ["\u{1F602}", "lachen traenen lustig"],
+      ["\u{1F923}", "totlachen rollen lustig"],
+      ["\u{1F604}", "lachen froh"],
+      ["\u{1F609}", "zwinkern augenzwinkern"],
+      ["\u{1F60E}", "sonnenbrille cool"],
+      ["\u{1F973}", "party feiern geburtstag"],
+      ["\u{1F92A}", "quatsch albern zunge"],
+      ["\u{1F643}", "umgedreht ironie"],
+      ["\u{1F60F}", "schmunzeln frech"],
+      ["\u{1F642}", "leicht laecheln"],
+      ["\u{1F60A}", "froh zufrieden"],
+      ["\u{1F92D}", "ups kichern hand vor mund"],
+    ],
+  },
+  {
+    name: "Staunen",
+    zeichen: [
+      ["\u{1F62E}", "oh staunen ueberrascht"],
+      ["\u{1F631}", "schock erschrocken"],
+      ["\u{1F92F}", "wow kopf explodiert krass"],
+      ["\u{1F440}", "augen schauen hinsehen"],
+      ["\u{1F914}", "nachdenken ueberlegen hm"],
+      ["\u{1F928}", "skeptisch zweifel augenbraue"],
+      ["\u{1F644}", "augenrollen genervt"],
+      ["\u{1F925}", "luege pinocchio"],
+      ["\u{1F633}", "peinlich rot"],
+      ["\u{1F971}", "muede gaehnen"],
+      ["\u{1F634}", "schlafen muede"],
+      ["❓", "frage unklar"],
+    ],
+  },
+  {
+    name: "Arbeit",
+    zeichen: [
+      ["\u{1F525}", "feuer krass stark lit"],
+      ["\u{1F680}", "rakete start schnell wachstum"],
+      ["\u{1F4C8}", "diagramm hoch wachstum zahlen"],
+      ["\u{1F4C9}", "diagramm runter weniger"],
+      ["\u{1F4A1}", "idee gluehbirne einfall"],
+      ["\u{1F4CC}", "pinnadel wichtig merken"],
+      ["⚠️", "achtung warnung vorsicht"],
+      ["\u{1F6A8}", "alarm dringend wichtig"],
+      ["⏰", "wecker zeit termin"],
+      ["\u{1F4C5}", "kalender termin datum"],
+      ["\u{1F4B0}", "geld diamanten umsatz"],
+      ["\u{1F48E}", "diamant edelstein wert"],
+      ["\u{1F3C6}", "pokal sieg bester"],
+      ["⭐", "stern gut bewertung"],
+      ["\u{1F4DD}", "notiz schreiben aufgabe"],
+      ["\u{1F50D}", "lupe suchen pruefen"],
+      ["\u{1F4CE}", "anhang datei bueroklammer"],
+      ["⚙️", "zahnrad technik einstellung"],
+    ],
+  },
+  {
+    name: "Sonst",
+    zeichen: [
+      ["\u{1F44B}", "winken hallo tschuess"],
+      ["\u{1F3B5}", "musik ton sound"],
+      ["\u{1F3A5}", "kamera video dreh"],
+      ["\u{1F4F1}", "handy telefon app"],
+      ["\u{1F4AC}", "sprechblase chat reden"],
+      ["\u{1F37B}", "prost feiern bier"],
+      ["☕", "kaffee pause"],
+      ["\u{1F355}", "pizza essen"],
+      ["\u{1F382}", "geburtstag torte"],
+      ["\u{1F381}", "geschenk ueberraschung"],
+      ["\u{1F340}", "kleeblatt glueck"],
+      ["\u{1F308}", "regenbogen bunt"],
+      ["☀️", "sonne schoen wetter"],
+      ["\u{1F319}", "mond nacht spaet"],
+      ["\u{1F415}", "hund dog dogi"],
+      ["\u{1F336}️", "chili scharf spicy"],
+    ],
+  },
+];
+
+/** Alles, was angenommen wird -- aus dem Katalog ABGELEITET.
+ *  Eine zweite Liste daneben wäre die, in der ein Zeichen fehlt, das
+ *  die Oberfläche anbietet. */
+export const ERLAUBT = new Set(
+  KATALOG.flatMap((g) => g.zeichen.map(([z]) => z)));
+
+/** Was vorn steht, solange jemand nichts Eigenes gewählt hat.
+ *  Bewusst dieselben sechs wie am 14.09. früh: Wer sich daran gewöhnt
+ *  hat, findet sie an derselben Stelle wieder. */
+export const VORSCHLAG = ["\u{1F44D}", "❤️", "\u{1F602}",
+  "\u{1F62E}", "\u{1F525}", "\u{1F64F}"];
+
+/** Wie viele Favoriten jemand ablegen darf.
+ *
+ *  EINE OBERE GRENZE MUSS SEIN, sonst ist die Vorschlagszeile
+ *  irgendwann die ganze Tafel -- und der Sinn der Vorschläge ist, dass
+ *  man sie nicht lesen muss. Acht passt in eine Zeile, auch am Handy. */
+export const FAVORITEN_MAX = 8;
+
+/* Eine Selbstprüfung beim Laden: Doppelte im Katalog wären still --
+   sie erschienen zweimal in der Tafel, und niemand sucht danach.
+   Lieber beim Start laut als im Betrieb leise. */
+{
+  const alle = KATALOG.flatMap((g) => g.zeichen.map(([z]) => z));
+  const doppelt = alle.filter((z, i) => alle.indexOf(z) !== i);
+  if (doppelt.length) {
+    console.error("[reaktionen] Doppelte Zeichen im Katalog:", doppelt.join(" "));
+  }
+  const fehlt = VORSCHLAG.filter((z) => !ERLAUBT.has(z));
+  if (fehlt.length) {
+    console.error("[reaktionen] Vorschlag steht nicht im Katalog:", fehlt.join(" "));
+  }
+}

server/workspace.js

@@ -2883,6 +2883,29 @@ export function db() {
       CREATE INDEX IF NOT EXISTS idx_chat_reaktionen_nachricht
         ON chat_reaktionen (nachricht_id);
 
+      /* FAVORITEN (14.09.2026).
+
+         Filipe: "man soll auch auswaehlen koennen, also paar als
+         vorschlaege mit der moeglichkeit andere auszuwaehlen und als
+         favoriten zu speichern."
+
+         AM MENSCHEN, NICHT AM GERAET. Im Browser abgelegt waeren sie
+         am Handy andere als am Rechner -- und beim naechsten Loeschen
+         der Seitendaten weg. Wer sich etwas merkt, will es ueberall
+         wiederfinden.
+
+         Die Spalte "platz" haelt die REIHENFOLGE. Ohne sie waere die
+         Vorschlagszeile bei jedem Laden anders sortiert, und man
+         greift daneben, weil das Zeichen gewandert ist. */
+      CREATE TABLE IF NOT EXISTS chat_reaktion_favoriten (
+        person_id INTEGER NOT NULL REFERENCES personen(id) ON DELETE CASCADE,
+        zeichen   TEXT NOT NULL,
+        platz     INTEGER NOT NULL,
+        PRIMARY KEY (person_id, zeichen)
+      );
+      CREATE INDEX IF NOT EXISTS idx_chat_favoriten_person
+        ON chat_reaktion_favoriten (person_id, platz);
+
       /* Creator-Profil (Onboarding aus dem Konzept). Eine Zeile je
          Creator, entsteht erst beim ersten Speichern.
          admin_notiz ist bewusst Teil dieser Tabelle, wird aber nur an