/* tagwerk – Knoepfe, Felder, Marken, Rueckfragen und die schmalen Schirme
 *
 * Teil der Gestaltung; eingebunden in index.html in fester Reihenfolge
 * (grund, listen, bedienung, drucken). */

/* --- Knoepfe ------------------------------------------------------------- */
/* Dieselben Knoepfe wie bei mapfit: heller Grund, duenner Rahmen, 6px Radius.
   Farbe traegt nur, was sie braucht - das Gruen fuehrt weiter, das Rot warnt. */
.btn {
  display: inline-flex; align-items: center; justify-content: center; gap: 5px;
  padding: 5px 12px; border: 1px solid var(--border-feld); border-radius: 6px;
  background: var(--flaeche); color: var(--text); font: inherit; font-size: 13px;
  cursor: pointer; white-space: nowrap;
}
.btn-sm { padding: 3px 10px; font-size: 13px; }
.btn:hover:not(:disabled) { background: var(--grau-hauch); }
.btn:disabled { opacity: 0.5; cursor: not-allowed; }
.btn:focus-visible { outline: 2px solid var(--blau-tief); outline-offset: 1px; }
.btn-primary { background: var(--gruen-tief); border-color: var(--gruen-tief); color: #fff; }
.btn-primary:hover:not(:disabled) { background: var(--gruen-tiefer); }
/* Zerstoerendes traegt die Warnfarbe und ein ×, genau wie bei mapfit: Die
   Farbe allein sieht man im Augenwinkel nicht zuverlaessig, das Zeichen davor
   kuendigt an, was der Knopf tut, bevor man ihn liest. Nicht bei den
   Sinnbild-Knoepfen - die tragen ihr Zeichen schon selbst. */
.btn-danger { color: var(--rot-tief); }
.btn-danger:not(.btn-icon)::before { content: "× "; font-weight: 600; }
.btn-danger:hover:not(:disabled) { background: var(--rot-hauch); border-color: var(--rot-tief); }
.btn-tight { padding: 3px 9px; font-size: 12px; }
/* Ein Knopf, der nur ein Zeichen traegt, ist ein Quadrat, und das Zeichen sitzt
   in seiner Mitte.
 *
 * Beides muss dastehen. Die Hoehe: Ohne sie ergibt sie sich aus dem
 * Zeilenabstand der Schrift, waehrend die Breite fest ist - der Knopf wurde ein
 * liegendes Rechteck und stand neben seinen Nachbarn zu niedrig. Und
 * line-height: 1, weil der Zeilenkasten sonst hoeher ist als das Zeichen darin:
 * Die Schrift haelt darueber und darunter Platz frei fuer Ober- und
 * Unterlaengen, die ein „⋯" oder ein „☰" gar nicht hat, und das Zeichen haengt
 * in diesem Kasten so tief, wie es die Grundlinie vorgibt.
 *
 * Und die drei flex-Zeilen stehen HIER, nicht bei .btn (berichtigt am
 * 12.08.2026): Der Verlass darauf, dass .btn sie ohnehin traegt, stimmte
 * nicht - .btn ist inline-block. Das Zeichen sass damit links oben statt in
 * der Mitte, und bei jedem gezeichneten Sinnbild fiel es auf. */
.btn-icon {
  display: inline-flex; align-items: center; justify-content: center;
  width: 30px; height: 30px; padding: 0; line-height: 1;
}
/* Ein Zeichenknopf zwischen schmalen Knoepfen (btn-tight) wird kleiner, bleibt
   aber quadratisch - sonst fiele er aus der Flucht der Reihe. */
.btn-icon.btn-tight { width: 24px; height: 24px; font-size: 14px; }
/* 26x26 im Kopf: Dort traegt die ganze Reihe 26 px, und ein Knopf, der nur
   ein Zeichen traegt, ist ein Quadrat.

   Seit dem 16.08.2026 steht genau das auch im Gestaltungssystem
   (design-system/dist/basis.css, .btn-icon und header .btn-icon): 30x30 in
   der Flaeche, 26x26 im Kopf. Bis dahin sagte basis.css dort 30x26 - ein
   liegendes Rechteck -, und tagwerk, mapfit und patientensim hielten je
   eigene Werte; derselbe Burger sah in den drei Werkzeugen verschieden aus.
   Die beiden Regeln hier sind damit wertgleich mit dem System und bleiben
   nur stehen, weil tagwerk basis.css nicht einbindet. */
header .btn-icon { width: 26px; height: 26px; }
/* Leise: sieht aus wie ein Verweis, nicht wie ein Knopf - fuer das, was selten
   und nie versehentlich getan wird. */
.btn-leise {
  border-color: transparent; background: none; color: var(--muted);
  text-decoration: underline; padding-left: 4px; padding-right: 4px;
}
.btn-leise:hover:not(:disabled) { background: none; color: var(--text); }
.btn.block { display: flex; width: 100%; margin-top: 6px; }
/* Die Knoepfe der Spalte („＋ Neue Liste", „Ansicht merken", „Papierkorb")
   sprechen dieselbe Sprache wie die Zeilen darueber (Wunsch vom 12.08.2026,
   siehe .wahl in listen.css): durchsichtig, links buendig, und beim
   Ueberfahren faerben sich Rahmen und Schrift gruen. Ein gefuellter Kasten
   zwischen lauter durchsichtigen Zeilen las sich als etwas anderes, dabei
   ist es dieselbe Spalte. */
#spalte .btn.block {
  justify-content: flex-start; background: none; border-color: transparent;
  color: var(--text);
}
#spalte .btn.block:hover:not(:disabled) {
  background: none; border-color: var(--gruen-tief); color: var(--gruen-tief);
}
/* Auch der LEISE Knopf steht in der Flucht (12.08.2026): „＋ Ansicht
   erstellen …" trug als btn-leise nur 4 px Polsterung links und begann damit
   sichtbar weiter aussen als „＋ Diese Ansicht merken" direkt darueber -
   zwei Zeilen desselben Blocks, zwei Anfaenge. Leise heisst hier: kein
   Rahmen, gedaempfte Schrift. Es heisst nicht: an einer anderen Stelle. */
#spalte .btn.block.btn-leise { padding-left: 12px; padding-right: 12px; }
.btn-row { display: flex; gap: 6px; flex-wrap: wrap; }

/* Der Kasten hinter dem ⋯ einer Blockueberschrift in der Spalte (13.08.2026,
   siehe .block-kopf in listen.css): dasselbe Bauteil wie die Menues im Kopf,
   nur kleiner.

   Er steht HIER und nicht bei seinen Geschwistern in listen.css, weil er
   .btn-row traegt: Deren `display: flex` steht eine Zeile darueber, und bei
   gleicher Spezifitaet gewinnt die spaeter geladene Datei. Ein `display:
   none` in listen.css verlor damit gegen dieses hier - das Menue stand
   dauerhaft offen, und seine Zeilen sahen als volle Knoepfe riesig aus.

   position: absolute, damit das Aufklappen die Aufzaehlung darunter nicht
   wegschiebt - sonst huepfte die halbe Spalte. */
.block-menue {
  display: none; position: absolute; right: 0; top: 22px; z-index: 6;
  flex-direction: column; gap: 2px; min-width: 170px; padding: 6px;
  border: 1px solid var(--border); border-radius: 8px;
  background: var(--flaeche); box-shadow: 0 6px 20px rgba(0, 0, 0, .18);
}
.spalte-block.mehr-auf .block-menue { display: flex; }
/* Menuezeilen und keine Knoepfe: linksbuendig, ohne Rahmen und ohne Fuellung -
   dieselbe Machart wie #kopf-werkzeuge weiter unten. Die Regel muss die
   Blockgriffe von #spalte .btn ueberstimmen, deshalb die Kennung davor. */
#spalte .block-menue .btn {
  justify-content: flex-start; width: auto; margin: 0;
  padding: 6px 9px; font-size: 13px; line-height: 1.3;
  border: 1px solid transparent; border-radius: 6px; background: none;
}
#spalte .block-menue .btn:hover:not(:disabled) {
  background: none; border-color: var(--gruen);
}

/* --- Felder -------------------------------------------------------------- */
input[type="text"], input[type="search"], input[type="date"],
input[type="datetime-local"], input[type="number"], input[type="time"],
select, textarea {
  font-family: inherit;
}
input:focus-visible, select:focus-visible, textarea:focus-visible {
  outline: 2px solid var(--gruen-tief); outline-offset: -1px;
}

/* Ueber einem Schreibfeld steht die Schreibmarke - ausdruecklich und nicht
   dem Zufall ueberlassen (Wunsch vom 27.08.2026: „Cursor ueber Textfeld
   sichtbar machen").

   Der Browser macht das von sich aus, solange ihm niemand dazwischenkommt.
   In Tagwerk kommt ihm jemand dazwischen: `cursor` VERERBT sich, und ueber
   der Liste liegen lauter Kaesten, die einen eigenen Zeiger setzen - die
   Eintragszeile die Greifhand (.eintrag-zeile), die Klapp-Ueberschrift und
   die Spaltenzeilen die Hand (summary, .wahl). Jedes Feld, das darin steht
   oder kuenftig darin landet, erbt deren Zeiger und sieht damit aus wie
   etwas zum Anfassen statt wie etwas zum Hineinschreiben. Genau umgekehrt
   ist es aber: Die Felder in den Unterpunkten tragen keinen Rahmen, solange
   man sie nicht ueberfaehrt - der Zeiger ist dort das ERSTE, was sagt, dass
   sich hier tippen laesst.

   Nur echte Schreibfelder. Ein Datum, eine Uhrzeit und eine Auswahlliste
   bedient man ueber ihre Griffe, nicht durch Schreiben - dort bleibt der
   Pfeil bzw. die Hand richtig. */
input[type="text"], input[type="search"], input[type="password"],
input[type="email"], input[type="tel"], input[type="url"],
input[type="number"], textarea {
  cursor: text;
}
select { cursor: pointer; }
/* Gesperrt ist gesperrt - dieselbe Auskunft wie an einem gesperrten Knopf
   (.btn:disabled oben). Ohne diese Zeile behielte ein ausgegrautes Feld die
   Schreibmarke und luede zum Tippen ein, das nicht ankommt. */
input:disabled, textarea:disabled, select:disabled { cursor: not-allowed; }

/* Die Suche im Kopf: dieselbe Tinte wie der Kopf, nur eine Spur heller, damit
   das Feld als Eingabe zu erkennen bleibt. Die Lupe steckt als Zeichnung im
   Feld und nicht als Knopf daneben - sie sagt, wozu das Feld da ist, ohne ein
   zweites Bedienelement zu sein. */
#suche {
  width: 100%; padding: 5px 10px 5px 30px; font-size: 13px;
  border: 1px solid var(--tinte-linie); border-radius: 6px;
  background: var(--tinte-hoch) url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Ccircle cx='7' cy='7' r='4.2' fill='none' stroke='%236f8069' stroke-width='1.6'/%3E%3Cpath d='M10.2 10.2 14 14' stroke='%236f8069' stroke-width='1.6' stroke-linecap='round'/%3E%3C/svg%3E") no-repeat 8px 50%;
  background-size: 14px 14px;
  color: var(--tinte-text);
}
#suche::placeholder { color: light-dark(#6f8069, #8fa091); }
#suche:hover { border-color: light-dark(#33493a, #4e6355); }
#suche:focus { outline: 2px solid var(--gruen); outline-offset: -1px; border-color: transparent; }

/* --- Der Schnelleinwurf --------------------------------------------------
   Ein eigener Kasten mit Rahmen: Was hier steht, legt etwas an. Der
   Filterstreifen darunter veraendert nur die Sicht. Ohne diese Trennung
   standen zwei Reihen gleich aussehender Marken uebereinander, und man
   klickte im Filter, was man eintragen wollte. */
/* Der Abstand steht OBEN: Der Einwurf ist seit dem 12.08.2026 der Fuss der
   Spalte (siehe #inhalt in grund.css) - er braucht Luft zur Liste ueber ihm
   und keinen Rand nach unten, wo die Kante des Fensters kommt. */
#schnell {
  margin-top: 12px; padding: 10px 12px;
  border: 1px solid var(--border); border-radius: 8px; background: var(--flaeche);
}
/* Eckige Marken im Einwurf, runde im Filter - der Unterschied ist im
   Augenwinkel zu sehen, ohne ihn zu lesen. */
#schnell .chip { border-radius: 6px; }
.schnell-zeile { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
.schnell-zeile + .schnell-zeile { margin-top: 7px; }
/* Das ＋ steht neben dem Titelfeld, in JEDER Listenart (Wunsch vom
   12.08.2026) - und zwar per order und nicht per Stellung im Dokument:
   Dort steht es weiterhin HINTER den Kernfeldern der Art (Betrag, Bestand,
   Einheit, Jahrgang, Takt), damit Tab vom Text erst dorthin springt und
   dann aufs Absenden. Was man sagen MUSS, kommt vor dem Knopf; wo er
   GEZEICHNET wird, ist eine andere Frage.
   Alles Uebrige bekommt order 2 und faellt damit dahinter - auch das, was
   im Dokument davor steht. */
#einwurf-eingabe > * { order: 2; }
#einwurf-eingabe > .einwurf-text { order: 0; }
/* Die KERNFELDER der Art stehen vor dem ＋ (Wunsch vom 12.08.2026): Betrag
   und Zahler in der Kasse, Bestand und Einheit im Vorrat, Menge auf dem
   Zettel, Datum und Jahrgang beim Geburtstag, Takt beim Vertrag. Sie sind
   Teil dessen, was man TIPPT - und was man tippt, steht vor dem Knopf, der
   es abschickt. Ohne diese Zeile sass das ＋ mitten darin, weil es per order
   gleich hinter das Titelfeld gezogen wird.

   Die Listenwahl und der Scanner bleiben dahinter: Die eine sagt, WOHIN es
   faellt (und steht meistens schon richtig), der andere ist ein Nebenweg. */
#einwurf-eingabe > #f-termin, #einwurf-eingabe > #f-jahrgang,
#einwurf-eingabe > #f-betrag, #einwurf-eingabe > #f-wer,
#einwurf-eingabe > #f-bestand, #einwurf-eingabe > #f-menge,
#einwurf-eingabe > #f-zeitraum { order: 0; }
#einwurf-eingabe > #btn-einwerfen { order: 1; flex: none; font-size: 17px; }
/* Feld und Pflicht-Stern als eine Gruppe (10.08.2026): Sie bricht als
   Ganzes um, ihr Inneres nie - ein Stern allein in der naechsten Zeile
   markiert nichts. */
.einwurf-text { display: flex; align-items: center; gap: 6px; flex: 1 1 240px; min-width: 0; }
#neu-text {
  flex: 1 1 auto; min-width: 0; padding: 7px 10px; font-size: 14px;
  border: 1px solid var(--border-feld); border-radius: 6px; background: var(--flaeche);
}
/* Die Waehrungswahl stand als einzige nicht in dieser Liste (gemeldet am
   23.08.2026 fuer die Vertraege) und nahm damit die Zeichnung des Browsers:
   ohne Rahmen, mit anderer Fuellung und anderer Schriftgroesse - direkt neben
   dem Betragsfeld, mit dem sie EIN Feld bildet. Dasselbe war schon der Menge
   passiert; ein Feld, das man beim Eintragen vergisst, faellt genau dort auf,
   wo es neben seinem Nachbarn steht. */
