@onesi/genesis-cli 0.1.13 → 0.2.1

package/dist/onboard/caps.js

@@ -0,0 +1,232 @@
+/**
+ * What this terminal can do, decided once per setup run. Two passes:
+ *   1. detect(): environment only, synchronous, no I/O. Every "no" here is final (NO_COLOR, CI, a pipe, TERM=dumb,
+ *      --no-animation, GENESIS_REDUCED_MOTION, a screen reader).
+ *   2. probe(): asks the terminal itself, in one write, with a single deadline: the background colour (OSC 11),
+ *      synchronized output (DECRQM 2026), the Kitty graphics protocol, and primary device attributes (DA1, which also
+ *      reports sixel). DA1 goes last; every terminal answers it, so its reply ends the probe without waiting out the
+ *      deadline. Nothing is asked unless stdin and stdout are both a TTY.
+ * Only `genesis setup` (and a bare `genesis` on a TTY) load this module; normal commands never pay for it.
+ */
+import { execFile } from 'node:child_process';
+const truthy = (v) => v !== undefined && v !== '' && v !== '0' && v.toLowerCase() !== 'false';
+function version(v) {
+    return (v ?? '').split(/[.\-+]/).map((x) => Number.parseInt(x, 10)).filter((n) => Number.isFinite(n));
+}
+function atLeast(v, min) {
+    const have = version(v);
+    if (!have.length)
+        return false;
+    for (let i = 0; i < min.length; i++) {
+        const a = have[i] ?? 0;
+        if (a !== min[i])
+            return a > min[i];
+    }
+    return true;
+}
+/** Identify the emulator from what it advertises. tmux and screen hide the outer terminal, so they are their own kind. */
+export function terminalKind(env) {
+    const p = env.TERM_PROGRAM ?? '';
+    if (env.TMUX)
+        return 'tmux';
+    if (/^screen/.test(env.TERM ?? '') && !env.TERM_PROGRAM)
+        return 'screen';
+    if (env.KITTY_WINDOW_ID || env.TERM === 'xterm-kitty')
+        return 'kitty';
+    if (p === 'ghostty' || env.GHOSTTY_RESOURCES_DIR || env.TERM === 'xterm-ghostty')
+        return 'ghostty';
+    if (p === 'WezTerm' || env.WEZTERM_EXECUTABLE)
+        return 'wezterm';
+    if (p === 'iTerm.app' || env.LC_TERMINAL === 'iTerm2')
+        return 'iterm';
+    if (p === 'vscode')
+        return 'vscode';
+    if (p === 'Apple_Terminal')
+        return 'apple';
+    if (p === 'Hyper')
+        return 'hyper';
+    if (p === 'rio')
+        return 'rio';
+    if (env.WT_SESSION)
+        return 'windows-terminal';
+    if (env.ConEmuANSI === 'ON')
+        return 'conemu';
+    if (env.ALACRITTY_WINDOW_ID || env.ALACRITTY_LOG || env.TERM === 'alacritty')
+        return 'alacritty';
+    if (env.TERM === 'foot' || env.TERM === 'foot-extra')
+        return 'foot';
+    if (env.KONSOLE_VERSION)
+        return 'konsole';
+    if (env.VTE_VERSION)
+        return 'vte';
+    if (env.XTERM_VERSION)
+        return 'xterm';
+    if (env.MLTERM)
+        return 'mlterm';
+    return 'unknown';
+}
+export function detect(input) {
+    const { env } = input;
+    const term = terminalKind(env);
+    const dumb = env.TERM === 'dumb';
+    const ci = truthy(env.CI) || !!env.GITHUB_ACTIONS || !!env.BUILDKITE || !!env.GITLAB_CI || !!env.TF_BUILD;
+    const interactive = input.stdoutTTY && input.stdinTTY && !dumb && !ci;
+    // Colour: NO_COLOR wins over everything (no-color.org); FORCE_COLOR can raise a pipe, never past NO_COLOR.
+    let color = 0;
+    if (env.NO_COLOR === undefined || env.NO_COLOR === '') {
+        const force = env.FORCE_COLOR;
+        if (force !== undefined && force !== '')
+            color = force === '0' || force === 'false' ? 0 : force === '1' ? 4 : force === '2' ? 8 : 24;
+        else if (input.stdoutTTY && !dumb) {
+            const truecolor = /^(truecolor|24bit)$/i.test(env.COLORTERM ?? '')
+                || ['kitty', 'ghostty', 'wezterm', 'iterm', 'vscode', 'windows-terminal', 'alacritty', 'foot', 'konsole', 'rio', 'hyper'].includes(term)
+                || (term === 'vte' && Number(env.VTE_VERSION) >= 3600);
+            color = truecolor ? 24 : /256/.test(env.TERM ?? '') || term === 'apple' ? 8 : 4;
+        }
+    }
+    const screenReader = !!input.flags?.screenReader || truthy(env.GENESIS_SCREEN_READER) || truthy(env.ACCESSIBILITY);
+    const reduced = truthy(env.GENESIS_REDUCED_MOTION) || truthy(env.REDUCED_MOTION);
+    let stillBecause;
+    if (!input.stdoutTTY)
+        stillBecause = 'output is not a terminal';
+    else if (dumb)
+        stillBecause = 'TERM=dumb';
+    else if (ci)
+        stillBecause = 'CI';
+    else if (input.flags?.animation === false || truthy(env.GENESIS_NO_ANIMATION))
+        stillBecause = '--no-animation';
+    else if (reduced)
+        stillBecause = 'reduced motion';
+    else if (screenReader)
+        stillBecause = 'screen reader';
+    else if (color === 0)
+        stillBecause = 'NO_COLOR';
+    // The first locale variable that is set wins (POSIX order). Unset everywhere means a modern UTF-8 default; only an
+    // explicit non-UTF-8 locale (C, POSIX, ISO-8859-1, …) turns Unicode drawing off.
+    const lang = env.LC_ALL || env.LC_CTYPE || env.LANG || '';
+    const unicode = (input.platform ?? process.platform) === 'win32' ? term === 'windows-terminal' || term === 'vscode'
+        : !lang || /UTF-?8/i.test(lang);
+    const hyperlinks = input.stdoutTTY && !dumb && (truthy(env.FORCE_HYPERLINK)
+        || ['kitty', 'ghostty', 'wezterm', 'vscode', 'windows-terminal', 'foot', 'konsole', 'rio', 'alacritty'].includes(term)
+        || (term === 'iterm' && atLeast(env.TERM_PROGRAM_VERSION, [3, 1]))
+        || (term === 'vte' && Number(env.VTE_VERSION) >= 5000));
+    // OSC 9 is a notification on iTerm2/WezTerm/Ghostty but progress (9;4) on Windows Terminal/ConEmu; never mix them up.
+    const notify = !interactive ? null
+        : term === 'kitty' ? 'osc99'
+            : term === 'iterm' || term === 'wezterm' ? 'osc9'
+                : term === 'ghostty' || term === 'foot' || term === 'vte' || term === 'konsole' ? 'osc777' : null;
+    const progress = interactive && (term === 'windows-terminal' || term === 'conemu' || term === 'ghostty'
+        || (term === 'iterm' && atLeast(env.TERM_PROGRAM_VERSION, [3, 6])));
+    // Graphics are a probe result for Kitty/Ghostty (the reply proves it); iTerm2's protocol is advertised by name.
+    // Images are opt-in (GENESIS_SETUP_IMAGES=1) until the hand-off is verified on each emulator; text cells are the default.
+    const graphics = !interactive || color < 24 || !truthy(env.GENESIS_SETUP_IMAGES) ? null : term === 'iterm' || term === 'wezterm' ? 'iterm' : null;
+    return {
+        interactive, color, motion: !stillBecause, stillBecause, screenReader, unicode, hyperlinks, notify, progress, graphics,
+        imagesAllowed: truthy(env.GENESIS_SETUP_IMAGES),
+        sync: null, background: null, cell: null, dark: !/^(?:.*;)?(?:7|15)$/.test(env.COLORFGBG ?? ''), // COLORFGBG "0;15" means light
+        sound: !!input.flags?.sound || truthy(env.GENESIS_SOUND), screencast: !!input.flags?.screencast || truthy(env.GENESIS_SCREENCAST), term,
+        columns: input.columns ?? 80, rows: input.rows ?? 24,
+    };
+}
+/** Parse every reply the probe can receive. Pure, so the tests can feed it bytes from real terminals. */
+export function parseReplies(data) {
+    const out = { da1: false };
+    const bg = /\x1b\]11;rgba?:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})/i.exec(data);
+    if (bg) {
+        const ch = (h) => Math.round((Number.parseInt(h, 16) / (16 ** h.length - 1)) * 255);
+        out.background = { r: ch(bg[1]), g: ch(bg[2]), b: ch(bg[3]) };
+    }
+    const mode = /\x1b\[\?2026;(\d)\$y/.exec(data);
+    if (mode)
+        out.sync = mode[1] === '1' || mode[1] === '2';
+    if (/\x1b_Gi=31;OK\x1b\\/.test(data))
+        out.kitty = true;
+    const cell = /\x1b\[6;(\d+);(\d+)t/.exec(data);
+    if (cell && Number(cell[1]) > 0 && Number(cell[2]) > 0)
+        out.cell = { height: Number(cell[1]), width: Number(cell[2]) };
+    const da = /\x1b\[\?([\d;]+)c/.exec(data);
+    if (da) {
+        out.da1 = true;
+        out.sixel = da[1].split(';').includes('4');
+    }
+    return out;
+}
+const KITTY_QUERY = '\x1b_Gi=31,s=1,v=1,a=q,t=d,f=24;AAAA\x1b\\';
+/** The probe. The Kitty query is an APC string, so it goes only to emulators known to swallow APC. */
+export const probeFor = (term) => '\x1b]11;?\x1b\\' + '\x1b[?2026$p'
+    + (['kitty', 'ghostty', 'wezterm', 'konsole'].includes(term) ? KITTY_QUERY : '') + '\x1b[16t' + '\x1b[c';
+export const PROBE = probeFor('kitty');
+/** Ask the terminal. Resolves on the DA1 reply or after `timeoutMs`, restoring stdin exactly as it was. */
+export async function probe(caps, io, timeoutMs = 180) {
+    if (!caps.interactive || caps.term === 'screen')
+        return caps;
+    const { stdin, stdout } = io;
+    const wasRaw = stdin.isRaw;
+    let data = '';
+    await new Promise((resolve) => {
+        const done = () => { clearTimeout(timer); stdin.off('data', onData); resolve(); };
+        const onData = (chunk) => { data += chunk.toString('latin1'); if (parseReplies(data).da1)
+            done(); };
+        const timer = setTimeout(done, timeoutMs);
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            done();
+            return;
+        }
+        stdin.on('data', onData);
+        stdin.resume();
+        stdout.write(probeFor(caps.term));
+    });
+    try {
+        stdin.setRawMode(wasRaw);
+    }
+    catch { /* already closed */ }
+    stdin.pause();
+    const r = parseReplies(data);
+    const background = r.background ?? null;
+    const dark = background ? luminance(background) < 0.4 : caps.dark;
+    // Inside tmux, images and graphics replies belong to the outer terminal; keep text only.
+    const graphics = caps.term === 'tmux' || caps.color < 24 || !caps.imagesAllowed ? null
+        : r.kitty ? 'kitty' : caps.graphics ?? (r.sixel && SIXEL_RENDERS.includes(caps.term) ? 'sixel' : null);
+    return { ...caps, background, dark, sync: r.sync ?? null, cell: r.cell ?? null,
+        graphics: graphics === 'sixel' && !r.cell ? null : graphics };
+}
+/** DA1 "4" claims sixel, but some emulators (xterm.js without its image addon) claim it and draw nothing. Trust it only here. */
+const SIXEL_RENDERS = ['foot', 'konsole', 'windows-terminal', 'xterm', 'mlterm', 'contour'];
+export function luminance({ r, g, b }) {
+    const l = (c) => { const s = c / 255; return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4; };
+    return 0.2126 * l(r) + 0.7152 * l(g) + 0.0722 * l(b);
+}
+/**
+ * The desktop's own reduce-motion and screen-reader switches (macOS Accessibility, GNOME). Each answer is a short
+ * process with a deadline; a missing tool or a timeout just means "not set".
+ */
+export async function systemPreferences(platform = process.platform, run = runQuiet) {
+    if (platform === 'darwin') {
+        const [motion, vo] = await Promise.all([
+            run('defaults', ['read', 'com.apple.universalaccess', 'reduceMotion']),
+            run('pgrep', ['-xq', 'VoiceOver']).then((r) => (r === null ? null : 'running')),
+        ]);
+        return { reducedMotion: motion?.trim() === '1', screenReader: vo === 'running' };
+    }
+    if (platform === 'linux') {
+        const [anim, orca] = await Promise.all([
+            run('gsettings', ['get', 'org.gnome.desktop.interface', 'enable-animations']),
+            run('gsettings', ['get', 'org.gnome.desktop.a11y.applications', 'screen-reader-enabled']),
+        ]);
+        return { reducedMotion: anim?.trim() === 'false', screenReader: orca?.trim() === 'true' };
+    }
+    return { reducedMotion: false, screenReader: false };
+}
+function runQuiet(cmd, args, timeoutMs = 250) {
+    return new Promise((resolve) => {
+        try {
+            execFile(cmd, args, { timeout: timeoutMs, windowsHide: true }, (error, stdout) => resolve(error ? null : String(stdout)));
+        }
+        catch {
+            resolve(null);
+        }
+    });
+}

package/dist/onboard/encode.d.ts

@@ -0,0 +1,23 @@
+import { Canvas, type Color } from './raster.js';
+import type { ColorDepth } from './caps.js';
+/** Nearest xterm-256 colour: the 6×6×6 cube or the grey ramp, whichever is closer. */
+export declare function ansi256({ r, g, b }: Color): number;
+export declare function ansi16(c: Color): number;
+export declare function fg(c: Color, depth: ColorDepth): string;
+export declare function bg(c: Color, depth: ColorDepth): string;
+export interface CellOptions {
+    depth: ColorDepth;
+    background: Color | null;
+    unicode: boolean;
+}
+/** One string per text row. Runs of identical SGR are merged, so a frame stays small enough to draw at 60 fps. */
+export declare function toCells(cv: Canvas, o: CellOptions): string[];
+/** RGBA PNG of the canvas (straight alpha), for the Kitty and iTerm2 protocols. */
+export declare function png(cv: Canvas): Buffer;
+/** Kitty graphics: transmit and display at the cursor, `cols`×`rows` cells, chunked at 4096 bytes; the cursor does not move. */
+export declare function kittyImage(data: Buffer, cols: number, rows: number, id?: number): string;
+export declare const kittyDelete: (id?: number) => string;
+/** iTerm2 inline image (also WezTerm), sized in cells. */
+export declare function itermImage(data: Buffer, cols: number, rows: number): string;
+/** Sixel with a small palette: the background and up to 63 blends of each ink present. Background pixels are left transparent. */
+export declare function sixel(cv: Canvas, background: Color): string;

package/dist/onboard/encode.js

@@ -0,0 +1,235 @@
+/**
+ * Canvas → terminal. Text cells carry two pixels each (▀ with the top as foreground, the bottom as background), so a
+ * row of text is two rows of pixels. Edges are anti-aliased against the terminal's real background when the probe
+ * learned it (OSC 11), so a blended edge is the exact colour a browser would paint; when the background is unknown we
+ * never paint a cell's background at all and pick ▀, ▄ or █ by coverage instead, so nothing ever shows a box.
+ * Images (Kitty, iTerm2, sixel) get the same canvas at device resolution.
+ */
+import { deflateSync } from 'node:zlib';
+import { mix } from './raster.js';
+const ESC = '\x1b';
+function cube(v) { return v < 48 ? 0 : v < 115 ? 1 : Math.floor((v - 35) / 40); }
+/** Nearest xterm-256 colour: the 6×6×6 cube or the grey ramp, whichever is closer. */
+export function ansi256({ r, g, b }) {
+    const cr = cube(r), cg = cube(g), cb = cube(b);
+    const lv = [0, 95, 135, 175, 215, 255];
+    const cd = (lv[cr] - r) ** 2 + (lv[cg] - g) ** 2 + (lv[cb] - b) ** 2;
+    const grey = Math.max(0, Math.min(23, Math.round(((r + g + b) / 3 - 8) / 10)));
+    const gv = 8 + grey * 10, gd = (gv - r) ** 2 + (gv - g) ** 2 + (gv - b) ** 2;
+    return gd < cd ? 232 + grey : 16 + 36 * cr + 6 * cg + cb;
+}
+const BASIC = [[30, { r: 0, g: 0, b: 0 }], [31, { r: 205, g: 49, b: 49 }], [32, { r: 13, g: 188, b: 121 }], [33, { r: 229, g: 229, b: 16 }],
+    [34, { r: 36, g: 114, b: 200 }], [35, { r: 188, g: 63, b: 188 }], [36, { r: 17, g: 168, b: 205 }], [37, { r: 229, g: 229, b: 229 }],
+    [90, { r: 102, g: 102, b: 102 }], [91, { r: 241, g: 76, b: 76 }], [92, { r: 35, g: 209, b: 139 }], [93, { r: 245, g: 245, b: 67 }],
+    [94, { r: 59, g: 142, b: 234 }], [95, { r: 214, g: 112, b: 214 }], [96, { r: 41, g: 184, b: 219 }], [97, { r: 255, g: 255, b: 255 }]];
+export function ansi16(c) {
+    let best = 37, d = Infinity;
+    for (const [code, v] of BASIC) {
+        const e = (v.r - c.r) ** 2 + (v.g - c.g) ** 2 + (v.b - c.b) ** 2;
+        if (e < d) {
+            d = e;
+            best = code;
+        }
+    }
+    return best;
+}
+const isInk = (c) => c.r === 1 && c.g === 2 && c.b === 3; // art.DEFAULT_INK: the terminal's own foreground
+export function fg(c, depth) {
+    if (isInk(c))
+        return `${ESC}[39m`;
+    if (depth === 24)
+        return `${ESC}[38;2;${c.r};${c.g};${c.b}m`;
+    if (depth === 8)
+        return `${ESC}[38;5;${ansi256(c)}m`;
+    if (depth === 4)
+        return `${ESC}[${ansi16(c)}m`;
+    return '';
+}
+export function bg(c, depth) {
+    if (depth === 24)
+        return `${ESC}[48;2;${c.r};${c.g};${c.b}m`;
+    if (depth === 8)
+        return `${ESC}[48;5;${ansi256(c)}m`;
+    if (depth === 4)
+        return `${ESC}[${ansi16(c) + 10}m`;
+    return '';
+}
+/** One string per text row. Runs of identical SGR are merged, so a frame stays small enough to draw at 60 fps. */
+export function toCells(cv, o) {
+    const rows = [];
+    const THRESH = 0.5;
+    for (let y = 0; y < cv.height; y += 2) {
+        let line = '', last = '';
+        const put = (sgr, ch) => { if (sgr !== last) {
+            line += (last ? `${ESC}[0m` : '') + sgr;
+            last = sgr;
+        } line += ch; };
+        for (let x = 0; x < cv.width; x++) {
+            const t = cv.pixel(x, y), b = y + 1 < cv.height ? cv.pixel(x, y + 1) : { c: t.c, a: 0 };
+            if (t.a < 0.02 && b.a < 0.02) {
+                put('', ' ');
+                continue;
+            }
+            if (!o.unicode || o.depth === 0) {
+                // No colour (NO_COLOR) or no Unicode: the shape alone, in the terminal's own ink.
+                const on = Math.max(t.a, b.a) >= THRESH;
+                put('', on ? (o.unicode ? (t.a >= THRESH && b.a >= THRESH ? '█' : t.a >= THRESH ? '▀' : '▄') : '#') : ' ');
+                continue;
+            }
+            if (o.background) {
+                const bgc = o.background;
+                const top = mix(bgc, t.c, t.a), bot = mix(bgc, b.c, b.a);
+                if (b.a < 0.02)
+                    put(fg(top, o.depth), '▀');
+                else if (t.a < 0.02)
+                    put(fg(bot, o.depth), '▄');
+                else if (t.a > 0.98 && b.a > 0.98 && same(top, bot))
+                    put(fg(top, o.depth), '█');
+                else
+                    put(fg(top, o.depth) + bg(bot, o.depth), '▀');
+            }
+            else {
+                // Unknown background: never paint it. Partial edges keep their colour at full strength and are drawn only
+                // when at least half covered, so the silhouette stays honest.
+                const T = t.a >= THRESH, B = b.a >= THRESH;
+                if (T && B) {
+                    if (same(t.c, b.c))
+                        put(fg(t.c, o.depth), '█');
+                    else if (isInk(b.c))
+                        put(fg(b.c, o.depth) + bg(t.c, o.depth), '▄'); // the default ink can only be a foreground
+                    else
+                        put(fg(t.c, o.depth) + bg(b.c, o.depth), '▀');
+                }
+                else if (T)
+                    put(fg(t.c, o.depth), '▀');
+                else if (B)
+                    put(fg(b.c, o.depth), '▄');
+                else
+                    put('', ' ');
+            }
+        }
+        rows.push((line + (last ? `${ESC}[0m` : '')).replace(/ +$/, ''));
+    }
+    return rows;
+}
+const same = (a, b) => a.r === b.r && a.g === b.g && a.b === b.b;
+// ── images ─────────────────────────────────────────────────────────────────
+const CRC = (() => { const t = new Uint32Array(256); for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++)
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[n] = c >>> 0;
+} return t; })();
+function crc32(buf) { let c = 0xffffffff; for (const b of buf)
+    c = CRC[(c ^ b) & 255] ^ (c >>> 8); return (c ^ 0xffffffff) >>> 0; }
+function chunk(type, data) {
+    const len = Buffer.alloc(4);
+    len.writeUInt32BE(data.length);
+    const td = Buffer.concat([Buffer.from(type, 'ascii'), data]);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(td));
+    return Buffer.concat([len, td, crc]);
+}
+/** RGBA PNG of the canvas (straight alpha), for the Kitty and iTerm2 protocols. */
+export function png(cv) {
+    const { width: W, height: H } = cv;
+    const raw = Buffer.alloc((W * 4 + 1) * H);
+    for (let y = 0; y < H; y++) {
+        raw[y * (W * 4 + 1)] = 0;
+        for (let x = 0; x < W; x++) {
+            const { c, a } = cv.pixel(x, y), o = y * (W * 4 + 1) + 1 + x * 4;
+            raw[o] = c.r;
+            raw[o + 1] = c.g;
+            raw[o + 2] = c.b;
+            raw[o + 3] = Math.round(a * 255);
+        }
+    }
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(W, 0);
+    ihdr.writeUInt32BE(H, 4);
+    ihdr[8] = 8;
+    ihdr[9] = 6;
+    return Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), chunk('IHDR', ihdr), chunk('IDAT', deflateSync(raw, { level: 6 })), chunk('IEND', Buffer.alloc(0))]);
+}
+/** Kitty graphics: transmit and display at the cursor, `cols`×`rows` cells, chunked at 4096 bytes; the cursor does not move. */
+export function kittyImage(data, cols, rows, id = 4242) {
+    const b64 = data.toString('base64');
+    let out = '';
+    for (let i = 0; i < b64.length; i += 4096) {
+        const part = b64.slice(i, i + 4096), more = i + 4096 < b64.length ? 1 : 0;
+        out += i === 0 ? `${ESC}_Ga=T,f=100,q=2,i=${id},c=${cols},r=${rows},C=1,m=${more};${part}${ESC}\\` : `${ESC}_Gm=${more},q=2;${part}${ESC}\\`;
+    }
+    return out;
+}
+export const kittyDelete = (id = 4242) => `${ESC}_Ga=d,d=I,i=${id},q=2${ESC}\\`;
+/** iTerm2 inline image (also WezTerm), sized in cells. */
+export function itermImage(data, cols, rows) {
+    return `${ESC}]1337;File=inline=1;size=${data.length};width=${cols};height=${rows};preserveAspectRatio=1;doNotMoveCursor=1:${data.toString('base64')}\x07`;
+}
+/** Sixel with a small palette: the background and up to 63 blends of each ink present. Background pixels are left transparent. */
+export function sixel(cv, background) {
+    const { width: W, height: H } = cv;
+    const palette = [];
+    const index = new Map();
+    const idx = new Int16Array(W * H).fill(-1);
+    for (let y = 0; y < H; y++)
+        for (let x = 0; x < W; x++) {
+            const { c, a } = cv.pixel(x, y);
+            if (a < 0.03)
+                continue;
+            const q = (v) => Math.round(v / 16) * 16;
+            const m = mix(background, c, Math.round(a * 8) / 8), key = `${q(m.r)},${q(m.g)},${q(m.b)}`;
+            let n = index.get(key);
+            if (n === undefined) {
+                if (palette.length >= 255)
+                    n = nearest(palette, m);
+                else {
+                    n = palette.length;
+                    palette.push(m);
+                    index.set(key, n);
+                }
+            }
+            idx[y * W + x] = n;
+        }
+    let out = `${ESC}P0;1;0q"1;1;${W};${H}`;
+    palette.forEach((c, n) => { out += `#${n};2;${Math.round(c.r / 2.55)};${Math.round(c.g / 2.55)};${Math.round(c.b / 2.55)}`; });
+    for (let band = 0; band < H; band += 6) {
+        const used = new Set();
+        for (let y = band; y < Math.min(H, band + 6); y++)
+            for (let x = 0; x < W; x++)
+                if (idx[y * W + x] >= 0)
+                    used.add(idx[y * W + x]);
+        let first = true;
+        for (const n of used) {
+            out += (first ? '' : '$') + `#${n}`;
+            first = false;
+            let run = '', prev = '', count = 0;
+            const flush = () => { if (!count)
+                return; run += count > 3 ? `!${count}${prev}` : prev.repeat(count); };
+            for (let x = 0; x < W; x++) {
+                let bits = 0;
+                for (let k = 0; k < 6; k++) {
+                    const y = band + k;
+                    if (y < H && idx[y * W + x] === n)
+                        bits |= 1 << k;
+                }
+                const ch = String.fromCharCode(63 + bits);
+                if (ch === prev)
+                    count++;
+                else {
+                    flush();
+                    prev = ch;
+                    count = 1;
+                }
+            }
+            flush();
+            out += run;
+        }
+        out += '-';
+    }
+    return out + `${ESC}\\`;
+}
+function nearest(p, c) { let best = 0, d = Infinity; p.forEach((v, n) => { const e = (v.r - c.r) ** 2 + (v.g - c.g) ** 2 + (v.b - c.b) ** 2; if (e < d) {
+    d = e;
+    best = n;
+} }); return best; }

