@fnndsc/chili 3.4.0 → 3.6.0

package/dist/plugins/pluginGroupHandler.js

@@ -8,39 +8,50 @@ import { options_toParams } from "../utils/cli.js";
 import { PluginContextController } from "../controllers/pluginContextController.js";
 import { pluginParameters_renderMan, pluginParameters_manRender } from "../views/pluginParameters.js";
 import { envelope_ok, envelope_error } from "@fnndsc/cumin";
-class InitializationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "InitializationError";
-    }
-}
+import { chiliErrLog, chiliLog } from "../screen/output.js";
 /**
  * Handles commands related to groups of plugin contexts (computes, instances, parameters).
  */
 export class PluginContextGroupHandler {
-    constructor(controller, assetName) {
-        this.baseGroupHandler = null;
-        this.controller = controller;
+    constructor(assetName, id) {
+        // Resolved lazily on first action.
+        this.controller = null;
         this.assetName = assetName;
-        // Cast ChRISEmbeddedResourceGroup to ChRISEmbeddedResourceGroup<unknown> safely.
-        this.baseGroupHandler = new BaseGroupHandler(this.assetName, this.controller.chrisObject);
+        this.id = id;
+        this.baseGroupHandler = new BaseGroupHandler(this.assetName);
     }
     /**
-     * Factory method to create a new PluginContextGroupHandler instance.
+     * Creates a PluginContextGroupHandler for an asset type. This performs no
+     * network work and resolves no plugin context — command registration needs
+     * only the asset name; the controller is resolved lazily on first action (see
+     * {@link controller_ensure}).
      *
-     * @param assetName - The type of plugin context to handle ('computesofplugin', 'instancesofplugin', 'parametersofplugin').
-     * @param id - Optional plugin ID. Defaults to current ChRIS plugin context.
-     * @returns A Promise resolving to a new PluginContextGroupHandler instance.
-     * @throws InitializationError if an unsupported asset type is provided.
+     * @param assetName - The type of plugin context ('computesofplugin', 'instancesofplugin', 'parametersofplugin').
+     * @param id - Optional plugin ID the context binds to; defaults to the current plugin context.
+     * @returns A new PluginContextGroupHandler instance.
      */
-    static async handler_create(assetName, id) {
-        try {
-            const controller = await PluginContextController.controller_create(assetName, id);
-            return new PluginContextGroupHandler(controller, assetName);
-        }
-        catch (error) {
-            throw new InitializationError(`Failed to initialize PluginContextGroupHandler: ${error}`);
+    static handler_create(assetName, id) {
+        return new PluginContextGroupHandler(assetName, id);
+    }
+    /**
+     * Lazily resolves and memoizes the plugin-context controller against the bound
+     * plugin id (or the current ChRIS context), wiring it into the
+     * registration-only base handler so its actions can read the context.
+     *
+     * @returns The controller, or null if the context cannot be resolved here.
+     */
+    async controller_ensure() {
+        if (!this.controller) {
+            try {
+                this.controller = await PluginContextController.controller_create(this.assetName, this.id);
+                this.baseGroupHandler.chrisObject =
+                    this.controller.chrisObject;
+            }
+            catch {
+                this.controller = null;
+            }
         }
+        return this.controller;
     }
     /**
      * Lists plugin parameters in a "man page" style format.
@@ -50,10 +61,15 @@ export class PluginContextGroupHandler {
      */
     async parameters_listMan(options) {
         try {
+            const controller = await this.controller_ensure();
+            if (!controller) {
+                chiliErrLog(`No plugin context is available for ${this.assetName} in the current context.`);
+                return;
+            }
             // We access the asset directly from the controller
-            const asset = this.controller.chrisObject.asset;
+            const asset = controller.chrisObject.asset;
             if (!asset || typeof asset.resources_listAndFilterByOptions !== 'function') {
-                console.error("Underlying resource does not support listing.");
+                chiliErrLog("Underlying resource does not support listing.");
                 return;
             }
             const params = options_toParams(options);
@@ -62,20 +78,23 @@ export class PluginContextGroupHandler {
                 pluginParameters_renderMan(results);
             }
             else {
-                console.log("No parameters found.");
+                chiliLog("No parameters found.");
             }
         }
         catch (error) {
-            console.error(`Error listing parameters: ${error}`);
+            chiliErrLog(`Error listing parameters: ${error}`);
         }
     }
     /**
      * Lists available fields for the current plugin context resource.
      */
     async parameters_fieldsList() {
-        if (this.baseGroupHandler) {
-            await this.baseGroupHandler.resourceFields_list();
+        const controller = await this.controller_ensure();
+        if (!controller) {
+            chiliErrLog(`No plugin context is available for ${this.assetName} in the current context.`);
+            return;
         }
+        await this.baseGroupHandler.resourceFields_list();
     }
     /**
      * Renders plugin parameters in "man page" style as an envelope.
@@ -87,7 +106,11 @@ export class PluginContextGroupHandler {
      */
     async parameters_listManRender(options) {
         try {
-            const asset = this.controller.chrisObject.asset;
+            const controller = await this.controller_ensure();
+            if (!controller) {
+                return envelope_error('', undefined, `No plugin context is available for ${this.assetName} in the current context.\n`);
+            }
+            const asset = controller.chrisObject.asset;
             if (!asset || typeof asset.resources_listAndFilterByOptions !== 'function') {
                 return envelope_error('', undefined, "Underlying resource does not support listing.\n");
             }
@@ -110,10 +133,11 @@ export class PluginContextGroupHandler {
      * @returns An envelope carrying the field listing.
      */
     async parameters_fieldsRender() {
-        if (this.baseGroupHandler) {
-            return this.baseGroupHandler.resourceFields_render();
+        const controller = await this.controller_ensure();
+        if (!controller) {
+            return envelope_ok('');
         }
-        return envelope_ok('');
+        return this.baseGroupHandler.resourceFields_render();
     }
     /**
      * Sets up the Commander.js commands for plugin context group operations.
@@ -121,9 +145,6 @@ export class PluginContextGroupHandler {
      * @param program - The Commander.js program instance.
      */
     pluginContextGroupCommand_setup(program) {
-        if (this.baseGroupHandler) {
-            this.baseGroupHandler.command_setup(program);
-        }
-        const fileGroupCommand = program.commands.find((cmd) => cmd.name() === this.assetName);
+        this.baseGroupHandler.command_setup(program);
     }
 }

package/dist/plugins/pluginHandler.js

@@ -13,6 +13,7 @@ import { pluginIds_resolve } from "../commands/plugin/search.js";
 import { pluginRun_render } from "../views/plugin.js"; // Still needed for pluginRun_render
 import chalk from "chalk";
 import { pluginReadme_render } from "../commands/plugin/readme.js";
+import { chiliErrLog, chiliLog } from "../screen/output.js";
 /**
  * Handles commands related to groups of ChRIS plugins.
  */
@@ -34,10 +35,10 @@ export class PluginGroupHandler {
     // async plugins_list(options: CLIoptions): Promise<void> {
     //   try {
     //     const { plugins, selectedFields } = await plugins_fetchList(options);
-    //     console.log(pluginList_render(plugins, selectedFields, { table: options.table, csv: options.csv }));
+    //     chiliLog(pluginList_render(plugins, selectedFields, { table: options.table, csv: options.csv }));
     //   } catch (error: unknown) {
     //     const msg = error instanceof Error ? error.message : String(error);
-    //     console.error(msg);
+    //     chiliErrLog(msg);
     //   }
     // }
     /**
@@ -50,11 +51,11 @@ export class PluginGroupHandler {
                 table_display(fields, ["fields"]);
             }
             else {
-                console.log(`No resource fields found for ${this.assetName}.`);
+                chiliLog(`No resource fields found for ${this.assetName}.`);
             }
         }
         catch (error) {
-            console.log(errorStack.stack_search(this.assetName)[0]);
+            chiliLog(errorStack.stack_search(this.assetName)[0]);
         }
     }
     /**
@@ -67,12 +68,12 @@ export class PluginGroupHandler {
         for (const search of searchables) {
             const items = await plugins_searchByTerm(search.raw);
             if (items.length === 0) {
-                console.log(`No plugins found matching: ${search.raw}`);
+                chiliLog(`No plugins found matching: ${search.raw}`);
                 continue;
             }
             for (const item of items) {
                 // Show item info - reusing table_display for single item details if possible, or simple log
-                console.log(`Preparing to delete Plugin: ID=${item.id}, Name=${item.name}, Version=${item.version}`);
+                chiliLog(`Preparing to delete Plugin: ID=${item.id}, Name=${item.name}, Version=${item.version}`);
                 if (!options.force) {
                     const confirmed = await prompt_confirm(`Are you sure you want to delete plugin ${item.name} (ID: ${item.id})?`);
                     if (!confirmed)
@@ -80,10 +81,10 @@ export class PluginGroupHandler {
                 }
                 const success = await plugin_deleteById(item.id);
                 if (success) {
-                    console.log(`Deleted plugin ${item.id}`);
+                    chiliLog(`Deleted plugin ${item.id}`);
                 }
                 else {
-                    console.error(`Failed to delete plugin ${item.id}`);
+                    chiliErrLog(`Failed to delete plugin ${item.id}`);
                 }
             }
         }
@@ -161,11 +162,11 @@ export class PluginMemberHandler {
     async readme_print(repoUrl) {
         const content = await this.controller.readmeContent_fetch(repoUrl);
         if (content) {
-            console.log(chalk.green.bold("\nREADME Content:"));
-            console.log(pluginReadme_render(content));
+            chiliLog(chalk.green.bold("\nREADME Content:"));
+            chiliLog(pluginReadme_render(content));
         }
         else {
-            console.log(chalk.red("README not found in the repository."));
+            chiliLog(chalk.red("README not found in the repository."));
         }
     }
     /**
@@ -176,21 +177,21 @@ export class PluginMemberHandler {
      */
     async plugin_readme(pluginId) {
         try {
-            console.log(`Fetching info for plugin with ID: ${pluginId}`);
+            chiliLog(`Fetching info for plugin with ID: ${pluginId}`);
             const documentation = await this.controller.documentationUrl_get(pluginId);
             if (!documentation) {
                 return null;
             }
-            console.log(documentation);
+            chiliLog(documentation);
             await this.readme_print(documentation);
             return documentation;
         }
         catch (error) {
             if (error instanceof Error) {
-                console.error(`Error fetching plugin info: ${error.message}`);
+                chiliErrLog(`Error fetching plugin info: ${error.message}`);
             }
             else {
-                console.error("An unknown error occurred while fetching plugin info");
+                chiliErrLog("An unknown error occurred while fetching plugin info");
             }
         }
         return null;
@@ -214,15 +215,15 @@ export class PluginMemberHandler {
         try {
             const instance = await plugin_execute(searchable, params);
             if (!instance) {
-                console.log(errorStack.messagesOfType_search("error", "plugin"));
+                chiliLog(errorStack.messagesOfType_search("error", "plugin"));
                 return null;
             }
-            console.log(pluginRun_render(instance));
+            chiliLog(pluginRun_render(instance));
             return instance.id;
         }
         catch (e) {
             const message = e instanceof Error ? e.message : String(e);
-            console.error(message);
+            chiliErrLog(message);
             return null;
         }
     }
@@ -234,7 +235,7 @@ export class PluginMemberHandler {
         if (!hits) {
             return null;
         }
-        console.log(hits);
+        chiliLog(hits);
         return hits;
     }
     /**
@@ -270,10 +271,10 @@ export class PluginMemberHandler {
                 else {
                     const warnings = errorStack_getAllOfType('warning');
                     if (warnings && warnings.length > 0) {
-                        warnings.forEach(warning => console.error(chalk.yellow(warning)));
+                        warnings.forEach(warning => chiliErrLog(chalk.yellow(warning)));
                     }
                     else {
-                        console.error(chalk.red("Plugin not found."));
+                        chiliErrLog(chalk.red("Plugin not found."));
                     }
                 }
             });
@@ -297,7 +298,7 @@ export class PluginMemberHandler {
             });
         }
         else {
-            console.error(`Failed to find '${this.assetName}' command. The 'readme' subcommand was not added.`);
+            chiliErrLog(`Failed to find '${this.assetName}' command. The 'readme' subcommand was not added.`);
         }
     }
 }

package/dist/run.d.ts

@@ -9,6 +9,16 @@
  *
  * @module
  */
+import { type ChiliCaptured } from "./screen/output.js";
+/**
+ * The set of top-level chili command names. Builds a fresh program and registers
+ * every handler — now a cheap, network-free operation — then reads the
+ * registered command names. A host (the brasa engine) uses this to decide
+ * whether an unknown chell command is worth delegating to chili at all.
+ *
+ * @returns The registered top-level command names.
+ */
+export declare function commandNames_get(): Promise<Set<string>>;
 /**
  * Executes a single chili command in the current process.
  *
@@ -22,3 +32,15 @@
  *   the leading `node`/script entries).
  */
 export declare function run(argv: string[]): Promise<void>;
+/**
+ * Executes a single chili command with its output captured instead of printed.
+ *
+ * Runs {@link run} inside {@link chili_capture}, so everything the command
+ * would have written to the output and error channels is collected and
+ * returned. This is how an in-process host (the brasa engine) drives chili
+ * headless and carries the result in an envelope, with no console monkeypatch.
+ *
+ * @param argv - The chili arguments, e.g. `["feeds", "list", "-s"]`.
+ * @returns The captured output and error text.
+ */
+export declare function run_capture(argv: string[]): Promise<ChiliCaptured>;

package/dist/run.js

@@ -25,8 +25,9 @@ import { chefsCommand_setup } from "./chefs/chefs.js";
 import { PACSServerGroupHandler } from "./pacs/pacsServerHandler.js";
 import { PACSQueryGroupHandler } from "./pacs/pacsQueryHandler.js";
 import { PACSRetrieveGroupHandler } from "./pacs/pacsRetrieveHandler.js";
-import { chrisConnection_init, NodeStorageProvider, errorStack_getAllOfType, } from "@fnndsc/cumin";
+import { chrisConnection_init, NodeStorageProvider, } from "@fnndsc/cumin";
 import { FileGroupHandler } from "./filesystem/fileGroupHandler.js";
+import { chiliErrLog, chiliLog, chili_capture } from "./screen/output.js";
 /**
  * Suppress the DEP0169 (`url.parse()`) warning emitted transitively by
  * axios -> proxy-from-env, which we do not control. Installed once at import.
@@ -72,51 +73,32 @@ async function handlers_initialize(program) {
     feedMemberHandler.feedCommand_setup(program);
     const pluginMemberHandler = new PluginMemberHandler();
     pluginMemberHandler.pluginCommand_setup(program);
-    try {
-        const filesGroupHandler = await FileGroupHandler.handler_create("files");
-        filesGroupHandler.fileGroupCommand_setup(program);
-        const linksGroupHandler = await FileGroupHandler.handler_create("links");
-        linksGroupHandler.fileGroupCommand_setup(program);
-        const dirsGroupHandler = await FileGroupHandler.handler_create("dirs");
-        dirsGroupHandler.fileGroupCommand_setup(program);
-    }
-    catch (e) {
-        const err = e instanceof Error ? e.message : String(e);
-        const errors = errorStack_getAllOfType("error");
-        const warnings = errorStack_getAllOfType("warning");
-        console.log(`Note: File group commands (files, dirs, links) are unavailable. Reason: ${err}`);
-        if (errors.length > 0) {
-            console.log("Errors:");
-            errors.forEach((msg) => console.log(`  - ${msg}`));
-        }
-        if (warnings.length > 0) {
-            console.log("Warnings:");
-            warnings.forEach((msg) => console.log(`  - ${msg}`));
-        }
-    }
-    try {
-        const computesOfPluginHandler = await PluginContextGroupHandler.handler_create("computesofplugin");
-        computesOfPluginHandler.pluginContextGroupCommand_setup(program);
-        const pluginInstancesHandler = await PluginContextGroupHandler.handler_create("instancesofplugin");
-        pluginInstancesHandler.pluginContextGroupCommand_setup(program);
-        const pluginParametersHandler = await PluginContextGroupHandler.handler_create("parametersofplugin");
-        pluginParametersHandler.pluginContextGroupCommand_setup(program);
+    // File-group and plugin-context commands register with no ChRIS context: each
+    // handler resolves its context lazily, only when one of its actions runs. This
+    // keeps setup free of network work, so an unrelated command (or a directory
+    // that is not a ChRIS folder) pays no file-context cost and produces no
+    // context-init noise.
+    for (const assetName of ["files", "links", "dirs"]) {
+        FileGroupHandler.handler_create(assetName).fileGroupCommand_setup(program);
     }
-    catch (e) {
-        const err = e instanceof Error ? e.message : String(e);
-        const errors = errorStack_getAllOfType("error");
-        const warnings = errorStack_getAllOfType("warning");
-        console.log(`Note: Plugin context commands are unavailable. Reason: ${err}`);
-        if (errors.length > 0) {
-            console.log("Errors:");
-            errors.forEach((msg) => console.log(`  - ${msg}`));
-        }
-        if (warnings.length > 0) {
-            console.log("Warnings:");
-            warnings.forEach((msg) => console.log(`  - ${msg}`));
-        }
+    for (const assetName of ["computesofplugin", "instancesofplugin", "parametersofplugin"]) {
+        PluginContextGroupHandler.handler_create(assetName).pluginContextGroupCommand_setup(program);
     }
 }
+/**
+ * The set of top-level chili command names. Builds a fresh program and registers
+ * every handler — now a cheap, network-free operation — then reads the
+ * registered command names. A host (the brasa engine) uses this to decide
+ * whether an unknown chell command is worth delegating to chili at all.
+ *
+ * @returns The registered top-level command names.
+ */
+export async function commandNames_get() {
+    const program = new Command();
+    connectCommand_setup(program);
+    await handlers_initialize(program);
+    return new Set(program.commands.map((cmd) => cmd.name()));
+}
 /**
  * Extracts a leading `key=value` context string from an argv array.
  *
@@ -155,7 +137,7 @@ export async function run(argv) {
     if (context) {
         const contextSetSuccess = await connection.context_set(context);
         if (!contextSetSuccess) {
-            console.error("Failed to set context.");
+            chiliErrLog("Failed to set context.");
             return;
         }
         fullArgv = newArgs;
@@ -174,8 +156,8 @@ export async function run(argv) {
     program.parseOptions(fullArgv);
     const options = program.opts();
     if (!options.nosplash) {
-        console.log(figlet.textSync("ChILI"));
-        console.log("ChILI handles Intelligent Line Interactions");
+        chiliLog(figlet.textSync("ChILI"));
+        chiliLog("ChILI handles Intelligent Line Interactions");
     }
     try {
         await program.parseAsync(fullArgv);
@@ -190,3 +172,17 @@ export async function run(argv) {
         throw err;
     }
 }
+/**
+ * Executes a single chili command with its output captured instead of printed.
+ *
+ * Runs {@link run} inside {@link chili_capture}, so everything the command
+ * would have written to the output and error channels is collected and
+ * returned. This is how an in-process host (the brasa engine) drives chili
+ * headless and carries the result in an envelope, with no console monkeypatch.
+ *
+ * @param argv - The chili arguments, e.g. `["feeds", "list", "-s"]`.
+ * @returns The captured output and error text.
+ */
+export async function run_capture(argv) {
+    return chili_capture(() => run(argv));
+}

package/dist/screen/output.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @file chili's output seam.
+ *
+ * chili historically printed straight to `console.log`/`console.error`, which
+ * fused its command layer to a terminal and forced any in-process host (the
+ * brasa engine, which drives chili headless) to capture output with a console
+ * monkeypatch. This seam inverts that: command output is written to whatever
+ * writer is installed, and by default that writer simply delegates to the
+ * process console — so chili's standalone CLI behaves exactly as it always has.
+ *
+ * A host captures a run's output with {@link chili_capture}, which swaps in a
+ * buffering writer for the duration of a call and returns the collected text.
+ * This is explicit dependency injection through a module seam, not a runtime
+ * override of the global `console`: the default writer calls `console.log`
+ * normally, and capture bypasses the console entirely.
+ *
+ * @module
+ */
+/**
+ * Destination for chili's command output.
+ */
+export interface ChiliWriter {
+    /**
+     * Writes to the output channel with `console.log` semantics.
+     *
+     * @param args - The values to format, exactly as passed to `console.log`.
+     */
+    log(...args: unknown[]): void;
+    /**
+     * Writes to the error channel with `console.error` semantics.
+     *
+     * @param args - The values to format, exactly as passed to `console.error`.
+     */
+    errLog(...args: unknown[]): void;
+    /**
+     * Writes raw text or bytes to the output channel without adding a newline.
+     *
+     * @param chunk - The text or bytes to write.
+     */
+    write(chunk: string | Buffer): void;
+}
+/**
+ * Installs a writer as the active output destination.
+ *
+ * @param writer - The writer to install.
+ * @returns The previously installed writer, so callers can restore it.
+ */
+export declare function chiliWriter_set(writer: ChiliWriter): ChiliWriter;
+/**
+ * Writes to the output channel with `console.log` semantics.
+ *
+ * @param args - The values to format, exactly as passed to `console.log`.
+ */
+export declare function chiliLog(...args: unknown[]): void;
+/**
+ * Writes to the error channel with `console.error` semantics.
+ *
+ * @param args - The values to format, exactly as passed to `console.error`.
+ */
+export declare function chiliErrLog(...args: unknown[]): void;
+/**
+ * Writes raw text or bytes to the output channel without adding a newline —
+ * the replacement for direct `process.stdout.write` calls.
+ *
+ * @param chunk - The text or bytes to write.
+ */
+export declare function chiliWrite(chunk: string | Buffer): void;
+/**
+ * The text captured from a run, one string per channel.
+ */
+export interface ChiliCaptured {
+    /** Everything written to the output channel. */
+    out: string;
+    /** Everything written to the error channel. */
+    err: string;
+}
+/**
+ * Runs `fn` with both channels captured into memory and returns the collected
+ * text, restoring the previous writer afterwards even if `fn` throws.
+ *
+ * Formatting matches `console.log`: arguments are rendered with `util.format`
+ * and each `log`/`errLog` call contributes a trailing newline, exactly as the
+ * console would have written.
+ *
+ * @param fn - The work whose output should be captured.
+ * @returns The captured output and error text.
+ */
+export declare function chili_capture(fn: () => Promise<void>): Promise<ChiliCaptured>;

package/dist/screen/output.js

@@ -0,0 +1,95 @@
+/**
+ * @file chili's output seam.
+ *
+ * chili historically printed straight to `console.log`/`console.error`, which
+ * fused its command layer to a terminal and forced any in-process host (the
+ * brasa engine, which drives chili headless) to capture output with a console
+ * monkeypatch. This seam inverts that: command output is written to whatever
+ * writer is installed, and by default that writer simply delegates to the
+ * process console — so chili's standalone CLI behaves exactly as it always has.
+ *
+ * A host captures a run's output with {@link chili_capture}, which swaps in a
+ * buffering writer for the duration of a call and returns the collected text.
+ * This is explicit dependency injection through a module seam, not a runtime
+ * override of the global `console`: the default writer calls `console.log`
+ * normally, and capture bypasses the console entirely.
+ *
+ * @module
+ */
+import { format } from "util";
+/**
+ * The default writer: delegates to the process console. Installed at import so
+ * the standalone CLI prints exactly as before.
+ */
+const consoleWriter = {
+    log: (...args) => { console.log(...args); },
+    errLog: (...args) => { console.error(...args); },
+    write: (chunk) => { process.stdout.write(chunk); },
+};
+/** The writer in effect. Swapped for the duration of a captured run. */
+let activeWriter = consoleWriter;
+/**
+ * Installs a writer as the active output destination.
+ *
+ * @param writer - The writer to install.
+ * @returns The previously installed writer, so callers can restore it.
+ */
+export function chiliWriter_set(writer) {
+    const previous = activeWriter;
+    activeWriter = writer;
+    return previous;
+}
+/**
+ * Writes to the output channel with `console.log` semantics.
+ *
+ * @param args - The values to format, exactly as passed to `console.log`.
+ */
+export function chiliLog(...args) {
+    activeWriter.log(...args);
+}
+/**
+ * Writes to the error channel with `console.error` semantics.
+ *
+ * @param args - The values to format, exactly as passed to `console.error`.
+ */
+export function chiliErrLog(...args) {
+    activeWriter.errLog(...args);
+}
+/**
+ * Writes raw text or bytes to the output channel without adding a newline —
+ * the replacement for direct `process.stdout.write` calls.
+ *
+ * @param chunk - The text or bytes to write.
+ */
+export function chiliWrite(chunk) {
+    activeWriter.write(chunk);
+}
+/**
+ * Runs `fn` with both channels captured into memory and returns the collected
+ * text, restoring the previous writer afterwards even if `fn` throws.
+ *
+ * Formatting matches `console.log`: arguments are rendered with `util.format`
+ * and each `log`/`errLog` call contributes a trailing newline, exactly as the
+ * console would have written.
+ *
+ * @param fn - The work whose output should be captured.
+ * @returns The captured output and error text.
+ */
+export async function chili_capture(fn) {
+    const outChunks = [];
+    const errChunks = [];
+    const previous = chiliWriter_set({
+        log: (...args) => { outChunks.push(`${format(...args)}\n`); },
+        errLog: (...args) => { errChunks.push(`${format(...args)}\n`); },
+        write: (chunk) => {
+            outChunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf-8"));
+        },
+    });
+    try {
+        await fn();
+    }
+    finally {
+        chiliWriter_set(previous);
+    }
+    return { out: outChunks.join(""), err: errChunks.join("") };
+}