@phantomcodes/cli 1.2.3 → 1.2.5

package/dist/core/errors.mjs

@@ -34,6 +34,6 @@ export function die(msg, code = 'cli_error', exitCode = 1) {
     throw new CliError(msg, code, exitCode);
 }
 /** How to get a key, for every message about a missing one. */
-export const GET_A_KEY = 'Set PHANTOM_API_KEY, or run: phantom login to connect a workspace';
+export const GET_A_KEY = 'Run phantom login to sign in, or set PHANTOM_API_KEY.';
 /** The message for a command that needs a key and has none. */
-export const NO_KEY = `No API key. ${GET_A_KEY}`;
+export const NO_KEY = `No Phantom key yet. ${GET_A_KEY}`;

package/dist/core/helpers.mjs

@@ -1,26 +1,59 @@
 import { spawn } from 'node:child_process';
 import { PhantomApiError, CliError, die } from "./errors.mjs";
+import { colorOn, paint } from "./style.mjs";
+import { Cancelled, canPick } from "./pick.mjs";
+/**
+ * Where a picker draws and reads, when this run can show one: a person at a
+ * terminal (or keys a test scripted), not CI. Null means use flags and the
+ * plain prompts instead.
+ */
+export function pickIo(input) {
+    const { io, env } = input;
+    if (!(io.keys ? io.isTTY : canPick(env, io.isTTY)))
+        return null;
+    // A command started from the menu goes back to it on Esc; one typed on its own quits.
+    return { write: io.stderr, env, keys: io.keys, esc: io.fromMenu ? 'back' : 'cancel', columns: process.stderr.columns };
+}
+/**
+ * Whether a command should draw its screen rather than print JSON: with
+ * `--table`, or when stdout is a terminal, unless `--json` asks for JSON.
+ * Scripts and agents read stdout through a pipe, so they keep getting JSON.
+ */
+export function showsScreen(input) {
+    return input.table || (Boolean(input.io.stdoutIsTTY) && !input.flags['json']);
+}
+/**
+ * A phantom command inside a sentence: `phantom`, its name, a second word for
+ * the commands that take one (`phantom key show`), then any flags. For
+ * example "Run phantom setup to sign in" matches `phantom setup` only.
+ */
+const COMMAND_IN_TEXT = /\bphantom [a-z][a-z-]*(?:(?<=(?:key|keys|workspace|plan|route|route rule)) [a-z][a-z-]*)?(?: --?[a-z][a-z-]*(?: <[^>]+>)?)*/g;
 /**
  * Prints an error to stderr as one line of JSON, `{"error":{...}}`, and
  * returns the exit code: 2 for a key the API rejected (401 or 403), the
  * {@link CliError}'s own code, or 1 for anything else.
  */