#neu-liste, #neu-termin, #neu-betrag, #neu-waehrung, #neu-wer, #neu-bestand,
#neu-menge, #neu-einheit, #neu-zeitraum, #neu-jahrgang {
  padding: 6px 8px; font-size: 13px;
  border: 1px solid var(--border-feld); border-radius: 6px; background: var(--flaeche);
}
#neu-liste { max-width: 190px; }
/* Ein artabhaengiges Kernfeld samt seiner Beschriftung: Betrag, Bestand, der
   Anbieter. Sie stehen in der ERSTEN Zeile, zwischen Text und Knopf - was man
   sagen muss, gehoert vor das Absenden. Zusammengehalten, damit Beschriftung
   und Feld beim Umbruch nicht auf zwei Zeilen fallen; die Gruppe selbst darf
   umbrechen, ihr Inneres nicht. */
.einwurf-feld { display: inline-flex; align-items: center; gap: 6px; flex: none; }
/* Der gemerkte Strichcode im Einwurf: Monospace wie jeder feste Wert. */
.barcode-wert {
  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
  font-size: 13px;
}

/* Die Zahlenfelder bleiben schmal: Ein Bestand hat zwei Stellen, kein Feld von
   200 Pixeln - und drei davon nebeneinander muessen in eine Handybreite. */
#neu-bestand { width: 4.5em; }
/* Die Menge auf dem Zettel ebenso (berichtigt am 13.08.2026, gemeldet am
   selben Tag: "Einkaufliste Eingabe gesprengt, Menge zu breit, Buttons
   brechen um"). Sie stand als einziges Zahlenfeld nicht in dieser Liste und
   nahm die Vorgabebreite eines Eingabefelds - rund zwanzig Zeichen fuer eine
   Zahl mit ein bis zwei Stellen. Solange sie ein Textfeld war, fiel das nicht
   auf; mit den Pfeilen kam die Breite des Drehknopfs dazu, und die Reihe
   brach um. Etwas breiter als der Bestand, weil die Pfeile Platz brauchen. */
#neu-menge { width: 5em; }
#neu-jahrgang { width: 6em; }
#neu-betrag { width: 6.5em; }
/* Die Beschriftung vor den Marken sagt, was sie setzen: die eigene Einteilung
   oder - in einer Geburtstagsliste - ein festes Datum. Ohne sie waere "morgen"
   zweideutig. */
.marken-be { font-size: 11px; color: var(--muted); flex: none; }
/* Zwischenueberschriften in den aufklappenden Menues (Wunsch vom 10.08.2026):
   klein, leise, mit Strich darueber - dieselbe Machart wie die abgesetzte
   Kennung im Kopfmenue. Sie teilen das Menue in Absaetze (Eintraege - Liste -
   Teilen - Daten - Endgueltig), damit vierzehn Zeilen nicht als ein Brei
   dastehen. Eine Ueberschrift steht nur, wenn unter ihr auch etwas steht
   (menueUeberschriften in ansicht.js). */
.menue-be {
  display: block; font-size: 10px; letter-spacing: 0.08em; text-transform: uppercase;
  color: var(--gliederung); padding: 8px 12px 2px; margin-top: 4px;
  border-top: 1px solid var(--border);
}
#listen-griffe > .menue-be:first-child { border-top: 0; margin-top: 0; padding-top: 2px; }
/* Der Pflicht-Stern: das eine Zeichen, das jeder als "muss" liest. GRUEN wie
   im Portal (assets/portal.css dort) und nicht rot: Gruen ist der Akzent der
   Familie - rot ist die Warnfarbe, und ein roter Stern saehe aus, als waere
   schon etwas schiefgegangen (berichtigt am 10.08.2026). */
.pflicht { color: var(--gruen-tief); font-weight: 700; flex: none; cursor: help; }
/* Ein Pflichtfeld, das beim Bestaetigen leer war (12.08.2026): Der Kasten
   bleibt offen, der Zeiger springt hinein - und das Feld sagt, dass es
   gemeint ist. Ohne diese Marke bliebe nur ein Kasten, der nicht zugeht,
   und man raet, woran es liegt. Rot und nicht gruen: Hier ist etwas
   ausstehend, und der Stern daneben ist die Ankuendigung, nicht die
   Meldung. */
.mf-dialog-feld.fehlt input, .mf-dialog-feld.fehlt select,
.mf-dialog-feld.fehlt textarea { border-color: var(--rot-tief); }
.mf-dialog-feld.fehlt > span:first-child { color: var(--rot-tief); }
/* Das leere Pflichtfeld sagt es in einem SATZ, nicht nur in Rot (dialog.js). */
.mf-dialog-fehler { display: block; margin-top: 3px; font-size: 12px; font-weight: 400; color: var(--rot-tief); }
/* Ein Betrag, der keiner ist (03.10.2026, betragMarkieren in ansicht.js):
   dasselbe Rot wie das leere Pflichtfeld - und auch hier mit Satz. Die Regel
   haengt an aria-invalid und nicht an einer Klasse, damit Ansage und Anblick
   nicht auseinanderlaufen koennen. */
input[aria-invalid="true"] { border-color: var(--rot-tief); }

/* Marken statt Auswahllisten: "morgen" ist ein Klick, im Auswahlfeld waeren es
   drei. Sie sind Schalter, keine Knoepfe - deshalb flach und ohne Fuellung,
   bis einer an ist. */
.chip-gruppe { display: inline-flex; align-items: center; gap: 3px; flex-wrap: wrap; }
.chip {
  padding: 3px 9px; border: 1px solid var(--border-feld); border-radius: 999px;
  background: var(--flaeche); font: inherit; font-size: 12px; color: var(--muted);
  cursor: pointer;
  /* Nicht schrumpfen und nicht umbrechen: In der seitlich wandernden Zeile am
     Handy wuerde aus "ohne Termin" sonst ein zweizeiliges Etwas. */
  flex: none; white-space: nowrap;
}
.chip:hover { border-color: light-dark(#8c959f, #6f7d73); color: var(--text); }
.chip.ist-an { background: var(--gruen-hauch); border-color: var(--gruen-tief); color: var(--gruen-tief); font-weight: 600; }
/* Die Zahl in der Marke sagt, was der Filter einbraechte - eine Null waere
   eine Auskunft, die niemand braucht, und stuende in jeder Marke. */
.chip .zahl { margin-left: 5px; font-size: 10px; font-variant-numeric: tabular-nums; opacity: 0.75; }
.chip .zahl:empty { display: none; }

/* --- Die Einteilung nach dem Anlegen -------------------------------------
   Eine Leiste, die von unten hereinfaehrt und sich ueber den Einwurf legt
   (Wunsch vom 12.08.2026). Sie steht genau dort, wo eben noch getippt wurde -
   der Blick muss nicht wandern, und der Daumen liegt schon da.

   Absolut im Inhalt und nicht fest im Fenster: Der Inhalt hat seine
   Lesebreite, und eine Leiste ueber die ganze Fensterbreite haenge neben der
   Spalte in der Luft. Die beiden automatischen Seitenraender halten sie in
   derselben Flucht wie Kopfzeile, Liste und Einwurf. */
#einteilung {
  /* Genau ueber dem Einwurf und genauso breit (Wunsch vom 12.08.2026): Die
     Einrueckung entspricht der Polsterung von #inhalt - ohne sie stand der
     Layer links und rechts um zwanzig Pixel ueber, und seine Felder sahen
     groesser aus als dieselben Felder darunter. Er ERSETZT die Anlage,
     solange er steht; dann muss er auch ihre Masse haben. */
  position: absolute; left: 20px; right: 20px; bottom: 12px; z-index: 30;
  /* width: auto gegen die Grundregel #inhalt > * (dort steht 100%): Mit
     gesetzter Breite UND beiden Kanten waere der Kasten ueberbestimmt, die
     automatischen Raender fielen auf null, und er klebte links statt in der
     Lesebreite mittig zu stehen. */
  width: auto;
  display: flex; flex-direction: column; gap: 7px;
  padding: 10px 12px;
  border: 1px solid var(--gruen-tief); border-radius: 8px;
  background: var(--flaeche); box-shadow: 0 -6px 24px rgba(0, 0, 0, 0.18);
  animation: einteilung-herein 0.14s ease-out;
}
/* Herein von unten - dieselbe Bewegung, die sie beschreibt: Sie kommt von
   dort, wo der Einwurf steht, und legt sich darueber. */
@keyframes einteilung-herein {
  from { transform: translateY(100%); opacity: 0; }
  to { transform: translateY(0); opacity: 1; }
}
/* Wer Bewegung abbestellt hat, bekommt sie ohne - die Leiste steht dann
   einfach da. Das Betriebssystem stellt diesen Wunsch, und er gilt fuer
   Menschen, denen Bewegung auf dem Schirm Uebelkeit macht. */
@media (prefers-reduced-motion: reduce) {
  #einteilung { animation: none; }
}
.einteilung-kopf, .einteilung-zeile {
  display: flex; align-items: center; gap: 8px; flex-wrap: wrap;
}
/* Den Platz bekommt der NAME, nicht die Luft daneben (berichtigt am
   13.08.2026: „bei Neue Aufgabe wird darum abgeschnitten, riesiger Platz bis
   zum Pfeil").

   Der Name stand auf flex: 0 1 auto - er durfte also schrumpfen, aber nicht
   wachsen -, und der Abstandhalter daneben nahm mit flex: 1 1 auto alles,
   was uebrig war. Ergebnis: Der getippte Text wurde nach ein paar Woertern
   ausgepunktet, waehrend rechts daneben eine Handbreit Leere bis zum
   Abbrechen-Kreuz stand. Ein Abstandhalter ist dazu da, einen Griff an den
   Rand zu schieben - er darf sich nicht am Platz bedienen, den der Inhalt
   braucht. */
.einteilung-kopf .luft { flex: 0 1 auto; min-width: 8px; }
/* Der Haken ganz rechts in der Einteilungszeile, ohne eine eigene Zeile dafür
   (Wunsch vom 12.08.2026). order haelt ihn am Ende, obwohl er im Dokument
   vorn steht - dort muss er stehen, weil zeichneSchnell die Marken und das
   Datumsfeld hierher ANHAENGT. */
#btn-einteilung-anlegen { order: 9; margin-left: auto; }
/* Platz zwischen der Beschriftung und den Marken (Wunsch vom 12.08.2026):
   „Priorität:" und „Angehen:" sind die FRAGE, die Marken dahinter die
   Antworten - eng aneinander las sich beides als eine Reihe. Eine feste
   Breite fuer die Beschriftung stellt beide Zeilen ausserdem in eine Flucht:
   Die Marken beginnen untereinander, statt um die Laenge des Wortes versetzt. */
.einteilung-zeile > .marken-be { flex: 0 0 68px; margin-right: 4px; }

/* Der Name der angelegten Aufgabe: Er sagt, WOVON hier die Rede ist - beim
   dritten Einwurf in Folge ist das keine Nebensache. Er gibt nach und kuerzt
   sich, denn er ist die Auskunft und nicht die Bedienung. */
.einteilung-name {
  min-width: 0; flex: 1 1 auto; font-size: 13px; font-weight: 600;
  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
}
/* Eckige Marken wie im Einwurf: Was hier gedrueckt wird, AENDERT etwas -
   dieselbe Unterscheidung wie dort (eckig legt an und stellt, rund filtert). */
#einteilung .chip { border-radius: 6px; }
#einteilung .chip:disabled { opacity: 0.5; cursor: default; }
#einteilung input[type="date"], #einteilung input[type="time"] {
  padding: 6px 8px; font-size: 13px;
  border: 1px solid var(--border-feld); border-radius: 6px; background: var(--flaeche);
}

/* --- Der Filter hinter dem Trichter --------------------------------------
   Die Schnellfilter standen als Streifen ueber den Eintraegen und stehen seit
   dem 12.08.2026 in einem Menue neben dem ⋯ (Wunsch vom selben Tag): Sie
   sollen nicht dauerhaft dastehen. Der Kasten ist derselbe wie beim ⋯ und beim
   Teilen - nur sein Inhalt sind Marken und keine Zeilen, denn Filtern ist ein
   Auswaehlen aus einer Handvoll, kein Durchgehen einer Liste. */
#filter-griffe {
  display: none; position: absolute; top: calc(100% + 4px); right: 0;
  z-index: 25; flex-direction: column; align-items: stretch; gap: 4px;
  width: max-content; min-width: 210px; max-width: min(320px, 90vw); padding: 6px 8px 8px;
  max-height: calc(100vh - 160px); overflow-y: auto; overscroll-behavior: contain;
  border: 1px solid var(--border); border-radius: 8px;
  background: var(--flaeche); box-shadow: 0 8px 28px rgba(0, 0, 0, 0.22);
}
#kopfzeile.filter-auf #filter-griffe { display: flex; }
#filter-griffe .chip-gruppe { gap: 4px; }
/* Der Zeitplan im Trichter (12.08.2026): Marken wie die Zustandsfilter
   darunter, nur ohne Zeichen - „Heute" braucht keines, und ein erfundenes
   Sinnbild fuer „Uebermorgen" waere ein Raetsel. Sie duerfen umbrechen: In
   einer Geburtstagsliste sind es zwoelf Monate.
   „Alle Zeiten" ist keine Zeitangabe, sondern ihr Fehlen - derselbe leise
   Ton wie in der Spalte, und ein Strich dahinter setzt es ab. */
#zeitplan .chip-alle { color: var(--muted); margin-right: 6px; }
#zeitplan .chip-alle.ist-an { color: var(--gruen-tief); }
#zeitplan .chip-alle::after {
  content: ""; display: inline-block; width: 1px; height: 12px;
  margin-left: 8px; margin-right: -4px; vertical-align: -2px;
  background: var(--border);
}
/* Die Zahl am Trichter sagt, wieviele Filter GESETZT sind - ein zugeklapptes
   Menue darf nicht verschweigen, dass es etwas wegnimmt. Ohne gesetzten
   Filter steht dort nichts - und zwar mit display: none, nicht nur leer:
   Ein leerer Span bleibt sonst ein Flex-Kind, und der gap des Knopfes traegt
   eine Geisterluecke ein - der Knopf wechselte seine Breite, je nachdem, ob
   ein Filter stand (behoben am 12.08.2026). Klein und mit Tabellenziffern
   wie die Zahlen in den Marken, damit 1 und 4 gleich breit sind. */
#btn-filter .zahl { font-size: 10px; font-variant-numeric: tabular-nums; opacity: 0.75; }
#btn-filter .zahl:empty { display: none; }
#btn-filter.ist-an { border-color: var(--gruen-tief); color: var(--gruen-tief); }
/* Der Trichter ist so hoch wie das ⋯ daneben (berichtigt am 13.08.2026:
   „Filter immer noch groesser als andere Buttons").

   Die Ursache ist dieselbe wie beim Profil-Griff im Kopf und beim Rueckweg
   im Eintrag - dreimal derselbe Fehler an drei Stellen: #btn-listenmehr
   traegt `btn-icon` und bekommt damit sein Quadrat (26 px, am Finger 36),
   #btn-filter traegt `btn btn-tight kopf-griff` und behielt die Polsterung
   eines beschrifteten Knopfes. Zwei Griffe nebeneinander in einer Reihe, und
   der eine ist hoeher als der andere.

   Die HOEHE wird angeglichen und nicht die Breite: Der Trichter traegt
   ausser dem Zeichen noch seine Zahl („3 Filter gesetzt"), und die braucht
   Platz. Ein Quadrat schnitte sie ab. */
