flagstaff 0.2.1 → 0.3.0

package/README.md

@@ -13,7 +13,7 @@
 
 <p align="center">
   <a href="https://www.npmjs.com/package/flagstaff"><img src="https://img.shields.io/npm/v/flagstaff?style=flat-square&color=0a6b47" alt="npm version" /></a>
-  <img src="https://img.shields.io/badge/dependencies-roundel-0a6b47?style=flat-square" alt="One dependency: roundel" />
+  <img src="https://img.shields.io/badge/dependencies-4%20in--family-0a6b47?style=flat-square" alt="Four dependencies, all in this repository: closeout, linegauge, paratext, roundel" />
   <img src="https://img.shields.io/badge/Node.js-24+-green.svg?style=flat-square" alt="Node.js 24+" />
   <img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square" alt="License: MIT" />
 </p>
@@ -243,11 +243,11 @@ screen, not the bytes.
 `logUpdateStderr`, with the row-level diffing intact: a five-row frame whose last row is a
 counter costs one row of output per tick, not five.
 
-log-update ships 113.4 KB across **sixteen** packages. This is 29.6 KB across **none** —
-the subpath reaches no package at all, not even roundel.
+log-update ships 113.4 KB across **sixteen** packages. This subpath reaches two, both from
+this repository: `linegauge/wrap` for the wrapper, and `closeout` for the cursor.
 It carries no port of `slice-ansi` — the wrapper already makes every row self-contained,
 so clipping a frame to the terminal's height is an array slice. `signal-exit`, 22.0 KB of
-those sixteen, is 1.4 KB here: `cursor.ts`, shared with the ora façade because both
+those sixteen, is `closeout`'s to own, shared with the ora façade because both
 incumbents port the same `cli-cursor` → `restore-cursor` → `signal-exit` chain. Ctrl+C
 mid-frame puts your cursor back, and still terminates — unless your program installed its
 own `SIGINT` handler, in which case it is delivered once, to you, and this stays out of it.
@@ -332,11 +332,11 @@ Every subpath is a lock, not a convention, and the numbers below are asserted by
 `weight.test.ts` against `dist/`, not estimated: `flagstaff/loop` reaches 4.4 KB on disk and
 never the plugin registry; `flagstaff/plugin` 8.4 KB, of which 2.4 KB is the schema;
 `flagstaff/spinner` 9.4 KB; `flagstaff/ora` 46.5 KB — 55.9 KB with roundel counted, against
-ora's own 113.6 KB; `flagstaff/log-update` 29.6 KB, reaching **no package at all**, against
-log-update's own 113.4 KB across sixteen; `flagstaff/boxen` 33.7 KB — 43.0 KB with roundel
+ora's own 113.6 KB; `flagstaff/log-update` 29.6 KB, against
+log-update's own 113.4 KB across sixteen, reaching only `linegauge/wrap` and `closeout`; `flagstaff/boxen` 33.7 KB — 43.0 KB with roundel
 counted, against boxen's own 132.4 KB across nineteen; `flagstaff/cli-table3` 32.9 KB —
 42.3 KB with roundel, against cli-table3's own 106.0 KB across seven. The three façades share `wrap.js` and
-`width.js`, and the first two share `cursor.js`; none reaches another's port, and none
+`width.js`, and the first two share `closeout`; none reaches another's port, and none
 reaches the core. `sideEffects: false` lets a
 bundler drop what a program does not use. ESM with a `default` condition, so
 `require('flagstaff/spinner')` works from CommonJS on Node ≥ 24.
