burgee 0.7.1 → 0.9.0

package/dist/meow.js

@@ -0,0 +1,146 @@
+import { ExitCode } from './exit-code.js';
+import { aliasMap, splitAtCommand, typeofDefault } from './meow/parse.js';
+import { buildHelp, normalizePackage, readPackageUp, setProcessTitle } from './meow/present.js';
+import { own } from './meow/types.js';
+import { checkChoices, checkInput, checkRequired, checkSetOnce, checkUnknown, requireImportMeta, validateCommands, validateFlags } from './meow/validate.js';
+import { host } from './runtime.js';
+import parser, { camelCase } from './yargs-parser.js';
+function meow(helpText, options = {}) {
+    const opts = typeof helpText === 'string' ? { help: helpText, ...options } : helpText;
+    if (typeof helpText !== 'string' && Object.keys(options).length > 0)
+        Object.assign(opts, options);
+    if (opts.input !== undefined && typeof opts.input !== 'string' && !Array.isArray(opts.input) && typeof opts.input !== 'object') {
+        throw new TypeError('The `input` option must be a string or an object.');
+    }
+    const flagSpecs = (opts.flags ?? {});
+    if (typeof flagSpecs !== 'object' || flagSpecs === null || Array.isArray(flagSpecs)) {
+        throw new TypeError('The `flags` option must be an object.');
+    }
+    if (typeof opts.input === 'object' && opts.input !== null) {
+        const required = opts.input.isRequired;
+        if (required !== undefined && typeof required !== 'boolean' && typeof required !== 'function') {
+            throw new TypeError('The `input.isRequired` option must be a boolean or a function.');
+        }
+    }
+    validateFlags(flagSpecs);
+    if (opts.pkg === undefined)
+        requireImportMeta(opts.importMeta);
+    const pkg = normalizePackage(opts.pkg ?? readPackageUp(opts.importMeta));
+    validateCommands(opts.commands);
+    const rawArgv = [...(opts.argv ?? host.argv.slice(2))];
+    const booleans = [];
+    const strings = [];
+    const numbers = [];
+    const defaults = {};
+    const arrays = [];
+    for (const [name, spec] of Object.entries(flagSpecs)) {
+        if (name === '--')
+            continue;
+        const type = spec.type ?? (spec.default === undefined ? undefined : typeofDefault(spec.default));
+        if (type === 'boolean')
+            booleans.push(name);
+        else if (type === 'number')
+            numbers.push(name);
+        else if (type === 'string')
+            strings.push(name);
+        if (spec.isMultiple === true)
+            arrays.push(name);
+        if (spec.default !== undefined)
+            own(defaults, name, spec.default);
+        else if (type === 'boolean' && 'booleanDefault' in opts) {
+            if (opts.booleanDefault !== undefined)
+                own(defaults, name, opts.booleanDefault);
+        }
+        else if (type === 'boolean')
+            own(defaults, name, false);
+        if (spec.isMultiple === true && spec.default === undefined) {
+            own(defaults, name, type === 'boolean' && !('booleanDefault' in opts) ? [false] : []);
+        }
+    }
+    const parserOptions = {
+        alias: aliasMap(flagSpecs),
+        array: arrays,
+        boolean: booleans,
+        string: strings,
+        number: numbers,
+        default: defaults,
+        configuration: {
+            'camel-case-expansion': true,
+            'greedy-arrays': false,
+            'parse-numbers': opts.inferType === true,
+            'parse-positional-numbers': opts.inferType === true,
+            'populate--': flagSpecs['--'] !== undefined,
+            'strip-aliased': false,
+            'strip-dashed': true,
+            'unknown-options-as-args': false,
+        },
+    };
+    const split = opts.commands === undefined ? undefined : splitAtCommand(rawArgv, parserOptions, opts);
+    const argv = split?.parent ?? rawArgv;
+    const parsed = parser.detailed(argv, parserOptions);
+    const { _: positional, ...rest } = parsed.argv;
+    const inputType = typeof opts.input === 'object' && opts.input !== null ? opts.input.type : opts.input;
+    const coerce = (v) => {
+        if (inputType === 'number')
+            return Number(v);
+        if (inputType === 'string')
+            return String(v);
+        return opts.inferType === true ? v : String(v);
+    };
+    const input = (split === undefined ? positional.map(coerce) : split.input);
+    const command = split?.command;
+    const dropped = new Set();
+    for (const [name, spec] of Object.entries(flagSpecs)) {
+        if (typeof spec.shortFlag === 'string')
+            dropped.add(spec.shortFlag);
+        if (typeof spec.alias === 'string')
+            dropped.add(spec.alias);
+        for (const extra of spec.aliases ?? [])
+            dropped.add(extra);
+        void name;
+    }
+    const flags = {};
+    const unnormalizedFlags = { ...rest };
+    for (const [key, value] of Object.entries(rest)) {
+        if (key === '--' || dropped.has(key))
+            continue;
+        Object.defineProperty(flags, camelCase(key), { value, writable: true, enumerable: true, configurable: true });
+    }
+    if (flagSpecs['--'] !== undefined)
+        flags['--'] = rest['--'] ?? [];
+    const help = buildHelp(opts, pkg);
+    const declared = opts.version === undefined ? undefined : String(opts.version);
+    const fromPkg = typeof pkg['version'] === 'string' && pkg['version'] !== '' ? pkg['version'] : undefined;
+    const version = declared ?? fromPkg ?? 'No version found';
+    const showHelp = (code = ExitCode.USAGE) => {
+        host.stdout.write(help === '' ? '\n' : `${help}\n`);
+        return host.exit(code);
+    };
+    const showVersion = () => {
+        host.stdout.write(`${version}\n`);
+        host.exit(ExitCode.OK);
+    };
+    setProcessTitle(pkg);
+    const result = { input, flags, unnormalizedFlags, pkg, help, version, showHelp, showVersion };
+    if (opts.commands !== undefined && command !== undefined)
+        result.command = command;
+    if (split?.unknownCommand !== undefined) {
+        host.stderr.write(`Unknown command: ${split.unknownCommand}\nAvailable commands: ${opts.commands?.join(', ') ?? ''}\n${help}\n`);
+        host.exit(ExitCode.USAGE);
+    }
+    if (input.length === 0) {
+        if (opts.autoHelp !== false && flagSpecs['help'] === undefined && flags['help'] === true)
+            showHelp(ExitCode.OK);
+        if (opts.autoVersion !== false && flagSpecs['version'] === undefined && flags['version'] === true)
+            showVersion();
+    }
+    checkSetOnce(flagSpecs, rest);
+    checkInput(opts, input, flags);
+    checkChoices(flagSpecs, flags);
+    checkRequired(flagSpecs, flags, input);
+    if (opts.allowUnknownFlags === false)
+        checkUnknown(flagSpecs, rest, argv, opts);
+    return result;
+}
+const meowFacade = meow;
+export default meowFacade;

