@ciphore/radiocli 0.2.4 → 0.2.6

package/dist/ui/visualizers/receiver-visualizers.js

@@ -1,8 +1,11 @@
 import { themeAccent, themeContributionColors } from '../theme.js';
+import { buildBoatLake } from './boat-lake.js';
+import { buildSumiOcean } from './sumi-ocean.js';
 import { retroReceiverBuilders } from './retro-receivers.js';
 import { receiverStyleMetadata } from './receiver-style-registry.js';
 const receiverStyleBuilders = {
     ...retroReceiverBuilders,
+    'boat-lake': buildBoatLake,
     ultracode: buildUltracode,
     'motion-contour': buildMotionContour,
     leds: buildLeds,
@@ -97,7 +100,9 @@ const microNativeScaleStyles = new Set([
     'galaxy',
     'cyclone',
     'fire',
-    'stormfront'
+    'stormfront',
+    'boat-lake',
+    'sumi-ocean'
 ]);
 function resampleVisualizer(rows, sourceWidth, sourceHeight, targetWidth, targetHeight, fallbackColor) {
     const source = Array.from({ length: sourceHeight }, (_, rowIndex) => visualCellsForLine(rows[rowIndex], sourceWidth, fallbackColor));
@@ -4078,12 +4083,6 @@ function buildPlanetarium(pulse, width, height, theme) {
     }
     return grid.map(row => lineFromCells(row, accent));
 }
-function receiverArtPalette(theme, colors) {
-    if (theme !== 'mono') {
-        return colors;
-    }
-    return ['#181818', '#303030', '#505050', '#777777', '#9a9a9a', '#bcbcbc', '#dddddd', '#ffffff'];
-}
 function receiverBandEnergy(pulse, startBand, samples = 6) {
     let total = 0;
     for (let index = 0; index < samples; index += 1) {
@@ -4091,107 +4090,6 @@ function receiverBandEnergy(pulse, startBand, samples = 6) {
     }
     return total / Math.max(1, samples);
 }
-/** A deep-perspective indigo ocean rendered with restrained sumi marks. */
-function buildSumiOcean(pulse, width, height, theme) {
-    const accent = themeAccent(theme);
-    const palette = receiverArtPalette(theme, ['#020817', '#06172c', '#092743', '#0d3c60', '#15567d', '#2777a1', '#66a9cc', '#d7edf5']);
-    const grid = emptyMotionGrid(width, height, palette[0] ?? '#020817');
-    const moonX = width * (0.73 + Math.sin(pulse * 0.006) * 0.015);
-    const moonY = height * 0.22;
-    const moonRadius = Math.max(1.1, height * 0.11);
-    for (let y = 0; y < height; y += 1) {
-        for (let x = 0; x < width; x += 1) {
-            const dx = (x - moonX) / 1.9;
-            const dy = y - moonY;
-            const distance = Math.sqrt(dx * dx + dy * dy);
-            if (distance <= moonRadius) {
-                grid[y][x] = { text: distance < moonRadius * 0.72 ? '█' : '▓', color: palette[7] ?? accent, bold: distance < moonRadius * 0.55 };
-            }
-            else if (hashNoise(x, y, 0) > 0.992) {
-                grid[y][x] = { text: '·', color: palette[5] ?? accent };
-            }
-        }
-    }
-    const horizon = 0.4;
-    const layers = [
-        { base: 0.42, amp: 0.035, cycles: 15, speed: 0.009, color: 2, glyph: '·' },
-        { base: 0.47, amp: 0.038, cycles: 12, speed: 0.012, color: 2, glyph: '░' },
-        { base: 0.53, amp: 0.042, cycles: 10, speed: 0.016, color: 3, glyph: '░' },
-        { base: 0.61, amp: 0.05, cycles: 8, speed: 0.021, color: 3, glyph: '▒' },
-        { base: 0.71, amp: 0.06, cycles: 6.5, speed: 0.027, color: 4, glyph: '▒' },
-        { base: 0.83, amp: 0.075, cycles: 5.2, speed: 0.034, color: 5, glyph: '▓' },
-        { base: 0.96, amp: 0.1, cycles: 4.2, speed: 0.042, color: 5, glyph: '█' }
-    ];
-    const bass = receiverBandEnergy(pulse, 2);
-    // The water plane grows darker and more textured toward the viewer. Far
-    // water is quiet and compressed at the horizon; nearby water occupies more
-    // screen space, producing a clear vanishing-depth read.
-    const horizonRow = Math.max(0, Math.round(height * horizon));
-    for (let y = horizonRow; y < height; y += 1) {
-        const depth = (y - horizonRow) / Math.max(1, height - 1 - horizonRow);
-        const colorIndex = Math.min(5, 2 + Math.floor(depth * 4));
-        for (let x = 0; x < width; x += 1) {
-            const texture = hashNoise(x, y, 41);
-            const glyph = texture > 0.975
-                ? ' '
-                : depth > 0.68
-                    ? texture > 0.48 ? '▓' : '▒'
-                    : depth > 0.32
-                        ? texture > 0.62 ? '▒' : '░'
-                        : texture > 0.76 ? '░' : '·';
-            grid[y][x] = { text: glyph, color: palette[colorIndex] ?? accent };
-        }
-    }
-    layers.forEach((layer, layerIndex) => {
-        for (let x = 0; x < width; x += 1) {
-            const nx = x / Math.max(1, width - 1);
-            const phase = nx * layer.cycles * Math.PI * 2 + pulse * layer.speed + layerIndex * 1.9;
-            const ridgeNoise = clampNumber(0.5 +
-                Math.sin(phase) * 0.27 +
-                Math.sin(phase * 1.83 + 0.9) * 0.16 +
-                Math.cos(phase * 3.2 - 0.4) * 0.07, 0, 1);
-            const near = layerIndex / Math.max(1, layers.length - 1);
-            const ridgeY = Math.round(height * (layer.base + layer.amp * (1 - ridgeNoise * 2) - (near > 0.7 ? bass * 0.018 : 0)));
-            const crest = layerIndex < 3 ? '─' : '━';
-            paintCell(grid, x, ridgeY, crest, palette[Math.min(6, layer.color + 1)] ?? accent);
-            if (ridgeY + 1 < height && layerIndex > 1) {
-                paintCell(grid, x, ridgeY + 1, layer.glyph, palette[layer.color] ?? accent);
-            }
-            if (layerIndex > 3 && ridgeY > 0 && (x + layerIndex * 3) % 13 < 3 + Math.floor(near * 3)) {
-                paintCell(grid, x, ridgeY - 1, layerIndex > 5 ? '▀' : '·', palette[6] ?? accent);
-            }
-        }
-    });
-    // A narrow moon path widens toward the foreground, reinforcing the same
-    // perspective even in short terminal viewports.
-    for (let y = horizonRow; y < height; y += 1) {
-        const depth = (y - horizonRow) / Math.max(1, height - 1 - horizonRow);
-        const reflectionHalfWidth = 1 + Math.floor(depth * Math.max(2, width * 0.045));
-        const center = Math.round(moonX + Math.sin(y * 2.1 + pulse * 0.025) * reflectionHalfWidth * 0.45);
-        for (let offset = -reflectionHalfWidth; offset <= reflectionHalfWidth; offset += 1) {
-            if (hashNoise(offset + 30, y, Math.floor(pulse / 12)) > 0.48 + depth * 0.14) {
-                paintCell(grid, center + offset, y, depth > 0.65 ? '━' : '─', palette[6] ?? accent);
-            }
-        }
-    }
-    // Two distant seabirds keep the horizon alive without making it busy.
-    const birdX = Math.round(width * (0.24 + 0.04 * Math.sin(pulse * 0.01)));
-    const birdY = Math.max(1, Math.round(height * 0.2));
-    paintCell(grid, birdX - 1, birdY, '⌁', palette[6] ?? accent);
-    paintCell(grid, birdX + 2, birdY + 1, '⌁', palette[5] ?? accent);
-    // A blue water plane beneath the block texture removes isolated black gaps
-    // while retaining the foreground-to-horizon depth bands.
-    for (let y = horizonRow; y < height; y += 1) {
-        const depth = (y - horizonRow) / Math.max(1, height - 1 - horizonRow);
-        const backgroundIndex = depth > 0.68 ? 3 : depth > 0.28 ? 2 : 1;
-        const backgroundColor = palette[backgroundIndex] ?? palette[1] ?? accent;
-        for (let x = 0; x < width; x += 1) {
-            const cell = grid[y][x];
-            grid[y][x] = { ...cell, backgroundColor };
-        }
-    }
-    return grid.map(row => lineFromCells(row, accent));
-}
 function rgbColor(red, green, blue) {
     const channel = (value) => Math.round(clampNumber(value, 0, 255)).toString(16).padStart(2, '0');
     return `#${channel(red)}${channel(green)}${channel(blue)}`;

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/dist/update-check.js

@@ -96,9 +96,10 @@ export function installUpdate(command = updateCommandForInstall().command) {
     });
 }
 export function updateShellForPlatform(platform, command) {
+    // Login profiles can replace PATH and select a different package-manager installation.
     return platform === 'win32'
         ? { command: 'cmd.exe', args: ['/d', '/s', '/c', command] }
-        : { command: 'sh', args: ['-lc', command] };
+        : { command: 'sh', args: ['-c', command] };
 }
 export function compareSemver(left, right) {
     const leftParts = semverParts(left);

package/docs/THIRD_PARTY_NOTICES.md

@@ -34,7 +34,9 @@ Earth vector data is public domain.
 
 ## node-airtunes2
 
-AirPlay support is provided as an optional integration with `node-airtunes2`
-2.5.0, distributed under the GNU Affero General Public License v3. Its source,
-license text, and attribution are available in the installed dependency and at
-<https://github.com/bertrandda/node-airtunes2>.
+AirPlay support uses a source copy of `node-airtunes2` 2.5.0, distributed under
+the GNU Affero General Public License v3, with RadioCLI's native Ed25519 security
+fix. The original attribution, license, complete native source, changes and
+archive provenance ship in `vendor/node-airtunes2/`. Runtime dependencies remain
+optional. See `vendor/node-airtunes2/RADIOCLI_PATCH.md` and the original project
+at <https://github.com/bertrandda/node-airtunes2>.

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.