@loomcli/core 0.6.0 → 0.8.0

package/dist/plugin.js

@@ -1,22 +1,25 @@
 import { checkEnvBinding, claimVariables } from './bindings.js';
+import { captureDeclaration, elidedRead, unreadableArgument, unreadableFault } from './capture.js';
 import { notACommand } from './command-rules.js';
 import { attach, commandCode, commandNode } from './command.js';
 import { elided, quoteString, spelled } from './diagnostic-text.js';
 import { DeclarationError, InternalError, quoted, reasonOf } from './errors.js';
 import { appliesTo, buildExtensions, isDescriptor, registerDescriptor } from './extension.js';
-import { checkDeprecated, checkDescription, checkHidden, factFault, partFinding, pluginOptionSite, slotSite, } from './facts.js';
-import { boundOptions, pluginSites } from './globals.js';
+import { checkDeprecated, checkDescription, checkHidden, partFinding, pluginOptionSite, slotSite, } from './facts.js';
+import { boundOptions, checkNoPresenceRule, pluginSites } from './globals.js';
 import { checkIdentity } from './identity.js';
 import { coreViews } from './lanes.js';
-import { booleanValue, compileOptions } from './options.js';
-import { isPlainObject } from './plain.js';
-import { foreignValue, middlewareActivation, notAFunction, notAList, notAnObject, pluginInstalledTwice, pluginOptionRule, signalClaimedTwice, slotTaken, sourceBinding, sourceBoundOwnOption, unknownSignal, } from './plugin-rules.js';
+import { compileOptions } from './options.js';
+import { copyOwnKeys, decidePlain, declaring, isPlainObject, shallowList, shallowRecord, } from './plain.js';
+import { foreignValue, middlewareActivation, notAFunction, notAList, notAnObject, pluginInstalledTwice, signalClaimedTwice, slotTaken, sourceBinding, sourceBoundOwnOption, unknownSignal, } from './plugin-rules.js';
 import { pluginLoaderFailed } from './rules.js';
 import { isProcessSignal } from './signals.js';
 import { buildTheme } from './theme.js';
 import { readTranslations } from './translators.js';
-import { captureConfig, checkDeclarations } from './validation.js';
+import { captureConfig, checkDeclarations, defaultDepthFault } from './validation.js';
 import { buildViews, viewIdentities } from './view.js';