package/dist/migrate.d.ts

@@ -0,0 +1,142 @@
+import { type Graded } from './compat.js';
+/**
+ * A2 — the whole mapping, as data.
+ *
+ * Whole specifiers only. `burgee/commander` is not a key, which is what makes a second run
+ * over an already-migrated tree a no-op and lets the command declare `effects: 'idempotent'`.
+ */
+export declare const MAPPING: Readonly<Record<string, string>>;
+/** The packages a project depends on that this command is about (A1). */
+export declare const HOSTS: readonly ["commander", "yargs"];
+/** Why a file was left untouched. Both are named positions, never a guess (A4). */
+export type RefusalReason = 'deep-import' | 'non-literal-specifier';
+export interface Refusal {
+    /** Relative to the directory being migrated, with forward slashes on every platform. */
+    file: string;
+    line: number;
+    /** The specifier as written, or `''` for a dynamic specifier that is not a literal. */
+    specifier: string;
+    reason: RefusalReason;
+}
+/** One rewritten specifier, for the per-mapping rollup the report prints. */
+export interface Mapped {
+    from: string;
+    to: string;
+    imports: number;
+    files: number;
+}
+export interface Detection {
+    /** Hosts named in `package.json`'s dependencies — declared. */
+    declared: string[];
+    /** Hosts a source file actually imports — used. These two disagree more often than not. */
+    imported: string[];
+}
+export interface MigrationReport {
+    files: number;
+    imports: number;
+    mapped: Mapped[];
+    refused: Refusal[];
+    detected: Detection;
+    dependencies: {
+        before: string[];
+        removable: string[];
+        after: number;
+    };
+    graded: (Graded & {
+        host: string;
+    })[];
+    dryRun: boolean;
+    /** N7 — an idempotent command says whether it changed anything; silence is what an agent misreads. */
+    changed: boolean;
+    /** A8 — `RUNTIME` when anything was refused, so an agent branches on the code. */
+    exitCode: number;
+}
+interface Site {
+    specifier: string;
+    /** Offsets of the specifier's text, excluding the quotes. */
+    start: number;
+    end: number;
+    line: number;
+}
+interface Scan {
+    sites: Site[];
+    /** `import(x)` / `require(x)` where `x` is not a string literal — refused, never guessed. */
+    nonLiteral: number[];
+}
+/**
+ * One linear pass over the text: comments, strings, templates and regular expressions are
+ * skipped as the shapes they are, and every quoted literal is classified by the two code
+ * tokens in front of it.
+ *
+ * It is a scan, not a parse. What it cannot classify it refuses (A4); what it can, it knows
+ * exactly, because a module specifier is a string literal in one of five positions and
+ * nothing else in the grammar looks like that.
+ */
+export declare function scan(source: string): Scan;
+export interface Rewrite {
+    source: string;
+    mapped: {
+        from: string;
+        to: string;
+    }[];
+    refused: Omit<Refusal, 'file'>[];
+    /** Whether this file references a host at all. A file that does not is not "untouched", it is unrelated. */
+    relevant: boolean;
+}
+/**
+ * A file that names neither host anywhere cannot contain a specifier for one — and in a real
+ * repository that is almost every file.
+ *
+ * `includes` is a `memmem`; `scan` is a character loop. It is not what makes the command
+ * fast (the whole scan phase is 25 ms of a ~400 ms run over 1,000 files) — it is what keeps
+ * the work proportional to the files that could matter rather than to the repository, and
+ * on a `Buffer` it also skips decoding 3 MB of UTF-8 that nothing was going to read.
+ */
+export declare function mentionsAHost(source: string | Buffer): boolean;
+/**
+ * A2/A5 — map every host specifier in one file, or map none of them.
+ *
+ * The edits are applied from the end backwards so earlier offsets stay valid, and the
+ * source is returned unchanged the moment there is a refusal in it: the unit of success is
+ * the file, so the worst case is *nothing changed here, and here is why* (D-051).
+ */
+export declare function rewriteSource(source: string): Rewrite;
+/** Every source file under `dir`, relative and slash-separated so a report reads the same everywhere. */
+export declare function sourceFiles(dir: string, at?: string, found?: string[]): string[];
+/**
+ * `git status --porcelain`, or `undefined` where there is no repository to ask (A6).
+ *
+ * Through `bellpull` rather than `node:child_process`, because spawning is bellpull's job
+ * and `scripts/inline-implementation-lock.test.ts` says so — it caught the first draft of
+ * this file, which reached for `execFileSync` out of habit. burgee already depends on the
+ * package, and `migrate.js` is loaded lazily, so nothing that does not run `migrate` pays
+ * for the edge.
+ *
+ * Not a repository, no `git` on `PATH`, an unreadable directory: all the same answer, which
+ * is *there is nothing here that could be dirty*. A6 protects a reviewable diff, and where
+ * there is no repository there is no diff to protect — refusing instead would make the
+ * command unusable on a tarball for a safety that was never available.
+ */
+export declare function workingTree(dir: string): Promise<string[] | undefined>;
+/** A6 — a dirty tree has no reviewable diff to add to, so the command declines rather than writes. */
+export declare class DirtyTreeError extends Error {
+    readonly entries: string[];
+    readonly fix = "commit or stash your changes, or pass --force";
+    constructor(entries: string[]);
+}
+export interface MigrateOptions {
+    dir: string;
+    dryRun?: boolean;
+    force?: boolean;
+    /** Injected by the tests; the real `git status --porcelain` otherwise. */
+    status?: (dir: string) => string[] | undefined | Promise<string[] | undefined>;
+}
+/**
+ * Migrate one project: detect, rewrite, report (A1, A7, A8).
+ *
+ * Non-interactive by design (D-052). The second audience is an agent migrating a
+ * repository unattended, and a prompt is a wall; safety is `--dry-run` and the refusal on
+ * a dirty tree, not a question.
+ */
+export declare function migrate(options: MigrateOptions): Promise<MigrationReport>;
+export {};