@@ -370,3 +370,21 @@ Part of the [burgee](https://github.com/ofri-peretz/burgee) family: a CLI on
 none requires the others.
 
 MIT © Ofri Peretz — see [LICENSE](./LICENSE).
+
+## Benchmarks
+
+Every number here is produced by `npm run bench` and published at [/docs/benchmarks](/docs/benchmarks).
+
+Graded by the incumbent's own test suite:
+
+| suite | passing |
+| :-- | --: |
+| `boxen` | 84 / 84 |
+| `cli-table3` | 29 / 29 |
+| `log-update` | 99 / 99 |
+| `ora` | 99 / 99 |
+## Where it sits
+
+Plugins register under the `tokens`, `glyphs`, `spinners`, `borders`, `components` keys, against the one schema the whole family shares.
+
+Nothing in this family builds on it yet, and it builds on `closeout`, `linegauge`, `paratext`, `roundel`.

package/dist/box.d.ts

@@ -1,3 +1,4 @@
+import { type Terminal } from './link.js';
 import { type BorderStyle, type Component } from './plugin.js';
 export interface BoxOptions {
     /** A registered border's name, or a style of your own. Default `round`. */
@@ -11,12 +12,27 @@ export interface BoxOptions {
     title?: string;
     /** Columns the whole box may occupy, borders included. Text wraps to fit. Default 80. */
     width?: number;
+    /**
+     * A url or a path the box's text points at — `file://…` for a path a terminal should be
+     * able to open, which is the case R12 is named after. The title is left alone: it is a
+     * label for the box, and a link around it would claim the border is clickable too.
+     */
+    href?: string;
+    /**
+     * The terminal the link is rendered for. Omitted, the real process is read through this
+     * package's seam. Supply one and the whole path is pure.
+     */
+    terminal?: Terminal;
 }
 /** Draw `text` in a box, as a string. The many callers who want only this want only this. */
 export declare function box(text: string, options?: BoxOptions): string;
 export interface BoxState {
     text: string;
     title?: string;
+    /** Per-state destination, overriding the one the component was built with. */
+    href?: string;
 }
 /** A box as a component: the text off a terminal, the drawing on one (R1). */
 export declare function boxComponent(options?: BoxOptions): Component<BoxState>;
+/** The runtime shape `BoxOptions.terminal` takes, so a caller can name it (R12). */
+export type { Terminal } from './link.js';

package/dist/box.js

@@ -1,6 +1,7 @@
 import { width } from 'linegauge';
 import { wrap } from 'linegauge/wrap';
 import { muted } from 'roundel/tokens';
+import { laid, painted, painter, STATIC } from './link.js';
 import { lookupBorder } from './plugin.js';
 const DEFAULT_WIDTH = 80;
 const DEFAULT_PAD_X = 1;
@@ -8,7 +9,7 @@ const DEFAULT_PAD_Y = 0;
 const BORDER_CELLS = 2;
 const ELLIPSIS = '…';
 const resolve = (border) => (typeof border === 'string' ? lookupBorder(border) : border);
-const padEnd = (line, cells) => line + ' '.repeat(Math.max(0, cells - width(line)));
+const padEnd = (line, cells, measured = line) => line + ' '.repeat(Math.max(0, cells - width(measured)));
 function fitTitle(title, cells) {
     if (width(title) <= cells)
         return title;
@@ -42,18 +43,23 @@ export function box(text, options = {}) {
     const borderCells = style.left === '' ? 0 : BORDER_CELLS;
     const inner = Math.max(1, total - borderCells);
     const content = Math.max(1, inner - padX * BORDER_CELLS);
-    const wrapped = wrap(text, content, { hard: true, trim: false }).split('\n');
+    const paint = painter(options.terminal);
+    const wrapped = wrap(laid(text, options.href, paint), content, { hard: true, trim: false }).split('\n');
     const blank = Array.from({ length: padY }, () => '');
     const pad = ' '.repeat(padX);
-    const rows = [...blank, ...wrapped, ...blank].map((line) => `${style.left}${pad}${padEnd(line, content)}${pad}${style.right}`);
+    const rows = [...blank, ...wrapped, ...blank].map((line) => `${style.left}${pad}${padEnd(painted(line, options.href, paint), content, line)}${pad}${style.right}`);
     const top = topBorder(style, inner, options.title);
     const bottom = style.bottom === '' ? '' : style.bottomLeft + style.bottom.repeat(inner) + style.bottomRight;
     return [top, ...rows, bottom].filter((row) => row !== '').join('\n');
 }
 export function boxComponent(options = {}) {
+    const plain = painter(STATIC);
     return {
         name: 'box',
-        static: (state) => (state.title === undefined || state.title === '' ? state.text : `${state.title}: ${state.text}`),
-        frame: (_t, state) => muted(box(state.text, state.title === undefined ? options : { ...options, title: state.title })),
+        static: (state) => {
+            const body = laid(state.text, state.href ?? options.href, plain);
+            return state.title === undefined || state.title === '' ? body : `${state.title}: ${body}`;
+        },
+        frame: (_t, state) => muted(box(state.text, { ...options, ...(state.title === undefined ? {} : { title: state.title }), ...(state.href === undefined ? {} : { href: state.href }) })),
     };
 }

package/dist/boxen.js

@@ -1,6 +1,8 @@
 import { width as stringWidth } from 'linegauge';
 import { wrap as wrapAnsi } from 'linegauge/wrap';
 import chalk from 'roundel/chalk';
+import { processRuntime } from './runtime.js';
+const rt = processRuntime();
 const NEWLINE = '\n';
 const PAD = ' ';
 const NONE = 'none';
@@ -20,7 +22,7 @@ const BOXES = {
     arrow: { topLeft: '↘', top: '↓', topRight: '↙', right: '←', bottomRight: '↖', bottom: '↑', bottomLeft: '↗', left: '→' },
 };
 function terminalColumns() {
-    const { env, stdout, stderr } = process;
+    const { env, stdout, stderr } = rt;
     if (stdout?.columns)
         return stdout.columns;
     if (stderr?.columns)
@@ -173,8 +175,8 @@ function boxContent(content, contentWidth, options) {
     return result;
 }
 function sanitizeOptions(options) {
-    if (options.fullscreen !== undefined && options.fullscreen !== false && process.stdout) {
-        let dimensions = [process.stdout.columns, process.stdout.rows];
+    if (options.fullscreen !== undefined && options.fullscreen !== false && rt.stdout) {
+        let dimensions = [rt.stdout.columns, rt.stdout.rows];
         if (typeof options.fullscreen === 'function')
             dimensions = options.fullscreen(...dimensions);
         options.width ||= dimensions[0];

package/dist/cli-table3.d.ts

@@ -4,7 +4,18 @@ export declare function strlen(str: unknown): number;
 export declare function pad(str: string, len: number, padChar: string, dir?: string): string;
 export declare function truncate(str: string, desiredLength: number, truncateChar?: string): string;
 export declare function wordWrap(maxLength: number, input: string, wrapOnWordBoundary?: boolean): string[];
-/** OSC 8 — the terminal hyperlink escape. */
+/**
+ * OSC 8 — the terminal hyperlink escape, and **not this package's to spell** (R12). The
+ * sequence is paratext's `link` capability rendered against {@link EMITTING}; this function
+ * contributes the argument order and upstream's `url || text`, and nothing else.
+ *
+ * Upstream's `hyperlink()` is an escape *builder*, not a policy decision: `utils-test.js`
+ * grades its exact bytes with no terminal anywhere in the call, and a cell given an `href`
+ * gets a sequence whatever `process.stdout` is. So this stays unconditional — the caller
+ * already decided — and the runtime handed to paratext says so out loud. `flagstaff/table`
+ * is the surface that *asks* whether the terminal can (rule 6); a façade that started asking
+ * would be reinterpreting its host, and `link.test.ts` pins these bytes against upstream's.
+ */
 export declare function hyperlink(url: string, text: string): string;
 export interface TableChars {
     [name: string]: string;

package/dist/cli-table3.js

@@ -1,10 +1,14 @@
 import { measure } from 'linegauge';
+import { linkFor } from 'paratext/link';
 import chalk from 'roundel/chalk';
 const ESC = '\u001B';
 const SGR = /\u001B\[(?:\d*;){0,5}\d*m/g;
 const SGR_CAPTURE = /\u001B\[((?:\d*;){0,5}\d*)m/g;
-const HYPERLINK_TAG = `${ESC}]8;;\u0007`;
 const HALF = 2;
+const EMITTING = { env: { WT_SESSION: '1' }, isTTY: { stdout: true } };
+const emitLink = linkFor(EMITTING);
+const EMPTY_LINK = emitLink('', '');
+const HYPERLINK_TAG = EMPTY_LINK.slice(0, EMPTY_LINK.length / HALF);
 export function strlen(str) {
     const stripped = String(str).replaceAll(SGR, '');
     return stripped.split('\n').reduce((memo, s) => Math.max(memo, measure(s)), 0);
@@ -209,9 +213,7 @@ function colorizeLines(input) {
     });
 }
 export function hyperlink(url, text) {
-    const OSC = `${ESC}]`;
-    const BEL = '\u0007';
-    return [OSC, '8', ';', ';', url || text, BEL, text, OSC, '8', ';', ';', BEL].join('');
+    return emitLink(text, url || text);
 }
 const DEBUG_LEVEL = { WARN: 1, INFO: 2, DEBUG: 3 };
 let debugMessages = [];

package/dist/cli.js

@@ -3,7 +3,9 @@ import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { hoist, manualClock } from './loop.js';
 import { PluginError, register, registered } from './plugin.js';
+import { processRuntime } from './runtime.js';
 import { spinner } from './spinner.js';
+const rt = processRuntime();
 const MODES = ['tty', 'pipe', 'ci', 'json', 'accessible'];
 const ENV = { tty: {}, pipe: {}, ci: { CI: 'true' }, json: {}, accessible: { CLI_ACCESSIBLE: '1' } };
 const LABEL_WIDTH = 12;
@@ -118,11 +120,11 @@ async function main(argv, write) {
     write(`${name}: ok${before.has(name) ? ' (replaces an earlier registration)' : ''}\n`);
     return EXIT_OK;
 }
-const [, , command, ...rest] = process.argv;
+const [, , command, ...rest] = rt.argv;
 const args = command === 'check' ? rest : [command, ...rest].filter((a) => a !== undefined);
-main(args, (s) => process.stdout.write(s)).then((code) => {
-    process.exitCode = code;
+main(args, (s) => rt.stdout.write(s)).then((code) => {
+    rt.exitCode = code;
 }, (e) => {
-    process.stderr.write(`${e instanceof Error ? e.message : String(e)}\n`);
-    process.exitCode = EXIT_RUNTIME;
+    rt.stderr.write(`${e instanceof Error ? e.message : String(e)}\n`);
+    rt.exitCode = EXIT_RUNTIME;
 });

package/dist/link.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The one place this package reaches OSC 8, and it does not implement it (R12).
+ *
+ * **Why `paratext/link` and not `paratext`.** The root entry reaches 20,221 B across ten
+ * modules and calls `registerBuiltins()` at import — a side effect, in a package that declares
+ * `sideEffects: false` so a bundler may drop what a program does not use. `paratext/link` is
+ * **2,410 B across four modules and registers nothing**, and it carries the whole of what the
+ * built-ins need: the guess (`supportsLink`), the bytes (`linkFor`) and the capability record.
+ * The 17,811 B difference would land on `flagstaff/table`, whose entire budget is 4,000 B, so
+ * this was not a close call — but it was measured rather than assumed, which is the rule.
+ * What the narrow entry gives up is the registry: a host that re-registered `link` to correct
+ * paratext's guess does not change what a box or a table emits. A program that needs that
+ * imports `paratext` and calls `emit()` itself.
+ *
+ * **What this module is allowed to decide: nothing.** `supportsLink` is asked, never
+ * re-derived — `box.ts` and `table.ts` read `live` to choose a *layout* (a url that is about
+ * to be carried by an escape must not also be carried by the columns), and `paint` for the
+ * bytes. Neither file names `isTTY`, `TERM`, or an escape. PRINCIPLES rule 6 is therefore
+ * paratext's to keep, and `link.test.ts` checks it was kept.
+ */
+import { linkFor } from 'paratext/link';
+/**
+ * The slice of the world paratext needs in order to answer. Derived from `linkFor` rather
+ * than imported: `paratext/link` publishes the functions, not the type, and a second
+ * specifier for a type would put `paratext` in this package's graph for something
+ * `verbatimModuleSyntax` erases anyway.
+ */
+export type Terminal = Parameters<typeof linkFor>[0];
+/**
+ * The real process, narrowed to what paratext asks of it. Read through this package's own
+ * seam (Y9), so `runtime.ts` stays the one file here that names the process and a caller
+ * that passes its own `terminal` reaches no global at all.
+ */
+export declare const terminalRuntime: () => Terminal;
+/**
+ * The runtime a **static projection** is defined against: no terminal, so paratext renders
+ * the fallback. `static()` is the text a pipe, a log, an agent and a screen reader get (R1),
+ * which is the same question `linkFor` answers for a runtime that is not a terminal — so it
+ * is asked rather than answered here, and `text (url)` stays a string paratext owns.
+ */
+export declare const STATIC: Terminal;
+export interface Painter {
+    /**
+     * Whether the sequence is going to be emitted — paratext's answer, for a caller deciding
+     * *layout*. Off a terminal the url is content and belongs in the columns; on one it is
+     * carried by an escape that measures zero.
+     */
+    readonly live: boolean;
+    /** `(text, url) => string`. The bytes, whichever branch holds. */
+    readonly paint: (text: string, url: string) => string;
+}
+/** Bind both questions to one runtime, once per drawing. */
+export declare function painter(terminal?: Terminal): Painter;
+/**
+ * A cell or a body with a destination attached. `href` is a url or a path — `file://` for a
+ * path a terminal should be able to open, which is the case R12 is named after.
+ */
+export interface Linked {
+    readonly text: string;
+    readonly href: string;
+}
+/** A table cell: text, or text with somewhere to go. A plain string stays a plain string. */
+export type Cell = string | Linked;
+export declare const cellText: (cell: Cell | undefined) => string;
+export declare const cellHref: (cell: Cell | undefined) => string | undefined;
+/**
+ * What the content reads as **before** the drawing measures it: the bare text where the
+ * sequence will carry the destination, paratext's fallback where it will not. This is the
+ * only consequence `live` has on layout, and it is the whole of it.
+ */
+export declare function laid(text: string, href: string | undefined, painted: Painter): string;
+/**
+ * The same content once it has been wrapped and is about to be padded. A line that survived
+ * wrapping gets the sequence; an empty one does not, because a link around nothing is an
+ * escape a terminal still has to parse and a screen reader still has to skip.
+ */
+export declare function painted(line: string, href: string | undefined, painter_: Painter): string;

package/dist/link.js

@@ -0,0 +1,23 @@
+import { linkFor, supportsLink } from 'paratext/link';
+import { processRuntime } from './runtime.js';
+export const terminalRuntime = () => {
+    const runtime = processRuntime();
+    return { env: runtime.env, isTTY: { stdout: runtime.stdout.isTTY === true } };
+};
+export const STATIC = { env: {}, isTTY: { stdout: false } };
+export function painter(terminal) {
+    const runtime = terminal ?? terminalRuntime();
+    return { live: supportsLink(runtime), paint: linkFor(runtime) };
+}
+export const cellText = (cell) => (typeof cell === 'string' ? cell : (cell?.text ?? ''));
+export const cellHref = (cell) => (typeof cell === 'string' || cell === undefined ? undefined : cell.href);
+export function laid(text, href, painted) {
+    if (href === undefined || href === '')
+        return text;
+    return painted.live ? text : painted.paint(text, href);
+}
+export function painted(line, href, painter_) {
+    if (!painter_.live || href === undefined || href === '' || line === '')
+        return line;
+    return painter_.paint(line, href);
+}

package/dist/log-update.d.ts

@@ -1,4 +1,4 @@
-/** What log-update writes to: `process.stdout` by default, anything stream-shaped in a test. */
+/** What log-update writes to: the runtime's stdout by default, anything stream-shaped in a test. */
 export interface LogUpdateStream {
     write(chunk: string): unknown;
     columns?: number;
@@ -22,7 +22,7 @@ export interface LogUpdate {
     /** Replace the frame with text that stays, unclipped, and start fresh after it. */
     persist(...text: unknown[]): void;
 }
-/** A renderer bound to one stream. `logUpdate` is this over `process.stdout`. */
+/** A renderer bound to one stream. `logUpdate` is this over the runtime's stdout. */
 export declare function createLogUpdate(stream: LogUpdateStream, { showCursor: keepCursor, defaultWidth, defaultHeight }?: LogUpdateOptions): LogUpdate;
 declare const logUpdate: LogUpdate;
 export declare const logUpdateStderr: LogUpdate;

package/dist/log-update.js

@@ -1,6 +1,8 @@
-import process from 'node:process';
+import { HIDE_CURSOR, SHOW_CURSOR } from 'closeout/cursor';
+import restoreCursor from 'closeout/restore-cursor';
 import { wrap } from 'linegauge/wrap';
-import { HIDE_CURSOR, restoreCursorOnExit, SHOW_CURSOR } from './cursor.js';
+import { processRuntime } from './runtime.js';
+const rt = processRuntime();
 const CSI = '\u001B[';
 const SYNCHRONIZED_OUTPUT_ENABLE = `${CSI}?2026h`;
 const SYNCHRONIZED_OUTPUT_DISABLE = `${CSI}?2026l`;
@@ -18,15 +20,15 @@ const eraseLines = (count) => {
     return count > 0 ? sequence + CURSOR_LEFT : sequence;
 };
 function hideCursor() {
-    if (process.stderr.isTTY !== true)
+    if (rt.stderr.isTTY !== true)
         return;
-    restoreCursorOnExit();
-    process.stderr.write(HIDE_CURSOR);
+    restoreCursor();
+    rt.stderr.write(HIDE_CURSOR);
 }
 function showCursor() {
-    if (process.stderr.isTTY !== true)
+    if (rt.stderr.isTTY !== true)
         return;
-    process.stderr.write(SHOW_CURSOR);
+    rt.stderr.write(SHOW_CURSOR);
 }
 const countLines = (text) => text.split('\n').length;
 function fitToHeight(wrapped, terminalHeight) {
@@ -168,6 +170,6 @@ export function createLogUpdate(stream, { showCursor: keepCursor = false, defaul
     };
     return render;
 }
-const logUpdate = createLogUpdate(process.stdout);
-export const logUpdateStderr = createLogUpdate(process.stderr);
+const logUpdate = createLogUpdate(rt.stdout);
+export const logUpdateStderr = createLogUpdate(rt.stderr);
 export default logUpdate;

package/dist/ora.d.ts

@@ -5,7 +5,7 @@ export interface SpinnerDefinition {
 /** Every spinner cli-spinners ships, unedited — ora re-exports it and so do we. */
 export declare const spinners: Record<string, SpinnerDefinition>;
 export type Color = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'gray';
-/** What ora writes to: `process.stderr` by default, anything stream-shaped in a test. */
+/** What ora writes to: the runtime's stderr by default, anything stream-shaped in a test. */
 export interface OraStream {
     write(chunk: string, encoding?: unknown, callback?: unknown): boolean;
     isTTY?: boolean;

package/dist/ora.js

@@ -1,14 +1,16 @@
 import { Buffer } from 'node:buffer';
-import process from 'node:process';
+import { HIDE_CURSOR, SHOW_CURSOR } from 'closeout/cursor';
+import restoreCursor from 'closeout/restore-cursor';
 import { lineCount } from 'linegauge';
 import chalk from 'roundel/chalk';
-import { HIDE_CURSOR, restoreCursorOnExit, SHOW_CURSOR } from './cursor.js';
+import { processRuntime } from './runtime.js';
 import spinnerCorpus from './spinners.json' with { type: 'json' };
+const rt = processRuntime();
 export const spinners = spinnerCorpus;
 function isUnicodeSupported() {
-    const { env } = process;
+    const { env } = rt;
     const { TERM, TERM_PROGRAM } = env;
-    if (process.platform !== 'win32')
+    if (rt.platform !== 'win32')
         return TERM !== 'linux';
     return (Boolean(env['WT_SESSION']) ||
         Boolean(env['TERMINUS_SUBLIME']) ||
@@ -22,7 +24,7 @@ function isUnicodeSupported() {
         env['TERMINAL_EMULATOR'] === 'JetBrains-JediTerm');
 }
 function isInteractive(stream) {
-    return Boolean(stream?.isTTY) && process.env['TERM'] !== 'dumb' && !('CI' in process.env);
+    return Boolean(stream?.isTTY) && rt.env['TERM'] !== 'dumb' && !('CI' in rt.env);
 }
 const UNICODE = isUnicodeSupported();
 const logSymbols = {
@@ -43,7 +45,7 @@ class StdinDiscarder {
             return;
         const code = typeof chunk === 'string' ? chunk.codePointAt(0) : chunk[0];
         if (code === ASCII_ETX_CODE)
-            process.kill(process.pid, 'SIGINT');
+            rt.kill(rt.pid, 'SIGINT');
     };
     start() {
         this.#activeCount += 1;
@@ -58,8 +60,8 @@ class StdinDiscarder {
             this.#realStop();
     }
     #realStart() {
-        const stdin = process.stdin;
-        if (process.platform === 'win32' || stdin?.isTTY !== true || typeof stdin.setRawMode !== 'function') {
+        const stdin = rt.stdin;
+        if (rt.platform === 'win32' || stdin?.isTTY !== true || typeof stdin.setRawMode !== 'function') {
             this.#stdin = undefined;
             return;
         }
@@ -115,7 +117,7 @@ export class Ora {
     #color;
     constructor(options) {
         const given = typeof options === 'string' ? { text: options } : options;
-        this.#options = { color: 'cyan', stream: process.stderr, discardStdin: true, hideCursor: true, isEnabled: false, isSilent: false, indent: 0, ...given };
+        this.#options = { color: 'cyan', stream: rt.stderr, discardStdin: true, hideCursor: true, isEnabled: false, isSilent: false, indent: 0, ...given };
         this.color = this.#options.color;
         this.#stream = this.#options.stream;
         if (typeof given?.isEnabled !== 'boolean')
@@ -132,7 +134,7 @@ export class Ora {
         this.prefixText = this.#options.prefixText;
         this.suffixText = this.#options.suffixText;
         this.indent = this.#options.indent;
-        if (process.env['NODE_ENV'] === 'test')
+        if (rt.env['NODE_ENV'] === 'test')
             this.#exposeTestProperties();
     }
     #exposeTestProperties() {
@@ -319,7 +321,7 @@ export class Ora {
             return this;
         if (this.#options.hideCursor)
             this.#hideCursor();
-        if (this.#options.discardStdin && process.stdin.isTTY) {
+        if (this.#options.discardStdin && rt.stdin.isTTY) {
             stdinDiscarder.start();
             this.#isDiscardingStdin = true;
         }
@@ -390,7 +392,7 @@ export class Ora {
     #hideCursor() {
         if (this.#stream.isTTY !== true)
             return;
-        restoreCursorOnExit();
+        restoreCursor();
         this.#stream.write(HIDE_CURSOR);
     }
     #showCursor() {
@@ -434,7 +436,7 @@ export class Ora {
     #installHook() {
         if (!this.isEnabled || this.#hookedStreams.size > 0)
             return;
-        for (const stream of new Set([this.#stream, process.stdout, process.stderr]))
+        for (const stream of new Set([this.#stream, rt.stdout, rt.stderr]))
             this.#hookStream(stream);
     }
     #hookStream(stream) {

package/dist/plugin.d.ts

@@ -60,7 +60,7 @@ export interface Plugin {
  * the lock has to read the source to work across the family, and it does. A `const` array
  * would therefore buy nothing and cost ~195 B on `./spinner`, which has 82 B of headroom.
  */
-export type PluginErrorCode = 'E_PLUGIN_SCHEMA' | 'E_NO_STATIC_PROJECTION' | 'E_PLUGIN_CONTRACT' | 'E_UNKNOWN_SPINNER' | 'E_UNKNOWN_BORDER' | 'E_NO_CONTRIBUTION' | 'E_COMPONENT_THREW';
+export type PluginErrorCode = 'E_PLUGIN_SCHEMA' | 'E_NO_STATIC_PROJECTION' | 'E_PLUGIN_CONTRACT' | 'E_UNKNOWN_SPINNER' | 'E_UNKNOWN_BORDER' | 'E_NO_CONTRIBUTION' | 'E_COMPONENT_THREW' | 'E_UNKNOWN_KIND';
 /** A refused plugin says what is wrong, where, and what to do about it. */
 export declare class PluginError extends Error {
     readonly code: PluginErrorCode;

package/dist/projection.d.ts

@@ -1,11 +1,4 @@
-/**
- * The per-mode writers (R1). This is the only module in the package that emits a cursor
- * operation, and it does so only in `tty`; every other projection is text and a newline,
- * which is what R5 greps for. Streams and time come in as arguments — nothing here knows
- * `process` exists. The three sequences are written by hand rather than through
- * `node:readline`, whose helpers want a `Writable` where the loop only has a `Writer`.
- */
-import { HIDE_CURSOR, SHOW_CURSOR } from './cursor.js';
+import { HIDE_CURSOR, SHOW_CURSOR } from 'closeout/cursor';
 import { type Component } from './plugin.js';
 export interface Writer {
     write(chunk: string): unknown;

package/dist/projection.js

@@ -1,4 +1,5 @@
-import { HIDE_CURSOR, restoreCursorOnExit, SHOW_CURSOR } from './cursor.js';
+import { onExit } from 'closeout';
+import { HIDE_CURSOR, SHOW_CURSOR } from 'closeout/cursor';
 export const DEFAULT_INTERVAL = 80;
 const CSI = '\u001B[';
 const NO_NET = () => undefined;
@@ -27,7 +28,7 @@ class TtyProjection {
     open(state) {
         this.#current = state;
         this.#out.write(HIDE_CURSOR);
-        this.#dropCursorNet = restoreCursorOnExit((s) => void this.#out.write(s));
+        this.#dropCursorNet = onExit(() => void this.#out.write(SHOW_CURSOR), { phase: 'restore' });
         this.#paint();
         if (this.#component.frame !== undefined)
             this.#cancel = this.#clock.schedule(() => this.#repaint(), this.#interval);

package/dist/runtime.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Only the members this package actually reads. Anything not named here — `process.exit`,
+ * `cwd`, `chdir`, `emit` — is unreachable through the seam by construction, because the
+ * declared type is this and not `NodeJS.Process`.
+ */
+export interface Runtime {
+    readonly env: NodeJS.ProcessEnv;
+    readonly argv: string[];
+    readonly platform: NodeJS.Platform;
+    readonly pid: number;
+    readonly stdin: NodeJS.ReadStream & {
+        fd: 0;
+    };
+    readonly stdout: NodeJS.WriteStream & {
+        fd: 1;
+    };
+    readonly stderr: NodeJS.WriteStream & {
+        fd: 2;
+    };
+    /** Set by `cli.ts` on the way out. Typed as node types it, string included. */
+    exitCode?: number | string | null | undefined;
+    kill(pid: number, signal: NodeJS.Signals): void;
+}
+/**
+ * The real process, narrowed. Nothing is read here: every access through the returned
+ * `Runtime` reaches the live process at the moment the caller makes it, which is what keeps
+ * `boxen`'s width lazy and lets ora's suite swap `process.kill` under a running spinner.
+ */
+export declare const processRuntime: () => Runtime;

package/dist/runtime.js

@@ -0,0 +1,2 @@
+import process from 'node:process';
+export const processRuntime = () => process;

package/dist/schema.json

@@ -1 +1 @@
-{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://github.com/ofri-peretz/burgee/blob/main/packages/flagstaff/src/schema.json","title":"flagstaff plugin","description":"A plugin is one plain object. Everything in it is data that can be read without running it; the only functions allowed are a component's `static` (required) and `frame` (optional). A spinner or component without a static projection is refused at register().","type":"object","required":["name"],"additionalProperties":true,"properties":{"name":{"type":"string","minLength":1,"description":"The plugin's name; also the prefix a host may use when two plugins contribute the same key."},"contract":{"type":"integer","minimum":1,"description":"The plugin contract this object follows. A host refuses a newer contract than it knows."},"tokens":{"type":"object","description":"A roundel theme: semantic token name to a hex colour, contrast-checked when flown.","additionalProperties":{"type":"string","pattern":"^#[0-9a-fA-F]{6}$"}},"glyphs":{"type":"object","description":"Symbols by meaning: `ok`, `fail`, `warn`, `info`, `running`. A plugin that ships glyphs changes every built-in that draws one.","additionalProperties":{"type":"string","minLength":1}},"spinners":{"type":"object","description":"Spinner styles by name, in cli-spinners' shape plus the static projection.","additionalProperties":{"$ref":"#/$defs/spinner"}},"borders":{"type":"object","description":"Border styles a box can be drawn with, by name.","additionalProperties":{"$ref":"#/$defs/border"}},"components":{"type":"object","description":"Components by name: `static(state)` returns the text a pipe, an agent or a screen reader gets; `frame(t, state)` is the optional animated form.","additionalProperties":{"$ref":"#/$defs/component"}}},"$defs":{"spinner":{"type":"object","required":["frames","interval","static"],"properties":{"frames":{"type":"array","items":{"type":"string"},"minItems":1},"interval":{"type":"integer","minimum":1,"description":"Milliseconds between frames on a terminal."},"static":{"type":"string","description":"What a pipe prints instead of the animation."}}},"component":{"type":"object","required":["static"],"properties":{"static":{"description":"(state) => string. Required: the projection every non-terminal mode prints."},"frame":{"description":"(t, state) => string. Optional: the frame at t milliseconds since hoisting."},"sample":{"type":"object","required":["running","done"],"description":"Two states to *show* this component with: `flagstaff check` and the docs gallery render `running` then `done`. Omitted, they assume `{ phase: 'running' }` and `{ phase: 'done' }` and say so in the output. The loop never reads it — a running program's state comes from the program.","properties":{"running":{"description":"The state to open with."},"done":{"description":"The state to close with."}}},"interval":{"type":"integer","minimum":1,"description":"Milliseconds between repaints when `frame` is given; 80 when omitted."}}},"border":{"type":"object","required":["topLeft","top","topRight","left","right","bottomLeft","bottom","bottomRight"],"description":"cli-boxes' shape exactly, so that corpus imports unchanged.","properties":{"topLeft":{"type":"string"},"top":{"type":"string"},"topRight":{"type":"string"},"left":{"type":"string"},"right":{"type":"string"},"bottomLeft":{"type":"string"},"bottom":{"type":"string"},"bottomRight":{"type":"string"}}}}}
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://github.com/ofri-peretz/burgee/blob/main/packages/flagstaff/src/schema.json","title":"flagstaff plugin","description":"A plugin is one plain object. Everything in it is data that can be read without running it; the only functions allowed are a component's `static` (required) and `frame` (optional). A spinner or component without a static projection is refused at register().","type":"object","required":["name"],"additionalProperties":true,"properties":{"name":{"type":"string","minLength":1,"description":"The plugin's name; also the prefix a host may use when two plugins contribute the same key."},"contract":{"type":"integer","minimum":1,"description":"The plugin contract this object follows. A host refuses a newer contract than it knows."},"tokens":{"type":"object","description":"A roundel theme: semantic token name to a hex colour, contrast-checked when flown.","additionalProperties":{"type":"string","pattern":"^#[0-9a-fA-F]{6}$"},"propertyNames":{"enum":["error","warn","ok","hint","muted","command","flag","value","heading","ground"],"description":"roundel's ten semantic tokens, and nothing else — `roundel`'s own validate() refuses any other name."}},"glyphs":{"type":"object","description":"Symbols by meaning: `ok`, `fail`, `warn`, `info`, `running`. A plugin that ships glyphs changes every built-in that draws one.","additionalProperties":{"type":"string","minLength":1}},"spinners":{"type":"object","description":"Spinner styles by name, in cli-spinners' shape plus the static projection.","additionalProperties":{"$ref":"#/$defs/spinner"}},"borders":{"type":"object","description":"Border styles a box can be drawn with, by name.","additionalProperties":{"$ref":"#/$defs/border"}},"components":{"type":"object","description":"Components by name: `static(state)` returns the text a pipe, an agent or a screen reader gets; `frame(t, state)` is the optional animated form.","additionalProperties":{"$ref":"#/$defs/component"}},"capabilities":{"$ref":"#/$defs/capabilities"}},"$defs":{"spinner":{"type":"object","required":["frames","interval","static"],"properties":{"frames":{"type":"array","items":{"type":"string"},"minItems":1},"interval":{"type":"integer","minimum":1,"description":"Milliseconds between frames on a terminal."},"static":{"type":"string","description":"What a pipe prints instead of the animation."}}},"component":{"type":"object","required":["static"],"properties":{"static":{"description":"(state) => string. Required: the projection every non-terminal mode prints."},"frame":{"description":"(t, state) => string. Optional: the frame at t milliseconds since hoisting."},"sample":{"type":"object","required":["running","done"],"description":"Two states to *show* this component with: `flagstaff check` and the docs gallery render `running` then `done`. Omitted, they assume `{ phase: 'running' }` and `{ phase: 'done' }` and say so in the output. The loop never reads it — a running program's state comes from the program.","properties":{"running":{"description":"The state to open with."},"done":{"description":"The state to close with."}}},"interval":{"type":"integer","minimum":1,"description":"Milliseconds between repaints when `frame` is given; 80 when omitted."}}},"border":{"type":"object","required":["topLeft","top","topRight","left","right","bottomLeft","bottom","bottomRight"],"description":"cli-boxes' shape exactly, so that corpus imports unchanged.","properties":{"topLeft":{"type":"string"},"top":{"type":"string"},"topRight":{"type":"string"},"left":{"type":"string"},"right":{"type":"string"},"bottomLeft":{"type":"string"},"bottom":{"type":"string"},"bottomRight":{"type":"string"}}},"capability":{"type":"object","required":["name","osc","when","encode","fallback"],"additionalProperties":false,"description":"One paratext capability: what it says to the terminal, when the terminal is believed to understand it, and what prints when it does not. No functions, so it travels through JSON. `encode` and `fallback` are templates: `{field}` is the field's value, `{field|base64}` is it base64-encoded, and `[ … ]` is emitted only when every field inside it has a value.","properties":{"name":{"type":"string","minLength":1,"description":"How callers name it. Registering an existing name replaces it — how a caller corrects a guess we got wrong."},"osc":{"description":"The OSC code this speaks, or 'BEL' for the bell and for protocols that are not OSC at all, such as Kitty's.","oneOf":[{"type":"integer","minimum":0},{"const":"BEL"}]},"when":{"type":"object","description":"When the terminal is believed to understand it. Every clause must hold; `termProgram` and `envAny` are ORs within themselves. Guesses — no terminal answers 'do you do OSC 1337' — and therefore data a caller can replace.","additionalProperties":false,"properties":{"tty":{"type":"boolean","description":"Refuse a pipe. Almost always true: a file that receives OSC gets control bytes in it."},"termProgram":{"type":"array","items":{"type":"string"},"description":"Any one of these TERM_PROGRAM values."},"envAny":{"type":"array","items":{"type":"string"},"description":"Any one of these environment variables merely being set, as VTE announces itself."},"term":{"type":"string","description":"An exact TERM — Kitty is xterm-kitty."}}},"encode":{"type":"string","minLength":1,"description":"The bytes, as a template, for a terminal that does understand."},"fallback":{"type":"string","description":"What to print when it does not — PRINCIPLES rule 6. '' is a legitimate answer, a window title having nothing to say in a log; absence is not, which is why this is required and may be ''."}},"examples":[{"name":"kitty-image","osc":"BEL","when":{"tty":true,"term":"xterm-kitty"},"encode":"\u001b_Ga=T,f=100;{base64}\u001b\\","fallback":"{caption}"}]},"capabilities":{"type":"object","description":"paratext capabilities by name — the OSC section of a plugin, read the way flagstaff reads `spinners`.","additionalProperties":{"$ref":"#/$defs/capability"}},"capabilityDocument":{"description":"What paratext's `check()` accepts. Two shapes, and only one of them survives 1.0.","oneOf":[{"description":"The family shape: a plugin carrying its capabilities under `capabilities`.","type":"object","required":["name","capabilities"],"properties":{"name":{"type":"string","minLength":1},"contract":{"type":"integer","minimum":1},"capabilities":{"$ref":"#/$defs/capabilities"}}},{"deprecated":true,"description":"Deprecated: one capability as the whole document, the shape paratext's schema had before this one absorbed it. Accepted for one minor release, removed at 1.0 — `check()` validates it and says so.","$ref":"#/$defs/capability"}]}}}

package/dist/table.d.ts

@@ -1,5 +1,7 @@
+import { type Cell, type Terminal } from './link.js';
 import { type Component } from './plugin.js';
-export type Row = string[];
+/** A row of cells. A plain `string[]` is still a row — a destination is opt-in per cell. */
+export type Row = Cell[];
 export interface TableOptions {
     /** Column headers. Omitted, the table is drawn without a header row. */
     head?: string[];
@@ -7,6 +9,12 @@ export interface TableOptions {
     width?: number;
     /** Alignment per column; `left` for any column not named. */
     align?: ('left' | 'right')[];
+    /**
+     * The terminal a linked cell is rendered for. Omitted, the real process is read through
+     * this package's seam. Supply one and the whole path is pure — which is how `link.test.ts`
+     * grades both branches without a terminal in sight.
+     */
+    terminal?: Terminal;
 }
 /** Draw `rows` as a table, as a string. */
 export declare function table(rows: Row[], options?: TableOptions): string;
@@ -16,3 +24,5 @@ export interface TableState {
 }
 /** A table as a component: `header: value` pairs off a terminal, the grid on one (R1). */
 export declare function tableComponent(options?: TableOptions): Component<TableState>;
+/** The cell shapes, re-exported so a caller of `flagstaff/table` can name them (R12). */
+export type { Cell, Linked } from './link.js';

package/dist/table.js

@@ -1,6 +1,7 @@
 import { width } from 'linegauge';
 import { wrap } from 'linegauge/wrap';
 import { heading, muted } from 'roundel/tokens';
+import { cellHref, cellText, laid, painted, painter, STATIC } from './link.js';
 const DEFAULT_WIDTH = 80;
 const CHROME_PER_COLUMN = 3;
 const CHROME_FIXED = 1;
@@ -8,15 +9,15 @@ const MIN_COLUMN = 3;
 const V = '│';
 const H = '─';
 const CORNERS = { topLeft: '┌', topRight: '┐', bottomLeft: '└', bottomRight: '┘', top: '┬', bottom: '┴', left: '├', right: '┤', cross: '┼' };
-const padTo = (line, cells, align) => {
-    const gap = ' '.repeat(Math.max(0, cells - width(line)));
+const padTo = (line, cells, align, measured = line) => {
+    const gap = ' '.repeat(Math.max(0, cells - width(measured)));
     return align === 'right' ? gap + line : line + gap;
 };
-function naturalWidths(rows, columns) {
+function naturalWidths(rows, columns, paint) {
     const widths = Array.from({ length: columns }, () => 0);
     for (const row of rows) {
         for (let index = 0; index < columns; index += 1)
-            widths[index] = Math.max(widths[index] ?? 0, width(row[index] ?? ''));
+            widths[index] = Math.max(widths[index] ?? 0, width(laid(cellText(row[index]), cellHref(row[index]), paint)));
     }
     return widths;
 }
@@ -35,10 +36,15 @@ function fitWidths(natural, available) {
     }
     return widths;
 }
-function layoutRow(row, widths, align) {
-    const cells = widths.map((w, index) => wrap(row[index] ?? '', w, { hard: true, trim: false }).split('\n'));
+function layoutRow(row, widths, align, paint) {
+    const cells = widths.map((w, index) => wrap(laid(cellText(row[index]), cellHref(row[index]), paint), w, { hard: true, trim: false }).split('\n'));
     const height = Math.max(1, ...cells.map((lines) => lines.length));
-    return Array.from({ length: height }, (_, line) => `${V} ${widths.map((w, index) => padTo(cells[index]?.[line] ?? '', w, align[index] ?? 'left')).join(` ${V} `)} ${V}`);
+    return Array.from({ length: height }, (_, line) => `${V} ${widths
+        .map((w, index) => {
+        const plain = cells[index]?.[line] ?? '';
+        return padTo(painted(plain, cellHref(row[index]), paint), w, align[index] ?? 'left', plain);
+    })
+        .join(` ${V} `)} ${V}`);
 }
 const rule = (widths, left, mid, right) => left + widths.map((w) => H.repeat(w + 2)).join(mid) + right;
 export function table(rows, options = {}) {
@@ -46,23 +52,28 @@ export function table(rows, options = {}) {
     const total = options.width ?? DEFAULT_WIDTH;
     const align = options.align ?? [];
     const available = Math.max(columns * MIN_COLUMN, total - columns * CHROME_PER_COLUMN - CHROME_FIXED);
+    const paint = painter(options.terminal);
     const all = options.head === undefined ? rows : [options.head, ...rows];
-    const widths = fitWidths(naturalWidths(all, columns), available);
+    const widths = fitWidths(naturalWidths(all, columns, paint), available);
     const out = [rule(widths, CORNERS.topLeft, CORNERS.top, CORNERS.topRight)];
     if (options.head !== undefined) {
-        out.push(...layoutRow(options.head.map((cell) => heading(cell)), widths, align), rule(widths, CORNERS.left, CORNERS.cross, CORNERS.right));
+        out.push(...layoutRow(options.head.map((cell) => heading(cell)), widths, align, paint), rule(widths, CORNERS.left, CORNERS.cross, CORNERS.right));
     }
     for (const row of rows)
-        out.push(...layoutRow(row, widths, align));
+        out.push(...layoutRow(row, widths, align, paint));
     out.push(rule(widths, CORNERS.bottomLeft, CORNERS.bottom, CORNERS.bottomRight));
     return out.join('\n');
 }
 export function tableComponent(options = {}) {
+    const plain = painter(STATIC);
     return {
         name: 'table',
         static: (state) => {
             const head = state.head ?? options.head;
-            return state.rows.map((row) => (head === undefined ? row.join('\t') : row.map((cell, index) => `${head[index] ?? index}: ${cell}`).join(', '))).join('\n');
+            const show = (cell) => laid(cellText(cell), cellHref(cell), plain);
+            return state.rows
+                .map((row) => (head === undefined ? row.map((cell) => show(cell)).join('\t') : row.map((cell, index) => `${head[index] ?? index}: ${show(cell)}`).join(', ')))
+                .join('\n');
         },
         frame: (_t, state) => muted(table(state.rows, state.head === undefined ? options : { ...options, head: state.head })),
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagstaff",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "The staff the flag flies from. A terminal frame loop with a static projection for agents and screen readers, and a plugin host for spinners, progress, boxes and tables. Drop-in paths for ora, log-update, boxen and cli-table3. Zero dependencies.",
   "license": "MIT",
   "type": "module",
@@ -115,10 +115,13 @@
     "plugins"
   ],
   "dependencies": {
-    "linegauge": "^0.2.0",
-    "roundel": "^0.3.0"
+    "closeout": "^0.2.0",
+    "linegauge": "^0.3.0",
+    "paratext": "^0.3.0",
+    "roundel": "^0.3.1"
   },
   "devDependencies": {
+    "fast-check": "^4.10.0",
     "vitest": "^5.0.0"
   }
 }

package/dist/cursor.d.ts

@@ -1,13 +0,0 @@
-export declare const HIDE_CURSOR = "\u001B[?25l";
-export declare const SHOW_CURSOR = "\u001B[?25h";
-/**
- * Installed once, the first time a cursor is hidden; puts it back however the process dies.
- *
- * `write` is how the caller's own surface reaches the terminal, and passing it is what makes
- * this usable from the core. `hoist()` already knows its stream — the Runtime gave it one and
- * the output mode was decided from it once (R1/U2) — so it must not be re-detected here: a
- * second detector is precisely what the policy exists to prevent. The façades pass nothing
- * and get the detection below, because that is their incumbents' contract — ora and
- * log-update restore *the process's* cursor whichever stream the caller handed them.
- */
-export declare function restoreCursorOnExit(write?: (s: string) => void): () => void;

package/dist/cursor.js

@@ -1,49 +0,0 @@
-import { constants } from 'node:os';
-import process from 'node:process';
-export const HIDE_CURSOR = '\u001B[?25l';
-export const SHOW_CURSOR = '\u001B[?25h';
-const TERMINATION_SIGNALS = ['SIGHUP', 'SIGINT', 'SIGTERM', 'SIGBREAK'].filter((signal) => signal in constants.signals);
-function terminalStream() {
-    if (process.stderr.isTTY)
-        return process.stderr;
-    if (process.stdout.isTTY)
-        return process.stdout;
-    return undefined;
-}
-let cursorRestoreInstalled = false;
-const NOTHING_TO_UNDO = () => undefined;
-export function restoreCursorOnExit(write) {
-    if (cursorRestoreInstalled)
-        return NOTHING_TO_UNDO;
-    cursorRestoreInstalled = true;
-    const terminal = write === undefined ? terminalStream() : { write };
-    if (terminal === undefined)
-        return NOTHING_TO_UNDO;
-    let restored = false;
-    const restore = () => {
-        if (restored)
-            return;
-        restored = true;
-        terminal.write(SHOW_CURSOR);
-    };
-    const installed = new Map();
-    const uninstall = () => {
-        for (const [name, fn] of installed)
-            process.removeListener(name, fn);
-        installed.clear();
-        process.removeListener('exit', restore);
-        cursorRestoreInstalled = false;
-    };
-    for (const signal of TERMINATION_SIGNALS) {
-        const handler = () => {
-            restore();
-            uninstall();
-            if (process.listenerCount(signal) === 0)
-                process.kill(process.pid, signal);
-        };
-        process.on(signal, handler);
-        installed.set(signal, handler);
-    }
-    process.once('exit', restore);
-    return uninstall;
-}