#btn-filter { height: 26px; padding: 0 7px; }
/* Die Marken tragen Zeichen UND Wort: Im Menue ist Platz, und ein Zeichen
   allein waere ein Raetsel. Das Zeichen traegt die Aussage im Augenwinkel,
   das Wort macht sie eindeutig. */
.chip-zeichen {
  display: inline-flex; align-items: center; gap: 5px;
  padding: 4px 9px;
}
.filter-zeichen {
  width: 15px; height: 15px; flex: none;
  fill: none; stroke: currentColor; stroke-width: 1.5;
  stroke-linecap: round; stroke-linejoin: round;
}
/* Das Dreieck fuer "in Bearbeitung" ist eine Flaeche und keine Linie - als
   Umriss saehe es aus wie ein leeres Warndreieck. */
.filter-zeichen.ist-gefuellt { fill: currentColor; stroke: none; }
/* Was nichts einbraechte, verblasst - statt zu verschwinden (siehe
   zeichneSchnellfilter). Eine Reihe, deren Marken kommen und gehen, greift
   man daneben; eine, in der eine blass ist, liest man im Vorbeigehen. */
#statusfilter .chip.ist-leer { opacity: 0.45; }
#filter-griffe .chip[data-schnell="ueberfaellig"].ist-an {
  background: var(--rot-hauch); border-color: var(--rot-tief); color: var(--rot-tief);
}
#filter-griffe .chip[data-schnell="wichtig"].ist-an {
  background: var(--gelb-hauch); border-color: var(--gelb-tief); color: var(--gelb-tief);
}
#filter-griffe .chip[data-schnell="laeuft"].ist-an {
  background: var(--blau-hauch); border-color: var(--blau-tief); color: var(--blau-tief);
}
#filter-griffe .chip[data-schnell="zugewiesen"].ist-an,
#filter-griffe .chip[data-schnell="wartet"].ist-an {
  background: var(--gelb-hauch); border-color: var(--gelb-tief); color: var(--gelb-tief);
}
.chip.chip-p1.ist-an { background: var(--gelb-hauch); border-color: var(--gelb-tief); color: var(--gelb-tief); }
.chip.chip-p2.ist-an { background: var(--rot-hauch); border-color: var(--rot-tief); color: var(--rot-tief); }
/* Die Seitenwahl traegt ihre Bedeutung als Farbe: Dafuer bleibt das Gruen
   des eingeschalteten Chips, Dagegen wird rot, Neutral grau - dieselben
   Toene wie die beiden Spalten und das Fazit, zu denen die Wahl fuehrt. */
#neu-seite .chip[data-seite="contra"].ist-an {
  background: var(--rot-hauch); border-color: var(--rot-tief); color: var(--rot-tief);
}
#neu-seite .chip[data-seite="neutral"].ist-an {
  background: var(--grau-hauch); border-color: var(--muted); color: var(--muted);
}
/* Alle Schalter (Kaestchen) einheitlich: dieselbe Groesse, dieselbe
   Markenfarbe, mittig zur Zeile - ob "Fuer wen", ein Unterpunkt-Haken oder
   "Takt ab Erledigung". Vorher hatte jede Stelle ihr eigenes Mass. */
#eintragsansicht input[type="checkbox"], .panel input[type="checkbox"] {
  width: 15px; height: 15px; margin: 0; accent-color: var(--gruen-tief);
  vertical-align: -2px; cursor: pointer;
}

.hint { display: block; margin: 6px 0 0; font-size: 11px; line-height: 1.45; color: var(--muted); }

/* --- Die Auswahlleiste ---------------------------------------------------
   Sie steht dort, wo sonst die Schnellfilter stehen: unmittelbar ueber den
   Eintraegen, auf die sie sich bezieht. Im Ton der Auswahl (gruen) und nicht in
   dem eines Filters - sie veraendert nicht die Sicht, sondern was der naechste
   Klick anfasst. */
#auswahlleiste {
  margin-bottom: 10px; padding: 7px 10px;
  border: 1px solid var(--gruen-tief); border-radius: 8px; background: light-dark(#eef5ef, #1a2c1f);
}
/* Zwei Zeilen (Wunsch vom 10.08.2026): oben die Auswahl, darunter die
   Aktionen darauf - in einer Zeile las sich beides als ein Brei. */
.sammel-zeile { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
.sammel-zeile + .sammel-zeile { margin-top: 6px; }
#auswahlleiste .luft { flex: 1 1 auto; }
#auswahl-zahl { font-weight: 600; color: var(--gruen-tief); }
#auswahlleiste .chip { background: var(--flaeche); }
/* Das Datum neben den Einteilungs-Marken (13.08.2026). Es steht in derselben
   Reihe und soll so hoch sein wie sie - sonst schoebe ein Feld in Feldhoehe
   die ganze Zeile auseinander. Nicht schrumpfen: Ein Datumsfeld, das Platz
   abgibt, verliert seinen Inhalt (dieselbe Lehre wie beim Einheitenfeld). */
#sammel-datum {
  flex: none; padding: 2px 6px; font-size: 12px;
  border: 1px solid var(--border-feld); border-radius: 999px;
  background: var(--flaeche); color: var(--text);
}

/* Ein Takt im Panel: eine Beschriftung, ein schmales Feld, eine Einheit -
   "alle [2] Wochen". Zusammengehalten, damit die drei Teile nicht an drei
   Stellen der Zeile umbrechen. */
.panel .takt { display: inline-flex; align-items: center; gap: 5px; flex: none; }
.panel .takt input[type="number"] { width: 4.5em; }
.panel .takt input[type="time"], .panel .takt input[type="date"],
.panel .takt input[type="datetime-local"] { width: auto; }
.panel .plan-zeile input[type="time"] { width: auto; flex: none; }
/* Die Wochentagsmarken sind schmal und gleich breit - sieben Marken in einer
   Reihe liest man als Woche, wenn sie eine Flucht bilden. */
.chip.chip-tag { min-width: 2.6em; justify-content: center; padding: 3px 6px; text-align: center; }

/* --- Die Ablegeleiste ----------------------------------------------------
   Sie erscheint nur waehrend eines Zuges, und zwar fest ueber der Fusszeile:
   immer an derselben Stelle, immer gleich gross, unabhaengig davon, was in
   der Liste steht. Damit laesst sich auch auf einen Zeitraum einteilen, in
   dem noch nichts liegt - ohne dass dafuer die halbe Seite verrutscht. */
#ablegeleiste {
  /* bottom lag bei 46px, um ueber der Fusszeile zu schweben - die ist seit
     dem 31.08.2026 ein Ueber-Kasten im Zahnrad, die Leiste rueckt nach. */
  position: fixed; z-index: 40; left: 50%; bottom: 14px;
  transform: translateX(-50%);
  display: none; align-items: center; gap: 6px; flex-wrap: wrap;
  max-width: min(96vw, 900px);
  padding: 8px 12px; border: 1px solid var(--border); border-radius: 10px;
  background: var(--flaeche); box-shadow: 0 6px 24px rgba(0, 0, 0, 0.22);
}
body.zieht #ablegeleiste { display: flex; }
/* In der Jahresansicht nicht: Ein Geburtstag ist ein Datum und keine Absicht,
   es gibt dort nichts einzuteilen (siehe zielplan in zeit.js). Eine Leiste, die
   erscheint und deren Knoepfe nichts tun, ist schlimmer als keine. */
/* Ohne Ziele keine Leiste - im Jahreskalender (ein Geburtstag hat sein
   Datum) und in den handsortierten Listen. LETZTERE aber nur, solange sie
   keine Kategorien fuehren (10.08.2026): Einkauf, Wuensche und Sammlung
   legen nach Kategorie ab, und dort ist die Leiste am Telefon das einzige
   erreichbare Ziel. Ein Zug auf eine ZEILE ordnet dort weiterhin um - die
   beiden stehen nebeneinander, nicht gegeneinander. */
/* Berichtigt am 12.08.2026: In den handsortierten Listen bleibt die Leiste
   STEHEN. Sie traegt dort seit dem 10.08.2026 die beiden Raender („Ganz nach
   oben", „Ganz nach unten") - und die waren damit in genau den Listen
   unsichtbar, fuer die es sie gibt. Wer einen Fund an den Anfang seiner
   Sammlung ziehen wollte, fand kein Ziel: Ueber der ersten Zeile liegt
   keines, und die beiden Knoepfe standen in einer ausgeblendeten Leiste.

   Weg bleibt sie nur in der Jahresansicht: Ein Geburtstag wird nicht
   eingeteilt und nicht umsortiert, dort gaebe es nichts abzulegen. */
body.jahresansicht #ablegeleiste { display: none; }
/* Eine Leiste, zwei Besetzungen: Zeitraeume ueberall, die beiden Seiten in
   einer Pro-und-Contra-Liste. Zwei Leisten waeren zweimal dieselbe Leiste -
   mit zwei Stellen, an denen man beim naechsten Umbau etwas vergisst. */
.ablege-seite { display: none; }
body.seitenansicht .ablege-seite { display: inline-block; }
body.seitenansicht .ablege-zeit { display: none; }
/* Wo nach Kategorien abgelegt wird (Vertraege, 10.08.2026), treten sie an die
   Stelle der Zeitraeume: Ein Vertrag wird nicht eingeteilt. Ist keine
   Kategorie vergeben, bleibt die Leiste ganz weg - eine leere Leiste ist ein
   Angebot ohne Inhalt (siehe body.ohne-ablege). */
/* In EINER Zeile, die seitlich rollt - nicht umbrechend: Zwanzig Kategorien
   machten die Leiste sonst vier Zeilen hoch, und die steht am Telefon fest
   ueber der Fusszeile, waehrend man mit dem Finger ein Ziel sucht. */
.ablege-kategorien { display: none; gap: 6px; }
body.kategorieansicht .ablege-kategorien {
  display: flex; flex: 1 1 auto; min-width: 0;
  flex-wrap: nowrap; overflow-x: auto; padding-bottom: 2px;
}
body.kategorieansicht .ablege-zeit { display: none; }
/* In den handsortierten Listen gibt es keine Zeitraeume - dort ordnet die
   Handreihenfolge, nicht der Tag. Die Zeitziele fallen deshalb weg; was
   bleibt, sind die beiden Raender und (wo die Liste welche fuehrt) die
   Kategorien. Ein „Heute" in einer Sammlung setzte ein Datum, das die Zeile
   nirgends zeigt. */
body.listenansicht .ablege-zeit { display: none; }
body.ohne-ablege #ablegeleiste { display: none; }
.ablege-be { font-size: 11px; color: var(--muted); flex: none; }
.ablege {
  padding: 7px 14px; border: 1px dashed var(--border); border-radius: 8px;
  background: var(--flaeche-tief); font: inherit; font-size: 13px; color: var(--text);
  cursor: copy; white-space: nowrap;
}
/* Unter dem Zeiger derselbe gruene Ton wie ueberall, wo etwas landet. */
.ablege.ablegen {
  background: var(--gruen-feld); border-color: var(--gruen-tief); border-style: solid;
  color: var(--gruen-tief); font-weight: 600;
}

/* Die Warnzeile ueber der Arbeitsflaeche. Sie geht nicht von selbst wieder
   weg - anders als die Meldezeile unten, die nach ein paar Sekunden
   verschwindet. Was hier steht, muss man beheben, nicht zur Kenntnis nehmen. */
#warnung {
  margin-bottom: 12px; padding: 9px 12px;
  border: 1px solid var(--rot-tief); border-left-width: 4px; border-radius: 6px;
  background: var(--rot-hauch); color: light-dark(#86121b, #ffb3ab); font-size: 13px; line-height: 1.45;
}
#warnung strong { color: var(--rot-tief); }

/* Der Ueber-Kasten - Ersatz der Fusszeile (Familienregel 31.08.2026):
   Marke, Fassung und Urheber hinter „Ueber Tagwerk …" im Zahnrad-Menue.
   Die Marken-Teile sind hier neu gesetzt, weil ihre Regeln in grund.css an
   <footer> haengen (dunkle Fusszeile) - der Kasten ist hell. */
.ueber-kasten {
  min-width: 280px; max-width: calc(100vw - 32px); padding: 18px 20px 14px;
  border: 1px solid var(--border); border-radius: 12px;
  background: var(--flaeche); color: var(--text);
}
.ueber-kasten::backdrop { background: rgba(15, 18, 22, 0.35); }
.ueber-kasten h2 {
  display: flex; align-items: baseline; gap: 8px;
  margin: 0 0 8px; font-size: 18px;
}
.ueber-kasten .fuss-marke { font-family: var(--schrift-anzeige); font-weight: 700; }
.ueber-kasten .akzent { color: var(--gruen-tief); }
.ueber-kasten #fuss-version { font-weight: 400; font-size: 13px; color: var(--muted); white-space: nowrap; }
/* Der Bau-Stand steht in einer EIGENEN Zeile unter der Marke (20.09.2026). In
   der Ueberschrift brach er am Telefon mitten im Satz um - die Kennung des
   Commits stand allein in Zeile zwei, hinter einem Punkt, der ins Leere
   zeigte. Ziffern in gleicher Breite: Man vergleicht ihn mit einem anderen. */
.ueber-kasten #fuss-bau { color: var(--muted); font-variant-numeric: tabular-nums; }
.ueber-kasten p { margin: 4px 0; font-size: 13px; }
.ueber-kasten .von-mischfeld { color: var(--text); text-decoration: none; font-weight: 600; }
.ueber-kasten .von-mischfeld span { color: var(--gruen-tief); }
.ueber-kasten .von-mischfeld:hover span { color: var(--gruen); }
.ueber-kasten form { margin: 14px 0 0; text-align: right; }
/* Am Finger (20.09.2026): Der Kasten liegt ausserhalb von <main> und <header>
   und bekam deren 36 px nie - „Schließen" blieb bei 29. Dazu mehr Luft ueber
   dem Knopf, wie in jeder Rueckfrage, und Verweise mit einer Flaeche, die ein
   Finger trifft (die Zeile waechst dabei nicht). */
@media (hover: none) {
  .ueber-kasten form { margin-top: 24px; }
  .ueber-kasten .btn { min-height: 36px; padding: 0 14px; touch-action: manipulation; }
  .ueber-kasten a { display: inline-block; padding: 8px 0; margin: -8px 0; }
}

/* --- Rueckfragen ---------------------------------------------------------
   Ein eigener Kasten statt confirm(): Er sieht aus wie die Anwendung, laesst
   sich beschriften und haelt die Frage bei dem, worauf sie sich bezieht. */
