@celestia-island/hikari 0.55.21 → 0.55.23

package/src/components/nodeCanvasTypes.ts

@@ -0,0 +1,170 @@
+/**
+ * nodeCanvasTypes.ts — Shared types for the HkNodeCanvas rendering base.
+ *
+ * These types are consumed by views (network topology, ladder diagram,
+ * mind map) that build on HkNodeCanvas. They are framework-agnostic
+ * (no Vue imports) so they can be used in pure computation modules too.
+ */
+
+// ── Camera & Bounds (re-exported from the main component) ────────────────
+
+export interface NodeCanvasCamera {
+  /** Zoom factor (1 = 1:1). */
+  k: number;
+  /** Translation of the content origin, in screen pixels. */
+  x: number;
+  /** Translation of the content origin, in screen pixels. */
+  y: number;
+}
+
+export interface NodeCanvasBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface NodeCanvasSlotProps {
+  camera: NodeCanvasCamera;
+  viewport: { width: number; height: number };
+  contentBounds: NodeCanvasBounds | null;
+}
+
+// ── Level of Detail ──────────────────────────────────────────────────────
+
+/** Level of detail, derived from the camera zoom factor. */
+export type LodLevel = "high" | "medium" | "low";
+
+/** Zoom thresholds: at or above `medium` shows full detail, at or above
+ *  `low` shows outlines + labels, below `low` shows outlines only. */
+export interface LodThresholds {
+  medium: number;
+  low: number;
+}
+
+export const LOD_DEFAULTS: LodThresholds = {
+  medium: 0.45,
+  low: 0.18,
+};
+
+/** Compute the LOD level from a zoom factor and thresholds. */
+export function computeLod(k: number, t: LodThresholds): LodLevel {
+  if (k >= t.medium) return "high";
+  if (k >= t.low) return "medium";
+  return "low";
+}
+
+// ── Canvas Painter ───────────────────────────────────────────────────────
+
+/** Context passed to canvas painters and the onFrame callback each frame. */
+export interface NodeCanvasFrameContext {
+  camera: NodeCanvasCamera;
+  viewport: { width: number; height: number };
+  /** Milliseconds since the last frame (for animations). */
+  dt: number;
+  /** Current LOD level. */
+  lod: LodLevel;
+  /** The Canvas2D context, already transformed to world coordinates. */
+  ctx: CanvasRenderingContext2D;
+}
+
+/** A canvas painter: called every frame while mounted. Painters draw
+ *  strokes, grids, pipes, edges — anything that benefits from Canvas2D
+ *  performance. They draw in WORLD coordinates (the camera transform
+ *  is already applied to the context). */
+export interface NodeCanvasPainter {
+  /** Unique identifier for registration/removal. */
+  id: string;
+  /** Called every frame. Draw in world coordinates. */
+  draw: (frame: NodeCanvasFrameContext) => void;
+  /** Painters with smaller z are drawn first (default 0). */
+  z?: number;
+}
+
+// ── Edges ────────────────────────────────────────────────────────────────
+
+/** How an edge is routed from source to target. */
+export type EdgeRouting = "bezier" | "orthogonal" | "direct";
+
+/** An edge between two points (or two nodes, resolved by the host). */
+export interface NodeCanvasEdge {
+  id: string;
+  /** Source point in world coordinates. */
+  from: { x: number; y: number };
+  /** Target point in world coordinates. */
+  to: { x: number; y: number };
+  /** Semantic type — views can use this for styling. */
+  type?: string;
+  /** Label rendered at the edge midpoint. */
+  label?: string;
+  /** Override the global routing strategy for this edge. */
+  routing?: EdgeRouting;
+  /** Stroke color (CSS color value or CSS variable name). */
+  color?: string;
+  /** Stroke width in world units. */
+  width?: number;
+  /** Dashed line. */
+  dashed?: boolean;
+}
+
+// ── Edge Geometry (pure functions) ───────────────────────────────────────
+
+/** Compute an SVG path string for an edge using the given routing. */
+export function edgePath(
+  edge: Pick<NodeCanvasEdge, "from" | "to">,
+  routing: EdgeRouting,
+): string {
+  const { from, to } = edge;
+  switch (routing) {
+    case "direct":
+      return `M ${from.x} ${from.y} L ${to.x} ${to.y}`;
+    case "orthogonal":
+      return orthogonalPath(from, to);
+    case "bezier":
+    default:
+      return bezierPath(from, to);
+  }
+}
+
+/** Cubic bezier: control points at 40% horizontal offset. */
+function bezierPath(
+  from: { x: number; y: number },
+  to: { x: number; y: number },
+): string {
+  const dx = Math.abs(to.x - from.x);
+  const cp = Math.max(dx * 0.4, 40);
+  return `M ${from.x} ${from.y} C ${from.x + cp} ${from.y}, ${to.x - cp} ${to.y}, ${to.x} ${to.y}`;
+}
+
+/** Manhattan routing: horizontal → vertical → horizontal. */
+function orthogonalPath(
+  from: { x: number; y: number },
+  to: { x: number; y: number },
+): string {
+  const midX = (from.x + to.x) / 2;
+  return `M ${from.x} ${from.y} L ${midX} ${from.y} L ${midX} ${to.y} L ${to.x} ${to.y}`;
+}
+
+/** Compute the midpoint of an edge (for label placement). */
+export function edgeMidpoint(
+  edge: Pick<NodeCanvasEdge, "from" | "to">,
+  routing: EdgeRouting,
+): { x: number; y: number } {
+  const { from, to } = edge;
+  if (routing === "orthogonal") {
+    const midX = (from.x + to.x) / 2;
+    return { x: midX, y: (from.y + to.y) / 2 };
+  }
+  return { x: (from.x + to.x) / 2, y: (from.y + to.y) / 2 };
+}
+
+// ── Print ────────────────────────────────────────────────────────────────
+
+export type PrintPaper = "a4-landscape" | "a3-landscape" | "auto";
+
+/** Paper dimensions in CSS pixels at 96 DPI. */
+export const PAPER_SIZES: Record<PrintPaper, { width: number; height: number } | null> = {
+  "a4-landscape": { width: 1122.5, height: 793.7 },
+  "a3-landscape": { width: 1587.4, height: 1122.5 },
+  auto: null,
+};

