toiljs 0.0.115 → 0.0.117

package/src/cli/ui.ts

@@ -1,169 +0,0 @@
-/**
- * Shared CLI presentation: the toiljs brand banner, gradient text, and small helpers.
- * Kept dependency-light (only picocolors); the gradient is hand-rolled truecolor ANSI so
- * the logo pops without pulling in a gradient library.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import pc from 'picocolors';
-
-type RGB = readonly [number, number, number];
-
-/** toiljs brand palette. */
-const PRIMARY: RGB = [37, 99, 255];
-const SECONDARY: RGB = [124, 58, 237];
-const ACCENT: RGB = [34, 227, 171];
-
-/** Logo gradient stops: blue → purple → teal. */
-const GRADIENT: readonly RGB[] = [PRIMARY, SECONDARY, ACCENT];
-
-/** ANSI-shadow "TOIL" wordmark. */
-const ART: readonly string[] = [
-    '████████╗  ██████╗  ██╗ ██╗     ',
-    '╚══██╔══╝ ██╔═══██╗ ██║ ██║     ',
-    '   ██║    ██║   ██║ ██║ ██║     ',
-    '   ██║    ██║   ██║ ██║ ██║     ',
-    '   ██║    ╚██████╔╝ ██║ ███████╗',
-    '   ╚═╝     ╚═════╝  ╚═╝ ╚══════╝',
-];
-
-export const dim = pc.dim;
-export const bold = pc.bold;
-
-/** True when we should emit ANSI color: a TTY (or FORCE_COLOR), and not disabled via NO_COLOR. */
-function colorEnabled(): boolean {
-    if (process.env.NO_COLOR) return false;
-    if (process.env.FORCE_COLOR) return true;
-    return process.stdout.isTTY;
-}
-
-function rgb(color: RGB, s: string): string {
-    return colorEnabled() ? `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${s}\x1b[39m` : s;
-}
-
-/** The primary brand accent (blue). No-ops to plain text when color is disabled. */
-export function brand(s: string): string {
-    return rgb(PRIMARY, s);
-}
-export const accent = brand;
-
-/** Success/positive accent (teal). */
-export function success(s: string): string {
-    return rgb(ACCENT, s);
-}
-
-/** Error accent (red, kept outside the brand palette since errors should read as errors). */
-export const danger = pc.red;
-
-/** Warning accent (yellow, outside the brand palette so warnings read as warnings). */
-export const warn = pc.yellow;
-
-function lerp(a: number, b: number, t: number): number {
-    return Math.round(a + (b - a) * t);
-}
-
-/** Samples the multi-stop brand gradient at `t` in [0, 1]. */
-function gradientAt(t: number): RGB {
-    const segments = GRADIENT.length - 1;
-    const scaled = t * segments;
-    const i = Math.min(Math.floor(scaled), segments - 1);
-    const a = GRADIENT[i];
-    const b = GRADIENT[i + 1];
-    const localT = scaled - i;
-    return [lerp(a[0], b[0], localT), lerp(a[1], b[1], localT), lerp(a[2], b[2], localT)];
-}
-
-/** Colors each character of `line` along the left→right brand gradient. */
-function gradientLine(line: string): string {
-    const n = line.length;
-    let out = '';
-    for (let i = 0; i < n; i++) {
-        const [r, g, b] = gradientAt(n > 1 ? i / (n - 1) : 0);
-        out += `\x1b[38;2;${r};${g};${b}m${line[i]}`;
-    }
-    return out + '\x1b[39m';
-}
-
-/** Reads the toiljs package version (CLI lives at build/cli/, package root is two up). */
-export function version(): string {
-    try {
-        const pkgPath = path.resolve(
-            path.dirname(fileURLToPath(import.meta.url)),
-            '..',
-            '..',
-            'package.json',
-        );
-        const raw = fs.readFileSync(pkgPath, 'utf8');
-        const match = /"version"\s*:\s*"([^"]+)"/.exec(raw);
-        if (match && match[1]) return match[1];
-    } catch {}
-    return '0.0.0';
-}
-
-// eslint-disable-next-line no-control-regex -- matching our own escape sequences is the point
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-
-/** The on-screen width of `s`, ignoring ANSI color codes. */
-function visibleWidth(s: string): number {
-    return s.replace(ANSI_RE, '').length;
-}
-
-/**
- * Frames already-colored lines in a rounded box sized to the widest line. `paint` colors the
- * border (the content keeps its own colors); padding is measured on the visible text, so ANSI
- * codes inside the lines never skew the right edge. Returns the box without a trailing newline.
- */
-export function box(lines: readonly string[], paint: (s: string) => string = (s) => s): string {
-    const width = lines.reduce((w, l) => Math.max(w, visibleWidth(l)), 0);
-    const side = paint('│');
-    const body = lines.map((l) => `  ${side}  ${l}${' '.repeat(width - visibleWidth(l))}  ${side}`);
-    return [
-        '  ' + paint(`╭${'─'.repeat(width + 4)}╮`),
-        ...body,
-        '  ' + paint(`╰${'─'.repeat(width + 4)}╯`),
-    ].join('\n');
-}
-
-/**
- * Banner taglines, one is picked at random per invocation. Each is a function so the accented
- * words pick up the brand color (or stay plain when color is disabled). The theme: TOIL is the
- * first full-stack framework for a globally distributed application delivery network.
- */
-const TAGLINES: ReadonlyArray<(a: (s: string) => string) => string> = [
-    (a) => `bringing ${a('hyper scale')} to anyone`,
-    (a) => `the first full-stack ${a('application delivery network')}`,
-    (a) => `your app, ${a('globally distributed')} by default`,
-    (a) => `one build, ${a('the whole planet')}`,
-    (a) => `full stack, ${a('zero distance')} to your users`,
-    (a) => `${a('react')} up front, ${a('wasm')} at every edge`,
-    (a) => `deployed where your ${a('users')} are`,
-    (a) => `the framework with a ${a('delivery network')} built in`,
-    (a) => `no regions, just ${a('the world')}`,
-    (a) => `${a('planet-scale')} apps from a single repo`,
-    (a) => `every request served ${a('next door')}`,
-    (a) => `frontend, backend, ${a('worldwide')}`,
-    (a) => `${a('hyper scale')} without the ops team`,
-    (a) => `your backend, ${a('compiled to wasm')}, running everywhere`,
-    (a) => `the internet is your ${a('runtime')}`,
-    (a) => `the speed of light is the ${a('only bottleneck')}`,
-    (a) => `static speed, ${a('dynamic everything')}`,
-    (a) => `scale to ${a('millions')} before lunch`,
-    (a) => `latency is a choice, choose ${a('zero')}`,
-    (a) => `build ${a('better')}, ship ${a('faster')}`,
-];
-
-/** A random brand tagline, accent words colored. */
-export function tagline(): string {
-    return TAGLINES[Math.floor(Math.random() * TAGLINES.length)](brand);
-}
-
-/** Prints the brand banner: gradient logo + random tagline + version. */
-export function banner(): void {
-    const lines = colorEnabled() ? ART.map(gradientLine) : ART.slice();
-    const ver = `${dim('  v')}${brand(version())}`;
-    process.stdout.write('\n' + lines.join('\n') + '\n\n  ' + tagline() + '   ' + ver + '\n\n');
-}
-
-

