flagstaff 0.0.1 → 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { hoist, manualClock } from './loop.js';
+import { PluginError, register, registered } from './plugin.js';
+import { spinner } from './spinner.js';
+const MODES = ['tty', 'pipe', 'ci', 'json', 'accessible'];
+const ENV = { tty: {}, pipe: {}, ci: { CI: 'true' }, json: {}, accessible: { CLI_ACCESSIBLE: '1' } };
+const LABEL_WIDTH = 12;
+const FRAMES_SHOWN = 3;
+const EXIT_USAGE = 2;
+const KNOWN = ['$schema', 'name', 'contract', 'tokens', 'glyphs', 'spinners', 'borders', 'components'];
+const KINDS = ['spinners', 'borders', 'components', 'glyphs', 'tokens'];
+const ASSUMED = { running: { phase: 'running' }, done: { phase: 'done' } };
+const SPIN = { running: { text: 'working' }, done: { text: 'done', status: 'ok' } };
+const FIX_NO_CONTRIBUTION = 'flagstaff reads spinners, borders, components, glyphs and tokens; check those spellings. A key another package in the family reads is allowed in the same object, but `flagstaff check` cannot grade one.';
+const FIX_THREW = '`static(state)` must return a string for the state it is rendered with; give the component a `sample: { running, done }` of the shape it expects';
+const visible = (s) => s.replaceAll('\u001B', '␛').replaceAll('\r', '␍').replaceAll('\n', '⏎ ');
+function render(component, mode, sample) {
+    const out = [];
+    const err = [];
+    const clock = manualClock();
+    const rt = { env: ENV[mode], isTTY: { stdout: mode === 'tty' }, stdout: { write: (s) => out.push(s) }, stderr: { write: (s) => err.push(s) }, clock };
+    try {
+        const flag = hoist(component, rt, sample.running, { json: mode === 'json' });
+        for (let i = 0; i < FRAMES_SHOWN; i += 1)
+            clock.tick(component.interval ?? 0);
+        flag.lower(sample.done);
+    }
+    catch (e) {
+        return { text: `threw: ${e instanceof Error ? e.message : String(e)}`, threw: true };
+    }
+    return { text: visible([...out, ...err].join('')), threw: false };
+}
+const row = (label, text) => `  ${label.padEnd(LABEL_WIDTH)}${text}\n`;
+function show(title, component, { sample, note }, write) {
+    write(`${title}\n`);
+    if (note !== '')
+        write(row('sample', note));
+    const broke = [];
+    for (const mode of MODES) {
+        const { text, threw } = render(component, mode, sample);
+        if (threw)
+            broke.push(mode);
+        write(row(mode, text));
+    }
+    return broke;
+}
+function census(plugin) {
+    let total = 0;
+    const parts = KINDS.map((kind) => {
+        const n = Object.keys((plugin[kind] ?? {})).length;
+        total += n;
+        return `${n} ${n === 1 ? kind.slice(0, -1) : kind}`;
+    });
+    return { line: parts.join(', '), total };
+}
+function refuse(code, message, fix, write) {
+    write(`${code}: ${message}\n  fix: ${fix}\n`);
+    return 1;
+}
+function sampleFor(def) {
+    const own = def.sample;
+    if (own === undefined)
+        return { sample: ASSUMED, note: `assumed ${JSON.stringify(ASSUMED)} — give the component a \`sample\` to choose its own` };
+    return { sample: own, note: `from the component: ${describe(own)}` };
+}
+function describe(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return '(not serializable — shown as given)';
+    }
+}
+async function main(argv, write) {
+    const file = argv[0];
+    if (file === undefined) {
+        write('usage: flagstaff check <plugin-file>\n');
+        return EXIT_USAGE;
+    }
+    const before = new Set(registered().plugins);
+    const loaded = (await import(pathToFileURL(resolve(file)).href));
+    const plugin = loaded.default ?? loaded;
+    try {
+        register(plugin);
+    }
+    catch (e) {
+        if (!(e instanceof PluginError))
+            throw e;
+        return refuse(e.code, e.message, e.fix, write);
+    }
+    const { name, spinners = {}, components = {} } = plugin;
+    const { line, total } = census(plugin);
+    write(`${name} — ${line}\n`);
+    const unknown = Object.keys(plugin)
+        .filter((key) => !KNOWN.includes(key))
+        .sort();
+    if (unknown.length > 0)
+        write(row('unknown', `${unknown.join(', ')} — flagstaff reads none of these; a key another package in the family reads is allowed here`));
+    if (total === 0)
+        return refuse('E_NO_CONTRIBUTION', `${name} registers, but contributes nothing flagstaff can render`, FIX_NO_CONTRIBUTION, write);
+    const broke = [];
+    for (const style of Object.keys(spinners)) {
+        const modes = show(`spinner ${style}`, spinner(style), { sample: SPIN, note: '' }, write);
+        if (modes.length > 0)
+            broke.push(`spinner ${style} threw in ${modes.join(', ')}`);
+    }
+    for (const [cname, def] of Object.entries(components)) {
+        const modes = show(`component ${cname}`, { ...def, name: cname }, sampleFor(def), write);
+        if (modes.length > 0)
+            broke.push(`${cname} threw in ${modes.join(', ')}`);
+    }
+    if (broke.length > 0)
+        return refuse('E_COMPONENT_THREW', broke.join('; '), FIX_THREW, write);
+    write(`${name}: ok${before.has(name) ? ' (replaces an earlier registration)' : ''}\n`);
+    return 0;
+}
+const [, , command, ...rest] = process.argv;
+const args = command === 'check' ? rest : [command, ...rest].filter((a) => a !== undefined);
+main(args, (s) => process.stdout.write(s)).then((code) => {
+    process.exitCode = code;
+}, (e) => {
+    process.stderr.write(`${e instanceof Error ? e.message : String(e)}\n`);
+    process.exitCode = 1;
+});