package/src/components/revealKinematogram.test.ts

@@ -5,6 +5,7 @@ import {
   FILTER_DRIFT_PX_S,
   layoutRevealGlyphs,
   NOISE_TILE_W,
+  parseColorTriple,
   RevealFilterPainter,
   RevealNoisePainter,
   sweepWindow,
@@ -134,12 +135,48 @@ describe("RevealNoisePainter", () => {
   });
 });
 
+describe("FILTER_DRIFT_PX_S settled band", () => {
+  it("keeps the drift in the live-tuned moderate band", () => {
+    // 84 px/s is the live-tuned settled value: the 300px/s
+    // persistence experiment read WORSE live (no stable surface for
+    // the eye to bind) and was reverted — a silent re-raise must go
+    // red. The band allows small tuning without test edits (R1 F2).
+    expect(FILTER_DRIFT_PX_S).toBeGreaterThanOrEqual(60);
+    expect(FILTER_DRIFT_PX_S).toBeLessThanOrEqual(120);
+  });
+});
+
+describe("parseColorTriple", () => {
+  it("parses computed rgb() strings without the leading-empty-token shift", () => {
+    // The bug this pins: "rgb(148, 233, 211)" used to split into a
+    // leading EMPTY token that Number() turned into 0, shifting the
+    // triple to [0, 148, 233] and skewing every derived HSL channel.
+    expect(parseColorTriple("rgb(148, 233, 211)")).toEqual([148, 233, 211]);
+    expect(parseColorTriple("rgb(255, 0, 0)")).toEqual([255, 0, 0]);
+  });
+
+  it("parses bare and alpha-suffixed triples, ignoring extra channels", () => {
+    expect(parseColorTriple("148 233 211")).toEqual([148, 233, 211]);
+    expect(parseColorTriple("148,233,211")).toEqual([148, 233, 211]);
+    expect(parseColorTriple("rgba(148, 233, 211, 0.5)")).toEqual([148, 233, 211]);
+  });
+
+  it("rejects modern color functions and non-triples", () => {
+    expect(parseColorTriple("oklch(70% 0.1 200)")).toBeNull();
+    expect(parseColorTriple("oklab(0.7 0.1 200)")).toBeNull();
+    expect(parseColorTriple("lab(52% 40 59)")).toBeNull();
+    expect(parseColorTriple("color(display-p3 1 0 0)")).toBeNull();
+    expect(parseColorTriple("teal")).toBeNull();
+    expect(parseColorTriple("")).toBeNull();
+  });
+});
+
 describe("RevealFilterPainter", () => {
   it("seeds both layer phases from randomness at each hold", () => {
     const p = new RevealFilterPainter();
     const rand = vi.spyOn(Math, "random").mockReturnValue(0.25);
     try {
-      p.beginHold("dark");
+      p.beginHold();
       // Drift-sign draw, then one phase draw per layer before retile;
       // happy-dom has no 2d context, so the tile builds bail before
       // consuming any more randomness.
@@ -154,17 +191,24 @@ describe("RevealFilterPainter", () => {
   it("drifts the two layers in OPPOSITE directions at equal speed", () => {
     // The segregation cue IS the 180° direction difference: a mutation
     // sending both layers the same way (or at unequal speeds) must go
-    // red here.
+    // red here. TWO probe combos whose real steps differ (42 and 21)
+    // so no single hardcoded step constant passes both (R1 F3: the
+    // old 0.25/2-only probe was blind to `const step = 42`).
     const p = new RevealFilterPainter();
     const rand = vi.spyOn(Math, "random").mockReturnValue(0.25); // driftSign = +1
     try {
-      p.beginHold("dark");
-      const before = p.peekDrift();
-      p.advance(0.25, 2);
-      const after = p.peekDrift();
-      const step = FILTER_DRIFT_PX_S * 2 * 0.25;
-      expect(after.background - before.background).toBeCloseTo(step, 10);
-      expect(after.ink - before.ink).toBeCloseTo(-step, 10);
+      p.beginHold();
+      for (const [dt, dpr] of [
+        [0.25, 2],
+        [0.125, 2],
+      ] as const) {
+        const before = p.peekDrift();
+        p.advance(dt, dpr);
+        const after = p.peekDrift();
+        const step = FILTER_DRIFT_PX_S * dpr * dt;
+        expect(after.background - before.background).toBeCloseTo(step, 10);
+        expect(after.ink - before.ink).toBeCloseTo(-step, 10);
+      }
     } finally {
       rand.mockRestore();
     }
@@ -174,7 +218,7 @@ describe("RevealFilterPainter", () => {
     const p = new RevealFilterPainter();
     const rand = vi.spyOn(Math, "random").mockReturnValue(0.75); // driftSign = -1
     try {
-      p.beginHold("dark");
+      p.beginHold();
       const before = p.peekDrift();
       p.advance(0.25, 2);
       const after = p.peekDrift();
@@ -188,7 +232,7 @@ describe("RevealFilterPainter", () => {
 
   it("never throws without a 2d context and stays unusable (fallback path)", () => {
     const p = new RevealFilterPainter();
-    expect(() => p.beginHold("dark")).not.toThrow();
+    expect(() => p.beginHold()).not.toThrow();
     expect(p.available).toBe(false);
   });
 });

package/src/components/revealKinematogram.ts

@@ -396,24 +396,24 @@ export class RevealNoisePainter {
  * password glyphs are STATIC apertures carrying a SECOND spatter
  * texture — statistically identical (same generator, dot size and
  * lightness distribution) but drifting the OPPOSITE way and shifted by
- * a small lightness pedestal toward the theme's visibility direction,
+ * a large brightening lightness pedestal (live-tuned, white-on-black
+ * reading),
  * with a soft halo band around the glyph row. A human segments the two
  * layers effortlessly (motion transparency at a 180° direction
  * difference is the strongest segregation cue the visual system has)
  * and reads the row aided by the pedestal + halo, while any SINGLE
  * frame carries no motion at all: the glyph boundary survives only as
- * a small mean-luminance step inside a smooth halo ramp — nothing for
+ * a mean-luminance step inside a smooth halo ramp — nothing for
  * a global or adaptive threshold to plateau on, and (matched
  * statistics) nothing for a texture classifier either.
  *
- * The palette is strictly GRAYSCALE — black, white and grays only, no
- * theme hue survives into the spatter (the ink-colored variant read as
- * an uncomfortable cyan). The two anchors follow the EFFECTIVE theme:
- * a dark theme (light field ink) gets a near-black ground with light
- * gray speckle, a white halo and a BRIGHTER glyph pedestal; a light
- * theme (dark ink) inverts every one of those — near-white ground,
- * dark gray speckle, black halo, DARKER glyph pedestal. Visibility,
- * not absolute brightness, is the invariant.
+ * The palette is strictly GRAYSCALE and strictly UNIFORM — black,
+ * white and grays only, no theme hue survives into the spatter (the
+ * ink-colored variant read as an uncomfortable cyan), and the anchors
+ * do NOT follow the theme: ALWAYS a near-black ground with dim gray
+ * speckle, a white halo and a much-brighter glyph pedestal (the theme-
+ * following light variant read far worse and was dropped — a dark
+ * reveal strip inside a light page is the accepted look).
  *
  * Why these parameters (the failure modes of video CAPTCHAs say what
  * to avoid — NuCAPTCHA & animated-GIF schemes died to per-frame OCR +
@@ -424,25 +424,37 @@ export class RevealNoisePainter {
  *   and motion signal both peak near the letters' diagnostic spatial
  *   band, so MODERATE noise contrast suffices (the old design's fine
  *   grain + fast ±40px/s drift is exactly what made it unreadable).
+ * - Legibility lives in the BRIGHTNESS channel (live-tuned): the
+ *   surround dots sit LOW (FILTER_BASE_L) on the near-black ground so
+ *   the background reads dim, the glyph layer is lifted by a LARGE
+ *   pedestal (FILTER_PEDESTAL_L) so the text reads bright, and the
+ *   dots are DENSE (FILTER_SPATTER_PX_PER_DOT) so both fields read as
+ *   textured surfaces rather than sparse speckle. The large pedestal
+ *   is a bigger single-frame leak than the original small one — an
+ *   accepted trade per the readability-first direction.
  * - The glyph apertures rasterize in BOLD: a heavier stroke exposes
  *   more of the counter-drifting texture inside each glyph (stronger
  *   signal under interference); the shared layout's 1.2× letter
  *   spacing absorbs the wider advances.
- * - Drift ±FILTER_DRIFT_PX_S: slow enough to track coherently at field
- *   sizes, fast enough that a single frame carries no usable motion
- *   energy (form-from-motion needs ~100–200ms of integration).
+ * - Drift ±FILTER_DRIFT_PX_S: moderate — slow enough to track
+ *   coherently at field font sizes, fast enough that a single frame
+ *   carries no usable motion energy. (A 300px/s persistence-of-vision
+ *   experiment read worse live: the eye never got a stable surface to
+ *   bind, so the speed came back down and legibility moved into the
+ *   brightness channel instead.)
  * - The glyph APERTURES never move — only the texture inside them
  *   flows. Cross-frame registration of the glyph shapes (the attack
  *   that killed video CAPTCHAs) finds nothing to align.
- * - The pedestal is deliberately SMALL: it is a static first-order cue
- *   and therefore the one signal a single frame leaks. Kept at
- *   FILTER_PEDESTAL_L lightness points and spread by the halo ramp, it
- *   aids human pop-out without giving thresholding a plateau. An
- *   attacker averaging MANY frames can in principle recover the
- *   pedestal's DC component (same cost class as the video attack on
- *   the noise strategy) — accepted risk, documented; consumers that
- *   cannot accept it pick "noise" (zero static signal) or "plain"
- *   (full readability).
+ * - The pedestal is deliberately LARGE (live-tuned readability
+ *   first): it is a static first-order cue and therefore the one
+ *   signal a single frame leaks, and the current magnitude leaks MORE
+ *   of it than the original small one — the accepted trade for a dim
+ *   surround and a bright text layer. The halo ramp still spreads the
+ *   step so thresholding finds no plateau, and an attacker averaging
+ *   MANY frames can in principle recover the pedestal's DC component
+ *   (same cost class as the video attack on the noise strategy) —
+ *   consumers that cannot accept this trade pick "noise" (zero static
+ *   signal) or "plain" (full readability).
  * - The drift sign is re-randomized per hold (and both tiles are
  *   freshly generated per hold) so two holds never replay the same
  *   frame sequence.
@@ -450,28 +462,28 @@ export class RevealNoisePainter {
  * Invariants the tests pin: glyph geometry NEVER touches the visible
  * canvas (mask → `source-in` noise stamp, exactly like the noise
  * painter); every spatter fill is a NEUTRAL gray (r === g === b); the
- * ground anchor follows the theme (near-black vs near-white); the two
- * tiles differ in mean luminance along the theme's pedestal direction;
- * the mask rasterizes in bold; the halo gradient is drawn every frame
- * in the theme's halo color; a pattern-less or gradient-less engine
+ * ground is ALWAYS the near-black anchor regardless of the theme or
+ * field ink; the two tiles differ in mean luminance along the
+ * pedestal; the mask rasterizes in bold; the halo gradient is drawn
+ * every frame in white; a pattern-less or gradient-less engine
  * degrades to the static plain text (filter exists FOR readability —
  * never to frozen noise). */
 
-/** Effective theme the filter anchors its grayscale palette to. */
-export type RevealFilterTheme = "dark" | "light";
-
-/** Counter-drift speed of each layer in CSS px/s (opposite signs). */
+/** Counter-drift speed of each layer in CSS px/s (opposite signs).
+ * The 300px/s persistence experiment read WORSE live (the eye never
+ * got a stable surface to bind); 84 tracks coherently at field sizes
+ * and is the settled value. */
 export const FILTER_DRIFT_PX_S = 84;
 
-/** Lightness pedestal of the glyph layer, in HSL lightness points
- * (clamped into [L_MIN, L_MAX] like every sample). The DIRECTION
- * follows the theme: brighter glyphs over a dark theme's ground,
- * darker glyphs over a light theme's. Small on purpose — see the
+/** Lightness pedestal of the glyph layer (brighter — the text reads
+ * white-on-black), in HSL lightness points (clamped into
+ * [L_MIN, L_MAX] like every sample). Deliberately LARGE (live-tuned
+ * readability-first): a dim surround and a bright text layer. The
+ * static single-frame leak grows with it — accepted trade, see the
  * strategy docblock. */
-export const FILTER_PEDESTAL_L = 10;
+export const FILTER_PEDESTAL_L = 26;
 
-/** Peak alpha of the halo band (theme-colored, at the glyph midline):
- * white over a dark ground, black over a light ground. */
+/** Peak alpha of the halo band (white, at the glyph-row midline). */
 export const FILTER_HALO_ALPHA = 0.1;
 
 /** Halo half-height as a multiple of the glyph font size (device px):
@@ -485,27 +497,47 @@ export const FILTER_HALO_FONT_SCALE = 1.2;
 const FILTER_SPATTER_R_MIN_CSS = 1.2;
 const FILTER_SPATTER_R_MAX_CSS = 2.8;
 
-/** Spatter coverage: one dot per this many tile px². BOTH layers share
- * the density, size and lightness distributions — matched texture
- * statistics are the single-frame defense; only the mean luminance
- * (pedestal) and the drift direction differ. */
-const FILTER_SPATTER_PX_PER_DOT = 45;
+/** Spatter coverage: one dot per this many tile px² — DENSE
+ * (live-tuned) so both fields read as textured surfaces. BOTH layers
+ * share the density, size and lightness distributions — matched
+ * texture statistics are the single-frame defense; only the mean
+ * luminance (pedestal) and the drift direction differ. */
+const FILTER_SPATTER_PX_PER_DOT = 28;
 
 /** Dot lightness spread around the layer base (both layers share it). */
 const FILTER_SPATTER_L_SPREAD = 22;
 
-/** Dark theme anchors: near-black ground, mid-light gray speckle. */
-const FILTER_DARK_BASE_L = 64;
-const FILTER_DARK_GROUND_L = 10;
-
-/** Light theme anchors: near-white ground, mid-dark gray speckle. */
-const FILTER_LIGHT_BASE_L = 38;
-const FILTER_LIGHT_GROUND_L = 93;
+/** The one anchor set: near-black ground + DIM gray speckle for the
+ * surround — white-on-black reading in EVERY theme with the brightness
+ * doing the work (the light variant read far worse and was dropped). */
+const FILTER_BASE_L = 48;
+const FILTER_GROUND_L = 10;
 
 /** Glyph aperture weight: bold strokes expose more of the counter-
  * drifting texture inside each glyph. */
 const FILTER_APERTURE_WEIGHT = "bold";
 
+/**
+ * Parse an `rgb(r, g, b)` / `rgba(...)` / bare `r g b` triple out of a
+ * color string, rejecting the modern color functions (oklch/lab/
+ * color() would split into garbage numeric triples — the caller keeps
+ * its previous base instead). Leading separators are REAL here: a
+ * computed `rgb(...)` string starts with separators and the split
+ * would yield a leading EMPTY token — `Number("") === 0` silently
+ * shifts the triple to [0, r, g] and skews every derived HSL channel
+ * (the noise painter's ink base read a light ink as 45.7% lightness
+ * before this was fixed).
+ */
+export function parseColorTriple(raw: string): [number, number, number] | null {
+  if (/^(oklch|oklab|lab|lch|color)\(/i.test(raw.trim())) return null;
+  const ns = raw
+    .split(/[\s,()rgba]+/)
+    .filter((t) => t !== "")
+    .map(Number)
+    .filter((n) => !isNaN(n));
+  return ns.length >= 3 ? [ns[0], ns[1], ns[2]] : null;
+}
+
 export class RevealFilterPainter {
   private bgTile: HTMLCanvasElement | null = null;
   private inkTile: HTMLCanvasElement | null = null;
@@ -514,7 +546,6 @@ export class RevealFilterPainter {
   private offsetBackground = 0;
   private offsetInk = 0;
   private driftSign = 1;
-  private theme: RevealFilterTheme = "dark";
   private dpr = 1;
   private ok = true;
 
@@ -530,20 +561,18 @@ export class RevealFilterPainter {
     return { background: this.offsetBackground, ink: this.offsetInk };
   }
 
-  /** Start a hold: two FRESH grayscale spatter tiles anchored to the
-   * theme (near-black/near-white ground), the glyph layer shifted by
-   * the pedestal along the theme's visibility direction, randomized
-   * phases and a randomized drift direction, so replays are never
-   * pixel-identical and automation cannot precompute the motion. */
-  beginHold(theme: RevealFilterTheme = "dark", dpr = 1): void {
+  /** Start a hold: two FRESH grayscale spatter tiles on the uniform
+   * near-black ground, the glyph layer lifted by the pedestal, with
+   * randomized phases and a randomized drift direction, so replays
+   * are never pixel-identical and automation cannot precompute the
+   * motion. */
+  beginHold(dpr = 1): void {
     this.dpr = dpr;
-    this.theme = theme;
     this.driftSign = Math.random() < 0.5 ? 1 : -1;
     this.offsetBackground = Math.random() * NOISE_TILE_W;
     this.offsetInk = Math.random() * NOISE_TILE_W;
     this.maskKey = ""; // force a mask rebuild on the first paint
-    const pedestal = (theme === "dark" ? 1 : -1) * FILTER_PEDESTAL_L;
-    this.ok = this.retile(0, "bg") && this.retile(pedestal, "ink");
+    this.ok = this.retile(0, "bg") && this.retile(FILTER_PEDESTAL_L, "ink");
   }
 
   advance(dt: number, dpr: number): void {
@@ -552,11 +581,10 @@ export class RevealFilterPainter {
     this.offsetInk -= this.driftSign * step;
   }
 
-  /** (Re)build one spatter tile: the theme's ground (near-black over a
-   * dark theme, near-white over a light one), then a fixed-density
-   * scatter of NEUTRAL-GRAY dots around the theme's base lightness.
-   * Draw order is deterministic (bg tile first, then ink) so tests can
-   * attribute the per-canvas recordings. */
+  /** (Re)build one spatter tile: the ONE near-black ground anchor,
+   * then a fixed-density scatter of NEUTRAL-GRAY dots around the one
+   * base lightness. Draw order is deterministic (bg tile first, then
+   * ink) so tests can attribute the per-canvas recordings. */
   private retile(pedestalL: number, which: "bg" | "ink"): boolean {
     try {
       if (typeof document === "undefined") return false;
@@ -570,19 +598,17 @@ export class RevealFilterPainter {
       tile.height = NOISE_TILE_H;
       const tctx = tile.getContext("2d");
       if (!tctx) return false;
-      const dark = this.theme === "dark";
-      const baseL = dark ? FILTER_DARK_BASE_L : FILTER_LIGHT_BASE_L;
-      const groundL = dark ? FILTER_DARK_GROUND_L : FILTER_LIGHT_GROUND_L;
       const lift = (v: number) => Math.min(L_MAX, Math.max(L_MIN, v));
-      // Saturation is ZERO by construction — black/white/gray only.
-      const [gr, gg, gb] = hslToRgb(0, 0, lift(groundL + pedestalL));
+      // Saturation is ZERO by construction — black/white/gray only,
+      // on the ONE near-black ground anchor.
+      const [gr, gg, gb] = hslToRgb(0, 0, lift(FILTER_GROUND_L + pedestalL));
       tctx.fillStyle = `rgb(${gr},${gg},${gb})`;
       tctx.fillRect(0, 0, NOISE_TILE_W, NOISE_TILE_H);
       const count = Math.round((NOISE_TILE_W * NOISE_TILE_H) / FILTER_SPATTER_PX_PER_DOT);
       const rMin = FILTER_SPATTER_R_MIN_CSS * this.dpr;
       const rMax = FILTER_SPATTER_R_MAX_CSS * this.dpr;
       for (let i = 0; i < count; i++) {
-        const dl = lift(baseL + pedestalL + (Math.random() * 2 - 1) * FILTER_SPATTER_L_SPREAD);
+        const dl = lift(FILTER_BASE_L + pedestalL + (Math.random() * 2 - 1) * FILTER_SPATTER_L_SPREAD);
         const [r, g, b] = hslToRgb(0, 0, dl);
         tctx.fillStyle = `rgb(${r},${g},${b})`;
         const rad = rMin + Math.random() * (rMax - rMin);
@@ -626,13 +652,12 @@ export class RevealFilterPainter {
       // Create the halo gradient up front as well: creation draws
       // nothing, so a bail here still leaves the visible canvas
       // untouched (no partial frame — see the pre-check above). The
-      // halo color follows the theme: white over a dark ground, black
-      // over a light one.
+      // halo is ALWAYS white — the reveal reads white-on-black in
+      // every theme — and the endpoints derive from the same channel
+      // string as the peak (no literal-compare desync trap).
       const bandH = Math.min(H / 2, FILTER_HALO_FONT_SCALE * layout.fontPx);
       const midY = H / 2;
-      // Endpoints derive from the SAME theme channel string as the
-      // peak — no literal compare that could silently desync them.
-      const haloRGB = this.theme === "dark" ? "255,255,255" : "0,0,0";
+      const haloRGB = "255,255,255";
       const grad = ctx.createLinearGradient(0, midY - bandH, 0, midY + bandH);
       if (!grad) return false;
       grad.addColorStop(0, `rgba(${haloRGB},0)`);