@zenera/gym 0.0.0-stage → 1.1.38

package/dist/cache.js

@@ -0,0 +1,275 @@
+import { Cache as Store } from '@zenera/cli/lib';
+import { join } from 'node:path';
+import { build, BuildFailed, regenerate } from "./generate.js";
+import { saveBuildDump } from "./logger.js";
+import { GENERATOR_RULES_VERSION } from "./spec.js";
+// ---------------------------------------------------------------------------
+// The cache
+//
+// Two layers over one identity. `Operation.key` is a function of the
+// operation's shape, so a spec edit produces a new key and the old artefact is
+// simply never asked for again — there is nothing to invalidate, which is the
+// part of a cache that is usually wrong.
+//
+// The generator itself lives in the machine's shared cache rather than beside
+// the container's workspace, so the same spec served from two directories is
+// written once. The box root is scratch: a hit is copied back into it, because
+// the container can only run what is under its mount.
+//
+// The in-flight map is the other half and matters more than it looks: ten
+// requests arriving together for an uncached operation must produce one build,
+// not ten. A failed build is remembered too, for the same reason — an operation
+// the model could not write for should not re-ask on every request.
+// ---------------------------------------------------------------------------
+export const GYM_KIND = 'gym-generator';
+const DEFAULT_CONCURRENCY = 4;
+export class Cache {
+    #opts;
+    #store;
+    #dumpDir;
+    #records = new Map();
+    #live = new Map();
+    #settled = new Set();
+    #slots;
+    #waiting = [];
+    #running = 0;
+    constructor(opts) {
+        this.#opts = opts;
+        this.#store = new Store(GYM_KIND, { dir: opts.cacheDir, mode: 0o600 });
+        this.#dumpDir = opts.dumpDir ?? join(opts.box.root, 'builds');
+        this.#slots = Math.max(1, opts.concurrency ?? DEFAULT_CONCURRENCY);
+    }
+    /**
+     * The generator for an operation, written if it does not exist yet. Callers
+     * that arrive during a build wait for that build rather than starting one.
+     *
+     * `cached` answers "did this call cost a model turn", which is what the
+     * response header is for — so it is false for the caller that triggered the
+     * build and for everyone who waited on it, and true from then on.
+     */
+    ensure(operation) {
+        const already = this.#settled.has(operation.key);
+        const running = this.#live.get(operation.key);
+        if (running) {
+            return already ? running.then((g) => ({ ...g, cached: true })) : running;
+        }
+        const started = this.#make(operation).then((g) => {
+            this.#settled.add(operation.key);
+            return g;
+        }, (err) => {
+            // A model that tried and could not is remembered: re-asking it
+            // once per request is how a mock server becomes an invoice.
+            // Anything else — a rate limit, a dropped connection — is about
+            // this moment rather than this operation, so it is forgotten
+            // and the next request gets a fresh go.
+            if (!(err instanceof BuildFailed)) {
+                this.#live.delete(operation.key);
+            }
+            throw err;
+        });
+        this.#live.set(operation.key, started);
+        return started;
+    }
+    get model() {
+        return this.#opts.model;
+    }
+    async getSource(key) {
+        const found = this.#store.get(key);
+        return found?.source?.trim() ? found.source : undefined;
+    }
+    async regenerate(operation, ctx) {
+        const { box, model, checks, ephemeral } = this.#opts;
+        await this.#enter();
+        this.#opts.onStart?.({ operation });
+        try {
+            const built = await regenerate(operation, {
+                model,
+                box,
+                checks,
+                attempts: this.#opts.attempts,
+                currentSource: ctx.currentSource,
+                failingInput: ctx.failingInput,
+                fault: ctx.fault,
+                stderr: ctx.stderr,
+                examples: ctx.examples,
+                onAttempt: (attempt, diagnostics, source, limit) => this.#rejected(operation, attempt, diagnostics, source, limit, true),
+            });
+            if (!ephemeral) {
+                this.#store.put(operation.key, {
+                    source: built.source,
+                    meta: {
+                        operationId: operation.operationId,
+                        method: operation.method,
+                        path: operation.path,
+                        source: operation.source,
+                        model: model.id,
+                        attempts: built.attempts,
+                        rulesVersion: GENERATOR_RULES_VERSION,
+                        createdAt: new Date().toISOString(),
+                    },
+                });
+            }
+            this.#opts.onReady?.({ operation, cached: false, attempts: built.attempts });
+            const gen = { key: operation.key, source: built.source, cached: false };
+            this.#settled.add(operation.key);
+            this.#live.set(operation.key, Promise.resolve(gen));
+            await this.#finished(operation);
+            return gen;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            // The box holds the last rejected attempt; the next request must run the old file.
+            await box.write(operation.key, ctx.currentSource).catch(() => undefined);
+            const dump = await this.#finished(operation, error);
+            this.#opts.onFail?.({ operation, error, dump });
+            throw error;
+        }
+        finally {
+            this.#leave();
+        }
+    }
+    async #make(operation) {
+        const { box, model, checks, rebuild, ephemeral } = this.#opts;
+        // Read before queueing: a cache hit costs nothing and must not wait
+        // behind somebody else's model call.
+        const source = rebuild ? undefined : await this.#read(box, operation.key);
+        if (source !== undefined) {
+            this.#opts.onReady?.({ operation, cached: true, attempts: 0 });
+            return { key: operation.key, source, cached: true };
+        }
+        await this.#enter();
+        this.#opts.onStart?.({ operation });
+        try {
+            const built = await build(operation, {
+                model,
+                box,
+                checks,
+                attempts: this.#opts.attempts,
+                onAttempt: (attempt, diagnostics, source, limit) => this.#rejected(operation, attempt, diagnostics, source, limit, false),
+            });
+            if (!ephemeral) {
+                this.#store.put(operation.key, {
+                    source: built.source,
+                    meta: {
+                        operationId: operation.operationId,
+                        method: operation.method,
+                        path: operation.path,
+                        source: operation.source,
+                        model: model.id,
+                        attempts: built.attempts,
+                        rulesVersion: GENERATOR_RULES_VERSION,
+                        createdAt: new Date().toISOString(),
+                    },
+                });
+            }
+            this.#opts.onReady?.({ operation, cached: false, attempts: built.attempts });
+            await this.#finished(operation);
+            return { key: operation.key, source: built.source, cached: false };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            const dump = await this.#finished(operation, error);
+            this.#opts.onFail?.({ operation, error, dump });
+            throw error;
+        }
+        finally {
+            this.#leave();
+        }
+    }
+    /**
+     * An attempt the judge threw out. The report is rewritten with the file
+     * still in it before the next attempt overwrites `gen.py` — for a timeout
+     * that source is the only evidence there will ever be, since a generator
+     * that hangs leaves no traceback behind.
+     */
+    async #rejected(operation, attempt, diagnostics, source, limit, regeneration) {
+        let record = this.#records.get(operation.key);
+        if (!record || attempt === 1) {
+            record = {
+                operation,
+                started: new Date(),
+                limit,
+                regeneration,
+                attempts: [],
+            };
+            this.#records.set(operation.key, record);
+        }
+        record.attempts.push({ attempt, at: new Date(), diagnostics, source });
+        await this.#report(record);
+        this.#opts.onAttempt?.({ operation, attempt, diagnostics, dump: record.path });
+    }
+    /** A report that cannot be written is not worth failing a build over. */
+    async #report(record, gaveUp = false) {
+        try {
+            record.path = await saveBuildDump(this.#dumpDir, {
+                started: record.started,
+                operationId: record.operation.operationId,
+                method: record.operation.method,
+                path: record.operation.path,
+                key: record.operation.key,
+                limit: record.limit,
+                regeneration: record.regeneration,
+                model: this.#opts.model.id,
+                attempts: record.attempts,
+                gaveUp,
+            });
+        }
+        catch {
+            // no report, then — the narration still says what failed
+        }
+    }
+    /**
+     * The end of a build, either way. A failure is stamped as such and its
+     * report handed to the error, so the request that gets the 501 can say
+     * where to read about it.
+     */
+    async #finished(operation, error) {
+        const record = this.#records.get(operation.key);
+        this.#records.delete(operation.key);
+        if (!record) {
+            return undefined;
+        }
+        if (error instanceof BuildFailed) {
+            await this.#report(record, true);
+            error.dump = record.path;
+        }
+        return record.path;
+    }
+    /**
+     * A hit is written into the box before it is returned. The container runs
+     * files under its mount and nothing else, and the mount is scratch that any
+     * `cache clear` is free to delete.
+     */
+    async #read(box, key) {
+        const found = this.#store.get(key);
+        if (!found?.source?.trim()) {
+            return undefined;
+        }
+        try {
+            await box.write(key, found.source);
+        }
+        catch {
+            // The mount went away. Writing it again is the model's job.
+            return undefined;
+        }
+        return found.source;
+    }
+    #enter() {
+        if (this.#running < this.#slots) {
+            this.#running++;
+            return Promise.resolve();
+        }
+        return new Promise((admit) => this.#waiting.push(admit));
+    }
+    /** Hands the slot straight to whoever is next, so the count stays exact. */
+    #leave() {
+        const next = this.#waiting.shift();
+        if (next) {
+            next();
+            return;
+        }
+        this.#running--;
+    }
+}
+export { BuildFailed };
+//# sourceMappingURL=cache.js.map