package/dist/migrate.js

@@ -0,0 +1,284 @@
+import { readdirSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ambientRuntime, run } from 'bellpull';
+import { GRADED } from './compat.js';
+import { ExitCode } from './exit-code.js';
+export const MAPPING = {
+    commander: 'burgee/commander',
+    yargs: 'burgee/yargs',
+    'yargs/yargs': 'burgee/yargs',
+    'yargs/helpers': 'burgee/yargs/helpers',
+};
+export const HOSTS = ['commander', 'yargs'];
+const WORD = /[A-Za-z0-9_$]/;
+const DIVIDES = new Set([')', ']', '}']);
+function startsRegex(previous) {
+    if (previous === '')
+        return true;
+    if (DIVIDES.has(previous))
+        return false;
+    return !WORD.test(previous.charAt(previous.length - 1));
+}
+function endOfString(source, open) {
+    const quote = source.charAt(open);
+    for (let i = open + 1; i < source.length; i += 1) {
+        const c = source.charAt(i);
+        if (c === '\\') {
+            i += 1;
+            continue;
+        }
+        if (c === quote || c === '\n')
+            return i + 1;
+    }
+    return source.length;
+}
+function endOfTemplate(source, open) {
+    let depth = 0;
+    for (let i = open + 1; i < source.length; i += 1) {
+        const c = source.charAt(i);
+        if (c === '\\') {
+            i += 1;
+            continue;
+        }
+        if (c === '$' && source.charAt(i + 1) === '{') {
+            depth += 1;
+            i += 1;
+            continue;
+        }
+        if (c === '}' && depth > 0) {
+            depth -= 1;
+            continue;
+        }
+        if (c === '`' && depth === 0)
+            return i + 1;
+    }
+    return source.length;
+}
+function endOfRegex(source, open) {
+    let inClass = false;
+    for (let i = open + 1; i < source.length; i += 1) {
+        const c = source.charAt(i);
+        if (c === '\\') {
+            i += 1;
+            continue;
+        }
+        if (c === '[' || c === ']') {
+            inClass = c === '[';
+            continue;
+        }
+        if (c === '\n')
+            return i;
+        if (c === '/' && !inClass)
+            return i + 1;
+    }
+    return source.length;
+}
+function newlines(source, from, to) {
+    let count = 0;
+    for (let i = from; i < to; i += 1)
+        if (source.charAt(i) === '\n')
+            count += 1;
+    return count;
+}
+function isSpecifier(previous, before) {
+    if (previous === 'from' || previous === 'import')
+        return true;
+    return previous === '(' && (before === 'import' || before === 'require');
+}
+function endOfTrivia(source, at) {
+    const c = source.charAt(at);
+    if (c === ' ' || c === '\t' || c === '\r' || c === '\n' || c === ';')
+        return at + 1;
+    if (c !== '/')
+        return at;
+    const next = source.charAt(at + 1);
+    if (next === '/') {
+        const end = source.indexOf('\n', at);
+        return end === -1 ? source.length : end;
+    }
+    if (next !== '*')
+        return at;
+    const end = source.indexOf('*/', at + 2);
+    return end === -1 ? source.length : end + 2;
+}
+function endOfLiteral(source, at, previous) {
+    const c = source.charAt(at);
+    if (c === "'" || c === '"')
+        return endOfString(source, at);
+    if (c === '`')
+        return endOfTemplate(source, at);
+    if (c === '/' && startsRegex(previous))
+        return endOfRegex(source, at);
+    return -1;
+}
+function endOfWord(source, at) {
+    let i = at;
+    while (i < source.length && WORD.test(source.charAt(i)))
+        i += 1;
+    return i;
+}
+const QUOTED = 'str';
+function push(tokens, text, line) {
+    if (tokens.pending && text !== QUOTED && text !== ')')
+        tokens.nonLiteral.push(line);
+    tokens.pending = text === '(' && (tokens.previous === 'import' || tokens.previous === 'require');
+    tokens.before = tokens.previous;
+    tokens.previous = text;
+}
+export function scan(source) {
+    const sites = [];
+    const tokens = { previous: '', before: '', pending: false, nonLiteral: [] };
+    let line = 1;
+    let i = 0;
+    while (i < source.length) {
+        const trivia = endOfTrivia(source, i);
+        if (trivia !== i) {
+            line += newlines(source, i, trivia);
+            i = trivia;
+            continue;
+        }
+        const literal = endOfLiteral(source, i, tokens.previous);
+        if (literal !== -1) {
+            const c = source.charAt(i);
+            const quoted = c === "'" || c === '"';
+            if (quoted && isSpecifier(tokens.previous, tokens.before))
+                sites.push({ specifier: source.slice(i + 1, literal - 1), start: i + 1, end: literal - 1, line });
+            push(tokens, quoted ? QUOTED : 'lit', line);
+            line += newlines(source, i, literal);
+            i = literal;
+            continue;
+        }
+        const word = endOfWord(source, i);
+        if (word !== i) {
+            push(tokens, source.slice(i, word), line);
+            i = word;
+            continue;
+        }
+        push(tokens, source.charAt(i), line);
+        i += 1;
+    }
+    return { sites, nonLiteral: tokens.nonLiteral };
+}
+const NEEDLE_BYTES = HOSTS.map((host) => Buffer.from(host));
+export function mentionsAHost(source) {
+    return typeof source === 'string' ? HOSTS.some((host) => source.includes(host)) : NEEDLE_BYTES.some((bytes) => source.includes(bytes));
+}
+function isDeep(specifier) {
+    if (MAPPING[specifier] !== undefined)
+        return false;
+    return HOSTS.some((host) => specifier.startsWith(`${host}/`));
+}
+export function rewriteSource(source) {
+    if (!mentionsAHost(source))
+        return { source, mapped: [], refused: [], relevant: false };
+    const { sites, nonLiteral } = scan(source);
+    const hits = sites.filter((s) => MAPPING[s.specifier] !== undefined || isDeep(s.specifier));
+    if (hits.length === 0)
+        return { source, mapped: [], refused: [], relevant: false };
+    const refused = [
+        ...hits.filter((s) => isDeep(s.specifier)).map((s) => ({ line: s.line, specifier: s.specifier, reason: 'deep-import' })),
+        ...nonLiteral.map((line) => ({ line, specifier: '', reason: 'non-literal-specifier' })),
+    ].sort((a, b) => a.line - b.line);
+    if (refused.length > 0)
+        return { source, mapped: [], refused, relevant: true };
+    let out = source;
+    const mapped = [];
+    for (const site of [...hits].sort((a, b) => b.start - a.start)) {
+        const to = MAPPING[site.specifier];
+        out = `${out.slice(0, site.start)}${to}${out.slice(site.end)}`;
+        mapped.push({ from: site.specifier, to });
+    }
+    return { source: out, mapped: mapped.reverse(), refused: [], relevant: true };
+}
+const SOURCE_EXTENSIONS = new Set(['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts']);
+const SKIP = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.turbo', '.next', '.output', '.cache', '.vercel']);
+export function sourceFiles(dir, at = '', found = []) {
+    for (const entry of readdirSync(join(dir, at), { withFileTypes: true })) {
+        const path = at === '' ? entry.name : `${at}/${entry.name}`;
+        if (entry.isDirectory()) {
+            if (!SKIP.has(entry.name))
+                sourceFiles(dir, path, found);
+        }
+        else if (SOURCE_EXTENSIONS.has(entry.name.slice(entry.name.lastIndexOf('.'))))
+            found.push(path);
+    }
+    return found;
+}
+async function declaredHosts(dir) {
+    try {
+        const raw = JSON.parse(await readFile(join(dir, 'package.json'), 'utf8'));
+        const declared = { ...raw.dependencies, ...raw.devDependencies };
+        return HOSTS.filter((host) => declared[host] !== undefined);
+    }
+    catch {
+        return [];
+    }
+}
+export async function workingTree(dir) {
+    const result = await run('git', ['-C', dir, 'status', '--porcelain'], { runtime: ambientRuntime(), stdio: 'pipe' });
+    if (!result.ok)
+        return undefined;
+    return result.stdout.split('\n').filter((line) => line !== '');
+}
+export class DirtyTreeError extends Error {
+    entries;
+    fix = 'commit or stash your changes, or pass --force';
+    constructor(entries) {
+        super(`the git tree has ${entries.length} uncommitted change${entries.length === 1 ? '' : 's'}`);
+        this.entries = entries;
+        this.name = 'DirtyTreeError';
+    }
+}
+const EMPTY = { source: '', mapped: [], refused: [], relevant: false };
+async function migrateBatch(dir, batch, write) {
+    const sources = await Promise.all(batch.map(async (file) => await readFile(join(dir, file))));
+    const results = sources.map((bytes) => (mentionsAHost(bytes) ? rewriteSource(bytes.toString('utf8')) : EMPTY));
+    if (write)
+        await Promise.all(results.map(async (r, i) => (r.mapped.length === 0 ? undefined : await writeFile(join(dir, batch[i]), r.source))));
+    return results;
+}
+function rollup(all) {
+    return Object.entries(MAPPING)
+        .map(([from, to]) => {
+        const hits = all.filter((m) => m.from === from);
+        return { from, to, imports: hits.length, files: new Set(hits.map((m) => m.file)).size };
+    })
+        .filter((row) => row.imports > 0);
+}
+function gradedFor(hosts) {
+    return hosts.filter((host) => GRADED[host] !== undefined).map((host) => ({ host, ...GRADED[host] }));
+}
+const BATCH = 256;
+export async function migrate(options) {
+    const { dir, dryRun = false, force = false } = options;
+    const entries = await (options.status ?? workingTree)(dir);
+    if (!dryRun && !force && entries !== undefined && entries.length > 0)
+        throw new DirtyTreeError(entries);
+    const files = sourceFiles(dir);
+    const results = [];
+    for (let i = 0; i < files.length; i += BATCH) {
+        const batch = files.slice(i, i + BATCH);
+        const done = await migrateBatch(dir, batch, !dryRun);
+        results.push(...done.map((result, k) => ({ file: batch[k], result })));
+    }
+    const all = results.flatMap(({ file, result }) => result.mapped.map((m) => ({ ...m, file })));
+    const refused = results.flatMap(({ file, result }) => result.refused.map((r) => ({ file, ...r })));
+    const imported = [...new Set(results.flatMap(({ result }) => (result.relevant ? result.mapped.map((m) => m.from) : [])))];
+    const declared = await declaredHosts(dir);
+    const stillUsed = new Set(refused.map((r) => r.specifier.split('/')[0] ?? ''));
+    const removable = declared.filter((host) => !stillUsed.has(host));
+    const touched = [...new Set(all.map((m) => m.file))];
+    return {
+        files: touched.length,
+        imports: all.length,
+        mapped: rollup(all),
+        refused,
+        detected: { declared, imported: [...new Set(imported.map((s) => s.split('/')[0] ?? s))].sort() },
+        dependencies: { before: declared, removable, after: declared.length - removable.length },
+        graded: gradedFor([...new Set([...declared, ...imported.map((s) => s.split('/')[0] ?? s)])].sort()),
+        dryRun,
+        changed: !dryRun && touched.length > 0,
+        exitCode: refused.length > 0 ? ExitCode.RUNTIME : ExitCode.OK,
+    };
+}

