Sekunden als Punkte, Ringe gestaffelt, silberner Rand weg

Filipe: "ich will aber dass die sekunden wie punkte sind, die minuten
breiter und die stunden noch breiter … den silbernen rand weg bitte den
will ich nicht … es soll nichts verschwommen aussehen oder so, im
gegenteil, richtig scharf und perfekt."

DER SILBERNE RING IST WEG. Er war die breiteste Flaeche der ganzen Uhr
und damit das Erste, was das Auge traf -- ausgerechnet der Teil, der
nichts anzeigt. Jetzt dunkles Metall; die drei Bahnen sind das Hellste
im Bild. Die Skalenstriche bleiben, sie geben Mass ohne zu fuellen.

DIE SEKUNDE IST EINE PUNKTREIHE. Sechzig Punkte, einer je Sekunde --
der schnellste Wert wird zaehlbar statt nur gewachsen. Das ist auch
ehrlicher: Die Sekunde SPRINGT, ein durchgehender Bogen behauptet einen
fliessenden Wert.

DIE BREITEN STAFFELN SICH: 3,2 / 5 / 7 statt 3 / 3,4 / 4. Die alten
Werte waren rechnerisch verschieden und im Bild nicht zu unterscheiden
-- ein Unterschied unter einem Pixel ist keiner. Jetzt liest man die
Ringe an ihrer STAERKE: je langsamer, desto schwerer.

SCHAERFE STATT NEBEL: Die weichen Scheine lagen mit 7 bis 9 px Radius
ueber den Bahnen wie Dunst. Jetzt 1,5 px -- sie liegen als KANTE an
statt als Wolke. Die Tiefe kommt aus dem Versatz der Lagen, so wie im
Rest dieser Uhr auch.

DREIMAL AN DERSELBEN STELLE DANEBEN, UND JEDES MAL IM BILD GESEHEN:

  1. Der Sekunden-Schweif stand noch im Dokument und war per CSS
     ausgeblendet -- das griff nicht, und ohne `dasharray` zeichnete er
     einen durchgehenden roten Ring um die ganze Uhr. Ein Element, das
     nie sichtbar sein soll, gehoert nicht ins Dokument. Ausblenden ist
     kein Entfernen.
  2. Dann das Punktmuster: n Paare plus Schluss-Luecke sind 2n+1 Werte.
     Bei ungerader Anzahl verdoppelt SVG die Liste und vertauscht dabei
     Striche und Luecken.
  3. Also eine Null angehaengt (`rest 0`) -- Anzahl gerade, Fehler
     blieb. Denn in `dasharray` wechseln sich Strich und Luecke ab: Nach
     2n Werten sitzt der naechste an UNGERADER Stelle und ist ein
     Strich. Der Rest wurde weiter gezeichnet. Richtig ist die Null
     ZUERST (`0 rest`), dann landet die Luecke an gerader Stelle.

UND DIE PRUEFUNG MUSSTE MIT. `pruef-start-ansicht` verglich die
REIHENFOLGE der Farbkanaele im Kachel-Licht. Das setzt voraus, dass die
Kanaele deutlich verschieden sind -- seit der neuen Palette stimmt das
nicht mehr: "Aufgaben" ist Tuerkis (G=191, B=163), gemessen 63 gegen 65.
ZWEI Stufen von 255. Die Reihenfolge kippt dort durch Rundung, und die
Pruefung meldete einen Fehler, wo keiner war.

Sie misst jetzt den FARBWINKEL -- dieselbe Frage ("ist es dieser Ton?"),
ohne die Voraussetzung. 40 Grad Toleranz; die Kachelfarben liegen nach
der Neuberechnung gut 60 Grad auseinander. Dazu eine GEGENPROBE je
Kachel: Der gemessene Ton wird gegen den Gegenton auf dem Farbkreis
gehalten und muss dort anschlagen. Eine Pruefung, die immer bestaetigt,
bestaetigt nichts.

Gemessen: Farbwinkel-Abstaende 13° / 16° / 7° von 40 erlaubten.
pruef-start-ansicht EXIT=0, 140 -> 143 Pruefungen (die drei Gegenproben
sind dazugekommen, keine ist verschwunden). pruef-css-klassen EXIT=0.

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

