@onesi/genesis-cli 0.1.13 → 0.2.0

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;
+}

package/dist/onboard/eye.js

@@ -0,0 +1,147 @@
+/**
+ * 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 const GEOMETRY = { radius: 100, barWidth: 200 / 9, barHeight: 400 / 3, cornerRadius: 200 / 45 };
+export const MOTION = { maxTurn: 55, turnRadius: 70, foreshorten: 0.8, maxLift: 14, closedHeight: 7, lidSquash: 0.3, safeRadius: 89, smileLift: 2.5, smileSquint: 35, squeeze: 1 };
+export const MOUTH = { y: 66, halfWidth: 44, birthHalfWidth: 20, thickness: 200 / 9, born: 3, follow: 0.6 };
+export const REST = { look: 0, lift: 0, open: 1, smile: 0, mouth: 0 };
+const DEG = Math.PI / 180;
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+/** The bar for a pose, in the -100…100 head box: centre (x, y), width w, height h. */
+export function poseToBar(p) {
+    const { look = 0, lift = 0, open = 1, smile = 0 } = p;
+    const turn = clamp(look, -1, 1) * MOTION.maxTurn * DEG;
+    const x = MOTION.turnRadius * Math.sin(turn);
+    const y = clamp(lift, -1, 1) * MOTION.maxLift - (MOTION.smileLift + MOTION.smileSquint / 2) * smile;
+    const shut = 1 - clamp(open, 0, 1);
+    const w = GEOMETRY.barWidth * (1 - MOTION.foreshorten * (1 - Math.cos(turn))) * (1 + MOTION.lidSquash * shut);
+    let h = Math.max(MOTION.closedHeight, MOTION.closedHeight + (GEOMETRY.barHeight - MOTION.closedHeight) * Math.max(0, open) - MOTION.smileSquint * smile);
+    h *= 1 - MOTION.squeeze * (1 - Math.sqrt(1 - (x / GEOMETRY.radius) ** 2));
+    // Keep the whole bar inside the safe radius (agent-eye fitHeight, without tilt).
+    const fits = (hh) => Math.hypot(Math.abs(x) + w / 2, Math.abs(y) + hh / 2) <= MOTION.safeRadius + GEOMETRY.cornerRadius;
+    if (!fits(h)) {
+        let lo = 0, hi = h;
+        for (let i = 0; i < 24; i++) {
+            const mid = (lo + hi) / 2;
+            if (fits(mid))
+                lo = mid;
+            else
+                hi = mid;
+        }
+        h = lo;
+    }
+    return { x, y, w, h };
+}
+export function poseToMouth(p) {
+    const m = Math.max(0, p.mouth ?? 0);
+    if (m === 0)
+        return null;
+    const turn = clamp(p.look ?? 0, -1, 1) * MOTION.maxTurn * DEG;
+    const half = (MOUTH.birthHalfWidth + (MOUTH.halfWidth - MOUTH.birthHalfWidth) * m) * (1 - 0.5 * (1 - Math.cos(turn)));
+    return { x: MOUTH.follow * MOTION.turnRadius * Math.sin(turn), y: MOUTH.y + MOUTH.born * (1 - Math.min(1, m)) + 0.5 * clamp(p.lift ?? 0, -1, 1) * MOTION.maxLift,
+        w: half * 2, h: MOUTH.thickness, o: clamp((m - 0.05) / 0.4, 0, 1) };
+}
+export const EASE = {
+    linear: [0, 0, 1, 1], shut: [0.6, 0, 0.9, 0.55], snap: [0.1, 0.9, 0.25, 1], settle: [0.3, 0, 0.3, 1],
+    glide: [0.45, 0, 0.25, 1], emerge: [0.2, 0.6, 0.35, 1], charge: [0.4, 0, 0.2, 1], exit: [0.45, 0, 0.7, 0.9],
+    // The site's motion curves (lib/motion CURVES): ease-out-expo for anything that arrives, ease-in-expo for leaving.
+    enter: [0.16, 1, 0.3, 1], leave: [0.7, 0, 0.84, 0],
+};
+export function cubicBezier(x1, y1, x2, y2) {
+    const cx = 3 * x1, bx = 3 * (x2 - x1) - cx, ax = 1 - cx - bx;
+    const cy = 3 * y1, by = 3 * (y2 - y1) - cy, ay = 1 - cy - by;
+    const sx = (t) => ((ax * t + bx) * t + cx) * t, sy = (t) => ((ay * t + by) * t + cy) * t;
+    const dx = (t) => (3 * ax * t + 2 * bx) * t + cx;
+    return (x) => {
+        if (x <= 0)
+            return 0;
+        if (x >= 1)
+            return 1;
+        let t = x;
+        for (let i = 0; i < 8; i++) {
+            const err = sx(t) - x;
+            if (Math.abs(err) < 1e-7)
+                return sy(t);
+            const d = dx(t);
+            if (Math.abs(d) < 1e-6)
+                break;
+            t -= err / d;
+        }
+        let lo = 0, hi = 1;
+        t = x;
+        while (hi - lo > 1e-7) {
+            if (sx(t) < x)
+                lo = t;
+            else
+                hi = t;
+            t = (lo + hi) / 2;
+        }
+        return sy(t);
+    };
+}
+const FN = Object.fromEntries(Object.entries(EASE).map(([k, v]) => [k, cubicBezier(v[0], v[1], v[2], v[3])]));
+export const ease = (name, x) => FN[name](x);
+export function sample(curve, t) {
+    if (t <= curve[0][0])
+        return curve[0][1];
+    for (let i = 1; i < curve.length; i++) {
+        const [t1, v1, e = 'linear'] = curve[i];
+        if (t < t1) {
+            const [t0, v0] = curve[i - 1];
+            return v0 + (v1 - v0) * FN[e]((t - t0) / (t1 - t0));
+        }
+    }
+    return curve[curve.length - 1][1];
+}
+export const curveEnd = (c) => c[c.length - 1][0];
+/** agent-eye BLINK: 80 ms close, 50 ms shut, 170 ms open with a little overshoot. Multiplies openness. */
+export const BLINK = [[0, 1], [0.08, 0, 'shut'], [0.13, 0], [0.3, 1.04, 'snap'], [0.42, 1, 'settle']];
+export const DOUBLE_BLINK = [[0, 1], [0.07, 0, 'shut'], [0.11, 0], [0.23, 1, 'snap'], [0.3, 1], [0.37, 0, 'shut'], [0.41, 0], [0.57, 1.04, 'snap'], [0.69, 1, 'settle']];
+/** agent-eye SMILE, 2.9 s. */
+export const SMILE = {
+    smile: [[0, 0], [0.36, 1, 'glide'], [1.3, 1], [1.46, 1.12, 'snap'], [1.76, 1, 'settle'], [2.2, 1], [2.7, -0.06, 'glide'], [2.9, 0, 'settle']],
+    mouth: [[0, 0], [0.2, 0], [0.46, 0.8, 'emerge'], [0.62, 1.04, 'snap'], [0.82, 1, 'settle'], [1.3, 1], [1.46, 1.05, 'snap'], [1.76, 1, 'settle'], [2.05, 1], [2.26, 0.12, 'glide'], [2.32, 0]],
+};
+/** agent-eye RAINBOW_MOMENT's light, worn here in One's amber: it charges up the bar, holds, and leaves through the top. */
+export const LIGHT = [[0, -1], [0.42, 0, 'charge'], [1.2, 0], [1.8, 1, 'exit']];
+/**
+ * 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 class IdleEye {
+    nextBlink;
+    blinkAt = -10;
+    curve = BLINK;
+    lookFrom = 0;
+    lookTo = 0;
+    lookAt = -10;
+    nextGlance;
+    rnd;
+    constructor(seed = 7) {
+        let s = seed >>> 0 || 1;
+        this.rnd = () => { s ^= s << 13; s >>>= 0; s ^= s >>> 17; s ^= s << 5; s >>>= 0; return s / 4294967296; };
+        this.nextBlink = 0.9 + this.rnd() * 1.2;
+        this.nextGlance = 2.2 + this.rnd() * 2;
+    }
+    /** 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, x) { this.lookFrom = this.lookNow(t); this.lookTo = x; this.lookAt = t; }
+    blink(t, double = false) { this.blinkAt = t; this.curve = double ? DOUBLE_BLINK : BLINK; this.nextBlink = t + 2.5 + this.rnd() * 3.5; }
+    lookNow(t) { const k = Math.min(1, (t - this.lookAt) / 0.22); return this.lookFrom + (this.lookTo - this.lookFrom) * ease('snap', Math.max(0, k)); }
+    pose(t) {
+        if (t >= this.nextBlink)
+            this.blink(t, this.rnd() < 0.18);
+        if (t >= this.nextGlance) {
+            const target = Math.abs(this.lookTo) > 0.1 ? 0 : (this.rnd() < 0.5 ? -1 : 1) * (0.45 + this.rnd() * 0.4);
+            this.look(t, target);
+            this.nextGlance = t + (target === 0 ? 2.5 + this.rnd() * 3 : 0.8 + this.rnd() * 1.1);
+            if (this.rnd() < 0.3)
+                this.blink(t);
+        }
+        const since = t - this.blinkAt;
+        const open = since >= 0 && since < curveEnd(this.curve) ? sample(this.curve, since) : 1;
+        return { ...REST, look: this.lookNow(t), open };
+    }
+}

package/dist/onboard/index.d.ts

@@ -0,0 +1,61 @@
+import type { AuthConfig } from '../auth.js';
+import type { CredentialStore } from '../store.js';
+import { type Caps } from './caps.js';
+import { type SetupState } from './state.js';
+import { type McpEnv } from './mcp.js';
+/** The two SDK calls setup makes, typed here so this module needs nothing from the SDK at load time. */
+export interface SetupClient {
+    whoami(): Promise<{
+        org: string;
+        principal?: string | null;
+        kind: string;
+    }>;
+    keys: {
+        create(org: string, body: {
+            name: string;
+            custody: 'reveal' | 'blinds';
+            scopes?: string[];
+        }): Promise<{
+            id: string;
+            value?: unknown;
+            blinds_credential_ref?: unknown;
+        }>;
+    };
+}
+export interface SetupDeps {
+    version: string;
+    env: Record<string, string | undefined>;
+    fetch: typeof fetch;
+    auth: AuthConfig;
+    getStore: () => Promise<CredentialStore>;
+    client: () => Promise<SetupClient>;
+    openBrowser: (url: string) => void;
+    baseUrl: string;
+    stdout?: NodeJS.WriteStream;
+    stdin?: NodeJS.ReadStream;
+    log: (s: string) => void;
+    flags: {
+        json?: boolean;
+        animation?: boolean;
+        screenReader?: boolean;
+        sound?: boolean;
+        screencast?: boolean;
+        restart?: boolean;
+        step?: string;
+        probe?: boolean;
+    };
+    login: {
+        startLogin: typeof import('../auth.js').startLogin;
+        completeLogin: typeof import('../auth.js').completeLogin;
+        selectSavedContext: typeof import('../auth.js').selectSavedContext;
+        savedLoginProvider: typeof import('../auth.js').savedLoginProvider;
+        startDeviceLogin: typeof import('../device-login.js').startDeviceLogin;
+        completeDeviceLogin: typeof import('../device-login.js').completeDeviceLogin;
+    };
+    mcpEnv?: McpEnv;
+    /** Tests pin the parade's cast and the clock-free copy. */
+    seed?: number;
+}
+export declare function capsFor(d: SetupDeps): Promise<Caps>;
+export declare function runSetup(d: SetupDeps): Promise<number>;
+export type { SetupState };