-export function handleError(err, stderr = (s) => process.stderr.write(s)) {
-    if (err instanceof PhantomApiError) {
-        stderr(JSON.stringify({
-            error: { status: err.status, code: err.code, message: err.message },
-        }) + '\n');
-        return err.status === 401 || err.status === 403 ? 2 : 1;
+export function handleError(err, stderr = (s) => process.stderr.write(s), opts = {}) {
+    // Ctrl+C in a picker: stop, with the code shells use for it (128 + SIGINT), and no error to read.
+    if (err instanceof Cancelled)
+        return 130;
+    const api = err instanceof PhantomApiError ? err : null;
+    const code = api ? api.code : err instanceof CliError ? err.code : 'unknown';
+    const message = err instanceof Error ? err.message : String(err);
+    if (opts.human) {
+        // A person at a terminal reads a sentence; the code stays for support, dimmed.
+        const p = paint(opts.env ?? {}, colorOn(opts.env ?? {}, true));
+        const lit = message.replace(COMMAND_IN_TEXT, (cmd) => p.cyan(cmd));
+        // The code only when it says more than "an error": HTTP 401, invalid_key helps support; cli_error doesn't.
+        const detail = api ? `HTTP ${api.status}, ${code}` : code === 'cli_error' || code === 'unknown' ? '' : code;
+        stderr(`\n  ${p.red('✗')} ${lit}\n${detail ? p.dim(`    ${detail}`) + '\n' : ''}\n`);
     }
-    if (err instanceof CliError) {
-        stderr(JSON.stringify({
-            error: { code: err.code, message: err.message },
-        }) + '\n');
-        return err.exitCode;
+    else {
+        stderr(JSON.stringify({ error: { ...(api ? { status: api.status } : {}), code, message } }) + '\n');
     }
-    const msg = err instanceof Error ? err.message : String(err);
-    stderr(JSON.stringify({ error: { code: 'unknown', message: msg } }) + '\n');
-    return 1;
+    if (api)
+        return api.status === 401 || api.status === 403 ? 2 : 1;
+    return err instanceof CliError ? err.exitCode : 1;
 }
 /**
  * Reads `--name value`, `--name=value` and bare `--name` (true) from the

package/dist/core/motion.mjs

@@ -0,0 +1,156 @@
+import { colorOn } from "./style.mjs";
+import { GHOST, WORDMARK } from "./brand.mjs";
+/** Whether to animate: color is on for that stream (a terminal, no NO_COLOR), it isn't CI, and PHANTOM_NO_MOTION isn't set. */
+export function motionOn(env, isTTY) {
+    if (env.PHANTOM_NO_MOTION && env.PHANTOM_NO_MOTION !== '0')
+        return false;
+    if (env.CI && env.CI !== 'false' && env.CI !== '0')
+        return false;
+    // FORCE_COLOR can color a pipe, but cursor moves only make sense on a real terminal.
+    return colorOn(env, isTTY) && Boolean(isTTY);
+}
+/** Fast at first, then easing to a stop: the curve for things that arrive. */
+export const easeOut = (t) => 1 - (1 - Math.min(1, Math.max(0, t))) ** 3;
+/**
+ * Lines appearing top to bottom: frame k shows the first k lines and keeps the
+ * rest blank, so the block's height never changes. `delay(line)` is how long
+ * the line waits before it appears; 0 lets it come with the one before.
+ */
+export function reveal(lines, delay) {
+    const book = { frames: [], delays: [] };
+    lines.forEach((line, k) => {
+        const wait = delay(line, k);
+        const frame = lines.map((l, j) => (j <= k ? l : ''));
+        // A line with no wait joins the frame before it instead of making its own.
+        if (book.frames.length && wait === 0)
+            book.frames[book.frames.length - 1] = frame;
+        else {
+            book.frames.push(frame);
+            book.delays.push(book.frames.length === 1 ? 0 : wait);
+        }
+    });
+    return book;
+}
+/**
+ * Every bar in `lines` (a run of ━ followed by its ─ track) drawn at
+ * `progress` of its length, 0 to 1. The track grows to fill what the bar gives
+ * up, so each line keeps its width.
+ */
+export function growBars(lines, progress) {
+    return lines.map((line) => line.replace(/(━+)((?:\x1b\[[0-9;]*m)*)(─*)/g, (_all, fill, codes, track) => {
+        const shown = Math.round(fill.length * progress);
+        return '━'.repeat(shown) + codes + '─'.repeat(fill.length - shown + track.length);
+    }));
+}
+/** Bars growing from nothing to their length over `ms`, easing out. */
+export function barsGrowing(lines, ms = 250, steps = 10) {
+    const frames = Array.from({ length: steps + 1 }, (_, k) => growBars(lines, easeOut(k / steps)));
+    return { frames, delays: frames.map((_, k) => (k === 0 ? 0 : ms / steps)) };
+}
+/** The ghost's eye row with the eyes closed: the two gaps filled with a low half block, like lids. */
+export const CLOSED_EYES = GHOST[1][0].replace(/ (?=█)/, '▄').replace(/ $/, '▄');
+/**
+ * The brand header drawing in, for a screen whose lines start with it
+ * (setup): PHANTOM appears letter by letter, the rest of the screen follows
+ * row by row, then the ghost blinks once.
+ */
+export function brandIntro(lines, opts = {}) {
+    const { letterMs = 20, rowMs = 18, blinkMs = 90 } = opts;
+    const wordRows = lines.map((l, k) => [k, WORDMARK.findIndex((w) => l.includes(w))]).filter(([, r]) => r >= 0);
+    const eyeRow = lines.findIndex((l) => l.includes(GHOST[1][0]));
+    const headerEnd = Math.max(eyeRow, ...wordRows.map(([k]) => k)) + 2;
+    const book = { frames: [], delays: [] };
+    const push = (frame, wait) => (book.frames.push(frame), book.delays.push(book.frames.length === 1 ? 0 : wait));
+    // 1. The ghost, then PHANTOM letter by letter beside it.
+    const letterCount = 7;
+    for (let n = 0; n <= letterCount; n++) {
+        push(lines.map((l, k) => {
+            if (k >= headerEnd)
+                return '';
+            const hit = wordRows.find(([row]) => row === k);
+            if (!hit)
+                return l;
+            return l.replace(WORDMARK[hit[1]], lettersOf(hit[1], n));
+        }), letterMs);
+    }
+    // 2. The rest of the screen, a row at a time.
+    for (let k = headerEnd; k < lines.length; k++)
+        push(lines.map((l, j) => (j <= k ? l : '')), lines[k] ? rowMs : 0);
+    // 3. One blink.
+    if (eyeRow >= 0) {
+        push(lines.map((l, k) => (k === eyeRow ? l.replace(GHOST[1][0], CLOSED_EYES) : l)), blinkMs);
+        push(lines, blinkMs);
+    }
+    return book;
+}
+/** Row `row` of PHANTOM with its first `n` letters drawn and the rest left as spaces. */
+function lettersOf(row, n) {
+    const full = WORDMARK[row];
+    const cut = LETTER_ENDS[n];
+    return full.slice(0, cut).padEnd(full.length);
+}
+/** Where each letter of PHANTOM ends in a wordmark row (the rows share widths): 0 letters, 1 letter and so on. */
+const LETTER_ENDS = (() => {
+    const widths = [4, 4, 4, 4, 3, 4, 5];
+    const ends = [0];
+    widths.forEach((w, k) => ends.push(ends[k] + w + (k ? 1 : 0)));
+    return ends;
+})();
+/** Wait `ms` milliseconds. Tests pass their own so they don't wait. */
+const realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Plays a flipbook on a stream: writes the first frame, then moves the cursor
+ * back up and redraws each next one in place. Ends on the last frame with a
+ * newline. A key press (on a terminal) or `rows` too few to fit the block
+ * skips straight to the last frame.
+ */
+export async function play(write, book, opts = {}) {
+    const last = book.frames[book.frames.length - 1] ?? [];
+    // Taller than the window: moving the cursor up would run off the top, so print the result.
+    if (!book.frames.length || (opts.rows !== undefined && last.length >= opts.rows)) {
+        write(last.join('\n') + '\n');
+        return;
+    }
+    const sleep = opts.sleep ?? realSleep;
+    const stopSkip = opts.skipOnKey ? listenForKey() : null;
+    try {
+        write(book.frames[0].join('\n'));
+        for (let k = 1; k < book.frames.length; k++) {
+            if (stopSkip?.pressed())
+                break;
+            await sleep(book.delays[k]);
+            write(redraw(book.frames[k]));
+        }
+        if (stopSkip?.pressed())
+            write(redraw(last));
+        write('\n');
+    }
+    finally {
+        stopSkip?.stop();
+    }
+}
+/** The codes that move back to the block's first line and write `frame` over it, clearing each line first. */
+function redraw(frame) {
+    const up = frame.length > 1 ? `\x1b[${frame.length - 1}A` : '';
+    return `\r${up}` + frame.map((line) => `\x1b[2K${line}`).join('\n');
+}
+/** Watches the keyboard while an animation plays, so any key skips it. Leaves the terminal as it found it. */
+function listenForKey() {
+    const input = process.stdin;
+    if (!input.isTTY || typeof input.setRawMode !== 'function')
+        return null;
+    let hit = false;
+    const onData = () => void (hit = true);
+    const wasRaw = input.isRaw;
+    input.setRawMode(true);
+    input.on('data', onData);
+    input.resume();
+    return {
+        pressed: () => hit,
+        stop: () => {
+            input.off('data', onData);
+            input.setRawMode(wasRaw);
+            input.pause();
+        },
+    };
+}

package/dist/core/pick.mjs

@@ -0,0 +1,295 @@
+// Choosing with the keyboard: a list you move through with ↑ and ↓ (or j and
+// k) and pick with Enter, and a checklist you tick with Space. Drawn on
+// stderr in phantom's style, redrawn in place as you move, and folded into
+// one line (the question and your answer) once you choose. Only for a person
+// at a terminal: scripts, pipes and CI get the plain prompts or flags instead.
+import { emitKeypressEvents } from 'node:readline';
+import { colorOn, paint } from "./style.mjs";
+/** A hint cut to the room left on the line, so a row never wraps in a narrow window. */
+const fitHint = (hint, used, columns) => {
+    const room = (columns ?? process.stderr.columns ?? 100) - used - 1;
+    return hint.length <= room ? hint : room > 3 ? hint.slice(0, room - 1) + '…' : '';
+};
+/** Thrown by a picker when Ctrl+C is pressed: stop the whole command, wherever it is. */
+export class Cancelled extends Error {
+    constructor() {
+        super('Cancelled.');
+        this.name = 'Cancelled';
+    }
+}
+/**
+ * Thrown by a command started from the start menu when Esc is pressed on its
+ * first step, so the menu shows again instead of the command ending.
+ */
+export class BackToMenu extends Error {
+    constructor() {
+        super('Back to the menu.');
+        this.name = 'BackToMenu';
+    }
+}
+/** Which way a key moves the marker: -1 up, 1 down, 0 not at all. */
+function step(key) {
+    if (key === 'up' || key === 'k' || key === 'shift-tab')
+        return -1;
+    if (key === 'down' || key === 'j' || key === 'tab')
+        return 1;
+    return 0;
+}
+/** Whether this run can show a picker: a person at a terminal on both ends, and not CI. */
+export function canPick(env, stderrIsTTY, stdinIsTTY = Boolean(process.stdin.isTTY)) {
+    if (env.CI && env.CI !== 'false' && env.CI !== '0')
+        return false;
+    return Boolean(stderrIsTTY) && stdinIsTTY;
+}
+/**
+ * The keyboard, one key at a time, named the way pickers read them: `up`,
+ * `down`, `return`, `space`, `escape`, `ctrl-c`, or the letter itself.
+ */
+export function keyboard() {
+    const input = process.stdin;
+    emitKeypressEvents(input);
+    const wasRaw = input.isRaw;
+    input.setRawMode?.(true);
+    input.resume();
+    const waiting = [];
+    const queued = [];
+    const onKey = (text, key = {}) => {
+        // A printable character comes through as itself, capitals and all, so the text box gets "Dana", not "dana".
+        const printable = Boolean(text && text.length === 1 && text >= ' ' && !key.ctrl && (key.name === undefined || key.name.length === 1));
+        const name = key.ctrl && key.name === 'c' ? 'ctrl-c' : key.name === 'enter' ? 'return' : key.shift && key.name === 'tab' ? 'shift-tab' : printable ? text : (key.name ?? text ?? '');
+        const resolve = waiting.shift();
+        if (resolve)
+            resolve(name);
+        else
+            queued.push(name);
+    };
+    input.on('keypress', onKey);
+    return {
+        next: () => new Promise((resolve) => (queued.length ? resolve(queued.shift()) : waiting.push(resolve))),
+        close: () => {
+            input.off('keypress', onKey);
+            input.setRawMode?.(wasRaw);
+            input.pause();
+        },
+    };
+}
+/**
+ * Keys from a list, for tests: each `next()` returns the next name, and `end`
+ * once the list runs out (which pickers treat as Esc). Every picker in a run reads from the same list, as
+ * they would from one keyboard.
+ */
+export function scriptedKeys(names) {
+    const left = [...names];
+    // `end` when the list runs out: pickers read it as Esc; a wait that only listens for Esc ignores it.
+    const source = { next: async () => left.shift() ?? 'end', close: () => { } };
+    return () => source;
+}
+/** A block of lines that redraws itself in place: the first draw prints it, each later one moves up and writes over it. */
+function block(write) {
+    let height = 0;
+    return (lines) => {
+        const up = height > 1 ? `\x1b[${height - 1}A` : '';
+        // \x1b[J clears whatever the last draw left below, when the new one is shorter.
+        write((height ? `\r${up}\x1b[J` : '') + lines.join('\n'));
+        height = lines.length;
+    };
+}
+/** The question line: a lime ? and the question in bold, then the answer once there is one. */
+const asked = (p, question, answer = '') => `  ${p.lime('?')} ${p.bold(question)}${answer ? ` ${p.cyan(answer)}` : ''}`;
+/** The answer a question shows after Esc: back, quit, or cancelled. */
+const escAnswer = (esc) => (esc === 'quit' ? 'quit' : esc === 'cancel' ? 'cancelled' : 'back');
+/** The hint under a picker: which keys do what. */
+const keysHint = (p, words) => `  ${p.dim(words)}`;
+/**
+ * Asks a question with a list of answers. ↑ and ↓ (or k and j, or Tab and
+ * Shift+Tab) move and Enter chooses. Esc or q returns null, which the caller
+ * reads as "go back a step"; Ctrl+C throws {@link Cancelled} to stop the
+ * whole command. `start` is where the marker begins.
+ */
+export async function choose(io, question, choices, start = 0) {
+    const p = paint(io.env, colorOn(io.env, true));
+    const draw = block(io.write);
+    const width = Math.max(...choices.map((c) => c.label.length)) + 3;
+    let at = Math.min(Math.max(0, start), choices.length - 1);
+    const frame = () => [
+        asked(p, question),
+        ...choices.map((c, k) => k === at
+            ? `  ${p.lime('❯')} ${p.bold(c.label.padEnd(width))}${p.dim(fitHint(c.hint ?? '', width + 4, io.columns))}`
+            : `    ${c.label.padEnd(width)}${p.dim(fitHint(c.hint ?? '', width + 4, io.columns))}`),
+        keysHint(p, `↑↓ or tab move · enter choose · esc ${io.esc ?? 'back'} · ctrl+c stop`),
+    ];
+    const keys = (io.keys ?? keyboard)();
+    io.write('\x1b[?25l');
+    try {
+        draw(frame());
+        for (;;) {
+            const key = await keys.next();
+            if (step(key))
+                at = (at + choices.length + step(key)) % choices.length;
+            else if (key === 'return') {
+                draw([asked(p, question, choices[at].label)]);
+                return choices[at].value;
+            }
+            else if (key === 'escape' || key === 'q' || key === 'end') {
+                draw([asked(p, question, escAnswer(io.esc))]);
+                return null;
+            }
+            else if (key === 'ctrl-c') {
+                draw([asked(p, question, 'cancelled')]);
+                throw new Cancelled();
+            }
+            else
+                continue;
+            draw(frame());
+        }
+    }
+    finally {
+        io.write('\n\x1b[?25h');
+        keys.close();
+    }
+}
+/**
+ * A checklist: ↑ and ↓ (or Tab) move, Space ticks or unticks, `a` ticks all,
+ * Enter goes on with the ticked items (it waits while none is ticked). Esc
+ * or q returns null (go back); Ctrl+C throws {@link Cancelled}.
+ */
+export async function checklist(io, question, items) {
+    const p = paint(io.env, colorOn(io.env, true));
+    const draw = block(io.write);
+    const ticked = items.map((i) => i.checked !== false);
+    const width = Math.max(...items.map((i) => i.label.length)) + 3;
+    let at = 0;
+    let nudge = '';
+    const frame = () => [
+        asked(p, question),
+        ...items.map((item, k) => {
+            const box = ticked[k] ? p.lime('◉') : p.dim('◯');
+            const label = k === at ? p.bold(item.label.padEnd(width)) : item.label.padEnd(width);
+            return `  ${k === at ? p.lime('❯') : ' '} ${box} ${label}${p.dim(fitHint(item.hint ?? '', width + 6, io.columns))}`;
+        }),
+        nudge ? `  ${p.yellow(nudge)}` : keysHint(p, `↑↓ or tab move · space tick · a all · enter go on · esc ${io.esc ?? 'back'}`),
+    ];
+    const keys = (io.keys ?? keyboard)();
+    io.write('\x1b[?25l');
+    try {
+        draw(frame());
+        for (;;) {
+            const key = await keys.next();
+            nudge = '';
+            if (step(key))
+                at = (at + items.length + step(key)) % items.length;
+            else if (key === 'space')
+                ticked[at] = !ticked[at];
+            else if (key === 'a')
+                ticked.fill(!ticked.every(Boolean));
+            else if (key === 'return') {
+                if (!ticked.some(Boolean))
+                    nudge = 'Tick at least one, or press esc to go back.';
+                else {
+                    const chosen = items.filter((_, k) => ticked[k]);
+                    draw([asked(p, question, chosen.map((i) => i.label).join(', '))]);
+                    return chosen.map((i) => i.value);
+                }
+            }
+            else if (key === 'escape' || key === 'q' || key === 'end') {
+                draw([asked(p, question, escAnswer(io.esc))]);
+                return null;
+            }
+            else if (key === 'ctrl-c') {
+                draw([asked(p, question, 'cancelled')]);
+                throw new Cancelled();
+            }
+            else
+                continue;
+            draw(frame());
+        }
+    }
+    finally {
+        io.write('\n\x1b[?25h');
+        keys.close();
+    }
+}
+/**
+ * Listens for Esc or Ctrl+C while something waits (sign-in waiting for
+ * approval), without taking over the screen. `pressed` settles with the key;
+ * other keys are ignored, and the end of a test's keys never settles it.
+ */
+export function cancelKeys(source) {
+    let closed = false;
+    const pressed = new Promise((resolve) => {
+        const listen = async () => {
+            while (!closed) {
+                const key = await source.next();
+                if (key === 'end')
+                    return;
+                if (key === 'escape' || key === 'q')
+                    return resolve('escape');
+                if (key === 'ctrl-c')
+                    return resolve('ctrl-c');
+            }
+        };
+        void listen();
+    });
+    return {
+        pressed,
+        close: () => {
+            closed = true;
+            source.close();
+        },
+    };
+}
+/**
+ * Asks for a short piece of text, such as a key's name or an amount: type it,
+ * Backspace to fix it, Enter to go on (it waits while `check` refuses the
+ * text, and shows why), Esc to go back (null), Ctrl+C to stop. Keys longer
+ * than one character that aren't named keys are typed as text, so a test can
+ * send "sam" as one key.
+ */
+export async function askText(io, question, opts = {}) {
+    const p = paint(io.env, colorOn(io.env, true));
+    const draw = block(io.write);
+    let text = '';
+    let problem = '';
+    const NAMED = new Set(['up', 'down', 'left', 'right', 'tab', 'shift-tab', 'space', 'return', 'escape', 'ctrl-c', 'backspace', 'delete', 'end']);
+    const frame = () => [
+        asked(p, question),
+        `  ${p.lime('❯')} ${text ? p.bold(text) : p.dim(opts.placeholder ?? '')}${p.lime('▏')}`,
+        problem ? `  ${p.yellow(problem)}` : keysHint(p, `type · enter go on · esc ${io.esc ?? 'back'}`),
+    ];
+    const keys = (io.keys ?? keyboard)();
+    io.write('\x1b[?25l');
+    try {
+        draw(frame());
+        for (;;) {
+            const key = await keys.next();
+            problem = '';
+            if (key === 'return') {
+                const why = opts.check?.(text.trim()) ?? (text.trim() ? null : 'Type something, or press esc to go back.');
+                if (!why) {
+                    draw([asked(p, question, text.trim())]);
+                    return text.trim();
+                }
+                problem = why;
+            }
+            else if (key === 'escape' || key === 'end') {
+                draw([asked(p, question, escAnswer(io.esc))]);
+                return null;
+            }
+            else if (key === 'ctrl-c') {
+                draw([asked(p, question, 'cancelled')]);
+                throw new Cancelled();
+            }
+            else if (key === 'backspace' || key === 'delete')
+                text = text.slice(0, -1);
+            else if (key === 'space')
+                text += ' ';
+            else if (!NAMED.has(key))
+                text += key;
+            draw(frame());
+        }
+    }
+    finally {
+        io.write('\n\x1b[?25h');
+        keys.close();
+    }
+}

package/dist/core/style.mjs

@@ -0,0 +1,36 @@
+/**
+ * Whether to print color: only to a terminal, never with `NO_COLOR` set
+ * (https://no-color.org) or on a `dumb` terminal. `FORCE_COLOR` turns it on
+ * anywhere, and `FORCE_COLOR=0` turns it off.
+ */
+export function colorOn(env, isTTY) {
+    if (env.NO_COLOR)
+        return false;
+    if (env.FORCE_COLOR !== undefined)
+        return env.FORCE_COLOR !== '0';
+    return Boolean(isTTY) && env.TERM !== 'dumb';
+}
+const wrap = (open, close) => (s) => `\x1b[${open}m${s}\x1b[${close}m`;
+const plain = (s) => s;
+/**
+ * The styles for one screen. Lime and cyan use 24-bit color when the terminal says it
+ * has it (`COLORTERM=truecolor`), and the nearest of the 256 standard colors otherwise.
+ */
+export function paint(env, on) {
+    if (!on)
+        return { lime: plain, bold: plain, white: plain, pill: plain, dim: plain, cyan: plain, green: plain, red: plain, yellow: plain };
+    const truecolor = env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit';
+    return {
+        lime: wrap(truecolor ? '38;2;62;230;168' : '38;5;79', '39'),
+        cyan: wrap(truecolor ? '38;2;0;209;255' : '38;5;45', '39'),
+        bold: wrap('1', '22'),
+        white: wrap('97', '39'),
+        pill: (s) => (truecolor ? `\x1b[48;2;62;230;168m\x1b[38;2;8;9;12m${s}\x1b[39m\x1b[49m` : `\x1b[48;5;79m\x1b[38;5;232m${s}\x1b[39m\x1b[49m`),
+        dim: wrap('2', '22'),
+        green: wrap('32', '39'),
+        red: wrap('31', '39'),
+        yellow: wrap('33', '39'),
+    };
+}
+/** `text` without color codes, to measure how wide it prints. */
+export const unstyled = (text) => text.replace(/\x1b\[[0-9;]*m/g, '');

package/dist/core/version.mjs

@@ -1,2 +1,2 @@
 /** This release of phantom. `npm version` keeps it equal to the version in package.json. */
-export const VERSION = '1.2.3';
+export const VERSION = '1.2.5';