package/dist/cursor.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,49 @@
+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;
+}

package/dist/import.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `flagstaff/import` (R11) — the two data corpora the ecosystem already has, as plugins.
+ *
+ * cli-spinners ships ~80 spinner styles and cli-boxes ships eight border sets, both as
+ * plain JSON that thousands of programs already depend on. Neither is bundled here: the
+ * weight of a corpus nobody asked for is exactly what U5 is about, and a caller who wants
+ * one already has it on disk. So these take the JSON and hand back a plugin:
+ *
+ * ```js
+ * import cliSpinners from 'cli-spinners';
+ * import { fromCliSpinners } from 'flagstaff/import';
+ * import { register } from 'flagstaff/plugin';
+ *
+ * register(fromCliSpinners(cliSpinners));
+ * spinner('moon');
+ * ```
+ *
+ * The result is an ordinary plugin — it goes through the same `register()`, is validated
+ * against the same schema, and can be replaced by another. That is the point: the gallery
+ * opens full, and a third-party plugin starts as a copy of one of these.
+ */
+import { type BorderStyle, type Plugin } from './plugin.js';
+/** cli-spinners' shape: no `static`, because it has no projection for a pipe. */
+export interface CliSpinner {
+    frames: string[];
+    interval?: number;
+}
+/** cli-boxes' shape — the same eight keys `BorderStyle` has, which is why it imports whole. */
+export type CliBox = BorderStyle;
+export interface FromCliSpinnersOptions {
+    /** The plugin's name, which is what `flagstaff check` and the gallery label it with. */
+    name?: string;
+    /**
+     * The static projection for a style, given its name and its frames. Default: `'…'` for
+     * every one of them.
+     *
+     * The design sketched "the first frame" here, and that turned out to be wrong when it met
+     * the corpus: a frozen `⠋` or `▰` is an animation stopped mid-stride, not a projection —
+     * it tells a pipe, an agent and a screen reader nothing that `…` does not tell them
+     * better. The parameter exists because it is the author's call, not this function's.
+     */
+    staticFor?: (name: string, spinner: CliSpinner) => string;
+}
+/** Turn cli-spinners' `spinners.json` into a plugin. The corpus stays the caller's. */
+export declare function fromCliSpinners(corpus: Record<string, CliSpinner>, { name, staticFor }?: FromCliSpinnersOptions): Plugin;
+export interface FromCliBoxesOptions {
+    name?: string;
+}
+/** Turn cli-boxes' `boxes.json` into a plugin. Its shape is already ours, so this is a copy. */
+export declare function fromCliBoxes(corpus: Record<string, CliBox>, { name }?: FromCliBoxesOptions): Plugin;