.mf-dialog {
  border: 1px solid var(--border); border-radius: 12px;
  padding: 18px 20px; max-width: 30rem; width: calc(100vw - 40px);
  background: var(--flaeche); color: var(--text);
  font: 13px/1.5 "Segoe UI", Arial, sans-serif;
  box-shadow: 0 12px 40px rgba(0, 0, 0, 0.22);
  /* Ein <dialog> traegt von Haus aus overflow: auto. Die aufgeklappte Liste
     der zweizeiligen Wahl liegt darueber (position: absolute) und ist hoeher
     als der Kasten - damit erschien beim Aufklappen eine Bildlaufleiste, der
     Kasten sprang in der Breite und die Liste wurde unten abgeschnitten.
     Sichtbar ueberstehen lassen ist das, was ein <select> auch tut: Seine
     Liste haelt sich an kein Elternelement. */
  overflow: visible;
  /* Und trotzdem passt er auf jeden Schirm (12.08.2026): Der Satz „der
     Kasten traegt eine Frage, zwei bis drei Felder und zwei Knoepfe" stimmte
     nicht mehr - „Konfigurieren" einer Kasse hat sechs Felder, und am
     Telefon sind die 16 px hoch und die Knoepfe 36. Mit aufgeklappter
     Tastatur lief der Kasten unten hinaus, und weil er nicht scrollt, kam
     man an „Speichern" nicht mehr heran.
     Gescrollt wird deshalb NUR der Feldbereich (siehe #frage-felder unten):
     Titel, Text und die beiden Knoepfe bleiben stehen, wo sie sind - eine
     Rueckfrage, deren Knoepfe man erst herunterrollen muss, ist keine. */
  max-height: calc(100dvh - 32px);
}
/* Das flex NUR am offenen Kasten - und das ist keine Feinheit, sondern der
   Unterschied zwischen einer Anwendung und einem Trümmerhaufen (Fehler vom
   12.08.2026, sofort gemeldet: „jetzt oeffnen sich zwei Fenster beim Laden
   mit Abbrechen und Ja, und beim Druecken passiert nix").
   Ein <dialog> traegt sein `display: none`, solange es zu ist, im
   Browser-Stylesheet - als gewoehnliche Regel und nicht als Sonderrecht.
   Ein `display: flex` an `.mf-dialog` ueberschreibt es also, und ALLE
   Kaesten der Seite standen offen da: als Bloecke im Fluss, ohne
   Modal-Verhalten, mit Knoepfen, die ins Leere griffen. */
.mf-dialog[open] { display: flex; flex-direction: column; }
/* Das Formular fuellt den Kasten, damit der Feldbereich darin wachsen kann. */
.mf-dialog > form { display: flex; flex-direction: column; min-height: 0; }
/* Der Hintergrund daempft die Anwendung, statt sie zu verdecken: Worueber
   gefragt wird, soll sichtbar bleiben - "Liste mit 14 Eintraegen loeschen?"
   ist leichter zu beantworten, wenn man die vierzehn noch sieht. */
.mf-dialog::backdrop { background: light-dark(rgba(14, 23, 16, 0.38), rgba(0, 0, 0, .55)); }
/* Die Ueberschrift eines Kastens traegt die TEXTFARBE (berichtigt am
   13.08.2026: „Papierkorb-Ueberschrift im Dark Mode nicht lesbar" - und sie
   war nur das sichtbarste Beispiel, es betraf jeden Kasten).

   Hier stand var(--tinte), und das ist kein Paar aus hell und dunkel, sondern
   ein FESTER Wert: #0e1710, das dunkle Gruen der Marke. Auf der hellen
   Kastenflaeche liest es sich als kraeftige Ueberschrift; im dunklen Thema
   steht es auf #1b201d - fast dieselbe Farbe wie der Grund darunter. Die
   Ueberschrift war nicht schlecht lesbar, sie war praktisch unsichtbar.

   Die Markenfarben (--tinte und ihre Verwandten) gehoeren dem Kopf und der
   Fusszeile, die in beiden Welten dunkel bleiben. Was auf der Arbeitsflaeche
   steht, nimmt deren Token - die tragen ihre beiden Fassungen. */
.mf-dialog h2 { margin: 0 0 10px; font-size: 15px; color: var(--text); }
.mf-dialog p { margin: 0 0 8px; }
.mf-dialog p:empty { display: none; }
/* Der eine Teil, der scrollt (12.08.2026 - siehe max-height oben). Die
   Polsterung rechts haelt die Bildlaufleiste von den Feldern weg; overflow-y
   auto und nicht scroll, damit bei zwei Feldern keine leere Leiste dasteht.
   `overflow-x: visible` geht in CSS nicht mit `overflow-y: auto` - der
   Browser macht daraus beidseitig auto. Das ist hier richtig: Die
   aufklappende Liste der zweizeiligen Wahl steht ausserhalb dieses
   Behaelters (sie haengt am Kasten selbst, der weiter overflow: visible
   traegt). */
#frage-felder { min-height: 0; overflow-y: auto; overscroll-behavior: contain; }
/* Nur wenn es eng wird: Ein Kasten mit zwei Feldern soll seine Felder nicht
   in einem eigenen Kaestchen zeigen, sondern schlicht dastehen.

   Links und rechts drei Pixel (berichtigt am 13.08.2026, gemeldet als "beim
   Aufschliessen wird der Rand links von der ersten Zahl abgeschnitten"):
   Dieser Bereich scrollt, und ein Scrollbereich SCHNEIDET an seiner Kante -
   auch waagerecht, denn overflow-y: auto macht aus overflow-x: visible ein
   auto (siehe oben). Das erste Kaestchen des Codes sitzt buendig am linken
   Rand; sein Fokusring liegt zwei Pixel WEITER links und lag damit ausserhalb.
   Zu sehen war es genau dann, wenn das Feld den Fokus bekommt - und das tut
   es beim Aufschliessen von selbst (siehe codefeld.js). */
#frage-felder:not(:empty) { padding: 0 3px; }
/* Solange eine zweizeilige Wahl aufgeklappt ist, darf der Bereich ueberstehen
   (gesetzt in dialog.js): Ein Scrollbereich beschnitte die Liste, und in
   diesem Augenblick ist sie wichtiger als der Rand. */
#frage-felder.laesst-ueberstehen { overflow: visible; }
.mf-dialog .mf-dialog-feld { display: block; margin: 12px 0 4px; font-weight: 600; }
.mf-dialog .mf-dialog-feld input,
.mf-dialog .mf-dialog-feld select {
  display: block; width: 100%; margin-top: 5px; padding: 6px 8px;
  border: 1px solid var(--border-feld); border-radius: 6px; font: inherit;
  background: var(--flaeche);
}
.mf-dialog .mf-dialog-feld input[hidden],
.mf-dialog .mf-dialog-feld select[hidden] { display: none; }
/* Das versteckte Feld der zweizeiligen Wahl traegt nur den Wert. Ohne diese
   Zeile machte die Regel darueber (display: block) es sichtbar - ein leeres
   Kaestchen unter der Auswahl, das nichts tut. */
.mf-dialog .mf-dialog-feld input[type="hidden"] { display: none; }

/* Ein Einmal-Code: weit gesperrt und gross genug, um ihn beim Abtippen mit dem
   Blick zu halten. Dieselbe Machart wie im Portal (.code-eingabe dort) - wer
   eines von beiden eingerichtet hat, erkennt das Feld wieder. */
.mf-dialog .mf-dialog-feld input.code-eingabe,
body.anmeldung .codefeld input.code-eingabe {
  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
  font-size: 17px; letter-spacing: .18em; text-align: center;
}

/* Der Code als sechs Kaestchen (10.08.2026, siehe codefeld.js): je Ziffer
   eines, gross und mittig - beim Abtippen sieht man, wo man steht, und am
   Ende, ob alle sechs da sind. Nach dem dritten eine Luecke, wie man den
   Code abliest (123 456). Die Selektoren sind bewusst schwer genug, um die
   Breitenregeln der Kaesten (input { width: 100% }) zu ueberstimmen -
   Dialog und Anmeldeseite setzen beide eigene. */
.code-ziffern { display: flex; gap: 6px; margin-top: 6px; }
.code-ziffern input.code-ziffer,
.mf-dialog .mf-dialog-feld .code-ziffern input.code-ziffer,
body.anmeldung .code-ziffern input.code-ziffer {
  /* Schrumpfbar (13.08.2026): Sechs Kaestchen zu 40 px, fuenf Luecken und
     die Trennung nach dem dritten sind 280 px - mehr, als ein Kasten auf
     einem 360er Schirm innen hat. Mit flex: none lief die Reihe hinaus und
     wurde beschnitten; so geben die Kaestchen gleichmaessig nach und bleiben
     alle sechs zu sehen. */
  display: block; flex: 0 1 40px; min-width: 0; width: 40px; height: 48px;
  margin: 0; padding: 0; text-align: center;
  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
  font-size: 22px;
  border: 1px solid var(--border-feld); border-radius: 6px;
  background: var(--flaeche); color: var(--text);
}
.code-ziffern input.code-ziffer:nth-of-type(4) { margin-left: 10px; }
/* Der leise Wechsel zum Reservecode: ein Verweis, kein Knopf - er tut nichts
   an den Daten, er tauscht nur das Feld. */
.code-wechsel {
  display: block; margin-top: 8px; padding: 0; border: 0; background: none;
  color: var(--muted); font: inherit; font-size: 12px; font-weight: 400;
  text-decoration: underline; cursor: pointer;
}
/* Textfarbe und nicht die Markentinte: Der Wechsel steht in einem Kasten auf
   der Arbeitsflaeche, und --tinte ist ein fester dunkler Wert (siehe die
   Ueberschrift weiter oben). Beim Ueberfahren wurde er im dunklen Thema
   unsichtbar, statt hervorzutreten. */
.code-wechsel:hover { color: var(--text); }
/* Die otpauth-Adresse als Verweis und nicht als Textfeld: Am Telefon ist ein
   Tipp darauf die ganze Einrichtung - das Betriebssystem oeffnet die
   Authenticator-App und legt das Konto an. Als Feld waere dieselbe Adresse
   eine Zeile Kauderwelsch zum Markieren und Einfuegen. Er sieht aus wie ein
   Knopf, weil er sich wie einer benimmt. */
