@onesi/genesis-cli 0.1.13 → 0.2.0

package/dist/onboard/art.js

@@ -0,0 +1,139 @@
+/**
+ * One's marks as drawings: the emblem (Digital One, the disc with the eye knocked out), the Ones, and the hybrid ONE
+ * logotype whose O can close to the disc, wake as the eye, hop through the Ones and open back to the ring (JR-B103's
+ * cycle, the One site's components/ui/nav-logotype.tsx). Everything is drawn into a raster.Canvas from brand.ts.
+ *
+ * Paint rules (one-system.css): the disc is One's black on light and chalk on dark, never outlined or glowing; amber
+ * is only ever light inside the eye; the Ones wear their own colours, and those colours mean nothing else.
+ */
+import { AMBER, DISC, INK, LOGOTYPE, NIGHT_INK, ONES } from './brand.js';
+import { circle, hex, mix, mul, parsePath, roundRect, scale, translate } from './raster.js';
+import { GEOMETRY, poseToBar, poseToMouth, sample, LIGHT, REST } from './eye.js';
+/**
+ * The terminal's own foreground. When the probe could not learn the background we draw ink and Digital One in this
+ * colour and the encoder emits SGR 39, so the mark is always the user's own ink: black on light, chalk on dark.
+ */
+export const DEFAULT_INK = { r: 1, g: 2, b: 3 };
+export const isDefaultInk = (c) => c.r === 1 && c.g === 2 && c.b === 3;
+export const inkFor = (tone) => tone === 'unknown' ? DEFAULT_INK : hex(tone === 'dark' ? NIGHT_INK : INK);
+const discFor = (tone) => tone === 'unknown' ? DEFAULT_INK : hex(tone === 'dark' ? DISC.chalk : DISC.black);
+/** Clip a convex polygon to y in [y0, y1] (Sutherland–Hodgman on two half-planes). */
+function clipY(poly, y0, y1) {
+    const pass = (p, keep, edge) => {
+        const out = [];
+        for (let i = 0; i < p.length; i++) {
+            const a = p[i], b = p[(i + 1) % p.length], ia = keep(a[1]), ib = keep(b[1]);
+            if (ia)
+                out.push(a);
+            if (ia !== ib) {
+                const t = (edge - a[1]) / (b[1] - a[1]);
+                out.push([a[0] + (b[0] - a[0]) * t, edge]);
+            }
+        }
+        return out;
+    };
+    return pass(pass(poly, (y) => y >= y0, y0), (y) => y <= y1, y1);
+}
+/** Draw a head into the -100…100 box mapped by `m`. */
+export function drawHead(cv, m, head, tone) {
+    const sq = head.squash ?? 1, lift = head.hop ?? 0;
+    const pivot = 100; // the head stands on its foot: squash about y = +100
+    const body = mul(m, mul(translate(0, pivot + lift), mul(scale(1 / Math.sqrt(sq), sq), translate(0, -pivot))));
+    const one = head.one;
+    const eyeM = one ? mul(body, mul(translate(one.eye.x, one.eye.y), scale(one.eye.scale))) : body;
+    const pose = one ? { ...head.pose, open: head.pose.open * one.eye.openScale, look: head.pose.look * one.eye.lookGain } : head.pose;
+    const bar = poseToBar(pose);
+    const r = Math.min(GEOMETRY.cornerRadius, bar.h / 2, bar.w / 2);
+    const barPoly = roundRect(bar.x, bar.y, bar.w, bar.h, r);
+    const mouth = poseToMouth(pose);
+    const mouthPoly = mouth ? roundRect(mouth.x, mouth.y, mouth.w, mouth.h, GEOMETRY.cornerRadius) : null;
+    const toBody = (p) => p.map(([x, y]) => [eyeM[0] * x + eyeM[2] * y + eyeM[4], eyeM[1] * x + eyeM[3] * y + eyeM[5]]);
+    if (!one) {
+        // Digital One: the disc with the eye (and smile) knocked out, as the still emblem's even-odd cut.
+        const disc = circle(0, 0, 100).map(([x, y]) => [body[0] * x + body[2] * y + body[4], body[1] * x + body[3] * y + body[5]]);
+        cv.fill([disc, toBody(barPoly), ...(mouthPoly ? [toBody(mouthPoly)] : [])], discFor(tone), undefined, 'evenodd');
+    }
+    else {
+        cv.fill(parsePath(one.d), hex(one.colour), body);
+        cv.fill([toBody(barPoly), ...(mouthPoly ? [toBody(mouthPoly)] : [])], hex(one.eyeColour));
+    }
+    drawLight(cv, toBody, bar, head.light ?? -1);
+}
+/**
+ * The eye fills with light: a band rises up the bar behind a pale front, holds, and leaves through the top
+ * (agent-eye's rainbow, in One's amber). Drawn as strips so the light can grade from amber at its foot to soft amber.
+ */
+function drawLight(cv, toBody, bar, light) {
+    const amount = 1 - Math.min(1, Math.abs(light));
+    if (amount <= 0.001)
+        return;
+    const top = bar.y - bar.h / 2, bottom = bar.y + bar.h / 2, H = bar.h;
+    // rising: the band's top climbs from the foot; leaving: its foot follows it out of the top.
+    const bandTop = light < 0 ? bottom - H * (1 + light) * 1.02 : top - 2;
+    const bandBottom = light < 0 ? bottom + 2 : bottom - H * light * 1.02;
+    const shape = roundRect(bar.x, bar.y, bar.w, bar.h, Math.min(GEOMETRY.cornerRadius, bar.h / 2, bar.w / 2));
+    const amber = hex(AMBER.amber), soft = hex(AMBER.soft), front = hex('#fff1d6');
+    const strips = 10;
+    for (let i = 0; i < strips; i++) {
+        const y0 = bandTop + ((bandBottom - bandTop) * i) / strips, y1 = bandTop + ((bandBottom - bandTop) * (i + 1)) / strips;
+        const part = clipY(shape, Math.max(top, y0), Math.min(bottom, y1));
+        if (part.length < 3)
+            continue;
+        const k = i / (strips - 1);
+        const c = light < 0 && i === 0 ? mix(soft, front, 0.7) : mix(soft, amber, k);
+        cv.fill([toBody(part)], c, undefined, 'nonzero', Math.min(1, amount * 1.15));
+    }
+}
+export const LOGO_ASPECT = LOGOTYPE.width / LOGOTYPE.height;
+export const LOGO_REST = { ring: 1, fill: 0, head: null, n: 1, e: 1 };
+/** The hybrid ONE, `px` tall (cap height plus the O's overshoot), its top-left at (x, y) in canvas pixels. */
+export function drawLogotype(cv, x, y, px, s, tone, hint = px <= 40) {
+    // Hinting for text cells: the scale makes a stem (11 units) a whole number of pixels, which also puts the N's second
+    // stem (99 units in) on the grid; the cap height starts on a whole pixel; and each letter moves, never more than half
+    // a pixel, so its first stem's left edge does too. Stems then read as solid columns instead of two grey halves.
+    const k = hint ? Math.max(1, Math.round((11 * px) / LOGOTYPE.height)) / 11 : px / LOGOTYPE.height;
+    // …and the cap height is a whole number of pixels too (a vertical squeeze of at most half a pixel), so the baseline
+    // is as sharp as the cap line.
+    const ky = hint ? Math.round(100 * k) / 100 : k;
+    y += hint ? (px - LOGOTYPE.height * ky) / 2 : 0;
+    const dy = hint ? Math.round(y - LOGOTYPE.top * ky) - (y - LOGOTYPE.top * ky) : 0;
+    const snapX = (ux) => hint ? (Math.round(x + ux * k) - (x + ux * k)) / k : 0;
+    const base = mul(translate(x, y + dy), mul(scale(k, ky), translate(0, -LOGOTYPE.top)));
+    const ink = inkFor(tone);
+    const { cx, cy, r, inner } = LOGOTYPE.O;
+    if (s.head) {
+        drawHead(cv, mul(base, mul(translate(cx, cy), scale(r / 100))), s.head, tone);
+    }
+    else if (s.ring > 0) {
+        const hole = inner * (1 - s.fill);
+        const sweep = Math.min(1, s.ring) * Math.PI * 2;
+        const n = 96;
+        const ring = [];
+        const steps = Math.max(2, Math.ceil((n * sweep) / (Math.PI * 2)));
+        for (let i = 0; i <= steps; i++) {
+            const a = (sweep * i) / steps;
+            ring.push([cx + r * Math.sin(a), cy - r * Math.cos(a)]);
+        }
+        if (hole > 0.05)
+            for (let i = steps; i >= 0; i--) {
+                const a = (sweep * i) / steps;
+                ring.push([cx + hole * Math.sin(a), cy - hole * Math.cos(a)]);
+            }
+        else
+            ring.push([cx, cy]);
+        cv.fill([ring], s.fill > 0.98 ? discFor(tone) : ink, base);
+    }
+    const letter = (d, ox, t) => {
+        if (t <= 0)
+            return;
+        const rise = (1 - t) * 14;
+        cv.fill(parsePath(d), ink, mul(base, translate(ox, rise)), 'nonzero', Math.min(1, t * 1.25));
+    };
+    letter(LOGOTYPE.N.d, LOGOTYPE.N.x + snapX(LOGOTYPE.N.x), s.n);
+    letter(LOGOTYPE.E.d, LOGOTYPE.E.x + snapX(LOGOTYPE.E.x), s.e);
+}
+/** Digital One, `px` across, centred at (cx, cy). */
+export function drawEmblem(cv, cx, cy, px, head, tone) {
+    drawHead(cv, mul(translate(cx, cy), scale(px / 200)), { one: null, pose: REST, ...head }, tone);
+}
+export { ONES, LIGHT, sample };