package/dist/onboard/eye.d.ts

@@ -0,0 +1,103 @@
+/**
+ * One's eye, from agent-eye.js (the One site's vendor/brand/agent-eye, engine sha256 83cc379a…): its geometry, pose
+ * math, easing curves and moments, ported line for line so the terminal eye blinks, glances and smiles on exactly the
+ * site's timing. Only the drawing is ours (raster.ts); the numbers are agent-eye's. The bar's painted-on-a-ball bend is
+ * left out: at terminal sizes it is under a tenth of a pixel.
+ */
+export declare const GEOMETRY: {
+    readonly radius: 100;
+    readonly barWidth: number;
+    readonly barHeight: number;
+    readonly cornerRadius: number;
+};
+export declare const MOTION: {
+    readonly maxTurn: 55;
+    readonly turnRadius: 70;
+    readonly foreshorten: 0.8;
+    readonly maxLift: 14;
+    readonly closedHeight: 7;
+    readonly lidSquash: 0.3;
+    readonly safeRadius: 89;
+    readonly smileLift: 2.5;
+    readonly smileSquint: 35;
+    readonly squeeze: 1;
+};
+export declare const MOUTH: {
+    readonly y: 66;
+    readonly halfWidth: 44;
+    readonly birthHalfWidth: 20;
+    readonly thickness: number;
+    readonly born: 3;
+    readonly follow: 0.6;
+};
+export interface Pose {
+    look: number;
+    lift: number;
+    open: number;
+    smile: number;
+    mouth: number;
+}
+export declare const REST: Pose;
+/** The bar for a pose, in the -100…100 head box: centre (x, y), width w, height h. */
+export declare function poseToBar(p: Partial<Pose>): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function poseToMouth(p: Partial<Pose>): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    o: number;
+} | null;
+export declare const EASE: {
+    readonly linear: readonly [0, 0, 1, 1];
+    readonly shut: readonly [0.6, 0, 0.9, 0.55];
+    readonly snap: readonly [0.1, 0.9, 0.25, 1];
+    readonly settle: readonly [0.3, 0, 0.3, 1];
+    readonly glide: readonly [0.45, 0, 0.25, 1];
+    readonly emerge: readonly [0.2, 0.6, 0.35, 1];
+    readonly charge: readonly [0.4, 0, 0.2, 1];
+    readonly exit: readonly [0.45, 0, 0.7, 0.9];
+    readonly enter: readonly [0.16, 1, 0.3, 1];
+    readonly leave: readonly [0.7, 0, 0.84, 0];
+};
+export type EaseName = keyof typeof EASE;
+export declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): (x: number) => number;
+export declare const ease: (name: EaseName, x: number) => number;
+/** A curve is [[seconds, value, ease into this key], …]. */
+export type Curve = readonly (readonly [number, number, EaseName?])[];
+export declare function sample(curve: Curve, t: number): number;
+export declare const curveEnd: (c: Curve) => number;
+/** agent-eye BLINK: 80 ms close, 50 ms shut, 170 ms open with a little overshoot. Multiplies openness. */
+export declare const BLINK: Curve;
+export declare const DOUBLE_BLINK: Curve;
+/** agent-eye SMILE, 2.9 s. */
+export declare const SMILE: {
+    smile: Curve;
+    mouth: Curve;
+};
+/** agent-eye RAINBOW_MOMENT's light, worn here in One's amber: it charges up the bar, holds, and leaves through the top. */
+export declare const LIGHT: Curve;
+/**
+ * The idle eye: agent-eye's alive mode in miniature. Blinks every 2.5–6 s (18 % of them double), glances now and then.
+ * Deterministic for a seed, so a recorded demo is the same every time.
+ */
+export declare class IdleEye {
+    private nextBlink;
+    private blinkAt;
+    private curve;
+    private lookFrom;
+    private lookTo;
+    private lookAt;
+    private nextGlance;
+    private rnd;
+    constructor(seed?: number);
+    /** Look toward x (-1…1) now, e.g. at the text it is waiting beside, or straight at you when the window regains focus. */
+    look(t: number, x: number): void;
+    blink(t: number, double?: boolean): void;
+    private lookNow;
+    pose(t: number): Pose;
+}