sh-ast 0.7.0 → 0.9.0

package/README.md

@@ -1,7 +1,8 @@
 # sh-ast
 
 A synchronous TypeScript interface to the `syntax` package of
-[mvdan/sh](https://github.com/mvdan/sh), pinned to **v3.13.1**. Parsing returns
+[mvdan/sh](https://github.com/mvdan/sh), pinned to **v3.13.1 with maintained corrections**
+([source and provenance](https://github.com/mike-north/sh-ast/tree/main/third_party/mvdan-sh)). These are the official Unicode sentinel backport and an owned, behavior-preserving change that scans consecutive comments iteratively. Parsing returns
 mutable records preserving upstream fields, defaults, nulls, numeric operators,
 byte strings, and token positions. First use initializes WebAssembly synchronously
 in Node.js; no initialization promise is required.
@@ -92,9 +93,22 @@ unsupported constructed nodes whose requested bound panics upstream.
 `PrintError` retains ordinary upstream printer failures, and `PrintPanicError`
 retains panics from printing representable inputs. `WalkPanicError` represents
 upstream-equivalent traversal panics; callback exceptions retain their identity.
-All extend `ShAstError`. The conservative structural-depth guard throws
-`ShParseMaxDepthError` before potentially exhausting the WASM stack. It is a
-binding resource constraint and can reject deeply nested quoted or commented text.
+All extend `ShAstError`. Parsing enforces a 128-unit native node-nesting budget.
+The counter includes open statement, word, and expression work plus iterative
+construction of deep operator trees; it is not a stack-frame count or a total
+input-size limit. Exceeding it throws `ShParseMaxDepthError` with stable code
+`SH_AST_PARSE_MAX_DEPTH`, no partial File or position sidecar, and permits later
+parse calls on the same runtime. `maxDepth` is the native budget; the historical
+field name `estimatedDepth` now carries the rejected native work counter.
+Grammar errors found first retain their ordinary `ParseError` precedence.
+Flat comment runs are scanned iteratively, with no separate comment-count limit.
+
+This is an empirical binding resource constraint, not an upstream grammar rule
+or a universal stack-safety guarantee. Repeated direct and ordinary ESLint calls
+were tested on Node 22; arbitrary pre-existing JS recursion can consume the host
+stack margin. Valid syntax can exceed this budget. The policy does not establish
+safety for arbitrary constructed ASTs or other recursive operations
+([tracked separately](https://github.com/mike-north/sh-ast/issues/71)).
 Printing collects complete output; large trees or indentation widths can consume
 substantial memory and time. The parse guard does not bound arbitrary constructed
 printing inputs. No arbitrary writer, partial-output, or reusable-printer protocol
@@ -202,6 +216,31 @@ function isAndCommand(command: BinaryCmd): boolean {
 const unnamed: RawOperator<'BinCmdOperator'> = rawOperator('BinCmdOperator', 500);
 ```
 
+`resolveArgv0` first searches the whole wrapper table for an exact name. An
+explicit path entry wins even if a plain-name entry appears earlier. Only when
+there is no exact match does an **absolute** path use its final segment
+(`/usr/bin/env`, `/usr//bin/env`); `chain` keeps the word as written. Relative
+paths (`./env`, `bin/env`) and trailing-slash paths have no such fallback, but
+can match names explicitly listed in a custom table. Custom plain names also
+acquire absolute-path aliases unless marked as builtins; path-only names do
+not alias other paths.
+
+`WrapperSpec.shellBuiltin: true` identifies a shell builtin, which can only
+match an exact entry in `names`. A path reaches an external executable rather
+than a builtin, so the default `command` and `exec` entries do not match
+`/tmp/command` or `/tmp/exec`. For example, `/tmp/command eval "$x"` keeps
+`/tmp/command` as its static effective command; `command eval "$x"` still
+resolves to `eval`. The external wrappers `env`, `sudo`, `nice`, `nohup`,
+`timeout` and `time` retain their absolute-path aliases. Custom tables may
+mark their own builtin (`{ names: ['builtin'], shellBuiltin: true }`);
+false or omitted retains the existing matching behavior. Explicit path entries
+still match exactly. Non-boolean values throw `ShAnalyzeInvalidWrapperSpecError`.
+
+Matching is a lexical analysis assumption: `PATH` and the filesystem are not
+consulted. Without an exact override, `/opt/mytools/env rm x` follows the `env`
+grammar and resolves to `rm`, even if that file is not the system utility. A
+dynamic word such as `"$dir/env"` is never matched.
+
 `resolveArgv0` follows only documented wrapper grammars. The default `env` and
 `sudo` entries accept assignment names beyond shell identifiers, such as `A-B`
 or `名`. `env` recognizes assignments after `--` and ends option scanning at its
@@ -215,6 +254,64 @@ Existing `skipAssignmentOperands: true` tables retain their ASCII shell-identifi
 rule before `--`. Wrapper assignment operands do not change `assignmentsSkipped`,
 which counts only shell-level prefixes.
 
+When the effective command is a shell interpreter (`bash`, `sh`, `dash`, `zsh`,
+`ksh`, `ksh93`, `mksh`, matched by the final path segment, so `/bin/bash` too)
+invoked with `-c`, `resolveArgv0` reports `effective: { static: false, reason:
+'embedded-command' }`, the same result as `env -S`: the command that runs is
+inside the string operand, which is never parsed. The interpreter's word stays
+available as `chain.at(-2)` and `chainIndices.at(-1)` is the option word that
+selected `-c`. Clustered flags (`-ec`, `-lc`), preceding options (`-o pipefail`,
+`+o`, `-e`) and `--` follow each shell's own option grammar, so `bash script.sh`,
+`bash -e script.sh`, `bash -- -c` and `bash -o c` still resolve to `bash`. A
+dynamic word in option position (`bash "$opts" -c ls`, `bash -c"$y" x`) is
+undecidable and also resolves to `bash`; there `static: true` means only that the
+interpreter's name is known, not that the command is a plain shell invocation. `DEFAULT_EMBEDDED_COMMAND_INTERPRETERS` is the overridable
+table; `ResolveArgv0Options.embeddedCommandInterpreters: []` restores the previous
+behavior.
+
+The table models zsh's `--emulate MODE` / `+-emulate MODE` operands and option
+terminators, including `-b` / `+b` after their current cluster (`zsh -b -c x`
+keeps `zsh`, while `zsh -bc x` is embedded). The ksh entry permits an omitted
+`-o` / `+o` operand before another signed option (`ksh +o -c x` is embedded);
+this was executed on ksh93u+ AJM 2012-08-01, not ksh93u+m or mksh. Bash, dash
+and zsh keep consuming the next word as that operand. Options that themselves
+change the grammar, such as zsh's `shoptionletters`, require a custom table.
+
+Custom interpreter names must be basenames: use `names: ['bash']` for both
+`/bin/bash` and `./bash`. Names containing `/`, null/undefined entries and
+malformed grammar fields throw `ShAnalyzeInvalidWrapperSpecError`. The first
+matching basename entry wins. Wrapper names retain their distinct policy:
+exact matches first, then a basename fallback for absolute paths only.
+
+Bash's single-dash long-option aliases are recognized before clusters:
+`bash -rcfile /dev/null s` and `bash -restricted s` stay static, while
+`bash -rcfile /dev/null -c x` records selector index 3. Custom grammars can
+list exact operand-free long options in `noOperandLongOptions`. Separate
+option operands must be static: an expansion such as `"$@"` may produce
+multiple actual arguments, so `bash -o "$@" -c x` and
+`bash --rcfile "$@" -c x` stop at the static interpreter. Sparse custom
+tables and sparse grammar-field arrays are rejected just like entries
+explicitly holding `undefined`.
+
+The command selector `c` is reserved and cannot be declared an operand-taking
+option in a custom interpreter entry; exact-token fields cannot contain `-c`.
+`embeddedCommandInterpreters` must be an array: `null` and other non-array
+containers throw `ShAnalyzeInvalidWrapperSpecError`; `undefined` uses defaults.
+Ksh/ksh93 `+c`, `+ec` and `+o +c` run scripts instead of selecting a string.
+Apple ksh's `-R` consumes a database-path operand. Ksh's lone `+` ends option processing;
+`ksh -c +` has no command string, while `ksh -c + x` is embedded (executed on
+ksh93u+ AJM 2012-08-01).
+
+Known limits: the table models common option spellings and is not a full
+emulation of each shell's option parser. Unusual spellings can be misclassified
+in either direction:
+
+- Bash/sh single-dash long options after a short option, e.g. `bash -e -rcfile M`.
+- `ksh -c +c M`, or a dynamic word after `-c` that expands to an option.
+- mksh's selector-bearing operands in `mksh -o -c M` and `mksh -o +c M`.
+- A lone `+` before `-c`, e.g. `bash + -c M`.
+- Zsh grammar switches, e.g. `zsh -o shoptionletters -b -c M`.
+
 ## Migration from 0.3
 
 Fields now use upstream spelling (`Type`, `Stmts`, `Cmd`, `Value`) and explicit

package/dist/analyze/index.d.ts

@@ -25,8 +25,8 @@ export { resolveWord } from './resolve-word.js';
 export type { ResolveWordOptions, WordResolution, WordResolutionReason } from './resolve-word.js';
 export { enumerateCommands } from './enumerate-commands.js';
 export type { CommandContext, CommandSite } from './enumerate-commands.js';
-export { DEFAULT_TRANSPARENT_WRAPPERS, resolveArgv0 } from './resolve-argv0.js';
-export type { Argv0ChainWord, Argv0Resolution, Argv0UnresolvedReason, Argv0UnresolvedWord, ResolveArgv0Options, WrapperSpec, } from './resolve-argv0.js';
+export { DEFAULT_EMBEDDED_COMMAND_INTERPRETERS, DEFAULT_TRANSPARENT_WRAPPERS, resolveArgv0, } from './resolve-argv0.js';
+export type { Argv0ChainWord, Argv0Resolution, Argv0UnresolvedReason, Argv0UnresolvedWord, EmbeddedCommandInterpreterSpec, ResolveArgv0Options, WrapperSpec, } from './resolve-argv0.js';
 export { ShAnalyzeInvalidWrapperSpecError, ShAnalyzeMaxDepthError, ShAstError } from '../errors.js';
 export type * from '../../generated/syntax-types.js';
 export type { BinAritOperator, BinCmdOperator, BinTestOperator, CaseOperator, GlobOperator, OperatorFamily, ParExpOperator, ParNamesOperator, ProcOperator, RawOperator, RedirOperator, UnAritOperator, UnTestOperator, } from '../../generated/syntax-constants.js';

package/dist/analyze/index.d.ts.map

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

package/dist/analyze/index.js

@@ -23,7 +23,7 @@
  */
 export { resolveWord } from './resolve-word.js';
 export { enumerateCommands } from './enumerate-commands.js';
-export { DEFAULT_TRANSPARENT_WRAPPERS, resolveArgv0 } from './resolve-argv0.js';
+export { DEFAULT_EMBEDDED_COMMAND_INTERPRETERS, DEFAULT_TRANSPARENT_WRAPPERS, resolveArgv0, } from './resolve-argv0.js';
 // Re-exported from the root errors module so a consumer of enumerateCommands/
 // resolveArgv0 can `import { ShAnalyzeMaxDepthError } from 'sh-ast/analyze'`
 // without also reaching into the root `sh-ast` entry point. `ShAstError`

package/dist/analyze/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/analyze/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EAAE,4BAA4B,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAUhF,8EAA8E;AAC9E,6EAA6E;AAC7E,yEAAyE;AACzE,4DAA4D;AAC5D,yEAAyE;AACzE,0EAA0E;AAC1E,2EAA2E;AAC3E,aAAa;AACb,OAAO,EAAE,gCAAgC,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAqBpG,gFAAgF;AAChF,gFAAgF;AAChF,OAAO,EACL,GAAG,EACH,QAAQ,EACR,cAAc,EACd,oBAAoB,EACpB,GAAG,EACH,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,OAAO,EACP,MAAM,EACN,UAAU,EACV,OAAO,EACP,MAAM,EACN,YAAY,EACZ,cAAc,EACd,KAAK,EACL,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,KAAK,EACL,KAAK,EACL,SAAS,EACT,MAAM,EACN,KAAK,EACL,QAAQ,EACR,GAAG,EACH,YAAY,EACZ,kBAAkB,EAClB,KAAK,EACL,MAAM,EACN,GAAG,EACH,UAAU,EACV,gBAAgB,EAChB,WAAW,EACX,GAAG,EACH,UAAU,EACV,OAAO,EACP,aAAa,EACb,cAAc,EACd,aAAa,EACb,GAAG,EACH,IAAI,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,UAAU,EACV,GAAG,EACH,UAAU,EACV,KAAK,EACL,GAAG,EACH,QAAQ,EACR,WAAW,EACX,gBAAgB,EAChB,GAAG,EACH,GAAG,EACH,EAAE,EACF,MAAM,EACN,OAAO,EACP,WAAW,EACX,MAAM,EACN,MAAM,EACN,aAAa,EACb,IAAI,EACJ,OAAO,EACP,IAAI,EACJ,GAAG,EACH,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,MAAM,EACN,UAAU,EACV,OAAO,EACP,KAAK,EACL,QAAQ,EACR,MAAM,EACN,GAAG,EACH,QAAQ,EACR,cAAc,EACd,cAAc,EACd,cAAc,EACd,cAAc,EACd,MAAM,EACN,UAAU,EACV,GAAG,EACH,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,SAAS,EACT,SAAS,EACT,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,YAAY,EACZ,OAAO,EACP,SAAS,EACT,KAAK,EACL,OAAO,EACP,QAAQ,EACR,SAAS,EACT,SAAS,EACT,KAAK,EACL,OAAO,EACP,QAAQ,EACR,OAAO,EACP,SAAS,EACT,MAAM,EACN,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,OAAO,EACP,YAAY,GACb,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/analyze/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EACL,qCAAqC,EACrC,4BAA4B,EAC5B,YAAY,GACb,MAAM,oBAAoB,CAAC;AAW5B,8EAA8E;AAC9E,6EAA6E;AAC7E,yEAAyE;AACzE,4DAA4D;AAC5D,yEAAyE;AACzE,0EAA0E;AAC1E,2EAA2E;AAC3E,aAAa;AACb,OAAO,EAAE,gCAAgC,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAqBpG,gFAAgF;AAChF,gFAAgF;AAChF,OAAO,EACL,GAAG,EACH,QAAQ,EACR,cAAc,EACd,oBAAoB,EACpB,GAAG,EACH,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,OAAO,EACP,MAAM,EACN,UAAU,EACV,OAAO,EACP,MAAM,EACN,YAAY,EACZ,cAAc,EACd,KAAK,EACL,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,KAAK,EACL,KAAK,EACL,SAAS,EACT,MAAM,EACN,KAAK,EACL,QAAQ,EACR,GAAG,EACH,YAAY,EACZ,kBAAkB,EAClB,KAAK,EACL,MAAM,EACN,GAAG,EACH,UAAU,EACV,gBAAgB,EAChB,WAAW,EACX,GAAG,EACH,UAAU,EACV,OAAO,EACP,aAAa,EACb,cAAc,EACd,aAAa,EACb,GAAG,EACH,IAAI,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,UAAU,EACV,GAAG,EACH,UAAU,EACV,KAAK,EACL,GAAG,EACH,QAAQ,EACR,WAAW,EACX,gBAAgB,EAChB,GAAG,EACH,GAAG,EACH,EAAE,EACF,MAAM,EACN,OAAO,EACP,WAAW,EACX,MAAM,EACN,MAAM,EACN,aAAa,EACb,IAAI,EACJ,OAAO,EACP,IAAI,EACJ,GAAG,EACH,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,MAAM,EACN,UAAU,EACV,OAAO,EACP,KAAK,EACL,QAAQ,EACR,MAAM,EACN,GAAG,EACH,QAAQ,EACR,cAAc,EACd,cAAc,EACd,cAAc,EACd,cAAc,EACd,MAAM,EACN,UAAU,EACV,GAAG,EACH,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,SAAS,EACT,SAAS,EACT,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,YAAY,EACZ,OAAO,EACP,SAAS,EACT,KAAK,EACL,OAAO,EACP,QAAQ,EACR,SAAS,EACT,SAAS,EACT,KAAK,EACL,OAAO,EACP,QAAQ,EACR,OAAO,EACP,SAAS,EACT,MAAM,EACN,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,OAAO,EACP,YAAY,GACb,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/analyze/resolve-argv0.d.ts

@@ -27,22 +27,47 @@ import type { WordResolution } from './resolve-word.js';
  */
 export interface WrapperSpec {
     /**
-     * The literal, exact argv0 text (after quote/escape removal) that
-     * identifies this wrapper — e.g. `['env']`. Matched only against a
-     * `static: true` word; see {@link WrapperSpec}'s doc comment.
+     * The command name that identifies this wrapper — e.g. `['env']`.
+     * Matched only against a `static: true` word; see {@link WrapperSpec}'s
+     * doc comment.
      *
-     * Matching is **exact-name-only** — never basename matching. `sudo` does
-     * not match `/usr/bin/sudo` or `./sudo`; only a word whose *entire*
-     * resolved text equals one of `names` is recognized. This is a
-     * deliberate, narrower-than-real-world policy choice (a real shell would
-     * happily run `/usr/bin/sudo`), not an oversight: silently treating any
-     * path *ending in* a known wrapper name as that wrapper would be a
-     * different, broader matching policy this package isn't making on a
-     * caller's behalf. A caller who wants path-aware matching can express it
-     * explicitly via a custom {@link ResolveArgv0Options.transparentWrappers}
-     * table (e.g. `names: ['sudo', '/usr/bin/sudo']`).
+     * Matching first searches the entire table for an exact name. Only when
+     * no exact entry exists does it try an absolute path's final segment:
+     *
+     * 1. Its entire resolved text (after quote/escape removal) equals one of
+     *    `names`: `env`, or a path a caller listed verbatim. An exact path
+     *    entry takes precedence over a plain-name entry even if listed later.
+     * 2. The spec does not declare {@link WrapperSpec.shellBuiltin | shellBuiltin: true},
+     *    and the word is an **absolute path** (starts with `/`) whose final segment
+     *    equals one of `names`: `/usr/bin/env`, `/usr/bin/sudo`, `/opt/x/nice`
+     *    and `/usr//bin/env` resolve as `env`, `sudo` and `nice`. The chain
+     *    keeps the word as written, so a consumer still sees the path.
+     *
+     * Relative paths and paths with a trailing slash do not use the
+     * final-segment fallback. They can still match an explicitly listed name,
+     * such as `./with-retry` or `/opt/with-retry/`. Custom plain names also
+     * acquire absolute-path aliases unless `shellBuiltin: true`; a path-only
+     * name does not acquire aliases for other paths with the same final segment.
+     *
+     * This is a lexical analysis assumption, not executable identity:
+     * `PATH` is not consulted and the filesystem is not read. Without an
+     * exact override, an unrelated executable named `/opt/mytools/env` uses
+     * the `env` entry's grammar. The chain preserves the original path so
+     * callers can apply their own policy. A word with an expansion
+     * (`"$dir/env"`) is not `static` and is never matched.
      */
     readonly names: readonly string[];
+    /**
+     * Whether this wrapper represents a shell builtin rather than an external
+     * utility. A path cannot reach a builtin: `/tmp/command` names an external
+     * executable, so its arguments must not be interpreted as builtin operands.
+     * When true, only exact entries in {@link WrapperSpec.names} match; the
+     * absolute-path final-segment fallback is disabled. Explicitly listed path
+     * entries still match exactly. False or omitted preserves utility matching.
+     * The defaults mark `command` and `exec`; custom tables may mark their own
+     * builtins, such as `builtin`.
+     */
+    readonly shellBuiltin?: boolean;
     /**
      * Legacy shorthand for {@link WrapperSpec.assignmentOperands}'s
      * `'shell-identifier'` grammar: skip statically resolved `NAME=value`
@@ -178,6 +203,145 @@ export interface WrapperSpec {
  * @public
  */
 export declare const DEFAULT_TRANSPARENT_WRAPPERS: readonly WrapperSpec[];
+/**
+ * A data-only description of one shell interpreter whose `-c` option makes the
+ * next operand a command string run by that shell (`bash -c 'rm x'`). Like
+ * `env -S`, the command that runs lives *inside* an operand, so
+ * {@link resolveArgv0} reports `'embedded-command'` instead of the
+ * interpreter's own name as the effective command.
+ * The selector `c` is reserved: exact-token fields (`noOperandLongOptions`,
+ * `operandLongOptions`, `optionTerminatorWords`) cannot contain `-c`.
+ *
+ * Only the option grammar needed to decide *whether `-c` is an option* is
+ * described: which options consume an operand word (so that `-o c` or
+ * `-o pipefail -c` are not misread) and where option parsing ends. Everything
+ * else about the interpreter — what its other options mean, whether a given
+ * option name is valid — is irrelevant to that decision and unmodeled; an
+ * invalid invocation that a real shell would reject is still reported
+ * conservatively, since nothing is guessed about what it would run.
+ *
+ * Option parsing ends at the first statically known word that is not an
+ * option, at `--`, at a lone `-`, or at a table-defined terminator; afterwards
+ * a word shaped like `-c` is an ordinary script operand. A dynamic word in
+ * option position leaves the question undecidable, so scanning stops and the interpreter is reported
+ * exactly as before (its own static name). In that case `static: true` means
+ * only that the interpreter's name is known; it does not mean the command is a
+ * plain shell invocation, because `bash "$f" -c x` runs `x` when `$f` is `-x`.
+ *
+ * This shape may grow new optional fields in a **minor** release; existing
+ * fields' meaning never changes.
+ *
+ * @public
+ */
+export interface EmbeddedCommandInterpreterSpec {
+    /**
+     * The interpreter's name, matched against a static command word's final
+     * path segment: `bash`, `/bin/bash` and `/usr/local/bin/bash` all match
+     * `['bash']`. Only the command word is reduced to its final segment;
+     * entries containing `/` (such as `['/bin/bash']`) are rejected with
+     * {@link ShAnalyzeInvalidWrapperSpecError}. Use `['bash']` to recognize
+     * path-qualified invocations. The first entry containing the segment wins.
+     *
+     * Unlike {@link WrapperSpec.names}, which tries exact names first and
+     * falls back to the final segment only for absolute paths, interpreter
+     * matching uses only the final segment, including for relative paths
+     * such as `./bash`. The question here is whether a command string is
+     * embedded, not which executable would be located.
+     */
+    readonly names: readonly string[];
+    /**
+     * Single option letters (without a sign) that take a name or value operand
+     * under both `-` and `+`, e.g. `['o']` for `-o pipefail` / `+o pipefail`.
+     * A letter listed here never selects the command string itself, so
+     * `bash -o c script` keeps `c` as an option *name*.
+     * The selector `c` is reserved and cannot be listed as an operand option;
+     * conflicting entries throw {@link ShAnalyzeInvalidWrapperSpecError}.
+     */
+    readonly operandOptions: readonly string[];
+    /**
+     * How an {@link EmbeddedCommandInterpreterSpec.operandOptions} letter
+     * receives its operand inside a clustered word:
+     *
+     * - `'separate-word'` — always the next word; remaining letters in the
+     *   cluster are still options (`bash -oc errexit 'cmd'` is `-o errexit -c`).
+     * - `'rest-of-cluster'` — the remainder of the word if any, else the next
+     *   word; later letters in the same word are part of the operand
+     *   (`zsh -oc` names an option `c`).
+     */
+    readonly operandAttachment: 'separate-word' | 'rest-of-cluster';
+    /**
+     * Letters from {@link EmbeddedCommandInterpreterSpec.operandOptions} whose
+     * separate operand may be omitted before a word beginning with `-` or `+`.
+     * An attached operand still belongs to the option. For example, ksh93u+
+     * treats `-o -c cmd` and `+o -c cmd` as an operand-free option listing
+     * followed by `-c`; bash, dash and zsh consume `-c` as the option name.
+     * A dynamic potential operand makes this distinction undecidable.
+     */
+    readonly optionalOperandOptions?: readonly string[];
+    /**
+     * No-operand letters that end option scanning after the current cluster,
+     * under either sign. Remaining letters in that cluster still take effect:
+     * zsh's `-b -c script` runs the file `-c`, but `-bc cmd` selects a string.
+     * These letters must not include `c` or an operand-taking letter.
+     */
+    readonly optionTerminatorLetters?: readonly string[];
+    /**
+     * Additional whole words that end option scanning, like zsh's `+` and `+-`.
+     * The terminator is not a command string; an already-selected `-c` needs
+     * a following word. `--` and a lone `-` are always terminators.
+     */
+    readonly optionTerminatorWords?: readonly string[];
+    /**
+     * Exact long-option words that take a separate operand, recognized before
+     * short-option clusters regardless of prefix: bash's `--rcfile FILE` and
+     * `-rcfile FILE`, or zsh's `--emulate sh`. A dynamic operand stops scanning
+     * because its expansion may produce multiple actual arguments.
+     */
+    readonly operandLongOptions?: readonly string[];
+    /**
+     * Exact long-option words with no operand, recognized before short-option
+     * clusters. Bash's `-restricted` and `-noprofile` are whole long options,
+     * not clusters containing `c` or `o`. Unlisted `--name` / `+-name` words
+     * are also treated as operand-free; option validity is not checked.
+     */
+    readonly noOperandLongOptions?: readonly string[];
+    /**
+     * `true` if the interpreter also treats `+c` as selecting the command
+     * string. Other shells do not select command mode with `+c`.
+     */
+    readonly plusCSelectsCommand?: boolean;
+}
+/**
+ * `sh-ast/analyze`'s default {@link EmbeddedCommandInterpreterSpec} table:
+ * the shells whose `-c` option makes {@link resolveArgv0} report
+ * `'embedded-command'`. Each entry's option grammar is hand-derived from the
+ * cited manual. Basic clusters and required operands were cross-checked on
+ * Linux bash 5.2.21, dash 0.5.12, zsh 5.9, ksh93u+m 1.0.8 and mksh R59.
+ * Long-option, termination and omitted-operand cases were checked on macOS
+ * bash 5.3.9 and 3.2.57 (also `/bin/sh`), Apple dash-16, zsh 5.9 and ksh93u+
+ * AJM 2012-08-01. Omitted `-o`/`+o` operands before another signed option
+ * were confirmed only on that ksh93u+ build, not ksh93u+m or mksh. Builds can
+ * differ: macOS's ksh93u+ differs from the cited 93u+m for `ksh -o c "echo X"`.
+ * The `sh` entry also models bash's long options because `sh` can be bash.
+ * Named options that change the option grammar itself (such as zsh's
+ * `shoptionletters`) are not interpreted; a custom table is needed for that
+ * grammar. It is data, not policy:
+ * it names no dangerous commands and a caller can replace or extend it via
+ * {@link ResolveArgv0Options.embeddedCommandInterpreters}; an empty array
+ * restores the behavior in which an interpreter is an ordinary effective
+ * command.
+ *
+ * Frozen, including each entry and its arrays.
+ *
+ * @see https://www.gnu.org/software/bash/manual/bash.html#Invoking-Bash — bash
+ * @see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sh.html — POSIX `sh`
+ * @see https://man7.org/linux/man-pages/man1/dash.1.html — dash(1)
+ * @see https://zsh.sourceforge.io/Doc/Release/Invocation-and-Startup.html — zsh
+ * @see https://github.com/ksh93/ksh — ksh93u+m `sh(1)`
+ * @see https://man.mirbsd.org/mksh.1 — mksh(1)
+ * @public
+ */
+export declare const DEFAULT_EMBEDDED_COMMAND_INTERPRETERS: readonly EmbeddedCommandInterpreterSpec[];
 /**
  * Options accepted by {@link resolveArgv0}.
  *
@@ -199,6 +363,19 @@ export interface ResolveArgv0Options {
      * flag matching.
      */
     readonly transparentWrappers?: readonly WrapperSpec[];
+    /**
+     * The shell interpreters whose `-c` operand is reported as an
+     * `'embedded-command'`. Defaults to
+     * {@link DEFAULT_EMBEDDED_COMMAND_INTERPRETERS}. Pass a replacement array to
+     * add or drop interpreters; an empty array disables the behavior, so every
+     * interpreter resolves as an ordinary effective command.
+     *
+     * Validated at the {@link resolveArgv0} boundary like
+     * {@link ResolveArgv0Options.transparentWrappers}: the table must be an
+     * array. A non-array value (including `null`) or malformed entry throws
+     * {@link ShAnalyzeInvalidWrapperSpecError}; only `undefined` uses defaults.
+     */
+    readonly embeddedCommandInterpreters?: readonly EmbeddedCommandInterpreterSpec[];
 }
 /**
  * Why {@link resolveArgv0} couldn't identify a single, definite effective
@@ -215,7 +392,10 @@ export interface ResolveArgv0Options {
  * - `'embedded-command'` — a wrapper flag whose value structurally embeds
  *   the real command rather than naming it as a separate word (e.g.
  *   `env -S 'rm -rf /'` — see {@link WrapperSpec.unresolvableFlags}'s doc
- *   comment).
+ *   comment), or a shell interpreter's `-c` option (`bash -c 'rm x'`, see
+ *   {@link EmbeddedCommandInterpreterSpec}). In both cases the chain's
+ *   second-to-last element is the wrapper or interpreter word, so its name
+ *   stays available.
  * - `'ambiguous-assignment'` — a statically known assignment operand whose
  *   acceptance differs across supported utility implementations, such as
  *   `env =value cmd` (GNU/glibc accepts an empty name; BSD rejects it).
@@ -332,7 +512,7 @@ export interface Argv0Resolution {
  * command) or add their own (e.g. a project's `with-retry` helper) and
  * both directions are followed identically to any built-in entry.
  *
- * **A statically-unknowable word is never guessed through** — three
+ * **A statically-unknowable word is never guessed through** — four
  * distinct cases all stop the chain immediately at that word rather than
  * falling back to any other guess:
  *
@@ -353,6 +533,30 @@ export interface Argv0Resolution {
  *    reports `effective: { static: false, reason: 'embedded-command' }`
  *    (see {@link WrapperSpec.unresolvableFlags}'s doc comment).
  *
+ * 4. The effective command is a shell interpreter
+ *    ({@link DEFAULT_EMBEDDED_COMMAND_INTERPRETERS}) invoked with `-c` —
+ *    `bash -c "$x"`, `sudo sh -ec ls` — and the command that runs is
+ *    inside the string operand. The result is the same
+ *    `'embedded-command'` shape `env -S` produces: the interpreter word is
+ *    `chain.at(-2)` and `chainIndices.at(-1)` is the option word that
+ *    selected `-c`. `bash script.sh`, `bash -e script.sh`, `bash -- -c`
+ *    and `bash -o c` are not `-c` invocations and resolve to `bash` as
+ *    before. A dynamic word in option position (`bash "$f" -c x`,
+ *    `bash -c"$y" x`) is undecidable, so the interpreter stays a static
+ *    `bash`: `static: true` then means only that the name is known, not that
+ *    the command is a plain shell invocation. The `-c` string itself is never
+ *    parsed.
+ *
+ * Known limits: the table models common option spellings, not a full
+ * emulation of each shell's option parser. Unusual spellings can be
+ * misclassified in either direction:
+ *
+ * - Bash/sh single-dash long options after a short option, e.g. `bash -e -rcfile M`.
+ * - `ksh -c +c M`, or a dynamic word after `-c` that expands to an option.
+ * - mksh's selector-bearing operands in `mksh -o -c M` and `mksh -o +c M`.
+ * - A lone `+` before `-c`, e.g. `bash + -c M`.
+ * - Zsh grammar switches, e.g. `zsh -o shoptionletters -b -c M`.
+ *
  * `VAR=val` shell-assignment prefixes on the `CallExpr` itself
  * (`CommandSite.node.Assigns`, e.g. `FOO=bar rm x`) are always skipped and
  * counted in {@link Argv0Resolution.assignmentsSkipped} — a mechanism
@@ -367,7 +571,8 @@ export interface Argv0Resolution {
  * least one argv word; see its doc comment), not a "malformed shell
  * source" case.
  * @throws {@link ShAnalyzeInvalidWrapperSpecError} if
- * `options.transparentWrappers` contains a malformed entry (see
+ * `options.transparentWrappers` or `options.embeddedCommandInterpreters`
+ * contains a malformed entry (see
  * {@link ResolveArgv0Options.transparentWrappers}'s doc comment).
  * @public
  */

package/dist/analyze/resolve-argv0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-argv0.d.ts","sourceRoot":"","sources":["../../src/analyze/resolve-argv0.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAElC;;;;;;;OAOG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAE1C;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,kBAAkB,GAAG,KAAK,GAAG,MAAM,CAAC;IAElE,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAExC;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAEnC;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAEtC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAE/C;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAE7C;;;;OAIG;IACH,QAAQ,CAAC,+BAA+B,CAAC,EAAE,MAAM,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,WAAW,EAqH7D,CAAC;AAEH;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CACvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,GAAG,sBAAsB,CAAC;AAEjG;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,mBAAmB,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAE1C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAEzC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IAEnC;;;;;;;;OAQG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACrC;AA2VD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,eAAe,CAoC9F"}
+{"version":3,"file":"resolve-argv0.d.ts","sourceRoot":"","sources":["../../src/analyze/resolve-argv0.ts"],"names":[],"mappings":"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"}