package/dist/import.js

@@ -0,0 +1,20 @@
+const DEFAULT_INTERVAL = 80;
+const DEFAULT_STATIC = '…';
+export function fromCliSpinners(corpus, { name = 'cli-spinners', staticFor = () => DEFAULT_STATIC } = {}) {
+    const spinners = {};
+    for (const [style, spinner] of Object.entries(corpus)) {
+        if (!Array.isArray(spinner?.frames) || spinner.frames.length === 0)
+            continue;
+        spinners[style] = { frames: spinner.frames, interval: spinner.interval ?? DEFAULT_INTERVAL, static: staticFor(style, spinner) };
+    }
+    return { name, contract: 1, spinners };
+}
+export function fromCliBoxes(corpus, { name = 'cli-boxes' } = {}) {
+    const borders = {};
+    for (const [style, box] of Object.entries(corpus)) {
+        if (typeof box?.topLeft !== 'string')
+            continue;
+        borders[style] = box;
+    }
+    return { name, contract: 1, borders };
+}

package/dist/index.d.ts

@@ -1,6 +1,12 @@
 /**
- * flagstaff — reserved. The first working release follows
- * docs/intents/cli-render/ in the burgee repository. Until then this entry
- * exports only its own name, so that importing it costs nothing and promises nothing.
+ * flagstaff — the staff the flag flies from. Re-exports only; each subpath is its own entry
+ * and costs only itself, so prefer `flagstaff/spinner` when that is all you need.
  */
-export declare const name: "flagstaff";
+export * from './box.js';
+export * from './import.js';
+export * from './loop.js';
+export * from './plugin.js';
+export * from './progress.js';
+export * from './spinner.js';
+export * from './table.js';
+export * from './tasks.js';

package/dist/index.js

@@ -1,7 +1,8 @@
-/**
- * flagstaff — reserved. The first working release follows
- * docs/intents/cli-render/ in the burgee repository. Until then this entry
- * exports only its own name, so that importing it costs nothing and promises nothing.
- */
-export const name = 'flagstaff';
-//# sourceMappingURL=index.js.map
+export * from './box.js';
+export * from './import.js';
+export * from './loop.js';
+export * from './plugin.js';
+export * from './progress.js';
+export * from './spinner.js';
+export * from './table.js';
+export * from './tasks.js';

package/dist/log-update.d.ts

