@ciphore/radiocli 0.2.5 → 0.2.6

package/dist/ui/visualizers/sumi-ocean.js

@@ -0,0 +1,183 @@
+import { encodeTerminalCell } from './terminal-cell.js';
+// Original artwork inspired by the quiet horizon and moon path at boat.dev.
+const palette = [
+    '#05091b', '#080e26', '#0b1432', '#101c40', '#14254e', '#192e60',
+    '#1f3973', '#284784', '#335694', '#4165a4', '#5376b4', '#688ac2',
+    '#809fd0', '#9ab4dd', '#b8cbe9', '#d6e2f3', '#ecf2fb', '#fcfdff'
+];
+const mono = palette.map(color => {
+    const value = Number.parseInt(color.slice(1), 16);
+    const channel = Math.round(((value >> 16) * 0.2126 + ((value >> 8) & 255) * 0.7152 + (value & 255) * 0.0722));
+    return `#${channel.toString(16).padStart(2, '0').repeat(3)}`;
+});
+const scenes = new Map();
+const clamp = (value) => Math.max(0, Math.min(1, value));
+const smooth = (value) => { const t = clamp(value); return t * t * (3 - 2 * t); };
+function hash(x, y) {
+    let value = Math.imul(x, 374761393) ^ Math.imul(y, 668265263);
+    value = Math.imul(value ^ (value >>> 13), 1274126177);
+    return ((value ^ (value >>> 16)) >>> 0) / 4294967295;
+}
+function noise(x, row) {
+    const left = Math.floor(x), blend = smooth(x - left);
+    return hash(left, row) * (1 - blend) + hash(left + 1, row) * blend;
+}
+function sceneFor(width, height) {
+    const key = `${width}:${height}`;
+    const cached = scenes.get(key);
+    if (cached)
+        return cached;
+    // 2×4 square subpixels match a terminal's 1:2 cell aspect. The previous 2×2
+    // grid made the tiny moon rectangular and merged thin crests into blocks.
+    const columns = width * 2, rows = height * 4;
+    const horizon = rows * (height <= 6 ? 0.43 : 0.46);
+    const moonColumn = Math.round(width * 0.78);
+    const moonRow = Math.floor(horizon / 4 * 0.40);
+    const moonX = (moonColumn + (height <= 8 ? 0.5 : 0)) * 2;
+    const moonY = height <= 8 ? moonRow * 4 + 2 : horizon * 0.40;
+    const radius = Math.max(height <= 3 ? 1.6 : 2, Math.min(6, height * 0.24));
+    const sky = new Float32Array(columns * rows).fill(-1);
+    const depths = Float32Array.from({ length: rows }, (_, y) => (y + 0.5 - horizon) / Math.max(1, rows - horizon));
+    const firstWater = depths.findIndex(depth => depth >= 0);
+    for (let y = 0; y < rows; y++)
+        for (let x = 0; x < columns; x++) {
+            const index = y * columns + x;
+            const u = (x + 0.5) / columns;
+            if (y < firstWater) {
+                const dx = x + 0.5 - moonX, dy = y + 0.5 - moonY;
+                const distance = Math.hypot(dx, dy);
+                const halo = Math.exp(-(distance * distance) / (radius * radius * 5));
+                const altitude = (y + 0.5) / horizon;
+                let shade = 1.1 + altitude * 2.6 + halo * 3.6;
+                const cloud = Math.sin(u * 15 + altitude * 4) * Math.sin(altitude * 11 - u * 4);
+                shade += Math.max(0, cloud) * smooth((altitude - 0.3) / 0.5) * 0.55;
+                const limb = smooth((radius + 0.4 - distance) / 0.8);
+                if (limb > 0 && height > 8) {
+                    const crater = Math.exp(-(((dx + radius * 0.25) ** 2 + (dy - radius * 0.15) ** 2) / (radius * radius * 0.16)));
+                    shade = shade * (1 - limb) + (17 - crater * 1.3) * limb;
+                }
+                else if (height >= 7 && y < horizon * 0.65 && distance > radius * 3 && hash(x, y + 17) > 0.997) {
+                    shade += 2.4;
+                }
+                sky[index] = shade;
+                continue;
+            }
+        }
+    const samples = new Float32Array(8);
+    // Only the sky is static. Cache complete sky rows, and sample the boundary
+    // again with the water so every ripple across the sea can travel sideways.
+    const skyline = Array.from({ length: Math.floor(firstWater / 4) }, (_, y) => {
+        const runs = [];
+        for (let x = 0; x < width; x++) {
+            for (let q = 0; q < 8; q++)
+                samples[q] = sky[(y * 4 + (q >> 1)) * columns + x * 2 + (q & 1)];
+            const moon = height <= 8 && width >= 8 && y === moonRow && x === moonColumn;
+            const cell = moon ? { glyph: '●', fg: 17, bg: 4 } : encodeTerminalCell(samples, x, y, 17);
+            const previous = runs.at(-1);
+            if (previous?.fg === cell.fg && previous.bg === cell.bg)
+                previous.text += cell.glyph;
+            else
+                runs.push({ text: cell.glyph, fg: cell.fg, bg: cell.bg });
+        }
+        return runs;
+    });
+    const scene = { sky, skyline, depths, firstWater, moonColumn, moonRow, moonX };
+    if (scenes.size >= 4)
+        scenes.delete(scenes.keys().next().value);
+    scenes.set(key, scene);
+    return scene;
+}
+const quadrants = ' ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█';
+// Broad quadrant marks retain the previous receiver's soft, horizontal water.
+// Average the fine samples instead of fitting sharp diagonal shapes to glints.
+function waterCell(samples, ambient) {
+    const values = [(samples[0] + samples[2]) / 2, (samples[1] + samples[3]) / 2,
+        (samples[4] + samples[6]) / 2, (samples[5] + samples[7]) / 2];
+    const mean = values.reduce((sum, value) => sum + value, 0) / 4;
+    const threshold = ambient === undefined ? mean : ambient + 0.2;
+    let mask = 0, high = 0, low = 0, count = 0;
+    for (let q = 0; q < 4; q++) {
+        if (values[q] > threshold) {
+            mask |= 1 << q;
+            high += values[q];
+            count++;
+        }
+        else
+            low += values[q];
+    }
+    const base = Math.max(1, Math.floor((ambient ?? mean) - 0.35));
+    const fg = ambient === undefined ? Math.min(17, Math.round(count ? high / count : mean)) : base + 2;
+    const bg = ambient === undefined ? Math.min(17, Math.round(count < 4 ? low / (4 - count) : mean)) : base;
+    return { glyph: fg === bg ? ' ' : quadrants[mask], fg, bg };
+}
+/** A steady moon above travelling water and a broad, ripple-broken reflection. */
+export function buildSumiOcean(pulse, width, height, theme) {
+    const scene = sceneFor(width, height);
+    const columns = width * 2, rows = height * 4;
+    const time = pulse * 0.08;
+    const colors = theme === 'mono' ? mono : palette;
+    const field = new Float32Array(scene.sky.length);
+    const ambient = new Float32Array(rows);
+    for (let y = scene.firstWater; y < rows; y++) {
+        const depth = scene.depths[y];
+        // Preserve the old perspective at normal sizes, with fewer distinct wave
+        // bands when the viewport is short so the surface cannot alias away.
+        const band = Math.floor(depth * Math.min(30, Math.max(6, height * 2)));
+        const phase = time * 0.48 + depth * 31;
+        const wander = Math.sin(phase * 0.63) * (0.003 + depth * 0.008) * columns;
+        const pathWidth = Math.max(1.1, columns * 0.008) + depth * columns * 0.055;
+        const base = 5.7 - depth * 2.6 + Math.sin(depth * 24 - time * 0.42) * 0.4;
+        ambient[y] = base;
+        const catchLight = smooth((noise(time * 0.5 + band * 0.37, band + 51) - 0.3) / 0.48);
+        const scale = 68 - depth * 45;
+        const drift = time * (0.18 + depth * 0.25);
+        for (let x = 0; x < columns; x++) {
+            const ripple = noise((x + 0.5) / columns * scale + drift, band + 23);
+            let value = base + (ripple - 0.5) * (1 + depth * 1.5);
+            const offset = (x + 0.5 - scene.moonX - wander) / pathWidth;
+            if (Math.abs(offset) < 3.2) {
+                const path = Math.exp(-offset * offset);
+                const fragment = smooth((ripple - 0.33) / 0.42);
+                value += path * (2.7 + catchLight * fragment * (7.5 - depth * 1.7));
+            }
+            value += smooth((ripple - 0.72) / 0.2) * (0.8 + depth * 1.6);
+            field[y * columns + x] = Math.min(17, value);
+        }
+    }
+    const result = [];
+    const samples = new Float32Array(8);
+    for (let y = 0; y < height; y++) {
+        let text = '';
+        const segments = [];
+        const append = (value, fg, bg) => {
+            const color = colors[fg], backgroundColor = colors[bg];
+            text += value;
+            const previous = segments.at(-1);
+            if (previous?.color === color && previous.backgroundColor === backgroundColor)
+                previous.text += value;
+            else
+                segments.push({ text: value, color, backgroundColor });
+        };
+        const skyline = scene.skyline[y];
+        if (skyline) {
+            for (const run of skyline)
+                append(run.text, run.fg, run.bg);
+        }
+        else
+            for (let x = 0; x < width; x++) {
+                for (let q = 0; q < 8; q++) {
+                    const sy = y * 4 + (q >> 1), index = sy * columns + x * 2 + (q & 1);
+                    samples[q] = sy < scene.firstWater ? scene.sky[index] : field[index];
+                }
+                const depth = (scene.depths[y * 4] + scene.depths[y * 4 + 3]) / 2;
+                const farFromReflection = Math.abs((x + 0.5) * 2 - scene.moonX) / columns > 0.018 + depth * 0.13;
+                const base = y * 4 >= scene.firstWater && farFromReflection ? (ambient[y * 4] + ambient[y * 4 + 3]) / 2 : undefined;
+                let cell = waterCell(samples, base);
+                if (height <= 8 && width >= 8 && y === scene.moonRow && x === scene.moonColumn)
+                    cell = { glyph: '●', fg: 17, bg: 4 };
+                append(cell.glyph, cell.fg, cell.bg);
+            }
+        result.push({ text, color: colors[7], segments });
+    }
+    return result;
+}