.mf-dialog .mf-dialog-link {
  display: inline-block; margin-top: 4px; padding: 7px 12px;
  border: 1px solid var(--border); border-radius: 7px;
  background: var(--flaeche); color: var(--gruen-tief); font-weight: 600;
  font-size: 14px; text-decoration: none;
}
.mf-dialog .mf-dialog-link:hover { background: light-dark(#e9efe8, #203025); border-color: light-dark(#c9d3cb, #3a4c40); }

/* --- Die zweizeilige Auswahl (siehe zweizeiligeWahl in dialog.js) ---------
   Oben der Name, darunter klein der Satz, der ihn von den anderen
   unterscheidet - im zugeklappten Knopf wie in jeder Zeile der Liste. Ein
   <select> kann das nicht: Eine Option ist dort eine Zeile Text.

   Gebraucht fuer die Listenart, und das ist der einzige Ort, an dem sich der
   Aufwand lohnt: Sie wird genau einmal gewaehlt, beim Anlegen, und ist die
   Entscheidung, die man spaeter am ehesten bereut. Wer sie trifft, muss die
   sechs Moeglichkeiten nebeneinander sehen koennen und nicht nacheinander. */
.wahl2 { position: relative; font-weight: 400; }
.wahl2-knopf {
  display: block; width: 100%; margin-top: 5px; padding: 6px 26px 6px 8px;
  border: 1px solid var(--border-feld); border-radius: 6px; font: inherit;
  background: var(--flaeche); text-align: left; cursor: pointer;
  /* Das Zeichen rechts wie an einem Auswahlfeld - der Knopf soll aussehen wie
     das, was er ersetzt, und nicht wie ein Knopf, der etwas ausloest. */
  background-image: var(--chevron-ab); background-repeat: no-repeat;
  background-position: right 6px center; background-size: 16px 16px;
}
.wahl2-knopf:hover { border-color: light-dark(#8c959f, #6f7d73); }
.wahl2-knopf:focus-visible { outline: 2px solid var(--gruen-tief); outline-offset: 1px; }
.wahl2-liste {
  position: absolute; z-index: 5; top: calc(100% + 2px); left: 0; right: 0;
  /* Nie hoeher als der halbe Schirm: Sieben zweizeilige Eintraege sind rund
     300 px, und am Telefon stuende die Liste sonst vom Feld bis zum unteren
     Rand. Was darueber hinausgeht, rollt in der Liste selbst. */
  max-height: min(320px, 50vh); overflow-y: auto; margin: 0; padding: 4px;
  list-style: none; border: 1px solid var(--border); border-radius: 8px;
  background: var(--flaeche); box-shadow: 0 10px 30px rgba(0, 0, 0, .22);
}
/* Ist unter dem Feld kein Platz mehr, klappt sie nach oben auf (siehe
   richtungSetzen in dialog.js) - eine Liste, die halb hinter dem Fensterrand
   liegt, ist keine Wahl. */
.wahl2-liste.nach-oben { top: auto; bottom: calc(100% + 2px); }
.wahl2-zeile { padding: 6px 8px; border-radius: 6px; cursor: pointer; }
.wahl2-zeile:hover { background: var(--hauch); }
.wahl2-zeile.ist-an { background: var(--gruen-hauch); }
.wahl2-gewaehlt, .wahl2-zeile { display: block; }
.wahl2-name { display: block; font-weight: 600; }
/* Der Satz darunter: kleiner, leiser, und er darf umbrechen - er ist der
   Grund, warum es diese Auswahl gibt, also wird er nicht abgeschnitten. */
.wahl2-was {
  display: block; margin-top: 1px;
  color: var(--muted); font-size: 12px; font-weight: 400; line-height: 1.35;
}
.wahl2-zeile.ist-an .wahl2-name { color: var(--gruen-tief); }
/* Der Hinweis zur gewaehlten Moeglichkeit, dicht unter ihrem Feld. Eigene Zeile
   hier, weil .mf-dialog p sonst mit seinem Abstand nach UNTEN gewinnt und den
   Satz von seinem Feld loest - er gehoert daran und nicht an das naechste. */
.mf-dialog .hint { margin: 4px 0 0; }
.mf-dialog-knoepfe { display: flex; align-items: center; gap: 8px; margin-top: 16px; }
/* Am Telefon mehr Luft zum letzten Feld (Wunsch vom 12.08.2026): Dort sind
   die Felder hoeher und die Knoepfe auch, und „Zugang: geschuetzt" klebte
   unmittelbar ueber „Uebernehmen" - man traf beim Zielen auf das Auswahlfeld
   den Knopf. Am Zeiger genuegen die 16 px. */
@media (hover: none) {
  .mf-dialog-knoepfe { margin-top: 24px; }
}

/* Ein fester Wert zum Ablesen (Geheimnis, Reservecodes): Monospace in einem
   gestrichelten Kasten - sichtbar keine Eingabe. user-select: all, damit ein
   Klick alles nimmt; pre-wrap, damit je Zeile ein Reservecode steht. */
.mf-dialog .mf-fest {
  display: block; margin-top: 4px;
  font-family: Consolas, "SF Mono", Menlo, monospace;
  font-size: 13px; letter-spacing: 0.04em; line-height: 1.6;
  padding: 8px 10px; border: 1px dashed var(--border); border-radius: 6px;
  background: var(--flaeche-tief); overflow-wrap: anywhere; white-space: pre-wrap;
  user-select: all;
}

/* Vorhandene Werte als Marken unter einem Textfeld (10.08.2026, die
   vergebenen Kategorien): antippen statt abtippen. Dieselben Marken wie in
   den Filtern - sie sind Umschalter und zeigen im An-Zustand, was im Feld
   steht. Sie rollen seitlich statt umzubrechen: Zwanzig Kategorien machten
   den Kasten sonst doppelt so hoch. */
.mf-dialog .feld-marken {
  display: flex; gap: 6px; margin-top: 6px;
  overflow-x: auto; padding-bottom: 2px;
}
.mf-dialog .feld-marken .chip { flex: none; }

/* Eine Reihe Kaestchen im Kasten (10.08.2026, „Welche Listen sind
   geschuetzt"): je Zeile ein Haken und sein Wort, fingergross und mit
   eigener Trefferflaeche. Sie scrollt fuer sich - zwanzig Listen sprengen
   sonst den Kasten. Gesperrte Zeilen bleiben stehen und werden blass:
   ausgrauen statt verstecken. */
.haken-liste { margin-top: 6px; max-height: 40vh; overflow-y: auto; }
.mf-dialog .mf-dialog-feld .haken-zeile {
  display: flex; align-items: center; gap: 8px;
  padding: 6px 2px; font-weight: 400; cursor: pointer;
}
.mf-dialog .mf-dialog-feld .haken-zeile input {
  display: block; flex: none; width: 16px; height: 16px; margin: 0; padding: 0;
}
.mf-dialog .mf-dialog-feld .haken-zeile:has(input:disabled) {
  color: var(--muted); cursor: default;
}

/* Der Scanner-Kasten: Das Kamerabild fuellt die Kastenbreite, bleibt aber
   gedeckelt - ein Hochkant-Telefonbild braucht keine halbe Seite Hoehe, der
   Strichcode liegt ohnehin in der Mitte. Darunter das Tippfeld als eigene
   Zeile: Feld und Knopf nebeneinander, das Feld nimmt den Platz. */
#scan-video {
  display: block; width: 100%; max-height: 40vh; margin-top: 10px;
  border-radius: 6px; background: #000; object-fit: cover;
}
.scan-tippzeile { display: flex; gap: 8px; margin-top: 10px; }
.scan-tippzeile input { flex: 1 1 auto; min-width: 0; }

/* Die Zeilen des Papierkorbs: Text, Herkunft, Griff zurueck. Die Liste
   scrollt fuer sich, damit ein voller Korb den Kasten nicht sprengt. */
#papierkorb-zeilen { margin-top: 10px; max-height: 50vh; overflow-y: auto; }
/* Das Protokoll scrollt wie der Papierkorb fuer sich - 150 Zeilen sprengen
   sonst jeden Kasten. Die Zeilen selbst tragen .verlauf-zeile aus listen.css:
   dieselbe Schrift wie unten im Eintrag, denn es ist dieselbe Auskunft. */
#protokoll-zeilen { margin-top: 10px; max-height: 60vh; overflow-y: auto; }
.korb-zeile {
  display: flex; align-items: center; gap: 6px 10px; padding: 6px 0;
  border-bottom: 1px solid var(--border);
  /* Lange Texte brechen um, statt Herkunft und Griff aus dem Kasten zu
     schieben (Fehler vom 10.08.2026, am Telefon aufgefallen). */
  flex-wrap: wrap;
}
.korb-zeile:last-child { border-bottom: 0; }
.korb-text { flex: 1 1 auto; min-width: 0; overflow-wrap: anywhere; }
.korb-meta { color: var(--muted); font-size: 11px; flex: none; }
/* Derselbe Aufbau im Papierkorb (Wunsch vom 13.08.2026: „Zurueckholen auf
   rechte Seite, genauso wie Leeren, Schliessen links"): Der Rueckweg links,
   die Handlungen rechts. Er hatte es genau andersherum - „Leeren" stand
   links und „Schliessen" rechts -, und damit lag ausgerechnet das
   Endgueltige dort, wo in jedem anderen Kasten das Abbrechen sitzt. */
.mf-dialog-knoepfe #btn-papierkorb-zu { order: 1; margin-right: auto; }
.mf-dialog-knoepfe #btn-papierkorb-leeren { order: 2; }
/* Und „Zurueckholen" ebenso rechts - auch wenn die Zeile umbricht: Ein Griff,
   der je nach Textlaenge mal rechts und mal links steht, laesst das Auge ihn
   in jeder Zeile neu suchen. */
.korb-zeile [data-zurueck] { margin-left: auto; flex: none; }

/* Abbrechen links, Handlung rechts - erst der Rueckweg, dann das Weiter.
   Im Dokument steht die Handlung zuerst, damit Enter sie ausloest (siehe
   index.html); hier wird die Reihenfolge fuers Auge zurechtgerueckt. Das ist
   der einzige Ort, an dem beides auseinanderfaellt - und der Grund dafuer
   steht an beiden Stellen. */
.mf-dialog-knoepfe #frage-nein,
.mf-dialog-knoepfe #btn-scan-zu { order: 1; margin-right: auto; }
.mf-dialog-knoepfe #frage-ja,
.mf-dialog-knoepfe #btn-scan-code { order: 2; }

/* --- Die Griffe des Ausschnitts ------------------------------------------
   Das ⋯ ist auf JEDER Breite ein Menue - nicht mehr nur am Telefon. Es stand
   lange am breiten Schirm als offene Reihe da („drei Knoepfe, die dastehen,
   sind drei Knoepfe"), aber die Reihe ist auf bis zu acht Griffe gewachsen
   und brach auch in der Lesebreite von 900 px in eine zweite Zeile um. Und
   ihr Inhalt wechselt je Ausschnitt (Haken zuruecksetzen nur bei Haken, Von
   A bis Z nur an einer Sammlung, die roten nur mit Wahl) - dasselbe
   Argument, aus dem das Teilen darunter schon immer ueberall ein Menue war.
   Draussen bleiben die HANDLUNGEN der Ansicht (→ Einkauf, Auswaehlen,
   Teilen); die Pflege der Liste steht dahinter. */
/* Die Hoehenbremse (12.08.2026): Das Menue ist bis zu dreizehn Zeilen lang
   und haengt unter einer Kopfzeile, unter der auf einem kurzen Schirm keine
   dreizehn Zeilen mehr Platz haben. Seit der Inhalt nicht mehr als Ganzes
   scrollt (siehe #inhalt in grund.css), gaebe es dann keinen Weg mehr zu den
   letzten Zeilen - jetzt scrollt das Menue in sich selbst. */
#listen-griffe {
  display: none; position: absolute; top: calc(100% + 4px); right: 0;
  z-index: 25; flex-direction: column; align-items: stretch; gap: 4px;
  min-width: 200px; padding: 6px;
  max-height: calc(100vh - 160px); overflow-y: auto; overscroll-behavior: contain;
  border: 1px solid var(--border); border-radius: 8px;
  background: var(--flaeche); box-shadow: 0 8px 28px rgba(0, 0, 0, 0.22);
}
#kopfzeile.mehr-auf #listen-griffe { display: flex; }
/* Im Menue ist jeder Griff eine Zeile: gleich breit, links buendig, hoch genug
   fuer einen Finger - wie im Menue des Kopfes. */
#listen-griffe .btn { justify-content: flex-start; padding: 9px 12px; font-size: 13px; }

/* Und zwar IMMER untereinander (berichtigt am 13.08.2026, gemeldet am selben
   Tag: „im ⋯-Menue Eintraege nicht nebeneinander, sondern immer untereinander
   darstellen; ggf. scrollbar, wenn es ueber das Fenster hinausragt").
 *
 * Die Menuekaesten tragen die Klasse .btn-row, und die bringt flex-wrap: wrap
 * mit - richtig fuer eine Knopfreihe, die umbrechen soll. In einer SPALTE mit
 * begrenzter Hoehe bedeutet dasselbe wrap aber etwas ganz anderes: Passt der
 * Inhalt nicht in die Hoehe, bricht er in eine ZWEITE SPALTE um. Genau das
 * geschah im ⋯ mit seinen vierzehn Zeilen, sobald der Schirm niedrig war -
 * das Menue wurde doppelt so breit, die Zeilen standen nebeneinander, und die
 * Reihenfolge las sich quer statt von oben nach unten. Das overflow-y: auto
 * daneben kam nie zum Zug: Wer seitlich ausweicht, ueberschreitet die Hoehe
 * nicht.
 *
 * nowrap macht aus dem seitlichen Ausweichen wieder das, was gemeint war -
 * eine Spalte, die scrollt. Fuer alle drei Kaesten derselben Machart; das
 * Konto traegt heute nur zwei Zeilen, aber die Regel gilt dem Bauteil und
 * nicht seinem heutigen Inhalt. (#filter-griffe bleibt aussen vor: Dort
 * SOLLEN Marken nebeneinander stehen und umbrechen.) */
#listen-griffe, #konto-griffe, #teilen-griffe { flex-wrap: nowrap; }

/* Die Teilen-Gruppe steht als Absatz IM ⋯-Menue, auf jeder Breite
   (12.08.2026 - vorher am breiten Schirm ein eigenes Menue mit eigenem
   Oeffner, am Telefon per resize-Zuhoerer umgehaengt: zwei Aufbauten fuer
   dieselben Zeilen). Kein eigener Kasten: Sie gliedert sich wie die anderen
   Absaetze ueber ihre Zwischenueberschrift. */
#teilen-griffe {
  display: flex; flex-direction: column; align-items: stretch;
  gap: 4px; min-width: 0;
}
#teilen-griffe .btn { justify-content: flex-start; padding: 9px 12px; font-size: 13px; }

/* Die Hilfeleiste (#hilfe-panel) und ihre Gestaltung stehen in css/hilfe.css
   - gemeinsam mit der eigenen Seite hilfe.html, wie bei mapfit. */

/* --- Schmale Schirme -----------------------------------------------------
   tagwerk wird am Handy abgehakt, nicht nur am Schreibtisch gepflegt. Unter
   860 px legt sich die Spalte ueber den Inhalt statt neben ihn: Nebeneinander
   blieben fuer den Eintragstext 40 Prozent der Breite, und der Text ist der
   Grund, warum man hersieht. */
/* Der Kopf bleibt eine Zeile, auf jeder Breite. Er brach hier einmal um: Die
   Suche sprang auf eine zweite Reihe ueber die ganze Breite, und der Kopf war
   am Telefon doppelt so hoch wie noetig - fuer ein Feld, in das man dort selten
   tippt, waehrend Ruecknahme, Menue und Abhaken taeglich gebraucht werden.
   Stattdessen gibt die Suche als Einzige nach (sie hat als Einzige einen
   sinnvollen Kleinstwert), die Griffe daneben behalten ihre Groesse. */
@media (max-width: 1100px) {
  /* Zeilenabstand 0 wie in der Grundregel: Die zweite Zeile ist die
     Suchleiste, und die bringt ihren Abstand selbst mit. */
  header { gap: 0 12px; }
}

@media (max-width: 860px) {
  #spalte {
    position: absolute; z-index: 20; top: 0; bottom: 0; left: 0;
    width: min(280px, 84vw);
    box-shadow: 0 0 24px rgba(0, 0, 0, 0.28);
    /* Am Ende der Spalte soll nicht die Seite dahinter weiterscrollen - sonst
       wischt man in der Liste und die Arbeitsflaeche wandert mit. */
    overscroll-behavior: contain;
  }
  /* Auf dem Handy ist die Spalte voreingestellt zu - man kommt zum Abhaken,
     nicht zum Sortieren. Der Burger im Kopf holt sie. */
  main:not(.spalte-auf) #spalte { display: none; }
  /* Die Wahlzeilen der Spalte sind Ziele fuer den Finger und nicht fuer einen
     Zeiger von einem Pixel Spitze. */
  .wahl { padding: 9px 8px; font-size: 14px; }
  /* Unten nur noch Luft fuer den Einwurf, der dort jetzt steht - die 40 px
     waren der Auslauf einer Seite, die als Ganzes scrollte. */
  #inhalt { padding: 12px 12px 10px; }
  #eintraege { overscroll-behavior-y: contain; }
  /* Der Einteilungs-Layer am Telefon (Wunsch vom 12.08.2026): Er sass an der
     Kante des Kastens (left: 0 meint den Rand INNERHALB der Polsterung nicht
     mit) und klebte damit weiter links als der Einwurf darunter. Die
     Einrueckung stellt ihn in dieselbe Flucht.

     Und er bricht ordentlich um: Die Beschriftung nimmt ihre eigene Zeile,
     die Marken darunter stehen eingerueckt - so bleibt sichtbar, dass sie
     zu ihr gehoeren. Vorher hielt die feste Beschriftungsbreite von 68 px
     eine Spalte frei, und daneben blieben von einer Handybreite noch
     zweihundert Pixel fuer sechs Marken. */
  #einteilung { left: 12px; right: 12px; bottom: 10px; padding: 10px; }
  .einteilung-zeile { align-items: flex-start; gap: 6px; }
  .einteilung-zeile > .marken-be { flex: 0 0 100%; margin: 0; }
  .einteilung-zeile > .chip-gruppe,
  .einteilung-zeile > .einwurf-feld { flex-wrap: wrap; margin-left: 10px; }
  /* Der Haken bleibt rechts und in der letzten Zeile - auch wenn davor
     umgebrochen wurde. */
  #btn-einteilung-anlegen { align-self: flex-end; }
  /* Das Eingabefeld nahm hier die erste Zeile ALLEIN, und der Knopf stand mit
     den Kernfeldern der Art darunter - sonst brach das breite „Hinzufuegen"
     als Einzelstueck um und stand verloren da.
     Seit der Knopf ein ＋ ist (12.08.2026), teilt er sich die Zeile mit dem
     Titelfeld: Zusammen brauchen sie rund 280 px, das passt in jede
     Handybreite. Genau das war der Wunsch - der Knopf, den man drueckt, steht
     bei dem, was man getippt hat. Die Kernfelder fallen darunter. */
  .einwurf-text { flex: 1 1 200px; }
  #neu-liste { flex: 1 1 auto; max-width: none; }
  .abschnitt-felder { grid-template-columns: 1fr; }

  /* Alles, was man am Telefon trifft, wird groesser. (Die 16 px der Felder
     stehen am Ende dieser Datei: Sie gelten am Finger, nicht unter einer
     Breite.) */
  .chip { padding: 6px 11px; font-size: 13px; }
  .eintrag-zeile { gap: 7px; padding: 8px 6px 8px 5px; }
  .eintrag .haken { width: 22px; height: 22px; margin-top: 1px; }
  /* (Was die Zeile am Finger traegt und wie gross, steht unter hover: none.) */
  /* Der Ziehgriff ist am Finger die ganze Bedienung des Einteilens (siehe
     fingerZiehenVerdrahten in main.js) - 14px trifft niemand im Gehen. */
  .eintrag-griff { width: 22px; font-size: 16px; padding: 4px 0; }
  .ea-titel { font-size: 17px; }
  /* Die Groessen der Sammelgriffe stehen beim uebrigen Fingermass unter
     hover: none - sie haengen an der Zeigerart, nicht an der Breite. */

  /* Der Filterstreifen nahm am Telefon unverhaeltnismaessig viel Platz: sieben
     Marken zu je 13px Schrift und Fingerpolsterung brauchten drei Zeilen -
     ueber neunzig Pixel, bevor der erste Eintrag kam, auf einem Schirm, der
     davon rund sechshundert hat. Hier standen dagegen drei Notbehelfe: leere
     Marken fielen weg, die Beschriftung fiel weg, und der Rest wanderte
     seitlich aus dem Bild.

     Alle drei sind gegangen (12.08.2026): Es gibt keinen Streifen mehr. Die
     Filter liegen hinter dem Trichter neben dem ⋯ (siehe #filter-griffe),
     also genau dort, wo man sie holt, wenn man sie braucht - und nirgends,
     solange man sie nicht braucht. Am Finger werden ihre Marken groesser,
     das genuegt. */
  #filter-griffe .chip-zeichen { padding: 7px 10px; }

  /* Das ⋯-Menue steht auf jeder Breite und traegt das Teilen fest als
     Absatz (siehe die Grundregeln oben) - hier unten bleibt nur, was
     wirklich am schmalen Schirm haengt: die Leisten. */

  /* Die Auswahlleiste sitzt am Telefon fest am unteren Rand - dieselbe Stelle
     und Machart wie die Ablegeleiste, aus demselben Grund: Sammelhandlungen
     gehoeren in die Daumenzone. Im Fluss ueber den Eintraegen brach sie in
     drei Reihen um und schob die Liste, um die es geht, aus dem Bild; unten
     trifft man „Abhaken" und „Morgen" mit dem Daumen, ohne umzugreifen. */
  #auswahlleiste {
    position: fixed; z-index: 35; left: 0; right: 0; bottom: 0;
    margin: 0; border-radius: 12px 12px 0 0;
    border-left: 0; border-right: 0; border-bottom: 0;
    padding: 8px 10px calc(8px + env(safe-area-inset-bottom));
    box-shadow: 0 -6px 24px rgba(0, 0, 0, 0.18);
  }
  /* Waehrend eines Zuges gehoert der untere Rand der Ablegeleiste - zwei
     Leisten uebereinander, und man traefe die falsche. */
  body.zieht #auswahlleiste { display: none; }
  /* Die Leiste liegt ueber dem Inhalt und verdeckte sonst die letzten Zeilen -
     genau die, die man beim Aufraeumen von unten nach oben als Naechste
     waehlen will. Polsterung nur, solange die Leiste dasteht - und in ihrer
     gemessenen Hoehe (12.08.2026, siehe zeichneAuswahl in ansicht.js): Hier
     stand ein fester Wert von 230 px fuer eine Leiste, die je nach Art und
     Breite zwei bis vier Reihen hoch ist. Der Rueckfallwert gilt nur, bis
     einmal gemessen wurde. */
  #inhalt:has(#auswahlleiste:not([hidden])) {
    padding-bottom: calc(var(--auswahl-hoch, 230px) + 16px);
  }
  /* Und die Meldezeile steht UEBER der Leiste statt dahinter (12.08.2026).
     Sie sass auf festen 46 px - der Hoehe der Fusszeile, die es am Telefon
     gar nicht gibt - und verschwand damit hinter der Leiste. Ausgerechnet
     die Sammelaktionen bestaetigen sich ueber sie („12 Einträge auf morgen"),
     und wer die Bestaetigung nicht sieht, drueckt noch einmal. */
  body.waehlt #toast { bottom: calc(var(--auswahl-hoch, 130px) + 12px); }

  /* Am Telefon ist die Ablegeleiste das einzige Ziel fuers Einteilen: Die
     Spalte mit ihren Zeitraeumen liegt zugeklappt hinter dem Rand, und wer
     einen Eintrag in der Hand haelt, kann sie nicht auch noch aufholen.
     Deshalb nimmt sie hier die ganze Breite am unteren Rand und teilt sich in
     Felder, die man im Gehen trifft - drei nebeneinander, zwei Reihen. */
  #ablegeleiste {
    left: 0; right: 0; bottom: 0; transform: none;
    max-width: none; border-radius: 12px 12px 0 0;
    padding: 8px 10px calc(8px + env(safe-area-inset-bottom));
    gap: 6px;
  }
  /* Die Beschriftung nimmt eine eigene Zeile: Als siebtes Feld in der Reihe
     naehme sie einem Ziel den Platz weg. */
  #ablegeleiste .ablege-be { flex: 1 0 100%; }
  .ablege {
    flex: 1 1 28%; padding: 12px 8px; text-align: center;
    white-space: normal;
  }
  /* Die Kategorien rollen seitlich in EINER Zeile (siehe oben) - deshalb
     duerfen sie hier nicht die 28-Prozent-Breite der Zeitfelder erben und
     auch nicht umbrechen: Eine Leiste, die mit der Zahl der Kategorien in
     die Hoehe waechst, deckt beim Ziehen den halben Schirm zu. */
  .ablege-kategorien .ablege { flex: none; white-space: nowrap; }
  /* Die Meldezeile stuende sonst mitten in der Leiste. */
  body.zieht #toast { bottom: auto; top: 12px; }
  /* Auf einem Telefon mit runden Ecken liegt der Rand der Fusszeile sonst unter
     der Bedienleiste des Systems. */
  footer { padding: 10px 16px calc(10px + env(safe-area-inset-bottom)); }
}

