@fnndsc/brasa 0.56.4 → 0.57.0

package/dist/chris/chrisCommands.js

@@ -1,5 +1,6 @@
 import { chrisfetchCommand, pingCommand } from '../builtins/games/chrislab.js';
-import { builtin_pipeline, builtin_plugin } from '../builtins/index.js';
+import { pluginCommand } from '../builtins/res/plugin.js';
+import { pipelineCommand } from '../builtins/res/pipeline.js';
 import { chmodCommand, getfaclCommand, setfaclCommand } from '../builtins/fs/acl.js';
 import { getfattrCommand, setfattrCommand } from '../builtins/fs/xattr.js';
 import { pacsCommand } from '../builtins/net/pacs.js';
@@ -16,7 +17,6 @@ import { contextCommand } from '../builtins/sys/context.js';
 import { physicalmodeCommand } from '../builtins/sys/physicalmode.js';
 import { idCommand, whereamiCommand, whoamiCommand } from '../builtins/sys/whoami.js';
 import { procCommand } from '../builtins/proc.js';
-import { envelopeHandler_wrap } from '../core/sink.js';
 import { fileCommand, md5sumCommand, sha256sumCommand, stringsCommand, xxdCommand } from '../builtins/games/bytes.js';
 import { duCommand } from '../builtins/fs/du.js';
 import { editCommand } from '../builtins/fs/edit.js';
@@ -27,7 +27,6 @@ import { recordCommand } from '../builtins/res/record.js';
 import { gatherCommand } from '../builtins/res/gather.js';
 import { userCommand } from '../builtins/res/user.js';
 import { motdCommand } from '../builtins/sys/motd.js';
-import { chrisHelp } from './help.js';
 import { whatifCommand } from './commandFallback.js';
 import { berthCommand } from '../builtins/berth/berth.js';
 import { downloadCommand } from '../builtins/fs/download.js';
@@ -41,29 +40,6 @@ import { workflowCommand } from '../builtins/res/workflow.js';
 import { dirsCommand, filesCommand, linksCommand } from '../builtins/res/files.js';
 import { parametersofpluginCommand } from '../builtins/parametersofplugin.js';
 import { storeCommand } from '../builtins/store.js';
