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

package/dist/cli/main.mjs

@@ -910,12 +910,19 @@ function optionsOf(argument, bindings) {
   }
   return ts.isIdentifier(value) ? constantOptions(value, bindings, types) : { kind: "unknown", expression: argument };
 }
+const UNDEFINED = "undefined";
+function isNoValue(argument, bindings) {
+  const { value } = unwrapped(argument);
+  const isUndefined = ts.isIdentifier(value) && value.text === UNDEFINED && bindings.declarationOf(value) === void 0;
+  return isUndefined || ts.isVoidExpression(value);
+}
 function generatorCalls(file, bindings) {
   const calls = [];
   const visit = (node) => {
     if (ts.isCallExpression(node) && isGenerator(node.expression, bindings)) {
       const argument = node.arguments[1];
-      const options = argument === void 0 ? void 0 : optionsOf(argument, bindings);
+      const isOmitted = argument === void 0 || isNoValue(argument, bindings);
+      const options = isOmitted ? void 0 : optionsOf(argument, bindings);
       calls.push({ call: node, options });
     }
     ts.forEachChild(node, visit);
@@ -949,7 +956,7 @@ function importTypeName(node) {
   const isOptions = !node.isTypeOf && qualifier !== void 0 && ts.isIdentifier(qualifier) && qualifier.text === TS_NODE_OPTIONS;
   return isGeneratorModule && isOptions ? qualifier : void 0;
 }
-function referencedName$1(node) {
+function referencedName$2(node) {
   if (ts.isTypeReferenceNode(node)) {
     return node.typeName;
   }
@@ -965,7 +972,7 @@ function optionsTypeName(node, bindings) {
   if (ts.isImportTypeNode(node)) {
     return importTypeName(node);
   }
-  const name = referencedName$1(node);
+  const name = referencedName$2(node);
   if (name !== void 0 && ts.isIdentifier(name)) {
     const binding = bindings.bindingOf(name);
     return binding?.kind === "helper-import" && binding.name === TS_NODE_OPTIONS ? name : void 0;
@@ -978,7 +985,7 @@ function optionsTypeName(node, bindings) {
   return isGeneratorModule && parts.right.text === TS_NODE_OPTIONS ? parts.right : void 0;
 }
 function localTypeOf(node, bindings) {
-  const name = referencedName$1(node);
+  const name = referencedName$2(node);
   const binding = name !== void 0 && ts.isIdentifier(name) ? bindings.bindingOf(name) : void 0;
   return binding?.kind === "local-type" ? binding.declaration : void 0;
 }
@@ -2072,10 +2079,10 @@ const PNPM_SETTINGS_FIELD = "pnpm";
 const OLD_PEER_DEPENDENTS = /* @__PURE__ */ new Map([
   ["swr-openapi", { peer: "openapi-fetch", range: ">=0.15" }]
 ]);
-const PATH_SEPARATOR$a = "/";
+const PATH_SEPARATOR$b = "/";
 const QUERY_START = "?";
 function renamedSpecifier(value) {
-  const ends = [value.indexOf(PATH_SEPARATOR$a), value.indexOf(QUERY_START)].filter(
+  const ends = [value.indexOf(PATH_SEPARATOR$b), value.indexOf(QUERY_START)].filter(
     (at) => at !== -1
   );
   const name = value.slice(0, ends.length === 0 ? value.length : Math.min(...ends));
@@ -2085,12 +2092,12 @@ function renamedSpecifier(value) {
   }
   const rest = value.slice(name.length);
   const subpath = rest.split(QUERY_START, 1)[0] ?? rest;
-  return { to: `${renamed}${rest}`, isDeep: subpath !== "" && subpath !== PATH_SEPARATOR$a };
+  return { to: `${renamed}${rest}`, isDeep: subpath !== "" && subpath !== PATH_SEPARATOR$b };
 }
 const NODE_MODULES_FOLDER = "node_modules/";
 function oldPackageInNodeModules(path) {
   return [...PACKAGE_RENAMES.keys()].find(
-    (name) => path.includes(`${NODE_MODULES_FOLDER}${name}${PATH_SEPARATOR$a}`) || path.endsWith(`${NODE_MODULES_FOLDER}${name}`)
+    (name) => path.includes(`${NODE_MODULES_FOLDER}${name}${PATH_SEPARATOR$b}`) || path.endsWith(`${NODE_MODULES_FOLDER}${name}`)
   );
 }
 
@@ -2203,22 +2210,166 @@ 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 init programs of containers run their arguments as the container's command, so an
+  // entrypoint `["tini", "--"]` gives the generator the command's flags.
+  launcher(["tini"], NONE, /* @__PURE__ */ new Set(["-p", "-e"])),
+  launcher(["docker-init"], NONE, /* @__PURE__ */ new Set(["-p", "-e"])),
+  launcher(["dumb-init"], NONE, /* @__PURE__ */ new Set(["-r", "--rewrite"])),
+  launcher(["catatonit"]),
+  withOperands(["gosu"], 1),
+  withOperands(["su-exec"], 1),
+  // 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 = '"';
+const DOUBLE_QUOTE$2 = '"';
 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 +2383,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,8 +2407,20 @@ 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 isQuoted = raw.length > 1 && raw.startsWith(DOUBLE_QUOTE$2) && raw.endsWith(DOUBLE_QUOTE$2);
   const inner = isQuoted ? 1 : 0;
   return raw.startsWith(EXPRESSION_OPEN, inner) && expressionEnd(raw, inner) === raw.length - inner;
 }
@@ -2272,7 +2436,7 @@ const COMMAND_SEPARATORS = /* @__PURE__ */ new Set([
 ]);
 const WORD_BREAKS = /* @__PURE__ */ new Set([" ", "	", "\r", "<", ">"]);
 const BACKSLASH$2 = "\\";
-const DOUBLE_QUOTE_ESCAPES = /* @__PURE__ */ new Set(["$", "`", '"', BACKSLASH$2, "\n"]);
+const DOUBLE_QUOTE_ESCAPES$1 = /* @__PURE__ */ new Set(["$", "`", '"', BACKSLASH$2, "\n"]);
 function singleQuoted(text, start) {
   const close = text.indexOf("'", start + 1);
   const end = close === -1 ? text.length : close + 1;
@@ -2283,7 +2447,7 @@ function doubleQuoted(text, start) {
   let index = start + 1;
   while (index < text.length && text[index] !== '"') {
     const next = text[index + 1] ?? "";
-    const isEscape = text[index] === BACKSLASH$2 && DOUBLE_QUOTE_ESCAPES.has(next);
+    const isEscape = text[index] === BACKSLASH$2 && DOUBLE_QUOTE_ESCAPES$1.has(next);
     value += isEscape ? next === "\n" ? "" : next : text[index];
     index += isEscape ? 2 : 1;
   }
@@ -2360,6 +2524,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$1.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;
@@ -2392,6 +2587,42 @@ function readWord(text, start) {
   return { start, end: index, value, raw: text.slice(start, index) };
 }
 
+const writtenOffset = (word, index) => word.written?.[index] ?? word.start + index;
+function rawText(word, from, text) {
+  return { text, offsets: Array.from(text, (_, index) => writtenOffset(word, from + index)) };
+}
+function unquotedRawText(word, from) {
+  const { value, offsets } = unquotedText(word.raw.slice(from));
+  return { text: value, offsets: offsets.map((index) => writtenOffset(word, from + index)) };
+}
+function placedWord(word, { offsets }) {
+  const written = Array.from(word.raw, (_, index) => {
+    return offsets[writtenOffset(word, index)];
+  });
+  const start = written[0] ?? offsets[word.start];
+  const end = (written.at(-1) ?? start - 1) + 1;
+  const isInOnePiece = written.every((offset, index) => offset === start + index);
+  const placed = { start, end, value: word.value, raw: word.raw };
+  return isInOnePiece ? placed : { ...placed, written };
+}
+function movedWord(word, offset) {
+  const moved = { ...word, start: word.start + offset, end: word.end + offset };
+  return word.written === void 0 ? moved : { ...moved, written: word.written.map((at) => at + offset) };
+}
+function writtenSpan(word, from, length) {
+  const first = writtenOffset(word, from);
+  const last = writtenOffset(word, from + length - 1);
+  return last - first === length - 1 ? { start: first, end: last + 1 } : void 0;
+}
+function placedSpan({ offsets }, length) {
+  const first = offsets[0];
+  const last = offsets[length - 1];
+  if (first === void 0 || last === void 0 || last - first !== length - 1) {
+    return void 0;
+  }
+  return { start: first, end: last + 1 };
+}
+
 const ASSIGNMENT_RE$2 = /^([A-Za-z_][A-Za-z0-9_]*)(\+?=)/;
 const APPEND_OPERATOR$1 = "+=";
 const DECLARATION_BUILTINS = /* @__PURE__ */ new Set([
@@ -2401,99 +2632,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;
 }
+const ARGUMENT_ASSIGNMENT_RE = /^([A-Za-z_][A-Za-z0-9_.-]*)(:::=|::=|:=|\?=|!=|\+?=)/;
+function assignmentOf(word, pattern = ASSIGNMENT_RE$2) {
+  const match = pattern.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((word) => assignmentOf(word));
 }
+function argumentAssignments(command) {
+  const own = new Set(shellAssignments(command).map(({ word }) => word));
+  return command.slice(leadingAssignments(command)).filter((word) => !own.has(word)).flatMap((word) => assignmentOf(word, ARGUMENT_ASSIGNMENT_RE));
+}
+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] ?? "";
-  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 };
+function assignmentValue(assignment) {
+  const { word, head } = assignment;
+  return isArrayAssignment(assignment) ? rawText(word, head + 1, word.raw.slice(head + 1, -1)) : unquotedRawText(word, head);
 }
 
-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$1 = "--";
+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 FOLDERS_RE = /^.*[/\\]/;
+const entryWord = (word) => word === void 0 ? void 0 : withoutWindowsSuffix(word.value.replace(FOLDERS_RE, ""));
+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$1) {
+      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 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 assignments = new Set(shellAssignments(words).map(({ word }) => word));
+  const namesOld = (word) => namesOldPackage(word.value) || namesOldPackage(values.get(word) ?? "");
+  return words.filter((word) => !handledOffsets.has(word.start) && !assignments.has(word) && namesOld(word)).map((word) => ({
+    offset: word.start,
+    manualStep: { kind: "old-name-in-command", location: locate(word.start), word: word.value }
+  }));
+}
+
+const PATH_SEPARATOR$a = "/";
+const WINDOWS_SEPARATOR_RE = /\\/g;
+const QUOTE_RE = /["']/g;
+const WINDOWS_PATH_RE = /^[^/]*[^\\/\s]\\[^\\/\s][^/]*$/;
+function programPath(word) {
+  const suffix = windowsSuffix(word.value);
+  const written = word.raw.replace(QUOTE_RE, "");
+  const isWindowsPath = suffix !== "" || WINDOWS_PATH_RE.test(written);
+  if (!isWindowsPath) {
+    return { path: word.value, suffix, written: word.value };
+  }
+  return { path: written.replace(WINDOWS_SEPARATOR_RE, PATH_SEPARATOR$a), suffix, written };
+}
+
+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
+};
+const PATH_SEPARATOR$9 = "/";
+const BIN_FOLDER$1 = "/.bin/";
+function namesGenerator(word) {
+  const { path, suffix } = programPath(word);
+  if (path.includes(PATH_SEPARATOR$9)) {
+    return path.endsWith(`${BIN_FOLDER$1}${GENERATOR_COMMAND}${suffix}`);
+  }
+  return packageReference(path.slice(0, path.length - suffix.length)).name === GENERATOR_COMMAND;
+}
+function runsGenerator(command) {
+  const words = withoutRecipePrefix(command);
+  const { program } = commandRoles(words);
+  const word = program === void 0 ? void 0 : words[program];
+  return word !== void 0 && namesGenerator(word);
+}
+
+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$7 = "\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$7, 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([
@@ -2544,7 +2933,7 @@ const USES = {
   "=": "assign",
   "+": "alternative"
 };
-const SINGLE_QUOTE = "'";
+const SINGLE_QUOTE$1 = "'";
 const BACKSLASH$1 = "\\";
 function expansionAt(text, start) {
   const head = EXPANSION_HEAD_RE.exec(text.slice(start));
@@ -2566,8 +2955,8 @@ function wordExpansions(raw) {
   const found = [];
   for (let index = 0; index < raw.length; ) {
     const char = raw[index];
-    if (char === SINGLE_QUOTE) {
-      const close = raw.indexOf(SINGLE_QUOTE, index + 1);
+    if (char === SINGLE_QUOTE$1) {
+      const close = raw.indexOf(SINGLE_QUOTE$1, index + 1);
       index = close === -1 ? raw.length : close + 1;
     } else if (char === BACKSLASH$1) {
       index += 2;
@@ -2581,17 +2970,45 @@ function wordExpansions(raw) {
   }
   return found;
 }
-const DOUBLE_QUOTE = '"';
+const DOUBLE_QUOTE$1 = '"';
 function wholeWordExpansion(raw) {
-  const isQuoted = raw.length > 1 && raw.startsWith(DOUBLE_QUOTE) && raw.endsWith(DOUBLE_QUOTE);
+  const isQuoted = raw.length > 1 && raw.startsWith(DOUBLE_QUOTE$1) && raw.endsWith(DOUBLE_QUOTE$1);
   const inner = isQuoted ? 1 : 0;
   const [expansion] = wordExpansions(raw);
   const isWhole = expansion?.expansionStart === inner && expansion.expansionEnd === raw.length - inner;
   return isWhole ? expansion : void 0;
 }
 
+const SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh", "ksh"]);
+const OPTION_PREFIXES = ["-", "+"];
+const SHORT_OPTION_PREFIX = "-";
+const LONG_OPTION_PREFIX = "--";
+const END_OF_OPTIONS = "--";
+const COMMAND_OPTION = "c";
+const SET_OPTIONS = /* @__PURE__ */ new Set(["-o", "+o"]);
+const PATH_SEPARATOR$8 = "/";
+const isShellOption = (word) => OPTION_PREFIXES.some((prefix) => word.startsWith(prefix));
+function shellScript(words) {
+  const program = words[0]?.value.split(PATH_SEPARATOR$8).at(-1) ?? "";
+  if (!SHELLS.has(program)) {
+    return void 0;
+  }
+  let hasCommandOption = false;
+  let index = 1;
+  for (let word = words[index]?.value; word !== void 0; word = words[index]?.value) {
+    if (word === END_OF_OPTIONS || !isShellOption(word)) {
+      const script = word === END_OF_OPTIONS ? words[index + 1] : words[index];
+      return hasCommandOption ? script : void 0;
+    }
+    const isShort = word.startsWith(SHORT_OPTION_PREFIX) && !word.startsWith(LONG_OPTION_PREFIX);
+    hasCommandOption ||= isShort && word.includes(COMMAND_OPTION);
+    index += SET_OPTIONS.has(word) ? 2 : 1;
+  }
+  return void 0;
+}
+
 const COMMENT = "#";
-const LINE_BREAK$4 = "\n";
+const LINE_BREAK$6 = "\n";
 function skipTrivia(text, index) {
   const char = text[index];
   if (WORD_BREAKS.has(char)) {
@@ -2621,7 +3038,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$6 && pending.length > 0) {
       const read = readBodies(text, index + 1, pending);
       heredocs.push(...read.bodies);
       pending = [];
@@ -2641,63 +3058,32 @@ 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 QUOTES$1 = /* @__PURE__ */ new Set(["'", '"']);
 const NESTED_COMMAND_RE = /[\s;&|()`]/;
-function nestedCommandText(word) {
+function isQuotedCommandLine(word) {
   const quote = word.raw[0];
-  const isOneQuotedString = QUOTES$2.has(quote) && word.raw.length > 1 && word.raw.endsWith(quote) && wordPart(word.raw, 0).end === word.raw.length;
-  return isOneQuotedString && NESTED_COMMAND_RE.test(word.value) ? word.raw.slice(1, -1) : void 0;
+  const isOneQuotedString = QUOTES$1.has(quote) && word.raw.length > 1 && word.raw.endsWith(quote) && wordPart(word.raw, 0).end === word.raw.length;
+  return isOneQuotedString && NESTED_COMMAND_RE.test(word.value);
+}
+function nestedCommandText(word, script) {
+  return word === script || isQuotedCommandLine(word) ? unquotedRawText(word, 0) : void 0;
 }
-const SHELLS$1 = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh", "ksh"]);
 const DOCKER_RUN = "RUN";
 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 PATH_SEPARATOR$7 = "/";
+const OPTION_PREFIX = "-";
+const programName$1 = (command) => command[0]?.value.split(PATH_SEPARATOR$7).at(-1) ?? "";
+const isOption = (word) => word.value.startsWith(OPTION_PREFIX);
+const isScriptShell = (command) => SHELLS.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] ?? []));
@@ -2705,9 +3091,11 @@ function scriptsRunBy(top, index, command) {
     (body) => body.command === index && readsScript(command) || body.command === previous && isPipedScript
   );
 }
-const shifted = (words, offset) => words.map((word) => ({ ...word, start: word.start + offset, end: word.end + offset }));
 function shellCommandsAt(text, offset, indent = 0) {
-  return shellCommands(text, indent).map((words) => shifted(words, offset));
+  return shellCommands(text, indent).map((words) => words.map((word) => movedWord(word, offset)));
+}
+function placedCommands(placed) {
+  return shellCommands(placed.text).map((words) => words.map((word) => placedWord(word, placed)));
 }
 function expansionCommands(word) {
   const expansions = wordExpansions(word.raw);
@@ -2715,20 +3103,27 @@ function expansionCommands(word) {
     ({ start }) => expansions.every((expansion) => start < expansion.start || start >= expansion.expansionEnd)
   );
   return [...expansions, ...literals].flatMap(
-    (part) => shellCommandsAt(part.text, word.start + part.start)
+    (part) => placedCommands(rawText(word, part.start, part.text))
   );
 }
+function commandLineAssignments(command) {
+  const read = [
+    ...shellAssignments(command),
+    ...argumentAssignments(command).filter(holdsCommandLine)
+  ];
+  return new Map(read.map((assignment) => [assignment.word, assignment]));
+}
 function innerCommands(command) {
-  const assignments = new Map(shellAssignments(command).map((found) => [found.word, found]));
+  const assignments = commandLineAssignments(command);
   const code = inlineCode(command)?.code;
+  const script = shellScript(command);
   return command.flatMap((word) => {
-    const inner = word === code ? void 0 : nestedCommandText(word);
+    const inner = word === code ? void 0 : nestedCommandText(word, script);
     if (inner !== void 0) {
-      return shellCommandsAt(inner, word.start + 1);
+      return placedCommands(inner);
     }
     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);
+    return assignment === void 0 ? expansionCommands(word) : placedCommands(assignmentValue(assignment));
   });
 }
 function shellCommands(text, indent = 0) {
@@ -2759,257 +3154,117 @@ function appendedPlace(earlierValues) {
 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:";
+      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 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 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)) };
+  });
 }
-function namesOldPackage(value) {
-  return PACKAGE_RENAMES.has(packageReference(value).name) || oldPackageInNodeModules(value) !== void 0 || value.endsWith(`/${GENERATOR_COMMAND}`);
+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 };
 }
-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 }
-  }));
+const isOwnGeneratorCommand = (place, command) => place === "after-outside" && command !== void 0 && runsGenerator(command);
+function appendedText(assignment) {
+  return placedCommands(assignmentValue(assignment));
+}
+const appendsOwnGenerator = ({ assignment, place }) => isOwnGeneratorCommand(place, appendedText(assignment)[0]);
+function setsKnownProgram(placed, all) {
+  const chain = all.slice(0, all.indexOf(placed) + 1).filter((earlier) => earlier.assignment.name === placed.assignment.name);
+  return chain.some((part) => part.place !== "after-outside" || appendsOwnGenerator(part));
+}
+function shellAppends(commands, variables) {
+  const appends = placedAssignments$1(commands).filter(isAfterValue).filter((placed) => !appendsOwnGenerator(placed)).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 passedFlag = (text) => text.split("=", 1)[0];
 function flagFindings(word, locate) {
-  const flag = word.raw.split("=", 1)[0];
+  const passed = unquotedRawText(word, 0);
+  const flag = passedFlag(passed.text);
   const to = FLAG_RENAMES.get(flag);
   if (to === void 0) {
     return [];
   }
   const offset = word.start;
-  const edit = { start: offset, end: offset + flag.length, text: to };
-  return [
-    { offset, edit, change: { kind: "flag-renamed", location: locate(offset), from: flag, to } }
-  ];
+  const location = locate(offset);
+  const span = placedSpan(passed, flag.length);
+  if (span === void 0) {
+    const manualStep = { kind: "split-flag", location, flag };
+    return [{ offset, manualStep }];
+  }
+  const edit = { ...span, text: to };
+  return [{ offset, edit, change: { kind: "flag-renamed", location, from: flag, to } }];
 }
 function renamedFlags(value) {
-  const flags = shellCommands(value).flat().map((word) => word.raw.split("=", 1)[0]);
+  const flags = shellCommands(value).flat().map((word) => passedFlag(word.value));
   return [...new Set(flags.filter((flag) => FLAG_RENAMES.has(flag)))];
 }
 function argumentFindings(word, locate, variables) {
@@ -3060,102 +3315,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;
-const WINDOWS_PATH_RE = /^[^/]*[^\\/\s]\\[^\\/\s][^/]*$/;
-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 };
-}
-
 const SHELL_VARIABLE_RE$1 = /^"?\$(?:([A-Za-z_][A-Za-z0-9_]*)|\{([A-Za-z_][A-Za-z0-9_]*)\})"?$/;
 function expandedName$1(text) {
   const match = SHELL_VARIABLE_RE$1.exec(text);
@@ -3180,8 +3339,12 @@ function expansionDefinitions(name, expansion) {
   const variable = isOutside ? { name, kind: "command", runsGenerator: false } : { name, kind: "reference", target: expansion.name };
   return [word, variable];
 }
-function programDefinitions$1({ name, value, isAppended }) {
-  if (isAppended === true) {
+function programDefinitions$1(definition) {
+  const { name, value } = definition;
+  if (definition.isAfterOutside === true) {
+    return [{ name, kind: "run-time" }];
+  }
+  if (definition.isAppended === true) {
     return [{ name, kind: "no-program" }];
   }
   const expansion = wholeWordExpansion(value.trim());
@@ -3220,12 +3383,14 @@ function assignedByExpansions(commands) {
   ]);
 }
 function withShellAssignments(commands, file) {
-  const assigned = placedAssignments$1(commands).flatMap((placed) => {
-    const { assignment, place } = placed;
-    if (isArrayAssignment(assignment) || place === "after-outside") {
+  const placed = placedAssignments$1(commands);
+  const assigned = placed.flatMap((entry) => {
+    const { assignment } = entry;
+    if (isArrayAssignment(assignment) || !setsKnownProgram(entry, placed)) {
       return [];
     }
-    return [{ name: assignment.name, value: assignment.value, isAppended: isAfterValue(placed) }];
+    const { name, value } = assignment;
+    return appendsOwnGenerator(entry) ? [{ name, value, isAfterOutside: true }] : [{ name, value, isAppended: isAfterValue(entry) }];
   });
   const definitions = [...assigned, ...assignedByExpansions(commands)];
   if (definitions.length === 0) {
@@ -3273,18 +3438,19 @@ function withUnreadVariables(variables) {
   };
 }
 
-const QUOTES$1 = /* @__PURE__ */ new Set(["'", '"']);
-const PATH_SEPARATOR$7 = "/";
+const QUOTES = /* @__PURE__ */ new Set(["'", '"']);
+const PATH_SEPARATOR$6 = "/";
 const BIN_FOLDER = "/.bin/";
 const OLD_PACKAGE_FOLDER = `node_modules/${GENERATOR_COMMAND}/`;
 function renameAtEnd(word, name, to, suffix = "") {
   const at = word.raw.lastIndexOf(name);
   const tail = word.raw.slice(at + name.length);
   const quote = tail.slice(suffix.length);
-  if (at === -1 || quote !== "" && !QUOTES$1.has(quote)) {
+  if (at === -1 || quote !== "" && !QUOTES.has(quote)) {
     return void 0;
   }
-  return { start: word.start + at, end: word.start + at + name.length, text: to };
+  const span = writtenSpan(word, at, name.length);
+  return span === void 0 ? void 0 : { ...span, text: to };
 }
 function packageFindings(found, locate) {
   const { name, isPinned } = packageReference(found.value);
@@ -3301,19 +3467,23 @@ 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$6}${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) {
   const program = programPath(word);
-  if (program.path.includes(PATH_SEPARATOR$7)) {
+  if (program.path.includes(PATH_SEPARATOR$6)) {
     return programPathFindings(word, program, location);
   }
   const { path, suffix } = program;
@@ -3371,12 +3541,24 @@ 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 uniqueFindings(found) {
+  const seen = /* @__PURE__ */ new Set();
+  return found.filter((finding) => {
+    const key = JSON.stringify(finding);
+    const isNew = !seen.has(key);
+    seen.add(key);
+    return isNew;
+  });
+}
+function textFindings(found) {
+  const findings = uniqueFindings(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 +3679,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([
@@ -3514,13 +3698,13 @@ const NO_LONGER_INSTALLED = /* @__PURE__ */ new Map([
 const ORIGINAL_NAMES = new Map(
   [...PACKAGE_RENAMES].map(([original, successor]) => [successor, original])
 );
-const PATH_SEPARATOR$6 = "/";
+const PATH_SEPARATOR$5 = "/";
 function namesUninstalledPackage(text) {
   return [...NO_LONGER_INSTALLED.keys()].some(
     (name) => text.includes(name) || text.includes(ORIGINAL_NAMES.get(name) ?? name)
   );
 }
-const directoryOf = (path) => path.slice(0, path.lastIndexOf(PATH_SEPARATOR$6) + 1);
+const directoryOf = (path) => path.slice(0, path.lastIndexOf(PATH_SEPARATOR$5) + 1);
 const isAtOrAbove = (path, filePath) => filePath.startsWith(directoryOf(path));
 function declaredNames(manifest) {
   return DEPENDENCY_FIELDS.flatMap((field) => mapsAt(manifest, field)).flatMap(textEntries).map(({ key }) => key.value);
@@ -3545,7 +3729,7 @@ function isDeclaredFor(manifests, filePath, name) {
   return containing.length === 0 || containing.some(declares);
 }
 const packageOfSpecifier = (specifier) => {
-  const slash = specifier.indexOf(PATH_SEPARATOR$6);
+  const slash = specifier.indexOf(PATH_SEPARATOR$5);
   return slash === -1 ? specifier : specifier.slice(0, slash);
 };
 function undeclaredImportSteps(imports, filePath, manifests) {
@@ -3556,22 +3740,225 @@ function undeclaredImportSteps(imports, filePath, manifests) {
   });
 }
 
+const ARGUMENTS_WORDS = new Set(
+  ["$", "$$"].flatMap(
+    (dollar) => ["@", "{@}"].flatMap((name) => ["", '"'].map((quote) => `${quote}${dollar}${name}${quote}`))
+  )
+);
+function runsArguments(script) {
+  return shellCommands(script).some((words) => {
+    const { program } = commandRoles(words);
+    return program !== void 0 && ARGUMENTS_WORDS.has(words[program]?.raw ?? "");
+  });
+}
+function runsItsCommand(entrypoint) {
+  const script = shellScript(entrypoint);
+  return script === void 0 || runsArguments(script.value);
+}
+function containerCommand(entrypoint, command) {
+  return runsGenerator(command) && runsItsCommand(entrypoint) ? [entrypoint, command] : [[...entrypoint, ...command]];
+}
+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 entrypointPairs(text, forms) {
+  const stages = dockerStages(text, forms);
+  return stages.flatMap((stage, index) => {
+    const entrypoint = entrypointOf(stages, index)?.form;
+    const command = stage.command?.form;
+    return entrypoint === void 0 || command === void 0 ? [] : [{ entrypoint, command }];
+  });
+}
+function entrypointCommandFindings(pairs, locate) {
+  return pairs.flatMap(({ entrypoint, command }) => {
+    if (shellScript(entrypoint.words) === void 0) {
+      return [];
+    }
+    const pair = { entrypoint: entrypoint.words, command: command.words };
+    return entrypointArgumentFindings({ ...pair, written: ENTRYPOINT_WRITTEN }, locate);
+  });
+}
+
+const DEFAULT_ESCAPE = "\\";
+const DIRECTIVE_RE = /^#[ \t]*([A-Za-z]+)[ \t]*=[ \t]*(\S+)[ \t]*$/;
+const ESCAPE_DIRECTIVE = "escape";
+const LINE_BREAK$5 = "\n";
+const CARRIAGE_RETURN = "\r";
+const BLANKS = /* @__PURE__ */ new Set([" ", "	", CARRIAGE_RETURN, LINE_BREAK$5]);
+const SINGLE_QUOTE = "'";
+const DOUBLE_QUOTE = '"';
+const DOUBLE_QUOTE_ESCAPES = /* @__PURE__ */ new Set([DOUBLE_QUOTE, "$"]);
+const ASSIGNMENT$1 = "=";
+const VARIABLE_INSTRUCTIONS = /* @__PURE__ */ new Set(["ARG", "ENV"]);
+const LEGACY_ENV_INSTRUCTION = "ENV";
+function escapeCharacter(text) {
+  for (const line of text.split(LINE_BREAK$5)) {
+    const directive = DIRECTIVE_RE.exec(line.replace(CARRIAGE_RETURN, ""));
+    if (directive === null) {
+      return DEFAULT_ESCAPE;
+    }
+    if (directive[1]?.toLowerCase() === ESCAPE_DIRECTIVE) {
+      return directive[2];
+    }
+  }
+  return DEFAULT_ESCAPE;
+}
+function instructionEnd(text, index, escapeMark) {
+  for (let end = text.indexOf(LINE_BREAK$5, index); end !== -1; ) {
+    if (!text.slice(index, end).trimEnd().endsWith(escapeMark)) {
+      return end;
+    }
+    index = end + 1;
+    end = text.indexOf(LINE_BREAK$5, index);
+  }
+  return text.length;
+}
+const add = (word, text, index) => {
+  word.value += text[index];
+  word.offsets.push(index);
+};
+function isContinuation(text, index, escapeMark) {
+  const lineEnd = text.indexOf(LINE_BREAK$5, index);
+  return text[index] === escapeMark && lineEnd !== -1 && text.slice(index + 1, lineEnd).trim() === "";
+}
+function isQuotedEscape(text, index, escapeMark) {
+  const next = text[index + 1] ?? "";
+  return text[index] === escapeMark && (DOUBLE_QUOTE_ESCAPES.has(next) || next === escapeMark);
+}
+function readQuoted(text, index, word, escapeMark) {
+  const quote = text[index];
+  let at = index + 1;
+  for (; at < text.length && text[at] !== quote; at++) {
+    if (isContinuation(text, at, escapeMark)) {
+      at = text.indexOf(LINE_BREAK$5, at);
+    } else {
+      at += quote === DOUBLE_QUOTE && isQuotedEscape(text, at, escapeMark) ? 1 : 0;
+      add(word, text, at);
+    }
+  }
+  return at + 1;
+}
+function readPart(text, index, word, escapeMark) {
+  const char = text[index];
+  if (char === SINGLE_QUOTE || char === DOUBLE_QUOTE) {
+    return readQuoted(text, index, word, escapeMark);
+  }
+  const end = index + (char === escapeMark && index + 1 < text.length ? 2 : 1);
+  add(word, text, end - 1);
+  return end;
+}
+function endWord(word, words) {
+  const value = word.value.trimEnd();
+  if (value !== "") {
+    words.push({ text: value, offsets: word.offsets.slice(0, value.length) });
+  }
+  return { value: "", offsets: [] };
+}
+function dockerWords(text, range, escapeMark, isWhole = false) {
+  const words = [];
+  const instruction = text.slice(0, range.end);
+  let word = { value: "", offsets: [] };
+  for (let index = range.start; index < range.end; ) {
+    if (isContinuation(text, index, escapeMark)) {
+      index = text.indexOf(LINE_BREAK$5, index) + 1;
+    } else if (BLANKS.has(text[index]) && (!isWhole || word.value === "")) {
+      word = endWord(word, words);
+      index++;
+    } else {
+      index = readPart(instruction, index, word, escapeMark);
+    }
+  }
+  endWord(word, words);
+  return words;
+}
+function assignedVariable({ text, offsets }) {
+  const at = text.indexOf(ASSIGNMENT$1);
+  if (at <= 0) {
+    return [];
+  }
+  return [
+    {
+      name: text.slice(0, at),
+      value: { text: text.slice(at + 1), offsets: offsets.slice(at + 1) }
+    }
+  ];
+}
+function instructionVariables(text, keyword, range, escapeMark) {
+  const [first, ...rest] = dockerWords(text, range, escapeMark);
+  if (first === void 0) {
+    return [];
+  }
+  if (keyword === LEGACY_ENV_INSTRUCTION && !first.text.includes(ASSIGNMENT$1)) {
+    const valueStart = rest[0]?.offsets[0] ?? range.end;
+    const [value] = dockerWords(text, { start: valueStart, end: range.end }, escapeMark, true);
+    return [{ name: first.text, value: value ?? { text: "", offsets: [] } }];
+  }
+  return [first, ...rest].flatMap(assignedVariable);
+}
+function variableInstructions(text, commands) {
+  const escapeMark = escapeCharacter(text);
+  return commands.flatMap(([keyword]) => {
+    if (keyword === void 0 || !VARIABLE_INSTRUCTIONS.has(keyword.value)) {
+      return [];
+    }
+    const range = { start: keyword.end, end: instructionEnd(text, keyword.end, escapeMark) };
+    const variables = instructionVariables(text, keyword.value, range, escapeMark);
+    return [{ start: keyword.start, end: range.end, variables }];
+  });
+}
+
 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 = ",";
 const NOT_LINE_BREAK_RE$1 = /[^\n]/g;
 const ARRAY_END = "]";
-const VARIABLE_INSTRUCTIONS = /* @__PURE__ */ new Set(["ARG", "ENV"]);
-const LEGACY_ENV_INSTRUCTION = "ENV";
-const ASSIGNMENT$1 = "=";
-const QUOTES = /* @__PURE__ */ new Set(['"', "'"]);
 function matchAt(pattern, text, index) {
   pattern.lastIndex = index;
   return pattern.exec(text)?.[0];
@@ -3615,30 +4002,18 @@ 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) {
+function execCommands(forms, pairs) {
+  const paired = new Set(pairs.map((pair) => pair.command));
   const commands = [];
   const escaped = [];
-  for (const { words } of forms) {
+  const read = [
+    ...forms.filter((form) => !paired.has(form)).map((form) => form.words),
+    ...pairs.flatMap((pair) => containerCommand(pair.entrypoint.words, pair.command.words))
+  ];
+  for (const words of read) {
     commands.push(words);
     const script = shellScript(words);
     if (script !== void 0 && script.raw === script.value) {
@@ -3647,7 +4022,8 @@ function execCommands(forms) {
       escaped.push(script);
     }
   }
-  return { commands, escaped };
+  const scripts = new Map(escaped.map((script) => [script.start, script]));
+  return { commands, escaped: [...scripts.values()] };
 }
 function withoutExecForms(text, forms) {
   const parts = [];
@@ -3668,39 +4044,6 @@ function escapedScriptSteps(scripts, lineOf) {
     return migrated === script.value ? [] : [{ kind: "command-string", line: lineOf(script.start), to: migrated }];
   });
 }
-function assignedVariable(word) {
-  const at = word.raw.indexOf(ASSIGNMENT$1);
-  if (at <= 0) {
-    return void 0;
-  }
-  const raw = word.raw.slice(at + 1);
-  const isQuoted = raw.length >= 2 && QUOTES.has(raw[0]) && raw.at(-1) === raw[0];
-  const value = isQuoted ? raw.slice(1, -1) : raw;
-  const start = word.start + at + 1 + (isQuoted ? 1 : 0);
-  return { name: word.raw.slice(0, at), value, start };
-}
-function instructionVariables(text, words) {
-  const [instruction, first, ...rest] = words;
-  const last = rest.at(-1);
-  if (instruction.value === LEGACY_ENV_INSTRUCTION && !first.raw.includes(ASSIGNMENT$1)) {
-    const value = last === void 0 ? "" : text.slice(rest[0]?.start, last.end);
-    return [{ name: first.value, value, start: rest[0]?.start ?? first.end }];
-  }
-  return [first, ...rest].flatMap((word) => assignedVariable(word) ?? []);
-}
-function variableInstructions(text, commands) {
-  return commands.flatMap((words) => {
-    const [instruction, first] = words;
-    if (instruction === void 0 || first === void 0) {
-      return [];
-    }
-    if (!VARIABLE_INSTRUCTIONS.has(instruction.value)) {
-      return [];
-    }
-    const end = words.at(-1).end;
-    return [{ start: instruction.start, end, variables: instructionVariables(text, words) }];
-  });
-}
 function withoutVariableInstructions(commands, instructions) {
   const isInInstruction = (words) => {
     const start = words[0]?.start ?? -1;
@@ -3710,22 +4053,29 @@ function withoutVariableInstructions(commands, instructions) {
   };
   return commands.filter((words) => !isInInstruction(words));
 }
-const valueCommands = ({ value, start }) => shellCommandsAt(value, start);
 function migrateDockerfile(text, file) {
   const lineOf = lineLocator(text);
   const locate = (offset) => `${file}:${lineOf(offset)}`;
   const forms = execForms(text);
-  const exec = execCommands(forms);
+  const pairs = entrypointPairs(text, forms);
+  const exec = execCommands(forms, pairs);
   const shellForm = shellCommands(withoutExecForms(text, forms));
   const instructions = variableInstructions(text, shellForm);
-  const definitions = instructions.flatMap((instruction) => instruction.variables);
-  const values = definitions.flatMap(valueCommands);
+  const variables = instructions.flatMap((instruction) => instruction.variables);
+  const definitions = variables.map(({ name, value }) => ({ name, value: value.text }));
+  const values = variables.flatMap(({ value }) => placedCommands(value));
   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(pairs, 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 +4641,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 +4651,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 +4674,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 +4698,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 +4727,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 +4835,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 +4866,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 +4886,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 +4907,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 +5110,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 +5174,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;
 }
@@ -4857,7 +5207,7 @@ function withoutAssignmentHeads(text, assignments) {
 }
 const COMPUTED_RE = /^\$[({]/;
 const isComputed = (written) => COMPUTED_RE.test(written.trim().replace(RECIPE_PREFIX_RE, ""));
-function referencedName(written) {
+function referencedName$1(written) {
   const match = VARIABLE_REFERENCE_RE.exec(written.trim().replace(RECIPE_PREFIX_RE, ""));
   return match === null ? void 0 : match[1] ?? match[2] ?? match[3];
 }
@@ -4875,7 +5225,7 @@ function valueDefinition(text, { name, valueStart, valueEnd }, commands) {
     return { name, kind: "no-program" };
   }
   const program = programWritten(text, first);
-  const target = referencedName(program);
+  const target = referencedName$1(program);
   if (target !== void 0) {
     return { name, kind: "reference", target };
   }
@@ -4911,9 +5261,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 } };
@@ -4931,7 +5284,7 @@ function variableValues(text, assignments) {
 }
 function makefileVariables(text, assignments, programs) {
   const values = variableValues(text, assignments);
-  const nameAt = (word) => referencedName(text.slice(word.start, word.end));
+  const nameAt = (word) => referencedName$1(text.slice(word.start, word.end));
   const variables = {
     programAt: (program) => {
       const written = text.slice(program.start, program.end);
@@ -5241,12 +5594,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 +5667,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 +5682,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 +5704,135 @@ function withInputDefaults(variables, strings) {
   };
 }
 
+const ARGUMENT_KEYS = /* @__PURE__ */ new Map([
+  ["entrypoint", ["command", "args"]],
+  ["command", ["args"]]
+]);
+const PAIRED_KEYS = /* @__PURE__ */ new Set([
+  ...ARGUMENT_KEYS.keys(),
+  ...[...ARGUMENT_KEYS.values()].flat()
+]);
+const MERGE_KEY = "<<";
+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]);
+function mapOf(string) {
+  const path = string.path.slice(0, isItem(string) ? -2 : -1);
+  let isMerged = false;
+  for (; ; ) {
+    if (path.at(-1) === MERGE_KEY) {
+      path.pop();
+    } else if (typeof path.at(-1) === "number" && path.at(-2) === MERGE_KEY) {
+      path.splice(-2);
+    } else {
+      return { map: JSON.stringify(path), isMerged };
+    }
+    isMerged = true;
+  }
+}
+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 = [];
+  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) {
+      continue;
+    }
+    const last = values.at(-1);
+    if (last !== void 0 && isNextItem(last, string)) {
+      last.strings.push(string);
+    } else {
+      values.push({ ...mapOf(string), key, strings: [string] });
+    }
+  }
+  return values;
+}
+function mapValues(values) {
+  const maps = [];
+  const latest = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    let map = latest.get(value.map);
+    if (map === void 0 || !value.isMerged && map.own.has(value.key)) {
+      map = { own: /* @__PURE__ */ new Map(), merged: /* @__PURE__ */ new Map() };
+      maps.push(map);
+      latest.set(value.map, map);
+    }
+    const values2 = value.isMerged ? map.merged : map.own;
+    if (!values2.has(value.key)) {
+      values2.set(value.key, value);
+    }
+  }
+  return maps;
+}
+function containerOf({ own, merged }) {
+  const keyValue = (key) => own.get(key) ?? merged.get(key);
+  for (const [key, argumentKeys] of ARGUMENT_KEYS) {
+    const entrypoint = keyValue(key);
+    if (entrypoint !== void 0) {
+      const argumentKey = argumentKeys.find((found) => keyValue(found) !== void 0);
+      return [
+        { entrypoint, command: argumentKey === void 0 ? void 0 : keyValue(argumentKey) }
+      ];
+    }
+  }
+  return [];
+}
+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 commands = shellCommands(isPlaced ? text.slice(start, end) : scalar.value);
+  const at = (word) => isPlaced ? movedWord(word, start) : { ...word, start: scalar.start, end: scalar.start };
+  return { words: (commands[0] ?? []).map(at), isPlaced, isWhole: commands.length <= 1 };
+}
+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, isWhole: true };
+}
+const isJoinable = (words) => words.isPlaced && words.isWhole;
+function containerReading({ entrypoint, command }, text, locate) {
+  const first = valueWords(entrypoint, text);
+  if (command === void 0) {
+    return { commands: isList(entrypoint) ? [first.words] : [], flags: [], scalars: [] };
+  }
+  const args = valueWords(command, text);
+  const pair = { entrypoint: first.words, command: args.words, written: entrypoint.key };
+  if (isJoinable(first) && isJoinable(args)) {
+    const isScript = shellScript(first.words) !== void 0;
+    return {
+      commands: containerCommand(first.words, args.words),
+      flags: isScript ? entrypointArgumentFindings(pair, locate) : [],
+      scalars: [entrypoint, command].filter((part) => !isList(part)).flatMap((part) => part.strings)
+    };
+  }
+  const lists = [entrypoint, command].filter(isList).map((part) => valueWords(part, text).words);
+  const flags = entrypointArgumentFindings({ ...pair, isPlaced: args.isPlaced }, locate);
+  return { commands: lists, flags, scalars: [] };
+}
+function containerCommands(text, strings, locate) {
+  const found = mapValues(keyValues(strings)).flatMap(containerOf).map((container) => containerReading(container, text, locate));
+  const commands = found.flatMap((reading) => reading.commands);
+  const scripts = commands.flatMap((words) => shellScript(words)?.item ?? []);
+  const flags = found.flatMap((reading) => reading.flags);
+  return {
+    findings: [commandWordFindings(commands, locate), textFindings(flags)],
+    scripts: new Set(scripts),
+    commandStrings: new Set(found.flatMap((reading) => reading.scalars.map(({ start }) => start)))
+  };
+}
+
 const YAML_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "run",
   "script",
@@ -5388,34 +5857,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 +6019,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 +6033,109 @@ 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 WORKFLOW_ENVIRONMENT = {
+  ...PLAIN,
+  keys: /* @__PURE__ */ new Set(),
+  reference: ENV_EXPRESSION_RE
+};
+const asShellVariable = (reference, name) => `$${name}`.padEnd(reference.length, " ");
+const YAML_FILE_KINDS = [
+  DEFAULT_YAML_FILE,
+  GITLAB_CI_FILE,
+  CI_ENVIRONMENT_FILE,
+  CIRCLECI_FILE,
+  COMPOSE_FILE,
+  TASKFILE,
+  AZURE_PIPELINES_FILE
+];
+const referencedName = (environment, groups) => environment.shellName(
+  groups.find((part) => typeof part === "string") ?? "",
+  VARIABLES_KEY
+);
+function referencedVariables(text) {
+  const environments = [...YAML_FILE_KINDS.map((kind) => kind.environment), WORKFLOW_ENVIRONMENT];
+  return environments.flatMap(
+    (environment) => environment.reference === void 0 ? [] : [...text.matchAll(environment.reference)].map(
+      (match) => referencedName(environment, match.slice(1))
+    )
+  );
+}
+function withToolReferences(text, { environment, names }) {
+  const { reference } = environment;
+  if (reference === void 0) {
+    return text;
   }
-  while (isInItem(strings[last + 1])) {
-    last += 1;
+  return text.replace(reference, (written, ...groups) => {
+    const name = referencedName(environment, groups);
+    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" && isKey(outer)) {
+    return { name: owner, key: outer };
   }
-  if (hasValueMaps && last === VALUE_KEY && typeof owner === "string" && keys.has(String(outer))) {
-    return named(owner, 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 +6144,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 +6188,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 +6222,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 +6238,31 @@ 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) {
+const NO_NAMES = /* @__PURE__ */ new Set();
+function migrateYamlCommands(text, file, strings, reading = DEFAULT_YAML_FILE) {
+  const { commandKeys, environment, parameters, outsideVariables = NO_NAMES } = reading;
   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 { findings, scripts, commandStrings } = containerCommands(text, strings, locate);
+  const isOwnCommand = (value) => !isContainerListItem(value) && !commandStrings.has(value.start);
+  const commandValues = new Set(values.filter(isOwnCommand));
   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 = /* @__PURE__ */ new Set([...[...entries.values()].map((entry) => entry.name), ...outsideVariables]);
+  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) }
   ]);
@@ -5654,7 +6309,7 @@ function listsByHook(strings, key) {
 }
 function entryWords(text, entry) {
   const { start } = entry.content;
-  return shellCommands(shellText(text, entry)).flat().map((word) => ({ ...word, start: word.start + start, end: word.end + start }));
+  return shellCommands(shellText(text, entry)).flat().map((word) => movedWord(word, start));
 }
 const itemWord = (text, item) => {
   const { start, end } = item.content;
@@ -5760,6 +6415,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) || referencedVariables(text).some((found) => names.has(found));
+}
+
 const withSteps = (migration, steps) => ({
   ...migration,
   manualSteps: [...migration.manualSteps, ...steps]
@@ -5784,7 +6458,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 +6583,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 +6603,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) {
@@ -5968,8 +6697,13 @@ const COMMAND_CONFIG_KINDS = [
   {
     matches: (path) => TASKFILE_NAMES.has(baseName(path)),
     migrate: whenNamed(
-      yamlConfig((_context, path) => [
-        usedStringsStep((text, strings) => migrateYamlCommands(text, path, strings, TASKFILE))
+      yamlConfig((context, path) => [
+        usedStringsStep(
+          (text, strings) => migrateYamlCommands(text, path, strings, {
+            ...TASKFILE,
+            outsideVariables: context.yamlReach.generatorVariables
+          })
+        )
       ])
     )
   },
@@ -5982,9 +6716,16 @@ 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),
+      outsideVariables: yamlReach.generatorVariables
+    })
+  )(text, read);
+};
 const manifestTarget = ({ version, catalogs, aliases }, path) => ({
   version,
   catalogs,
@@ -6060,11 +6801,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 +6963,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 +6990,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));
@@ -6352,6 +7090,7 @@ const NOT_ONLY_GENERATOR_NOTE = "may run openapi-typescript or another program (
 const OLD_NAME_IN_COMMAND_NOTE = "names an old package where the tool cannot tell what runs it (a script name, an argument of a program it does not know), so it was kept: migrate it by hand";
 const SCRIPT_NOT_SHELL_NOTE = "so the tool does not read it as commands: migrate the old package names in it by hand";
 const COMMAND_STRING_NOTE = "a string runs openapi-typescript, so it was kept; change it to";
+const SPLIT_FLAG_NOTE = "is an old flag of the generator that quotes split where it is written, so it was kept: rename";
 function pinnedPackageMessage(step) {
   const successor = PACKAGE_RENAMES.get(step.name) ?? step.name;
   return `${step.location} names a pinned ${step.name}@<version>: change it to ${successor}@<version>`;
@@ -6370,6 +7109,7 @@ const COMMAND_STEP_KINDS = /* @__PURE__ */ new Set([
   "pinned-package",
   "old-package-file",
   "old-name-in-command",
+  "split-flag",
   "script-not-shell",
   "command-string"
 ]);
@@ -6388,6 +7128,8 @@ function commandStepMessage(step) {
       return `${step.location}: ${step.path} ${OLD_FILE_NOTE$1}`;
     case "old-name-in-command":
       return `${step.location}: "${step.word}" ${OLD_NAME_IN_COMMAND_NOTE}`;
+    case "split-flag":
+      return `${step.location}: ${step.flag} ${SPLIT_FLAG_NOTE} ${flagRenames([step.flag])}`;
     case "script-not-shell":
       return `${step.location}: the script runs with ${step.shell}, ${SCRIPT_NOT_SHELL_NOTE}`;
     case "command-string":