package/dist/ui/visualizers/terminal-cell.js

@@ -0,0 +1,45 @@
+const dither = [0, 0.5, 0.125, 0.625, 0.75, 0.25, 0.875, 0.375, 0.1875, 0.6875, 0.0625, 0.5625, 0.9375, 0.4375, 0.8125, 0.3125];
+const glyphs = ' ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█';
+// Eight samples retain diagonals that disappear when collapsed into quadrants.
+// All glyphs are single-column BMP characters supported by existing TUI fonts.
+const patterns = [...glyphs].slice(1, 8).map((glyph, index) => {
+    const quadrant = index + 1;
+    return { glyph, mask: (quadrant & 1 ? 5 : 0) | (quadrant & 2 ? 10 : 0) | (quadrant & 4 ? 80 : 0) | (quadrant & 8 ? 160 : 0) };
+});
+patterns.push({ glyph: '◢', mask: 232 }, { glyph: '◣', mask: 212 }, { glyph: '◤', mask: 23 }, { glyph: '◥', mask: 43 }, { glyph: '▂', mask: 192 }, { glyph: '▆', mask: 252 });
+const clusters = patterns.map(pattern => ({ ...pattern, indices: Array.from({ length: 8 }, (_, q) => q).filter(q => pattern.mask & (1 << q)) }));
+export function encodeTerminalCell(samples, x, y, maximum) {
+    let total = 0, squared = 0;
+    for (const sample of samples) {
+        total += sample;
+        squared += sample * sample;
+    }
+    const mean = total / 8;
+    const base = Math.floor(mean);
+    const shade = Math.min(4, Math.floor((mean - base) * 4 + dither[(y & 3) * 4 + (x & 3)]));
+    const value = base + shade / 4;
+    let error = 0;
+    for (const sample of samples)
+        error += (sample - value) ** 2;
+    error *= 0.8;
+    let glyph = [' ', '░', '▒', '▓', ' '][shade];
+    let fg = Math.min(maximum, base + 1), bg = Math.min(maximum, base + (shade === 4 ? 1 : 0));
+    for (const pattern of clusters) {
+        let sum = 0;
+        const count = pattern.indices.length;
+        for (const q of pattern.indices)
+            sum += samples[q];
+        const a = Math.round(sum / count), b = Math.round((total - sum) / (8 - count));
+        if (a === b)
+            continue;
+        // Sum of squared residuals, without resampling each cluster's members.
+        const cost = squared - 2 * a * sum + count * a * a - 2 * b * (total - sum) + (8 - count) * b * b;
+        if (cost < error) {
+            error = cost;
+            glyph = pattern.glyph;
+            fg = a;
+            bg = b;
+        }
+    }
+    return { glyph, fg, bg };
+}