+/** The slots of a definition that hold a list, each copied with its entries as they were built. */
+const definitionLists = ['extensions', 'signals', 'commands', 'views', 'translators'];
 /** Authored values register here, so the public type publishes no state to reach or replace. */
 const nodes = new WeakMap();
 /**
@@ -34,17 +37,47 @@ class PluginDeclaration {
  * One plugin: an identity and the contributions it carries. Creating and installing the value runs
  * none of its code: `onCommandAttach` runs at graph build, `onFailure` runs when `run()` renders a
  * failure, and the middleware runs inside an invocation, so an installed plugin an invocation never
- * reaches costs that invocation its hooks alone. Every rule
- * that one definition carries on its own throws here, before the value exists.
+ * reaches costs that invocation its hooks alone. The definition is read once, after the identity,
+ * and every rule that one definition carries on its own throws here, before the value exists.
  */
 function plugin(identity, definition) {
-    const captured = {
-        ...definition,
-        ...(definition?.theme === undefined
-            ? {}
-            : { theme: isPlainObject(definition.theme) ? { ...definition.theme } : definition.theme }),
-    };
-    return new PluginDeclaration(readPlugin(identity, isPlainObject(definition) ? captured : definition));
+    return new PluginDeclaration(declaring(() => readPlugin(identity, definition)));
+}
+/**
+ * The one copy of a definition that `plugin()` reads: the definition, its theme mapping, options
+ * record, middleware with its activation list, and source, and each list it holds. An entry of a
+ * list is what its factory built and is not copied, and each option's config is captured where its
+ * own rules read it, so a fault about it names the option. A read that throws is the unreadable
+ * fault of the definition, and a definition that is not a plain object is the not-an-object fault.
+ */
+function captureDefinition(identity, definition) {
+    return captureDeclaration(definition, (copy, read) => {
+        read.nested(copy, 'theme', shallowRecord);
+        read.nested(copy, 'options', shallowRecord);
+        read.nested(copy, 'middleware', copyMiddleware);
+        read.nested(copy, 'source', shallowRecord);
+        for (const list of definitionLists) {
+            read.nested(copy, list, shallowList);
+        }
+    }, {
+        notAnObject: () => new DeclarationError(notAnObject, {
+            correction: 'Supply { options, middleware, extensions, views }.',
+            findings: [{ arguments: [identity, definition], call: 'plugin', mark: '1' }],
+            sentence: `${pluginSentence(identity)} declares a definition that is not an object.`,
+        }),
+        unreadable: unreadableArgument({ call: 'plugin', named: identity, subject: pluginSentence(identity) }, 'definition'),
+    });
+}
+/** A middleware object's copy, its activation list copied too, or any other value as declared. */
+function copyMiddleware(middleware) {
+    if (!decidePlain(middleware)) {
+        return middleware;
+    }
+    const copy = copyOwnKeys(middleware);
+    if (Object.hasOwn(copy, 'activate')) {
+        copy.activate = shallowList(copy.activate);
+    }
+    return copy;
 }
 /** How every plugin diagnostic names one plugin at the start of a sentence. */
 function pluginSentence(identity) {
@@ -71,17 +104,6 @@ function entryCode(value) {
     const node = nodeOf(value);
     return node ? spelled(`plugin(${quoteString(node.identity)}, ${elided})`) : value;
 }
-/** The declarations one plugin value carries, which a JavaScript author reaches as any value. */
-function definitionOf(identity, definition) {
-    if (!isPlainObject(definition)) {
-        throw new DeclarationError(notAnObject, {
-            correction: 'Supply { options, middleware, extensions, views }.',
-            findings: [{ arguments: [identity, definition], call: 'plugin', mark: '1' }],
-            sentence: `${pluginSentence(identity)} declares a definition that is not an object.`,
-        });
-    }
-    return definition;
-}
 /** How a second claim on one slot reads: its clause, the note on the owner's entry, and the fix. */
 const slotWords = {
     signals: {
@@ -116,9 +138,9 @@ function slotFault(site, slot, claim) {
 /**
  * The installed list in composition order, with every rule that reads two plugins together: an
  * identity installed twice, a second claim on the theme slot, the signals slot, or the
- * configuration source, and two distinct descriptors under one identity. The slot is read
- * defensively, because a JavaScript author reaches it with any value. Each plugin's own rules
- * already ran at its `plugin()` call.
+ * configuration source, and two distinct descriptors under one identity. The slot is the copy the
+ * Application's constructor took, which a JavaScript author fills with any value. Each plugin's own
+ * rules already ran at its `plugin()` call.
  */
 function installPlugins(application, plugins) {
     const printed = Array.isArray(plugins) ? Array.from(plugins, entryCode) : plugins;
@@ -186,29 +208,38 @@ function installPlugins(application, plugins) {
     }
     return { descriptors, plugins: installed };
 }
-/** The keys a plugin option may not declare, in the order its diagnostic names them. */
-const forbidden = ['validate', 'validateOmitted', 'required'];
-/** The rules a plugin option answers before every rule an ordinary declaration carries. */
-function checkPluginOption(site, config) {
-    const sentence = site.subject;
-    if (!isPlainObject(config)) {
-        throw new DeclarationError(notAnObject, {
+/**
+ * The rules a plugin's option answers before every rule an ordinary declaration carries, read from
+ * the one copy of its config that `captureConfig` takes, which it answers with for every later read.
+ * `siteOf` places the option with the value its entry prints as: the config as declared for a value
+ * that is not one, elided for a config whose read threw, and the copy for every later rule.
+ */
+function checkPluginOption(siteOf, declared) {
+    const sentence = siteOf(declared).subject;
+    const config = captureConfig(declared, {
+        notAnObject: () => new DeclarationError(notAnObject, {
             correction: 'Supply { type, ... }.',
-            findings: [partFinding(site, [])],
+            findings: [partFinding(siteOf(declared), [])],
             sentence: `${sentence} is not an option declaration.`,
-        });
-    }
-    const rejected = forbidden.find((key) => key in config);
-    if (rejected !== undefined) {
-        throw factFault(pluginOptionRule, site, {
-            correction: 'Remove it; a plugin option carries no validator or presence rule, and the middleware interprets the value.',
-            fact: rejected,
-            sentence: `${sentence} declares ${rejected}.`,
-        });
-    }
+        }),
+        // The default's walk stopped at the limit, so the finding prints it elided.
+        tooDeep: () => {
+            const { keys, shown } = elidedRead('default');
+            return defaultDepthFault(sentence, [partFinding(siteOf(shown), keys)]);
+        },
+        // A part whose read threw is never read again, so the finding prints it elided.
+        unreadable: (thrown, slot) => {
+            const { keys, shown } = elidedRead(slot);
+            return unreadableFault({ declared: 'config', findings: [partFinding(siteOf(shown), keys)], subject: sentence }, thrown);
+        },
+    });
+    const site = siteOf(config);
+    // A plugin's options are global options, so they answer the global option's presence rule.
+    checkNoPresenceRule(site, config);
     checkDescription(site, config.description);
     checkHidden(site, config.hidden);
     checkDeprecated(site, config.deprecated);
+    return config;
 }
 /**
  * One plugin's option declarations, in declaration order. They join the globals table, so the rules
@@ -223,12 +254,23 @@ function readOptions(identity, declared, build) {
         });
     }
     const inputs = [];
-    for (const [name, config] of Object.entries(declared ?? {})) {
+    // A finding prints each option's captured config once it is taken, and each later one elided.
+    const shown = Object.fromEntries(Object.keys(declared ?? {}).map((name) => [name, spelled(elided)]));
+    for (const [name, entry] of Object.entries(declared ?? {})) {
         const sentence = `${pluginSentence(identity)} option ${quoted(name)}`;
-        const site = pluginOptionSite({ identity, options: declared }, name, sentence);
-        checkPluginOption(site, config);
+        // A computed key defines its own property even for `__proto__`, where assignment would not.
+        const siteOf = (value) => pluginOptionSite({ identity, options: { ...shown, [name]: value } }, name, sentence);
+        const config = checkPluginOption(siteOf, entry);
+        // Defining the key keeps its place, and holds even for a key of `__proto__`.
+        Object.defineProperty(shown, name, {
+            configurable: true,
+            enumerable: true,
+            value: config,
+            writable: true,
+        });
+        const site = siteOf(config);
         checkEnvBinding(site, config);
-        const input = { config: captureConfig(config), kind: 'option', name };
+        const input = { config, kind: 'option', name };
         // The shared rules name the plugin and the option, so a fault reads with its contributor.
         checkDeclarations([{ input, site }], sentence);
         build.records.set(input, buildExtensions({
@@ -243,11 +285,12 @@ function readOptions(identity, declared, build) {
         }));
         inputs.push(input);
     }
-    // Two options of one plugin meet in the one table the pre-scan reads, so they share its rules.
+    // Two options of one plugin meet in the globals table every Command's table holds.
+    // They therefore share its rules.
     const siteOf = pluginSites(identity, inputs);
     compileOptions(inputs, { siteOf, subject: `plugin ${quoted(identity)}` });
     claimVariables(boundOptions(inputs, (input) => ({
-        phrase: `plugin ${quoted(identity)} option "${input.name}"`,
+        phrase: `plugin ${quoted(identity)} option ${quoted(input.name)}`,
         site: siteOf(input),
     })));
     return inputs;
@@ -532,7 +575,8 @@ function readSource(identity, declaration, own) {
     }
     const carrier = own.inputs.find((input) => Object.hasOwn(own.build.records.get(input) ?? {}, bindingIdentity));
     if (carrier) {
-        const option = pluginOptionSite({ identity, options: declaration.options }, carrier.name, `${sentence} option ${quoted(carrier.name)}`);
+        // The record prints each option's captured config, which is what its rules read.
+        const option = pluginSites(identity, own.inputs)(carrier);
         throw new DeclarationError(sourceBoundOwnOption, {
             correction: "Remove the value; the source's own options resolve before it loads.",
             findings: [partFinding(option, ['extensions'])],
@@ -552,7 +596,8 @@ function defineExtensions(identity, declaration, build) {
             sentence: `${pluginSentence(identity)} declares extensions that are not an array.`,
         });
     }
-    for (const [index, descriptor] of (extensions ?? []).entries()) {
+    const list = Array.isArray(extensions) ? extensions : [];
+    for (const [index, descriptor] of list.entries()) {
         if (!isDescriptor(descriptor)) {
             throw new DeclarationError(foreignValue, {
                 correction: 'Supply the value returned by extension(identity, config).',
@@ -567,14 +612,15 @@ function defineExtensions(identity, declaration, build) {
     }
 }
 /**
- * Every rule one definition carries on its own, in the order the definition's slots are read. The
- * plugin's own extensions register before any declaration carries a value, so a duplicated package
- * copy is reported from the list that defines it. The views list is read against core's view
- * identities, and the Application reads it again against every other contributor's.
+ * Every rule one definition carries on its own, in the order the definition's slots are read, each
+ * from the one copy `captureDefinition` takes once the identity is judged. The plugin's own
+ * extensions register before any declaration carries a value, so a duplicated package copy is
+ * reported from the list that defines it. The views list is read against core's view identities,
+ * and the Application reads the same copy again against every other contributor's.
  */
 function readPlugin(named, definition) {
     checkIdentity('plugin', named);
-    const declaration = definitionOf(named, definition);
+    const declaration = captureDefinition(named, definition);
     const theme = declaration.theme === undefined ? undefined : buildTheme(declaration.theme, named);
     const build = { descriptors: new Map(), records: new Map() };
     defineExtensions(named, declaration, build);
@@ -608,34 +654,6 @@ function readPlugin(named, definition) {
 function ownedSignals(plugins) {
     return plugins.find((entry) => entry.signals.length > 0)?.signals ?? [];
 }
-/** A collected value, or the declared array default, as this run's own copy. */
-function collectedValue(collected, declared) {
-    if (collected) {
-        return [...collected];
-    }
-    return Array.isArray(declared) ? [...declared] : [];
-}
-/** One plugin option's value for one run: what a tier supplied, or the declared default. */
-function pluginValue({ config, name }, values) {
-    const declared = config.default;
-    if (config.type === 'boolean') {
-        return booleanValue(values, name, config);
-    }
-    if (config.multiple === true) {
-        return collectedValue(values.lists.get(name), declared);
-    }
-    // Build already proved that a string option without a validator declares a string default.
-    return values.strings.get(name) ?? (typeof declared === 'string' ? declared : undefined);
-}
-/**
- * One plugin's own option values for one run: what argv or an input source supplied, or the
- * declared default, filled without validation. A collected value and an array default are copied,
- * so a plugin that writes to what it received changes neither the declaration nor the next run.
- * Entries become own keys even for a name such as `__proto__`, which assignment would not.
- */
-function pluginValues(inputs, values) {
-    return Object.fromEntries(inputs.map((input) => [input.name, pluginValue(input, values)]));
-}
 /** One plugin's own spellings for one run, frozen, so no plugin writes what another reads. */
 function pluginSpellings(inputs, values) {
     // Entries become own keys even for a name such as `__proto__`, which assignment would not.
@@ -645,4 +663,4 @@ function pluginSpellings(inputs, values) {
     });
     return Object.freeze(Object.fromEntries(supplied));
 }
-export { installPlugins, loadDefault, ownedSignals, plugin, pluginSentence, pluginSpellings, pluginViews, pluginValues, };
+export { installPlugins, loadDefault, ownedSignals, plugin, pluginSentence, pluginSpellings, pluginViews, };

package/dist/sources.d.ts

@@ -5,7 +5,7 @@ import type { OptionValues } from './options.js';
 import type { BuiltPlugin } from './plugin.js';
 import type { ContextualStyle } from './style.js';
 import type { Host, Out } from './types.js';
-import type { OptionInput } from './validation.js';
+import type { OptionInput, Provenance, Validation } from './validation.js';
 /**
  * One scope the stage fills: its options in declaration order, and the values argv supplied them.
  * The stage writes each fill into `values`, so the caller hands it the run's own copy.
@@ -35,23 +35,32 @@ interface SourceStage {
     signal: AbortSignal;
     /** The contextual style an action receives, so a source escapes raw data before it warns. */
     style: ContextualStyle;
+    /**
+     * Validates the listed options alone, from the values the stage has filled so far, with what the
+     * environment tier found about them, under the context every validator of the run reads. A
+     * configuration source's own options pass through it before the source loads.
+     */
+    validate: (inputs: readonly OptionInput[], provenance: Provenance) => Promise<Validation>;
 }
 /**
  * What the stage found beside the values it filled. `labels` names where each filled option's value
- * came from, by option name, and `rejected` names the variable of each Boolean option whose value
- * is outside the grammar. Both are internal to core's failure messages. `fault` is a configuration
+ * came from, by option name, and `rejected` names the variable of each Boolean or counted option
+ * whose value is outside its grammar. Both are internal to core's failure messages. `fault` is a configuration
  * source's own fault, or the failure its resolver threw, which stops the stage and takes the place
- * of every validation problem.
+ * of every validation problem. `validated` is the pass over the source's own options ahead of its
+ * call, whose values and problems the run's one validation pass reads.
  */
-interface SourceOutcome {
+interface SourceOutcome extends Provenance {
     fault: LoomError | undefined;
-    labels: ReadonlyMap<string, string>;
-    rejected: ReadonlyMap<string, string>;
+    validated: Validation | undefined;
 }
 /**
  * The input-source stage: the environment, then the configuration source, for every option in
- * scope that argv left unfilled. When no option is left to ask, the source never loads. A source
- * fault stops the stage and fills nothing more.
+ * scope that argv left unfilled. When no option is left to ask, the source never loads. The
+ * source's own options pass their validators before it loads, and when one is rejected the source
+ * is never called and the problem reports with every other validation problem, while each option
+ * the source would have been asked to fill reports no missing value. A source fault stops the
+ * stage and fills nothing more.
  */
 declare function fillInputs(stage: SourceStage): Promise<SourceOutcome>;
 export type { SourceOutcome, SourceStage, StageScope };

package/dist/sources.js

@@ -1,8 +1,9 @@
-import { asSentence, foreignFailure, InternalError, LoomError, reasonOf } from './errors.js';
+import { asSentence, foreignFailure, InternalError, LoomError, quoted, reasonOf, } from './errors.js';
 import { isProseLine } from './facts.js';
+import { frozenValues } from './globals.js';
 import { isSupplied } from './options.js';
 import { isPlainObject } from './plain.js';
-import { loadDefault, pluginSentence, pluginValues } from './plugin.js';
+import { loadDefault, pluginSentence } from './plugin.js';
 import { foreignThrow, foreignThrowCorrection, sourceAnswers, sourceAnswersCorrection, } from './rules.js';
 /** The Boolean grammar a bound variable is read through: the whole value, case-insensitive. */
 const truths = new Map([
@@ -11,10 +12,13 @@ const truths = new Map([
     ['false', false],
     ['true', true],
 ]);
+/** The count grammar a bound variable is read through: the whole value, one or more ASCII digits. */
+const countText = /^[0-9]+$/u;
 /**
- * Reads one option's bound variable. An empty variable is unset and falls through, a string option
- * receives the raw string, and a Boolean option reads the whole value through the grammar, so the
- * value states the option's value and not a spelling.
+ * Reads one option's bound variable. An empty variable is unset and falls through, and a string
+ * option receives the raw string, never its implied value. A Boolean option reads the whole value
+ * through the grammar, so the value states the option's value and not a spelling, and a counted
+ * option reads the whole value as decimal digits.
  */
 function readVariable(input, env) {
     const variable = input.config.env;
@@ -25,6 +29,9 @@ function readVariable(input, env) {
     if (input.config.type === 'string') {
         return { kind: 'fill', value: raw };
     }
+    if (input.config.type === 'count') {
+        return countText.test(raw) ? { kind: 'fill', value: Number(raw) } : { kind: 'rejected' };
+    }
     const value = truths.get(raw.toLowerCase());
     return value === undefined ? { kind: 'rejected' } : { kind: 'fill', value };
 }
@@ -33,6 +40,9 @@ function fill(values, name, value) {
     if (typeof value === 'boolean') {
         values.booleans.set(name, value);
     }
+    else if (typeof value === 'number') {
+        values.counts.set(name, value);
+    }
     else if (typeof value === 'string') {
         values.strings.set(name, value);
     }
@@ -43,12 +53,13 @@ function fill(values, name, value) {
 /** How a fault names the value an answer owed, by the shape the option takes. */
 const owed = {
     boolean: 'a Boolean',
+    count: 'a whole number of 0 or more',
     list: 'an array of strings',
     string: 'a string',
 };
 function rawKind(input) {
-    if (input.config.type === 'boolean') {
-        return 'boolean';
+    if (input.config.type !== 'string') {
+        return input.config.type;
     }
     return input.config.multiple === true ? 'list' : 'string';
 }
@@ -78,6 +89,9 @@ function rawValue(kind, value) {
     if (kind === 'boolean') {
         return typeof value === 'boolean' ? value : undefined;
     }
+    if (kind === 'count') {
+        return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+    }
     return typeof value === 'string' ? value : undefined;
 }
 /**
@@ -100,12 +114,12 @@ function readAnswer(sentence, input, answer) {
     const shape = isPlainObject(answer) ? answer : undefined;
     const label = shape?.label;
     if (!shape || !isProseLine(label)) {
-        throw ruleFault(`${sentence} answered option "${input.name}" with an answer that is not { value, label }.`);
+        throw ruleFault(`${sentence} answered option ${quoted(input.name)} with an answer that is not { value, label }.`);
     }
     const kind = rawKind(input);
     const value = rawValue(kind, shape.value);
     if (value === undefined) {
-        throw ruleFault(`${sentence} answered option "${input.name}" with a value that is not ${owed[kind]}.`);
+        throw ruleFault(`${sentence} answered option ${quoted(input.name)} with a value that is not ${owed[kind]}.`);
     }
     return { label, value };
 }
@@ -121,7 +135,7 @@ function readAnswers(sentence, answers, requested) {
     return Object.entries(answers).map(([name, answer]) => {
         const target = byName.get(name);
         if (!target) {
-            throw ruleFault(`${sentence} answered option "${name}", which core did not request.`);
+            throw ruleFault(`${sentence} answered option ${quoted(name)}, which core did not request.`);
         }
         const { label, value } = readAnswer(sentence, target.input, answer);
         return { label, target, value };
@@ -150,7 +164,7 @@ function sourceFailure(sentence, error) {
  * Core builds the context before the call, so a fault of its own is never the plugin's.
  */
 async function askSource(stage, call) {
-    const { owner, requested } = call;
+    const { options, owner, requested } = call;
     const resolver = await loadDefault(owner.identity, owner.source.load, {
         guard: isResolverExport,
         noun: 'source',
@@ -162,7 +176,8 @@ async function askSource(stage, call) {
     const context = {
         graph: stage.inspected(),
         host: stage.host,
-        options: pluginValues(owner.inputs, stage.globals.values),
+        // Validation produced the record the plugin's option types describe.
+        options,
         out: stage.out,
         requests: requested.map(({ input, scope }) => stage.request(input, scope.global)),
         style: stage.style,
@@ -193,8 +208,8 @@ async function askSource(stage, call) {
 }
 /**
  * The environment tier: each option in scope that argv left unfilled reads its bound variable. A
- * filled option is labeled with its variable, and a Boolean one outside the grammar is recorded
- * as rejected, which fills nothing.
+ * filled option is labeled with its variable, and a Boolean or counted one outside its grammar is
+ * recorded as rejected, which fills nothing.
  */
 function fillFromEnvironment(scopes, env) {
     const labels = new Map();
@@ -228,8 +243,11 @@ function requestedOf(scopes, excluded, bound) {
 }
 /**
  * The input-source stage: the environment, then the configuration source, for every option in
- * scope that argv left unfilled. When no option is left to ask, the source never loads. A source
- * fault stops the stage and fills nothing more.
+ * scope that argv left unfilled. When no option is left to ask, the source never loads. The
+ * source's own options pass their validators before it loads, and when one is rejected the source
+ * is never called and the problem reports with every other validation problem, while each option
+ * the source would have been asked to fill reports no missing value. A source fault stops the
+ * stage and fills nothing more.
  */
 async function fillInputs(stage) {
     const scopes = stage.locals ? [stage.globals, stage.locals] : [stage.globals];
@@ -239,20 +257,32 @@ async function fillInputs(stage) {
         ? requestedOf(scopes, rejected, { binding: owner.source.binding, extensions: stage.extensions })
         : [];
     if (!owner || requested.length === 0) {
-        return { fault: undefined, labels, rejected };
+        return { fault: undefined, labels, rejected, validated: undefined };
     }
+    let validated = undefined;
     try {
-        for (const { label, target, value } of await askSource(stage, { owner, requested })) {
+        validated = await stage.validate(owner.inputs, { labels, rejected });
+        // A rejected own option skips the source, and the options it would have filled report no omission.
+        if (validated.failure) {
+            const unanswered = new Set(requested.map(({ input }) => input));
+            return { fault: undefined, labels, rejected, unanswered, validated };
+        }
+        // A run cancelled while the source's own options were validated loads nothing.
+        if (stage.signal.aborted) {
+            return { fault: undefined, labels, rejected, validated };
+        }
+        const options = frozenValues(owner.inputs, validated.values);
+        for (const { label, target, value } of await askSource(stage, { options, owner, requested })) {
             fill(target.scope.values, target.input.name, value);
             labels.set(target.input.name, label);
         }
-        return { fault: undefined, labels, rejected };
+        return { fault: undefined, labels, rejected, validated };
     }
     catch (error) {
         // The resolver's own failure keeps its class, and so its code.
         // Every other fault above is raised as an internal error, and anything else is wrapped the same way.
         const fault = error instanceof LoomError ? error : foreignFailure(error);
-        return { fault, labels, rejected };
+        return { fault, labels, rejected, validated };
     }
 }
 export { fillInputs };

package/dist/style-layout.js

@@ -1,4 +1,4 @@
-import { graphemeWidths } from '@rockorager/uucode/width';
+import { graphemeWidths } from './style-width.js';
 const offsets = [0, 1, 2, 3, 4, 5, 6, 7];
 const empty = {
     advance: offsets.map(() => 0),
@@ -117,6 +117,7 @@ function padBlock(block, padding, attributes) {
     if (!block.tabs && block.minimum >= padding.width) {
         return block;
     }
+    const space = (count) => leaf({ attributes, kind: 'text', text: ' '.repeat(count) }, count);
     const lines = block.lines.map((line, index) => {
         // A terminal newline has no extra line to align; interior blank lines do.
         if (index > 0 && index === block.lines.length - 1 && !line.content.text) {
@@ -134,7 +135,6 @@ function padBlock(block, padding, attributes) {
         else if (padding.align === 'center') {
             before = Math.floor(missing / 2);
         }
-        const space = (count) => leaf({ attributes, kind: 'text', text: ' '.repeat(count) }, count);
         // Re-segment inserted spaces too: a trailing Unicode Prepend character can absorb one.
         const spaced = join([space(before), content, space(missing - before)]);
         const row = measured([{ content: spaced, ending: [] }]);

package/dist/style-width.d.ts

@@ -0,0 +1,13 @@
+/** One grapheme cluster of a string: where it starts and ends, and the columns it occupies. */
+interface GraphemeWidth {
+    start: number;
+    end: number;
+    width: number;
+}
+/**
+ * Each grapheme cluster of a string with the terminal columns it occupies. Printable ASCII that no
+ * non-ASCII character follows is its own one-column cluster. Any other run of clusters is read by
+ * one cursor, which starts at the run and carries the break state from cluster to cluster.
+ */
+export declare function graphemeWidths(text: string): Generator<GraphemeWidth>;
+export {};