workspace/assets/js/start.js

@@ -398,8 +398,68 @@
       spuren[welcher] = document.querySelector(`[data-spur="${welcher}"]`);
     }
 
+    /* DIE SEKUNDE IST EINE PUNKTREIHE (08.09.2026).
+
+       Filipe: "ich will aber dass die sekunden wie punkte sind".
+
+       Sechzig Punkte auf der Bahn, einer je Sekunde, und es leuchten so
+       viele, wie vergangen sind. `stroke-linecap: round` macht aus einer
+       Strichlaenge nahe null einen Kreis vom Durchmesser der
+       Strichbreite -- so entsteht ein Punkt ohne ein einziges weiteres
+       Element.
+
+       DAS MUSTER MUSS MITWACHSEN, und genau das kann `dashoffset`
+       allein nicht: Es verschiebt ein festes Muster, es kuerzt es
+       nicht. Ein festes Punktmuster plus Offset ergaebe eine Reihe, die
+       WANDERT statt zu wachsen. Deshalb wird die Liste je Sekunde neu
+       gebaut: n Paare aus Punkt und Luecke, dahinter eine Luecke ueber
+       den ganzen Rest. Sechzig Zahlenpaare einmal je Sekunde sind
+       nichts -- die Alternative waeren sechzig Elemente im Dokument. */
+    const SEK_PUNKTE = 60;
+    const punktMuster = (U, n) => {
+      const schritt = U / SEK_PUNKTE;
+      if (n <= 0) return `0 ${U}`;
+      /* 0.01 statt 0: Manche Browser zeichnen eine Strichlaenge von
+         exakt null gar nicht, auch mit runder Kappe. */
+      const paar = `0.01 ${(schritt - 0.01).toFixed(3)} `;
+      /* DIE REIHENFOLGE ENTSCHEIDET, OB DER REST EINE LUECKE IST.
+
+         In `dasharray` wechseln sich Strich und Luecke ab, beginnend
+         mit einem Strich. Nach n Paaren stehen 2n Werte -- der naechste
+         Wert sitzt damit an UNGERADER Stelle und ist ein STRICH.
+
+         Genau daran bin ich zweimal gescheitert. Erst haengte ich den
+         Rest direkt an (2n+1 Werte, ungerade -- SVG verdoppelt die
+         Liste und vertauscht dabei alles), dann setzte ich eine Null
+         hinterher (`rest 0`): Die Anzahl war gerade, aber der Rest
+         stand weiterhin an ungerader Stelle und wurde gezeichnet. Im
+         Bildschirmfoto lief beide Male ein durchgehender roter Bogen
+         ueber die halbe Uhr, neben den richtigen Punkten.
+
+         Richtig ist die Null ZUERST: Sie belegt die ungerade Stelle als
+         Strich der Laenge null, und der Rest landet an gerader Stelle --
+         als Luecke, wie gemeint. Zwei Zahlen in der richtigen
+         Reihenfolge, und der Rest verschwindet. */
+      return paar.repeat(n) + '0 ' + (U - n * schritt).toFixed(3);
+    };
+
     const setze = (welcher, anteil) => {
       const U = UMFANG[welcher];
+
+      if (welcher === 'sekunde') {
+        /* Der erste Punkt gehoert der Sekunde 0 -- deshalb n = sk + 1:
+           Bei 0 Sekunden leuchtet einer, bei 59 alle sechzig. Ein Ring,
+           der bei null voellig leer ist, sieht eine Sekunde lang aus wie
+           ein Ladefehler. */
+        const n = Math.round(anteil * SEK_PUNKTE) + 1;
+        const muster = punktMuster(U, Math.min(n, SEK_PUNKTE));
+        for (const el of lagen[welcher]) {
+          el.style.strokeDasharray = muster;
+          el.style.strokeDashoffset = '0';
+        }
+        return;
+      }
+
       const wert = String(U * (1 - anteil));
       for (const el of lagen[welcher]) el.style.strokeDashoffset = wert;