package/dist/onboard/brand.d.ts

@@ -0,0 +1,56 @@
+/**
+ * One's brand geometry and colour, for the terminal. Generated from the One site (l1felabs one-website, worktree
+ * one-ones-shapes-20261016 at cdf3a16c): components/ui/logo.tsx (EMBLEM), components/ui/logotype.ts (the hybrid ONE,
+ * JR-B103), tests/fixtures/ones-shapes/shapes.json + palette.json (the Ones, life/ones-shapes/v2) and app/one-system.css
+ * (amber, the disc, paper and night). Do not edit by hand; regenerate from those files.
+ *
+ * Rules carried over (one-system.css): amber is One's light, never the interface's; the Ones' colours belong to the
+ * characters, never to success, warning or failure; the disc is One's black on light and chalk on dark, with no glow.
+ */
+export declare const EMBLEM_PATH = "M16 0A16 16 0 1 1 16 32A16 16 0 1 1 16 0Z";
+export declare const DISC: {
+    readonly black: "#141b16";
+    readonly chalk: "#f2f1ea";
+    readonly eyeLight: "#fbfaf6";
+    readonly eyeDark: "#f2f1ea";
+};
+export declare const AMBER: {
+    readonly amber: "#c8793a";
+    readonly soft: "#e9a867";
+};
+export declare const PAPER = "#f4f2ec", NIGHT = "#0b0c0c", INK = "#191614", NIGHT_INK = "#f2f1ea";
+export declare const LOGOTYPE: {
+    readonly width: 340.5;
+    readonly height: 103;
+    readonly top: -1.5;
+    readonly O: {
+        readonly cx: 51.5;
+        readonly cy: 50;
+        readonly r: 51.5;
+        readonly inner: 39.84;
+    };
+    readonly N: {
+        readonly x: 119.5;
+        readonly d: "M0 0h11v100h-11ZM99 0h11v100h-11ZM16.1 10L31.444 10L93.9 90L78.556 90Z";
+    };
+    readonly E: {
+        readonly x: 248.5;
+        readonly d: "M0 0h11v100h-11ZM17 0h72.32v10.12h-72.32ZM0 43.94h76.816v10.12h-76.816ZM17 89.88h75v10.12h-75Z";
+    };
+};
+export interface OneShape {
+    id: string;
+    d: string;
+    eye: {
+        x: number;
+        y: number;
+        scale: number;
+        openScale: number;
+        lookGain: number;
+    };
+    colour: string;
+    eyeColour: string;
+    keyline: string | null;
+}
+/** Ones that join the parade (shapes.json parade: true), in agent-eye's -100…100 head box. */
+export declare const ONES: readonly OneShape[];

