@sema-agent/core 7.44.0 → 7.46.0

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

@@ -0,0 +1,613 @@
+const READ = { kind: "path", effect: "read" };
+const WRITE = { kind: "path", effect: "write" };
+const CREATED = { kind: "path", effect: "create" };
+const TOUCHED = { kind: "path", effect: "create", seats: ["landing"] };
+const REMOVED = { kind: "path", effect: "write", seats: ["entry"] };
+const COPY_SOURCE = { kind: "path", effect: "write", seats: ["landing", "entry"], writtenAt: [] };
+const MOVE_SOURCE = { kind: "path", effect: "write", seats: ["landing", "entry"], writtenAt: ["entry"] };
+const DESTINATION = { kind: "path", effect: "write", seats: ["landing", "entry"] };
+const EDITED = { kind: "path", effect: "edit-in-place", seats: ["entry"] };
+const NAMES = { kind: "path", effect: "names" };
+const INDIRECT = { kind: "path", effect: "read", valueForm: "indirect" };
+const FORM = { kind: "path", effect: "read", valueForm: "form" };
+const HEADER = { kind: "path", effect: "read", valueForm: "header" };
+const URL = { kind: "path", effect: "read", valueForm: "url", programGlob: true };
+const UPLOAD = { kind: "path", effect: "read", programGlob: true };
+const COUNT = { kind: "datum", form: "count" };
+const PATTERN = { kind: "datum", form: "pattern" };
+const NAME_PATTERN = { kind: "datum", form: "name-pattern" };
+const LABEL = { kind: "datum", form: "label" };
+const DELIMITER = { kind: "datum", form: "delimiter" };
+const MESSAGE = { kind: "datum", form: "message" };
+const SHELL_TEXT = { kind: "shell-text" };
+const ASSIGNMENT = { kind: "assignment" };
+const ENTRY_PROBE = { kind: "entry-probe" };
+const BINDS_NAME = { kind: "binds-name" };
+const COMMAND = { kind: "command" };
+const VOLUME = { kind: "mount-source", form: "volume" };
+const MOUNT = { kind: "mount-source", form: "mount" };
+const OBJECT_PATH = { kind: "object-path" };
+const text = (language) => ({ kind: "program-text", language });
+const file = (language) => ({ kind: "program-file", language });
+const SWITCH = { arity: 0 };
+const val = (value, extra = {}) => ({ arity: 1, ...(value !== undefined ? { value } : {}), ...extra });
+const optional = (value) => ({ arity: "attached", ...(value !== undefined ? { value } : {}) });
+const switches = (letters, extra = {}) => Object.fromEntries([...letters].map((l) => [l, { arity: 0, ...extra }]));
+const longSwitches = (names, extra = {}) => Object.fromEntries(names.map((n) => [n, { arity: 0, ...extra }]));
+const values = (letters, value) => Object.fromEntries([...letters].map((l) => [l, val(value)]));
+const grammar = (short, long = {}, extra = {}) => ({ dialect: "any", short, long, afterFirstOperand: "either", ...extra });
+function implementations(union, gnu, bsd) {
+    const one = (dialect, d) => {
+        const short = { ...union.short };
+        const long = { ...union.long };
+        const dashWords = union.dashWords === undefined ? undefined : { ...union.dashWords };
+        const table = (spelling) => (spelling.startsWith("--") ? long : spelling.length === 2 ? short : dashWords);
+        const key = (spelling) => spelling.replace(/^--?/, "");
+        for (const s of d.lacks ?? [])
+            delete table(s)?.[key(s)];
+        for (const [s, spec] of Object.entries(d.reads ?? {})) {
+            const t = table(s);
+            if (t !== undefined)
+                t[key(s)] = spec;
+        }
+        return { ...union, dialect, short, long, ...(dashWords !== undefined ? { dashWords } : {}), afterFirstOperand: d.afterFirstOperand ?? union.afterFirstOperand, ...(d.obsoleteFirst !== undefined ? { obsoleteFirst: d.obsoleteFirst } : {}) };
+    };
+    return [one("gnu", gnu), one("bsd", bsd)];
+}
+const BINARY = "binary";
+const BANNERS = longSwitches(["help", "version"], { mode: "banner" });
+const head = {
+    key: "head",
+    grammars: implementations(grammar({ c: val(COUNT, { bounds: "bytes" }), n: val(COUNT, { bounds: "lines" }), ...switches("qvz") }, { bytes: val(COUNT, { bounds: "bytes" }), lines: val(COUNT, { bounds: "lines" }), ...longSwitches(["quiet", "silent", "verbose", "zero-terminated"]), ...BANNERS }), {}, { lacks: ["-q", "-v", "-z", "--quiet", "--silent", "--verbose", "--zero-terminated", "--help", "--version"] }),
+    operands: { stdinBelow: 1 },
+    witness: BINARY,
+};
+const TAIL_OBSOLETE = { f: { arity: 0, mode: "follows" }, F: { arity: 0, mode: "follows" }, b: SWITCH, c: SWITCH, l: SWITCH, r: SWITCH };
+const tail = {
+    key: "tail",
+    grammars: implementations(grammar({ ...values("bcns", COUNT), ...switches("fF", { mode: "follows" }), ...switches("qvz") }, {
+        bytes: val(COUNT), lines: val(COUNT), "max-unchanged-stats": val(COUNT), pid: val(COUNT), "sleep-interval": val(COUNT),
+        follow: { arity: "attached", value: LABEL, mode: "follows" },
+        ...longSwitches(["quiet", "retry", "silent", "verbose", "zero-terminated"]), ...BANNERS,
+    }), { lacks: ["-b"], obsoleteFirst: { signs: "+-", letters: TAIL_OBSOLETE } }, { lacks: ["-s", "-z", "--max-unchanged-stats", "--pid", "--sleep-interval", "--follow", "--retry", "--zero-terminated", "--help", "--version"], obsoleteFirst: { signs: "+-", letters: TAIL_OBSOLETE } }),
+    operands: { stdinBelow: 1 },
+    witness: BINARY,
+};
+const cut = {
+    key: "cut",
+    grammars: implementations(grammar({ b: val(COUNT), c: val(COUNT), d: val(DELIMITER), f: val(COUNT), ...switches("nsz") }, {
+        bytes: val(COUNT), characters: val(COUNT), delimiter: val(DELIMITER), fields: val(COUNT), "output-delimiter": val(DELIMITER),
+        ...longSwitches(["complement", "only-delimited", "zero-terminated"]), ...BANNERS,
+    }), {}, { lacks: ["-z", "--bytes", "--characters", "--delimiter", "--fields", "--output-delimiter", "--complement", "--only-delimited", "--zero-terminated", "--help", "--version"] }),
+    operands: { stdinBelow: 1 },
+    witness: BINARY,
+};
+const GREP_GRAMMAR = grammar({
+    A: val(COUNT), B: val(COUNT), C: val(COUNT), D: val(LABEL), d: val(LABEL, { selectsWhenValue: "recurse" }), e: val(PATTERN, { fillsSlot: true }), f: val(READ, { fillsSlot: true }), m: val(COUNT),
+    ...switches("0123456789abcEFGhHiIlLnoPqsUvwxyzZ"),
+    V: { arity: 0, mode: "banner" },
+    ...switches("rR", { selects: "traversal" }),
+}, {
+    "after-context": val(COUNT), "before-context": val(COUNT), "binary-files": val(LABEL), devices: val(LABEL), directories: val(LABEL, { selectsWhenValue: "recurse" }),
+    exclude: val(NAME_PATTERN), "exclude-dir": val(NAME_PATTERN), "exclude-from": val(READ), file: val(READ, { fillsSlot: true }), "group-separator": val(LABEL),
+    include: val(NAME_PATTERN), label: val(LABEL), "max-count": val(COUNT), regexp: val(PATTERN, { fillsSlot: true }),
+    color: optional(LABEL), colour: optional(LABEL), context: optional(COUNT),
+    ...longSwitches(["basic-regexp", "byte-offset", "count", "extended-regexp", "files-with-matches", "files-without-match", "fixed-strings", "ignore-case", "initial-tab", "invert-match", "line-buffered", "line-number", "line-regexp", "no-filename", "no-group-separator", "no-messages", "null", "null-data", "only-matching", "perl-regexp", "quiet", "silent", "text", "with-filename", "word-regexp"]), ...BANNERS,
+    ...longSwitches(["dereference-recursive", "recursive"], { selects: "traversal" }),
+}, { walksCwdWithoutOperand: true });
+const BSD_GREP_LACKS = ["-P", "--exclude-from", "--group-separator", "--initial-tab", "--no-group-separator", "--perl-regexp", "--dereference-recursive"];
+const GNU_MATCHER_CONFLICTS = {
+    grep: [],
+    egrep: ["-F", "-G", "-P", "--fixed-strings", "--basic-regexp", "--perl-regexp"],
+    fgrep: ["-E", "-G", "-P", "--extended-regexp", "--basic-regexp", "--perl-regexp"],
+};
+const grepRow = (key) => ({
+    key,
+    grammars: implementations(GREP_GRAMMAR, { reads: { "--context": val(COUNT) }, lacks: GNU_MATCHER_CONFLICTS[key] ?? [] }, { lacks: BSD_GREP_LACKS }),
+    operands: { positional: [PATTERN], stdinBelow: 2 },
+    traversal: { discloses: "contents" },
+    witness: BINARY,
+});
+const diff = {
+    key: "diff",
+    grammars: implementations(grammar({ C: val(COUNT), D: val(LABEL), F: val(PATTERN), I: val(PATTERN), L: val(LABEL), S: val(NAMES), U: val(COUNT), W: val(COUNT), X: val(READ), x: val(NAME_PATTERN), ...switches("abBcdeEHilnNpqstTuvwyZ"), ...switches("r", { selects: "traversal" }) }, {
+        exclude: val(NAME_PATTERN), "exclude-from": val(READ), "from-file": val(READ), "horizon-lines": val(COUNT), ifdef: val(LABEL), "ignore-matching-lines": val(PATTERN),
+        label: val(LABEL), "show-function-line": val(PATTERN), "starting-file": val(NAMES), tabsize: val(COUNT), "to-file": val(READ), width: val(COUNT),
+        color: optional(LABEL), context: optional(COUNT), unified: optional(COUNT),
+        ...longSwitches(["brief", "ed", "expand-tabs", "ignore-all-space", "ignore-blank-lines", "ignore-case", "ignore-space-change", "ignore-tab-expansion", "ignore-trailing-space", "initial-tab", "minimal", "new-file", "normal", "paginate", "report-identical-files", "rcs", "show-c-function", "side-by-side", "speed-large-files", "suppress-blank-empty", "text"]), ...BANNERS,
+        ...longSwitches(["recursive"], { selects: "traversal" }),
+    }), { reads: { "-v": { arity: 0, mode: "banner" } } }, { lacks: ["-E", "-v", "-Z", "--from-file", "--to-file", "--ignore-tab-expansion", "--ignore-trailing-space", "--suppress-blank-empty"] }),
+    operands: { stdinBelow: 2 },
+    traversal: { discloses: "contents", always: true },
+    witness: BINARY,
+};
+const cmp = {
+    key: "cmp",
+    grammars: implementations(grammar({ i: val(COUNT), n: val(COUNT), ...switches("blsv") }, { bytes: val(COUNT), "ignore-initial": val(COUNT), ...longSwitches(["print-bytes", "quiet", "silent", "verbose"]), ...BANNERS }), { reads: { "-v": { arity: 0, mode: "banner" } } }, { lacks: ["-v", "--help", "--version"] }),
+    operands: { stdinBelow: 2 },
+    witness: BINARY,
+};
+const IN_PLACE_ATTACHED = { arity: "attached", value: LABEL, selects: "edit-in-place" };
+const IN_PLACE_SUFFIX = { arity: "suffix", value: LABEL, selects: "edit-in-place" };
+const INERT = { effect: "none" };
+const SED_LONG = {
+    expression: val(text("sed"), { fillsSlot: true, ...INERT }), file: val(file("sed"), { fillsSlot: true, ...INERT }), "line-length": val(COUNT),
+    "in-place": IN_PLACE_ATTACHED,
+    "follow-symlinks": { arity: 0, writesAt: ["landing"] },
+    ...longSwitches(["debug", "null-data", "sandbox", "separate", "unbuffered"]),
+    ...longSwitches(["posix", "regexp-extended", "zero-terminated"], INERT),
+    ...longSwitches(["quiet", "silent"], { ...INERT, mode: "quiet" }),
+    ...BANNERS,
+};
+const SED_SHORT = {
+    e: val(text("sed"), { fillsSlot: true, ...INERT }), f: val(file("sed"), { fillsSlot: true, ...INERT }),
+    i: IN_PLACE_ATTACHED, I: IN_PLACE_SUFFIX,
+    n: { arity: 0, ...INERT, mode: "quiet" },
+    ...switches("s"),
+    ...switches("uzEraH", INERT),
+};
+const sed = {
+    key: "sed",
+    grammars: implementations({ dialect: "any", short: SED_SHORT, long: SED_LONG, afterFirstOperand: "either" }, { reads: { "-l": val(COUNT) }, lacks: ["-a", "-H", "-I"], afterFirstOperand: "options" }, { reads: { "-l": SWITCH, "-i": IN_PLACE_SUFFIX }, lacks: ["-s", "-z", ...Object.keys(SED_LONG).map((n) => `--${n}`)], afterFirstOperand: "operands" }),
+    operands: { positional: [text("sed")], editedInPlace: EDITED, stdinBelow: 2 },
+    witness: BINARY,
+};
+const date = {
+    key: "date",
+    grammars: implementations(grammar({ d: val(COUNT), f: val(READ), r: val(NAMES), s: val(COUNT, { effect: "writes" }), ...switches("uR") }, { date: val(COUNT), file: val(READ), reference: val(NAMES), "rfc-3339": val(COUNT), set: val(COUNT, { effect: "writes" }), "iso-8601": optional(LABEL), ...longSwitches(["debug", "rfc-822", "rfc-email", "universal", "utc"]), ...BANNERS }), {}, { reads: { "-f": val(LABEL) }, lacks: ["--file", "--reference"] }),
+    witness: BINARY,
+};
+const tar = {
+    key: "tar",
+    grammars: [grammar({ b: val(COUNT), C: val(NAMES), f: val(READ), T: val(READ, { delivers: "operands" }), X: val(READ), g: val(), ...switches("adhjJkmOpPStvwWxzZ"), ...switches("cru", { selects: "traversal" }) }, {
+            "blocking-factor": val(COUNT), directory: val(NAMES), exclude: val(NAME_PATTERN), "exclude-from": val(READ), file: val(READ), "files-from": val(READ, { delivers: "operands" }), "strip-components": val(COUNT),
+            ...longSwitches(["absolute-names", "dereference", "extract", "get", "interactive", "keep-old-files", "list", "preserve-permissions", "sparse", "to-stdout", "touch", "verbose", "verify"]), ...BANNERS,
+            ...longSwitches(["append", "create", "update"], { selects: "traversal" }),
+        })],
+    traversal: { discloses: "contents", keyWordLetters: "cru" },
+    witness: BINARY,
+};
+const find = {
+    key: "find",
+    grammars: implementations(grammar({ D: val(LABEL), O: val(COUNT), f: val(NAMES), ...switches("HLPdsx") }, BANNERS, {
+        afterFirstOperand: "options",
+        dashWords: {
+            amin: val(COUNT), anewer: val(NAMES), atime: val(COUNT), cmin: val(COUNT), cnewer: val(NAMES), context: val(LABEL),
+            ctime: val(COUNT), fstype: val(LABEL), gid: val(COUNT), group: val(LABEL), ilname: val(NAMES), iname: val(NAME_PATTERN),
+            inum: val(COUNT), ipath: val(NAMES), iregex: val(NAME_PATTERN), iwholename: val(NAMES), links: val(COUNT),
+            lname: val(NAMES), maxdepth: val(COUNT), mindepth: val(COUNT), mmin: val(COUNT), mtime: val(COUNT), name: val(NAME_PATTERN),
+            newer: val(NAMES), newerat: val(NAMES), neweraa: val(NAMES), neweram: val(NAMES), newerac: val(NAMES),
+            newerct: val(NAMES), newerca: val(NAMES), newercm: val(NAMES), newercc: val(NAMES),
+            newermt: val(NAMES), newerma: val(NAMES), newermm: val(NAMES), newermc: val(NAMES),
+            newerBt: val(NAMES), newerBa: val(NAMES), newerBm: val(NAMES), newerBc: val(NAMES),
+            path: val(NAMES), perm: val(LABEL), printf: val(LABEL), regex: val(NAME_PATTERN), regextype: val(LABEL),
+            samefile: val(NAMES), size: val(COUNT), type: val(LABEL), uid: val(COUNT), used: val(COUNT), user: val(LABEL),
+            wholename: val(NAMES), xtype: val(LABEL),
+            delete: { arity: 0, effect: "writes" },
+            ...longSwitches(["exec", "execdir", "ok", "okdir"], { effect: "executes" }),
+            fprint: val(WRITE), fprint0: val(WRITE), fls: val(WRITE), fprintf: val(WRITE),
+            "files0-from": val(READ, { delivers: "operands" }),
+            ...longSwitches([
+                "and", "daystart", "depth", "empty", "executable", "false", "follow", "ignore_readdir_race", "mount", "noignore_readdir_race", "noleaf", "not", "nogroup",
+                "nouser", "or", "print", "print0", "prune", "quit", "readable", "true", "writable", "xdev",
+            ]),
+            ...BANNERS,
+        },
+    }), { lacks: ["-f", "-s", "-x"], reads: { "-samefile": val(READ) } }, { lacks: ["-D", "-O", "--help", "--version", "-context", "-printf", "-regextype", "-used", "-xtype", "-fprint", "-fprint0", "-fls", "-fprintf", "-files0-from", "-daystart", "-executable", "-readable", "-writable", "-help", "-version"] }),
+    operands: { dash: "file" },
+    traversal: { discloses: "names", always: true },
+    witness: BINARY,
+};
+const curl = {
+    key: "curl",
+    grammars: [grammar({
+            A: val(LABEL), b: val(INDIRECT), C: val(COUNT), c: val(WRITE), D: val(WRITE), d: val(INDIRECT), E: val(READ), e: val(LABEL),
+            F: val(FORM), H: val(HEADER), K: val(READ), m: val(COUNT), o: val(WRITE), P: val(LABEL), Q: val(LABEL), r: val(COUNT),
+            T: val(UPLOAD), t: val(LABEL), U: val(LABEL), u: val(LABEL), w: val(INDIRECT), X: val(LABEL), x: val(LABEL), Y: val(COUNT),
+            y: val(COUNT), z: val(READ), g: { arity: 0, literalValues: true },
+            ...switches("#012346aBfGiIjJklLnNOpqRsSvZ"),
+            ...switches("hMV", { mode: "banner" }),
+        }, {
+            cacert: val(READ), capath: val(READ), cert: val(READ), config: val(READ), "connect-timeout": val(COUNT), cookie: val(INDIRECT), "cookie-jar": val(WRITE),
+            data: val(INDIRECT), "data-ascii": val(INDIRECT), "data-binary": val(INDIRECT), "data-raw": val(LABEL), "data-urlencode": val(FORM), "dump-header": val(WRITE),
+            form: val(FORM), "form-string": val(LABEL), header: val(HEADER), key: val(READ), "max-time": val(COUNT), "netrc-file": val(READ), output: val(WRITE),
+            proxy: val(LABEL), range: val(COUNT), referer: val(LABEL), request: val(LABEL), resolve: val(LABEL), trace: val(WRITE), "time-cond": val(READ),
+            "trace-ascii": val(WRITE), "upload-file": val(UPLOAD), url: val(URL), user: val(LABEL), "user-agent": val(LABEL), "write-out": val(INDIRECT),
+            ...longSwitches(["append", "compressed", "disable", "fail", "get", "head", "include", "insecure", "junk-session-cookies", "list-only", "location", "netrc", "next", "no-buffer", "parallel", "proxytunnel", "remote-header-name", "remote-name", "remote-time", "show-error", "silent", "use-ascii", "verbose"]), ...BANNERS,
+            manual: { arity: 0, mode: "banner" }, globoff: { arity: 0, literalValues: true },
+        })],
+    operands: { rest: URL },
+    witness: BINARY,
+};
+const ls = {
+    key: "ls",
+    grammars: implementations(grammar(switches("R", { selects: "traversal" }), longSwitches(["recursive"], { selects: "traversal" })), {}, { lacks: ["--recursive"] }),
+    operands: { dash: "file", rest: NAMES },
+    traversal: { discloses: "names" },
+    witness: BINARY,
+};
+const walker = (key, discloses, dashFile) => ({
+    key,
+    grammars: discloses === "contents" ? [grammar({}, {}, { walksCwdWithoutOperand: true })] : [],
+    ...(dashFile ? { operands: { dash: "file", ...(discloses === "names" ? { rest: NAMES } : {}) } } : {}),
+    traversal: { discloses, always: true },
+    witness: BINARY,
+});
+const BANNER_LONGS = ["--version", "--help", "--usage", "-version", "-help"];
+function interpreterGrammar(language, g) {
+    const short = {};
+    const long = {};
+    const dashWords = {};
+    const put = (spelling, spec) => {
+        if (spelling.startsWith("--"))
+            long[spelling.slice(2)] = spec;
+        else
+            dashWords[spelling.slice(1)] = spec;
+    };
+    for (const l of g.plain ?? "")
+        short[l] = SWITCH;
+    for (const l of g.interactive ?? "")
+        short[l] = { arity: 0, mode: "interactive" };
+    for (const l of g.banner ?? "")
+        short[l] = { arity: 0, mode: "banner" };
+    for (const l of g.separated ?? "")
+        short[l] = val();
+    for (const l of g.attached ?? "")
+        short[l] = { arity: "attached", ...((g.banner ?? "").includes(l) ? { mode: "banner" } : {}) };
+    for (const l of g.file ?? "")
+        short[l] = val(file(language), { fillsSlot: true, ...(g.fileEndsOptions === true ? { endsOptions: true } : {}) });
+    for (const l of g.module ?? "")
+        short[l] = { arity: 1, mode: "names-program", fillsSlot: true, ...(g.fileEndsOptions === true ? { endsOptions: true } : {}) };
+    for (const l of g.assignment ?? "")
+        short[l] = val(ASSIGNMENT);
+    for (const l of g.modules ?? "")
+        short[l] = val(file(language));
+    for (const l of g.text ?? "")
+        short[l] = val(text(language), { fillsSlot: true });
+    for (const s of g.longPlain ?? [])
+        put(s, SWITCH);
+    for (const s of g.longValue ?? [])
+        put(s, val());
+    for (const s of g.longAttached ?? [])
+        put(s, optional());
+    for (const s of BANNER_LONGS)
+        put(s, { arity: 0, mode: "banner" });
+    for (const s of g.longSupplemental ?? [])
+        put(s, val(READ));
+    for (const s of g.longModules ?? [])
+        put(s, val(file(language)));
+    for (const s of g.longNamesProgram ?? [])
+        put(s, { arity: 0, mode: "names-program" });
+    for (const s of g.longFile ?? [])
+        put(s, val(file(language), { fillsSlot: true, ...(g.fileEndsOptions === true ? { endsOptions: true } : {}) }));
+    for (const s of g.longText ?? [])
+        put(s, val(text(language), { fillsSlot: true }));
+    return { dialect: "any", short, long, dashWords, afterFirstOperand: "either" };
+}
+const interpreter = (key, language, g, program, stdinWhenUnnamed, extra = {}, departures) => ({
+    key,
+    versioned: true,
+    grammars: departures === undefined ? [interpreterGrammar(language, g)] : implementations(interpreterGrammar(language, g), departures.gnu, departures.bsd),
+    ...(program === "none" ? {} : { operands: { positional: program === "file" ? [file(language)] : program === "text" ? [text(language)] : [undefined, text(language)] } }),
+    delivery: { stdinWhenUnnamed },
+    witness: BINARY,
+    ...extra,
+});
+const PERL = { text: "eEmM", separated: "I", attached: "iCFxDV", plain: "nplawcsStTUWX", banner: "vVh" };
+const RUBY = { text: "e", separated: "IrECKT", attached: "F", plain: "nplawcsSU", banner: "vh" };
+const PYTHON = { text: "c", module: "m", separated: "WXQ", plain: "uBEIsSqbdvxOtR", banner: "Vh?", interactive: "i", fileEndsOptions: true };
+const NODE = {
+    longText: ["--eval", "--print"], text: "ep",
+    longModules: ["--import", "--loader", "--experimental-loader", "--require"],
+    longValue: ["--env-file", "--conditions"],
+    longAttached: ["--max-old-space-size"],
+    longNamesProgram: ["--test"],
+    longPlain: ["--inspect", "--inspect-brk", "--no-warnings", "--trace-warnings", "--watch", "--enable-source-maps", "--experimental-modules", "--no-deprecation", "--check"],
+    modules: "r", plain: "c", banner: "vh", interactive: "i",
+};
+const PHP = { longText: ["--run", "--process-begin", "--process-code", "--process-end"], text: "rRBE", file: "fF", separated: "dcz", plain: "nqswl", banner: "vhi", interactive: "a" };
+const LUA = { text: "e", separated: "l", banner: "vh", interactive: "i" };
+const EXPECT = { text: "c", separated: "Db", plain: "dN", banner: "vh", interactive: "i" };
+const AWK = { longText: ["--source"], text: "e", longFile: ["--file", "--exec"], file: "fE", separated: "F", assignment: "v", banner: "V" };
+const POSIX_AWK = { file: "f", separated: "F", assignment: "v" };
+const AWK_IMPLEMENTATIONS = { gnu: {}, bsd: { lacks: ["-E", "--file", "--exec", "--source"] } };
+const JQ = { longFile: ["--from-file"], file: "f", separated: "L", plain: "nrjcsSaCMRe", banner: "h" };
+const BC = { longText: ["--expression"], text: "e", plain: "lqsw", banner: "vh", interactive: "i" };
+const DC = { longText: ["--expression"], text: "e", longFile: ["--file"], file: "f", banner: "hV" };
+const SQLITE = { longText: ["-cmd"], longSupplemental: ["-init"] };
+const PSQL = { longText: ["--command"], text: "c", longFile: ["--file"], file: "f", separated: "hpUdoF", plain: "aeEqtxXwW", banner: "lV?" };
+const OSASCRIPT = { text: "e", separated: "ls", plain: "i", banner: "h" };
+const RSCRIPT = { text: "e", banner: "h" };
+const JULIA = { longText: ["--eval", "--print"], text: "eE", separated: "JLp", plain: "q", banner: "vh", interactive: "i" };
+const GHCI = { text: "e", separated: "io" };
+const GROOVY = { text: "e", separated: "Dcl", plain: "n", banner: "vh", interactive: "i" };
+const BUN = { longText: ["--eval", "--print"], text: "ep", modules: "r", banner: "vh" };
+const launcher = (key, spec = {}, g, extra = {}) => ({
+    key,
+    grammars: g === undefined ? [] : [g],
+    launcher: spec ?? {},
+    witness: BINARY,
+    ...extra,
+});
+const PRIVILEGED = { declared: "runs the program as another user or in another root: the gate does not acquire privileges" };
+const LINUX_NAMESPACE = { declared: "a Linux namespace / scheduling wrapper that needs privileges or a kernel feature the gate host may not have" };
+const SHELL_TEXT_LAUNCHER = { declared: "hands its operands to a shell as text: the row reads no program word whose opens the gate could predict" };
+const WORKDIR = { kind: "path", effect: "names", base: "working-directory" };
+const ROOTDIR = { kind: "path", effect: "names", base: "root" };
+const PROGRAM_SEARCH = { kind: "path", effect: "names", base: "program-search" };
+export const DURATION_SPELLING = /^\d+(?:\.\d+)?[smhd]?$/;
+const BANNER = { arity: 0, mode: "banner" };
+const launcherSwitches = (spellings, banners) => {
+    const spec = (x) => (x === "--help" || x === "--version" || banners.includes(x) ? BANNER : SWITCH);
+    return {
+        short: Object.fromEntries(spellings.filter((x) => !x.startsWith("--")).map((x) => [x.slice(1), spec(x)])),
+        long: Object.fromEntries(spellings.filter((x) => x.startsWith("--")).map((x) => [x.slice(2), spec(x)])),
+    };
+};
+const launcherGrammar = (g, extra = {}) => {
+    const sw = launcherSwitches(g.switches ?? [], g.banners ?? []);
+    const short = { ...sw.short };
+    const long = { ...sw.long };
+    const put = (spelling, spec) => { if (spelling.startsWith("--"))
+        long[spelling.slice(2)] = spec;
+    else
+        short[spelling.slice(1)] = spec; };
+    for (const [spelling, role] of Object.entries(g.values ?? {}))
+        put(spelling, val(role));
+    for (const [spelling, role] of Object.entries(g.optional ?? {}))
+        put(spelling, optional(role));
+    for (const spelling of g.shellText ?? [])
+        put(spelling, val(SHELL_TEXT));
+    for (const spelling of g.shells ?? [])
+        put(spelling, { arity: 0, mode: "interactive" });
+    return { dialect: "any", short, long, afterFirstOperand: "either", ...extra };
+};
+const launchers = [
+    { key: "env", grammars: implementations(launcherGrammar({
+            switches: ["-i", "-v", "--ignore-environment", "--debug", "--list-signal-handling", "--help", "--version"],
+            values: { "-u": LABEL, "--unset": LABEL, "-C": WORKDIR, "--chdir": WORKDIR, "-a": LABEL, "--argv0": LABEL, "-P": PROGRAM_SEARCH },
+            optional: { "--default-signal": LABEL, "--ignore-signal": LABEL },
+            shellText: ["-S", "--split-string"],
+        }), { lacks: ["-P"] }, { lacks: ["-a", "--ignore-environment", "--debug", "--list-signal-handling", "--help", "--version", "--unset", "--chdir", "--argv0", "--default-signal", "--ignore-signal", "--split-string"] }), launcher: { assignmentOperands: true, bareDash: true }, witness: BINARY },
+    launcher("command", {}, grammar({ p: SWITCH })),
+    launcher("builtin"),
+    launcher("exec", {}, launcherGrammar({ switches: ["-c", "-l"], values: { "-a": LABEL } })),
+    launcher("noglob", {}, undefined, { witness: { declared: "a zsh precommand modifier" } }),
+    launcher("nocorrect", {}, undefined, { witness: { declared: "a zsh precommand modifier" } }),
+    { key: "xargs", grammars: implementations(launcherGrammar({
+            switches: ["-0", "-r", "-t", "-x", "-p", "-o", "--null", "--no-run-if-empty", "--verbose", "--exit", "--interactive", "--open-tty", "--show-limits", "--help", "--version"],
+            values: { "-n": COUNT, "-L": COUNT, "-P": COUNT, "-I": LABEL, "-d": DELIMITER, "-s": COUNT, "-E": LABEL, "--max-args": COUNT, "--max-procs": COUNT, "--delimiter": DELIMITER, "--max-chars": COUNT, "--process-slot-var": LABEL },
+            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({
+        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 }),
+    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 }),
+    launcher("chroot", { requiredOperands: 1, whenNoProgram: "shell" }, undefined, { witness: PRIVILEGED }),
+    launcher("setpriv", {}, undefined, { witness: PRIVILEGED }),
+    launcher("nohup", {}, grammar({}, BANNERS)),
+    { key: "nice", grammars: implementations(grammar({ n: val(COUNT) }, { adjustment: val(COUNT), ...BANNERS }), {}, { lacks: ["--adjustment", "--help", "--version"] }), launcher: { negativeIntegerIsOwnArgument: true }, witness: BINARY },
+    launcher("ionice", {}, launcherGrammar({
+        switches: ["-t", "--ignore", "-h", "--help", "-V", "--version"],
+        banners: ["-h", "-V"],
+        values: { "-c": LABEL, "-n": COUNT, "-p": COUNT, "-P": COUNT, "-u": COUNT, "--class": LABEL, "--classdata": COUNT, "--pid": COUNT, "--pgid": COUNT, "--uid": COUNT },
+    }), { witness: LINUX_NAMESPACE }),
+    launcher("chrt", { requiredOperands: 1, requiredOperandSpelling: /^\d+$/ }, launcherGrammar({
+        switches: ["-b", "-f", "-i", "-o", "-r", "-d", "-m", "-a", "-R", "-v", "--batch", "--fifo", "--idle", "--other", "--rr", "--deadline", "--max", "--all-tasks", "--reset-on-fork", "--verbose", "--help", "--version"],
+        values: { "-p": COUNT, "--pid": COUNT, "-T": COUNT, "-P": COUNT, "-D": COUNT, "--sched-runtime": COUNT, "--sched-period": COUNT, "--sched-deadline": COUNT },
+    }), { witness: LINUX_NAMESPACE }),
+    launcher("taskset", { requiredOperands: 1, requiredOperandSpelling: /^(?:0x)?[\da-f]+$|^[\d,:-]+$/i }, launcherGrammar({ switches: ["-a", "-p", "-c", "--all-tasks", "--pid", "--cpu-list", "--help", "--version"] }), { witness: LINUX_NAMESPACE }),
+    { 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("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"],
+        values: { "-w": COUNT, "-E": COUNT, "--timeout": COUNT, "--wait": COUNT, "--conflict-exit-code": COUNT },
+        shellText: ["-c", "--command"],
+    }), { operands: { rest: CREATED } }),
+    launcher("unshare", { whenNoProgram: "shell" }, launcherGrammar({
+        switches: ["-m", "-u", "-i", "-n", "-p", "-U", "-C", "-T", "-f", "-r", "-c", "--mount", "--uts", "--ipc", "--net", "--pid", "--user", "--cgroup", "--time", "--fork", "--map-root-user", "--map-current-user", "--kill-child", "--mount-proc", "--keep-caps", "--help", "--version"],
+        values: { "-R": ROOTDIR, "-w": WORKDIR, "-S": LABEL, "-G": LABEL, "--setuid": LABEL, "--setgid": LABEL, "--root": ROOTDIR, "--wd": WORKDIR, "--propagation": LABEL, "--setgroups": LABEL, "--monotonic": COUNT, "--boottime": COUNT, "--map-user": LABEL, "--map-group": LABEL },
+    }), { witness: LINUX_NAMESPACE }),
+    launcher("nsenter", { whenNoProgram: "shell" }, launcherGrammar({
+        switches: ["-a", "-m", "-u", "-i", "-n", "-p", "-U", "-C", "-T", "-F", "-Z", "--all", "--mount", "--uts", "--ipc", "--net", "--pid", "--user", "--cgroup", "--time", "--no-fork", "--preserve-credentials", "--help", "--version"],
+        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("numactl", {}, undefined, { witness: LINUX_NAMESPACE }),
+    launcher("prlimit", {}, undefined, { witness: LINUX_NAMESPACE }),
+    launcher("systemd-run", {}, undefined, { witness: { declared: "hands the program to a service manager" } }),
+    launcher("strace", {}, launcherGrammar({
+        switches: ["-f", "-c", "-C", "-d", "-D", "-h", "-i", "-k", "-q", "-r", "-t", "-T", "-v", "-V", "-w", "-x", "-y", "-z", "-Z", "-F", "--follow-forks", "--summary-only", "--summary", "--debug", "--help", "--version"],
+        banners: ["-h", "-V"],
+        values: {
+            "-e": LABEL, "-o": WRITE, "-p": COUNT, "-s": COUNT, "-E": ASSIGNMENT, "-P": NAMES, "-S": LABEL, "-a": COUNT, "-b": LABEL, "-I": COUNT, "-u": LABEL, "-X": LABEL, "-O": COUNT, "-U": LABEL,
+            "--output": WRITE, "--trace": LABEL, "--expr": LABEL, "--attach": COUNT, "--string-limit": COUNT, "--env": ASSIGNMENT, "--trace-path": NAMES, "--columns": COUNT, "--user": LABEL, "--interruptible": COUNT,
+            "--detach-on": LABEL, "--const-print-style": LABEL, "--summary-sort-by": LABEL, "--summary-syscall-overhead": COUNT, "--summary-columns": LABEL,
+        },
+    }), { witness: LINUX_NAMESPACE }),
+    launcher("ltrace", {}, launcherGrammar({
+        switches: ["-c", "-C", "-f", "-i", "-L", "-r", "-S", "-t", "-T", "-V", "--demangle", "--help", "--version"],
+        banners: ["-V"],
+        values: { "-a": COUNT, "-A": COUNT, "-e": LABEL, "-l": NAMES, "-n": COUNT, "-o": WRITE, "-p": COUNT, "-s": COUNT, "-u": LABEL, "-x": LABEL, "-D": LABEL, "-F": READ, "-w": COUNT, "--align": COUNT, "--config": READ, "--debug": LABEL, "--indent": COUNT, "--library": NAMES, "--output": WRITE, "--string-max": COUNT, "--where": COUNT },
+    }), { witness: LINUX_NAMESPACE }),
+    launcher("valgrind"),
+    launcher("firejail", { whenNoProgram: "shell" }, undefined, { witness: LINUX_NAMESPACE }),
+    launcher("bwrap", {}, undefined, { witness: LINUX_NAMESPACE }),
+];
+function gitSubcommand(plain, attached, valued, longValued) {
+    return { grammar: grammar({ ...switches(plain), ...Object.fromEntries([...attached].map((l) => [l, optional()])), ...Object.fromEntries([...valued].map((l) => [l, l === "m" ? val(MESSAGE) : val()])) }, Object.fromEntries(longValued.map((n) => [n, n === "message" ? val(MESSAGE) : val()]))) };
+}
+const GIT_GREP = {
+    grammar: grammar({
+        e: val(PATTERN, { fillsSlot: true }), f: val(READ, { fillsSlot: true }), A: val(COUNT), B: val(COUNT), C: val(COUNT), m: val(COUNT),
+        O: { arity: "attached", value: LABEL, effect: "executes" },
+        ...switches("aEFGHIPchilnoqrsvwzL"),
+    }, {
+        regexp: val(PATTERN, { fillsSlot: true }), file: val(READ, { fillsSlot: true }), "after-context": val(COUNT), "before-context": val(COUNT), context: val(COUNT),
+        "max-count": val(COUNT), "max-depth": val(COUNT), threads: val(COUNT), "open-files-in-pager": { arity: "attached", value: LABEL, effect: "executes" },
+        ...longSwitches(["cached", "untracked", "no-index", "recurse-submodules", "text", "ignore-case", "word-regexp", "invert-match", "line-number", "column", "files-with-matches", "files-without-match", "count", "null", "break", "heading", "show-function", "function-context", "extended-regexp", "basic-regexp", "fixed-strings", "perl-regexp", "all-match", "quiet", "full-name"]),
+    }, { walksCwdWithoutOperand: true }),
+    operands: { positional: [PATTERN] },
+    traversal: { discloses: "contents", always: true },
+};
+const gitObjectSubcommand = (short = {}, long = {}) => ({ grammar: grammar(short, long), operands: { rest: OBJECT_PATH } });
+const git = {
+    key: "git",
+    grammars: [grammar({ p: SWITCH, P: SWITCH, C: val(WORKDIR), c: val() }, {
+            ...longSwitches(["paginate", "no-pager", "bare", "no-replace-objects", "literal-pathspecs", "glob-pathspecs", "noglob-pathspecs", "icase-pathspecs", "no-optional-locks"]),
+            "git-dir": val(WORKDIR), "work-tree": val(WORKDIR), namespace: val(), "config-env": val(), "super-prefix": val(),
+        })],
+    subcommands: {
+        commit: gitSubcommand("apsnvqeioz", "Su", "mFCct", ["message", "file", "template", "pathspec-from-file", "author", "date", "cleanup", "fixup", "squash", "trailer", "reuse-message", "reedit-message"]),
+        tag: gitSubcommand("asfdvle", "n", "mFu", ["message", "file", "local-user", "cleanup", "trailer", "sort", "format", "contains", "no-contains", "points-at", "merged", "no-merged"]),
+        merge: gitSubcommand("nqve", "S", "mFsX", ["message", "file", "strategy", "strategy-option", "into-name", "cleanup"]),
+        stash: gitSubcommand("pkuaqS", "", "m", ["message", "pathspec-from-file"]),
+        grep: GIT_GREP,
+        show: gitObjectSubcommand(),
+        "cat-file": gitObjectSubcommand(switches("ptsep")),
+        archive: gitObjectSubcommand({ o: val(WRITE) }, { output: val(WRITE), format: val(LABEL), prefix: val(LABEL), remote: val(LABEL) }),
+    },
+    witness: BINARY,
+};
+const noPath = (key, rest, extra = {}) => ({ key, grammars: [], operands: { rest }, witness: BINARY, ...extra });
+const BUILTIN_ONLY = { declared: "a shell builtin with no binary of its own on every host: its words are read by the shell" };
+const noPathRows = [
+    noPath("pwd", LABEL, { builtin: "inert" }), noPath("echo", LABEL, { builtin: "inert", grammars: [grammar(switches("neE"), {}, { afterFirstOperand: "operands" })], prints: "words" }), noPath("printf", LABEL, { grammars: [grammar({ v: val(BINDS_NAME) })], prints: "format" }), noPath("whoami", LABEL), noPath("uname", LABEL),
+    noPath("which", LABEL), noPath("basename", LABEL), noPath("dirname", LABEL),
+    { key: "tr", grammars: [], operands: { rest: LABEL, stdinBelow: "always" }, witness: BINARY },
+    noPath("cal", COUNT), noPath("uptime", LABEL), noPath("id", LABEL), noPath("groups", LABEL), noPath("nproc", LABEL), noPath("locale", LABEL),
+    noPath("free", LABEL, { grammars: [grammar({ s: val(COUNT, { mode: "repeats" }) }, { seconds: val(COUNT, { mode: "repeats" }) })] }),
+    noPath("true", LABEL, { builtin: "inert" }), noPath("false", LABEL, { builtin: "inert" }), noPath("seq", COUNT), noPath("expr", LABEL), noPath("type", LABEL, { witness: BUILTIN_ONLY }), noPath("sleep", COUNT),
+    { key: "test", grammars: [grammar({ v: val(BINDS_NAME) })], operands: { rest: ENTRY_PROBE, evaluates: true }, witness: BINARY },
+    { key: "[", grammars: [grammar({ v: val(BINDS_NAME) })], operands: { rest: ENTRY_PROBE, evaluates: true }, witness: BINARY },
+];
+const DECLARE_GRAMMAR = grammar({
+    i: { arity: 0, assigns: "integer" }, n: { arity: 0, assigns: "reference" }, r: { arity: 0, assigns: "frozen" },
+    ...switches("aAluc", { assigns: "transformed" }), ...switches("pfFgI", { assigns: "unsettled" }), ...switches("tx"),
+}, {}, { plusShort: { ...switches("afFirtx"), p: { arity: 0, assigns: "unsettled" } } });
+const EXPORT_GRAMMAR = grammar({ ...switches("np"), ...switches("aAf", { assigns: "unsettled" }) });
+const declaration = (key, g, rest = BINDS_NAME, assigns) => ({ key, grammars: [g], operands: { rest }, builtin: "declaration", ...(assigns !== undefined ? { assigns } : {}), witness: BUILTIN_ONLY });
+const nameBinders = [
+    { key: "read", grammars: [grammar({ a: val(BINDS_NAME), p: val(LABEL), d: val(DELIMITER), i: val(LABEL), t: val(COUNT), n: val(COUNT), N: val(COUNT), u: val(COUNT), ...switches("ers") })], operands: { rest: BINDS_NAME }, witness: BUILTIN_ONLY },
+    { key: "getopts", grammars: [], operands: { positional: [LABEL, { kind: "binds-name", asWritten: true }], rest: LABEL }, witness: BUILTIN_ONLY },
+    { key: "wait", grammars: [grammar({ ...switches("fn"), p: val(BINDS_NAME) })], operands: { rest: LABEL }, witness: BUILTIN_ONLY },
+    { key: "unset", grammars: [], operands: { rest: BINDS_NAME }, witness: BUILTIN_ONLY },
+    { key: "let", grammars: [], operands: { rest: { kind: "program-text", language: "arithmetic" } }, witness: BUILTIN_ONLY },
+];
+const assignmentNotPaths = (key) => ({ key, grammars: [], operands: { assignmentArguments: "not-paths" }, witness: { declared: "a build tool / container client: what a NAME=value argument means is the build's or the container's" } });
+const CONTAINER_RUN = {
+    grammar: grammar({ v: val(VOLUME), e: val(ASSIGNMENT), w: val(LABEL), u: val(LABEL), p: val(LABEL), h: val(LABEL), l: val(LABEL), m: val(LABEL), ...switches("itdPq") }, {
+        volume: val(VOLUME), mount: val(MOUNT), env: val(ASSIGNMENT), "env-file": val(READ), "label-file": val(READ),
+        name: val(LABEL), network: val(LABEL), entrypoint: val(LABEL), user: val(LABEL), workdir: val(LABEL), publish: val(LABEL), platform: val(LABEL), hostname: val(LABEL), label: val(LABEL),
+        ...longSwitches(["rm", "detach", "interactive", "tty", "privileged", "init", "read-only"]),
+    }, { afterFirstOperand: "operands" }),
+    operands: { assignmentArguments: "not-paths" },
+};
+const containerRuntime = (key) => ({
+    key,
+    grammars: [grammar({ H: val(LABEL), c: val(LABEL), l: val(LABEL), D: SWITCH }, { host: val(LABEL), context: val(LABEL), "log-level": val(LABEL), config: val(READ), tlscacert: val(READ), tlscert: val(READ), tlskey: val(READ), ...longSwitches(["debug", "tls", "tlsverify"]) })],
+    operands: { assignmentArguments: "not-paths" },
+    subcommands: { run: CONTAINER_RUN, create: CONTAINER_RUN },
+    witness: { declared: "a build tool / container client: what a NAME=value argument means is the build's or the container's" },
+});
+const shellRow = (key, textAt, witness = BINARY, grammars = [], stdin) => ({ key, grammars, reentry: { kind: "shell", text: textAt, ...(stdin !== undefined ? { stdin } : {}) }, witness });
+const shellGrammar = (plain, valued, long = {}) => grammar({ ...switches(plain), ...(plain.includes("s") ? switches("s", { mode: "interactive" }) : {}), ...values(valued, LABEL), c: val(SHELL_TEXT) }, long);
+const posixShellGrammar = (plain, valued) => ({ ...shellGrammar(plain, valued), plusOptions: true });
+const POSIX_SHELL = posixShellGrammar("abCefhimnsuvx", "o");
+const SHELL_GRAMMARS = {
+    sh: posixShellGrammar("abefimnsuvxCEI", "o"),
+    bash: posixShellGrammar("abefhiklmnprstuvxBCDEHPT", "oO"),
+    dash: posixShellGrammar("abefilmnsuvxCEIV", "o"),
+    ksh: posixShellGrammar("abefhiklmnprstuvxBCEGH", "o"),
+    zsh: posixShellGrammar("adefghiklmnprstuvwxyBCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", "o"),
+    csh: shellGrammar("defilmnqstvxFVX", ""),
+    tcsh: shellGrammar("defilmnqstvxFVX", ""),
+    fish: grammar({ ...switches("ilnNP"), ...switches("hv", { mode: "banner" }), c: val(SHELL_TEXT), C: val(), d: val(LABEL), f: val(LABEL), o: val(WRITE), p: val(WRITE) }, { command: val(SHELL_TEXT), ...BANNERS }),
+    ash: POSIX_SHELL, mksh: POSIX_SHELL, pdksh: POSIX_SHELL, yash: POSIX_SHELL,
+};
+const SHELLS = ["sh", "bash", "zsh", "dash", "ksh", "fish", "ash", "mksh", "yash", "pdksh", "csh", "tcsh"];
+const codeBodyRows = [
+    { key: "trap", grammars: [grammar(switches("lpP"))], body: "first-operand", witness: BINARY },
+    { key: "alias", grammars: [], body: "assignment-values", witness: BINARY },
+    { key: "mapfile", grammars: [grammar({ ...switches("t"), ...values("dunOcs"), C: val(SHELL_TEXT) })], operands: { rest: BINDS_NAME }, body: "option-values", witness: BINARY },
+    { key: "readarray", grammars: [grammar({ ...switches("t"), ...values("dunOcs"), C: val(SHELL_TEXT) })], operands: { rest: BINDS_NAME }, body: "option-values", witness: BINARY },
+    { key: "compgen", grammars: [grammar({ ...switches("abcdefgjksuv"), ...values("oAGWPSXV"), F: val(COMMAND), C: val(SHELL_TEXT) })], body: "option-values", witness: BINARY },
+    { key: "complete", grammars: [grammar({ ...switches("abcdefgjksuvDEIpr"), ...values("oAGWPSXV"), F: val(COMMAND), C: val(SHELL_TEXT) })], body: "option-values", witness: { declared: "a completion spec runs its command only when a person asks for a completion interactively" } },
+];
+const copyGrammars = (bsdSuffixSwitch) => implementations(grammar({ S: val(LABEL, { effect: "writes" }), t: val(DESTINATION, { fillsLast: true }) }, { "target-directory": val(DESTINATION, { fillsLast: true }), suffix: val(LABEL, { effect: "writes" }), "no-preserve": val(LABEL), sparse: val(LABEL) }), { afterFirstOperand: "options" }, { ...(bsdSuffixSwitch ? { reads: { "-S": SWITCH } } : {}), lacks: [...(bsdSuffixSwitch ? [] : ["-S"]), "-t", "--target-directory", "--suffix", "--no-preserve", "--sparse"], afterFirstOperand: "operands" });
+const writerRows = [
+    { key: "mkdir", grammars: [], operands: { rest: CREATED, dash: "file" }, witness: BINARY },
+    { key: "touch", grammars: implementations(grammar({ h: { arity: 0, writesAt: ["landing", "entry"] } }, { "no-dereference": { arity: 0, writesAt: ["landing", "entry"] } }), {}, { lacks: ["--no-dereference"] }), operands: { rest: TOUCHED, dash: "file" }, witness: BINARY },
+    { key: "rm", grammars: implementations(grammar({ ...switches("rR", { selects: "traversal" }), f: { arity: 0, mode: "forced" } }, { ...longSwitches(["recursive"], { selects: "traversal" }), force: { arity: 0, mode: "forced" } }), {}, { lacks: ["--recursive", "--force"] }), operands: { rest: REMOVED, dash: "file" }, witness: BINARY },
+    { key: "rmdir", grammars: implementations(grammar({ p: { arity: 0, effect: "writes" } }, { parents: { arity: 0, effect: "writes" } }), {}, { lacks: ["--parents"] }), operands: { rest: REMOVED, dash: "file" }, witness: BINARY },
+    { key: "tee", grammars: [], operands: { rest: WRITE, dash: "file" }, witness: BINARY },
+    { key: "cp", grammars: copyGrammars(true), operands: { rest: COPY_SOURCE, last: DESTINATION, dash: "file" }, witness: BINARY },
+    { key: "mv", grammars: copyGrammars(false), operands: { rest: MOVE_SOURCE, last: DESTINATION, dash: "file" }, witness: BINARY },
+];
+const stdinReaders = [
+    { key: "cat", grammars: [], operands: { stdinBelow: 1 }, witness: BINARY },
+    { key: "wc", grammars: [], operands: { stdinBelow: 1 }, witness: BINARY },
+    { key: "comm", grammars: [], operands: { stdinBelow: 2 }, witness: BINARY },
+];
+const SYNTAX = { declared: "shell syntax, not a program: read by the lexer" };
+const block = (key, g = []) => ({ key, grammars: g, syntax: "block", witness: SYNTAX });
+export const PROGRAM_ROWS = [
+    head, tail, cut, grepRow("grep"), grepRow("egrep"), grepRow("fgrep"), diff, cmp, sed, date, tar, find, curl,
+    ls, walker("du", "names", true), walker("rg", "contents", false), walker("tree", "names", true), walker("ag", "contents", false), walker("ack", "contents", false),
+    interpreter("perl", "perl", PERL, "file", true),
+    interpreter("ruby", "ruby", RUBY, "file", true),
+    interpreter("python", "python", PYTHON, "file", true, { modules: { timeit: text("python") } }),
+    interpreter("node", "javascript", NODE, "file", true),
+    interpreter("nodejs", "javascript", NODE, "file", true),
+    interpreter("php", "php", PHP, "file", true),
+    interpreter("lua", "lua", LUA, "file", true),
+    interpreter("luajit", "lua", LUA, "file", true),
+    interpreter("tclsh", "tcl", {}, "file", true),
+    interpreter("wish", "tcl", {}, "file", true, { witness: { declared: "a windowing shell: it opens a display before it reads its script, and the gate host has none" } }),
+    interpreter("expect", "expect", EXPECT, "file", true),
+    interpreter("awk", "awk", AWK, "text", false, {}, AWK_IMPLEMENTATIONS),
+    interpreter("gawk", "awk", AWK, "text", false),
+    interpreter("mawk", "awk", POSIX_AWK, "text", false),
+    interpreter("nawk", "awk", POSIX_AWK, "text", false),
+    interpreter("jq", "jq", JQ, "text", false),
+    interpreter("bc", "bc", BC, "none", true),
+    interpreter("dc", "dc", DC, "none", true),
+    interpreter("sqlite", "sql", SQLITE, "text-second", true),
+    interpreter("psql", "sql", PSQL, "none", true, { witness: { declared: "a database client: it connects to a server before it reads a program file or text, and the gate host has no server" } }),
+    interpreter("osascript", "applescript", OSASCRIPT, "file", true),
+    interpreter("Rscript", "r", RSCRIPT, "file", false),
+    interpreter("julia", "julia", JULIA, "file", true),
+    interpreter("ghci", "haskell", GHCI, "none", true),
+    interpreter("groovy", "groovy", GROOVY, "file", false),
+    interpreter("bun", "javascript", BUN, "file", false),
+    ...launchers,
+    git,
+    ...noPathRows,
+    ...writerRows,
+    ...stdinReaders,
+    ...["declare", "typeset", "local"].map((key) => declaration(key, DECLARE_GRAMMAR)),
+    declaration("export", EXPORT_GRAMMAR, { kind: "binds-name", asWritten: true }), declaration("readonly", EXPORT_GRAMMAR, { kind: "binds-name", asWritten: true }, "frozen"),
+    ...nameBinders,
+    ...["make", "gmake", "bmake", "cmake", "ninja", "meson"].map(assignmentNotPaths),
+    containerRuntime("docker"), containerRuntime("podman"),
+    { key: "pushd", grammars: [], movesBase: "unfollowed", witness: BUILTIN_ONLY },
+    { key: "popd", grammars: [], movesBase: "unfollowed", witness: BUILTIN_ONLY },
+    ...SHELLS.map((s) => shellRow(s, "c-option", BINARY, [SHELL_GRAMMARS[s]], "script")),
+    shellRow("eval", "words", BUILTIN_ONLY), shellRow("source", "file-operand", BUILTIN_ONLY), shellRow(".", "file-operand", BUILTIN_ONLY), shellRow("parallel", "non-option-words", BINARY, [], "script"),
+    ...codeBodyRows,
+    ...["for", "select", "case", "esac", "fi", "done", "function", "coproc", "]]", "in"].map((k) => block(k)),
+    block("[[", [grammar({ v: val(BINDS_NAME) })]),
+];