-const envelope = {
-    plugin: builtin_plugin,
-    plugins: builtin_plugin,
-    pipeline: builtin_pipeline,
-    pipelines: builtin_pipeline,
-};
-const plain = {
-    pipeline: envelopeHandler_wrap(builtin_pipeline),
-    pipelines: envelopeHandler_wrap(builtin_pipeline),
-    plugin: envelopeHandler_wrap(builtin_plugin),
-    plugins: envelopeHandler_wrap(builtin_plugin),
-};
-/** The ChRIS backend commands: their handlers. Their help is registered from `builtins/help.ts`, which holds it. */
-/**
- * What the ChRIS commands hold of the session: a read holds nothing and
- * runs beside anything. A command not named holds the whole session; a
- * declared command says in its declaration (`gather` holds the cohort).
- */
-const holds = {
-    ...Object.fromEntries([
-        'pipelines', 'plugins',
-    ].map((name) => [name, []])),
-};
 /** The ChRIS commands declared in one record each: grammar, kinds, handler, holds and help together. */
 const declarations = [
     downloadCommand, berthCommand,
@@ -80,12 +56,11 @@ const declarations = [
     xxdCommand, stringsCommand, sha256sumCommand, md5sumCommand, motdCommand, recordCommand,
     // Files.
     editCommand, configCommand, uploadCommand, fileCommand,
+    // Resources.
+    pluginCommand, pipelineCommand,
 ];
+/** The ChRIS backend's commands, every one declared in one record. */
 export const chrisCommands = {
-    envelope,
-    plain,
-    help: chrisHelp,
-    holds,
     declarations,
 };
 //# sourceMappingURL=chrisCommands.js.map

package/dist/chris/chrisCommands.js.map

@@ -1 +1 @@
-{"version":3,"file":"chrisCommands.js","sourceRoot":"","sources":["../../src/chris/chrisCommands.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"chrisCommands.js","sourceRoot":"","sources":["../../src/chris/chrisCommands.ts"],"names":[],"mappings":"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"}

package/dist/chris/commandFallback.d.ts

@@ -1,11 +1,37 @@
 import type { CommandEnvelope } from '@fnndsc/menu';
 import type { BackendFallback } from '../core/backend.js';
 import type { ExpressionDeclaration } from '../core/commandDeclaration.js';
+import { type PipelineLine } from './binDeclarations.js';
+/** The built-in names the ChRIS session answers, for `help variables`. */
+export declare const CHRIS_BUILTIN_LINES: ReadonlyArray<string>;
+/**
+ * Answers a pipeline line already read: the look it asks for, or its runs.
+ *   --diagram (with --withargs, or --signalflow) → the diagram
+ *   --signalflow             → SignalFlow YAML
+ *   --help / -h              → the pipeline's page
+ *   --nodes / --parameters   → pipeline info
+ *   --manifest               → pipeline manifest
+ *   --source / --readme      → pipeline source
+ *   otherwise                → a run
+ *
+ * @param name - The pipeline's `/bin` name.
+ * @param line - The line, read against its declaration.
+ * @param dry - Resolve a run and print it, creating and running nothing.
+ * @returns The answer's envelope.
+ *
+ * @example
+ * ```ts
+ * await pipelineParsed_run('PHI_detection_id12', line);
+ * ```
+ */
+export declare function pipelineParsed_run(name: string, line: PipelineLine, dry?: boolean): Promise<CommandEnvelope>;
 /**
  * `whatif <plugin or Pipeline line>`: resolves the line as a run would, to
  * the version, the operands, the stage, the node and the parameters, prints
  * that, and stops before anything is created or run. A prefix, as `time`
- * and `env` are, since every flag after a `/bin` name is the plugin's.
+ * and `env` are, since every flag after a `/bin` name is the plugin's: the
+ * line after it is parsed against that plugin's or pipeline's declaration,
+ * and refused as the real line would be.
  *
  * @param args - The line: the `/bin` name and its words.
  * @returns An ok envelope when the real line would be accepted; an error after the refusal the real line would give.
@@ -13,8 +39,9 @@ import type { ExpressionDeclaration } from '../core/commandDeclaration.js';
 export declare function builtin_whatif(args: string[]): Promise<CommandEnvelope>;
 /**
  * `whatif <plugin or Pipeline line>`: the declaration. Its words are a whole
- * line of another command, whose flags are that command's, so it parses
- * them itself (an expression grammar), as `time` and `env` would.
+ * line of another command, whose grammar is that command's (the declaration
+ * CUBE's parameters make), so it hands them on as they came, as `time` and
+ * `env` would.
  *
  * @example
  * ```ts

package/dist/chris/commandFallback.js

@@ -3,19 +3,20 @@
  *
  * A plugin named with its version runs as that plugin. A word naming a
  * plugin or a pipeline in `/bin` runs it (a captured line runs only a
- * pipeline: a plugin's run prints live). Anything else goes to chili, when
- * chili has the command, with a notice ahead of its output.
+ * pipeline: a plugin's run prints live). Its line is parsed first against
+ * the declaration made from CUBE's parameters (`binDeclarations.ts`), and a
+ * bad line is refused before anything runs. Anything else goes to chili,
+ * when chili has the command, with a notice ahead of its output.
  *
  * @module
  */
 import chalk from 'chalk';
-import { CHRIS_BUILTIN_LINES } from './help.js';
 import { variablesPage_render } from '../builtins/variablesPage.js';
 import { envelope_deliver, sink_get } from '../core/sink.js';
 import { exitCode_read, exitCode_set, handler_runDirect } from '../core/handlerRun.js';
 import { runs_awaitSettled, settlement_render } from '../builtins/res/runWait.js';
 import { binExecutableMatches_get, binPluginHighest_find } from './binExecutables.js';
-import { builtin_pipeline } from '../builtins/res/pipeline.js';
+import { pipelineDiagramCommand_handle, pipelineInfo_handle, pipelineManifestCommand_handle, pipelineRun_execute, pipelineSource_handle, } from '../builtins/res/pipeline.js';
 import { builtin_executePlugin } from '../builtins/pluginExecute.js';
 import { pluginExecutable_handle } from '../builtins/executable.js';
 import { pipelineExecutableHelp_render, pluginExecutableHelp_render } from '../builtins/help.js';
@@ -28,6 +29,14 @@ import { newFeed_cacheAdd } from '../builtins/feedCreation.js';
 import { OperandRefusal, operands_read, stage_lines, stage_make, stageMade_lines, stageWriter_default, stageWriter_none } from '../builtins/operands.js';
 import { echoNode_render } from '../builtins/runEcho.js';
 import { operandRuns_split } from '../builtins/operandRuns.js';
+import { shellWords_values } from '../lib/parser.js';
+import { binDeclaration_get, binEntry_resolve, pipelineDeclaration_get, pipelineWords_parse, pluginDeclaration_get, } from './binDeclarations.js';
+/** The built-in names the ChRIS session answers, for `help variables`. */
+export const CHRIS_BUILTIN_LINES = [
+    '  ${gather}        every gathered member, as operands (where it was gathered FROM); read live',
+    '  ${gather.series.folderPath}  the same members, where they LANDED in CUBE',
+    '  ${gather.name}  ${gather.feed.id}  any field of the cohort, as `gather` answers it',
+];
 /**
  * The node a pipeline run starts from, read from its operand (#1303): a
  * directory inside a feed is that node; outside one, or a set of files
@@ -35,14 +44,14 @@ import { operandRuns_split } from '../builtins/operandRuns.js';
  * name (or the subjects') as its title, and the run goes on from that root.
  *
  * @param name - The pipeline's `/bin` name, for the refusal lines.
- * @param args - The words after it.
+ * @param line - The line, read.
  * @param dry - Say where the run would start, staging and rooting nothing (`whatif`).
- * @returns The words to run with (`--previous` set) and whether a feed was rooted, or null after a refusal was said.
+ * @returns Where the run starts, or null after a refusal was said.
  */
-async function pipelineOperand_place(name, args, dry = false) {
+async function pipelineOperand_place(name, line, dry = false) {
     let operands;
     try {
-        operands = await operands_read(args);
+        operands = await operands_read(line.operands);
     }
     catch (error) {
         if (!(error instanceof OperandRefusal))
@@ -54,14 +63,14 @@ async function pipelineOperand_place(name, args, dry = false) {
         // No operand: the working directory is the input, as it is for a plugin run from /bin. Inside a feed node the
         // run goes on from that node (`pipeline run` reads it); outside one, pl-dircopy roots a new feed on it first,
         // as the directory operand would (#1364).
-        if (operands.rest.some((word) => word.split('=')[0] === '--previous'))
-            return { words: args, rooted: false };
+        if (line.previous !== undefined)
+            return { previous: line.previous, dryNewFeed: false, rooted: false };
         const cwd = await path_resolve('.');
         if (path_isInFeed(cwd))
-            return { words: args, rooted: false };
+            return { dryNewFeed: false, rooted: false };
         operands = { ...operands, directory: cwd, typed: [cwd] };
     }
-    if (operands.rest.some((word) => word.split('=')[0] === '--previous')) {
+    if (line.previous !== undefined) {
         sink_get().err_write(chalk.red(`${name}: the operand and --previous say the input twice\n`));
         return null;
     }
@@ -71,7 +80,7 @@ async function pipelineOperand_place(name, args, dry = false) {
             sink_get().err_write(chalk.red(`${name}: ${operands.typed[0]} is in a feed but not at a node (…/feeds/feed_N/pl-x_ID)\n`));
             return null;
         }
-        return { words: ['--previous', String(here), ...operands.rest], rooted: false };
+        return { previous: here, dryNewFeed: false, rooted: false };
     }
     let stage = null;
     let root = operands.directory ?? '';
@@ -88,14 +97,14 @@ async function pipelineOperand_place(name, args, dry = false) {
         }
         if (dry)
             sink_get().data_write(chalk.cyan(`would stage under ${stage.path}\n`));
-        for (const line of stage_lines(stage))
-            sink_get().data_write(chalk.cyan(`${line}\n`));
+        for (const stageLine of stage_lines(stage))
+            sink_get().data_write(chalk.cyan(`${stageLine}\n`));
         root = stage.path;
         title = stage.subjects.map((subject) => subject.name).join(', ');
     }
     if (dry) {
         sink_get().data_write(chalk.gray(`${echoNode_render(root, title)}\n`));
-        return { words: ['--whatif-new-feed', ...operands.rest], rooted: false };
+        return { dryNewFeed: true, rooted: false };
     }
     const feed = await feed_create([root], { title });
     if (feed === null) {
@@ -106,27 +115,39 @@ async function pipelineOperand_place(name, args, dry = false) {
     newFeed_cacheAdd({ feedID: feed.id, title, ownerUsername: feed.owner_username, rootInstanceID });
     sink_get().data_write(chalk.green(`Feed created: ${feed.id}\n`));
     if (stage !== null) {
-        for (const line of stageMade_lines(stage, `/home/${feed.owner_username}/feeds/feed_${feed.id}/pl-dircopy_${rootInstanceID}/data`))
-            sink_get().data_write(chalk.cyan(`${line}\n`));
+        for (const made of stageMade_lines(stage, `/home/${feed.owner_username}/feeds/feed_${feed.id}/pl-dircopy_${rootInstanceID}/data`))
+            sink_get().data_write(chalk.cyan(`${made}\n`));
     }
-    return { words: ['--previous', String(rootInstanceID), ...operands.rest], rooted: true };
+    return { previous: rootInstanceID, dryNewFeed: false, rooted: true };
 }
 /**
  * Runs a pipeline once from the node its operand names.
  *
  * @param name - The pipeline's `/bin` name.
- * @param args - The words after it: at most one directory operand.
+ * @param line - The line, read: at most one directory operand.
  * @param dry - Resolve the run and print it, creating and running nothing.
  * @returns The run's envelope; an error envelope after a refusal was said.
  */
-async function pipelineRun_start(name, args, dry = false) {
+async function pipelineRun_start(name, line, dry = false) {
     // The operand says where the run starts (#1303); refused, nothing runs.
-    const placed = await pipelineOperand_place(name, args, dry);
-    const words = placed === null || !dry || placed.words.includes('--whatif-new-feed') ? (placed?.words ?? []) : [...placed.words, '--whatif'];
-    const envelope = placed === null ? { status: 'error', rendered: '' } : await builtin_pipeline(['run', name, ...words]);
+    const placed = await pipelineOperand_place(name, line, dry);
+    if (placed === null)
+        return { status: 'error', rendered: '' };
+    const request = {
+        pipeline: name,
+        ...(line.compute !== undefined ? { compute: line.compute } : {}),
+        ...(placed.previous !== undefined ? { previous: placed.previous } : {}),
+        ...(line.paramFile !== undefined ? { paramFile: line.paramFile } : {}),
+        bindings: line.bindings.map((binding) => ({ node: binding.node, field: binding.field, value: binding.value })),
+        detach: line.detach,
+        verbose: line.verbose,
+        dry,
+        dryNewFeed: placed.dryNewFeed,
+    };
+    const envelope = await pipelineRun_execute(request);
     // The model says when the run rooted a feed first: the fallback rooted it, so the fallback says so (the kind is
     // `pipeline.scheduled`, PIPELINE_SCHEDULED_KIND; named here so a test's stub of the pipeline module need not carry it).
-    if (placed?.rooted === true && envelope.model?.kind === 'pipeline.scheduled')
+    if (placed.rooted && envelope.model?.kind === 'pipeline.scheduled')
         envelope.model.data.newFeed = true;
     return envelope;
 }
@@ -135,14 +156,14 @@ async function pipelineRun_start(name, args, dry = false) {
  * names several, each run headed by its operand.
  *
  * @param name - The pipeline's `/bin` name.
- * @param args - The words after it.
+ * @param line - The line, read.
  * @param dry - Resolve every run and print it, creating and running nothing.
  * @returns The last run's envelope, an error when any run failed or the line was refused.
  */
-async function pipelineRuns_start(name, args, dry = false) {
+async function pipelineRuns_start(name, line, dry = false) {
     let runs;
     try {
-        runs = await operandRuns_split(args);
+        runs = await operandRuns_split(line.operands);
     }
     catch (error) {
         if (!(error instanceof OperandRefusal))
@@ -151,21 +172,20 @@ async function pipelineRuns_start(name, args, dry = false) {
         return { status: 'error', rendered: '' };
     }
     if (runs.length === 1)
-        return pipelineRun_start(name, args, dry);
+        return pipelineRun_start(name, line, dry);
     // Every run is dispatched before any is waited for; then one wait holds the line for them all.
-    const detach = args.includes('--detach');
     const instanceIDs = [];
     let last = { status: 'ok', rendered: '' };
     let failed = false;
     for (const words of runs) {
         sink_get().data_write(chalk.gray(`${name} ${words[0]}:\n`));
-        last = await pipelineRun_start(name, detach ? words : [...words, '--detach'], dry);
+        last = await pipelineRun_start(name, { ...line, operands: words, detach: true }, dry);
         failed ||= last.status === 'error';
         if (last.model?.kind === 'pipeline.scheduled') {
             instanceIDs.push(...last.model.data.instances.map((node) => node.instanceId));
         }
     }
-    if (!detach && instanceIDs.length > 0) {
+    if (!line.detach && instanceIDs.length > 0) {
         const settlement = await runs_awaitSettled(instanceIDs, name);
         sink_get().data_write(`${settlement_render(settlement, name)}\n`);
         if (settlement.outcome === 'settled' && settlement.failed > 0)
@@ -174,51 +194,80 @@ async function pipelineRuns_start(name, args, dry = false) {
     return failed ? { ...last, status: 'error' } : last;
 }
 /**
- * Handles a pipeline name invoked directly as an executable from /bin.
- * Routes flag combinations to the appropriate pipeline subcommand:
- *   --diagram             → pipeline diagram (preserving renderer flags)
- *   --signalflow          → pipeline diagram --signalflow
- *   --help / -h           → contextual pipeline-executable help
- *   --nodes / --parameters → pipeline info
- *   --manifest             → pipeline manifest
- *   --source / --readme    → pipeline source
- *   (bare or --compute)    → pipeline run
+ * Answers a pipeline line already read: the look it asks for, or its runs.
+ *   --diagram (with --withargs, or --signalflow) → the diagram
+ *   --signalflow             → SignalFlow YAML
+ *   --help / -h              → the pipeline's page
+ *   --nodes / --parameters   → pipeline info
+ *   --manifest               → pipeline manifest
+ *   --source / --readme      → pipeline source
+ *   otherwise                → a run
  *
- * @param name - The pipeline name as typed.
- * @param args - Arguments following the pipeline name.
+ * @param name - The pipeline's `/bin` name.
+ * @param line - The line, read against its declaration.
  * @param dry - Resolve a run and print it, creating and running nothing.
- * @returns The pipeline builtin's envelope, preserving diagram models and text.
+ * @returns The answer's envelope.
+ *
+ * @example
+ * ```ts
+ * await pipelineParsed_run('PHI_detection_id12', line);
+ * ```
  */
-async function pipelineExecutable_handle(name, args, dry = false) {
+export async function pipelineParsed_run(name, line, dry = false) {
     const exitCodeBefore = exitCode_read();
     let envelope;
-    if (args.includes('--help') || args.includes('-h')) {
-        envelope = { status: 'ok', rendered: pipelineExecutableHelp_render(name) };
-    }
-    else if (args.includes('--diagram')) {
-        const diagramArgs = args.filter((argument) => argument !== '--diagram');
-        envelope = await builtin_pipeline(['diagram', name, ...diagramArgs]);
+    switch (line.look) {
+        case 'help':
+            envelope = { status: 'ok', rendered: pipelineExecutableHelp_render(name, (await pipelineDeclaration_get(name)) ?? undefined) };
+            break;
+        case 'diagram':
+            envelope = await pipelineDiagramCommand_handle(name, line.withArguments, line.signalflow);
+            break;
+        case 'signalflow':
+            envelope = await pipelineDiagramCommand_handle(name, false, true);
+            break;
+        case 'manifest':
+            envelope = await pipelineManifestCommand_handle(name);
+            break;
+        case 'nodes':
+            envelope = await pipelineInfo_handle(name);
+            break;
+        case 'source':
+            envelope = await pipelineSource_handle(name);
+            break;
+        case null:
+            envelope = await pipelineRuns_start(name, line, dry);
+            break;
     }
-    else if (args.includes('--signalflow')) {
-        envelope = await builtin_pipeline(['diagram', name, '--signalflow']);
-    }
-    else if (args.includes('--manifest')) {
-        envelope = await builtin_pipeline(['manifest', name]);
-    }
-    else if (args.includes('--nodes') || args.includes('--parameters')) {
-        envelope = await builtin_pipeline(['info', name]);
-    }
-    else if (args.includes('--source') || args.includes('--readme')) {
-        envelope = await builtin_pipeline(['source', name]);
-    }
-    else {
-        envelope = await pipelineRuns_start(name, args, dry);
-    }
-    const result = envelope ?? { status: 'ok', rendered: '' };
     const exitCodeAfter = exitCode_read();
     if (exitCodeAfter !== 0 && exitCodeAfter !== exitCodeBefore)
-        result.status = 'error';
-    return result;
+        envelope.status = 'error';
+    return envelope;
+}
+/**
+ * Handles a pipeline name invoked directly as an executable from /bin: its
+ * line parsed against the declaration made from its manifest, a bad line
+ * refused before anything runs.
+ *
+ * @param name - The pipeline's `/bin` name.
+ * @param args - Arguments following the pipeline name.
+ * @param dry - Resolve a run and print it, creating and running nothing.
+ * @returns The answer's envelope; an error after a refusal.
+ */
+async function pipelineExecutable_handle(name, args, dry = false) {
+    const declaration = await pipelineDeclaration_get(name);
+    if (declaration === null) {
+        sink_get().err_write(chalk.red(`${name}: could not read the pipeline's manifest from CUBE, so the line cannot be read\n`));
+        exitCode_set(1);
+        return { status: 'error', rendered: '' };
+    }
+    const parsed = await pipelineWords_parse(declaration, args);
+    if (!parsed.ok) {
+        sink_get().err_write(`${chalk.red(parsed.refusal)}\n`);
+        exitCode_set(1);
+        return { status: 'error', rendered: '' };
+    }
+    return pipelineParsed_run(name, parsed.line, dry);
 }
 /**
  * Hands a word to chili when chili has it, with the hand-off notice on the
@@ -240,7 +289,9 @@ async function chili_delegate(command, args) {
  * `whatif <plugin or Pipeline line>`: resolves the line as a run would, to
  * the version, the operands, the stage, the node and the parameters, prints
  * that, and stops before anything is created or run. A prefix, as `time`
- * and `env` are, since every flag after a `/bin` name is the plugin's.
+ * and `env` are, since every flag after a `/bin` name is the plugin's: the
+ * line after it is parsed against that plugin's or pipeline's declaration,
+ * and refused as the real line would be.
  *
  * @param args - The line: the `/bin` name and its words.
  * @returns An ok envelope when the real line would be accepted; an error after the refusal the real line would give.
@@ -251,49 +302,51 @@ export async function builtin_whatif(args) {
         sink_get().err_write(chalk.red('whatif: usage: whatif <plugin or Pipeline> [operands] [options]\n'));
         return { status: 'error', rendered: '' };
     }
+    // The words after the /bin name keep the shell words the line carried, so its operands glob by kind.
+    const carried = args.words;
+    const lineWords = carried !== undefined && carried.length === args.length ? shellWords_values(carried.slice(1)) : words;
     const binMatches = await binExecutableMatches_get(command);
     if (binMatches.plugin)
-        return builtin_executePlugin(command, words, undefined, true);
+        return builtin_executePlugin(command, lineWords, undefined, true);
     if (binMatches.pipeline) {
-        const envelope = await pipelineExecutable_handle(binMatches.pipeline.name, words, true);
+        const envelope = await pipelineExecutable_handle(binMatches.pipeline.name, lineWords, true);
         envelope_deliver(envelope);
         return { ...envelope, rendered: '' };
     }
     const highest = await binPluginHighest_find(command);
     if (highest !== null) {
         sink_get().data_write(chalk.gray(`running ${highest.executable} (highest of ${highest.versions.join(', ')})\n`));
-        return builtin_executePlugin(highest.executable, words, undefined, true);
+        return builtin_executePlugin(highest.executable, lineWords, undefined, true);
     }
     sink_get().err_write(chalk.red(`whatif: ${command}: not a plugin or a Pipeline in /bin\n`));
     return { status: 'error', rendered: '' };
 }
 /**
  * Completes a word of a `whatif` line as the line after it completes: its
- * first word a plugin `/bin` lists, an option the plugin or pipeline takes,
- * and an operand a path when the `/bin` entry takes paths.
+ * first word a plugin or pipeline `/bin` lists, then the rest from that
+ * entry's declaration (its options, and its input paths).
  *
  * @param words - The words after `whatif`, before the one completed.
  * @param word - The word typed so far.
  * @returns The candidates.
  */
 async function whatifWord_complete(words, word) {
-    const { chrisCompletion } = await import('./completion.js');
     const first = words[0];
     if (first === undefined) {
-        const names = (await chrisCompletion.commandWords?.()) ?? [];
-        return names.filter((name) => name.startsWith(word));
+        const { binNames_list } = await import('./completion.js');
+        return (await binNames_list()).filter((name) => name.startsWith(word));
     }
-    if (word.startsWith('-'))
-        return (await chrisCompletion.options?.([...words], word)) ?? [];
-    if (words[words.length - 1] === 'as' || !(await chrisCompletion.pathArguments?.(first)))
+    const declaration = await binDeclaration_get(first);
+    if (declaration === null)
         return [];
-    const { cfsPaths_complete } = await import('../lib/completer/cfsPaths.js');
-    return cfsPaths_complete(word);
+    const { declaredWord_complete } = await import('../lib/completer/declared.js');
+    return declaredWord_complete(declaration, words.slice(1), word);
 }
 /**
  * `whatif <plugin or Pipeline line>`: the declaration. Its words are a whole
- * line of another command, whose flags are that command's, so it parses
- * them itself (an expression grammar), as `time` and `env` would.
+ * line of another command, whose grammar is that command's (the declaration
+ * CUBE's parameters make), so it hands them on as they came, as `time` and
+ * `env` would.
  *
  * @example
  * ```ts
@@ -306,7 +359,7 @@ export const whatifCommand = {
     help: {
         usage: 'whatif <plugin or Pipeline> [operands] [options]',
         summary: 'Print what a plugin or Pipeline line would do, and run nothing',
-        description: 'Resolve the line as a run would and print it: the version picked, the operands as read, the stage, the node it would attach to or the feed it would root, and every parameter with defaults marked. Nothing is staged, no feed is made, no job starts. When the real line would refuse, whatif prints the same refusal and exits non-zero. A prefix, as time and env are: every flag after a /bin name belongs to the plugin, and several directory operands print one resolution per run.',
+        description: 'Resolve the line as a run would and print it: the version picked, the operands as read, the stage, the node it would attach to or the feed it would root, and every parameter with defaults marked. Nothing is staged, no feed is made, no job starts. When the real line would refuse, whatif prints the same refusal and exits non-zero: the line is parsed against the plugin\'s or Pipeline\'s own declaration, made from CUBE\'s parameters. A prefix, as time and env are: every flag after a /bin name belongs to the plugin, and several directory operands print one resolution per run.',
         category: 'Resources',
         examples: ['whatif pl-freesurfer ~/uploads/t1.nii as sub-01', 'whatif pl-dcm2niix ~/feeds/feed_12/pl-dircopy_40/data'],
     },
@@ -314,9 +367,27 @@ export const whatifCommand = {
     handler: builtin_whatif,
     complete: whatifWord_complete,
 };
+/**
+ * The page of a `/bin` entry, its usage and every option from the
+ * declaration CUBE's parameters make.
+ *
+ * @param entry - The entry.
+ * @returns The page.
+ */
+async function binEntryHelp_render(entry) {
+    if (entry.kind === 'plugin')
+        return pluginExecutableHelp_render(entry.executable, (await pluginDeclaration_get(entry.executable)) ?? undefined);
+    return pipelineExecutableHelp_render(entry.name, (await pipelineDeclaration_get(entry.name)) ?? undefined);
+}
 /** The ChRIS backend's fallback. */
 export const chrisFallback = {
-    claim: pluginExecutable_handle,
+    claim: async (command, args) => {
+        // A plugin version's page is its declaration's, read from CUBE.
+        if (/-v[^/]+$/.test(command) && (args.includes('--help') || args.includes('-h'))) {
+            return { status: 'ok', rendered: pluginExecutableHelp_render(command, (await pluginDeclaration_get(command)) ?? undefined) };
+        }
+        return pluginExecutable_handle(command, args);
+    },
     unknown: async (command, args, captured) => {
         const binMatches = await binExecutableMatches_get(command);
         // A bare /bin plugin name runs the plugin, and a run is a CUBE job: typed
@@ -349,13 +420,11 @@ export const chrisFallback = {
             return variablesPage_render(CHRIS_BUILTIN_LINES);
         // A plugin version (`pl-dircopy-v2.1.2`) is its own executable.
         if (/-v[^/]+$/.test(command))
-            return pluginExecutableHelp_render(command);
-        const binMatches = await binExecutableMatches_get(command);
-        if (binMatches.pipeline)
-            return pipelineExecutableHelp_render(binMatches.pipeline.name);
-        // A bare plugin name's help is its highest version's.
-        const highest = await binPluginHighest_find(command);
-        return highest === null ? null : pluginExecutableHelp_render(highest.executable);
+            return pluginExecutableHelp_render(command, (await pluginDeclaration_get(command)) ?? undefined);
+        // A pipeline, or a bare plugin name (its highest version's page).
+        const entry = await binEntry_resolve(command);
+        return entry === null ? null : binEntryHelp_render(entry);
     },
+    declaration: binDeclaration_get,
 };
 //# sourceMappingURL=commandFallback.js.map