package/dist/onboard/brand.js

@@ -0,0 +1,134 @@
+/**
+ * One's brand geometry and colour, for the terminal. Generated from the One site (l1felabs one-website, worktree
+ * one-ones-shapes-20261016 at cdf3a16c): components/ui/logo.tsx (EMBLEM), components/ui/logotype.ts (the hybrid ONE,
+ * JR-B103), tests/fixtures/ones-shapes/shapes.json + palette.json (the Ones, life/ones-shapes/v2) and app/one-system.css
+ * (amber, the disc, paper and night). Do not edit by hand; regenerate from those files.
+ *
+ * Rules carried over (one-system.css): amber is One's light, never the interface's; the Ones' colours belong to the
+ * characters, never to success, warning or failure; the disc is One's black on light and chalk on dark, with no glow.
+ */
+export const EMBLEM_PATH = "M16 0A16 16 0 1 1 16 32A16 16 0 1 1 16 0Z";
+export const DISC = { black: "#141b16", chalk: "#f2f1ea", eyeLight: "#fbfaf6", eyeDark: "#f2f1ea" };
+export const AMBER = { amber: "#c8793a", soft: "#e9a867" };
+export const PAPER = "#f4f2ec", NIGHT = "#0b0c0c", INK = "#191614", NIGHT_INK = "#f2f1ea";
+export const LOGOTYPE = {
+    width: 340.5, height: 103, top: -1.5,
+    O: { cx: 51.5, cy: 50, r: 51.5, inner: 39.84 },
+    N: { x: 119.5, d: "M0 0h11v100h-11ZM99 0h11v100h-11ZM16.1 10L31.444 10L93.9 90L78.556 90Z" },
+    E: { x: 248.5, d: "M0 0h11v100h-11ZM17 0h72.32v10.12h-72.32ZM0 43.94h76.816v10.12h-76.816ZM17 89.88h75v10.12h-75Z" },
+};
+/** Ones that join the parade (shapes.json parade: true), in agent-eye's -100…100 head box. */
+export const ONES = [
+    {
+        "id": "star",
+        "d": "M0 -96.15A21.4 21.4 0 0 1 17.28 -87.38L39.72 -56.69A19.03 19.03 0 0 0 49.15 -49.84L85.28 -37.98A21.4 21.4 0 0 1 95.95 -5.12L73.7 25.72A19.03 19.03 0 0 0 70.1 36.79L69.98 74.82A21.4 21.4 0 0 1 42.03 95.13L5.82 83.49A19.03 19.03 0 0 0 -5.82 83.49L-42.03 95.13A21.4 21.4 0 0 1 -69.98 74.82L-70.1 36.79A19.03 19.03 0 0 0 -73.7 25.72L-95.95 -5.12A21.4 21.4 0 0 1 -85.28 -37.98L-49.15 -49.84A19.03 19.03 0 0 0 -39.72 -56.69L-17.28 -87.38A21.4 21.4 0 0 1 0 -96.15Z",
+        "eye": {
+            "x": 0,
+            "y": 12,
+            "scale": 0.8,
+            "openScale": 0.8,
+            "lookGain": 1
+        },
+        "colour": "#ffe93f",
+        "eyeColour": "#141b16",
+        "keyline": "#918312"
+    },
+    {
+        "id": "heart",
+        "d": "M0 -83.4A25.58 25.58 0 0 0 11.75 -86.26A60.47 60.47 0 0 1 84.6 7.76L13.87 86.83A18.6 18.6 0 0 1 -13.87 86.83L-84.6 7.76A60.47 60.47 0 0 1 -11.75 -86.26A25.58 25.58 0 0 0 0 -83.4Z",
+        "eye": {
+            "x": 0,
+            "y": -15,
+            "scale": 0.8,
+            "openScale": 0.8,
+            "lookGain": 1
+        },
+        "colour": "#ff7eb6",
+        "eyeColour": "#141b16",
+        "keyline": "#d3568f"
+    },
+    {
+        "id": "cloud",
+        "d": "M0 -75.75A63.04 63.04 0 0 1 56.25 -18.9A9.78 9.78 0 0 0 64.25 -10.18A43.48 43.48 0 0 1 56.52 76.09H-65.22A34.78 34.78 0 0 1 -75.5 8.08A9.78 9.78 0 0 0 -68.74 -2.85H-68.74A63.04 63.04 0 0 1 0 -75.75Z",
+        "eye": {
+            "x": 0,
+            "y": 6,
+            "scale": 0.8,
+            "openScale": 0.8,
+            "lookGain": 0.5
+        },
+        "colour": "#e9c8ff",
+        "eyeColour": "#141b16",
+        "keyline": "#9577a9"
+    },
+    {
+        "id": "droplet",
+        "d": "M0 -100.01A10.43 10.43 0 0 1 8.88 -95.05L61.35 -9.8A72.04 72.04 0 0 1 0 100A72.04 72.04 0 0 1 -61.35 -9.8L-8.88 -95.05A10.43 10.43 0 0 1 0 -100.01Z",
+        "eye": {
+            "x": 0,
+            "y": 21,
+            "scale": 0.8,
+            "openScale": 0.92,
+            "lookGain": 0.5
+        },
+        "colour": "#5cc8ff",
+        "eyeColour": "#141b16",
+        "keyline": "#148bbd"
+    },
+    {
+        "id": "diamond",
+        "d": "M0 -100.01A19.91 19.91 0 0 1 15.1 -93.08L85.22 -11.54A17.7 17.7 0 0 1 85.22 11.54L15.1 93.08A19.91 19.91 0 0 1 -15.1 93.08L-85.22 11.54A17.7 17.7 0 0 1 -85.22 -11.54L-15.1 -93.08A19.91 19.91 0 0 1 0 -100.01Z",
+        "eye": {
+            "x": 0,
+            "y": -1,
+            "scale": 0.8,
+            "openScale": 0.84,
+            "lookGain": 0.5
+        },
+        "colour": "#2ad4d4",
+        "eyeColour": "#141b16",
+        "keyline": "#139191"
+    },
+    {
+        "id": "gumdrop",
+        "d": "M0 -78A100 100 0 0 1 87.93 69.62A16 16 0 0 1 73.87 78H-73.87A16 16 0 0 1 -87.93 69.62A100 100 0 0 1 0 -78Z",
+        "eye": {
+            "x": 0,
+            "y": 1,
+            "scale": 0.8,
+            "openScale": 0.94,
+            "lookGain": 1
+        },
+        "colour": "#d27cf2",
+        "eyeColour": "#141b16",
+        "keyline": "#b35ed2"
+    },
+    {
+        "id": "egg",
+        "d": "M0 -100A45.31 45.31 0 0 1 32.04 -86.73A154.69 154.69 0 0 1 77.35 22.65A77.35 77.35 0 0 1 0 100A77.35 77.35 0 0 1 -77.35 22.65A154.69 154.69 0 0 1 -32.04 -86.73A45.31 45.31 0 0 1 0 -100Z",
+        "eye": {
+            "x": 0,
+            "y": 14,
+            "scale": 0.8,
+            "openScale": 1,
+            "lookGain": 1
+        },
+        "colour": "#ffc2d4",
+        "eyeColour": "#141b16",
+        "keyline": "#aa7384"
+    },
+    {
+        "id": "blob",
+        "d": "M0 -94.11A63.92 63.92 0 0 1 29.45 -66.43A22.68 22.68 0 0 0 48.1 -54.56A47.42 47.42 0 0 1 66.28 35.34H66.28A22.68 22.68 0 0 0 53.6 56.04A43.3 43.3 0 0 1 -25.31 81.32H-25.31A22.68 22.68 0 0 0 -49.38 72.19A35.05 35.05 0 0 1 -85.74 17.07A22.68 22.68 0 0 0 -83.68 -6.92A63.92 63.92 0 0 1 0 -94.11Z",
+        "eye": {
+            "x": 0,
+            "y": 7,
+            "scale": 0.8,
+            "openScale": 0.84,
+            "lookGain": 0.5
+        },
+        "colour": "#5ee6a8",
+        "eyeColour": "#141b16",
+        "keyline": "#129564"
+    }
+];

