@onesi/genesis-cli 0.1.13 → 0.2.0

package/dist/onboard/ui.js

@@ -0,0 +1,615 @@
+/**
+ * Setup's pieces: the welcome (the hybrid ONE drawing itself, its O waking as One's eye and hopping through the Ones),
+ * type that arrives, choices with a rail that glides between rows in eighth-cell steps, a confirmation, a text field
+ * whose caret is the emblem's bar, and a waiting card where One's eye keeps you company.
+ *
+ * Every piece has a still form that is the same words in the same order, so reduced motion, screen readers, NO_COLOR,
+ * TERM=dumb and pipes get exactly the same setup.
+ */
+import { Canvas, hex, mix } from './raster.js';
+import { drawEmblem, drawLogotype, LOGO_ASPECT, LOGO_REST } from './art.js';
+import { ONES } from './brand.js';
+import { toCells, fg, kittyImage, itermImage, png, sixel, kittyDelete } from './encode.js';
+import { animate, Interrupted, width } from './term.js';
+import { BLINK, IdleEye, LIGHT, REST, SMILE, ease, sample } from './eye.js';
+const ESC = '\x1b';
+const FPS = 60;
+export class Style {
+    term;
+    tone;
+    ink;
+    mutedColor;
+    constructor(term) {
+        this.term = term;
+        const c = term.caps;
+        this.tone = c.background ? (c.dark ? 'dark' : 'light') : 'unknown';
+        this.ink = c.background && c.color >= 24 ? hex(c.dark ? '#f2f1ea' : '#191614') : null;
+        this.mutedColor = c.background && c.color >= 24 ? hex(c.dark ? '#b2afad' : '#625f5d') : null;
+    }
+    sgr(open, s) { return this.term.caps.color ? `${open}${s}${ESC}[0m` : s; }
+    bold = (s) => this.sgr(`${ESC}[1m`, s);
+    muted = (s) => this.mutedColor ? this.sgr(fg(this.mutedColor, 24), s) : this.sgr(`${ESC}[2m`, s);
+    /** Text partway through arriving: from the background toward ink, in linear light. */
+    arriving(s, k) {
+        if (k >= 1 || !this.term.caps.color)
+            return s;
+        if (this.ink && this.term.caps.background)
+            return `${fg(mix(this.term.caps.background, this.ink, ease('enter', k)), 24)}${s}${ESC}[0m`;
+        return k < 0.5 ? `${ESC}[2m${s}${ESC}[0m` : s;
+    }
+    error = (s) => this.sgr(`${ESC}[31m`, s);
+    get check() { return this.term.caps.unicode ? '✓' : 'ok'; }
+    get dot() { return this.term.caps.unicode ? '·' : '-'; }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Resolve when a key arrives or `ms` passes; true if a key cut it short. */
+async function wait(term, ms) {
+    const ac = new AbortController();
+    const k = term.key(ac.signal).then((key) => key.name !== 'abort');
+    const r = await Promise.race([k, sleep(ms).then(() => false)]);
+    ac.abort();
+    return r;
+}
+// ── welcome ────────────────────────────────────────────────────────────────
+/** Pick three Ones for the parade: random per run, fixed by GENESIS_DEMO_SEED so recordings repeat. */
+export function paradeCast(seed) {
+    let s = (seed ?? Math.floor(Math.random() * 2 ** 31)) >>> 0 || 1;
+    const rnd = () => { s = (s * 1103515245 + 12345) >>> 0; return s / 2 ** 32; };
+    const pool = [...ONES];
+    for (let i = pool.length - 1; i > 0; i--) {
+        const j = Math.floor(rnd() * (i + 1));
+        [pool[i], pool[j]] = [pool[j], pool[i]];
+    }
+    return pool.slice(0, 3);
+}
+/** The logotype's state at time t of the welcome. Pure, so the tests can check any frame. */
+export function welcomeAt(t, cast, short = false) {
+    const k = (a, d, e = 'enter') => ease(e, Math.min(1, Math.max(0, (t - a) / d)));
+    const reveal = { ring: k(0, 0.6), fill: 0, head: null, n: k(0.15, 0.52), e: k(0.26, 0.52) };
+    if (short) {
+        // Later runs: the logotype arrives and the O blinks once as One, then rests.
+        if (t < 0.85)
+            return { ...reveal, done: false };
+        if (t < 1.09)
+            return { ...LOGO_REST, fill: k(0.85, 0.24), done: false };
+        if (t < 1.6)
+            return { ...LOGO_REST, head: { one: null, pose: { ...REST, open: sample(BLINK, t - 1.12) } }, done: false };
+        if (t < 1.73)
+            return { ...LOGO_REST, fill: 1 - k(1.6, 0.13, 'leave'), done: false };
+        return { ...LOGO_REST, done: true };
+    }
+    if (t < 0.9)
+        return { ...reveal, done: false };
+    if (t < 1.14)
+        return { ...LOGO_REST, fill: k(0.9, 0.24), done: false };
+    const one = (pose, extra = {}) => ({ ...LOGO_REST, head: { one: null, pose: { ...REST, ...pose }, ...extra }, done: false });
+    const light = t < 3.0 ? sample(LIGHT, t - 1.2) : 1;
+    // wake: open from shut with the blink's snap, then glance right and back, then blink.
+    if (t < 2.9) {
+        const open = t < 1.31 ? sample(BLINK, 0.13 + (t - 1.14)) : t > 2.6 ? sample(BLINK, t - 2.6) : 1;
+        const look = t < 1.6 ? 0 : t < 2.3 ? 0.6 * k(1.6, 0.22, 'snap') : 0.6 * (1 - k(2.3, 0.22, 'snap'));
+        return one({ open, look }, { light });
+    }
+    // the parade: hop into each One (the cut on landing), then home.
+    const HOP = 0.42, start = 2.9, stops = [...cast, null];
+    if (t < start + HOP * stops.length) {
+        const i = Math.floor((t - start) / HOP), p = (t - start - i * HOP) / HOP;
+        const from = i === 0 ? null : stops[i - 1], to = stops[i];
+        const squat = p < 0.16 ? 1 - 0.12 * ease('glide', p / 0.16) : p < 0.24 ? 0.88 + 0.2 * ease('snap', (p - 0.16) / 0.08) : 1;
+        const air = p >= 0.2 && p < 0.62 ? Math.sin((Math.PI * (p - 0.2)) / 0.42) : 0;
+        const land = p >= 0.62 && p < 0.9 ? 1 - 0.1 * Math.sin((Math.PI * (p - 0.62)) / 0.28) : 1;
+        const shape = p < 0.62 ? from : to;
+        return { ...LOGO_REST, head: { one: shape, pose: { ...REST, lift: -0.8 * air, open: 1 }, hop: -16 * air, squash: squat * land }, done: false };
+    }
+    const after = t - (start + HOP * stops.length);
+    if (after < 0.5)
+        return one({ open: sample(BLINK, after - 0.08) });
+    if (after < 0.63)
+        return { ...LOGO_REST, fill: 1 - k(start + HOP * stops.length + 0.5, 0.13, 'leave'), done: false };
+    return { ...LOGO_REST, done: true };
+}
+export function hero(term, style) {
+    const cols = term.columns;
+    if (cols < 40 || !term.caps.unicode)
+        return null;
+    let px = Math.floor((cols - 6) / LOGO_ASPECT / 2) * 2;
+    px = Math.max(10, Math.min(20, px));
+    const w = Math.ceil(px * LOGO_ASPECT) + 2;
+    return {
+        rows: px / 2, px,
+        draw(state) {
+            const cv = new Canvas(w, px);
+            drawLogotype(cv, 1, 0, px, state, style.tone);
+            return toCells(cv, { depth: term.caps.color, background: term.caps.background, unicode: true });
+        },
+    };
+}
+/**
+ * The still logotype at device resolution where the terminal can show images (Kitty, iTerm2/WezTerm, sixel): the
+ * half-block animation pulls into focus as a crisp drawing in exactly the same cells.
+ */
+function heroImage(term, style, h) {
+    const g = term.caps.graphics;
+    if (!g)
+        return null;
+    const cell = term.caps.cell ?? { width: 9, height: 18 };
+    const cols = Math.ceil(h.px * LOGO_ASPECT) + 2, rows = h.rows;
+    const W = cols * cell.width, H = rows * cell.height;
+    const cv = new Canvas(W, H, 3);
+    const k = H / h.px; // device pixels per half-block pixel
+    drawLogotype(cv, k, 0, H, LOGO_REST, style.tone);
+    if (g === 'kitty')
+        return kittyImage(png(cv), cols, rows);
+    if (g === 'iterm')
+        return itermImage(png(cv), cols, rows);
+    return term.caps.background ? sixel(cv, term.caps.background) : null;
+}
+export async function welcome(term, style, opts) {
+    const h = hero(term, style);
+    const tag = opts.tagline;
+    if (!term.caps.motion || !h) {
+        if (h && !term.caps.screenReader) {
+            for (const l of h.draw(LOGO_REST))
+                term.say(l);
+            term.say();
+        }
+        for (const l of tag)
+            term.say(l);
+        return;
+    }
+    const cast = paradeCast(opts.seed);
+    let skipped = false, interrupted = false;
+    const ac = new AbortController();
+    term.key(ac.signal).then((k) => { if (k.name !== 'abort')
+        skipped = true; }, () => { skipped = interrupted = true; });
+    term.say();
+    await animate(FPS, (t) => {
+        const s = skipped ? { ...LOGO_REST, done: true } : welcomeAt(t, cast, opts.short);
+        term.frame(h.draw(s));
+        return !s.done;
+    });
+    ac.abort();
+    if (interrupted) {
+        term.commit();
+        throw new Interrupted();
+    }
+    const img = heroImage(term, style, h);
+    if (img) {
+        // Clear the half-block drawing and put the image in its cells; the cursor stays where text continues.
+        term.frame(Array(h.rows).fill(''));
+        term.write(`\r${h.rows > 1 ? `${ESC}[${h.rows - 1}A` : ''}${term.margin}${img}${ESC}[${h.rows - 1}B\r`);
+    }
+    term.commit();
+    term.say();
+    await typeLines(term, style, tag);
+}
+/** Lines that type themselves in: a little faster on spaces, a breath at punctuation, each glyph fading up to ink. */
+export async function typeLines(term, style, lines) {
+    if (!term.caps.motion) {
+        for (const l of lines)
+            term.say(l);
+        return;
+    }
+    for (const line of lines) {
+        const plain = [...line];
+        if (/\x1b/.test(line) || !plain.length) {
+            term.say(line);
+            continue;
+        }
+        const at = [];
+        let clock = 0;
+        for (const ch of plain) {
+            at.push(clock);
+            clock += ch === ' ' ? 0.008 : /[.,:;—]/.test(ch) ? 0.05 : 0.014;
+        }
+        let skipped = false, interrupted = false;
+        const ac = new AbortController();
+        term.key(ac.signal).then((k) => { if (k.name !== 'abort')
+            skipped = true; }, () => { skipped = interrupted = true; });
+        const FADE = 0.12;
+        await animate(FPS, (t) => {
+            if (skipped)
+                t = clock + FADE;
+            let s = '';
+            for (let i = 0; i < plain.length; i++) {
+                if (at[i] > t)
+                    break;
+                s += style.arriving(plain[i], (t - at[i]) / FADE);
+            }
+            term.frame([s]);
+            return t < clock + FADE;
+        });
+        ac.abort();
+        term.commit();
+        if (interrupted)
+            throw new Interrupted();
+    }
+}
+const EIGHTHS = ['', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+/**
+ * One row's rail cell when the rail (one row tall) sits at fractional row `pos`. Lower eighths draw the rail coming in
+ * from below; reverse video of the same glyphs draws it leaving through the bottom (the terminal swaps its own ink
+ * and paper, so this works without knowing either).
+ */
+export function railCell(row, pos) {
+    const d = pos - row;
+    if (d <= -1 || d >= 1)
+        return ' ';
+    if (d >= 0) {
+        const n = Math.round((1 - d) * 8);
+        return n <= 0 ? ' ' : n >= 8 ? '█' : EIGHTHS[n];
+    }
+    // The rail's foot is in this cell's top part: reverse video of a lower block leaves the top (8 − n)/8 in ink.
+    const n = Math.round(-d * 8);
+    return n <= 0 ? '█' : n >= 8 ? ' ' : `${ESC}[7m${EIGHTHS[n]}${ESC}[27m`;
+}
+export async function select(term, style, q) {
+    const opts = q.options;
+    let idx = Math.max(0, Math.min(opts.length - 1, q.initial ?? 0));
+    while (opts[idx]?.disabled && idx < opts.length - 1)
+        idx++;
+    const footer = '    ' + style.muted(`↑↓ choose  enter ok${q.skippable ? '  s skip' : ''}`);
+    if (term.caps.screenReader || !term.caps.interactive) {
+        term.say(q.title);
+        opts.forEach((o, i) => term.say(`  ${i + 1}. ${o.label}${o.hint ? ` (${o.hint})` : ''}${i === idx ? ' [default]' : ''}`));
+        if (!term.caps.interactive)
+            return opts[idx].value;
+        term.say(`Type a number and press enter${q.skippable ? ', or s to skip' : ''}. Enter alone takes the default.`);
+        let buf = '';
+        for (;;) {
+            const k = await term.key();
+            if (k.name === 'enter') {
+                const n = buf ? Number(buf) - 1 : idx;
+                if (opts[n] && !opts[n].disabled) {
+                    term.say(`  ${opts[n].label}`);
+                    return opts[n].value;
+                }
+                buf = '';
+                continue;
+            }
+            if (q.skippable && k.name === 's') {
+                term.say('  Skipped');
+                return 'skip';
+            }
+            if (k.ch && /\d/.test(k.ch))
+                buf += k.ch;
+            if (k.name === 'backspace')
+                buf = buf.slice(0, -1);
+        }
+    }
+    let pos = idx, from = idx, moveAt = -1;
+    const t0 = performance.now();
+    const now = () => (performance.now() - t0) / 1000;
+    const render = () => {
+        const t = now();
+        if (moveAt >= 0 && term.caps.motion) {
+            const p = Math.min(1, (t - moveAt) / 0.16);
+            pos = from + (idx - from) * ease('snap', p);
+            if (p >= 1)
+                moveAt = -1;
+        }
+        else
+            pos = idx;
+        term.frame([style.bold(q.title), ...opts.map((o, i) => {
+                const label = o.disabled ? style.muted(o.label) : i === idx ? style.bold(o.label) : o.label;
+                return `  ${railCell(i, pos)} ${label}${o.hint ? '  ' + style.muted(o.hint) : ''}`;
+            }), footer]);
+    };
+    render();
+    let running = true;
+    const loop = term.caps.motion ? animate(FPS, () => { if (moveAt >= 0)
+        render(); return running; }) : Promise.resolve();
+    try {
+        for (;;) {
+            const k = await term.key();
+            const step = (d) => { let n = idx; do
+                n = (n + d + opts.length) % opts.length;
+            while (opts[n].disabled && n !== idx); from = pos; idx = n; moveAt = now(); render(); };
+            if (k.name === 'up' || k.name === 'k' || k.name === 'backtab')
+                step(-1);
+            else if (k.name === 'down' || k.name === 'j' || k.name === 'tab')
+                step(1);
+            else if (k.ch && /^[1-9]$/.test(k.ch) && opts[Number(k.ch) - 1] && !opts[Number(k.ch) - 1].disabled) {
+                from = pos;
+                idx = Number(k.ch) - 1;
+                moveAt = now();
+                render();
+            }
+            else if (k.name === 'enter' || k.name === 'space') {
+                running = false;
+                await loop;
+                term.frame([`${style.bold(q.title)} ${style.muted(opts[idx].label)}`]);
+                term.commit();
+                return opts[idx].value;
+            }
+            else if (q.skippable && (k.name === 's' || k.name === 'escape')) {
+                running = false;
+                await loop;
+                term.frame([`${style.bold(q.title)} ${style.muted('skipped')}`]);
+                term.commit();
+                return 'skip';
+            }
+        }
+    }
+    finally {
+        running = false;
+    }
+}
+export async function confirm(term, style, question, initial) {
+    const hint = initial ? 'Y/n' : 'y/N';
+    if (!term.caps.interactive) {
+        term.say(`${question} ${initial ? 'yes' : 'no'}`);
+        return initial;
+    }
+    if (term.caps.screenReader)
+        term.say(`${question} (${hint})`);
+    else
+        term.frame([`${style.bold(question)} ${style.muted(hint)}`]);
+    for (;;) {
+        const k = await term.key();
+        const answer = k.name === 'enter' ? initial : k.name === 'y' ? true : k.name === 'n' || k.name === 'escape' || k.name === 's' ? false : null;
+        if (answer === null)
+            continue;
+        if (term.caps.screenReader)
+            term.say(answer ? 'yes' : 'no');
+        else {
+            term.frame([`${style.bold(question)} ${style.muted(answer ? 'yes' : 'no')}`]);
+            term.commit();
+        }
+        return answer;
+    }
+}
+/** A one-line field. The caret is a steady bar (DECSCUSR 6), the emblem's bar; typed letters fade up to ink. */
+export async function input(term, style, q) {
+    if (!term.caps.interactive) {
+        term.say(`${q.label} ${q.initial}`);
+        return q.initial;
+    }
+    let value = '', error = null;
+    const born = [];
+    const t0 = performance.now(), now = () => (performance.now() - t0) / 1000;
+    term.cursor(true);
+    term.cursorShape(6);
+    const render = () => {
+        const shown = value ? [...value].map((ch, i) => style.arriving(ch, (now() - born[i]) / 0.12)).join('') : style.muted(q.initial);
+        const line = `${style.bold(q.label)} ${shown}`;
+        const lines = [line, error ? style.error(error) : style.muted('enter ok')];
+        term.frame(lines);
+        // Put the real caret after the typed text: up one line, to the column.
+        const col = width(`${q.label} `) + width(value);
+        term.write(`${ESC}[1A\r${col ? `${ESC}[${col}C` : ''}`);
+    };
+    let running = true;
+    const anim = term.caps.motion ? animate(FPS, () => { if (born.length && now() - born[born.length - 1] < 0.15) {
+        term.write(`${ESC}[1B`);
+        render();
+    } return running; }) : Promise.resolve();
+    render();
+    try {
+        for (;;) {
+            const k = await term.key();
+            if (k.name === 'enter') {
+                const v = value || q.initial, e = q.validate?.(v) ?? null;
+                if (e) {
+                    error = e;
+                    term.write(`${ESC}[1B`);
+                    render();
+                    continue;
+                }
+                running = false;
+                await anim;
+                term.write(`${ESC}[1B`);
+                term.frame([`${style.bold(q.label)} ${style.muted(v)}`]);
+                term.commit();
+                return v;
+            }
+            if (k.name === 'backspace') {
+                value = [...value].slice(0, -1).join('');
+                born.pop();
+            }
+            else if (k.name === 'paste' && k.ch) {
+                for (const ch of k.ch.replace(/[\r\n\t\x00-\x1f\x7f]/g, '')) {
+                    value += ch;
+                    born.push(now());
+                }
+            }
+            else if (k.ch && !k.ctrl && k.name !== 'space') {
+                value += k.ch;
+                born.push(now());
+            }
+            else if (k.name === 'space') {
+                value += ' ';
+                born.push(now());
+            }
+            else if (k.name === 'escape') {
+                value = '';
+                born.length = 0;
+            }
+            error = null;
+            term.write(`${ESC}[1B`);
+            render();
+        }
+    }
+    finally {
+        running = false;
+        term.cursorShape(0);
+        term.cursor(!term.caps.motion);
+    }
+}
+/**
+ * Wait for `task` beside One's eye. The eye idles as on the site (blinks, glances at the text), turns to look at you
+ * when you come back to the window, and the tab shows indeterminate progress. Keys in `keys` end the wait early and
+ * are returned (e.g. "d" to switch to a device code); Ctrl-C stops setup, resumably.
+ */
+export async function waitBeside(term, style, lines, task, keys = []) {
+    term.progress(3);
+    if (!term.caps.interactive || !term.caps.motion || term.caps.screenReader || !term.caps.unicode) {
+        for (const l of lines())
+            term.say(l);
+        const ac = new AbortController();
+        const keyP = term.caps.interactive ? keyMatching(term, keys, ac.signal) : new Promise(() => { });
+        try {
+            return await Promise.race([task.then((value) => ({ value })), keyP.then((key) => ({ key }))]);
+        }
+        finally {
+            ac.abort();
+            term.progress(0);
+        }
+    }
+    const eye = new IdleEye(11);
+    const t0 = performance.now(), now = () => (performance.now() - t0) / 1000;
+    const onFocus = (f) => { if (f) {
+        eye.look(now(), 0);
+        eye.blink(now() + 0.25);
+    } };
+    term.focusListeners.add(onFocus);
+    let result;
+    task.then((value) => { result = { value }; }, () => { result = result ?? {}; });
+    const ac = new AbortController();
+    let interrupted = false;
+    keyMatching(term, keys, ac.signal).then((key) => { if (key.name !== 'abort')
+        result = { key }; }, () => { interrupted = true; });
+    const PX = 13; // odd, centred on a pixel, so the bar lands on whole pixel columns
+    try {
+        await animate(30, (t) => {
+            // PX is odd and the disc is centred on a pixel's middle, so the eye lands on a whole column.
+            const cv = new Canvas(PX, PX + 1);
+            drawEmblem(cv, PX / 2, (PX + 1) / 2, PX, { pose: eye.pose(t) }, style.tone);
+            const art = toCells(cv, { depth: term.caps.color, background: term.caps.background, unicode: true });
+            const text = lines();
+            const top = Math.max(0, Math.floor((art.length - text.length) / 2));
+            term.frame(art.map((a, i) => `${a}${' '.repeat(Math.max(0, PX - width(a)))}   ${text[i - top] ?? ''}`).concat(text.slice(art.length - top)));
+            return !result && !interrupted;
+        });
+    }
+    finally {
+        term.focusListeners.delete(onFocus);
+        ac.abort();
+        term.progress(0);
+    }
+    if (interrupted)
+        throw new Interrupted();
+    if (result?.value !== undefined || result?.key) {
+        term.commit();
+        return result;
+    }
+    term.commit();
+    return { value: await task };
+}
+async function keyMatching(term, names, signal) {
+    for (;;) {
+        const k = await term.key(signal);
+        if (k.name === 'abort' || names.includes(k.name))
+            return k;
+    }
+}
+/** The moment it works: One smiles, and the light fills the eye and leaves. */
+export async function delight(term, style, line) {
+    if (!term.caps.motion || !term.caps.unicode) {
+        term.say(line);
+        return;
+    }
+    const PX = 13;
+    await animate(FPS, (t) => {
+        const cv = new Canvas(PX, PX + 1);
+        const pose = { ...REST, smile: sample(SMILE.smile, t), mouth: sample(SMILE.mouth, t) };
+        drawEmblem(cv, PX / 2, (PX + 1) / 2, PX, { pose, light: sample(LIGHT, t - 0.1) }, style.tone);
+        const art = toCells(cv, { depth: term.caps.color, background: term.caps.background, unicode: true });
+        const mid = Math.floor(art.length / 2);
+        term.frame(art.map((a, i) => `${a}${' '.repeat(Math.max(0, PX - width(a)))}   ${i === mid ? style.arriving(line, t / 0.3) : ''}`));
+        return t < 2.0;
+    });
+    term.commit();
+}
+export { kittyDelete };
+/** Several choices at once (space toggles, a selects all, enter confirms). Screen readers type numbers. */
+export async function pick(term, style, q) {
+    const opts = q.options.map((o) => ({ ...o }));
+    const box = (on) => term.caps.unicode ? (on ? '◉' : '○') : on ? '[x]' : '[ ]';
+    if (term.caps.screenReader || !term.caps.interactive) {
+        term.say(q.title);
+        opts.forEach((o, i) => term.say(`  ${i + 1}. ${o.label}${o.hint ? ` (${o.hint})` : ''}${o.checked ? ' [selected]' : ''}`));
+        if (!term.caps.interactive)
+            return opts.filter((o) => o.checked && !o.disabled).map((o) => o.value);
+        term.say('Type numbers to toggle, then press enter. Enter alone keeps the selection.');
+        let buf = '';
+        for (;;) {
+            const k = await term.key();
+            if (k.ch && /\d/.test(k.ch)) {
+                buf += k.ch;
+                continue;
+            }
+            if (k.name === 'enter') {
+                if (!buf) {
+                    const chosen = opts.filter((o) => o.checked && !o.disabled);
+                    term.say(`  ${chosen.map((o) => o.label).join(', ') || 'none'}`);
+                    return chosen.map((o) => o.value);
+                }
+                const o = opts[Number(buf) - 1];
+                buf = '';
+                if (o && !o.disabled) {
+                    o.checked = !o.checked;
+                    term.say(`  ${o.label} ${o.checked ? 'selected' : 'not selected'}`);
+                }
+            }
+        }
+    }
+    let idx = Math.max(0, opts.findIndex((o) => !o.disabled));
+    const render = () => term.frame([style.bold(q.title), ...opts.map((o, i) => {
+            const mark = o.disabled ? style.muted(box(false)) : box(o.checked);
+            const label = o.disabled ? style.muted(o.label) : i === idx ? style.bold(o.label) : o.label;
+            return `  ${railCell(i, idx)} ${mark} ${label}${o.hint ? '  ' + style.muted(o.hint) : ''}`;
+        }), '    ' + style.muted('space toggle  a all  enter ok')]);
+    render();
+    for (;;) {
+        const k = await term.key();
+        const move = (d) => { let n = idx; do
+            n = (n + d + opts.length) % opts.length;
+        while (opts[n].disabled && n !== idx); idx = n; };
+        if (k.name === 'up' || k.name === 'k')
+            move(-1);
+        else if (k.name === 'down' || k.name === 'j' || k.name === 'tab')
+            move(1);
+        else if (k.name === 'space' && !opts[idx].disabled)
+            opts[idx].checked = !opts[idx].checked;
+        else if (k.name === 'a') {
+            const all = opts.every((o) => o.disabled || o.checked);
+            for (const o of opts)
+                if (!o.disabled)
+                    o.checked = !all;
+        }
+        else if (k.name === 'enter') {
+            const chosen = opts.filter((o) => o.checked && !o.disabled);
+            term.frame([`${style.bold(q.title)} ${style.muted(chosen.map((o) => o.label).join(', ') || 'none')}`]);
+            term.commit();
+            return chosen.map((o) => o.value);
+        }
+        else if (k.name === 'escape' || k.name === 's') {
+            term.frame([`${style.bold(q.title)} ${style.muted('skipped')}`]);
+            term.commit();
+            return [];
+        }
+        render();
+    }
+}
+/**
+ * A short wait on one line: the emblem's bar blinking on agent-eye's timing (its lid closing as lower eighth blocks),
+ * then the line resolves to its result. Still terminals print the label once.
+ */
+export async function busy(term, style, label, task) {
+    if (!term.caps.motion || !term.caps.unicode) {
+        term.say(style.muted(label + '…'));
+        return task;
+    }
+    let settled = false;
+    task.then(() => { settled = true; }, () => { settled = true; });
+    const eye = new IdleEye(5);
+    await animate(30, (t) => {
+        const open = Math.max(0, Math.min(1, eye.pose(t).open));
+        const n = Math.round(open * 8);
+        term.frame([`${n >= 8 ? '█' : EIGHTHS[n] || ' '} ${style.muted(label)}`]);
+        return !settled;
+    });
+    term.frame([]);
+    return task;
+}

package/dist/orgs.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from 'commander';
+import type { Genesis } from '@onesi/genesis';
+type Dependencies = {
+    client: () => Promise<Genesis>;
+    emit: (data: unknown, pretty: () => string) => void;
+    signal?: AbortSignal;
+};
+/** Orgs accepts documents of 1 byte to 5 MiB (sent as base64 in JSON). */
+export declare const ORGS_MAX_DOCUMENT_BYTES: number;
+/**
+ * The Orgs commands that are more than one JSON request: uploading a document from a file, downloading
+ * a document's bytes to a path (checked against its sha256), and requesting formation with --dry-run.
+ * Every other Orgs operation is a generic command under `genesis orgs` (products.ts).
+ */
+export declare function registerOrgs(program: Command, deps: Dependencies): void;
+export {};