/* --- Die Einstellungen des Kopfes hinter dem Zahnrad ---------------------
   Auf JEDER Breite ein Menue (geaendert am 12.08.2026, Wunsch vom selben
   Tag). Vorher standen Schutz, Importieren, Erinnerungen, Hell/Dunkel,
   Drucken, Profil, Kennung und Abmelden offen in der Reihe und fuhren erst
   unter 1100 px zusammen - denn zusammen brauchen sie gut 700 Pixel, und
   darunter ueberschnitten sich Suchfeld und Knoepfe.

   Die Grenze war richtig gerechnet und trotzdem die falsche Frage: Acht
   Knoepfe nebeneinander sind auch bei 1400 px keine Bedienung, sondern eine
   Aufzaehlung - keiner davon wird taeglich gebraucht, und man liest sie jedes
   Mal mit. Hinter einem Zahnrad sind sie das, was sie sind: Einstellungen.
   Denselben Weg ist das ⋯ der Kopfzeile schon gegangen.

   Das Menue haengt unter dem Kopf und nicht im Fluss der Zeile - sonst
   schoebe es beim Aufklappen die halbe Anwendung nach unten. Bezug ist der
   Kopf selbst (position: relative in grund.css). */
/* Jedes Kopfmenue haengt unter SEINEM Knopf und nicht am rechten Rand des
   Kopfes (Wunsch vom 12.08.2026): Wer auf das Zahnrad drueckt, sucht sein
   Menue darunter - drei Menues, die alle rechts aufgingen, liessen einen
   jedes Mal pruefen, welches man erwischt hat. Dafuer steht jeder Knopf
   samt Menue in einer eigenen Huelle mit position: relative.

   Das Konto-Menue haengt als einziges an der RECHTEN Kante seiner Huelle:
   Sein Knopf ist der letzte im Kopf, und nach links geoeffnet stuende das
   Menue sonst zur Haelfte ausserhalb des Fensters. */
.kopf-menue { position: relative; display: inline-flex; }
#kopf-konto { position: relative; }
#kopf-werkzeuge {
  display: none; position: absolute; top: calc(100% + 4px); left: 0;
  z-index: 25; flex-direction: column; align-items: stretch; gap: 4px;
  min-width: 210px; padding: 4px;
  max-height: 70vh; overflow-y: auto; overscroll-behavior: contain;
  border: 1px solid var(--tinte-linie); border-radius: 8px;
  background: var(--tinte-hoch); box-shadow: 0 8px 28px rgba(0, 0, 0, 0.45);
}
/* Das zweite Kopfmenue - Konto (12.08.2026): derselbe Kasten, nur
   schmaler; es traegt zwei Zeilen und keine zehn. */
#konto-griffe {
  display: none; position: absolute; top: calc(100% + 4px); left: 0;
  z-index: 25; flex-direction: column; align-items: stretch; gap: 4px;
  min-width: 170px; padding: 4px; max-height: 70vh; overflow-y: auto;
  border: 1px solid var(--tinte-linie); border-radius: 8px;
  background: var(--tinte-hoch); box-shadow: 0 8px 28px rgba(0, 0, 0, 0.45);
}
#konto-griffe .btn, header #konto-griffe .btn {
  width: auto; height: auto; justify-content: flex-start;
  padding: 9px 12px; line-height: 1.2;
}
/* ALLE Kopfmenues oeffnen nach links, an der rechten Kante ihres Knopfes
   (berichtigt am 12.08.2026): Die Knoepfe stehen rechts im Kopf, und ein
   Menue, das von dort nach rechts aufgeht, laeuft aus dem Bild - am Telefon
   sofort, am Schreibtisch beim naechsten Eintrag im Menue. Nach links ist
   Platz, denn links davon liegt der ganze Kopf.

   „Direkt unterhalb seines Knopfes" bleibt es trotzdem: Die Huelle um Knopf
   und Menue traegt position: relative, das Menue haengt an IHR - nur eben an
   ihrer rechten statt ihrer linken Kante. */
#kopf-werkzeuge, #konto-griffe {
  left: auto; right: 0; max-width: calc(100vw - 16px);
}
header.menue-auf #kopf-werkzeuge,
header.konto-auf #konto-griffe { display: flex; }
/* Im Menue ist jeder Griff eine Zeile: gleich breit, links buendig, hoch
   genug fuer einen Finger. */
/* Die Zeilen im Menue tragen den Familienstil des Gestaltungssystems
   (.menue-eintrag in design-system/dist/basis.css, Wunsch vom 12.08.2026):
   flaechig durchsichtig, links buendig, und beim Ueberfahren leuchtet der
   RAHMEN auf statt der Fuellung. Hier standen gewoehnliche Knoepfe mit
   Rahmen und Fuellung untereinander - zehn Kaesten in einem Kasten, und
   jeder sah aus, als koenne man ihn einzeln anfassen.

   Gruen statt Blau: Der Akzent dieser Familie ist das Markengruen; Blau
   gehoert im Gestaltungssystem den Verweisen. */
#kopf-werkzeuge .btn, #konto-griffe .btn,
header #kopf-werkzeuge .btn:not(.btn-icon),
header #konto-griffe .btn:not(.btn-icon) {
  width: auto; height: auto; justify-content: flex-start;
  padding: 6px 9px; line-height: 1.3; border-radius: 6px;
  border: 1px solid transparent; background: none;
}
#kopf-werkzeuge .btn:hover:not(:disabled),
#konto-griffe .btn:hover:not(:disabled) {
  background: none; border-color: var(--gruen);
}
/* Ein Zeichen in einer Menuezeile steht an ihrem ENDE (18.09.2026, wie
   seitenblick; site/telefon.html): Alle Woerter beginnen auf einer Flucht,
   die Zeichen stehen am rechten Rand untereinander. */
#kopf-werkzeuge .zeilen-zeichen { margin-left: auto; padding-left: 12px; }
/* Die Zwischenueberschriften auf der dunklen Tinte des Kopfes: Die Grundregel
   (.menue-be) ist fuer die helle Arbeitsflaeche gemacht und stuende hier fast
   unsichtbar da. */
#kopf-werkzeuge .menue-be { color: var(--tinte-leise); border-top-color: var(--tinte-linie); }
#kopf-werkzeuge > .menue-be:first-child { border-top: 0; margin-top: 0; padding-top: 2px; }

/* Das Zahnrad ohne Wort (12.08.2026): Das Zeichen IST der Name - wie bei
   Lupe und ? daneben, auf jeder Breite. */
#btn-mehr { font-size: 15px; line-height: 1; }

/* Die Hilfe hat ZWEI Griffe, und immer nur einer davon steht da (13.08.2026,
   siehe #btn-hilfe-menue in index.html): am breiten Schirm das ? im Kopf, am
   Telefon eine Zeile im Zahnrad-Menue. Kein doppelter Aufbau - beide haengen
   an demselben setzen() in hilfeVerdrahten.

   Ueber die BREITE geschaltet und nicht ueber die Zeigerart: Es geht um
   Platz in einer Zeile, nicht um Finger, die zielen. Und ueber display statt
   ueber das hidden-Attribut, weil sonst zwei Stellen dasselbe entscheiden
   muessten - die Breite kennt nur das Stylesheet. */
#btn-hilfe-menue { display: none; }

/* Die Griffe im Kopf - Einstellungen und Konto - sind gleich gebaut:
   gezeichnetes Zeichen, daneben das Wort, solange Platz ist. Die Zeichnung
   steht hier EINMAL fuer alle; ohne diese Regel hatten die SVG darin weder
   Groesse noch Strich und blieben unsichtbar (Fehler vom 12.08.2026).
   Gezeichnet und nicht getippt, weil ⚙ und ☰ als Schriftzeichen auf manchen
   Systemen farbige Emoji sind. */
.kopf-griff { display: inline-flex; align-items: center; gap: 7px; }
/* Gezeichnete Sinnbilder in Knoepfen - WORTGLEICH uebernommen aus
   design-system/dist/basis.css (.btn > svg). Dort steht auch das Warum: Ein
   <svg> ohne Masse ist 300x150 gross, und currentColor haelt das Zeichen in
   der Farbe der Schrift daneben.

   Hier stand eine eigene Fassung mit 15 px und Strichstaerke 1,5 - mapfit
   bekam beim selben Umbau 16 px, und dieselben Knoepfe sahen in den beiden
   Werkzeugen verschieden aus (12.08.2026). Genau dagegen gibt es das
   Gestaltungssystem; wer die Werte aendern will, aendert sie DORT. */
.btn > svg {
  width: 16px; height: 16px; flex: none;
  fill: none; stroke: currentColor; stroke-width: 1.6;
  stroke-linecap: round; stroke-linejoin: round;
}
/* Trichter und die drei Punkte sind Flaechen und keine Umrisse - als Linie
   waere der Trichter in 16 Pixeln ein Dreieck mit einem Strich daran, und
   ein Punkt mit Strichstaerke 1,6 waere ein Ring. */
#btn-filter > svg, #btn-listenmehr > svg { fill: currentColor; stroke: none; }
#btn-nutzer { max-width: 200px; }
#btn-nutzer .kennung {
  min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
  margin: 0;
}

/* Der Kopf auf einem schmalen Telefon: Marke, Titel, die zwei Verlaufsgriffe
   und die vier Griffe rechts (Suche, Einstellungen, Hilfe, Konto) muessen in
   eine Zeile von 360 Pixeln - dafuer geben unten die Woerter neben den
   Zeichen nach, waehrend Rueckgaengig, Suche und das Abhaken zur taeglichen
   Arbeit gehoeren und stehen bleiben. */