package/dist/onboard/caps.d.ts

@@ -0,0 +1,90 @@
+export type ColorDepth = 0 | 4 | 8 | 24;
+export type Graphics = 'kitty' | 'iterm' | 'sixel' | null;
+export interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface Caps {
+    /** stdin and stdout are both terminals: prompts can be interactive. */
+    interactive: boolean;
+    color: ColorDepth;
+    /** Frame animation is allowed (not reduced motion, not a screen reader, not CI, not dumb). */
+    motion: boolean;
+    /** Why motion is off, for `genesis setup --explain` and the tests. */
+    stillBecause?: string;
+    /** Linear, append-only output for screen readers: no redraws, no spinners, numbered choices. */
+    screenReader: boolean;
+    unicode: boolean;
+    hyperlinks: boolean;
+    /** Desktop notification escape the terminal understands. */
+    notify: 'osc9' | 'osc777' | 'osc99' | null;
+    /** Taskbar/tab progress (OSC 9;4). Only where OSC 9 is not a notification. */
+    progress: boolean;
+    graphics: Graphics;
+    imagesAllowed: boolean;
+    /** DECSET 2026 answered "supported"; otherwise we still bracket frames (unknown private modes are ignored). */
+    sync: boolean | null;
+    /** The terminal's real background, when it told us. Edges are blended against it. */
+    background: Rgb | null;
+    /** One cell in device pixels (CSI 16 t), when the terminal reports it: images are drawn at exactly this grid. */
+    cell: {
+        width: number;
+        height: number;
+    } | null;
+    dark: boolean;
+    sound: boolean;
+    /** Recording a demo: account names, emails and identifiers are masked wherever setup prints them. */
+    screencast: boolean;
+    term: string;
+    columns: number;
+    rows: number;
+}
+export interface DetectInput {
+    env: Record<string, string | undefined>;
+    stdoutTTY: boolean;
+    stdinTTY: boolean;
+    columns?: number;
+    rows?: number;
+    flags?: {
+        animation?: boolean;
+        screenReader?: boolean;
+        sound?: boolean;
+        screencast?: boolean;
+    };
+    platform?: NodeJS.Platform;
+}
+/** Identify the emulator from what it advertises. tmux and screen hide the outer terminal, so they are their own kind. */
+export declare function terminalKind(env: Record<string, string | undefined>): string;
+export declare function detect(input: DetectInput): Caps;
+/** Parse every reply the probe can receive. Pure, so the tests can feed it bytes from real terminals. */
+export declare function parseReplies(data: string): {
+    background?: Rgb;
+    sync?: boolean;
+    kitty?: boolean;
+    sixel?: boolean;
+    cell?: {
+        width: number;
+        height: number;
+    };
+    da1: boolean;
+};
+/** The probe. The Kitty query is an APC string, so it goes only to emulators known to swallow APC. */
+export declare const probeFor: (term: string) => string;
+export declare const PROBE: string;
+/** Ask the terminal. Resolves on the DA1 reply or after `timeoutMs`, restoring stdin exactly as it was. */
+export declare function probe(caps: Caps, io: {
+    stdin: NodeJS.ReadStream;
+    stdout: NodeJS.WriteStream;
+}, timeoutMs?: number): Promise<Caps>;
+export declare function luminance({ r, g, b }: Rgb): number;
+/**
+ * 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 declare function systemPreferences(platform?: NodeJS.Platform, run?: typeof runQuiet): Promise<{
+    reducedMotion: boolean;
+    screenReader: boolean;
+}>;
+declare function runQuiet(cmd: string, args: string[], timeoutMs?: number): Promise<string | null>;
+export {};

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