package/src/cli/update.ts

@@ -1,248 +0,0 @@
-/**
- * `toiljs update`, a friendly wrapper over `npm-check-updates`: checks the registry for newer
- * dependency versions, shows them grouped by semver bump (major / minor / patch) with colors, lets
- * you pick which to apply (or `-y` for all), bumps package.json, and runs the project's package
- * manager install. ncu is invoked via `npx --yes` so it isn't a permanent dependency of toiljs.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { cancel, intro, isCancel, multiselect, note, outro, spinner } from '@clack/prompts';
-
-import { MIGRATIONS_README } from './create.js';
-import { capture, run } from './proc.js';
-import { buildRows, type Bump, parseNcuJson, type UpdateRow, withheldUpgrades } from './updates.js';
-import { accent, danger, dim, success, warn } from './ui.js';
-
-export interface UpdateOptions {
-    readonly root?: string;
-    readonly cwd: string;
-    /** Apply all available updates without the interactive picker. */
-    readonly yes?: boolean;
-    /** ncu `--target` (latest | minor | patch | newest | greatest). Default latest. */
-    readonly target?: string;
-}
-
-export interface PackageManager {
-    readonly name: string;
-    readonly ncuName: string;
-}
-
-/** Detects the package manager from the project's lockfile (defaults to npm). */
-export function detectPackageManager(root: string): PackageManager {
-    if (fs.existsSync(path.join(root, 'pnpm-lock.yaml'))) return { name: 'pnpm', ncuName: 'pnpm' };
-    if (fs.existsSync(path.join(root, 'yarn.lock'))) return { name: 'yarn', ncuName: 'yarn' };
-    if (fs.existsSync(path.join(root, 'bun.lockb'))) return { name: 'bun', ncuName: 'bun' };
-    return { name: 'npm', ncuName: 'npm' };
-}
-
-/** Reads the merged dependency ranges (deps + devDeps) from a package.json. */
-function readDependencies(pkgPath: string): Record<string, string> {
-    const parsed: unknown = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    if (typeof parsed !== 'object' || parsed === null) return {};
-    const pkg = parsed as Record<string, unknown>;
-    const merge = (v: unknown): Record<string, string> => {
-        if (typeof v !== 'object' || v === null) return {};
-        const out: Record<string, string> = {};
-        for (const [k, val] of Object.entries(v)) if (typeof val === 'string') out[k] = val;
-        return out;
-    };
-    return { ...merge(pkg.dependencies), ...merge(pkg.devDependencies) };
-}
-
-/**
- * The server dir(s) of a project: the directories of the toilconfig.json `entries`, conventionally
- * `server/`. Falls back to `<root>/server` when there is no toilconfig (or it has no string entries),
- * matching how `doctor` locates the server tree.
- */
-function serverDirs(root: string): string[] {
-    const dirs = new Set<string>();
-    try {
-        const parsed: unknown = JSON.parse(
-            fs.readFileSync(path.join(root, 'toilconfig.json'), 'utf8'),
-        );
-        const entries =
-            typeof parsed === 'object' &&
-            parsed !== null &&
-            Array.isArray((parsed as { entries?: unknown }).entries)
-                ? (parsed as { entries: unknown[] }).entries.filter(
-                      (e): e is string => typeof e === 'string',
-                  )
-                : [];
-        for (const e of entries) dirs.add(path.dirname(path.resolve(root, e)));
-    } catch {
-        // no/unreadable toilconfig.json: fall back to the conventional server/ below
-    }
-    if (dirs.size === 0) dirs.add(path.join(root, 'server'));
-    return [...dirs];
-}
-
-/**
- * Ensures the ToilDB `migrations/` folder exists under each server dir that exists. `@migrate`
- * functions MUST live in a `*.migration.ts` file under `migrations/` (folder + extension is a
- * compile error otherwise) and the build auto-discovers them, so an up-to-date project keeps the
- * folder ready. Idempotent: only writes the folder + README where the server dir exists and the
- * folder is absent. Returns the project-relative paths created (for the note), empty if nothing.
- */
-function ensureMigrationsDirs(root: string): string[] {
-    const created: string[] = [];
-    for (const dir of serverDirs(root)) {
-        if (!fs.existsSync(dir)) continue;
-        const migrations = path.join(dir, 'migrations');
-        if (fs.existsSync(migrations)) continue;
-        fs.mkdirSync(migrations, { recursive: true });
-        fs.writeFileSync(path.join(migrations, 'README.md'), MIGRATIONS_README);
-        created.push(path.relative(root, migrations) || 'migrations');
-    }
-    return created;
-}
-
-function bumpColor(bump: Bump, text: string): string {
-    if (bump === 'major') return danger(text);
-    if (bump === 'minor') return warn(text);
-    if (bump === 'patch') return success(text);
-    return dim(text);
-}
-
-/** Renders a row as `name  from -> to`, the version part colored by bump. */
-function rowLine(row: UpdateRow): string {
-    return `${row.name}  ${dim(row.from)} ${dim('->')} ${bumpColor(row.bump, row.to)}`;
-}
-
-/** Tells the user which upgrades were held back, and why they are not simply missing. */
-function noteWithheld(names: readonly string[]): void {
-    note(
-        names.map((n) => `${dim('-')} ${n}`).join('\n') +
-            '\n\n' +
-            dim(
-                'Held back: this major is not supported by toiljs yet. TypeScript 7 is the native\n' +
-                    'port and ships no JavaScript compiler API, so route metadata would stop being\n' +
-                    'baked into the built HTML and typescript-eslint would not load.',
-            ),
-        warn('Not upgraded'),
-    );
-}
-
-const TARGETS = new Set(['latest', 'minor', 'patch', 'newest', 'greatest']);
-
-export async function runUpdate(opts: UpdateOptions): Promise<void> {
-    const root = path.resolve(opts.root ?? opts.cwd);
-    const pkgPath = path.join(root, 'package.json');
-    if (!fs.existsSync(pkgPath)) {
-        throw new Error('No package.json here. Run from your project root or pass --root <dir>.');
-    }
-    const currentDeps = readDependencies(pkgPath);
-    const pm = detectPackageManager(root);
-    const target = opts.target && TARGETS.has(opts.target) ? opts.target : 'latest';
-
-    const ncuArgs = (extra: string[]): string[] => [
-        '--yes',
-        'npm-check-updates',
-        '--packageManager',
-        pm.ncuName,
-        '--target',
-        target,
-        ...extra,
-    ];
-
-    intro(accent('toiljs update'));
-
-    // Bring the project's structure up to date: ensure the ToilDB migrations folder exists (it is
-    // newer than some projects, and the compiler requires @migrate functions to live under it).
-    const createdMigrations = ensureMigrationsDirs(root);
-    if (createdMigrations.length > 0) {
-        note(
-            createdMigrations.map((p) => `${dim('+')} ${p}/`).join('\n'),
-            'Created ToilDB migrations folder',
-        );
-    }
-
-    const s = spinner();
-    s.start('Checking the registry for updates');
-    const res = await capture('npx', ncuArgs(['--jsonUpgraded']), root);
-    if (res.code !== 0 && res.stdout.indexOf('{') === -1) {
-        s.stop('Could not check for updates');
-        note(dim(res.stderr.trim() || 'npm-check-updates failed.'), 'Error');
-        process.exitCode = 1;
-        return;
-    }
-    // Hold back upgrades into a major toiljs cannot run on (typescript 7), so neither the picker nor
-    // a `-y` run can install one. `--reject` keeps ncu from applying them during `-u` below.
-    const upgraded = parseNcuJson(res.stdout);
-    const withheld = withheldUpgrades(upgraded);
-    for (const name of withheld) delete upgraded[name];
-
-    const rows = buildRows(upgraded, currentDeps);
-    if (rows.length === 0) {
-        s.stop('Everything is up to date');
-        if (withheld.length > 0) noteWithheld(withheld);
-        outro(success('Nothing to update.'));
-        return;
-    }
-    s.stop(`${String(rows.length)} update${rows.length === 1 ? '' : 's'} available`);
-    if (withheld.length > 0) noteWithheld(withheld);
-
-    const counts = { major: 0, minor: 0, patch: 0, other: 0 };
-    for (const r of rows) counts[r.bump]++;
-    note(
-        rows.map(rowLine).join('\n'),
-        `${danger(`${String(counts.major)} major`)}  ${warn(`${String(counts.minor)} minor`)}  ${success(`${String(counts.patch)} patch`)}`,
-    );
-
-    let selected: string[];
-    if (opts.yes) {
-        selected = rows.map((r) => r.name);
-    } else {
-        const answer = await multiselect<string>({
-            message: 'Select packages to update (space to toggle, enter to confirm)',
-            options: rows.map((r) => ({
-                value: r.name,
-                label: r.name,
-                hint: `${r.from} -> ${r.to}`,
-            })),
-            initialValues: rows.map((r) => r.name),
-            required: false,
-        });
-        if (isCancel(answer)) {
-            cancel('Update cancelled.');
-            return;
-        }
-        selected = answer;
-    }
-
-    if (selected.length === 0) {
-        outro(dim('No packages selected.'));
-        return;
-    }
-
-    s.start('Updating package.json');
-    const applyAll = selected.length === rows.length;
-    const reject = withheld.length > 0 ? ['--reject', withheld.join(' ')] : [];
-    await run(
-        'npx',
-        ncuArgs(applyAll ? ['-u', ...reject] : ['-u', '--filter', selected.join(' '), ...reject]),
-        root,
-    );
-    s.stop('package.json updated');
-
-    // Run the install with VISIBLE output (so a failure is diagnosable — npm
-    // prints the real error) and handle a non-zero exit gracefully, instead of
-    // leaving the spinner spinning forever on a failed install.
-    note(dim(`Running ${pm.name} install…`), 'Install');
-    try {
-        await run(pm.name, ['install'], root, { stdio: 'inherit' });
-    } catch {
-        outro(
-            danger(
-                `${pm.name} install failed — package.json was updated to the new versions, but the ` +
-                    `install did not finish. Fix the error printed above, then run \`${pm.name} install\`.`,
-            ),
-        );
-        process.exitCode = 1;
-        return;
-    }
-
-    outro(
-        success(`Updated ${String(selected.length)} package${selected.length === 1 ? '' : 's'}.`),
-    );
-}