@media (max-width: 600px) {
  /* Zwei Felder wie am breiten Schirm: links Zeichen, Titel, Ruecknahme und
     Wiederholen, rechts die Griffe der Anwendung.

     Hier standen DREI Spalten (auto minmax(0,1fr) auto), und das war ein
     Rest aus der Zeit, als die Suche ein breites FELD in der Mitte des
     Kopfes war - ein eigenes drittes Kind (berichtigt am 13.08.2026,
     gemeldet am selben Tag: „zurueck und vor ueberlappen sich am Smartphone
     mit anderen Funktionen").

     Seit dem 12.08.2026 ist die Suche eine Lupe in der rechten Gruppe, und
     der Kopf hat wieder zwei Kinder. Die fielen damit in die Spalten 1 und
     2 - also die LINKE in "auto" und die RECHTE in "minmax(0, 1fr)", genau
     verkehrt herum, waehrend die dritte Spalte leer mitlief. Die Folge sieht
     man erst auf einer Handbreite: Die rechte Gruppe traegt lauter
     Zeichenknoepfe zu 36 px, die nicht schrumpfen (flex: none, nowrap) -
     ihre Spalte darf aber bis auf null zusammengehen. Also lief ihr Inhalt
     ueber die Spur hinaus, und weil sie am Ende ausgerichtet ist, nach
     LINKS: mitten in ↶ und ↷, die dort als letzte der linken Gruppe stehen.

     Richtig herum ist es umgekehrt: Die flexible Spur gehoert der Seite mit
     dem Titel - er ist das Einzige im Kopf, das nachgeben darf und kann
     (siehe #ansicht-titel: er kuerzt sich mit „…") -, die feste Spur den
     Knoepfen, die es nicht koennen. Es ist also dieselbe Aufteilung wie am
     breiten Schirm, und die Zeile darf hier ganz entfallen.

     Was am Telefon nachgibt, gibt weiterhin unten nach: das Wort „Tagwerk"
     neben dem Zeichen - die Marke steht im Zeichen, und man weiss, welche
     Anwendung man geoeffnet hat -, und die Kennung, die mit dem Abmelden ins
     Menue wandert. */
  header { padding: 8px 10px; gap: 0 8px; }
  header .kopf-links { flex-wrap: nowrap; gap: 6px; }
  header .kopf-rechts { flex-wrap: nowrap; gap: 6px; }
  /* Und die rechte Gruppe schrumpft nicht: Drei Zeichenknoepfe zu 36 px sind
     das Mass, unter das der Kopf nicht geht - was fehlt, nimmt sich der
     Titel daneben. Ein Rasterkind darf naemlich von sich aus unter seinen
     Inhalt schrumpfen; diese Zeile verbietet es ihm. (Dass seine KINDER
     nicht schrumpfen, steht in grund.css - das ist eine andere Frage und die
     zweite Haelfte derselben Regel: Im Kopf gibt nur der Titel nach.) */
  header .kopf-rechts { min-width: max-content; }
  #suchleiste { margin: 8px -10px -8px; padding: 8px 12px; }
  /* Der beschreibende Streifen ueber der Liste BRICHT am Telefon um, statt
     seitlich wegzuscrollen (13.08.2026, Wunsch vom selben Tag zu den
     Fixkosten).

     Er scrollt bei Platzmangel waagerecht, und zwar ohne sichtbare Leiste -
     am Zeiger geht das, dort schiebt man ihn mit dem Rad oder greift ihn.
     Am Telefon ist ein lautlos abgeschnittener Streifen dagegen einfach ein
     Streifen, von dem man den Rest nicht kennt: Bei einer Fixkostenliste war
     ab „Im Monat" nichts mehr zu sehen, und das ist die Zahl, wegen der man
     die Liste aufmacht. Umgebrochen steht alles da, und die Griffe rechts
     bleiben, wo sie sind (.kopf-haupt bricht weiterhin nicht um).

     Die Geldantwort bekommt dabei eine eigene Zeile: Sie ist die Auskunft,
     kein Beiwerk - und zwischen Zaehler und Ausschnittmarken gequetscht
     laese man sie als eine Angabe unter vielen. */
  .kopf-neben { flex-wrap: wrap; overflow-x: visible; }
  #kopfzeile .geldzeile { flex: 1 0 100%; }
  /* Schmaler am Telefon: Das ⋯-Menue traegt bis zu vierzehn Zeilen und war
     mit seiner Mindestbreite auf einem 360er Schirm dicht am Rand. Die
     Zeilen brechen notfalls um - lieber zweizeilig als abgeschnitten. */
  #kopf-werkzeuge, #konto-griffe,
  #filter-griffe, #listen-griffe { min-width: 0; max-width: calc(100vw - 12px); }
  /* Das ? weicht ins Zahnrad-Menue (Wunsch vom 13.08.2026, siehe
     #btn-hilfe-menue oben): Vier Zeichenknoepfe rechts, Burger und
     Markenzeichen links, dazu ↶ und ↷ - sieben fingergrosse Ziele auf
     360 px, und fuer den Namen der Liste blieben zwoelf Pixel. Die Hilfe ist
     unter den vieren die einzige, die man nicht bei der Arbeit braucht; man
     liest sie einmal nach. Damit gilt fuer sie dieselbe Regel, die die
     Update-Pruefung ins Menue gebracht hat.

     Der Titel bekommt die 42 px und wird damit ueberhaupt erst lesbar - er
     ist die Antwort auf „wo bin ich", und die stand am Telefon als „A…" da. */
  #btn-hilfe { display: none; }
  /* display: FLEX und nicht block (berichtigt am 13.08.2026: „warum ist
     Hilfe … mittig und alle anderen Menuepunkte links?"). Ein .btn ist ein
     inline-flex-Kasten, und die Menuezeilen richten ihren Inhalt ueber
     justify-content: flex-start aus. `display: block` nahm ihm den
     Flex-Zusammenhang - damit lief die Ausrichtung ins Leere, und der Text
     sass wieder mittig, wie in einem gewoehnlichen Knopf. */
  #btn-hilfe-menue { display: flex; }
  /* Am Telefon tragen die Kopfgriffe nur ihr Zeichen (Wunsch vom
     12.08.2026): Einstellungen und das Profil. Bisher fiel nur das Wort der
     Einstellungen weg, und die Reihe war trotzdem zu breit - Woerter neben
     Burger, Marke und Titel gehen auf keiner Handbreite auf. */
  .kopf-griff .knopf-breit { display: none; }
  .kopf-griff { padding: 0 6px; justify-content: center; }
  header .brand > span { display: none; }
  /* Dieselbe Regel fuer die Speichermarke (27.08.2026): Das Zeichen bleibt,
     das Wort geht. „Gespeichert 14:32" kostet hier gut hundert Pixel - so
     viel, wie dem Namen der Liste insgesamt bleibt. Der Haken allein sagt
     weiter, DASS gespeichert ist; WANN steht im Tooltip der Marke, und der
     traegt den ganzen Satz - deshalb steht die Uhrzeit dort und nicht nur
     im Wort (siehe speichermarkeZeigen in main.js). Weg ist die Marke damit
     nicht: Verstecken naehme die Auskunft, Kuerzen laesst sie stehen. */
  header .stand-marke { min-width: 0; }
  header .stand-marke .stand-wort { display: none; }
  /* Wer angemeldet ist, steht dann nicht mehr im Kopf - der Name kostete auf
     einer Handbreite so viel wie zwei Griffe. Er steht im Tooltip und als
     erste Zeile im Menue dahinter, das man ohnehin oeffnet, um ihn zu
     aendern oder sich abzumelden. */
  /* Und er ist dort ein Zeichenknopf wie Lupe und Zahnrad daneben - also
     genauso breit (berichtigt am 13.08.2026: "warum ist das Profil-Icon
     breiter als die anderen Icon-Buttons?").

     Die Ursache steht in der Klassenliste: #btn-nutzer traegt `btn
     kopf-griff`, seine Nachbarn `btn btn-icon`. Nur die zweite Klasse holt
     das Quadrat (header .btn-icon), und so behielt der Profil-Griff die
     Polsterung eines beschrifteten Knopfes, obwohl sein Wort hier weg ist -
     er sah aus wie ein Zeichenknopf und mass wie ein Wortknopf.

     Die Klasse einfach zu ergaenzen ginge nicht: Ueber 600 px traegt er die
     Kennung, und ein Quadrat von 26 px koennte sie nicht zeigen. Das Mass
     gilt deshalb genau dort, wo auch das Wort faellt. */
  #btn-nutzer {
    max-width: none; width: 26px; height: 26px;
    padding: 0; justify-content: center;
  }

  /* Die Fusszeile faellt weg. Sie traegt Marke, Fassung und die Rechtstexte -
     lauter Auskuenfte, die man einmal sucht und nicht taeglich liest. Auf
     einem Telefon kostete sie dafuer eine ganze Zeile Bildschirmhoehe, jede
     Sekunde, in der man abhakt. Die Update-Pruefung wohnt deshalb nicht mehr
     hier, sondern im Einstellungsmenue (12.08.2026). Nicht ueber die
     Zeigerart gebunden, sondern ueber die Breite: Es geht um Hoehe, die
     fehlt, nicht um Finger, die zielen. */
  footer { display: none; }

}

/* Am Finger waechst der Profil-Griff wie jeder Zeichenknopf mit (36 px, siehe
   .btn-icon weiter unten) - aber nur dort, wo er ueberhaupt einer ist: Ein
   Tablet in Querlage hat keinen Zeiger UND genug Platz fuer die Kennung. */
@media (max-width: 600px) and (hover: none) {
  #btn-nutzer { width: 36px; height: 36px; }
}
/* Und der Trichter am Finger ebenso hoch wie das ⋯ daneben. */
@media (hover: none) {
  #kopfzeile #btn-filter { height: 36px; padding: 0 9px; }
}

/* Am Finger gibt es kein Ueberfahren. Was nur beim Ueberfahren erscheint, ist
   dort nicht bloss unsichtbar, sondern unerreichbar - das Loeschen einer Zeile,
   das Anfangen, das Wegwerfen einer gemerkten Ansicht oder eines Unterpunkts.
   Gebunden an die Zeigerart und nicht an die Breite: Ein Tablet in Querlage ist
   breit und hat trotzdem keinen Zeiger. */
@media (hover: none) {
  /* ALLES in einer Knopfreihe ist am Finger gleich hoch - auch die reinen
     Zeichenknoepfe (berichtigt am 12.08.2026, gemeldet am selben Tag: „die
     Icons im Header sind am Smartphone alle kleiner").

     Die Frage ist zweimal falsch beantwortet worden, und beide Male
     andersherum: Erst waren die Zeichenknoepfe 36 px und die beschrifteten
     24 - „sichtbar, aber nicht treffbar" (so steht es in site/telefon.html). Dann
     wuchsen die beschrifteten auf 36 und die Zeichenknoepfe gingen auf ihre
     26 zurueck, mit dem Argument, ein 36er Ziel sei ohnehin kleiner als die
     44, die als Fingermass gelten. Das Argument stimmt und trifft die Sache
     nicht: 36 ist deutlich besser als 26, und der eigentliche Fehler war nie
     die absolute Groesse, sondern der VERSATZ. Eine Reihe, in der ein Knopf
     zehn Pixel kleiner ist als sein Nachbar, sieht kaputt aus und laesst
     einen danebenzielen - gleich, welcher der beiden der kleinere ist.

     Also: eine Hoehe fuer alle. Das Zeichen darin waechst mit, sonst sitzt
     ein 16er Sinnbild verloren in einem 36er Kasten. Am Zeiger bleibt alles,
     wie es war - dort trifft man auch 26 px. */
  .btn-icon, header .btn-icon, .btn-icon.btn-tight { width: 36px; height: 36px; }
  .btn > svg { width: 18px; height: 18px; }
  /* Die BESCHRIFTETEN Knoepfe der Kopfzeile („Sammelbearbeitung", „→ Einkauf")
     blieben als btn-tight bei 24 px stehen - die einzigen Ziele der Seite
     unter dem Fingermass, und sie sassen versetzt neben dem ⋯ daneben.
     Dieselben 9px/12px wie die Menuezeilen, damit alles in einer Flucht
     steht. Die Regel trifft auch die Zeilen der beiden Menues - dort stehen
     dieselben Werte schon, es aendert sich nichts. */
  #kopfzeile .btn:not(.btn-icon) { padding: 9px 12px; font-size: 13px; }
  /* Die Sammelgriffe der Auswahlleiste sind am Telefon der schnellste Weg,
     ein Wochenende aufzuraeumen - Marken wie Knoepfe fingergross, denn beide
     fassen hier mehrere Zeilen auf einmal an. */
  #auswahlleiste .btn, #auswahlleiste .chip { padding: 9px 12px; font-size: 13px; }
  /* Dieselbe Regel fuer die Griffe vom 10.08.2026 - die Telefon-Schicht des
     Gestaltungssystems gilt fuer JEDE Knopfreihe, nicht nur die Kopfzeile:
     die Zeilen des Papierkorbs, die Anhaenge in der Einzelansicht, die
     Knoepfe unten in der Spalte und die beiden im Schnelleinwurf (der
     kleinere "Ausfuehrlich" waechst am Finger mit - klein heisst am Zeiger
     leiser, nicht am Finger unerreichbar). */
  /* Und die DETAILSEITE (13.08.2026, gemeldet am selben Tag). Sie stand als
     einzige nicht in dieser Aufzaehlung - ihre Knoepfe und Marken blieben
     damit am Telefon auf Schreibtischmass: der Rueckweg, "Liste …",
     "Loeschen", die Stufen der Dauer, die Schalter fuer Rang und Stand, die
     Schlummer-Marken. Also genau die Flaeche, auf der man am Telefon
     arbeitet, wenn man einen Eintrag aufgeschlagen hat.

     Dass es auffiel, liegt an der Form der Regel: Sie zaehlt Orte auf, statt
     einmal zu sagen, was gilt. Jeder neue Ort mit Knoepfen muss hier
     nachgetragen werden, und einer wird immer vergessen. Das bleibt eine
     Falle - hier steht nur der fehlende Ort, nicht ihre Aufloesung. */
  .mf-dialog .btn, .anhaenge .btn, #spalte .btn,
  #schnell .btn, #eintragsansicht .btn:not(.btn-icon),
  #eintragsansicht .chip { padding: 9px 12px; font-size: 13px; }
  header #btn-rueckgaengig, header #btn-wiederholen { font-size: 19px; }
  header .header-group .btn:not(.btn-icon) { height: 36px; padding: 0 12px; line-height: 34px; }
  header .btn-sm { padding: 8px 12px; }

  .punkt-weg { opacity: 1; }
  /* Die Zeile traegt am Finger drei Dinge: Haekchen, Text und den Weg in den
     Eintrag. ▶, × und der Haken an Ueberfaelligem stehen dort nicht: Als
     Ziele zu 24 px lagen sie dicht nebeneinander (Loeschen neben Oeffnen)
     und nahmen dem Text ein Drittel der Zeile. Alle drei gibt es im
     geoeffneten Eintrag (Status, „Angehen am", Loeschen) und fuer mehrere
     zugleich in der Sammelleiste, die ein langer Druck auf die Zeile holt;
     aufs Einteilen wartet ausserdem die Ablegeleiste.

     Der Chevron ist dafuer das Ziel, das man ansteuert: 44 px breit und so
     hoch wie die Zeile. Die negativen Raender holen ihn an ihre Kanten - die
     Polsterung der Zeile gehoert damit zum Ziel und nicht zum Rand. */
  .eintrag-zeile { padding: 8px 6px 8px 5px; }
  .eintrag-arbeit, .eintrag-weg, .eintrag-heute { display: none; }
  .eintrag-oeffnen {
    opacity: 1; align-self: stretch; width: 44px; height: auto; min-height: 44px;
    margin: -8px -6px -8px 0; border-radius: 0; font-size: 24px;
  }
  .eintrag .haken { width: 26px; height: 26px; margin-top: -1px; }
  /* Das ⋯ einer Zeile (Vertraege) und das am Eintrag: ein Zeichenknopf wie
     jeder andere, also dessen Fingermass. */
  .eintrag-mehr { width: 36px; height: 36px; }
  .eintrag-mehr > svg { width: 18px; height: 18px; }
  .eintrag-griff { color: var(--muted); }
  /* Ein Doppeltipp oeffnet den Eintrag (siehe eintraegeVerdrahten in main.js).
     Ohne diese Zeile wartet der Browser darauf, ob daraus ein Heranzoomen wird,
     und schickt den Doppelklick eine Drittelsekunde spaeter - oder gar nicht.
     Der Ziehgriff behaelt sein eigenes touch-action: none aus listen.css; die
     Eigenschaft vererbt sich nicht, das Ziehen bleibt also unberuehrt.

     manipulation und nicht none: Die Liste muss scrollen koennen. Dass ein
     angehobener Eintrag die Seite trotzdem nicht mitzieht, besorgt main.js -
     hier ginge es nicht, weil der Browser touch-action beim Aufsetzen des
     Fingers festlegt und die Zeile bis zum Anheben scrollbar bleiben muss. */
  .eintrag-zeile { touch-action: manipulation; -webkit-touch-callout: none; }

  /* Dieselbe Regel fuer die Griffe IN den Zeilen - sichtbar gemacht waren sie
     (siehe oben), aber nicht fingergross. Ausgerechnet die drei, bei denen es
     am meisten zaehlt: − und ＋ im Vorrat sind dort die Handlung des Tages
     und blieben mit 26 px die kleinsten dauerhaften Ziele der Liste; die
     Vertragswoerter (Gekuendigt, Verlaengert) sind die folgenreichsten
     Handlungen der ganzen Oberflaeche und standen 22 px hoch genau dort, wo
     der Daumen beim Rollen aufsetzt; die Loeschgriffe der Ansichten und
     Unterpunkte waren mit 22 px kaum zu treffen - und ein danebengesetzter
     Finger trifft die Zeile und oeffnet etwas anderes. */
  /* Die WORTknoepfe wachsen weiter - dort geht es um Lesbarkeit. Die reinen
     Zeichen (− ＋ am Vorrat, die Loeschkreuze) behalten ihre Groesse, siehe
     oben. */
  .eintrag-frist, .punkt-aufgabe { padding: 8px 12px; font-size: 13px; }
}


