openapi-typesafe-migrate 1.0.0-rc.10 → 1.0.0-rc.11

package/dist/cli/main.mjs

@@ -2203,22 +2203,158 @@ function referencedFiles(path, documents) {
   });
 }
 
+const NONE = /* @__PURE__ */ new Set();
+const PACKAGE_OPTIONS = /* @__PURE__ */ new Set(["-p", "--package"]);
+const PACKAGE_MANAGER_OPTIONS = /* @__PURE__ */ new Set([
+  "--filter",
+  "-F",
+  "--dir",
+  "-C",
+  "--prefix",
+  "--cwd",
+  "--workspace"
+]);
+const launcher = (words, packageOptions = NONE, valueOptions = NONE) => {
+  const allValueOptions = /* @__PURE__ */ new Set([...valueOptions, ...packageOptions]);
+  return { words, packageOptions, valueOptions: allValueOptions, operands: 0 };
+};
+const CONTAINER_OPTIONS = /* @__PURE__ */ new Set([
+  "-e",
+  "--env",
+  "--env-file",
+  "-v",
+  "--volume",
+  "--mount",
+  "-p",
+  "--publish",
+  "-w",
+  "--workdir",
+  "-u",
+  "--user",
+  "--name",
+  "--network",
+  "--entrypoint",
+  "--platform",
+  "-l",
+  "--label",
+  "-h",
+  "--hostname",
+  "--add-host"
+]);
+const container = (words) => ({
+  ...launcher(words, NONE, CONTAINER_OPTIONS),
+  operands: 1
+});
+const withOperands = (words, operands, valueOptions = NONE) => ({ ...launcher(words, NONE, valueOptions), operands });
+const XARGS_OPTIONS = /* @__PURE__ */ new Set([
+  "-I",
+  "-J",
+  "-L",
+  "-n",
+  "-P",
+  "-R",
+  "-S",
+  "-s",
+  "-d",
+  "-E",
+  "-a",
+  "--max-args",
+  "--max-procs",
+  "--max-lines",
+  "--delimiter",
+  "--arg-file"
+]);
+const NODE_OPTIONS = /* @__PURE__ */ new Set([
+  "-r",
+  "--require",
+  "--import",
+  "--loader",
+  "--env-file"
+]);
+const LAUNCHERS = [
+  launcher(["npm", "exec"], PACKAGE_OPTIONS),
+  launcher(["npm", "x"], PACKAGE_OPTIONS),
+  launcher(["pnpm", "exec"], NONE, PACKAGE_MANAGER_OPTIONS),
+  launcher(["pnpm", "dlx"], /* @__PURE__ */ new Set(["--package"])),
+  launcher(["yarn", "dlx"], PACKAGE_OPTIONS),
+  launcher(["yarn", "exec"]),
+  launcher(["bun", "x"], PACKAGE_OPTIONS),
+  withOperands(["yarn", "workspace"], 1),
+  launcher(["dotenvx", "run"], NONE, /* @__PURE__ */ new Set(["-f", "--env-file", "-e", "--env", "--convention"])),
+  launcher(
+    ["doppler", "run"],
+    NONE,
+    /* @__PURE__ */ new Set(["-p", "--project", "-c", "--config", "--token", "--mount", "--scope"])
+  ),
+  launcher(["nx", "exec"], NONE, /* @__PURE__ */ new Set(["--projects", "-p", "--exclude"])),
+  launcher(["deno", "run"], NONE, /* @__PURE__ */ new Set(["--config", "-c", "--import-map", "--location"])),
+  launcher(["deno", "x"]),
+  launcher(["npx"], PACKAGE_OPTIONS, /* @__PURE__ */ new Set(["-c", "--call"])),
+  launcher(["pnpx"], PACKAGE_OPTIONS),
+  launcher(["bunx"], PACKAGE_OPTIONS),
+  // Like a bare `pnpm <name>`, a bare `bun <name>` runs the binary when no script has the name.
+  launcher(["bun"], NONE, /* @__PURE__ */ new Set(["--cwd", "--filter", "-F"])),
+  launcher(["corepack"]),
+  launcher(["pnpm"], NONE, PACKAGE_MANAGER_OPTIONS),
+  launcher(["yarn"], NONE, PACKAGE_MANAGER_OPTIONS),
+  launcher(["node"], NONE, NODE_OPTIONS),
+  launcher(["tsx"], NONE, NODE_OPTIONS),
+  launcher(["ts-node"], NONE, /* @__PURE__ */ new Set([...NODE_OPTIONS, "-P", "--project", "-O", "--compiler"])),
+  launcher(["cross-env"]),
+  launcher(["dotenv"], NONE, /* @__PURE__ */ new Set(["-e", "-c", "-v"])),
+  launcher(["env"], NONE, /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"])),
+  launcher(["exec"], NONE, /* @__PURE__ */ new Set(["-a"])),
+  launcher(["command"]),
+  launcher(["time"]),
+  launcher(["nice"], NONE, /* @__PURE__ */ new Set(["-n", "--adjustment"])),
+  withOperands(["timeout"], 1, /* @__PURE__ */ new Set(["-s", "--signal", "-k", "--kill-after"])),
+  launcher(["xargs"], NONE, XARGS_OPTIONS),
+  launcher(["nohup"]),
+  launcher(["sudo"], NONE, /* @__PURE__ */ new Set(["-u", "-g"])),
+  // The shell form of Dockerfile instructions runs the rest of the line in a shell.
+  launcher(["RUN"], NONE, /* @__PURE__ */ new Set(["--mount", "--network", "--security"])),
+  launcher(["CMD"]),
+  launcher(["ENTRYPOINT"]),
+  container(["docker", "run"]),
+  container(["docker", "exec"]),
+  container(["docker", "compose", "run"]),
+  container(["docker", "compose", "exec"]),
+  container(["podman", "run"]),
+  container(["podman", "exec"])
+];
+const installers = (manager, subcommands) => subcommands.map((subcommand) => ({ words: [manager, subcommand] }));
+const NPM_INSTALL = ["install", "i", "add", "update", "up", "uninstall", "remove", "rm", "un"];
+const INSTALLERS = [
+  ...installers("npm", NPM_INSTALL),
+  ...installers("pnpm", ["add", "update", "up", "remove", "rm", "uninstall", "un"]),
+  ...installers("yarn", ["add", "upgrade", "up", "remove"]),
+  // Yarn 1 installs global packages with `yarn global add`.
+  { words: ["yarn", "global", "add"] },
+  { words: ["yarn", "global", "remove"] },
+  ...installers("bun", ["add", "a", "update", "remove", "rm", "install", "i"]),
+  ...installers("deno", ["add", "install", "i", "remove", "uninstall"])
+];
+const NPM_SPECIFIER_PREFIX = "npm:";
+
 const EXPRESSION_OPEN = "${{";
-const EXPRESSION_CLOSE = "}}";
+const EXPRESSION_CLOSE$1 = "}}";
 const LITERAL_QUOTE = "'";
 const SHELL_SINGLE_QUOTE = "'";
 const BACKSLASH$3 = "\\";
 const DOUBLE_QUOTE$1 = '"';
 function expressionEnd(text, start) {
   for (let index = start + EXPRESSION_OPEN.length; index < text.length; ) {
-    if (text.startsWith(EXPRESSION_CLOSE, index)) {
-      return index + EXPRESSION_CLOSE.length;
+    if (text.startsWith(EXPRESSION_CLOSE$1, index)) {
+      return index + EXPRESSION_CLOSE$1.length;
     }
     const close = text[index] === LITERAL_QUOTE ? text.indexOf(LITERAL_QUOTE, index + 1) : index;
     index = close === -1 ? text.length : close + 1;
   }
   return void 0;
 }
+const INDEX_OPEN = "[";
+const TRAILING_BLANKS_RE = /[ \t]*$/;
+const isIndexKey = (raw, open) => raw.slice(0, open).replace(TRAILING_BLANKS_RE, "").endsWith(INDEX_OPEN);
 function literalsIn(raw, start, end) {
   const found = [];
   let open = raw.indexOf(LITERAL_QUOTE, start);
@@ -2232,7 +2368,8 @@ function literalsIn(raw, start, end) {
     if (close === -1) {
       break;
     }
-    found.push(...isEscaped ? [] : [{ text: raw.slice(open + 1, close), start: open + 1 }]);
+    const isValue = !isEscaped && !isIndexKey(raw, open);
+    found.push(...isValue ? [{ text: raw.slice(open + 1, close), start: open + 1 }] : []);
     open = raw.indexOf(LITERAL_QUOTE, close + 1);
   }
   return found;
@@ -2255,6 +2392,18 @@ function expressionLiterals(raw) {
   }
   return found;
 }
+function mapExpressions(text, map) {
+  const parts = [];
+  let copiedUpTo = 0;
+  for (let open = text.indexOf(EXPRESSION_OPEN); open !== -1; ) {
+    const end = expressionEnd(text, open) ?? text.length;
+    parts.push(text.slice(copiedUpTo, open), map(text.slice(open, end)));
+    copiedUpTo = end;
+    open = text.indexOf(EXPRESSION_OPEN, end);
+  }
+  parts.push(text.slice(copiedUpTo));
+  return parts.join("");
+}
 function isWholeExpression(raw) {
   const isQuoted = raw.length > 1 && raw.startsWith(DOUBLE_QUOTE$1) && raw.endsWith(DOUBLE_QUOTE$1);
   const inner = isQuoted ? 1 : 0;
@@ -2360,6 +2509,37 @@ function wordPart(text, index) {
   }
   return { end: index + 1, value: char };
 }
+function doubleQuotedOffsets(text, start, end) {
+  const offsets = [];
+  for (let index = start + 1; index < end && text[index] !== '"'; index++) {
+    const isEscape = text[index] === BACKSLASH$2 && DOUBLE_QUOTE_ESCAPES.has(text[index + 1] ?? "");
+    index += isEscape ? 1 : 0;
+    if (text[index] !== "\n" || !isEscape) {
+      offsets.push(index);
+    }
+  }
+  return offsets;
+}
+function partOffsets(text, start, part) {
+  const char = text[start];
+  if (char === '"') {
+    return doubleQuotedOffsets(text, start, part.end);
+  }
+  const isOpened = char === "'" || char === BACKSLASH$2 && part.end - start > 1;
+  const first = isOpened ? start + 1 : start;
+  return Array.from(part.value, (_, index) => first + index);
+}
+function unquotedText(text) {
+  let value = "";
+  const offsets = [];
+  for (let index = 0; index < text.length; ) {
+    const part = wordPart(text, index);
+    value += part.value;
+    offsets.push(...partOffsets(text, index, part));
+    index = part.end;
+  }
+  return { value, offsets };
+}
 const ARRAY_HEAD_RE = /^[A-Za-z_][A-Za-z0-9_]*\+?=$/;
 function arrayListEnd(text, index) {
   let depth = 0;
@@ -2401,105 +2581,257 @@ const DECLARATION_BUILTINS = /* @__PURE__ */ new Set([
   "declare",
   "typeset"
 ]);
-const QUOTES$3 = /* @__PURE__ */ new Set(["'", '"']);
-const UNPLAIN_RE = /['"\\$`]/;
 function leadingAssignments(command) {
   const index = command.findIndex((word) => !ASSIGNMENT_RE$2.test(word.raw));
   return index === -1 ? command.length : index;
 }
+function assignmentOf(word) {
+  const match = ASSIGNMENT_RE$2.exec(word.raw);
+  const name = match?.[1];
+  if (match === null || name === void 0) {
+    return [];
+  }
+  const head = match[0].length;
+  const isAppend = match[2] === APPEND_OPERATOR$1;
+  return [{ name, value: word.value.slice(head), word, isAppend, head }];
+}
 function shellAssignments(command) {
   const count = leadingAssignments(command);
   const isDeclaration = DECLARATION_BUILTINS.has(command[count]?.value ?? "");
   const words = [...command.slice(0, count), ...isDeclaration ? command.slice(count + 1) : []];
-  return words.flatMap((word) => {
-    const match = ASSIGNMENT_RE$2.exec(word.raw);
-    const name = match?.[1];
-    if (match === null || name === void 0) {
-      return [];
-    }
-    const head = match[0].length;
-    const isAppend = match[2] === APPEND_OPERATOR$1;
-    return [{ name, value: word.value.slice(head), word, isAppend, head }];
-  });
+  return words.flatMap(assignmentOf);
+}
+function argumentAssignments(command) {
+  const own = new Set(shellAssignments(command).map(({ word }) => word));
+  return command.slice(leadingAssignments(command)).filter((word) => !own.has(word)).flatMap(assignmentOf);
 }
+const COMMAND_LINE_RE = /[\s;&|()`]/;
+const holdsCommandLine = (assignment) => COMMAND_LINE_RE.test(assignment.value);
 const ARRAY_OPEN = "(";
-const ARRAY_CLOSE = ")";
 const isArrayAssignment = (assignment) => assignment.word.raw.startsWith(ARRAY_OPEN, assignment.head);
-function assignmentValueText(assignment) {
-  const at = assignment.head;
-  const raw = assignment.word.raw.slice(at);
-  const start = assignment.word.start + at;
-  const quote = raw[0] ?? "";
+function arrayValue({ word, head }) {
+  const start = word.start + head + 1;
+  const place = (found) => ({
+    ...found,
+    start: found.start + start,
+    end: found.end + start
+  });
+  return { text: word.raw.slice(head + 1, -1), place };
+}
+function assignmentValue(assignment) {
   if (isArrayAssignment(assignment)) {
-    return raw.endsWith(ARRAY_CLOSE) ? { text: raw.slice(1, -1), start: start + 1 } : void 0;
-  }
-  if (QUOTES$3.has(quote)) {
-    const isOneString = raw.length > 1 && raw.endsWith(quote) && wordPart(raw, 0).end === raw.length;
-    return isOneString ? { text: raw.slice(1, -1), start: start + 1 } : void 0;
-  }
-  return UNPLAIN_RE.test(raw) ? void 0 : { text: raw, start };
+    return arrayValue(assignment);
+  }
+  const { word, head } = assignment;
+  const { value, offsets } = unquotedText(word.raw.slice(head));
+  const written = (index) => head + offsets[index];
+  const place = (found) => {
+    const first = written(found.start);
+    const end = written(found.end - 1) + 1;
+    const raw = word.raw.slice(first, end);
+    return { ...found, start: word.start + first, end: word.start + end, raw };
+  };
+  return { text: value, place };
 }
 
-const HEREDOC_OPERATOR = "<<";
-const HERE_STRING_OPERATOR = "<<<";
-const STRIP_TABS = "-";
-const LINE_BREAK$5 = "\n";
-const LEADING_TABS_RE = /^\t+/;
-const CARRIAGE_RETURN_RE = /\r$/;
-function heredocAt(text, index, where) {
-  if (text.startsWith(HERE_STRING_OPERATOR, index)) {
-    return { end: index + HERE_STRING_OPERATOR.length };
-  }
-  if (!text.startsWith(HEREDOC_OPERATOR, index)) {
-    return void 0;
-  }
-  let start = index + HEREDOC_OPERATOR.length;
-  const isTabStripped = text[start] === STRIP_TABS;
-  start += isTabStripped ? 1 : 0;
-  while (text[start] === " " || text[start] === "	") {
-    start++;
+const END_OF_OPTIONS = "--";
+const isOption$1 = (word) => word.value.startsWith("-") && word.value.length > 1;
+function skipAssignments(words, start) {
+  let index = start;
+  while (index < words.length && ASSIGNMENT_RE$2.test(words[index].raw)) {
+    index++;
   }
-  const word = readWord(text, start);
-  const pending = { delimiter: word.value, isTabStripped, ...where };
-  return word.value === "" ? void 0 : { pending, end: word.end };
+  return index;
 }
-function isDelimiterLine(text, lineStart, end, heredoc) {
-  let first = lineStart;
-  while (first < lineStart + heredoc.indent && text[first] === " ") {
-    first++;
-  }
-  const line = text.slice(first, end).replace(CARRIAGE_RETURN_RE, "");
-  const compared = heredoc.isTabStripped ? line.replace(LEADING_TABS_RE, "") : line;
-  return compared === heredoc.delimiter;
+const WINDOWS_PROGRAM_SUFFIX_RE = /\.(?:cmd|exe|ps1)$/i;
+const windowsSuffix = (value) => WINDOWS_PROGRAM_SUFFIX_RE.exec(value)?.[0] ?? "";
+const withoutWindowsSuffix = (value) => value.slice(0, value.length - windowsSuffix(value).length);
+const entryWord = (word) => word === void 0 ? void 0 : withoutWindowsSuffix(word.value);
+function matchingPrefix(entries, words, index) {
+  return entries.find(
+    (entry) => entry.words.every((name, offset) => entryWord(words[index + offset]) === name)
+  );
 }
-function readBody(text, start, heredoc) {
-  let lineStart = start;
-  while (lineStart < text.length) {
-    const lineEnd = text.indexOf(LINE_BREAK$5, lineStart);
-    const end = lineEnd === -1 ? text.length : lineEnd;
-    if (isDelimiterLine(text, lineStart, end, heredoc)) {
-      const body = { command: heredoc.command, start, text: text.slice(start, lineStart) };
-      return { body, end: Math.min(end + 1, text.length) };
-    }
-    lineStart = end + 1;
-  }
-  return { body: { command: heredoc.command, start, text: text.slice(start) }, end: text.length };
+function inlineOptionPackage(word, launcher) {
+  const equals = word.value.indexOf("=");
+  const name = word.value.slice(0, equals);
+  return launcher.packageOptions.has(name) ? { word, value: word.value.slice(equals + 1) } : void 0;
 }
-function readBodies(text, start, pending) {
-  const bodies = [];
-  let end = start;
-  for (const heredoc of pending) {
-    const read = readBody(text, end, heredoc);
-    bodies.push(read.body);
-    end = read.end;
+function launchedProgram(words, start, launcher, packages) {
+  let index = start;
+  while (index < words.length && isOption$1(words[index])) {
+    const option = words[index++];
+    if (option.value === END_OF_OPTIONS) {
+      break;
+    }
+    const inline = option.value.includes("=") ? inlineOptionPackage(option, launcher) : void 0;
+    if (inline !== void 0) {
+      packages.push(inline);
+    }
+    const value = words[index];
+    if (!option.value.includes("=") && launcher.valueOptions.has(option.value) && value) {
+      if (launcher.packageOptions.has(option.value)) {
+        packages.push({ word: value, value: value.value });
+      }
+      index++;
+    }
   }
-  return { bodies, end };
+  return index;
 }
-
-const CODE_OPTIONS = /* @__PURE__ */ new Map([
-  ["python", /* @__PURE__ */ new Set(["-c"])],
-  ["node", /* @__PURE__ */ new Set(["-e", "--eval", "-p", "--print"])],
-  ["bun", /* @__PURE__ */ new Set(["-e", "--eval", "-p", "--print"])],
+const installArguments = (words, start) => words.slice(start).filter((word) => !isOption$1(word)).map((word) => ({ word, value: word.value }));
+function commandRoles(words) {
+  const packages = [];
+  let index = skipAssignments(words, 0);
+  while (index < words.length) {
+    const installer = matchingPrefix(INSTALLERS, words, index);
+    if (installer !== void 0) {
+      packages.push(...installArguments(words, index + installer.words.length));
+      return { program: void 0, packages };
+    }
+    const launcher = matchingPrefix(LAUNCHERS, words, index);
+    if (launcher === void 0) {
+      return { program: index, packages };
+    }
+    const start = index + launcher.words.length;
+    const afterOptions = launchedProgram(words, start, launcher, packages);
+    index = skipAssignments(words, afterOptions + launcher.operands);
+  }
+  return { program: void 0, packages };
+}
+
+function packageReference(value) {
+  const bare = value.startsWith(NPM_SPECIFIER_PREFIX) ? value.slice(NPM_SPECIFIER_PREFIX.length) : value;
+  const at = bare.indexOf("@", 1);
+  return { name: at === -1 ? bare : bare.slice(0, at), isPinned: at !== -1 };
+}
+function namesOldPackage(value) {
+  return PACKAGE_RENAMES.has(packageReference(value).name) || oldPackageInNodeModules(value) !== void 0 || value.endsWith(`/${GENERATOR_COMMAND}`);
+}
+const unreadArgumentValues = (words) => new Map(
+  argumentAssignments(words).filter((assignment) => !holdsCommandLine(assignment)).map(({ word, value }) => [word, value])
+);
+function unmigratedWordFindings(words, handledOffsets, locate) {
+  const values = unreadArgumentValues(words);
+  const namesOld = (word) => namesOldPackage(word.value) || namesOldPackage(values.get(word) ?? "");
+  return words.filter((word) => !handledOffsets.has(word.start) && namesOld(word)).map((word) => ({
+    offset: word.start,
+    manualStep: { kind: "old-name-in-command", location: locate(word.start), word: word.value }
+  }));
+}
+
+const RECIPE_PREFIX_RE$1 = /^[@+-]+(?=.)/;
+function withoutRecipePrefix(words) {
+  const [first, ...rest] = words;
+  if (first === void 0 || !RECIPE_PREFIX_RE$1.test(first.value)) {
+    return words;
+  }
+  return [{ ...first, value: first.value.replace(RECIPE_PREFIX_RE$1, "") }, ...rest];
+}
+const NO_VARIABLES = {
+  programAt: () => void 0,
+  referenceAt: () => void 0
+};
+function runsGenerator(command) {
+  const words = withoutRecipePrefix(command);
+  const { program } = commandRoles(words);
+  const word = program === void 0 ? void 0 : words[program];
+  return word !== void 0 && packageReference(withoutWindowsSuffix(word.value)).name === GENERATOR_COMMAND;
+}
+
+const COMMAND_PREFIX_WORDS = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "elif",
+  "else",
+  "fi",
+  "while",
+  "until",
+  "do",
+  "done",
+  "!",
+  "{",
+  "}",
+  "esac"
+]);
+const CLAUSE_WORDS = /* @__PURE__ */ new Set(["for", "select", "case", "[["]);
+const FUNCTION_WORD = "function";
+const FUNCTION_HEADER_LENGTH = 2;
+const isReserved = (word, words) => word !== void 0 && word.raw === word.value && words.has(word.value);
+function prefixLength(words, index) {
+  if (isReserved(words[index], COMMAND_PREFIX_WORDS)) {
+    return 1;
+  }
+  const word = words[index];
+  return word?.raw === FUNCTION_WORD ? FUNCTION_HEADER_LENGTH : 0;
+}
+function simpleCommand(words) {
+  let first = 0;
+  for (let length = prefixLength(words, 0); length > 0; length = prefixLength(words, first)) {
+    first += length;
+  }
+  return isReserved(words[first], CLAUSE_WORDS) ? [] : words.slice(first);
+}
+
+const HEREDOC_OPERATOR = "<<";
+const HERE_STRING_OPERATOR = "<<<";
+const STRIP_TABS = "-";
+const LINE_BREAK$6 = "\n";
+const LEADING_TABS_RE = /^\t+/;
+const CARRIAGE_RETURN_RE = /\r$/;
+function heredocAt(text, index, where) {
+  if (text.startsWith(HERE_STRING_OPERATOR, index)) {
+    return { end: index + HERE_STRING_OPERATOR.length };
+  }
+  if (!text.startsWith(HEREDOC_OPERATOR, index)) {
+    return void 0;
+  }
+  let start = index + HEREDOC_OPERATOR.length;
+  const isTabStripped = text[start] === STRIP_TABS;
+  start += isTabStripped ? 1 : 0;
+  while (text[start] === " " || text[start] === "	") {
+    start++;
+  }
+  const word = readWord(text, start);
+  const pending = { delimiter: word.value, isTabStripped, ...where };
+  return word.value === "" ? void 0 : { pending, end: word.end };
+}
+function isDelimiterLine(text, lineStart, end, heredoc) {
+  let first = lineStart;
+  while (first < lineStart + heredoc.indent && text[first] === " ") {
+    first++;
+  }
+  const line = text.slice(first, end).replace(CARRIAGE_RETURN_RE, "");
+  const compared = heredoc.isTabStripped ? line.replace(LEADING_TABS_RE, "") : line;
+  return compared === heredoc.delimiter;
+}
+function readBody(text, start, heredoc) {
+  let lineStart = start;
+  while (lineStart < text.length) {
+    const lineEnd = text.indexOf(LINE_BREAK$6, lineStart);
+    const end = lineEnd === -1 ? text.length : lineEnd;
+    if (isDelimiterLine(text, lineStart, end, heredoc)) {
+      const body = { command: heredoc.command, start, text: text.slice(start, lineStart) };
+      return { body, end: Math.min(end + 1, text.length) };
+    }
+    lineStart = end + 1;
+  }
+  return { body: { command: heredoc.command, start, text: text.slice(start) }, end: text.length };
+}
+function readBodies(text, start, pending) {
+  const bodies = [];
+  let end = start;
+  for (const heredoc of pending) {
+    const read = readBody(text, end, heredoc);
+    bodies.push(read.body);
+    end = read.end;
+  }
+  return { bodies, end };
+}
+
+const CODE_OPTIONS = /* @__PURE__ */ new Map([
+  ["python", /* @__PURE__ */ new Set(["-c"])],
+  ["node", /* @__PURE__ */ new Set(["-e", "--eval", "-p", "--print"])],
+  ["bun", /* @__PURE__ */ new Set(["-e", "--eval", "-p", "--print"])],
   ["ruby", /* @__PURE__ */ new Set(["-e"])],
   ["perl", /* @__PURE__ */ new Set(["-e", "-E"])]
 ]);
@@ -2591,7 +2923,7 @@ function wholeWordExpansion(raw) {
 }
 
 const COMMENT = "#";
-const LINE_BREAK$4 = "\n";
+const LINE_BREAK$5 = "\n";
 function skipTrivia(text, index) {
   const char = text[index];
   if (WORD_BREAKS.has(char)) {
@@ -2621,7 +2953,7 @@ function topLevelCommands(text, indent) {
       index = heredoc.end;
     } else if (afterTrivia !== index) {
       index = afterTrivia;
-    } else if (text[index] === LINE_BREAK$4 && pending.length > 0) {
+    } else if (text[index] === LINE_BREAK$5 && pending.length > 0) {
       const read = readBodies(text, index + 1, pending);
       heredocs.push(...read.bodies);
       pending = [];
@@ -2641,39 +2973,6 @@ function topLevelCommands(text, indent) {
   }
   return { commands, heredocs, pipes };
 }
-const COMMAND_PREFIX_WORDS = /* @__PURE__ */ new Set([
-  "if",
-  "then",
-  "elif",
-  "else",
-  "fi",
-  "while",
-  "until",
-  "do",
-  "done",
-  "!",
-  "{",
-  "}",
-  "esac"
-]);
-const CLAUSE_WORDS = /* @__PURE__ */ new Set(["for", "select", "case", "[["]);
-const FUNCTION_WORD = "function";
-const FUNCTION_HEADER_LENGTH = 2;
-const isReserved = (word, words) => word !== void 0 && word.raw === word.value && words.has(word.value);
-function prefixLength(words, index) {
-  if (isReserved(words[index], COMMAND_PREFIX_WORDS)) {
-    return 1;
-  }
-  const word = words[index];
-  return word?.raw === FUNCTION_WORD ? FUNCTION_HEADER_LENGTH : 0;
-}
-function simpleCommand(words) {
-  let first = 0;
-  for (let length = prefixLength(words, 0); length > 0; length = prefixLength(words, first)) {
-    first += length;
-  }
-  return isReserved(words[first], CLAUSE_WORDS) ? [] : words.slice(first);
-}
 const QUOTES$2 = /* @__PURE__ */ new Set(["'", '"']);
 const NESTED_COMMAND_RE = /[\s;&|()`]/;
 function nestedCommandText(word) {
@@ -2687,17 +2986,17 @@ const PASS_THROUGH = "cat";
 const PATH_SEPARATOR$9 = "/";
 const OPTION_PREFIX$1 = "-";
 const programName$1 = (command) => command[0]?.value.split(PATH_SEPARATOR$9).at(-1) ?? "";
-const isOption$1 = (word) => word.value.startsWith(OPTION_PREFIX$1);
-const isScriptShell = (command) => SHELLS$1.has(programName$1(command)) && command.slice(1).every(isOption$1);
+const isOption = (word) => word.value.startsWith(OPTION_PREFIX$1);
+const isScriptShell = (command) => SHELLS$1.has(programName$1(command)) && command.slice(1).every(isOption);
 function readsScript(command) {
   if (programName$1(command) !== DOCKER_RUN) {
     return isScriptShell(command);
   }
   const after = command.slice(1);
-  const shell = after.slice(after.findIndex((word) => !isOption$1(word)));
-  return after.every(isOption$1) || isScriptShell(shell);
+  const shell = after.slice(after.findIndex((word) => !isOption(word)));
+  return after.every(isOption) || isScriptShell(shell);
 }
-const passesThrough = (command) => programName$1(command) === PASS_THROUGH && command.slice(1).every(isOption$1);
+const passesThrough = (command) => programName$1(command) === PASS_THROUGH && command.slice(1).every(isOption);
 function scriptsRunBy(top, index, command) {
   const previous = index - 1;
   const isPipedScript = top.pipes.has(previous) && isScriptShell(command) && passesThrough(simpleCommand(top.commands[previous] ?? []));
@@ -2712,288 +3011,148 @@ function shellCommandsAt(text, offset, indent = 0) {
 function expansionCommands(word) {
   const expansions = wordExpansions(word.raw);
   const literals = expressionLiterals(word.raw).filter(
-    ({ start }) => expansions.every((expansion) => start < expansion.start || start >= expansion.expansionEnd)
-  );
-  return [...expansions, ...literals].flatMap(
-    (part) => shellCommandsAt(part.text, word.start + part.start)
-  );
-}
-function innerCommands(command) {
-  const assignments = new Map(shellAssignments(command).map((found) => [found.word, found]));
-  const code = inlineCode(command)?.code;
-  return command.flatMap((word) => {
-    const inner = word === code ? void 0 : nestedCommandText(word);
-    if (inner !== void 0) {
-      return shellCommandsAt(inner, word.start + 1);
-    }
-    const assignment = assignments.get(word);
-    const value = assignment === void 0 ? void 0 : assignmentValueText(assignment);
-    return value === void 0 ? expansionCommands(word) : shellCommandsAt(value.text, value.start);
-  });
-}
-function shellCommands(text, indent = 0) {
-  const top = topLevelCommands(text, indent);
-  const commands = [];
-  for (const [index, words] of top.commands.entries()) {
-    const command = simpleCommand(words);
-    if (command.length > 0) {
-      commands.push(command);
-    }
-    commands.push(...innerCommands(command));
-    const scripts = scriptsRunBy(top, index, command);
-    commands.push(...scripts.flatMap((body) => shellCommandsAt(body.text, body.start, indent)));
-  }
-  return commands;
-}
-
-function assertNever(value) {
-  throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
-}
-
-function appendedPlace(earlierValues) {
-  if (earlierValues.length === 0) {
-    return "after-outside";
-  }
-  return earlierValues.every((value) => value.trim() === "") ? "start" : "after-value";
-}
-function canRunGenerator(definition, generators) {
-  switch (definition.kind) {
-    case "command":
-      return definition.runsGenerator;
-    case "reference":
-      return generators.has(definition.target);
-    case "no-program":
-      return false;
-    case "run-time":
-      return true;
-    default:
-      return assertNever(definition);
-  }
-}
-function canRunOther(definition, others, defined) {
-  switch (definition.kind) {
-    case "command":
-      return !definition.runsGenerator;
-    case "reference":
-      return others.has(definition.target) || !defined.has(definition.target);
-    case "no-program":
-      return false;
-    case "run-time":
-      return true;
-    default:
-      return assertNever(definition);
-  }
-}
-function variablePrograms(definitions) {
-  const defined = new Set(definitions.map((definition) => definition.name));
-  const generators = /* @__PURE__ */ new Set();
-  const others = /* @__PURE__ */ new Set();
-  for (let size = -1; size !== generators.size + others.size; ) {
-    size = generators.size + others.size;
-    for (const definition of definitions) {
-      if (canRunGenerator(definition, generators)) {
-        generators.add(definition.name);
-      }
-      if (canRunOther(definition, others, defined)) {
-        others.add(definition.name);
-      }
-    }
-  }
-  const programOf = (name) => {
-    if (!generators.has(name)) {
-      return "other";
-    }
-    return others.has(name) ? "generator-or-other" : "generator";
-  };
-  return new Map([...defined].map((name) => [name, programOf(name)]));
-}
-
-function placedAssignments$1(commands) {
-  const all = commands.flatMap(shellAssignments).sort((left, right) => {
-    return left.word.start - right.word.start;
-  });
-  return all.map((assignment, index) => {
-    if (!assignment.isAppend) {
-      return { assignment, place: void 0 };
-    }
-    const earlier = all.slice(0, index).filter((found) => found.name === assignment.name);
-    return { assignment, place: appendedPlace(earlier.map((found) => found.value)) };
-  });
-}
-const isAfterValue = ({ place }) => place === "after-value" || place === "after-outside";
-function shellAppend(assignment, variables) {
-  const at = assignment.word.start;
-  const written = `$${assignment.name}`;
-  const found = variables.programAt({ raw: written, value: written, start: at, end: at });
-  const program = found ?? { written, program: "generator-or-other" };
-  const text = assignmentValueText(assignment);
-  if (text !== void 0) {
-    const [command] = shellCommandsAt(text.text, text.start);
-    return { value: { words: command ?? [], program }, command };
-  }
-  const words = shellCommands(assignment.value).flat().map((word) => ({ ...word, start: at, end: at }));
-  const isCertain = program.program === "other";
-  const uncertain = { ...program, program: "generator-or-other" };
-  return { value: { words, program: isCertain ? program : uncertain }, command: void 0 };
-}
-function shellAppends(commands, variables) {
-  const appends = placedAssignments$1(commands).filter(isAfterValue).map(({ assignment }) => shellAppend(assignment, variables));
-  const taken = new Set(appends.flatMap(({ command }) => command === void 0 ? [] : [command]));
-  const isTaken = (command) => [...taken].some(
-    (found) => found.length === command.length && found[0]?.start === command[0]?.start
-  );
-  return {
-    commands: commands.filter((command) => !isTaken(command)),
-    appended: appends.map(({ value }) => value)
-  };
-}
-
-const NONE = /* @__PURE__ */ new Set();
-const PACKAGE_OPTIONS = /* @__PURE__ */ new Set(["-p", "--package"]);
-const PACKAGE_MANAGER_OPTIONS = /* @__PURE__ */ new Set([
-  "--filter",
-  "-F",
-  "--dir",
-  "-C",
-  "--prefix",
-  "--cwd",
-  "--workspace"
-]);
-const launcher = (words, packageOptions = NONE, valueOptions = NONE) => {
-  const allValueOptions = /* @__PURE__ */ new Set([...valueOptions, ...packageOptions]);
-  return { words, packageOptions, valueOptions: allValueOptions, operands: 0 };
-};
-const CONTAINER_OPTIONS = /* @__PURE__ */ new Set([
-  "-e",
-  "--env",
-  "--env-file",
-  "-v",
-  "--volume",
-  "--mount",
-  "-p",
-  "--publish",
-  "-w",
-  "--workdir",
-  "-u",
-  "--user",
-  "--name",
-  "--network",
-  "--entrypoint",
-  "--platform",
-  "-l",
-  "--label",
-  "-h",
-  "--hostname",
-  "--add-host"
-]);
-const container = (words) => ({
-  ...launcher(words, NONE, CONTAINER_OPTIONS),
-  operands: 1
-});
-const withOperands = (words, operands, valueOptions = NONE) => ({ ...launcher(words, NONE, valueOptions), operands });
-const XARGS_OPTIONS = /* @__PURE__ */ new Set([
-  "-I",
-  "-J",
-  "-L",
-  "-n",
-  "-P",
-  "-R",
-  "-S",
-  "-s",
-  "-d",
-  "-E",
-  "-a",
-  "--max-args",
-  "--max-procs",
-  "--max-lines",
-  "--delimiter",
-  "--arg-file"
-]);
-const NODE_OPTIONS = /* @__PURE__ */ new Set([
-  "-r",
-  "--require",
-  "--import",
-  "--loader",
-  "--env-file"
-]);
-const LAUNCHERS = [
-  launcher(["npm", "exec"], PACKAGE_OPTIONS),
-  launcher(["npm", "x"], PACKAGE_OPTIONS),
-  launcher(["pnpm", "exec"], NONE, PACKAGE_MANAGER_OPTIONS),
-  launcher(["pnpm", "dlx"], /* @__PURE__ */ new Set(["--package"])),
-  launcher(["yarn", "dlx"], PACKAGE_OPTIONS),
-  launcher(["yarn", "exec"]),
-  launcher(["bun", "x"], PACKAGE_OPTIONS),
-  withOperands(["yarn", "workspace"], 1),
-  launcher(["dotenvx", "run"], NONE, /* @__PURE__ */ new Set(["-f", "--env-file", "-e", "--env", "--convention"])),
-  launcher(
-    ["doppler", "run"],
-    NONE,
-    /* @__PURE__ */ new Set(["-p", "--project", "-c", "--config", "--token", "--mount", "--scope"])
-  ),
-  launcher(["nx", "exec"], NONE, /* @__PURE__ */ new Set(["--projects", "-p", "--exclude"])),
-  launcher(["deno", "run"], NONE, /* @__PURE__ */ new Set(["--config", "-c", "--import-map", "--location"])),
-  launcher(["deno", "x"]),
-  launcher(["npx"], PACKAGE_OPTIONS, /* @__PURE__ */ new Set(["-c", "--call"])),
-  launcher(["pnpx"], PACKAGE_OPTIONS),
-  launcher(["bunx"], PACKAGE_OPTIONS),
-  // Like a bare `pnpm <name>`, a bare `bun <name>` runs the binary when no script has the name.
-  launcher(["bun"], NONE, /* @__PURE__ */ new Set(["--cwd", "--filter", "-F"])),
-  launcher(["corepack"]),
-  launcher(["pnpm"], NONE, PACKAGE_MANAGER_OPTIONS),
-  launcher(["yarn"], NONE, PACKAGE_MANAGER_OPTIONS),
-  launcher(["node"], NONE, NODE_OPTIONS),
-  launcher(["tsx"], NONE, NODE_OPTIONS),
-  launcher(["ts-node"], NONE, /* @__PURE__ */ new Set([...NODE_OPTIONS, "-P", "--project", "-O", "--compiler"])),
-  launcher(["cross-env"]),
-  launcher(["dotenv"], NONE, /* @__PURE__ */ new Set(["-e", "-c", "-v"])),
-  launcher(["env"], NONE, /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"])),
-  launcher(["exec"], NONE, /* @__PURE__ */ new Set(["-a"])),
-  launcher(["command"]),
-  launcher(["time"]),
-  launcher(["nice"], NONE, /* @__PURE__ */ new Set(["-n", "--adjustment"])),
-  withOperands(["timeout"], 1, /* @__PURE__ */ new Set(["-s", "--signal", "-k", "--kill-after"])),
-  launcher(["xargs"], NONE, XARGS_OPTIONS),
-  launcher(["nohup"]),
-  launcher(["sudo"], NONE, /* @__PURE__ */ new Set(["-u", "-g"])),
-  // The shell form of Dockerfile instructions runs the rest of the line in a shell.
-  launcher(["RUN"], NONE, /* @__PURE__ */ new Set(["--mount", "--network", "--security"])),
-  launcher(["CMD"]),
-  launcher(["ENTRYPOINT"]),
-  container(["docker", "run"]),
-  container(["docker", "exec"]),
-  container(["docker", "compose", "run"]),
-  container(["docker", "compose", "exec"]),
-  container(["podman", "run"]),
-  container(["podman", "exec"])
-];
-const installers = (manager, subcommands) => subcommands.map((subcommand) => ({ words: [manager, subcommand] }));
-const NPM_INSTALL = ["install", "i", "add", "update", "up", "uninstall", "remove", "rm", "un"];
-const INSTALLERS = [
-  ...installers("npm", NPM_INSTALL),
-  ...installers("pnpm", ["add", "update", "up", "remove", "rm", "uninstall", "un"]),
-  ...installers("yarn", ["add", "upgrade", "up", "remove"]),
-  // Yarn 1 installs global packages with `yarn global add`.
-  { words: ["yarn", "global", "add"] },
-  { words: ["yarn", "global", "remove"] },
-  ...installers("bun", ["add", "a", "update", "remove", "rm", "install", "i"]),
-  ...installers("deno", ["add", "install", "i", "remove", "uninstall"])
-];
-const NPM_SPECIFIER_PREFIX = "npm:";
+    ({ start }) => expansions.every((expansion) => start < expansion.start || start >= expansion.expansionEnd)
+  );
+  return [...expansions, ...literals].flatMap(
+    (part) => shellCommandsAt(part.text, word.start + part.start)
+  );
+}
+function commandLineAssignments(command) {
+  const read = [
+    ...shellAssignments(command),
+    ...argumentAssignments(command).filter(holdsCommandLine)
+  ];
+  return new Map(read.map((assignment) => [assignment.word, assignment]));
+}
+function valueCommands$1(assignment) {
+  const value = assignmentValue(assignment);
+  return shellCommands(value.text).map((words) => words.map(value.place));
+}
+function innerCommands(command) {
+  const assignments = commandLineAssignments(command);
+  const code = inlineCode(command)?.code;
+  return command.flatMap((word) => {
+    const inner = word === code ? void 0 : nestedCommandText(word);
+    if (inner !== void 0) {
+      return shellCommandsAt(inner, word.start + 1);
+    }
+    const assignment = assignments.get(word);
+    return assignment === void 0 ? expansionCommands(word) : valueCommands$1(assignment);
+  });
+}
+function shellCommands(text, indent = 0) {
+  const top = topLevelCommands(text, indent);
+  const commands = [];
+  for (const [index, words] of top.commands.entries()) {
+    const command = simpleCommand(words);
+    if (command.length > 0) {
+      commands.push(command);
+    }
+    commands.push(...innerCommands(command));
+    const scripts = scriptsRunBy(top, index, command);
+    commands.push(...scripts.flatMap((body) => shellCommandsAt(body.text, body.start, indent)));
+  }
+  return commands;
+}
 
-function packageReference(value) {
-  const bare = value.startsWith(NPM_SPECIFIER_PREFIX) ? value.slice(NPM_SPECIFIER_PREFIX.length) : value;
-  const at = bare.indexOf("@", 1);
-  return { name: at === -1 ? bare : bare.slice(0, at), isPinned: at !== -1 };
+function assertNever(value) {
+  throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
 }
-function namesOldPackage(value) {
-  return PACKAGE_RENAMES.has(packageReference(value).name) || oldPackageInNodeModules(value) !== void 0 || value.endsWith(`/${GENERATOR_COMMAND}`);
+
+function appendedPlace(earlierValues) {
+  if (earlierValues.length === 0) {
+    return "after-outside";
+  }
+  return earlierValues.every((value) => value.trim() === "") ? "start" : "after-value";
 }
-function unmigratedWordFindings(words, handledOffsets, locate) {
-  return words.filter((word) => !handledOffsets.has(word.start) && namesOldPackage(word.value)).map((word) => ({
-    offset: word.start,
-    manualStep: { kind: "old-name-in-command", location: locate(word.start), word: word.value }
-  }));
+function canRunGenerator(definition, generators) {
+  switch (definition.kind) {
+    case "command":
+      return definition.runsGenerator;
+    case "reference":
+      return generators.has(definition.target);
+    case "no-program":
+      return false;
+    case "run-time":
+      return true;
+    default:
+      return assertNever(definition);
+  }
+}
+function canRunOther(definition, others, defined) {
+  switch (definition.kind) {
+    case "command":
+      return !definition.runsGenerator;
+    case "reference":
+      return others.has(definition.target) || !defined.has(definition.target);
+    case "no-program":
+      return false;
+    case "run-time":
+      return true;
+    default:
+      return assertNever(definition);
+  }
+}
+function variablePrograms(definitions) {
+  const defined = new Set(definitions.map((definition) => definition.name));
+  const generators = /* @__PURE__ */ new Set();
+  const others = /* @__PURE__ */ new Set();
+  for (let size = -1; size !== generators.size + others.size; ) {
+    size = generators.size + others.size;
+    for (const definition of definitions) {
+      if (canRunGenerator(definition, generators)) {
+        generators.add(definition.name);
+      }
+      if (canRunOther(definition, others, defined)) {
+        others.add(definition.name);
+      }
+    }
+  }
+  const programOf = (name) => {
+    if (!generators.has(name)) {
+      return "other";
+    }
+    return others.has(name) ? "generator-or-other" : "generator";
+  };
+  return new Map([...defined].map((name) => [name, programOf(name)]));
+}
+
+function placedAssignments$1(commands) {
+  const all = commands.flatMap(shellAssignments).sort((left, right) => {
+    return left.word.start - right.word.start;
+  });
+  return all.map((assignment, index) => {
+    if (!assignment.isAppend) {
+      return { assignment, place: void 0 };
+    }
+    const earlier = all.slice(0, index).filter((found) => found.name === assignment.name);
+    return { assignment, place: appendedPlace(earlier.map((found) => found.value)) };
+  });
+}
+const isAfterValue = ({ place }) => place === "after-value" || place === "after-outside";
+function shellAppend(assignment, variables) {
+  const at = assignment.word.start;
+  const written = `$${assignment.name}`;
+  const found = variables.programAt({ raw: written, value: written, start: at, end: at });
+  const program = found ?? { written, program: "generator-or-other" };
+  const [command] = appendedText(assignment);
+  return { value: { words: command ?? [], program }, command };
+}
+const isOwnGeneratorCommand = (place, command) => place === "after-outside" && command !== void 0 && runsGenerator(command);
+function appendedText(assignment) {
+  const value = assignmentValue(assignment);
+  return shellCommands(value.text).map((words) => words.map(value.place));
+}
+function shellAppends(commands, variables) {
+  const appends = placedAssignments$1(commands).filter(isAfterValue).filter(({ assignment, place }) => !isOwnGeneratorCommand(place, appendedText(assignment)[0])).map(({ assignment }) => shellAppend(assignment, variables));
+  const taken = new Set(appends.flatMap(({ command }) => command === void 0 ? [] : [command]));
+  const isTaken = (command) => [...taken].some(
+    (found) => found.length === command.length && found[0]?.start === command[0]?.start
+  );
+  return {
+    commands: commands.filter((command) => !isTaken(command)),
+    appended: appends.map(({ value }) => value)
+  };
 }
 
 function flagFindings(word, locate) {
@@ -3012,7 +3171,7 @@ function renamedFlags(value) {
   const flags = shellCommands(value).flat().map((word) => word.raw.split("=", 1)[0]);
   return [...new Set(flags.filter((flag) => FLAG_RENAMES.has(flag)))];
 }
-function argumentFindings(word, locate, variables) {
+function argumentFindings$1(word, locate, variables) {
   const reference = variables.referenceAt(word);
   if (reference === void 0) {
     return flagFindings(word, locate);
@@ -3036,7 +3195,7 @@ const oldFlagsOf = (findings) => findings.flatMap(({ change, manualStep }) => {
   return manualStep?.kind === "flags-in-variable" ? [...manualStep.flags] : [];
 });
 function programArgumentFindings(words, { offset, use }, locate, variables) {
-  const found = words.flatMap((word) => argumentFindings(word, locate, variables));
+  const found = words.flatMap((word) => argumentFindings$1(word, locate, variables));
   if (use?.program !== "generator-or-other") {
     return found;
   }
@@ -3060,90 +3219,6 @@ function appendedValueFindings({ words, program }, locate, variables) {
   return [...found, ...unmigratedWordFindings(words, handled, locate)];
 }
 
-const END_OF_OPTIONS = "--";
-const isOption = (word) => word.value.startsWith("-") && word.value.length > 1;
-function skipAssignments(words, start) {
-  let index = start;
-  while (index < words.length && ASSIGNMENT_RE$2.test(words[index].raw)) {
-    index++;
-  }
-  return index;
-}
-const WINDOWS_PROGRAM_SUFFIX_RE = /\.(?:cmd|exe|ps1)$/i;
-const windowsSuffix = (value) => WINDOWS_PROGRAM_SUFFIX_RE.exec(value)?.[0] ?? "";
-const withoutWindowsSuffix = (value) => value.slice(0, value.length - windowsSuffix(value).length);
-const entryWord = (word) => word === void 0 ? void 0 : withoutWindowsSuffix(word.value);
-function matchingPrefix(entries, words, index) {
-  return entries.find(
-    (entry) => entry.words.every((name, offset) => entryWord(words[index + offset]) === name)
-  );
-}
-function inlineOptionPackage(word, launcher) {
-  const equals = word.value.indexOf("=");
-  const name = word.value.slice(0, equals);
-  return launcher.packageOptions.has(name) ? { word, value: word.value.slice(equals + 1) } : void 0;
-}
-function launchedProgram(words, start, launcher, packages) {
-  let index = start;
-  while (index < words.length && isOption(words[index])) {
-    const option = words[index++];
-    if (option.value === END_OF_OPTIONS) {
-      break;
-    }
-    const inline = option.value.includes("=") ? inlineOptionPackage(option, launcher) : void 0;
-    if (inline !== void 0) {
-      packages.push(inline);
-    }
-    const value = words[index];
-    if (!option.value.includes("=") && launcher.valueOptions.has(option.value) && value) {
-      if (launcher.packageOptions.has(option.value)) {
-        packages.push({ word: value, value: value.value });
-      }
-      index++;
-    }
-  }
-  return index;
-}
-const installArguments = (words, start) => words.slice(start).filter((word) => !isOption(word)).map((word) => ({ word, value: word.value }));
-function commandRoles(words) {
-  const packages = [];
-  let index = skipAssignments(words, 0);
-  while (index < words.length) {
-    const installer = matchingPrefix(INSTALLERS, words, index);
-    if (installer !== void 0) {
-      packages.push(...installArguments(words, index + installer.words.length));
-      return { program: void 0, packages };
-    }
-    const launcher = matchingPrefix(LAUNCHERS, words, index);
-    if (launcher === void 0) {
-      return { program: index, packages };
-    }
-    const start = index + launcher.words.length;
-    const afterOptions = launchedProgram(words, start, launcher, packages);
-    index = skipAssignments(words, afterOptions + launcher.operands);
-  }
-  return { program: void 0, packages };
-}
-
-const RECIPE_PREFIX_RE$1 = /^[@+-]+(?=.)/;
-function withoutRecipePrefix(words) {
-  const [first, ...rest] = words;
-  if (first === void 0 || !RECIPE_PREFIX_RE$1.test(first.value)) {
-    return words;
-  }
-  return [{ ...first, value: first.value.replace(RECIPE_PREFIX_RE$1, "") }, ...rest];
-}
-const NO_VARIABLES = {
-  programAt: () => void 0,
-  referenceAt: () => void 0
-};
-function runsGenerator(command) {
-  const words = withoutRecipePrefix(command);
-  const { program } = commandRoles(words);
-  const word = program === void 0 ? void 0 : words[program];
-  return word !== void 0 && packageReference(withoutWindowsSuffix(word.value)).name === GENERATOR_COMMAND;
-}
-
 const PATH_SEPARATOR$8 = "/";
 const WINDOWS_SEPARATOR_RE = /\\/g;
 const QUOTE_RE = /["']/g;
@@ -3152,8 +3227,10 @@ function programPath(word) {
   const suffix = windowsSuffix(word.value);
   const written = word.raw.replace(QUOTE_RE, "");
   const isWindowsPath = suffix !== "" || WINDOWS_PATH_RE.test(written);
-  const windowsPath = written.replace(WINDOWS_SEPARATOR_RE, PATH_SEPARATOR$8);
-  return { path: isWindowsPath ? windowsPath : word.value, suffix };
+  if (!isWindowsPath) {
+    return { path: word.value, suffix, written: word.value };
+  }
+  return { path: written.replace(WINDOWS_SEPARATOR_RE, PATH_SEPARATOR$8), suffix, written };
 }
 
 const SHELL_VARIABLE_RE$1 = /^"?\$(?:([A-Za-z_][A-Za-z0-9_]*)|\{([A-Za-z_][A-Za-z0-9_]*)\})"?$/;
@@ -3301,14 +3378,18 @@ function packageFindings(found, locate) {
   const change = { kind: "package-name-renamed", location, from: name, to };
   return edit === void 0 ? [] : [{ offset, edit, change }];
 }
-function programPathFindings(word, { path, suffix }, location) {
+function programPathFindings(word, program, location) {
+  const { path, suffix, written } = program;
   const offset = word.start;
   if (path.includes(OLD_PACKAGE_FOLDER)) {
     return [{ offset, manualStep: { kind: "old-package-file", location, path } }];
   }
-  const isBin = path.endsWith(`${BIN_FOLDER}${GENERATOR_COMMAND}${suffix}`);
-  const to = MIGRATED_GENERATOR_COMMAND;
-  const edit = isBin ? renameAtEnd(word, GENERATOR_COMMAND, to, suffix) : void 0;
+  if (!path.endsWith(`${BIN_FOLDER}${GENERATOR_COMMAND}${suffix}`)) {
+    const manualStep = { kind: "old-name-in-command", location, word: written };
+    const isGenerator = path.endsWith(`${PATH_SEPARATOR$7}${GENERATOR_COMMAND}${suffix}`);
+    return isGenerator ? [{ offset, manualStep }] : [];
+  }
+  const edit = renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND, suffix);
   return edit === void 0 ? [] : [{ offset, edit, change: { kind: "command-renamed", location } }];
 }
 function programFindings(word, location) {
@@ -3371,12 +3452,15 @@ function shellTextFindings(text, locate) {
 function commandWordFindings(commands, locate, variables = NO_VARIABLES, appended = []) {
   const known = withUnreadVariables(withWordExpansions(withShellAssignments(commands, variables)));
   const shell = shellAppends(commands, known);
-  const findings = [
+  return textFindings([
     ...shell.commands.flatMap((words) => commandFindings(words, locate, known)),
     ...[...appended, ...shell.appended].flatMap(
       (value) => appendedValueFindings(value, locate, known)
     )
-  ].sort((left, right) => left.offset - right.offset);
+  ]);
+}
+function textFindings(found) {
+  const findings = [...found].sort((left, right) => left.offset - right.offset);
   return {
     edits: findings.flatMap((finding) => finding.edit === void 0 ? [] : [finding.edit]),
     changes: findings.flatMap((finding) => finding.change === void 0 ? [] : [finding.change]),
@@ -3497,15 +3581,17 @@ function rangeStyle(spec) {
   return isHyphenRange ? "^" : versionStyle(first[2], first[3], first[4]);
 }
 const isLocalPackageSpec = (spec) => LOCAL_PROTOCOLS.some((protocol) => spec.startsWith(protocol));
+const NPM_PROTOCOL$1 = "npm:";
 function migrateVersionSpec(spec, version) {
-  if (KEPT_PROTOCOLS.some((protocol) => spec.startsWith(protocol))) {
+  if (KEPT_PROTOCOLS.some((protocol2) => spec.startsWith(protocol2))) {
     return { kind: "kept", spec, isReported: false };
   }
-  const style = rangeStyle(spec);
+  const protocol = spec.startsWith(NPM_PROTOCOL$1) ? NPM_PROTOCOL$1 : "";
+  const style = rangeStyle(spec.slice(protocol.length));
   if (style === void 0) {
     return { kind: "kept", spec, isReported: true };
   }
-  return { kind: "replaced", spec: `${style}${version}` };
+  return { kind: "replaced", spec: `${protocol}${style}${version}` };
 }
 
 const NO_LONGER_INSTALLED = /* @__PURE__ */ new Map([
@@ -3544,25 +3630,104 @@ function isDeclaredFor(manifests, filePath, name) {
   const declares = ({ names }) => names === void 0 || names.has(name) || original !== void 0 && names.has(original);
   return containing.length === 0 || containing.some(declares);
 }
-const packageOfSpecifier = (specifier) => {
-  const slash = specifier.indexOf(PATH_SEPARATOR$6);
-  return slash === -1 ? specifier : specifier.slice(0, slash);
-};
-function undeclaredImportSteps(imports, filePath, manifests) {
-  return imports.flatMap(({ specifier, line }) => {
-    const name = packageOfSpecifier(specifier);
-    const installers = NO_LONGER_INSTALLED.get(name);
-    return installers === void 0 || isDeclaredFor(manifests, filePath, name) ? [] : [{ kind: "package-not-declared", line, name, installers }];
+const packageOfSpecifier = (specifier) => {
+  const slash = specifier.indexOf(PATH_SEPARATOR$6);
+  return slash === -1 ? specifier : specifier.slice(0, slash);
+};
+function undeclaredImportSteps(imports, filePath, manifests) {
+  return imports.flatMap(({ specifier, line }) => {
+    const name = packageOfSpecifier(specifier);
+    const installers = NO_LONGER_INSTALLED.get(name);
+    return installers === void 0 || isDeclaredFor(manifests, filePath, name) ? [] : [{ kind: "package-not-declared", line, name, installers }];
+  });
+}
+
+const SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh"]);
+const OPTION_PREFIX = "-";
+const LONG_OPTION_PREFIX = "--";
+const COMMAND_OPTION = "c";
+const SET_OPTION = "-o";
+const PATH_SEPARATOR$5 = "/";
+function shellScript(words) {
+  const program = words[0]?.value.split(PATH_SEPARATOR$5).at(-1) ?? "";
+  if (!SHELLS.has(program)) {
+    return void 0;
+  }
+  let index = 1;
+  for (let option = words[index]?.value; option !== void 0; option = words[index]?.value) {
+    if (!option.startsWith(OPTION_PREFIX)) {
+      return void 0;
+    }
+    if (!option.startsWith(LONG_OPTION_PREFIX) && option.includes(COMMAND_OPTION)) {
+      return words[index + 1];
+    }
+    index += option === SET_OPTION ? 2 : 1;
+  }
+  return void 0;
+}
+function entrypointProgram(entrypoint) {
+  const script = shellScript(entrypoint);
+  if (script !== void 0) {
+    return shellCommands(script.value).some(runsGenerator) ? "generator-or-other" : "other";
+  }
+  const { changes } = commandWordFindings([entrypoint], () => "");
+  return changes.some((change) => change.kind === "command-renamed") ? "generator" : "other";
+}
+function entrypointArgumentFindings({ entrypoint, command, written, isPlaced = true }, locate) {
+  const program = entrypointProgram(entrypoint);
+  const first = command[0];
+  if (program === "other" || first === void 0 || entrypointProgram(command) !== "other") {
+    return [];
+  }
+  const use = { written, program: isPlaced ? program : "generator-or-other" };
+  return programArgumentFindings(command, { offset: first.start, use }, locate, NO_VARIABLES);
+}
+
+const STAGE_INSTRUCTION_RE = /^[ \t]*(FROM|CMD|ENTRYPOINT)\b(.*)$/gm;
+const FROM_RE = /^[ \t]+(?:--\S+[ \t]+)*(\S+)(?:[ \t]+AS[ \t]+(\S+))?/i;
+const FROM = "FROM";
+const CMD = "CMD";
+const ENTRYPOINT_WRITTEN = "ENTRYPOINT";
+function dockerStages(text, forms) {
+  const formAt = new Map(forms.map((form) => [form.lineStart, form]));
+  const stages = [];
+  for (const match of text.matchAll(STAGE_INSTRUCTION_RE)) {
+    const [, keyword, rest] = match;
+    const stage = stages.at(-1);
+    if (keyword === FROM) {
+      const from = FROM_RE.exec(rest ?? "");
+      const name = from?.[2]?.toLowerCase();
+      stages.push({ base: from?.[1] ?? "", name, entrypoint: void 0, command: void 0 });
+    } else if (stage !== void 0) {
+      const instruction = { form: formAt.get(match.index) };
+      stage[keyword === CMD ? "command" : "entrypoint"] = instruction;
+    }
+  }
+  return stages;
+}
+function baseStage(stages, index) {
+  const base = stages[index]?.base.toLowerCase();
+  return stages.findIndex((stage, at) => at < index && (stage.name === base || `${at}` === base));
+}
+function entrypointOf(stages, index) {
+  const own = stages[index]?.entrypoint;
+  const base = baseStage(stages, index);
+  return own ?? (base === -1 ? void 0 : entrypointOf(stages, base));
+}
+function entrypointCommandFindings(text, forms, locate) {
+  const stages = dockerStages(text, forms);
+  return stages.flatMap((stage, index) => {
+    const entrypoint = entrypointOf(stages, index)?.form;
+    const command = stage.command?.form;
+    if (entrypoint === void 0 || command === void 0) {
+      return [];
+    }
+    const pair = { entrypoint: entrypoint.words, command: command.words };
+    return entrypointArgumentFindings({ ...pair, written: ENTRYPOINT_WRITTEN }, locate);
   });
 }
 
 const EXEC_FORM_START_RE = /^[ \t]*(?:RUN|CMD|ENTRYPOINT)(?:[ \t]+--\S+)*[ \t]+\[/gm;
-const SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh"]);
-const OPTION_PREFIX = "-";
-const LONG_OPTION_PREFIX = "--";
-const COMMAND_OPTION = "c";
-const SET_OPTION = "-o";
-const PATH_SEPARATOR$5 = "/";
 const ARRAY_BLANK_RE = /(?:[ \t\r\n]|\\\r?\n)*/y;
 const QUOTED_RE = /"(?:[^"\\\n]|\\.)*"/y;
 const ITEM_SEPARATOR = ",";
@@ -3615,26 +3780,9 @@ function execFormAt(text, start) {
 function execForms(text) {
   return [...text.matchAll(EXEC_FORM_START_RE)].flatMap((match) => {
     const form = execFormAt(text, match.index + match[0].length - 1);
-    return form === void 0 ? [] : [form];
+    return form === void 0 ? [] : [{ ...form, lineStart: match.index }];
   });
 }
-function shellScript(words) {
-  const program = words[0]?.value.split(PATH_SEPARATOR$5).at(-1) ?? "";
-  if (!SHELLS.has(program)) {
-    return void 0;
-  }
-  let index = 1;
-  for (let option = words[index]?.value; option !== void 0; option = words[index]?.value) {
-    if (!option.startsWith(OPTION_PREFIX)) {
-      return void 0;
-    }
-    if (!option.startsWith(LONG_OPTION_PREFIX) && option.includes(COMMAND_OPTION)) {
-      return words[index + 1];
-    }
-    index += option === SET_OPTION ? 2 : 1;
-  }
-  return void 0;
-}
 function execCommands(forms) {
   const commands = [];
   const escaped = [];
@@ -3722,10 +3870,16 @@ function migrateDockerfile(text, file) {
   const values = definitions.flatMap(valueCommands);
   const run = withoutVariableInstructions(shellForm, instructions);
   const commands = [...run, ...values, ...exec.commands];
-  const variables = shellVariables(definitions);
-  const { edits, changes, manualSteps } = commandWordFindings(commands, locate, variables);
-  const steps = [...manualSteps, ...escapedScriptSteps(exec.escaped, lineOf)];
-  return { text: applyTextEdits(text, edits), changes, manualSteps: steps };
+  const found = commandWordFindings(commands, locate, shellVariables(definitions));
+  const entry = textFindings(entrypointCommandFindings(text, forms, locate));
+  const edits = [...found.edits, ...entry.edits];
+  const changes = [...found.changes, ...entry.changes];
+  const steps = [...found.manualSteps, ...entry.manualSteps];
+  return {
+    text: applyTextEdits(text, edits),
+    changes,
+    manualSteps: [...steps, ...escapedScriptSteps(exec.escaped, lineOf)]
+  };
 }
 
 const CATALOG_PROTOCOL = "catalog:";
@@ -4291,7 +4445,7 @@ const BACKTICK = "`";
 const ESCAPING_DELIMITER = '"';
 const ESCAPE = "\\";
 const COMMENT_START$1 = "#";
-const LINE_BREAK$3 = "\n";
+const LINE_BREAK$4 = "\n";
 function closingOffset(text, delimiter, from) {
   if (delimiter !== ESCAPING_DELIMITER) {
     const close = text.indexOf(delimiter, from);
@@ -4301,7 +4455,7 @@ function closingOffset(text, delimiter, from) {
     const char = text[index];
     if (char === ESCAPE) {
       index += 1;
-    } else if (char === ESCAPING_DELIMITER || char === LINE_BREAK$3) {
+    } else if (char === ESCAPING_DELIMITER || char === LINE_BREAK$4) {
       return char === ESCAPING_DELIMITER ? index : void 0;
     }
   }
@@ -4324,7 +4478,7 @@ function literalAt(text, offset) {
 function expressionAt(text, start) {
   const literals = [];
   let index = start;
-  while (index < text.length && text[index] !== LINE_BREAK$3 && text[index] !== COMMENT_START$1) {
+  while (index < text.length && text[index] !== LINE_BREAK$4 && text[index] !== COMMENT_START$1) {
     const literal = literalAt(text, index);
     literals.push(...literal === void 0 ? [] : [literal]);
     index = literal?.end ?? index + 1;
@@ -4348,7 +4502,7 @@ function interpolationAt(text, start) {
     if (text.startsWith(INTERPOLATION_CLOSE, index)) {
       return { start, end: index + INTERPOLATION_CLOSE.length, literals };
     }
-    if (text[index] === LINE_BREAK$3) {
+    if (text[index] === LINE_BREAK$4) {
       return void 0;
     }
     const literal = literalAt(text, index);
@@ -4377,11 +4531,11 @@ const EQUALS = "=";
 const OPEN_PAREN = "(";
 const CLOSE_PAREN = ")";
 const COMMENT_START = "#";
-const LINE_BREAK$2 = "\n";
+const LINE_BREAK$3 = "\n";
 const BLANK_RE = /[ \t]/;
 const depthChange = (char) => char === OPEN_PAREN ? 1 : char === CLOSE_PAREN ? -1 : 0;
 function headerColon(text, from) {
-  for (let index = from; index < text.length && text[index] !== LINE_BREAK$2; ) {
+  for (let index = from; index < text.length && text[index] !== LINE_BREAK$3; ) {
     const literal = literalAt(text, index);
     const char = text[index];
     if (literal !== void 0) {
@@ -4485,7 +4639,7 @@ function shellProgram(shell) {
 const isCommandLineShell = (shell) => COMMAND_LINE_SHELLS.has(shellProgram(shell));
 const endsWith = (path, keys) => keys.every((key, index) => path[path.length - keys.length + index] === key);
 const isDefaultShell = (value) => endsWith(value.path, DEFAULT_SHELL_PATH);
-function scopeOf(value) {
+function scopeOf$1(value) {
   const keys = isDefaultShell(value) ? DEFAULT_SHELL_PATH.length : 1;
   return JSON.stringify(value.path.slice(0, -keys));
 }
@@ -4516,7 +4670,7 @@ function stepShells(strings) {
   const ordered = [...shells.filter(isDefaultShell), ...shells.filter(isOwnShell)];
   const byScope = new Map([
     ...inheritedShells(strings, shells),
-    ...ordered.map((value) => [scopeOf(value), value.value])
+    ...ordered.map((value) => [scopeOf$1(value), value.value])
   ]);
   return (value) => {
     for (let depth = value.path.length - 1; depth >= 0; depth -= 1) {
@@ -4536,18 +4690,18 @@ function otherShellFindings(values, shellOf, locate) {
   return { edits: [], changes: [], manualSteps };
 }
 
-const LINE_BREAK$1 = "\n";
+const LINE_BREAK$2 = "\n";
 const SHEBANG = "#!";
 const BODY_LINE_RE = /^(?:[ \t][^\n]*|[ \t]*\r?)$/;
 function nextLineStart(text, offset) {
-  const lineBreak = text.indexOf(LINE_BREAK$1, offset);
+  const lineBreak = text.indexOf(LINE_BREAK$2, offset);
   return lineBreak === -1 ? text.length : lineBreak + 1;
 }
 function bodyEnd(text, start) {
   let end = start;
   while (end < text.length) {
     const lineEnd = nextLineStart(text, end);
-    if (!BODY_LINE_RE.test(text.slice(end, lineEnd).replace(LINE_BREAK$1, ""))) {
+    if (!BODY_LINE_RE.test(text.slice(end, lineEnd).replace(LINE_BREAK$2, ""))) {
       break;
     }
     end = lineEnd;
@@ -4557,7 +4711,7 @@ function bodyEnd(text, start) {
 function shebangRecipe(text, header) {
   const start = nextLineStart(text, header.end);
   const end = bodyEnd(text, start);
-  const firstLine = text.slice(start, end).split(LINE_BREAK$1).map((line) => line.trim()).find((line) => line.length > 0);
+  const firstLine = text.slice(start, end).split(LINE_BREAK$2).map((line) => line.trim()).find((line) => line.length > 0);
   if (firstLine === void 0 || !firstLine.startsWith(SHEBANG)) {
     return [];
   }
@@ -4760,7 +4914,7 @@ const VALUE_ARGUMENTS = /* @__PURE__ */ new Map([
   ["and", 0]
 ]);
 const WHOLE_TEXT_FUNCTIONS = /* @__PURE__ */ new Set(["strip"]);
-const FUNCTION_HEAD_RE = /^\$[({]([a-z]+)[ \t]+/;
+const FUNCTION_HEAD_RE = /^\$[({]([a-z]+(?:-[a-z]+)*)[ \t]+/;
 const OPENING = new Set(Object.keys(CLOSING));
 const CLOSINGS = new Set(Object.values(CLOSING));
 function callArguments(text, start, end) {
@@ -4824,14 +4978,14 @@ const ASSIGNMENT_RE = new RegExp(
 const VARIABLE_REFERENCE_RE = /^\$(?:\(([A-Za-z_][A-Za-z0-9_.-]*)\)|\{([A-Za-z_][A-Za-z0-9_.-]*)\}|([A-Za-z_]))$/;
 const RECIPE_PREFIX_RE = /^[@+-]+/;
 const NOT_LINE_BREAK_RE = /[^\n]/g;
-const LINE_BREAK = "\n";
+const LINE_BREAK$1 = "\n";
 const BACKSLASH = "\\";
 const APPEND_OPERATOR = "+=";
 const CONDITIONAL_OPERATOR = "?=";
 function logicalLineEnd(text, index) {
-  let end = text.indexOf(LINE_BREAK, index);
+  let end = text.indexOf(LINE_BREAK$1, index);
   while (end !== -1 && text[end - 1] === BACKSLASH) {
-    end = text.indexOf(LINE_BREAK, end + 1);
+    end = text.indexOf(LINE_BREAK$1, end + 1);
   }
   return end === -1 ? text.length : end;
 }
@@ -4911,9 +5065,12 @@ const startsIn = (command, { valueStart, valueEnd }) => {
   return valueStart <= start && start < valueEnd;
 };
 function appendedCommands(commands, placed, programs) {
-  const appends = placed.filter(({ place }) => place !== void 0 && place !== "start");
+  const commandsIn = (assignment) => commands.filter((command) => startsIn(command, assignment)).sort((left, right) => (left[0]?.start ?? 0) - (right[0]?.start ?? 0));
+  const appends = placed.filter(
+    ({ assignment, place }) => place !== void 0 && place !== "start" && !isOwnGeneratorCommand(place, commandsIn(assignment)[0])
+  );
   const appended = appends.map(({ assignment }) => {
-    const words = commands.filter((command) => startsIn(command, assignment)).flat().sort((left, right) => left.start - right.start);
+    const words = commandsIn(assignment).flat().sort((left, right) => left.start - right.start);
     const written = `$(${assignment.name})`;
     const program = programs.get(assignment.name) ?? "generator-or-other";
     return { words, program: { written, program } };
@@ -5241,12 +5398,18 @@ const PNPM_SETTINGS = {
   overrideSections: /* @__PURE__ */ new Set(["overrides", "patchedDependencies"]),
   prefix: `${PNPM_SETTINGS_FIELD}.`
 };
+const BUN_SETTING_FIELDS = ["trustedDependencies"];
 function reportSettings(manifest, findings) {
   for (const field of OVERRIDE_FIELDS) {
     for (const name of valuesAt(manifest, field).flatMap(overriddenOldPackages)) {
       findings.manualSteps.push({ kind: "override-names-package", field, name });
     }
   }
+  for (const field of BUN_SETTING_FIELDS) {
+    for (const name of valuesAt(manifest, field).flatMap(oldPackagesNamedBy)) {
+      findings.manualSteps.push({ kind: "setting-names-package", field, name });
+    }
+  }
   for (const settings of mapsAt(manifest, PNPM_SETTINGS_FIELD)) {
     reportSettingSections(settings, PNPM_SETTINGS, findings);
   }
@@ -5308,18 +5471,12 @@ function oldPackagePatchSteps(fileName) {
   return name === void 0 || to === void 0 ? [] : [{ kind: "old-package-patch", name, to }];
 }
 
-const INPUTS_KEY = "inputs";
-const DEFAULT_KEY = "default";
-const INPUT_DEFAULT_DEPTH = 3;
-const INPUT_NAME_INDEX = -2;
 const BLANK = " ";
 const SURROUNDING_QUOTES_RE = /^"(.*)"$/s;
-const isInputDefault = (value) => value.path.length >= INPUT_DEFAULT_DEPTH && value.path.at(-1) === DEFAULT_KEY && value.path.at(-INPUT_DEFAULT_DEPTH) === INPUTS_KEY;
-const INPUT_REFERENCE_RE = /(?<![\w.-])(?:github\.event\.)?inputs\.([A-Za-z_][A-Za-z0-9_-]*)/g;
-function inputDefaults(strings) {
+const INPUT_REFERENCE_RE = /(?<![\w.-])(?:github\.event\.)?inputs(?:\.([A-Za-z_][A-Za-z0-9_-]*)|\[[ \t]*'([^']*)'[ \t]*\])/g;
+function inputValues(defaults) {
   const values = /* @__PURE__ */ new Map();
-  for (const value of strings.filter(isInputDefault)) {
-    const name = String(value.path.at(INPUT_NAME_INDEX));
+  for (const [value, name] of defaults) {
     values.set(
       name,
       [values.get(name), value.value].filter((part) => part !== void 0).join(BLANK)
@@ -5329,27 +5486,14 @@ function inputDefaults(strings) {
 }
 function expressionValue(expression, defaults) {
   const inputs = [...expression.matchAll(INPUT_REFERENCE_RE)].flatMap((match) => {
-    const value = defaults.get(match[1]);
+    const value = defaults.get(match[1] ?? match[2] ?? "");
     return value === void 0 ? [] : [value];
   });
   const literals = expressionLiterals(expression).map((literal) => literal.text);
   return [...inputs, ...literals].join(BLANK);
 }
-function withExpressionValues(text, defaults) {
-  const parts = [];
-  let copiedUpTo = 0;
-  for (let open = text.indexOf(EXPRESSION_OPEN); open !== -1; ) {
-    const end = expressionEnd(text, open) ?? text.length;
-    parts.push(text.slice(copiedUpTo, open), expressionValue(text.slice(open, end), defaults));
-    copiedUpTo = end;
-    open = text.indexOf(EXPRESSION_OPEN, end);
-  }
-  parts.push(text.slice(copiedUpTo));
-  return parts.join("");
-}
-function withInputDefaults(variables, strings) {
-  const defaults = inputDefaults(strings);
-  const expressionsRead = (text) => withExpressionValues(text, defaults);
+function withInputDefaults(variables, defaults) {
+  const expressionsRead = (text) => mapExpressions(text, (expression) => expressionValue(expression, defaults));
   return {
     programAt: (program) => variables.programAt(program),
     referenceAt: (word) => {
@@ -5364,6 +5508,113 @@ function withInputDefaults(variables, strings) {
   };
 }
 
+const ARGUMENT_KEYS = /* @__PURE__ */ new Map([
+  ["entrypoint", "command"],
+  ["command", "args"]
+]);
+const PAIRED_KEYS = /* @__PURE__ */ new Set([
+  ...ARGUMENT_KEYS.keys(),
+  ...ARGUMENT_KEYS.values()
+]);
+const TRAILING_KEY = "args";
+const LINE_BREAK = "\n";
+const isItem = (string) => typeof string.path.at(-1) === "number";
+const isContainerListItem = (string) => isItem(string) && PAIRED_KEYS.has(String(string.path.at(-2)));
+const isList = (value) => value.strings[0] !== void 0 && isItem(value.strings[0]);
+const mapOf = (string) => JSON.stringify(string.path.slice(0, isItem(string) ? -2 : -1));
+function isNextItem(value, string) {
+  const last = value?.strings.at(-1);
+  return last !== void 0 && isItem(last) && isItem(string) && JSON.stringify(last.path.slice(0, -1)) === JSON.stringify(string.path.slice(0, -1)) && Number(string.path.at(-1)) > Number(last.path.at(-1));
+}
+function keyValues(strings) {
+  const values = [];
+  const starts = /* @__PURE__ */ new Set();
+  for (const string of strings) {
+    const key = ownerKey(string.path) ?? "";
+    const isValue = isItem(string) ? string.path.at(-2) === key : string.path.at(-1) === key;
+    if (!PAIRED_KEYS.has(key) || !isValue || starts.has(string.start)) {
+      continue;
+    }
+    starts.add(string.start);
+    const last = values.at(-1);
+    if (last !== void 0 && isNextItem(last, string)) {
+      last.strings.push(string);
+    } else {
+      values.push({ map: mapOf(string), key, strings: [string] });
+    }
+  }
+  return values;
+}
+const isPlaceable = (string, text) => !string.isEscaped && !(string.isFolded && text.slice(string.content.start, string.content.end).includes(LINE_BREAK));
+function scalarWords(scalar, text) {
+  const { start, end } = scalar.content;
+  const isPlaced = isPlaceable(scalar, text);
+  const [words = []] = shellCommands(isPlaced ? text.slice(start, end) : scalar.value);
+  const at = (word) => isPlaced ? { ...word, start: word.start + start, end: word.end + start } : { ...word, start: scalar.start, end: scalar.start };
+  return { words: words.map(at), isPlaced };
+}
+function valueWords(value, text) {
+  const [first] = value.strings;
+  if (first !== void 0 && !isItem(first)) {
+    return scalarWords(first, text);
+  }
+  const words = value.strings.map((item) => {
+    const { start, end } = item.content;
+    return { start, end, value: item.value, raw: text.slice(start, end), item };
+  });
+  return { words, isPlaced: true };
+}
+function pairOf(left, right) {
+  if (right === void 0 || left.map !== right.map) {
+    return void 0;
+  }
+  if (ARGUMENT_KEYS.get(left.key) === right.key) {
+    return [left, right];
+  }
+  return ARGUMENT_KEYS.get(right.key) === left.key ? [right, left] : void 0;
+}
+function containers(values) {
+  const found = [];
+  for (let index = 0; index < values.length; index++) {
+    const value = values[index];
+    const pair = pairOf(value, values[index + 1]);
+    if (pair !== void 0) {
+      found.push({ entrypoint: pair[0], command: pair[1] });
+      index++;
+    } else if (value.key !== TRAILING_KEY) {
+      found.push({ entrypoint: value, command: void 0 });
+    }
+  }
+  return found;
+}
+function listCommand({ entrypoint, command }, text) {
+  const parts = command === void 0 ? [entrypoint] : [entrypoint, command];
+  return parts.filter(isList).flatMap((part) => valueWords(part, text).words);
+}
+function argumentFindings(container, text, locate) {
+  const { entrypoint, command } = container;
+  if (command === void 0) {
+    return [];
+  }
+  const words = valueWords(entrypoint, text).words;
+  if (isList(entrypoint) && isList(command) && shellScript(words) === void 0) {
+    return [];
+  }
+  const args = valueWords(command, text);
+  const pair = { entrypoint: words, command: args.words, written: entrypoint.key };
+  return entrypointArgumentFindings({ ...pair, isPlaced: args.isPlaced }, locate);
+}
+function containerCommands(text, strings, locate) {
+  const found = containers(keyValues(strings));
+  const commands = found.map((container) => listCommand(container, text));
+  const scripts = commands.flatMap((words) => shellScript(words)?.item ?? []);
+  const flags = found.flatMap((container) => argumentFindings(container, text, locate));
+  return {
+    findings: [commandWordFindings(commands, locate), textFindings(flags)],
+    scripts: new Set(scripts)
+  };
+}
+
 const YAML_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "run",
   "script",
@@ -5388,34 +5639,161 @@ const TASKFILE_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "status"
 ]);
 
+const ROOT_PREFIX = "/";
+const NOT_A_PROJECT_PATH_RE = /\{\{|\$|^[a-z][a-z\d+.-]*:/i;
+const LEADING_ROOT_RE = /^\/+/;
+const YAML_FILE_RE = /\.ya?ml$/;
+const NO_INCLUDES = {
+  isIncludeAt: () => false,
+  isFromRoot: () => false
+};
+const TASKFILE_INCLUDES_KEY = "includes";
+const TASKFILE_KEY = "taskfile";
+const TASKFILE_INCLUDES = {
+  isIncludeAt: ([key, name, field]) => key === TASKFILE_INCLUDES_KEY && typeof name === "string" && (field === void 0 || field === TASKFILE_KEY),
+  isFromRoot: () => false
+};
+const GITLAB_INCLUDE_KEY = "include";
+const GITLAB_LOCAL_KEY = "local";
+const GITLAB_INCLUDES = {
+  isIncludeAt: ([key, ...rest]) => {
+    const [first] = typeof rest[0] === "number" ? rest.slice(1) : rest;
+    const isLocal = first === void 0 || first === GITLAB_LOCAL_KEY;
+    return key === GITLAB_INCLUDE_KEY && isLocal;
+  },
+  isFromRoot: () => true
+};
+const AZURE_TEMPLATE_KEY = "template";
+const AZURE_TEMPLATES = {
+  isIncludeAt: (path) => path.at(-1) === AZURE_TEMPLATE_KEY,
+  isFromRoot: (reference) => reference.startsWith(ROOT_PREFIX)
+};
+function includedPaths(fromPath, strings, includes) {
+  return strings.flatMap((string) => {
+    const reference = string.value.trim();
+    if (!includes.isIncludeAt(string.path) || NOT_A_PROJECT_PATH_RE.test(reference)) {
+      return [];
+    }
+    const path = includes.isFromRoot(reference) ? referencedProjectPath("", reference.replace(LEADING_ROOT_RE, "")) : referencedProjectPath(fromPath, reference);
+    return path !== void 0 && YAML_FILE_RE.test(path) ? [path] : [];
+  });
+}
+
+const NAME_KEY = "name";
+function itemName(strings, index) {
+  const item = strings[index]?.path.slice(0, -1) ?? [];
+  const isInItem = (string) => string !== void 0 && item.every((part, at) => string.path[at] === part);
+  const isName = (string) => string.path.length === item.length + 1 && string.path.at(-1) === NAME_KEY;
+  let [first, last] = [index, index];
+  while (isInItem(strings[first - 1])) {
+    first -= 1;
+  }
+  while (isInItem(strings[last + 1])) {
+    last += 1;
+  }
+  return strings.slice(first, last + 1).find(isName)?.value;
+}
+
+const DEFAULT_KEY = "default";
+const INPUTS_KEY = "inputs";
+const PARAMETERS_KEY = "parameters";
+const SPEC_KEY = "spec";
+const SPEC_INPUT_DEPTH = 4;
+const PATH_TAIL$1 = [-1, -2, -3];
+function defaultUnder(key, value) {
+  const [last, name, owner] = PATH_TAIL$1.map((at) => value?.path.at(at));
+  return last === DEFAULT_KEY && owner === key && typeof name === "string" ? name : void 0;
+}
+const NO_PARAMETERS = {
+  defaultOf: () => void 0,
+  asExpressions: (text) => text
+};
+const GITHUB_INPUTS = {
+  defaultOf: (strings, index) => defaultUnder(INPUTS_KEY, strings[index]),
+  asExpressions: (text) => text
+};
+const GITLAB_INTERPOLATION_RE = /\$\[\[(.*?)\]\]/g;
+const GITLAB_INPUTS = {
+  defaultOf: (strings, index) => {
+    const value = strings[index];
+    const isSpec = value?.path.length === SPEC_INPUT_DEPTH && value.path[0] === SPEC_KEY;
+    return isSpec ? defaultUnder(INPUTS_KEY, value) : void 0;
+  },
+  asExpressions: (text) => text.replace(GITLAB_INTERPOLATION_RE, "$${{$1}}")
+};
+const CIRCLECI_PARAMETER_RE = /<<[ \t]*(?:pipeline\.)?parameters\.([A-Za-z_][A-Za-z0-9_-]*)[ \t]*>>/g;
+const EXPRESSION_CLOSE = "}}";
+const asInputExpression = (written, name) => `${EXPRESSION_OPEN} ${INPUTS_KEY}.${name}`.padEnd(written.length - EXPRESSION_CLOSE.length, " ") + EXPRESSION_CLOSE;
+const CIRCLECI_PARAMETERS = {
+  defaultOf: (strings, index) => defaultUnder(PARAMETERS_KEY, strings[index]),
+  asExpressions: (text) => text.replace(CIRCLECI_PARAMETER_RE, asInputExpression)
+};
+const AZURE_PARAMETERS_RE = /(?<![\w.-])parameters(?=\.|\[)/g;
+const AZURE_AS_INPUTS = INPUTS_KEY.padStart(PARAMETERS_KEY.length, " ");
+const AZURE_PARAMETERS = {
+  defaultOf: (strings, index) => {
+    const [last, item, owner] = PATH_TAIL$1.map((at) => strings[index]?.path.at(at));
+    const isDefault = last === DEFAULT_KEY && typeof item === "number" && owner === PARAMETERS_KEY;
+    return isDefault ? itemName(strings, index) : void 0;
+  },
+  asExpressions: (text) => mapExpressions(text, (expression) => expression.replace(AZURE_PARAMETERS_RE, AZURE_AS_INPUTS))
+};
+function parameterDefaults(strings, parameters) {
+  return new Map(
+    strings.flatMap((value, index) => {
+      const name = parameters.defaultOf(strings, index);
+      return name === void 0 ? [] : [[value, name]];
+    })
+  );
+}
+
 const ENV_KEY = "env";
 const ENVIRONMENT_KEY = "environment";
 const VARIABLES_KEY = "variables";
 const VARS_KEY = "vars";
-const VALUE_KEY = "value";
-const NAME_KEY = "name";
 const PLAIN = {
   hasValueMaps: false,
   hasListItems: false,
   hasNamedItems: false,
   reference: void 0,
-  shellName: (name) => name
+  shellName: (name) => name,
+  hasDollarEscapes: false
 };
 const DEFAULT_YAML_FILE = {
   commandKeys: YAML_COMMAND_KEYS,
-  environment: { ...PLAIN, keys: /* @__PURE__ */ new Set([ENV_KEY]) }
+  environment: { ...PLAIN, keys: /* @__PURE__ */ new Set([ENV_KEY]) },
+  parameters: GITHUB_INPUTS,
+  includes: NO_INCLUDES
 };
 const GITLAB_CI_FILE = {
   commandKeys: YAML_COMMAND_KEYS,
-  environment: { ...PLAIN, keys: /* @__PURE__ */ new Set([ENV_KEY, VARIABLES_KEY]), hasValueMaps: true }
+  environment: { ...PLAIN, keys: /* @__PURE__ */ new Set([ENV_KEY, VARIABLES_KEY]), hasValueMaps: true },
+  parameters: GITLAB_INPUTS,
+  includes: GITLAB_INCLUDES
 };
+const CI_ENVIRONMENT = { ...PLAIN, keys: /* @__PURE__ */ new Set([ENV_KEY, ENVIRONMENT_KEY]) };
 const CI_ENVIRONMENT_FILE = {
   commandKeys: YAML_COMMAND_KEYS,
-  environment: { ...PLAIN, keys: /* @__PURE__ */ new Set([ENV_KEY, ENVIRONMENT_KEY]) }
+  environment: CI_ENVIRONMENT,
+  parameters: NO_PARAMETERS,
+  includes: NO_INCLUDES
+};
+const CIRCLECI_FILE = {
+  commandKeys: YAML_COMMAND_KEYS,
+  environment: CI_ENVIRONMENT,
+  parameters: CIRCLECI_PARAMETERS,
+  includes: NO_INCLUDES
 };
 const COMPOSE_FILE = {
   commandKeys: YAML_COMMAND_KEYS,
-  environment: { ...PLAIN, keys: /* @__PURE__ */ new Set([ENV_KEY, ENVIRONMENT_KEY]), hasListItems: true }
+  environment: {
+    ...PLAIN,
+    keys: /* @__PURE__ */ new Set([ENV_KEY, ENVIRONMENT_KEY]),
+    hasListItems: true,
+    hasDollarEscapes: true
+  },
+  parameters: NO_PARAMETERS,
+  includes: NO_INCLUDES
 };
 const TASKFILE = {
   commandKeys: TASKFILE_COMMAND_KEYS,
@@ -5423,7 +5801,9 @@ const TASKFILE = {
     ...PLAIN,
     keys: /* @__PURE__ */ new Set([ENV_KEY, VARS_KEY]),
     reference: /\{\{-?[ \t]*\.([A-Za-z_][A-Za-z0-9_]*)[ \t]*-?\}\}/g
-  }
+  },
+  parameters: NO_PARAMETERS,
+  includes: TASKFILE_INCLUDES
 };
 const AZURE_NAME_SEPARATOR_RE = /\./g;
 const AZURE_SHELL_SEPARATOR = "_";
@@ -5435,49 +5815,84 @@ const AZURE_PIPELINES_FILE = {
     hasNamedItems: true,
     reference: /\$\(([A-Za-z_][A-Za-z0-9_.]*)\)|\$\{\{[ \t]*variables\.([A-Za-z_][A-Za-z0-9_.]*)[ \t]*\}\}/g,
     shellName: (name, key) => key === VARIABLES_KEY ? name.replace(AZURE_NAME_SEPARATOR_RE, AZURE_SHELL_SEPARATOR).toUpperCase() : name
-  }
+  },
+  parameters: AZURE_PARAMETERS,
+  includes: AZURE_TEMPLATES
 };
-const LIST_ITEM_RE = /^([A-Za-z_][A-Za-z0-9_]*)=/;
-function itemName(strings, index) {
-  const item = strings[index]?.path.slice(0, -1) ?? [];
-  const isInItem = (string) => string !== void 0 && item.every((part, at) => string.path[at] === part);
-  const isName = (string) => string.path.length === item.length + 1 && string.path.at(-1) === NAME_KEY;
-  let [first, last] = [index, index];
-  while (isInItem(strings[first - 1])) {
-    first -= 1;
+const ENV_EXPRESSION_RE = /\$\{\{[ \t]*env\.([A-Za-z_][A-Za-z0-9_]*)[ \t]*\}\}/g;
+const asShellVariable = (reference, name) => `$${name}`.padEnd(reference.length, " ");
+function withToolReferences(text, { environment, names }) {
+  const { reference, shellName } = environment;
+  if (reference === void 0) {
+    return text;
   }
-  while (isInItem(strings[last + 1])) {
-    last += 1;
+  return text.replace(reference, (written, ...groups) => {
+    const group = groups.find((part) => typeof part === "string") ?? "";
+    const name = shellName(group, VARIABLES_KEY);
+    return names.has(name) ? asShellVariable(written, name) : written;
+  });
+}
+const DOLLAR_ESCAPE_RE = /\$\$([A-Za-z_][A-Za-z0-9_]*|\{[^}]*\})/g;
+const withoutDollarEscapes = (text) => text.replace(
+  DOLLAR_ESCAPE_RE,
+  (written, name) => `$${name}`.padEnd(written.length, " ")
+);
+function withVariableReferences(text, references) {
+  const parameters = references?.parameters.asExpressions(text) ?? text;
+  const expressions = parameters.replace(ENV_EXPRESSION_RE, asShellVariable);
+  if (references === void 0) {
+    return expressions;
   }
-  return strings.slice(first, last + 1).find(isName)?.value;
+  const escaped = references.environment.hasDollarEscapes ? withoutDollarEscapes(expressions) : expressions;
+  return withToolReferences(escaped, references);
 }
+
+const VALUE_KEY = "value";
+const OPTIONS_KEY = "options";
+const LIST_ITEM_RE = /^([A-Za-z_][A-Za-z0-9_]*)=/;
+const PATH_TAIL = [-1, -2, -3, -4];
 const isNamedItemValue = (value, keys) => value.path.at(-1) === VALUE_KEY && typeof value.path.at(-2) === "number" && keys.has(String(value.path.at(-3)));
-function environmentEntry(strings, index, environment) {
+function entryPlace(strings, index, { keys, hasValueMaps, hasListItems, hasNamedItems }) {
   const value = strings[index];
-  const { keys, hasValueMaps, hasListItems, hasNamedItems, shellName } = environment;
-  const [last, owner, outer] = [value.path.at(-1), value.path.at(-2), value.path.at(-3)];
-  const named = (name2, key, head = 0) => name2 === void 0 ? void 0 : { name: shellName(name2, String(key)), head };
-  if (typeof last === "string" && keys.has(String(owner))) {
-    return named(last, owner);
+  const [last, owner, outer, optionOf] = PATH_TAIL.map((at) => value.path.at(at));
+  const isKey = (part) => keys.has(String(part));
+  if (typeof last === "string" && isKey(owner)) {
+    return { name: last, key: owner };
   }
-  if (hasValueMaps && last === VALUE_KEY && typeof owner === "string" && keys.has(String(outer))) {
-    return named(owner, outer);
+  if (hasValueMaps && last === VALUE_KEY && typeof owner === "string" && isKey(outer)) {
+    return { name: owner, key: outer };
+  }
+  const isOption = typeof last === "number" && owner === OPTIONS_KEY && typeof outer === "string";
+  if (hasValueMaps && isOption && isKey(optionOf)) {
+    return { name: outer, key: optionOf };
   }
   if (hasNamedItems && isNamedItemValue(value, keys)) {
-    return named(itemName(strings, index), outer);
+    return { name: itemName(strings, index), key: String(outer) };
   }
-  const item = hasListItems && typeof last === "number" && keys.has(String(owner));
-  const name = item ? LIST_ITEM_RE.exec(value.value)?.[1] : void 0;
-  return named(name, owner, (name?.length ?? 0) + 1);
+  const isItem = hasListItems && typeof last === "number" && isKey(owner);
+  const name = isItem ? LIST_ITEM_RE.exec(value.value)?.[1] : void 0;
+  const head = (name?.length ?? 0) + 1;
+  return name === void 0 ? void 0 : { name, key: String(owner), head };
+}
+function scopeOf(path, key) {
+  const owner = path.slice(0, path.lastIndexOf(key));
+  return owner.slice(0, owner.findLastIndex((part) => typeof part === "number") + 1);
 }
 function environmentEntries(strings, environment) {
   return new Map(
     strings.flatMap((value, index) => {
-      const entry = environmentEntry(strings, index, environment);
-      return entry === void 0 ? [] : [[value, entry]];
+      const place = entryPlace(strings, index, environment);
+      if (place?.name === void 0) {
+        return [];
+      }
+      const name = environment.shellName(place.name, place.key);
+      const head = place.head ?? 0;
+      const scope = scopeOf(value.path, place.key);
+      return [[value, { name, head, scope }]];
     })
   );
 }
+const isInScope = (path, entry) => entry.scope.every((part, at) => path[at] === part);
 const ENV_ITEM_KEYS = /* @__PURE__ */ new Set([ENV_KEY]);
 function environmentItemSteps(strings, entries, locate) {
   return strings.filter((value) => isNamedItemValue(value, ENV_ITEM_KEYS) && !entries.has(value)).filter((value) => namesOriginalPackage(value.value)).map((value) => ({
@@ -5486,43 +5901,35 @@ function environmentItemSteps(strings, entries, locate) {
     word: value.value
   }));
 }
-const ENV_EXPRESSION_RE = /\$\{\{[ \t]*env\.([A-Za-z_][A-Za-z0-9_]*)[ \t]*\}\}/g;
-const asShellVariable = (reference, name) => `$${name}`.padEnd(reference.length, " ");
-function withToolReferences(text, { environment, names }) {
-  const { reference, shellName } = environment;
-  if (reference === void 0) {
-    return text;
-  }
-  return text.replace(reference, (written, ...groups) => {
-    const group = groups.find((part) => typeof part === "string") ?? "";
-    const name = shellName(group, VARIABLES_KEY);
-    return names.has(name) ? asShellVariable(written, name) : written;
-  });
-}
-function withVariableReferences(text, references) {
-  const expressions = text.replace(ENV_EXPRESSION_RE, asShellVariable);
-  return references === void 0 ? expressions : withToolReferences(expressions, references);
+
+const FOLDED_LINE_BREAK_RE = /(?<=\S[^\S\n]*)\n(?=[^\S\n]*\S)/g;
+function shellText(text, value, references) {
+  const slice = text.slice(value.content.start, value.content.end);
+  const unfolded = value.isFolded ? slice.replace(FOLDED_LINE_BREAK_RE, " ") : slice;
+  return withVariableReferences(unfolded, references);
 }
 
-function environmentVariables(text, entries, references) {
-  return shellVariables(
-    [...entries].map(([value, entry]) => {
-      const shell = value.isEscaped ? withVariableReferences(value.value, references) : shellText(text, value, references);
-      return { name: entry.name, value: shell.slice(entry.head) };
-    })
-  );
+function scopedVariables({
+  text,
+  entries,
+  inputs,
+  references
+}) {
+  const definitions = [...entries].map(([value, entry]) => {
+    const shell = value.isEscaped ? withVariableReferences(value.value, references) : shellText(text, value, references);
+    return { entry, name: entry.name, value: shell.slice(entry.head) };
+  });
+  return (value) => {
+    const reaching = definitions.filter(({ entry }) => isInScope(value.path, entry));
+    return withInputDefaults(shellVariables(reaching), inputs);
+  };
 }
+
 const DEPENDABOT_NAME_KEYS = /* @__PURE__ */ new Set([
   "dependency-name",
   "patterns",
   "exclude-patterns"
 ]);
-const FOLDED_LINE_BREAK_RE = /(?<=\S[^\S\n]*)\n(?=[^\S\n]*\S)/g;
-function shellText(text, value, references) {
-  const slice = text.slice(value.content.start, value.content.end);
-  const unfolded = value.isFolded ? slice.replace(FOLDED_LINE_BREAK_RE, " ") : slice;
-  return withVariableReferences(unfolded, references);
-}
 const LEADING_SPACES_RE = /^ */;
 function blockIndent(shell) {
   const lines = shell.split("\n").slice(1).filter((line) => line.trim() !== "");
@@ -5538,33 +5945,32 @@ function oncePerPlace(strings) {
   });
 }
 const valuesOf = (strings, keys) => oncePerPlace(strings.filter((string) => keys.has(ownerKey(string.path) ?? "")));
-const EXEC_FORM_KEYS = /* @__PURE__ */ new Set(["command", "entrypoint"]);
-const isExecFormItem = (value) => typeof value.path.at(-1) === "number" && EXEC_FORM_KEYS.has(String(value.path.at(-2)));
-const listOf = (item) => item.path.slice(0, -1).join(".");
-const isNextItem = (previous, item) => listOf(previous) === listOf(item) && Number(item.path.at(-1)) > Number(previous.path.at(-1));
-function execFormCommands(text, items) {
-  const commands = [];
-  let previous;
-  let command = [];
-  for (const item of items) {
-    if (previous === void 0 || !isNextItem(previous, item)) {
-      command = [];
-      commands.push(command);
-    }
-    const { start, end } = item.content;
-    command.push({ start, end, value: item.value, raw: text.slice(start, end) });
-    previous = item;
-  }
-  return commands;
-}
 function escapedValueFindings(value, encode, { locate, variables, references }) {
-  const commands = shellCommands(withVariableReferences(value.value, references));
-  const found = commandWordFindings(commands, () => locate(value.start), variables);
+  const read = withVariableReferences(value.value, references);
+  const commands = shellCommands(read);
+  const findings = commandWordFindings(commands, () => locate(value.start), variables);
+  const found = withWrittenWords(findings, commands, { read, written: value.value });
   const migrated = applyTextEdits(value.value, found.edits);
   const isChanged = migrated !== value.value;
   const edits = isChanged ? [{ start: value.start, end: value.end, text: encode(migrated) }] : [];
   return { ...found, edits };
 }
+const PADDING = " ";
+function writtenWord({ read, written }, word) {
+  let blanks = word.end;
+  while (read[blanks] === PADDING) {
+    blanks += 1;
+  }
+  const covered = written.slice(word.end, blanks).trimEnd();
+  return written.slice(word.start, word.end + covered.length);
+}
+function withWrittenWords(found, commands, value) {
+  const words = new Map(commands.flat().map((word) => [word.raw, writtenWord(value, word)]));
+  const manualSteps = found.manualSteps.map(
+    (step) => "variable" in step ? { ...step, variable: words.get(step.variable) ?? step.variable } : step
+  );
+  return { ...found, manualSteps };
+}
 function valueFindings(value, context) {
   if (value.isEscaped && value.encode !== void 0) {
     return escapedValueFindings(value, value.encode, context);
@@ -5573,7 +5979,9 @@ function valueFindings(value, context) {
   const { start } = value.content;
   const shell = shellText(text, value, references);
   const commands = shellCommands(shell, blockIndent(shell));
-  const found = commandWordFindings(commands, (offset) => locate(start + offset), variables);
+  const findings = commandWordFindings(commands, (offset) => locate(start + offset), variables);
+  const written = text.slice(start, value.content.end);
+  const found = withWrittenWords(findings, commands, { read: shell, written });
   return { ...found, edits: shiftedEdits(found.edits, start) };
 }
 const shiftedEdits = (edits, offset) => edits.map((edit) => ({ ...edit, start: edit.start + offset, end: edit.end + offset }));
@@ -5587,27 +5995,28 @@ function appliedFindings(text, found) {
     manualSteps: found.flatMap((findings) => findings.manualSteps)
   };
 }
-function valueContext({ text, locate }, strings, entries, environment) {
-  const names = new Set([...entries.values()].map((entry) => entry.name));
-  const references = { environment, names };
-  const fileVariables = environmentVariables(text, entries, references);
-  return { text, locate, variables: withInputDefaults(fileVariables, strings), references };
-}
-function migrateYamlCommands(text, file, strings, { commandKeys, environment } = DEFAULT_YAML_FILE) {
+function migrateYamlCommands(text, file, strings, { commandKeys, environment, parameters } = DEFAULT_YAML_FILE) {
   const lineOf = lineLocator(text);
   const locate = (offset) => `${file}:${lineOf(offset)}`;
   const shellOf = stepShells(strings);
   const values = valuesOf(strings, commandKeys).filter((value) => shellOf(value) === void 0);
-  const commandValues = new Set(values.filter((value) => !isExecFormItem(value)));
+  const commandValues = new Set(values.filter((value) => !isContainerListItem(value)));
+  const { findings, scripts } = containerCommands(text, strings, locate);
   const entries = environmentEntries(strings, environment);
-  const isVariable = (value) => entries.has(value) || isInputDefault(value);
-  const shellValues = oncePerPlace(
-    strings.filter((value) => commandValues.has(value) || isVariable(value))
-  );
-  const context = valueContext({ text, locate }, strings, entries, environment);
+  const defaults = parameterDefaults(strings, parameters);
+  const isShellText = (value) => commandValues.has(value) || scripts.has(value) || entries.has(value) || defaults.has(value);
+  const shellValues = oncePerPlace(strings.filter(isShellText));
+  const names = new Set([...entries.values()].map((entry) => entry.name));
+  const references = { environment, names, parameters };
+  const inputs = inputValues(defaults);
+  const variablesAt = scopedVariables({ text, entries, inputs, references });
+  const contextOf = (value) => ({
+    ...{ text, locate, references },
+    variables: variablesAt(value)
+  });
   return appliedFindings(text, [
-    ...shellValues.map((value) => valueFindings(value, context)),
-    commandWordFindings(execFormCommands(text, values.filter(isExecFormItem)), locate),
+    ...shellValues.map((value) => valueFindings(value, contextOf(value))),
+    ...findings,
     otherShellFindings(valuesOf(strings, commandKeys), shellOf, locate),
     { edits: [], changes: [], manualSteps: environmentItemSteps(strings, entries, locate) }
   ]);
@@ -5760,6 +6169,25 @@ function migrateWorkspaceCatalogs(text, read, target, file) {
   return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
 
+function generatorVariables(text, strings, { environment }) {
+  const entries = environmentEntries(strings, environment);
+  return [...entries].flatMap(([value, entry]) => {
+    const shell = value.isEscaped ? value.value : shellText(text, value);
+    return shellCommands(shell.slice(entry.head)).some(runsGenerator) ? [entry.name] : [];
+  });
+}
+const NAME_END = "(?![A-Za-z0-9_])";
+const SPECIAL_CHARACTERS_RE$1 = /[.*+?^${}()|[\]\\]/g;
+function usesVariable(text, names) {
+  if (names.size === 0) {
+    return false;
+  }
+  const alternatives = [...names].map((name2) => name2.replace(SPECIAL_CHARACTERS_RE$1, "\\$&"));
+  const name = `(?:${alternatives.join("|")})`;
+  const expansion = `\\$(?:\\{|\\(|env:)?${name}${NAME_END}|%${name}%`;
+  return new RegExp(expansion).test(text);
+}
+
 const withSteps = (migration, steps) => ({
   ...migration,
   manualSteps: [...migration.manualSteps, ...steps]
@@ -5784,7 +6212,7 @@ const stringsStep = (migrate) => (text, read) => read.kind === "unreadable" ? un
 const usedStringsStep = (migrate) => (text, read) => read.kind === "unreadable" ? unreadableConfig(text, read.offset) : migrate(text, usedDocumentStrings(read.documents));
 const jsonConfig = (steps) => (text, path, context) => migrateConfig(text, (current) => context.readers.json.read(current), steps(context, path));
 const yamlConfig = (steps) => (text, path, context) => migrateConfig(text, (current) => context.readers.yaml.read(current), steps(context, path));
-const whenNamed = (migrate) => (text, path, context) => namesOriginalPackage(text) ? migrate(text, path, context) : unchanged(text);
+const whenNamed = (migrate) => (text, path, context) => namesOriginalPackage(text) || usesVariable(text, context.yamlReach.generatorVariables) ? migrate(text, path, context) : unchanged(text);
 
 const SHELL_EXTENSIONS = /* @__PURE__ */ new Set([".sh", ".bash", ".zsh"]);
 const MAKEFILE_EXTENSION = ".mk";
@@ -5909,15 +6337,18 @@ const CI_ENVIRONMENT_FILES = /* @__PURE__ */ new Set([
   ".woodpecker.yml",
   ".woodpecker.yaml"
 ]);
-const CI_ENVIRONMENT_FOLDERS = [".circleci/", ".woodpecker/"];
+const CIRCLECI_FOLDER = ".circleci/";
+const WOODPECKER_FOLDER = ".woodpecker/";
 const COMPOSE_FILE_RE = /^(?:docker-)?compose(?:\.[^/]+)?\.ya?ml$/;
 function yamlCommandFileFor(path) {
   const name = baseName(path);
   if (GITLAB_FILES.has(name) || isInFolder(path, GITLAB_FOLDER)) {
     return GITLAB_CI_FILE;
   }
-  const isCiEnvironment = CI_ENVIRONMENT_FOLDERS.some((folder) => isInFolder(path, folder));
-  if (CI_ENVIRONMENT_FILES.has(name) || isCiEnvironment) {
+  if (isInFolder(path, CIRCLECI_FOLDER)) {
+    return CIRCLECI_FILE;
+  }
+  if (CI_ENVIRONMENT_FILES.has(name) || isInFolder(path, WOODPECKER_FOLDER)) {
     return CI_ENVIRONMENT_FILE;
   }
   if (isAzurePipelinesFile(path)) {
@@ -5926,6 +6357,58 @@ function yamlCommandFileFor(path) {
   return COMPOSE_FILE_RE.test(name) ? COMPOSE_FILE : DEFAULT_YAML_FILE;
 }
 
+const yamlKindOf = (reach, path) => reach.kinds.get(path) ?? yamlCommandFileFor(path);
+const namedKindOf = (path) => TASKFILE_NAMES.has(baseName(path)) ? TASKFILE : yamlCommandFileFor(path);
+async function textOf$1(path, { files }) {
+  const read = await files.read(path);
+  return read.kind === "read" ? read.text : void 0;
+}
+function stringsOf(text, { readers }) {
+  const parsed = text === void 0 ? void 0 : readers.yaml.read(text);
+  return parsed?.kind === "read" ? usedDocumentStrings(parsed.documents) : [];
+}
+const ANY_FOLDERS_WILDCARD = "**";
+const WILDCARD_RE = /\*\*?/g;
+const SPECIAL_CHARACTERS_RE = /[.+?^${}()|[\]\\]/g;
+const ANY_FOLDERS = ".*";
+const ANY_NAME = "[^/]*";
+function matchingPaths(pattern, listed) {
+  const source = pattern.replace(SPECIAL_CHARACTERS_RE, "\\$&").replace(WILDCARD_RE, (star) => star === ANY_FOLDERS_WILDCARD ? ANY_FOLDERS : ANY_NAME);
+  const matches = new RegExp(`^${source}$`);
+  return listed.filter((path) => matches.test(path));
+}
+async function includedKinds(paths, dependencies) {
+  const kinds = /* @__PURE__ */ new Map();
+  const pending = paths.map((path) => ({ path, kind: namedKindOf(path) })).filter(({ kind }) => kind.includes !== NO_INCLUDES);
+  for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+    const strings = stringsOf(await textOf$1(next.path, dependencies), dependencies);
+    const included = includedPaths(next.path, strings, next.kind.includes);
+    for (const path of included.flatMap((pattern) => matchingPaths(pattern, paths))) {
+      if (!kinds.has(path) && namedKindOf(path) === DEFAULT_YAML_FILE) {
+        kinds.set(path, next.kind);
+        pending.push({ path, kind: next.kind });
+      }
+    }
+  }
+  return kinds;
+}
+const isVariableSource = (path, text) => namesOriginalPackage(text) && (isCiConfigFile(path) || !mayBeApiDescription(text));
+async function planYamlReach(paths, dependencies) {
+  const yamlPaths = paths.filter((path) => YAML_EXTENSIONS.has(extensionOf(path)));
+  const kinds = await includedKinds(yamlPaths, dependencies);
+  const names = /* @__PURE__ */ new Set();
+  for (const path of yamlPaths) {
+    const text = await textOf$1(path, dependencies);
+    if (text !== void 0 && isVariableSource(path, text)) {
+      const kind = kinds.get(path) ?? namedKindOf(path);
+      for (const name of generatorVariables(text, stringsOf(text, dependencies), kind)) {
+        names.add(name);
+      }
+    }
+  }
+  return { kinds, generatorVariables: names };
+}
+
 const isHuskyHook = (path) => (path.startsWith(HUSKY_FOLDER) || path.includes(`/${HUSKY_FOLDER}`)) && !path.includes(HUSKY_INTERNALS);
 const isDependabotConfig = (path) => [...DEPENDABOT_FILES].some((file) => path === file || path.endsWith(`/${file}`));
 function migrateSource(text, path, context) {
@@ -5982,9 +6465,13 @@ const COMMAND_CONFIG_KINDS = [
     )
   }
 ];
-const yamlCommandsStep = (path, isPart) => (text, read) => isPart || !isCiConfigFile(path) && read.kind === "read" && isApiDescription(read.documents) ? unchanged(text) : usedStringsStep(
-  (current, strings) => migrateYamlCommands(current, path, strings, yamlCommandFileFor(path))
-)(text, read);
+const yamlCommandsStep = (path, { apiDescriptionParts, yamlReach }) => (text, read) => {
+  const isCiFile = isCiConfigFile(path) || yamlReach.kinds.has(path);
+  const isApi = !isCiFile && read.kind === "read" && isApiDescription(read.documents);
+  return apiDescriptionParts.has(path) || isApi ? unchanged(text) : usedStringsStep(
+    (current, strings) => migrateYamlCommands(current, path, strings, yamlKindOf(yamlReach, path))
+  )(text, read);
+};
 const manifestTarget = ({ version, catalogs, aliases }, path) => ({
   version,
   catalogs,
@@ -6060,11 +6547,7 @@ const FILE_KINDS = [
   },
   {
     matches: (path) => YAML_EXTENSIONS.has(extensionOf(path)),
-    migrate: whenNamed(
-      yamlConfig((context, path) => [
-        yamlCommandsStep(path, context.apiDescriptionParts.has(path))
-      ])
-    )
+    migrate: whenNamed(yamlConfig((context, path) => [yamlCommandsStep(path, context)]))
   },
   {
     matches: (path) => DOCKERFILE_NAMES.has(baseName(path)),
@@ -6226,9 +6709,10 @@ async function planProjectTarget(paths, dependencies, version) {
   });
   const declarations = withNamedImportMaps(manifests, importMaps);
   const parts = await apiDescriptionParts(paths, dependencies);
+  const yamlReach = await planYamlReach(paths, dependencies);
   return {
     ...{ version, catalogs, manifests: declarations, aliases, importMaps },
-    apiDescriptionParts: parts
+    ...{ apiDescriptionParts: parts, yamlReach }
   };
 }
 
@@ -6252,9 +6736,9 @@ async function planFile(path, dependencies, target) {
     return read;
   }
   const { rewriter, scanner, readers } = dependencies;
-  const { version, catalogs, manifests, aliases, apiDescriptionParts } = target;
+  const { version, catalogs, manifests, aliases, apiDescriptionParts, yamlReach } = target;
   const context = {
-    ...{ version, catalogs, manifests, aliases, apiDescriptionParts },
+    ...{ version, catalogs, manifests, aliases, apiDescriptionParts, yamlReach },
     ...{ rewriter, scanner, readers }
   };
   const attempt = attemptMigration(() => migrate(read.text, path, context));