package/src/cli/updates.ts

@@ -1,92 +0,0 @@
-/**
- * Pure helpers for `toiljs update`: parse `npm-check-updates --jsonUpgraded` output and classify the
- * semver bump of each upgrade. IO-free so it can be unit-tested; the spawn/UI live in `update.ts`.
- */
-
-/** The kind of version jump an upgrade represents. */
-export type Bump = 'major' | 'minor' | 'patch' | 'other';
-
-/** One available upgrade: package, current range, target range, and bump kind. */
-export interface UpdateRow {
-    readonly name: string;
-    readonly from: string;
-    readonly to: string;
-    readonly bump: Bump;
-}
-
-/** Extracts a version's leading `x.y.z` (ignoring `^`, `~`, `>=`, etc.); missing parts become 0. */
-function parseVersion(v: string): [number, number, number] {
-    const m = /(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(v);
-    if (!m) return [0, 0, 0];
-    return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
-}
-
-/** Classifies the bump from `from` to `to` (both may be ranges like `^1.2.3`). */
-export function classifyBump(from: string, to: string): Bump {
-    const [fa, fb, fc] = parseVersion(from);
-    const [ta, tb, tc] = parseVersion(to);
-    if (ta !== fa) return 'major';
-    if (tb !== fb) return 'minor';
-    if (tc !== fc) return 'patch';
-    return 'other';
-}
-
-/**
- * Parses the JSON object `npm-check-updates --jsonUpgraded` prints (a `{ name: range }` map). Tolerant
- * of leading/trailing noise (npx banners) by slicing to the outermost braces. Returns `{}` on failure.
- */
-export function parseNcuJson(stdout: string): Record<string, string> {
-    const start = stdout.indexOf('{');
-    const end = stdout.lastIndexOf('}');
-    if (start === -1 || end <= start) return {};
-    try {
-        const parsed: unknown = JSON.parse(stdout.slice(start, end + 1));
-        if (typeof parsed !== 'object' || parsed === null) return {};
-        const out: Record<string, string> = {};
-        for (const [k, v] of Object.entries(parsed)) if (typeof v === 'string') out[k] = v;
-        return out;
-    } catch {
-        return {};
-    }
-}
-
-/**
- * Majors `toiljs update` refuses to upgrade into, by package. TypeScript 7 is the native (Go) port:
- * it ships `tsc` but no JavaScript compiler API, which toiljs's route-metadata extractor, the eslint
- * preset, and typedoc all load. Upgrading into it silently stops SEO metadata being baked into the
- * built HTML and hard-crashes typescript-eslint, so the upgrade is withheld until the ecosystem
- * catches up. Bumps *within* the supported major are still offered.
- */
-export const UNSUPPORTED_MAJOR: Readonly<Record<string, number>> = { typescript: 7 };
-
-/**
- * The names ncu wants to upgrade into a major toiljs does not support (see {@link UNSUPPORTED_MAJOR}).
- * These are dropped from the picker and passed to ncu's `--reject`, so `-u` cannot apply them either.
- */
-export function withheldUpgrades(upgraded: Record<string, string>): string[] {
-    return Object.entries(upgraded)
-        .filter(([name, to]) => {
-            const ceiling = UNSUPPORTED_MAJOR[name];
-            return ceiling !== undefined && parseVersion(to)[0] >= ceiling;
-        })
-        .map(([name]) => name)
-        .sort();
-}
-
-const SEVERITY: Record<Bump, number> = { major: 0, minor: 1, patch: 2, other: 3 };
-
-/**
- * Builds the upgrade rows from the ncu map and the project's current dependency ranges, sorted by
- * bump severity (major first) then name.
- */
-export function buildRows(
-    upgraded: Record<string, string>,
-    currentDeps: Record<string, string>,
-): UpdateRow[] {
-    return Object.entries(upgraded)
-        .map(([name, to]) => {
-            const from = currentDeps[name] ?? '?';
-            return { name, from, to, bump: classifyBump(from, to) };
-        })
-        .sort((a, b) => SEVERITY[a.bump] - SEVERITY[b.bump] || a.name.localeCompare(b.name));
-}

package/src/cli/validate.ts

@@ -1,31 +0,0 @@
-/**
- * Pure input validation for `toiljs create`, kept dependency-light (only node:path) so it can be
- * unit-tested without pulling in the rest of the CLI.
- */
-import path from 'node:path';
-
-/** Package managers the scaffolder may invoke. Allowlisted so a hostile `--pm` can't inject a shell command. */
-export const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn', 'bun'];
-
-/** Validates a project name's characters. Returns `true`, or an error message. */
-export function isValidName(name: string): true | string {
-    if (!name.trim()) return 'Please enter a project name.';
-    if (!/^[a-z0-9._@/-]+$/i.test(name)) return 'Use letters, numbers, dashes, dots or slashes.';
-    return true;
-}
-
-/**
- * Resolves `name` to an absolute directory under `cwd`, refusing to escape it (a name like
- * `../x` or an absolute path). Returns the resolved dir, or `null` if it would escape `cwd`.
- */
-export function resolveProjectDir(cwd: string, name: string): string | null {
-    const target = path.resolve(cwd, name);
-    const rel = path.relative(cwd, target);
-    if (rel.startsWith('..') || path.isAbsolute(rel)) return null;
-    return target;
-}
-
-/** Whether `pm` is a supported package manager (guards shell use of `--pm`). */
-export function isPackageManager(pm: string): boolean {
-    return PACKAGE_MANAGERS.includes(pm);
-}

package/src/cli/version-check.ts

@@ -1,125 +0,0 @@
-/**
- * Pure helpers for the automatic toiljs update check that runs on every CLI invocation
- * (and therefore on `npm run dev` / `npm run build`, which call the CLI). IO-free so it
- * can be unit-tested; the registry fetch, cache file, and printing live in `notify.ts`.
- */
-
-/** How long a registry answer is trusted before we ask npm again. */
-export const CHECK_TTL_MS = 60 * 60 * 1000;
-
-/** What we persist between runs: the latest known version and when we asked. */
-export interface CheckCache {
-    readonly latest: string | null;
-    readonly checkedAt: number;
-}
-
-/** Parses the cache file contents; returns null when malformed (forces a fresh check). */
-export function parseCheckCache(raw: string): CheckCache | null {
-    try {
-        const parsed: unknown = JSON.parse(raw);
-        if (typeof parsed !== 'object' || parsed === null) return null;
-        const o = parsed as Record<string, unknown>;
-        const latest = typeof o.latest === 'string' ? o.latest : null;
-        const checkedAt = typeof o.checkedAt === 'number' ? o.checkedAt : NaN;
-        if (!Number.isFinite(checkedAt)) return null;
-        return { latest, checkedAt };
-    } catch {
-        return null;
-    }
-}
-
-/** True when the cached answer is still trustworthy (also stale if the clock went backwards). */
-export function isCacheFresh(
-    cache: CheckCache,
-    now: number,
-    ttlMs: number = CHECK_TTL_MS,
-): boolean {
-    return cache.checkedAt <= now && now - cache.checkedAt < ttlMs;
-}
-
-interface Parsed {
-    readonly nums: readonly [number, number, number];
-    readonly pre: string | null;
-}
-
-function parseSemver(v: string): Parsed {
-    const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(v.trim());
-    if (!m) return { nums: [0, 0, 0], pre: null };
-    return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ?? null };
-}
-
-/**
- * Compares two semver strings: negative when `a < b`, 0 when equal, positive when `a > b`.
- * A prerelease sorts below its release (`0.1.0-beta.1 < 0.1.0`); two prereleases compare
- * lexicographically, which is enough for an update nudge.
- */
-export function compareSemver(a: string, b: string): number {
-    const pa = parseSemver(a);
-    const pb = parseSemver(b);
-    for (let i = 0; i < 3; i++) {
-        if (pa.nums[i] !== pb.nums[i]) return pa.nums[i] < pb.nums[i] ? -1 : 1;
-    }
-    if (pa.pre === pb.pre) return 0;
-    if (pa.pre === null) return 1;
-    if (pb.pre === null) return -1;
-    return pa.pre < pb.pre ? -1 : 1;
-}
-
-/** True when `installed` is behind `latest`. */
-export function isOutdated(installed: string, latest: string): boolean {
-    return compareSemver(installed, latest) < 0;
-}
-
-/** The command that updates toiljs for the project's package manager, or globally. */
-export function installCommand(pm: string, scope: 'project' | 'global'): string {
-    if (scope === 'global') {
-        if (pm === 'pnpm') return 'pnpm add -g toiljs@latest';
-        if (pm === 'yarn') return 'yarn global add toiljs@latest';
-        if (pm === 'bun') return 'bun add -g toiljs@latest';
-        return 'npm install -g toiljs@latest';
-    }
-    if (pm === 'pnpm') return 'pnpm add toiljs@latest';
-    if (pm === 'yarn') return 'yarn add toiljs@latest';
-    if (pm === 'bun') return 'bun add toiljs@latest';
-    return 'npm install toiljs@latest';
-}
-
-/** One out-of-date install we want to nag about. */
-export interface OutdatedRow {
-    /** Where the stale copy lives: the project's node_modules or the global CLI. */
-    readonly scope: 'project' | 'global';
-    readonly installed: string;
-    readonly command: string;
-}
-
-/**
- * Decides what (if anything) to warn about. `projectVersion` is the toiljs resolved in the
- * project's node_modules (null when not installed there), `cliVersion` is the copy of the CLI
- * actually running, and `cliIsLocal` tells us whether those are the same install.
- */
-export function findOutdated(
-    latest: string,
-    projectVersion: string | null,
-    cliVersion: string,
-    cliIsLocal: boolean,
-    pm: string,
-): OutdatedRow[] {
-    const rows: OutdatedRow[] = [];
-    if (projectVersion !== null && isOutdated(projectVersion, latest)) {
-        rows.push({
-            scope: 'project',
-            installed: projectVersion,
-            command: installCommand(pm, 'project'),
-        });
-    }
-    // The running CLI only gets its own row when it is not the project install we already
-    // reported (global installs, or `npx toiljs` outside a project).
-    if (!cliIsLocal && isOutdated(cliVersion, latest)) {
-        rows.push({
-            scope: 'global',
-            installed: cliVersion,
-            command: installCommand('npm', 'global'),
-        });
-    }
-    return rows;
-}