/* ================= Anmeldeseite ================= */
/* Nur login.html traegt <body class="anmeldung">. Alles hier ist daran
   gebunden, und das ist keine Zierde:
   - `main` traegt in grund.css die Anwendungshuelle (display:flex, links die
     Spalte, rechts das Blatt). Die Anmeldeseite benutzt dasselbe Element,
     hat aber weder Spalte noch Blatt. Ohne diese Ueberschreibung stuenden
     Ueberschrift, Fehlerzeile und Formular NEBENEINANDER.
   - `label` erzeugt die Anwendung selbst (ansicht.js, dialog.js). Eine globale
     Regel dafuer wuerde jeden Dialog verstellen.

   Die Werte sind dieselben wie in seitenblicks bedienung.css - dort brauchen sie
   keine Bindung, weil die ganze Oberflaeche aus Karten und Formularen besteht.
   Beide Werkzeuge sollen sich beim Anmelden gleich anfuehlen, und dazu muessen
   es dieselben Zahlen sein. */

body.anmeldung main {
  display: block;
  flex: 1; min-height: 0; overflow-y: auto;
  padding: 24px 24px 40px;
}

body.anmeldung .card {
  max-width: 380px; margin: 60px auto;
  background: var(--flaeche); border: 1px solid var(--border);
  border-radius: 8px; padding: 20px;
  accent-color: var(--gruen-tief);
}

body.anmeldung h1 { font-size: 22px; margin: 0 0 16px; }

body.anmeldung label { display: block; font-weight: 600; margin: 14px 0 4px; font-size: 14px; }

body.anmeldung input[type="text"],
body.anmeldung input[type="password"] {
  width: 100%; padding: 7px 10px; border: 1px solid var(--border-feld);
  border-radius: 6px; font-size: 14px; font-family: inherit;
  background: var(--flaeche); color: var(--text);
}

body.anmeldung .muted { color: var(--muted); font-size: 13px; }

/* Der Konto-Block unter der Maske - abgesetzt durch eine Linie: Er ist der
   zweite Weg auf derselben Karte, nicht Teil der Anmeldung darueber. Er
   erscheint nur mit gueltiger Einladung (siehe anmeldung.js). */
body.anmeldung #einladung-block { margin-top: 22px; padding-top: 16px;
                                  border-top: 1px solid var(--border); }
body.anmeldung .konto-titel { font-size: 17px; margin: 0 0 4px; }

/* Dieselbe Sprache wie die Meldungen der Anwendung: roter Rahmen, roter Grund,
   bleibt stehen bis zum naechsten Versuch. */
body.anmeldung .flash { padding: 10px 14px; border-radius: 6px; margin-bottom: 14px; font-size: 14px; }
body.anmeldung .flash-error { background: light-dark(#ffebe9, #3a1d1c); border: 1px solid light-dark(#ffc1bc, #6b2f2a); color: light-dark(#86121b, #ffb3ab); }

/* Der Anmeldename fiel hier unter 380 px als Letzter weg. Seit dem
   12.08.2026 gehen alle drei Woerter schon bei 600 px zusammen (siehe dort) -
   ein eigener Sonderfall fuer den Namen ist damit hinfaellig. */

/* --- Das Kreuz zum Leeren ------------------------------------------------
   Wunsch vom 12.08.2026: Jedes Feld, das einen Wert traegt, bietet rechts
   darin ein x an, das ihn wegnimmt. Warum als Hintergrundbild und nicht als
   Knopf, steht in leerkreuz.js - kurz: ein Knopf braucht eine Huelle um das
   Feld, und fast jedes Feld dieser Anwendung ist ein Flex-Kind mit eigener
   Breitenregel, die eine Huelle nicht erbt.

   Die Klasse steht ZWEIMAL im Waehler. Das ist kein Versehen: Ohne die
   Verdopplung waere die Regel schwaecher als `.mf-dialog .mf-dialog-feld
   input`, und in genau den Dialogen - wo die meisten Felder stehen - bliebe
   der Innenabstand aus und das Kreuz laege auf dem Text. Mit ihr wiegen beide
   gleich schwer, und diese Datei laedt spaeter. */
input.hat-x.hat-x {
  padding-right: 26px;
  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M4.6 4.6l6.8 6.8M11.4 4.6l-6.8 6.8' stroke='%23888' stroke-width='1.5' stroke-linecap='round'/%3E%3C/svg%3E");
  background-repeat: no-repeat;
  background-position: right 7px center;
  background-size: 12px 12px;
}

/* Datum, Uhrzeit und Zahl zeichnet der Browser rechts selbst an: Kalender,
   Uhr, Pfeilchen. Das Kreuz rueckt davor, der rechte Streifen bleibt seiner.
   Die 24 px sind dieselben wie EIGEN in leerkreuz.js. */
input.hat-x.hat-x[type="number"], input.hat-x.hat-x[type="date"],
input.hat-x.hat-x[type="time"], input.hat-x.hat-x[type="datetime-local"],
input.hat-x.hat-x[type="month"], input.hat-x.hat-x[type="week"] {
  padding-right: 50px; background-position: right 31px center;
}
/* Datum und Uhrzeit geben ihren Text nicht her (12.08.2026): Der Browser
   bemisst diese Felder selbst und rechnet die 50 px des Kreuzes nicht
   ueberall ein - am Telefon war bei der Anlage das Jahr abgeschnitten,
   obwohl der Kasten breit genug AUSSAH. Die Mindestbreite haelt den Platz
   fuer Wert, Browsergriff und Kreuz frei; ch waechst mit der Schrift
   (16 px am Telefon) mit. */
/* Die Mindestbreite gilt IMMER und nicht erst mit einem Wert (13.08.2026).

   Zwei Berichtigungen an derselben Zeile, an einem Tag:

     1. Die Zugabe war zu klein („wähle Übermorgen, das Datum wird
        abgeschnitten, obwohl massig Platz wäre"). Sie muss DREIERLEI tragen,
        gerechnet war zweierlei: den linken Innenabstand (8), den rechten für
        das Kreuz (50) - und den Griff, den der BROWSER selbst in das Feld
        zeichnet. Dessen Kalendersymbol steht innerhalb des Inhaltskastens und
        nimmt gut zwanzig Pixel. Der Kasten sah dabei breit genug aus, weil
        die fehlende Breite nicht am Feld fehlte, sondern in ihm.

     2. Sie hing an `.hat-x` - der Klasse, die leerkreuz.js setzt, sobald
        etwas im Feld steht („auch ein Feld, das noch kein Datum oder Uhrzeit
        gewählt hat, soll schon die korrekte Größe haben"). Ein leeres Feld
        war damit schmaler und sprang in dem Augenblick auf, in dem man einen
        Tag wählte - und zwar unter der Hand, während man noch im Kalender
        stand. Ein Feld hat die Größe seines INHALTS, und der ist bei einem
        Datumsfeld immer derselbe: TT.MM.JJJJ. Der Browser zeigt genau das
        auch im leeren Zustand an (bei der Uhrzeit „--:--"), es passte nur
        nicht hinein.

   Der INNENABSTAND bleibt an .hat-x: Die fünfzig Pixel sind für das Kreuz,
   und das gibt es nur mit Wert. Leer hat das Feld damit etwas mehr Luft für
   denselben Text - springen tut nichts, weil die Außenmaße dieselben sind. */
input[type="date"] { min-width: calc(10ch + 80px); }
input[type="time"] { min-width: calc(5ch + 80px); }
input[type="datetime-local"] { min-width: calc(16ch + 80px); }

/* Der Zeiger sagt, dass da etwas zu druecken ist (nur mit Maus, siehe
   leerkreuz.js). Ohne ihn sieht das Kreuz aus wie eine Zeichnung. */
input.ueber-x { cursor: pointer; }

/* Zwei Felder tragen ihre Masse an einer Kennung und wiegen damit schwerer
   als jede Klasse - sie muessen es hier einzeln nachziehen. Die Suche traegt
   ausserdem links schon die Lupe: Sie steht als eigene Angabe am Feld, damit
   beide Bilder nebeneinander liegen koennen, statt dass eines das andere
   ueberschreibt. */
#suche { --lupe: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Ccircle cx='7' cy='7' r='4.2' fill='none' stroke='%236f8069' stroke-width='1.6'/%3E%3Cpath d='M10.2 10.2 14 14' stroke='%236f8069' stroke-width='1.6' stroke-linecap='round'/%3E%3C/svg%3E"); }
#suche.hat-x {
  padding-right: 26px;
  background-image: var(--lupe),
    url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M4.6 4.6l6.8 6.8M11.4 4.6l-6.8 6.8' stroke='%23888' stroke-width='1.5' stroke-linecap='round'/%3E%3C/svg%3E");
  background-position: 8px 50%, right 7px center;
  background-size: 14px 14px, 12px 12px;
  background-repeat: no-repeat, no-repeat;
}
#einteilung input.hat-x[type="date"], #einteilung input.hat-x[type="time"] {
  padding-right: 50px;
}

/* --- Die Kategorie-Vorschlaege -------------------------------------------
   Sie stehen als Marken UNTER dem Feld, nicht in einem datalist - warum,
   steht bei kategorieFeld in ansicht.js (kurz: dessen Griff zeichnet der
   Browser, und in Firefox laesst er sich nicht wegnehmen).

   Das Feld nimmt darum die ganze Zeile, die Marken die naechste: Sie sind
   ein Angebot und keine zweite Spalte neben der Eingabe. */
.panel .kategorie-feld { align-items: stretch; gap: 6px; }
.panel .kategorie-feld > input[type="text"] { flex: 1 0 100%; }
.panel .kategorie-vorschlaege { flex: 1 0 100%; }

/* --- Zugänge: die Liste des Betreibers (js/zugaenge.js) -------------------
   Derselbe Kasten wie in mapfit, Patientensim und Wachplan; dort trägt ihn
   basis.css des Gestaltungssystems, Abschnitt 14. Tagwerk pflegt seine
   Blätter selbst, also stehen dieselben Regeln hier - mit Tagwerks Größen
   (--gr-klein und Geschwister gibt es hier nicht) und sonst Zeile für Zeile
   wortgleich. Wer dort etwas ändert, ändert es hier mit. */
.mf-dialog.mf-zugaenge { max-width: 560px; }
.mf-zugaenge-liste { margin-top: 12px; max-height: min(50vh, 420px); overflow-y: auto; }

.mf-zugang {
  display: flex; align-items: center; gap: 12px;
  padding: 8px 0;
}
.mf-zugang + .mf-zugang { border-top: 1px solid var(--border); }
.mf-zugang-wer { flex: 1; min-width: 0; }
.mf-zugang-name { display: block; font-size: 14px; line-height: 1.25; }
/* Kennung, Herkunft, Datum – Beiwerk in einer Zeile, die nicht umbricht:
   Zwei Zeilen darunter verschöben die ganze Liste. */
.mf-zugang-quelle {
  display: block;
  font-size: 12px; color: var(--muted);
  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
}
/* Ein gesperrter Zugang ist nicht weg, nur still – gedämpft und nicht
   durchgestrichen: Durchgestrichen hieße gelöscht, und das ist das andere. */
.mf-zugang.ist-gesperrt .mf-zugang-name { color: var(--muted); }

.mf-zugang-aktiv {
  flex: none; display: flex; align-items: center; gap: 6px;
  font-size: 12px; color: var(--muted);
  cursor: pointer;
}
.mf-zugang-aktiv:has(input:disabled) { cursor: default; opacity: .55; }
.mf-zugang > .btn { flex: none; }

.mf-zugaenge-meldung { margin: 8px 0 0; font-size: 13px; }
.mf-zugaenge-meldung.gut { color: var(--gruen-tief); }
.mf-zugaenge-meldung.schlecht { color: var(--rot-tief); }
/* Der Abstandhalter der Knopfreihe. Er gehört zu .mf-dialog-knoepfe (oben)
   und fehlte hier nur, weil bisher keine Reihe in Tagwerk etwas nach rechts
   schieben musste. */
.mf-dialog-luft { flex: 1 1 auto; }

/* ================= Felder am Finger: nie unter 16 px ================= */
/* Safari auf dem iPhone zoomt beim Hineintippen in jedes Feld mit kleinerer
   Schrift die ganze Seite heran, und danach steht man in einer Liste, die
   nicht mehr ins Bild passt. Das ist eine Untergrenze und keine Gestaltung -
   deshalb !important und am Ende der Datei: Jede Regel mit einer Kennung
   (#neu-text, #neu-liste), jede fuer den Eintrag, den Kasten und die
   Anmeldung schlaegt sonst eine Regel, die nur das Element nennt.

   Gebunden an die Zeigerart und nicht an die Breite: Ein iPad in Querlage
   ist breit und zoomt genauso. Ausgenommen sind die Kaestchen des
   Codefelds - sie tragen 22 px - und was keine Schrift zeigt. */
@media (hover: none) {
  input:not([type="checkbox"]):not([type="radio"]):not([type="range"]):not([type="file"]):not(.code-ziffer),
  select, textarea { font-size: 16px !important; }
}