@@ -0,0 +1,29 @@
+/** What log-update writes to: `process.stdout` by default, anything stream-shaped in a test. */
+export interface LogUpdateStream {
+    write(chunk: string): unknown;
+    columns?: number;
+    rows?: number;
+    isTTY?: boolean;
+}
+export interface LogUpdateOptions {
+    /** Leave the cursor visible while a frame is up. Default false. */
+    showCursor?: boolean;
+    /** Columns to assume when the stream reports none. Default 80. */
+    defaultWidth?: number;
+    /** Rows to assume when the stream reports none. Default 24. */
+    defaultHeight?: number;
+}
+export interface LogUpdate {
+    (...text: unknown[]): void;
+    /** Erase the current frame, leaving nothing behind. */
+    clear(): void;
+    /** Give up the rows: the frame stays on screen and the next render starts fresh. */
+    done(): void;
+    /** 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`. */
+export declare function createLogUpdate(stream: LogUpdateStream, { showCursor: keepCursor, defaultWidth, defaultHeight }?: LogUpdateOptions): LogUpdate;
+declare const logUpdate: LogUpdate;
+export declare const logUpdateStderr: LogUpdate;
+export default logUpdate;

package/dist/log-update.js

@@ -0,0 +1,173 @@
+import process from 'node:process';
+import { HIDE_CURSOR, restoreCursorOnExit, SHOW_CURSOR } from './cursor.js';
+import { wrap } from './wrap.js';
+const CSI = '\u001B[';
+const SYNCHRONIZED_OUTPUT_ENABLE = `${CSI}?2026h`;
+const SYNCHRONIZED_OUTPUT_DISABLE = `${CSI}?2026l`;
+const CURSOR_LEFT = `${CSI}G`;
+const ERASE_LINE = `${CSI}2K`;
+const ERASE_END_LINE = `${CSI}K`;
+const DEFAULT_WIDTH = 80;
+const DEFAULT_HEIGHT = 24;
+const cursorUp = (count = 1) => `${CSI}${count}A`;
+const cursorDown = (count = 1) => `${CSI}${count}B`;
+const eraseLines = (count) => {
+    let sequence = '';
+    for (let index = 0; index < count; index += 1)
+        sequence += ERASE_LINE + (index < count - 1 ? cursorUp() : '');
+    return count > 0 ? sequence + CURSOR_LEFT : sequence;
+};
+function hideCursor() {
+    if (process.stderr.isTTY !== true)
+        return;
+    restoreCursorOnExit();
+    process.stderr.write(HIDE_CURSOR);
+}
+function showCursor() {
+    if (process.stderr.isTTY !== true)
+        return;
+    process.stderr.write(SHOW_CURSOR);
+}
+const countLines = (text) => text.split('\n').length;
+function fitToHeight(wrapped, terminalHeight) {
+    if (terminalHeight === 0)
+        return { text: '', wasClipped: wrapped !== '' };
+    const lines = wrapped.split('\n');
+    const toRemove = Math.max(0, lines.length - terminalHeight);
+    if (toRemove === 0)
+        return { text: wrapped, wasClipped: false };
+    return { text: lines.slice(toRemove).join('\n'), wasClipped: true };
+}
+function diffFrames(previousLines, nextLines) {
+    let start = 0;
+    while (start < previousLines.length && start < nextLines.length && previousLines[start] === nextLines[start])
+        start += 1;
+    let endPrevious = previousLines.length - 1;
+    let endNext = nextLines.length - 1;
+    while (endPrevious >= start && endNext >= start && previousLines[endPrevious] === nextLines[endNext]) {
+        endPrevious -= 1;
+        endNext -= 1;
+    }
+    return { start, endPrevious, endNext };
+}
+function moveToRow(from, to) {
+    const delta = to - from;
+    if (delta > 0)
+        return cursorDown(delta);
+    if (delta < 0)
+        return cursorUp(-delta);
+    return '';
+}
+function buildPatch({ previousCount, start, endPrevious, endNext, nextLines, endsWithNewline }) {
+    let sequence = moveToRow(previousCount - 1, start) + CURSOR_LEFT;
+    const linesToClear = Math.max(0, endPrevious - start + 1);
+    for (let index = 0; index < linesToClear; index += 1)
+        sequence += ERASE_LINE + (index < linesToClear - 1 ? cursorDown() : '');
+    if (linesToClear > 1)
+        sequence += cursorUp(linesToClear - 1);
+    sequence += CURSOR_LEFT;
+    const wrote = nextLines.slice(start, endNext + 1);
+    let writtenLineBreaks = 0;
+    if (wrote.length > 0) {
+        const chunk = wrote.join('\n');
+        const trailingNewline = endsWithNewline && endNext < nextLines.length - 1 && !chunk.endsWith('\n');
+        sequence += chunk;
+        writtenLineBreaks = countLines(chunk) - 1;
+        sequence += ERASE_END_LINE;
+        if (trailingNewline) {
+            sequence += '\n';
+            writtenLineBreaks += 1;
+        }
+    }
+    return sequence + moveToRow(start + writtenLineBreaks, nextLines.length - 1);
+}
+export function createLogUpdate(stream, { showCursor: keepCursor = false, defaultWidth, defaultHeight } = {}) {
+    const widthOf = () => stream.columns ?? defaultWidth ?? DEFAULT_WIDTH;
+    const heightOf = () => stream.rows ?? defaultHeight ?? DEFAULT_HEIGHT;
+    let previousLineCount = 0;
+    let previousWidth = widthOf();
+    let previousOutput = '';
+    const useSynchronizedOutput = stream.isTTY === true;
+    const write = (output) => {
+        if (output === '')
+            return;
+        stream.write(useSynchronizedOutput ? SYNCHRONIZED_OUTPUT_ENABLE + output + SYNCHRONIZED_OUTPUT_DISABLE : output);
+    };
+    const computeFrame = (text, columns, clipToHeight = true) => {
+        const textString = String(text);
+        const raw = textString.endsWith('\n') ? textString : `${textString}\n`;
+        const wrapped = wrap(raw, columns, { trim: false, hard: true, wordWrap: false });
+        const { text: frameText, wasClipped } = clipToHeight ? fitToHeight(wrapped, heightOf()) : { text: wrapped, wasClipped: false };
+        return { wrapped: frameText, lines: frameText === '' ? [] : frameText.split('\n'), wasClipped };
+    };
+    const reset = () => {
+        previousOutput = '';
+        previousWidth = widthOf();
+        previousLineCount = 0;
+    };
+    const remember = (frame, columns) => {
+        previousOutput = frame.wrapped;
+        previousWidth = columns;
+        previousLineCount = frame.lines.length;
+    };
+    const render = (...args) => {
+        if (!keepCursor)
+            hideCursor();
+        const columns = widthOf();
+        const frame = computeFrame(args.join(' '), columns);
+        const { wrapped, lines, wasClipped } = frame;
+        if (lines.length === 0) {
+            if (previousLineCount > 0)
+                write(eraseLines(previousLineCount));
+            remember(frame, columns);
+            return;
+        }
+        if (wrapped === previousOutput && previousWidth === columns)
+            return;
+        if (previousLineCount === 0) {
+            write(wrapped);
+            remember(frame, columns);
+            return;
+        }
+        if (previousWidth !== columns || wasClipped) {
+            write(eraseLines(previousLineCount) + wrapped);
+            remember(frame, columns);
+            return;
+        }
+        const previousLines = previousOutput === '' ? [] : previousOutput.split('\n');
+        let { start, endPrevious, endNext } = diffFrames(previousLines, lines);
+        if (previousLines.length !== lines.length) {
+            endPrevious = previousLines.length - 1;
+            endNext = lines.length - 1;
+        }
+        if (start === lines.length && previousLineCount === lines.length)
+            return;
+        if (start === 0) {
+            write(eraseLines(previousLineCount) + wrapped);
+            remember(frame, columns);
+            return;
+        }
+        write(buildPatch({ previousCount: previousLineCount, start, endPrevious, endNext, nextLines: lines, endsWithNewline: wrapped.endsWith('\n') }));
+        remember(frame, columns);
+    };
+    render.clear = () => {
+        write(eraseLines(previousLineCount));
+        reset();
+    };
+    render.done = () => {
+        reset();
+        if (!keepCursor)
+            showCursor();
+    };
+    render.persist = (...args) => {
+        const erasePrevious = previousLineCount > 0 ? eraseLines(previousLineCount) : '';
+        const columns = widthOf();
+        const { wrapped } = computeFrame(args.join(' '), columns, false);
+        write(erasePrevious + wrapped);
+        reset();
+    };
+    return render;
+}
+const logUpdate = createLogUpdate(process.stdout);
+export const logUpdateStderr = createLogUpdate(process.stderr);
+export default logUpdate;

package/dist/loop.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The frame loop (R1). `hoist()` raises a component, `update()` changes its state, `lower()`
+ * takes it down and leaves the static line behind. Which of the four projections runs is the
+ * output policy's decision (`roundel/policy`), read once from the runtime; this file never
+ * looks at a stream's `isTTY` or an environment variable itself (U2).
+ */
+import { type ModeOptions, type OutputMode, type Runtime as PolicyRuntime } from 'roundel/policy';
+import { type Component } from './plugin.js';
+import { type Clock, type Writer } from './projection.js';
+/** What the loop needs from the world: the policy's slice plus the two streams and a clock. */
+export interface Runtime extends PolicyRuntime {
+    stdout: Writer;
+    stderr: Writer;
+    clock: Clock;
+}
+export interface Hoisted<S> {
+    readonly mode: OutputMode;
+    update(state: S): void;
+    /** Lower the flag: the final state's static projection is what stays on screen. */
+    lower(state?: S): void;
+}
+/** Hoist a component in its initial state. Pass `{ json: true }` when the run was asked for `--json`. */
+export declare function hoist<S>(component: Component<S>, rt: Runtime, initial: S, opts?: ModeOptions): Hoisted<S>;
+export interface ManualClock extends Clock {
+    /** Advance by `ms`, running every callback that falls due, earliest first. */
+    tick(ms: number): void;
+}
+/** A clock that moves only when told (R9): the same frames every run, so a spinner snapshots. */
+export declare function manualClock(start?: number): ManualClock;
+export type { Clock, Writer } from './projection.js';

package/dist/loop.js

@@ -0,0 +1,67 @@
+import { outputMode } from 'roundel/policy';
+import { jsonProjection, staticProjection, ttyProjection } from './projection.js';
+function projectionFor(mode, component, rt) {
+    if (mode === 'tty')
+        return ttyProjection(component, rt.stdout, rt.clock);
+    if (mode === 'json')
+        return jsonProjection(component, rt.stderr);
+    return staticProjection(component, rt.stdout);
+}
+export function hoist(component, rt, initial, opts = {}) {
+    const mode = outputMode(rt, opts);
+    const projection = projectionFor(mode, component, rt);
+    let state = initial;
+    let lowered = false;
+    projection.open(state);
+    return {
+        mode,
+        update(next) {
+            if (lowered)
+                return;
+            state = next;
+            projection.change(state);
+        },
+        lower(final = state) {
+            if (lowered)
+                return;
+            lowered = true;
+            state = final;
+            projection.close(state);
+        },
+    };
+}
+const TICK_CAP = 1000;
+function nextDue(timers, until) {
+    return timers.filter((t) => t.at <= until).sort((a, b) => a.at - b.at || a.id - b.id)[0];
+}
+export function manualClock(start = 0) {
+    let now = start;
+    let nextId = 0;
+    let timers = [];
+    return {
+        now: () => now,
+        schedule(fn, ms) {
+            const id = nextId++;
+            timers.push({ id, at: now + Math.max(0, ms), fn });
+            return () => {
+                timers = timers.filter((t) => t.id !== id);
+            };
+        },
+        tick(ms) {
+            const until = now + ms;
+            let ran = 0;
+            let due = nextDue(timers, until);
+            while (due !== undefined && ran < TICK_CAP) {
+                const { id, at, fn } = due;
+                timers = timers.filter((t) => t.id !== id);
+                now = Math.max(now, at);
+                fn();
+                ran += 1;
+                due = nextDue(timers, until);
+            }
+            if (due !== undefined)
+                throw new Error(`manualClock: ${TICK_CAP} callbacks in one tick; something reschedules itself at 0 ms`);
+            now = until;
+        },
+    };
+}