@sema-agent/core 7.46.0 → 7.47.0

package/dist/shell/lex.js

@@ -357,6 +357,7 @@ class WordBuilder {
     marks = [];
     subscript;
     compound = false;
+    widenedClasses = [];
     begin(src) { if (!this.started)
         this.at = src; }
     push(w, f, by, src) {
@@ -402,6 +403,17 @@ class WordBuilder {
     mark(reason, rawAt) { this.marks.push({ at: rawAt, reason }); }
     inSubscript() { return this.subscript !== undefined && this.subscript.rawEnd === undefined; }
     foldedOf(r) { return r >= this.foldedAt.length ? this.folded.length : this.foldedAt[r]; }
+    classSpelled(from, to) {
+        let out = "";
+        let at = from;
+        for (const [a, b] of this.widenedClasses) {
+            if (a < at || b > to)
+                continue;
+            out += `${this.folded.slice(at, a)}?`;
+            at = b;
+        }
+        return out + this.folded.slice(at, to);
+    }
     slice(from, to) {
         const out = [];
         for (const p of this.pieces) {
@@ -519,9 +531,23 @@ class WordBuilder {
             else if (stack.length > 0 && (d === "," || (d === "." && this.raw[j + 1] === ".")))
                 stack[stack.length - 1].listed = true;
         }
-        const nextBracketClose = new Array(n + 1).fill(-1);
-        for (let j = n - 1; j >= 0; j--)
-            nextBracketClose[j] = readable(j) && this.raw[j] === "]" ? j : nextBracketClose[j + 1];
+        const text = this.folded;
+        const nf = text.length;
+        const readableAt = (f) => f < nf && readable(this.rawOfFolded[f]);
+        const unitClose = (d) => {
+            const at = new Array(nf + 2).fill(-1);
+            for (let f = nf - 2; f >= 0; f--)
+                at[f] = readableAt(f) && readableAt(f + 1) && text[f] === d && text[f + 1] === "]" ? f : at[f + 1];
+            return at;
+        };
+        const unitCloses = new Map([":", "=", "."].map((d) => [d, unitClose(d)]));
+        const nextBracketClose = new Array(nf + 2).fill(-1);
+        const nextSlash = new Array(nf + 1).fill(nf);
+        for (let f = nf - 1; f >= 0; f--) {
+            const unitEnd = readableAt(f) && text[f] === "[" && readableAt(f + 1) ? unitCloses.get(text[f + 1] ?? "")?.[f + 2] ?? -1 : -1;
+            nextBracketClose[f] = readableAt(f) && text[f] === "]" ? f : unitEnd >= 0 ? nextBracketClose[unitEnd + 2] : nextBracketClose[f + 1];
+            nextSlash[f] = text[f] === "/" ? f : nextSlash[f + 1];
+        }
         const ranges = [];
         for (let k = 0; k < n; k++) {
             if (!readable(k))
@@ -536,19 +562,35 @@ class WordBuilder {
                 continue;
             }
             if (c === "*" || c === "?") {
-                ranges.push({ from: k, to: k + 1, exp: { kind: "glob", yields: "many" } });
+                ranges.push({ from: k, to: k + 1, exp: { kind: "glob", yields: "many", pattern: { folded: c, written: c, judged: c } } });
                 continue;
             }
             if (c === "[") {
-                let j = k + 1;
-                if (this.raw[j] === "!" || this.raw[j] === "^")
+                if (this.rawOfFolded[this.foldedOf(k)] !== k)
+                    continue;
+                let j = this.foldedOf(k) + 1;
+                if ((text[j] === "!" || text[j] === "^") && readableAt(j))
                     j++;
-                if (this.raw[j] === "]")
+                if (text[j] === "]" && readableAt(j))
                     j++;
-                const close = j < n ? nextBracketClose[j] : -1;
-                if (close < 0)
+                const closeAt = j < nf ? nextBracketClose[j] : -1;
+                if (closeAt < 0 || nextSlash[j] < closeAt)
                     continue;
-                ranges.push({ from: k, to: close + 1, exp: { kind: "glob", yields: "many", body: this.raw.slice(k + 1, close) } });
+                const close = this.rawOfFolded[closeAt];
+                let expands = false;
+                for (let m = k + 1; m < close && !expands; m++)
+                    expands = inExp[m] || braceClose.get(m)?.listed === true;
+                let widened = false;
+                for (let m = k + 1; m < close && !widened; m++)
+                    widened = this.rawQuoted[m] !== undefined;
+                for (let f = j; f < closeAt && !widened; f++)
+                    widened = readableAt(f) && text[f] === "[" && readableAt(f + 1) && (unitCloses.get(text[f + 1] ?? "")?.[f + 2] ?? -1) >= 0;
+                const from = this.foldedOf(k);
+                const to = this.foldedOf(close + 1);
+                if (!expands && widened)
+                    this.widenedClasses.push([from, to]);
+                const pattern = expands ? {} : { pattern: { folded: this.folded.slice(from, to), written: this.raw.slice(k, close + 1), judged: widened ? "?" : this.folded.slice(from, to) } };
+                ranges.push({ from: k, to: close + 1, exp: { kind: "glob", yields: "many", body: this.raw.slice(k + 1, close), ...pattern } });
                 k = close;
             }
         }
@@ -647,18 +689,20 @@ class WordBuilder {
     }
     finish(atCommandPosition, tildeSpelling = true) {
         const rawText = this.raw;
-        let foldedText = this.folded;
+        let literalTilde = false;
         let assignment;
         const tildeEnd = this.tildePrefixEnd(0, false);
         if (tildeEnd !== undefined)
             this.carveTilde(0, tildeEnd);
         else {
-            if (tildeSpelling)
-                foldedText = literalTildeSpelling(foldedText);
+            literalTilde = tildeSpelling;
             assignment = this.readAssignment();
         }
         if (!(assignment !== undefined && assignment.bare && atCommandPosition))
             this.carveBraceAndGlob();
+        const spelled = (text) => (literalTilde ? literalTildeSpelling(text) : text);
+        const foldedText = spelled(this.folded);
+        const judged = this.widenedClasses.length > 0 ? spelled(this.classSpelled(0, this.folded.length)) : undefined;
         if (assignment !== undefined && this.subscript?.text)
             this.mark("subscript_text", this.subscript.rawStart);
         const marks = this.marks.filter((m) => m.reason !== "subscript_text" || assignment?.subscript !== undefined).sort((a, b) => a.at - b.at);
@@ -679,6 +723,7 @@ class WordBuilder {
             kind: "word",
             raw: rawText,
             folded: foldedText,
+            ...(judged !== undefined ? { judged } : {}),
             pieces,
             quotedSpans: spans,
             expansions: pieces.filter((p) => p.expansion !== undefined),

package/dist/tools/fs/bash-program-position.d.ts

@@ -53,12 +53,15 @@ export type ProgramPositionRefusal = {
     readonly kind: "control_syntax_at_program_position";
     readonly owner: string;
     readonly word: string;
-    /** Not a DECLINE ({@link programPositionRunsShell}): the row WAS read and a SHELL stands at the program
-     *  position. Absent ⇒ genuine control syntax, which IS one. */
-    readonly runsShell?: true;
-    /** The launcher hands the shell its operands as text (`watch "S"`); absent beside `runsShell`, the shell is handed
-     *  nothing (`sudo -s`, `chroot DIR`) and runs its standard input. */
-    readonly handsText?: true;
+    /** Not a DECLINE ({@link programPositionRunsShell}): the row WAS read and a SHELL — or a program the launcher
+     *  names by an option of its own (`su -s PROGRAM`) — stands at the program position, run by the launcher at argv
+     *  index `launcher` and handed the words from index `from` on (none where `from` is the argv's end: `sudo -s`,
+     *  `chroot DIR`), as that launcher's row composes them (`launchedCommands`, shell-reentry-text.ts). Absent ⇒
+     *  genuine control syntax, which IS one. */
+    readonly runsShell?: {
+        readonly launcher: number;
+        readonly from: number;
+    };
 };
 export interface ProgramPosition {
     /** Indices of the bare control words stripped in front (`!`, `if`, `time`, …), in order; their declared options

package/dist/tools/fs/bash-program-position.js

@@ -1,5 +1,5 @@
 import { SHELL_CONTROL_PREFIXES } from "../../shell/lex.js";
-import { BLOCK_WORD_NAMES, LAUNCHER_NAMES, feedsArgvFromStdin, launcherOptionStep, programRow, selectedOptions, streamDefaultProgram } from "./program-read-model.js";
+import { BLOCK_WORD_NAMES, LAUNCHER_NAMES, feedsArgvFromStdin, launcherOptionStep, launcherRunsShell, programRow, selectedOptions, streamDefaultProgram } from "./program-read-model.js";
 export const NOT_AUTO_ALLOWED = "— not auto-allowed";
 export function programBasename(word) {
     return word.includes("/") ? (word.split("/").pop() ?? word) : word;
@@ -79,12 +79,12 @@ export function readProgramPosition(words) {
     }
     const launchers = [{ index: i, name: basename }];
     const owner = head;
-    const shellRefusal = (handsText) => ({ kind: "control_syntax_at_program_position", owner, word: "sh", runsShell: true, ...(handsText !== undefined ? { handsText } : {}) });
+    const shellRefusal = (launcher, from) => ({ kind: "control_syntax_at_program_position", owner, word: "sh", runsShell: { launcher, from } });
     let lastRow = launcherRowOf(basename)?.launcher;
     let owedOperands = lastRow?.requiredOperands ?? 0;
     const chain0 = (program, refusal) => ({ controlWords, written, assignments, launchers, argvFromStdin: false, runsDefaultProgram: false, program, refusal });
-    if (lastRow?.shellText === true)
-        return chain0(undefined, shellRefusal(true));
+    if (launcherRunsShell(launcherRowOf(basename), folded.slice(i + 1)))
+        return chain0(undefined, shellRefusal(i, i + 1));
     let argvFromStdin = feedsArgvFromStdin(basename);
     let lastReentry = argvFromStdin ? i : -1;
     let reentryDefault = argvFromStdin ? streamDefaultProgram(basename) : undefined;
@@ -92,6 +92,7 @@ export function readProgramPosition(words) {
         const runsDefaultProgram = lastReentry === folded.length - 1;
         return { controlWords, written, assignments, launchers, argvFromStdin, runsDefaultProgram, ...(runsDefaultProgram && reentryDefault !== undefined ? { defaultProgram: reentryDefault } : {}), program, refusal };
     };
+    const selectsShell = (l, end) => selectedOptions(launcherRowOf(l.name), folded.slice(l.index + 1, end)).some((o) => o.mode === "interactive");
     for (let j = pastLauncherOptions(basename, folded, i + 1); j < folded.length; j++) {
         const t = folded[j];
         if (owedOperands > 0 && !t.startsWith("-")) {
@@ -100,6 +101,8 @@ export function readProgramPosition(words) {
         }
         if (lastRow?.assignmentOperands === true && !t.startsWith("-") && t.includes("="))
             continue;
+        if (lastRow?.shellCommand !== undefined && !t.startsWith("-") && selectsShell(launchers[launchers.length - 1], j))
+            return chain(undefined, shellRefusal(launchers[launchers.length - 1].index, j));
         const wordBasename = programBasename(t);
         if (feedsArgvFromStdin(wordBasename)) {
             argvFromStdin = true;
@@ -112,8 +115,8 @@ export function readProgramPosition(words) {
         if (LAUNCHER_NAMES.has(wordBasename)) {
             launchers.push({ index: j, name: wordBasename });
             lastRow = launcherRowOf(wordBasename)?.launcher;
-            if (lastRow?.shellText === true)
-                return chain(undefined, shellRefusal(true));
+            if (launcherRunsShell(launcherRowOf(wordBasename), folded.slice(j + 1)))
+                return chain(undefined, shellRefusal(j, j + 1));
             owedOperands = lastRow?.requiredOperands ?? 0;
             j = pastLauncherOptions(wordBasename, folded, j + 1) - 1;
             continue;
@@ -126,8 +129,8 @@ export function readProgramPosition(words) {
         return chain({ index: j, name: t, basename: wordBasename });
     }
     const last = launchers[launchers.length - 1];
-    if (lastRow?.whenNoProgram === "shell" || selectedOptions(launcherRowOf(last.name), folded.slice(last.index + 1)).some((o) => o.mode === "interactive"))
-        return chain(undefined, shellRefusal());
+    if (lastRow?.whenNoProgram === "shell" || selectsShell(last, folded.length))
+        return chain(undefined, shellRefusal(last.index, folded.length));
     return chain(undefined);
 }
 export function argvReentryUnjudged(pos, acceptsTarget) {
@@ -139,12 +142,12 @@ export function argvReentryUnjudged(pos, acceptsTarget) {
 export const SHELL_SCAN_DECLINES = Object.freeze(["unreadable_program_position", "stream_fed_operands"]);
 export function programPositionRunsShell(pos, runsShell) {
     if (pos.refusal !== undefined)
-        return pos.refusal.kind === "control_syntax_at_program_position" && pos.refusal.runsShell === true;
+        return pos.refusal.kind === "control_syntax_at_program_position" && pos.refusal.runsShell !== undefined;
     return pos.program !== undefined && runsShell(pos.program.basename);
 }
 export function shellScanDeclineOf(pos, acceptsStreamTarget) {
     if (pos.refusal !== undefined) {
-        return pos.refusal.kind === "control_syntax_at_program_position" && pos.refusal.runsShell === true ? undefined : "unreadable_program_position";
+        return pos.refusal.kind === "control_syntax_at_program_position" && pos.refusal.runsShell !== undefined ? undefined : "unreadable_program_position";
     }
     return argvReentryUnjudged(pos, acceptsStreamTarget) ? "stream_fed_operands" : undefined;
 }

package/dist/tools/fs/program-read-model.d.ts

@@ -75,7 +75,8 @@ export type ArgRole =
  | {
     readonly kind: "shell-text";
 }
-/** The program word a launcher runs; the words after it are that program's argv. */
+/** The program a launcher or a builtin runs by name: a function (`compgen -F`), the program a launcher runs in place of
+ *  a shell (`su -s PROGRAM`). */
  | {
     readonly kind: "command";
 }
@@ -163,10 +164,10 @@ export interface OptionSpec {
     readonly endsOptions?: true;
     /** `banner`: prints and exits; `interactive`: reads commands from its standard input (after its program, `python -i`;
      *  instead of a script file, `sh -s`; a launcher's shell, run where no program follows, `sudo -s`); `names-program`: selects
-     *  the program to run without a value (`node --test`); `follows`: follows its files as they grow, until killed
-     *  (`tail -f`); `repeats`: repeats on an interval until killed (`free -s`); `quiet`: prints only what the program's own
-     *  text tells it to (`sed -n`); `forced`: removes without asking, and passes over an operand that is not there
-     *  (`rm -f`). */
+     *  the program to run without a value (`node --test`; a launcher's, from the caller's environment: `su -m`); `follows`:
+     *  follows its files as they grow, until killed (`tail -f`); `repeats`: repeats on an interval until killed (`free -s`);
+     *  `quiet`: prints only what the program's own text tells it to (`sed -n`); `forced`: removes without asking, and passes
+     *  over an operand that is not there (`rm -f`). */
     readonly mode?: OptionMode;
     /** This switch turns the program's own value glob off (`curl -g`): every {@link ArgRole} `programGlob` value of the
      *  invocation is read literally. */
@@ -250,10 +251,22 @@ export interface LauncherSpec {
     readonly assignmentOperands?: true;
     /** A bare negative integer in its option section is its own argument (`nice -5 <cmd>`). */
     readonly negativeIntegerIsOwnArgument?: true;
-    /** It hands its operands to a SHELL as text (`watch "cat /x"`): there is no program word. */
-    readonly shellText?: true;
+    /** It runs a SHELL in place of a program word, and how the words after it become that shell's argv: `joined` — its
+     *  non-option words, joined by a space, are the shell's `-c` text (`watch "cat /x"`); `user` — its first operand (past
+     *  a lone `-`) names the user it runs as, and the words after the user are the shell's own argv, behind a `-c TEXT` its
+     *  own shell-text option gives (`su [-] [USER [ARG…]]`: an implementation that reads its options anywhere takes them
+     *  past the user too, one that stops at the user hands them on); the program is its option of role `command` where
+     *  one is given (`su -s PROGRAM`), or a `names-program` switch's (`su -m`: the caller's `$SHELL`). */
+    readonly shellText?: "joined" | "user";
+    /** Option spellings that make a {@link shellText} launcher run the program its operands name instead
+     *  (`runuser -u USER CMD…`). */
+    readonly programWith?: readonly string[];
     /** With no program word it runs a shell. */
     readonly whenNoProgram?: "shell";
+    /** Where a switch selecting its shell (mode `interactive`: `sudo -s`) has words after it, they are that shell's `-c`
+     *  text: `escaped` — joined by a space, every character of each but a letter, a digit, `_`, `-` and `$` escaped with a
+     *  backslash. Absent, the launcher takes no such words (`doas -s CMD` is refused) and they are read as the program. */
+    readonly shellCommand?: "escaped";
     /** The spelling a required operand must have (a word spelled otherwise is not one the launcher accepts). Absent: any
      *  word that is not option-shaped. */
     readonly requiredOperandSpelling?: RegExp;
@@ -652,6 +665,10 @@ export declare function launcherOptionPathRole(row: ProgramRow, tok: string): Ex
  *  separated (2), a value fused to its long name or short letter (1); a switch, an attached-only option, or a cluster of
  *  switches (1); a lone `-` where the launcher reads it as its own switch (1). */
 export declare function launcherOptionStep(row: ProgramRow, tok: string): 1 | 2 | undefined;
+/** Does a launcher that runs a shell ({@link LauncherSpec.shellText}) run one over these words — the words after it —
+ *  rather than the program they name? Not where an implementation selects one of its {@link LauncherSpec.programWith}
+ *  options (as that implementation reads them: past `--` a word is an operand). */
+export declare function launcherRunsShell(row: ProgramRow, args: readonly string[]): boolean;
 /** The spellings of a launcher's command-line options (`env -S` / `--split-string`): the value is a command line the
  *  launcher splits and runs. */
 export declare function commandLineOptionSpellings(row: ProgramRow | undefined): readonly string[];

package/dist/tools/fs/program-read-model.js

@@ -1055,6 +1055,13 @@ export function launcherOptionStep(row, tok) {
         return 1;
     return undefined;
 }
+export function launcherRunsShell(row, args) {
+    const l = row.launcher;
+    if (l?.shellText === undefined)
+        return false;
+    const specs = new Set((l.programWith ?? []).map((s) => (s.startsWith("--") ? mergedTable(row, "long").get(s.slice(2)) : mergedTable(row, "short").get(s.slice(1)))?.spec));
+    return !implementationsOf(row).some((view) => selectedOptions(view, args, "one-implementation").some((o) => specs.has(o)));
+}
 export function commandLineOptionSpellings(row) {
     if (row === undefined)
         return [];

package/dist/tools/fs/program-read-model.rows.js

@@ -360,8 +360,19 @@ const launcherGrammar = (g, extra = {}) => {
         put(spelling, val(SHELL_TEXT));
     for (const spelling of g.shells ?? [])
         put(spelling, { arity: 0, mode: "interactive" });
+    for (const spelling of g.programs ?? [])
+        put(spelling, { arity: 0, mode: "names-program" });
     return { dialect: "any", short, long, afterFirstOperand: "either", ...extra };
 };
+const SU_OPTIONS = {
+    switches: ["-f", "-l", "-P", "-T", "-h", "-V", "--fast", "--login", "--pty", "--no-pty", "--help", "--version"],
+    banners: ["-h", "-V"],
+    values: { "-g": LABEL, "-G": LABEL, "-w": LABEL, "-s": COMMAND, "--group": LABEL, "--supp-group": LABEL, "--whitelist-environment": LABEL, "--shell": COMMAND },
+    shellText: ["-c", "--command", "--session-command"],
+    programs: ["-m", "-p", "--preserve-environment"],
+};
+const SU = launcherGrammar(SU_OPTIONS, { stepsDashDash: true });
+const SU_LINUX_ONLY = [...SU_OPTIONS.switches, ...Object.keys(SU_OPTIONS.values), ...SU_OPTIONS.shellText, ...SU_OPTIONS.programs].filter((s) => !["-f", "-l", "-m"].includes(s));
 const launchers = [
     { key: "env", grammars: implementations(launcherGrammar({
             switches: ["-i", "-v", "--ignore-environment", "--debug", "--list-signal-handling", "--help", "--version"],
@@ -380,18 +391,18 @@ const launchers = [
             optional: { "-i": LABEL, "-l": COUNT, "--replace": LABEL, "--eof": LABEL, "--max-lines": COUNT },
         }, {}), { reads: { "-a": val(READ, { delivers: "operands" }), "--arg-file": val(READ, { delivers: "operands" }) } }, { lacks: ["-d", "-i", "-l", "-a", "--arg-file", "--null", "--no-run-if-empty", "--verbose", "--exit", "--interactive", "--open-tty", "--show-limits", "--help", "--version", "--max-args", "--max-procs", "--delimiter", "--max-chars", "--process-slot-var", "--replace", "--eof", "--max-lines"] }), launcher: {}, reentry: { kind: "argv", defaultProgram: "echo" }, witness: BINARY },
     launcher("busybox"),
-    launcher("sudo", { assignmentOperands: true }, launcherGrammar({
+    launcher("sudo", { assignmentOperands: true, shellCommand: "escaped" }, launcherGrammar({
         switches: ["-A", "-b", "-E", "-H", "-K", "-k", "-l", "-n", "-P", "-S", "-V", "-v", "--askpass", "--background", "--preserve-env", "--set-home", "--remove-timestamp", "--reset-timestamp", "--list", "--non-interactive", "--preserve-groups", "--stdin", "--version", "--validate", "--bell", "--help"],
         shells: ["-i", "-s", "--login", "--shell"],
         values: {
             "-u": LABEL, "-g": LABEL, "-U": LABEL, "-C": COUNT, "-D": WORKDIR, "-h": LABEL, "-p": LABEL, "-r": LABEL, "-R": ROOTDIR, "-t": LABEL, "-T": COUNT, "-a": LABEL,
             "--user": LABEL, "--group": LABEL, "--other-user": LABEL, "--close-from": COUNT, "--chdir": WORKDIR, "--host": LABEL, "--prompt": LABEL, "--role": LABEL, "--chroot": ROOTDIR, "--type": LABEL, "--command-timeout": COUNT, "--auth-type": LABEL,
         },
-    }), { witness: PRIVILEGED }),
-    launcher("doas", {}, launcherGrammar({ switches: ["-L", "-n"], shells: ["-s"], values: { "-a": LABEL, "-u": LABEL, "-C": READ } }), { witness: PRIVILEGED }),
+    }, { stepsDashDash: true }), { witness: PRIVILEGED }),
+    launcher("doas", {}, launcherGrammar({ switches: ["-L", "-n"], shells: ["-s"], values: { "-a": LABEL, "-u": LABEL, "-C": READ } }, { stepsDashDash: true }), { witness: PRIVILEGED }),
     launcher("pkexec", { whenNoProgram: "shell" }, launcherGrammar({ switches: ["--disable-internal-agent", "--keep-cwd", "--version", "--help"], values: { "--user": LABEL } }), { witness: PRIVILEGED }),
-    launcher("su", { shellText: true }, undefined, { witness: PRIVILEGED }),
-    launcher("runuser", { shellText: true }, undefined, { witness: PRIVILEGED }),
+    { key: "su", grammars: implementations(SU, { afterFirstOperand: "options" }, { lacks: SU_LINUX_ONLY, afterFirstOperand: "operands" }), launcher: { shellText: "user" }, witness: PRIVILEGED },
+    { key: "runuser", grammars: [launcherGrammar({ ...SU_OPTIONS, values: { ...SU_OPTIONS.values, "-u": LABEL, "--user": LABEL } }, { afterFirstOperand: "options", stepsDashDash: true })], launcher: { shellText: "user", programWith: ["-u", "--user"] }, witness: PRIVILEGED },
     launcher("chroot", { requiredOperands: 1, whenNoProgram: "shell" }, undefined, { witness: PRIVILEGED }),
     launcher("setpriv", {}, undefined, { witness: PRIVILEGED }),
     launcher("nohup", {}, grammar({}, BANNERS)),
@@ -409,7 +420,7 @@ const launchers = [
     { key: "stdbuf", grammars: implementations(grammar({ i: val(LABEL), o: val(LABEL), e: val(LABEL) }, { input: val(LABEL), output: val(LABEL), error: val(LABEL), ...BANNERS }), {}, { lacks: ["--input", "--output", "--error", "--help", "--version"] }), launcher: {}, witness: BINARY },
     launcher("timeout", { requiredOperands: 1, requiredOperandSpelling: DURATION_SPELLING }, grammar({ v: SWITCH, k: val(COUNT), s: val(LABEL) }, { foreground: SWITCH, "preserve-status": SWITCH, verbose: SWITCH, "kill-after": val(COUNT), signal: val(LABEL), ...BANNERS })),
     { key: "time", grammars: implementations(grammar({ p: SWITCH, a: SWITCH, v: SWITCH, q: SWITCH, f: val(LABEL), o: val(WRITE) }, { portability: SWITCH, append: SWITCH, verbose: SWITCH, quiet: SWITCH, help: SWITCH, version: SWITCH, format: val(LABEL), output: val(WRITE) }, { stepsDashDash: true }), {}, { lacks: ["-v", "-q", "-f", "--portability", "--append", "--verbose", "--quiet", "--help", "--version", "--format", "--output"] }), launcher: {}, witness: BINARY },
-    launcher("watch", { shellText: true }, undefined, { witness: SHELL_TEXT_LAUNCHER }),
+    launcher("watch", { shellText: "joined" }, undefined, { witness: SHELL_TEXT_LAUNCHER }),
     launcher("setsid", {}, launcherGrammar({ switches: ["-c", "-f", "-w", "--ctty", "--fork", "--wait", "--help", "--version"] })),
     launcher("flock", { requiredOperands: 1 }, launcherGrammar({
         switches: ["-s", "-x", "-u", "-n", "-o", "-F", "--shared", "--exclusive", "--unlock", "--nonblock", "--nb", "--close", "--no-fork", "--verbose", "--help", "--version"],
@@ -425,7 +436,7 @@ const launchers = [
         values: { "-t": COUNT, "-S": LABEL, "-G": LABEL, "--target": COUNT, "--setuid": LABEL, "--setgid": LABEL },
         optional: { "-r": ROOTDIR, "-w": WORKDIR, "--root": ROOTDIR, "--wd": WORKDIR },
     }), { witness: LINUX_NAMESPACE }),
-    launcher("script", { shellText: true }, launcherGrammar({ shellText: ["-c", "--command"] }), { witness: SHELL_TEXT_LAUNCHER }),
+    launcher("script", { shellText: "joined" }, launcherGrammar({ shellText: ["-c", "--command"] }), { witness: SHELL_TEXT_LAUNCHER }),
     launcher("numactl", {}, undefined, { witness: LINUX_NAMESPACE }),
     launcher("prlimit", {}, undefined, { witness: LINUX_NAMESPACE }),
     launcher("systemd-run", {}, undefined, { witness: { declared: "hands the program to a service manager" } }),

package/dist/tools/fs/removal-targets.js

@@ -2,7 +2,8 @@ import { planShellReads } from "./shell-read-plan.js";
 import { literalTextOf } from "../../shell/lex.js";
 import { createShellReadEstablisher, establishShellReadsLexically } from "./shell-read-establish.js";
 import { isAbsolutePathForm, isWinFormPath, normalizeAbsPathLexically } from "./safety.js";
-import { reentryText } from "./shell-reentry-text.js";
+import { launchedCommands, launchedReadings, reentryText, spellLaunched } from "./shell-reentry-text.js";
+import { readProgramPosition } from "./bash-program-position.js";
 import { bashClassifyDefaultAllow } from "./bash-readonly-classifier.js";
 import { programArgs } from "./shell-read-write-targets.js";
 import { implementationsOf, programRow, runsShellText, selectedOptions, writeReadings } from "./program-read-model.js";
@@ -167,10 +168,19 @@ function runtimeScriptOf(segment) {
     const program = segment.verb;
     if (segment.reentry !== "shell" || program === undefined || !runsShellText(program.basename))
         return undefined;
-    const at = segment.argv.findIndex((w) => w.folded === program.name);
     const MARK = "\u0000";
-    const words = at < 0 ? [] : segment.argv.slice(at + 1).map((w) => literalTextOf(w.pieces) ?? `${MARK}${w.raw}`);
-    const texts = [reentryText(program.basename, words), ...(segment.stdin ?? []).map((s) => reentryText(program.basename, words, s.literal ?? `${MARK}${s.from}`))];
+    const spell = (k, from = 0) => {
+        const w = segment.argv[k];
+        const literal = literalTextOf(w.pieces);
+        return literal !== undefined ? literal.slice(from) : `${MARK}${w.raw.slice(from)}`;
+    };
+    const pos = readProgramPosition(segment.argv);
+    const named = pos.program !== undefined && pos.refusal === undefined ? [{ shell: program.basename, words: segment.argv.slice(pos.program.index + 1).map((_, k) => spell(pos.program.index + 1 + k)) }] : [];
+    const launched = launchedCommands(segment.argv, pos).flatMap((c) => {
+        const shell = launchedReadings(segment.argv, c).shell;
+        return shell === undefined ? [] : spellLaunched(segment.argv, c.args, { word: spell }).map((words) => ({ shell, words }));
+    });
+    const texts = [...named, ...launched].flatMap(({ shell, words }) => [reentryText(shell, words), ...(segment.stdin ?? []).map((s) => reentryText(shell, words, s.literal ?? `${MARK}${s.from}`))]);
     const text = texts.find((t) => t?.includes(MARK) === true);
     return text === undefined ? undefined : text.split(MARK).join("");
 }

package/dist/tools/fs/shell-read-argv.d.ts

@@ -7,14 +7,15 @@
  */
 import { type LexedWord } from "../../shell/lex.js";
 import { type Read } from "./shell-read-word.js";
-import { type BindingTable, type BoundValue } from "./shell-read-bindings.js";
+import { type BindingTable, type FloorValue } from "./shell-read-bindings.js";
 import { subcommandOf, type ArgRole, type ProgramRow } from "./program-read-model.js";
 import type { ReadCandidate, ReadCandidateProvenance } from "./shell-read-plan.js";
 /** A candidate before the threading fills its bases. `alternatives`: the other spellings its word may expand to (a name
- *  bound to several values) — one candidate each once the segment's reads are read. */
+ *  bound to several values), each with the pattern its names are matched by — one candidate each once the segment's reads
+ *  are read. */
 export type Bare = Omit<ReadCandidate, "bases"> & {
-    readonly alternatives?: readonly string[];
-    readonly floors?: readonly BoundValue[];
+    readonly alternatives?: readonly Pick<ReadCandidate, "spelled" | "pattern">[];
+    readonly floors?: readonly FloorValue[];
 };
 /** What reading a segment's words found beside its candidates. */
 export interface WordContext {

package/dist/tools/fs/shell-read-argv.js

@@ -1,5 +1,5 @@
 import { literalTildeSpelling } from "../../shell/lex.js";
-import { expandsOf, readOfText, rewritten } from "./shell-read-word.js";
+import { expandsOf, patternOf, readOfText, rewritten, spellingOf } from "./shell-read-word.js";
 import { arithmeticSubstitutions } from "./shell-read-bindings.js";
 import { argvProgramOf, attachedOptionPayloads, isPathShapedToken } from "./bash-readonly-classifier.js";
 import { assignmentArgumentsAreNotPaths, evaluatesOperands, messageWords, moduleTailOf, objectPathsOf, opensNoOperand, programRow, programTextMayOpen, programTextOpensOf, readArgs, selectsContentsTraversal, slotValueCandidates, subcommandOf, valuesAreLiteral, walksCwdWithoutOperand, wordsReadBySomeImplementations, } from "./program-read-model.js";
@@ -10,14 +10,16 @@ export function pathSubcommandOf(row, args) {
 export const programTextSentence = (language) => `runs inline ${language} program text, which may open files this station does not read`;
 export function bare(r, provenance, spelled = r.folded) {
     const whole = spelled === r.folded;
-    if (!whole && r.values !== undefined)
+    const alternatives = r.values !== undefined && r.values.length > 1 ? r.values.slice(1).map((v) => { const pattern = patternOf(v); return { spelled: spellingOf(v), ...(pattern !== undefined ? { pattern } : {}) }; }) : undefined;
+    if (!whole && alternatives !== undefined)
         return { spelled, raw: r.raw, provenance, expands: "unresolvable" };
     return {
         spelled,
         raw: r.raw,
         provenance,
         expands: r.expands,
-        ...(whole && r.values !== undefined ? { alternatives: r.values.slice(1) } : {}),
+        ...(whole && r.pattern !== undefined ? { pattern: r.pattern } : {}),
+        ...(whole && alternatives !== undefined ? { alternatives } : {}),
         ...(whole && r.homeFloor !== undefined ? { floorSpelled: r.homeFloor } : {}),
         ...(whole && r.floorValues !== undefined ? { floors: r.floorValues } : {}),
     };

package/dist/tools/fs/shell-read-bindings.d.ts

@@ -26,9 +26,34 @@
  */
 import { type LexedRedirect, type LexedSegment, type LexedToken, type LexedWord } from "../../shell/lex.js";
 import { type DeclaredAttribute } from "./program-read-model.js";
-/** A value a name may hold: the text it holds, and whether that text is a PATTERN whose matches are the values (a `for`
- *  list word the shell globs before the loop binds it). */
-export interface BoundValue {
+/** A value a name may hold — the text the program receives ({@link spelled}: what a shell re-parsing it reads), literal
+ *  throughout, or a PATTERN whose matches are the values (a `for` list word the shell globs before the loop binds it;
+ *  `spelled` is then the pattern as the program receives it where it matches nothing): `glob`, with its `parts` — the
+ *  value in runs: a literal run (quoted or literal text, a settled value) and a pattern run (glob pieces as written,
+ *  quoting kept, and as a reader judges them — {@link WordExpansion.pattern}). The one producer is the piece walk
+ *  ({@link valueOf}). */
+export type BoundValue = {
+    readonly spelled: string;
+    readonly glob?: never;
+    readonly parts?: never;
+} | {
+    readonly spelled: string;
+    readonly glob: true;
+    readonly parts: readonly ValuePart[];
+};
+/** One run of a pattern {@link BoundValue}: literal text, or a pattern — the shell expands its characters — `text` as
+ *  written (what a shell re-reading it matches by), `judged` as a reader judges the names it matches. */
+export type ValuePart = {
+    readonly text: string;
+    readonly pattern: false;
+} | {
+    readonly text: string;
+    readonly pattern: true;
+    readonly judged: string;
+};
+/** A spelling the deny judge alone reads ({@link Binding.floor}, {@link wordFloorValues}): a value, or a word as written
+ *  where its names are unknown — nothing re-reads it, so a pattern says no more than that it is one. */
+export interface FloorValue {
     readonly spelled: string;
     readonly glob?: true;
 }
@@ -58,7 +83,7 @@ export interface Binding {
     readonly scope?: "local" | "unread";
     /** Spellings the name may hold that the deny judge still reads where the name is otherwise unknown (an array's
      *  elements: what `${A[k]}` expands to is one of them). */
-    readonly floor?: readonly BoundValue[];
+    readonly floor?: readonly FloorValue[];
 }
 /** An attribute a declaration gives a name — or every name (`name` absent: the declaration computed it): a later
  *  assignment to it is evaluated as arithmetic (`integer`), stores a case change or an array element (`transformed`), or
@@ -104,27 +129,29 @@ export declare function projectSegment(segment: LexedSegment): ProjectedSegment;
  *  token, a head whose body opens in a later segment). */
 export declare function dropDefinitionHeads(tokens: LexedToken[]): readonly number[];
 /**
- * What a word holds through the names it refers to — `$NAME`, `${NAME}`, a leading `~` (the value of `HOME`):
- *  · `undefined` — it refers to no name (it reads as written);
- *  · its values — every combination of the values its names may hold here (a piece the shell globs keeps its written
- *    pattern, and the value is then a pattern);
- *  · `"unknown"` — a name it refers to is not settled here, it carries an expansion no name answers (a modifier, a
- *    substitution, a brace list, `~user`), an UNQUOTED expansion's value is not one word or `IFS` may have changed
- *    (`quoted` = the whole word is read as one value: an assignment's value, which is never split), or it would list
- *    more than {@link WORD_VALUES_MAX} values.
- * `table.stateOf` is read after `overlay` (the names the same segment bound earlier).
+ * What a word holds through the names it refers to — `$NAME`, `${NAME}`, a leading `~` (the value of `HOME`): `undefined`
+ * where it refers to no name (it reads as written), else {@link valueOf}. `table.stateOf` is read after `overlay` (the
+ * names the same segment bound earlier).
  */
 export declare function wordValues(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined, quoted: boolean, overlay?: ReadonlyMap<string, NameState>): readonly BoundValue[] | "unknown" | undefined;
+/**
+ * What a VALUE word holds (an assignment's value, a `for` list word, a word handed to a program) — THE piece walk, the one
+ * producer of {@link BoundValue}s: every combination of the values its pieces take — a literal piece its text, a glob
+ * piece its pattern (as the program receives it, as written for a shell re-reading it, and as a reader judges it — the
+ * lexer's three texts, never re-cut here), `~` and `$NAME` the values the table gives:
+ *  · its values — a piece the shell globs makes the value a pattern;
+ *  · `"unknown"` — a name it refers to is not settled here, it carries an expansion no name answers (a modifier, a
+ *    substitution, a brace list, `~user`, an expansion inside a bracket pattern), an UNQUOTED expansion's value is not one
+ *    word or `IFS` may have changed (`quoted` = the whole word is read as one value: an assignment's value, which is never
+ *    split), or it would list more than {@link WORD_VALUES_MAX} values.
+ */
+export declare function valueOf(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined, quoted: boolean, overlay?: ReadonlyMap<string, NameState>): NameState;
 /**
  * The spellings a word the table leaves unknown may still take through the deny floors of the names it refers to
  * ({@link BindingTable.floorOf}) — `${A[k]}`, `${A[@]}`, `$A` reading an array's elements — or through their values where
  * known: for the deny judge alone. Empty where some name it refers to leaves neither.
  */
-export declare function wordFloorValues(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined): readonly BoundValue[];
-/** What a VALUE word holds (an assignment's value, a `for` list word): {@link wordValues}, or — a word referring to no
- *  name — its own text (a word the shell globs is a pattern; one carrying any other expansion holds what the text does
- *  not say). */
-export declare function valueOf(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined, quoted: boolean, overlay?: ReadonlyMap<string, NameState>): NameState;
+export declare function wordFloorValues(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined): readonly FloorValue[];
 /**
  * What ONE segment does to the names (see the module header). `argv` = the segment's argv projection (structure
  * dropped); `readValue` folds a value word against the table (a reader that answers `unknown` gives the names alone).
@@ -164,7 +191,7 @@ export interface BindingTable {
     /** `HOME` may hold something other than the declared home here. */
     readonly homeTouched: boolean;
     /** Every spelling any binding of this name before here left for the deny judge alone ({@link Binding.floor}). */
-    floorOf(name: string): readonly BoundValue[];
+    floorOf(name: string): readonly FloorValue[];
     /** What a substitution body here starts with. */
     readonly inherited: InheritedNames;
 }