package/dist/command.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '@zenera/cli/lib';
+export declare const command: Command;
+//# sourceMappingURL=command.d.ts.map

package/dist/command.js

@@ -0,0 +1,414 @@
+import { bold, cacheItems, clearCache, CliError, cyan, dim, EXIT, green, json, KeyStore, note, ownedContainers, parse, paths, red, removeContainers, table, usageError, write, writeAll, yellow, } from '@zenera/cli/lib';
+import { createModel } from '@zenera/neo';
+import { rmSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { CONTAINER_PREFIX, GENERATORS } from "./box.js";
+import { GYM_KIND } from "./cache.js";
+import { reason } from "./generate.js";
+import { formatDumpPath } from "./logger.js";
+import { listen } from "./server.js";
+import { chooseModel, MODEL_ENV, open, readSettings, SOURCE_LABELS, writeSettings, } from "./setup.js";
+import { called } from "./spec.js";
+// ---------------------------------------------------------------------------
+// zen gym — a mock API from a specification
+//
+// A command in another package rather than a binary of its own: one thing to
+// install, one keyring, one name to remember. `zen` loads this module only when
+// somebody types `zen gym`, so nothing here is on the path of `zen list`.
+//
+// That it stays up is not a problem for the frame — `run` simply does not
+// resolve until a signal arrives, and the process lives as long as the answer
+// takes, which is what every other command already means.
+// ---------------------------------------------------------------------------
+const USAGE = 'zen gym <serve|build|cache|model> [spec...]';
+// `--json` is the frame's, lifted out of the arguments before they arrive; it
+// reaches us as `ctx.json` and must not be declared again or `strict` rejects it.
+const OPTIONS = {
+    port: { type: 'string' },
+    host: { type: 'string' },
+    model: { type: 'string' },
+    image: { type: 'string' },
+    cache: { type: 'string' },
+    attempts: { type: 'string' },
+    concurrency: { type: 'string' },
+    seed: { type: 'string' },
+    timeout: { type: 'string' },
+    'max-body': { type: 'string' },
+    'regen-limit': { type: 'string' },
+    'requests-dir': { type: 'string' },
+    rebuild: { type: 'boolean' },
+    'no-cache': { type: 'boolean' },
+    clear: { type: 'boolean' },
+    quiet: { type: 'boolean' },
+};
+export const command = {
+    summary: 'Simulated API environments for agent training and evaluation.',
+    usage: USAGE,
+    details: [
+        'Commands',
+        ...table([
+            ['  serve <spec...>', dim('Serve the documents. Generators are written on demand.')],
+            ['  build <spec...>', dim('Write every generator now and exit.')],
+            ['  cache ls|clear', dim('What has been generated, or throw it away.')],
+            ['  model [ref]', dim('Show or set the model it uses. Remembered between runs.')],
+        ]),
+        '',
+        'Options',
+        ...table([
+            ['  --port <n>', dim('Default 8787.')],
+            ['  --host <h>', dim('Default 127.0.0.1. Anything else is reachable off-machine.')],
+            ['  --model <ref>', dim('Which model writes the generators, for this run only.')],
+            ['  --image <ref>', dim('Skip the baked image and use this one.')],
+            ['  --cache <dir>', dim("The container's workspace. Default ~/.zenera/neo/gym.")],
+            ['  --seed <n>', dim('Answer the same request the same way every time.')],
+            ['  --attempts <n>', dim('Tries per generator before giving up. Default 5.')],
+            ['  --concurrency <n>', dim('Generators written at once. Default 4.')],
+            ['  --timeout <s>', dim('Seconds one generator may take. Default 30.')],
+            ['  --max-body <n>', dim('Largest request body accepted, in bytes.')],
+            ['  --regen-limit <n>', dim('Maximum regenerations per URL on error. Default 3.')],
+            ['  --requests-dir <dir>', dim('Where to save request/response .md files.')],
+            ['  --rebuild', dim('Ignore what is cached and write it again.')],
+            ['  --no-cache', dim('Do not record what is written.')],
+            ['  --clear', dim('With `model`: forget the stored one.')],
+            ['  --quiet', dim('No narration.')],
+        ]),
+        '',
+        dim(`The model is looked for in this order: ${cyan('--model')}, ${cyan(MODEL_ENV)}, ` +
+            `${cyan('zen gym model')}, then the best one your keys can buy.`),
+        dim(`Credentials come from the ${cyan('zen')} keyring — try ${cyan('zen key ls')}.`),
+    ],
+    async run(ctx) {
+        const [name, ...rest] = ctx.args;
+        switch (name) {
+            case 'serve':
+                return await serve(rest, ctx);
+            case 'build':
+                return await warm(rest, ctx);
+            case 'cache':
+                return await cache(rest, ctx);
+            case 'model':
+                return await model(rest, ctx);
+            default:
+                throw usageError(name ? `unknown command "${name}"` : 'no command given', USAGE);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// serve
+// ---------------------------------------------------------------------------
+async function serve(args, ctx) {
+    const { values, positionals } = parse(args, OPTIONS, 'zen gym serve <spec...>');
+    const loud = !values.quiet && !ctx.json;
+    const setup = await start(values, positionals, ctx, 'serve');
+    if (loud) {
+        printSpecs(setup.router.operations, ctx.cwd);
+    }
+    const host = values.host ?? '127.0.0.1';
+    const requestsDir = values['requests-dir']
+        ? resolve(ctx.cwd, values['requests-dir'])
+        : undefined;
+    const listener = await listen({
+        router: setup.router,
+        cache: setup.cache,
+        checks: setup.checks,
+        box: setup.box,
+        seed: number(values.seed, 'seed'),
+        maxBody: number(values['max-body'], 'max-body'),
+        requestsDir,
+        regenLimit: number(values['regen-limit'], 'regen-limit'),
+        onRequest: values.quiet ? undefined : (line) => note(line),
+    }, host, number(values.port, 'port') ?? 8787);
+    if (!values.quiet) {
+        note(`${green('listening')} ${cyan(`http://${host}:${listener.port}`)} ` +
+            dim(`${setup.router.operations.length} operations`));
+        if (host !== '127.0.0.1' && host !== 'localhost') {
+            note(yellow(`bound to ${host} — this mock is reachable from the network`));
+        }
+        note(dim(`generators: ${setup.root}/${GENERATORS}`));
+        note(dim(`request logs: ${requestsDir ?? `${setup.root}/requests`}`));
+        note(dim(`failed builds: ${setup.root}/builds`));
+    }
+    // The address is the answer; the rest was narration.
+    write(`http://${host}:${listener.port}`);
+    await until(['SIGINT', 'SIGTERM']);
+    if (!values.quiet) {
+        note(dim('stopping'));
+    }
+    await listener.close();
+    await setup.close();
+}
+/** Resolves when one of the signals arrives, and stops listening for them. */
+function until(signals) {
+    return new Promise((settle) => {
+        const done = () => {
+            for (const s of signals) {
+                process.off(s, done);
+            }
+            settle();
+        };
+        for (const s of signals) {
+            process.once(s, done);
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// build — every generator, up front
+// ---------------------------------------------------------------------------
+async function warm(args, ctx) {
+    const { values, positionals } = parse(args, OPTIONS, 'zen gym build <spec...>');
+    const loud = !values.quiet && !ctx.json;
+    const setup = await start(values, positionals, ctx, 'build');
+    if (loud) {
+        printSpecs(setup.router.operations, ctx.cwd);
+    }
+    const results = [];
+    try {
+        for (const operation of setup.router.operations) {
+            const id = `${operation.method.toUpperCase()} ${called(operation)}`;
+            if (!operation.success.schema) {
+                results.push({ operation: id, status: 'skipped', detail: 'no response body' });
+                continue;
+            }
+            try {
+                const generator = await setup.cache.ensure(operation);
+                results.push({ operation: id, status: generator.cached ? 'cached' : 'built' });
+            }
+            catch (err) {
+                results.push({
+                    operation: id,
+                    status: 'failed',
+                    detail: reason(err),
+                });
+            }
+        }
+    }
+    finally {
+        await setup.close();
+    }
+    if (ctx.json) {
+        json(results);
+    }
+    else {
+        writeAll(table(results.map((r) => [
+            `  ${mark(r.status)}`,
+            r.operation,
+            dim(r.detail?.slice(0, 100) ?? ''),
+        ])));
+    }
+    // Reported first, then failed: the table is the answer either way.
+    const failed = results.filter((r) => r.status === 'failed').length;
+    if (failed > 0) {
+        throw new CliError(`${failed} of ${results.length} generators failed`, EXIT.failed, 'run again to retry, or raise --attempts');
+    }
+}
+const mark = (status) => status === 'failed' ? red('failed') : status === 'skipped' ? dim('skipped') : green(status);
+// ---------------------------------------------------------------------------
+// cache
+// ---------------------------------------------------------------------------
+async function cache(args, ctx) {
+    const { values, positionals } = parse(args, OPTIONS, 'zen gym cache <ls|clear>');
+    const root = values.cache ? resolve(ctx.cwd, values.cache) : paths.gym();
+    const sub = positionals[0] ?? 'ls';
+    if (sub === 'ls') {
+        const entries = listGenerators();
+        if (ctx.json) {
+            json(entries);
+            return;
+        }
+        if (entries.length === 0) {
+            note('nothing cached yet');
+            return;
+        }
+        writeAll(table([
+            [bold('KEY'), bold('OPERATION'), bold('MODEL'), bold('TRIES')],
+            ...entries.map((e) => [
+                e.key,
+                `${e.method?.toUpperCase() ?? '?'} ${e.path ?? ''}`,
+                dim(e.model ?? '—'),
+                dim(String(e.attempts ?? '—')),
+            ]),
+        ]));
+        return;
+    }
+    if (sub === 'clear') {
+        clearCache({ kind: GYM_KIND });
+        // The workspace is scratch — whatever a hit was copied into it is
+        // written again from the cache, or by the model.
+        rmSync(join(root, GENERATORS), { recursive: true, force: true });
+        // The container is named after its configuration, so a stale one would
+        // otherwise sit there stopped forever with nothing pointing at it.
+        // `zn-<key>-<digest>` is the shape, and this one's key is `gym`.
+        const mine = (await ownedContainers()).filter((c) => c.name.startsWith(CONTAINER_PREFIX));
+        if (mine.length > 0) {
+            await removeContainers(mine.map((c) => c.name));
+        }
+        note(`${green('cleared')} ${dim(paths.cache())}`);
+        return;
+    }
+    throw usageError(`unknown cache command "${sub}"`, 'zen gym cache <ls|clear>');
+}
+/**
+ * The keys are the operation keys, written verbatim — which is why they can be
+ * listed at all. Anything the store cannot parse is left out rather than shown
+ * as a row with nothing in it.
+ */
+function listGenerators() {
+    const { rows } = cacheItems(GYM_KIND);
+    return rows
+        .map((row) => ({ key: row.key, ...row.value?.meta }))
+        .sort((a, b) => a.key.localeCompare(b.key));
+}
+// ---------------------------------------------------------------------------
+// model
+//
+// A stored model is remembered the way `zen meta model` remembers one: in the
+// home directory, beside the keyring, because it is a choice about this tool on
+// this machine. Shown rather than merely set, since the question when a run
+// surprises you is not "which model" but "why that one".
+// ---------------------------------------------------------------------------
+const MODEL_USAGE = 'zen gym model [ref|--clear]';
+async function model(args, ctx) {
+    const { values, positionals } = parse(args, OPTIONS, MODEL_USAGE);
+    const ref = positionals[0];
+    if (ref && values.clear) {
+        throw usageError('--clear takes no model', MODEL_USAGE);
+    }
+    // Before anything builds a model: vertex reads its project out of the
+    // environment, and the keyring is what puts it there.
+    const keys = await KeyStore.open();
+    keys.materialize();
+    if (ref || values.clear) {
+        const file = await readSettings();
+        if (ref) {
+            // Only that the ref parses: asking the provider costs a call, and
+            // the next run makes one anyway.
+            createModel(ref);
+            writeSettings({ ...file, model: ref });
+        }
+        else {
+            delete file.model;
+            writeSettings(file);
+        }
+        if (ctx.json) {
+            json({ model: ref });
+            return;
+        }
+        note(ref ? `${green('set')} ${ref}` : `${green('cleared')} ${dim('the stored model')}`);
+    }
+    const chosen = await chooseModel(values.model, keys);
+    if (ctx.json) {
+        json({ model: chosen?.ref, from: chosen?.from, stored: (await readSettings()).model });
+        return;
+    }
+    if (!chosen) {
+        note('no model, and no key to recommend one from');
+        note(dim('add a key: zen key add openai'));
+        return;
+    }
+    note(`${cyan(chosen.ref)} ${dim(`from ${SOURCE_LABELS[chosen.from]}`)}`);
+    if (chosen.from === 'default') {
+        note(dim(`set one: zen gym model <provider>:<id>`));
+    }
+}
+function summarize(operations) {
+    const by = new Map();
+    for (const op of operations) {
+        let stat = by.get(op.source);
+        if (!stat) {
+            stat = { source: op.source, paths: new Set(), methods: 0, functions: 0 };
+            by.set(op.source, stat);
+        }
+        stat.paths.add(op.path);
+        stat.methods += 1;
+        if (op.success.schema) {
+            stat.functions += 1;
+        }
+    }
+    return [...by.values()];
+}
+const HEADERS = ['PATHS', 'METHODS', 'FUNCTIONS'];
+function printSpecs(operations, cwd) {
+    const stats = summarize(operations);
+    const rows = stats.map((s) => ({
+        name: relative(cwd, s.source) || s.source,
+        cells: [s.paths.size, s.methods, s.functions],
+    }));
+    if (rows.length > 1) {
+        rows.push({
+            name: 'total',
+            cells: HEADERS.map((_, i) => rows.reduce((n, r) => n + r.cells[i], 0)),
+        });
+    }
+    // Numbers are padded before they are styled: a colour code has no width,
+    // and `table` cannot know that.
+    const widths = HEADERS.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r.cells[i]).length)));
+    const lines = table([
+        [bold('SPEC'), ...HEADERS.map((h, i) => bold(h.padStart(widths[i])))],
+        ...rows.map((r) => [
+            r.name === 'total' ? dim(r.name) : r.name,
+            ...r.cells.map((c, i) => String(c).padStart(widths[i])),
+        ]),
+    ]);
+    note('');
+    for (const line of lines) {
+        note(`  ${line}`);
+    }
+    note('');
+}
+// ---------------------------------------------------------------------------
+// Shared
+// ---------------------------------------------------------------------------
+async function start(values, specs, ctx, what) {
+    const loud = !values.quiet && !ctx.json;
+    const setup = await open({
+        specs,
+        cwd: ctx.cwd,
+        cache: values.cache,
+        model: values.model,
+        image: values.image,
+        attempts: number(values.attempts, 'attempts'),
+        concurrency: number(values.concurrency, 'concurrency'),
+        timeout: number(values.timeout, 'timeout'),
+        rebuild: values.rebuild,
+        ephemeral: values['no-cache'],
+        onImageBuild: loud
+            ? (tag) => note(`${dim('building')} ${tag} ${dim('— once, then cached')}`)
+            : undefined,
+        events: {
+            onStart: loud
+                ? ({ operation }) => note(`${dim('writing a generator for')} ${operation.method.toUpperCase()} ${called(operation)}`)
+                : undefined,
+            onAttempt: loud
+                ? ({ operation, attempt, diagnostics }) => note(`  ${yellow(`attempt ${attempt} failed`)} ${dim(`${operation.operationId}: ${(diagnostics ?? []).join(' ').slice(0, 160)}`)}`)
+                : undefined,
+            onReady: loud && what === 'serve'
+                ? ({ operation, cached }) => cached
+                    ? undefined
+                    : note(`  ${green('ready')} ${dim(operation.operationId)}`)
+                : undefined,
+            onFail: loud
+                ? ({ operation, error, dump }) => {
+                    note(`  ${red('gave up')} ${dim(operation.operationId)} ${reason(error)}`);
+                    if (dump) {
+                        note(formatDumpPath('report', dump));
+                    }
+                }
+                : undefined,
+        },
+    });
+    if (loud) {
+        note(dim(`model ${setup.choice.ref} from ${SOURCE_LABELS[setup.choice.from]}`));
+    }
+    return setup;
+}
+function number(raw, what) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        throw usageError(`--${what} must be a number, got "${raw}"`);
+    }
+    return value;
+}
+//# sourceMappingURL=command.js.map