package/docs/boat-lake.md

@@ -0,0 +1,88 @@
+# Boat Lake receiver
+
+`boat-lake` is a local adaptation of the procedural lake behind [boat.dev](https://boat.dev/).
+The original scene was extracted on October 28, 2026 from the public client bundle
+[`26-7j4wbk3v76.js`](https://boat.dev/_next/static/chunks/26-7j4wbk3v76.js).
+The landscape, lighting, water, reflections and sail polygons come from that
+scene. Provenance comments are retained in the isolated kernel and local
+reference. No website copy, branding, fonts, analytics or network code is included.
+
+## Preview locally
+
+```sh
+node scripts/build-boat-lake-preview.mjs
+python3 -m http.server 4178 --bind 127.0.0.1 --directory output/boat-lake
+```
+
+Open <http://127.0.0.1:4178>. Switch between **Extracted scene** and **Receiver style**.
+The reference runs the original layered drawing and character quantizer. The
+receiver runs the terminal adapter. The preview defaults to actual TUI proportions
+with 8×16 pixel cells. **Enlarge** magnifies those cells without inventing detail.
+Sizes range from 120×30 to 20×3, including the normal 120×18 receiver maximum.
+[Size checks](http://127.0.0.1:4178/sizes.html) show several sizes together, plus
+real Unicode text rendered in browser monospace for the smaller layouts.
+Terminal font metrics can differ from the canvas representation.
+
+Pause/play is available; the preview also pauses in hidden tabs and starts still
+when reduced motion is requested. Both reference and receiver use fixed daytime
+lighting (phase `0.44`) with no page fade. The builder uses installed esbuild and
+bundled local sources. It does not fetch assets. Output is ignored by Git.
+
+Select **Boat Lake** in RadioCLI's existing receiver-style picker. The docs
+receiver gallery uses the same registry and renderer. The radio default and saved
+receiver selection are unchanged.
+
+## Composition and rendering
+
+- Size the scene to the viewport rather than squeezing a fixed 160×42 artboard
+  into every receiver. Short layouts use a lower horizon, with fewer, larger boats.
+- Keep the foreground boat away from the bright sun reflection for contrast.
+- Rasterize the original sail and hull polygons directly; sampling already
+  quantized sprites a second time erased their small features.
+- Preserve eight samples per cell, with quadrant blocks, diagonal triangles,
+  quarter-height blocks and fine ordered shading. Evaluate two-color cluster
+  errors from their sums rather than repeatedly calculating every residual.
+- At 3–6 rows, use explicit terminal-grid sails, hull and pine silhouettes so they
+  remain recognizable. The smallest receivers use one boat.
+- Adapt the upstream pine minimum height so short scenes retain their tips.
+- Cache static scenery, encoded static cells and a detailed reflection field.
+  Interpolated horizontal refraction animates the cached water; larger boats bob
+  gently. This is an approximation of the original water animation, rather than
+  rerunning its full reflected scene on every frame.
+- Retain at most four viewport caches with no playback history. Preserve the
+  original blue palette, with grayscale for the mono theme, and merge adjacent
+  equal-color cells into terminal runs.
+
+The receiver needs no GPU, images, external fonts or network service. Motion uses
+RadioCLI's existing receiver clock and pause behavior.
+
+## Measurements
+
+```sh
+npx tsx scripts/boat-lake/benchmark.mts
+```
+
+The benchmark warms both renderers for 60 frames, then measures 200 frames per
+output resolution. The reference measures original field sampling and original
+character quantization on its fixed artboard. The receiver additionally includes
+boat compositing and segment creation, and uses its adaptive composition and
+cached refraction animation. This compares their steady-state costs, not identical
+per-frame algorithms. A first frame or cache miss also builds the reflected field.
+Neither measurement includes browser painting, Ink rendering or terminal I/O.
+
+Node v24.15.0 on this machine:
+
+| Viewport | Reference median | Receiver median | Receiver p95 |
+| --- | ---: | ---: | ---: |
+| 120×30 | 9.258 ms | 0.869 ms | 1.115 ms |
+| 120×18 | 5.952 ms | 0.522 ms | 0.751 ms |
+| 100×14 | 3.547 ms | 0.360 ms | 0.445 ms |
+| 80×10 | 2.041 ms | 0.225 ms | 0.318 ms |
+| 60×7 | 1.135 ms | 0.142 ms | 0.209 ms |
+| 36×4 | 0.374 ms | 0.061 ms | 0.092 ms |
+| 24×4 | 0.246 ms | 0.026 ms | 0.027 ms |
+| 20×3 | 0.148 ms | 0.016 ms | 0.017 ms |
+
+Tests cover terminal column widths, glyphs and palettes, merged segments,
+monochrome, steady scenery with animated water, detailed shading, recognizable
+compact sails/hulls/pines throughout playback, and determinism after cache eviction.

package/docs/sumi-ocean.md

@@ -0,0 +1,80 @@
+# Sumi Ocean refinement
+
+The existing `sumi-ocean` receiver takes visual cues from the moonlit harbour above
+[boat.dev's footer](https://boat.dev/): a clear moon, soft halo, quiet horizon and
+broken silver reflections. Its artwork is original typed TypeScript. It uses no
+harbour code, boats, jetty, barrels, images, external fonts or network services.
+
+The style ID, saved selection and indigo palette remain the same, including a
+monochrome version. The sky stays steady. Reflections shimmer and refract through
+RadioCLI's existing receiver clock and pause behavior.
+
+## Local comparison
+
+```sh
+node scripts/build-boat-lake-preview.mjs
+python3 -m http.server 4178 --bind 127.0.0.1 --directory output/boat-lake
+```
+
+Open <http://127.0.0.1:4178/ocean.html>. The **Previous receiver** button shows the
+four-sample renderer immediately before this refinement. Compare sizes from
+120×30 down to 20×3, in indigo or monochrome. The normal receiver maximum is 14
+rows; 30 rows are an enlarged study. The preview now defaults to actual TUI
+proportions with 8×16 pixel cells. **Enlarge** magnifies those same cells.
+
+[Size checks](http://127.0.0.1:4178/ocean-sizes.html) show several sizes together,
+including real Unicode text in browser monospace. Terminal font metrics can
+differ from the canvas representation. The preview pauses in hidden tabs and
+starts still when reduced motion is requested. An optional local footer screenshot
+appears when `output/boat-lake/footer-reference.png` is present. No asset is fetched
+from the original website.
+
+## Small receivers and detail
+
+- Use eight samples per cell on a 2×4 square-subpixel grid, matching the terminal's
+  1:2 cell aspect. The sky uses Boat Lake's fine cell encoder and ordered shading.
+- Keep the previous receiver's broad quadrant marks for water. Average the fine
+  samples into quadrants instead of fitting diagonal shapes to the reflection.
+- Adapt the horizon, moon size and number of wave bands to the viewport. Short
+  receivers avoid undersampling a fixed thirty-band water field.
+- Below nine rows, draw a round native circle glyph so the moon stays legible.
+- Restore the previous receiver's wide, ripple-broken reflection. Its center
+  meanders gently, its path widens toward the foreground, and travelling water
+  texture determines which fragments catch the moonlight.
+
+## Caching and animation
+
+Cache the sky field, encoded sky rows and depth coordinates by viewport. Animate
+water across its full width with the previous receiver's travelling noise and
+perspective-dependent speed. Reflection and water share the same moving texture,
+so their motion stays connected. Do not freeze the sea outside the reflection
+band: that optimization removed the lateral motion that made the previous scene
+work.
+
+The cache retains at most four viewports and no playback history. Water fields
+and returned segments are newly created, so consumer mutations cannot damage
+cached data. The renderer adds no dependency, timer or GPU requirement.
+
+## Local measurements
+
+```sh
+npx tsx scripts/boat-lake/benchmark-ocean.mts
+```
+
+The immediately preceding renderer is frozen in
+`scripts/boat-lake/sumi-quadrants.mjs`. Each renderer receives 60 warm-up frames
+and 200 measured frames at matching dimensions. Measurements report scene setup,
+median and p95 CPU time, and average color-run counts. They exclude browser
+painting, Ink rendering and terminal I/O.
+
+Node v24.15.0 on this machine measured a 0.114 ms median and 0.145 ms p95
+for the current 100×14 renderer, versus 0.068 ms and 0.100 ms for the previous
+four-sample version. At 36×4, the current median was 0.015 ms versus 0.007 ms.
+Restoring full-surface motion does more work than animating only a narrow strip;
+these local CPU measurements exclude painting and terminal I/O.
+
+Tests cover terminal column widths, glyphs, continuous backgrounds, merged runs,
+a visible moon and reflected light throughout long playback at small sizes,
+water texture moving on both sides of the reflection, steady sky, monochrome,
+cache eviction, and mutation isolation. Water uses broad quadrant marks without
+forced bars or diagonal reflection shapes. The terminal snapshot is updated.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciphore/radiocli",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "A terminal-first world radio receiver built with Ink, mpv, and resilient public-radio providers.",
   "type": "module",
   "license": "MIT",
@@ -81,7 +81,8 @@
   },
   "dependencies": {
     "@homebridge/dbus-native": "^0.7.9",
-    "@modelcontextprotocol/server": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.3.1",
+    "chalk": "^5.6.2",
     "ink": "^7.0.5",
     "jsonc-parser": "^3.3.1",
     "react": "^19.2.6",