package/dist/plugin.d.ts

@@ -19,7 +19,7 @@ export interface Plugin {
     };
     enforce?: 'pre' | 'post';
 }
-export type PluginErrorCode = 'E_PLUGIN_SCHEMA' | 'E_PLUGIN_CONTRACT';
+export type PluginErrorCode = 'E_PLUGIN_SCHEMA' | 'E_PLUGIN_CONTRACT' | 'E_NO_CONTRIBUTION';
 /** A refused plugin says what is wrong and what to do about it — the family's one vocabulary. */
 export declare class PluginError extends Error {
     readonly code: PluginErrorCode;

package/dist/plugin.js

@@ -68,7 +68,7 @@ function checkCommands(commands, name, taken) {
         }
         seen.add(path);
         try {
-            checkCommand(path, (node['options'] ?? {}), node['effects'], node['run'] !== undefined || node['load'] !== undefined);
+            checkCommand(path, node);
         }
         catch (error) {
             throw schema(`${at}: ${error.message}`, 'a plugin command is declared exactly as a first-party one');

package/dist/runtime.d.ts

@@ -66,6 +66,8 @@ export declare const host: {
     readonly stdin: NodeJS.ReadStream;
     readonly stdout: NodeJS.WriteStream;
     readonly stderr: NodeJS.WriteStream;
+    /** What `ps` shows. meow renames the process after the binary it is; nothing else sets it. */
+    setTitle(value: string): void;
     /**
      * The terminal's width, or undefined when there is no terminal to ask. Guarded on
      * `process` itself because cliui's upstream is guarded there: `getWindowWidth` is reached

package/dist/runtime.js

@@ -18,6 +18,9 @@ export const host = {
     get stderr() {
         return process.stderr;
     },
+    setTitle(value) {
+        process.title = value;
+    },
     get columns() {
         if (typeof process === 'undefined')
             return undefined;

package/dist/schema-entry.d.ts

@@ -0,0 +1,3 @@
+/** `burgee/schema` — the schema surface and the manifest it reads, by itself. See `index.ts`. */
+export { commandSchemaOf, inputSchemaOf, schemaOf, summaryOf, type CommandSchema, type JsonSchema, type ProgramSchema, type SchemaSummary } from './schema.js';
+export { Manifest } from './manifest.js';

package/dist/schema-entry.js

@@ -0,0 +1,2 @@
+export { commandSchemaOf, inputSchemaOf, schemaOf, summaryOf } from './schema.js';
+export { Manifest } from './manifest.js';