openapi-typesafe-migrate 1.0.0-rc.11 → 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}`)
   );
 }
 
@@ -2311,6 +2318,14 @@ const LAUNCHERS = [
   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"]),
@@ -2341,7 +2356,7 @@ 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$1, index)) {
@@ -2405,7 +2420,7 @@ function mapExpressions(text, map) {
   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;
 }
@@ -2421,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;
@@ -2432,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;
   }
@@ -2512,7 +2527,7 @@ function wordPart(text, index) {
 function doubleQuotedOffsets(text, start, end) {
   const offsets = [];
   for (let index = start + 1; index < end && text[index] !== '"'; index++) {
-    const isEscape = text[index] === BACKSLASH$2 && DOUBLE_QUOTE_ESCAPES.has(text[index + 1] ?? "");
+    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);
@@ -2572,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([
@@ -2585,8 +2636,9 @@ function leadingAssignments(command) {
   const index = command.findIndex((word) => !ASSIGNMENT_RE$2.test(word.raw));
   return index === -1 ? command.length : index;
 }
-function assignmentOf(word) {
-  const match = ASSIGNMENT_RE$2.exec(word.raw);
+const 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 [];
@@ -2599,42 +2651,22 @@ 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(assignmentOf);
+  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(assignmentOf);
+  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 isArrayAssignment = (assignment) => assignment.word.raw.startsWith(ARRAY_OPEN, assignment.head);
-function arrayValue({ word, head }) {
-  const start = word.start + head + 1;
-  const place = (found) => ({
-    ...found,
-    start: found.start + start,
-    end: found.end + start
-  });
-  return { text: word.raw.slice(head + 1, -1), place };
-}
 function assignmentValue(assignment) {
-  if (isArrayAssignment(assignment)) {
-    return arrayValue(assignment);
-  }
   const { word, head } = assignment;
-  const { value, offsets } = unquotedText(word.raw.slice(head));
-  const written = (index) => head + offsets[index];
-  const place = (found) => {
-    const first = written(found.start);
-    const end = written(found.end - 1) + 1;
-    const raw = word.raw.slice(first, end);
-    return { ...found, start: word.start + first, end: word.start + end, raw };
-  };
-  return { text: value, place };
+  return isArrayAssignment(assignment) ? rawText(word, head + 1, word.raw.slice(head + 1, -1)) : unquotedRawText(word, head);
 }
 
-const END_OF_OPTIONS = "--";
+const END_OF_OPTIONS$1 = "--";
 const isOption$1 = (word) => word.value.startsWith("-") && word.value.length > 1;
 function skipAssignments(words, start) {
   let index = start;
@@ -2646,7 +2678,8 @@ function skipAssignments(words, start) {
 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);
+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)
@@ -2661,7 +2694,7 @@ 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) {
+    if (option.value === END_OF_OPTIONS$1) {
       break;
     }
     const inline = option.value.includes("=") ? inlineOptionPackage(option, launcher) : void 0;
@@ -2712,13 +2745,28 @@ const unreadArgumentValues = (words) => new Map(
 );
 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) && namesOld(word)).map((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;
@@ -2731,11 +2779,20 @@ 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 && packageReference(withoutWindowsSuffix(word.value)).name === GENERATOR_COMMAND;
+  return word !== void 0 && namesGenerator(word);
 }
 
 const COMMAND_PREFIX_WORDS = /* @__PURE__ */ new Set([
@@ -2775,7 +2832,7 @@ function simpleCommand(words) {
 const HEREDOC_OPERATOR = "<<";
 const HERE_STRING_OPERATOR = "<<<";
 const STRIP_TABS = "-";
-const LINE_BREAK$6 = "\n";
+const LINE_BREAK$7 = "\n";
 const LEADING_TABS_RE = /^\t+/;
 const CARRIAGE_RETURN_RE = /\r$/;
 function heredocAt(text, index, where) {
@@ -2807,7 +2864,7 @@ function isDelimiterLine(text, lineStart, end, heredoc) {
 function readBody(text, start, heredoc) {
   let lineStart = start;
   while (lineStart < text.length) {
-    const lineEnd = text.indexOf(LINE_BREAK$6, lineStart);
+    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) };
@@ -2876,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));
@@ -2898,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;
@@ -2913,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$5 = "\n";
+const LINE_BREAK$6 = "\n";
 function skipTrivia(text, index) {
   const char = text[index];
   if (WORD_BREAKS.has(char)) {
@@ -2953,7 +3038,7 @@ function topLevelCommands(text, indent) {
       index = heredoc.end;
     } else if (afterTrivia !== index) {
       index = afterTrivia;
-    } else if (text[index] === LINE_BREAK$5 && 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 = [];
@@ -2973,21 +3058,23 @@ function topLevelCommands(text, indent) {
   }
   return { commands, heredocs, pipes };
 }
-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 = (word) => word.value.startsWith(OPTION_PREFIX$1);
-const isScriptShell = (command) => SHELLS$1.has(programName$1(command)) && command.slice(1).every(isOption);
+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);
@@ -3004,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);
@@ -3014,7 +3103,7 @@ 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) {
@@ -3024,20 +3113,17 @@ function commandLineAssignments(command) {
   ];
   return new Map(read.map((assignment) => [assignment.word, assignment]));
 }
-function valueCommands$1(assignment) {
-  const value = assignmentValue(assignment);
-  return shellCommands(value.text).map((words) => words.map(value.place));
-}
 function innerCommands(command) {
   const assignments = commandLineAssignments(command);
   const code = inlineCode(command)?.code;
+  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);
-    return assignment === void 0 ? expansionCommands(word) : valueCommands$1(assignment);
+    return assignment === void 0 ? expansionCommands(word) : placedCommands(assignmentValue(assignment));
   });
 }
 function shellCommands(text, indent = 0) {
@@ -3140,11 +3226,15 @@ function shellAppend(assignment, variables) {
 }
 const isOwnGeneratorCommand = (place, command) => place === "after-outside" && command !== void 0 && runsGenerator(command);
 function appendedText(assignment) {
-  const value = assignmentValue(assignment);
-  return shellCommands(value.text).map((words) => words.map(value.place));
+  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(({ assignment, place }) => !isOwnGeneratorCommand(place, appendedText(assignment)[0])).map(({ assignment }) => shellAppend(assignment, 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
@@ -3155,23 +3245,29 @@ function shellAppends(commands, variables) {
   };
 }
 
+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$1(word, locate, variables) {
+function argumentFindings(word, locate, variables) {
   const reference = variables.referenceAt(word);
   if (reference === void 0) {
     return flagFindings(word, locate);
@@ -3195,7 +3291,7 @@ const oldFlagsOf = (findings) => findings.flatMap(({ change, manualStep }) => {
   return manualStep?.kind === "flags-in-variable" ? [...manualStep.flags] : [];
 });
 function programArgumentFindings(words, { offset, use }, locate, variables) {
-  const found = words.flatMap((word) => argumentFindings$1(word, locate, variables));
+  const found = words.flatMap((word) => argumentFindings(word, locate, variables));
   if (use?.program !== "generator-or-other") {
     return found;
   }
@@ -3219,20 +3315,6 @@ function appendedValueFindings({ words, program }, locate, variables) {
   return [...found, ...unmigratedWordFindings(words, handled, locate)];
 }
 
-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);
-  if (!isWindowsPath) {
-    return { path: word.value, suffix, written: word.value };
-  }
-  return { path: written.replace(WINDOWS_SEPARATOR_RE, PATH_SEPARATOR$8), suffix, written };
-}
-
 const SHELL_VARIABLE_RE$1 = /^"?\$(?:([A-Za-z_][A-Za-z0-9_]*)|\{([A-Za-z_][A-Za-z0-9_]*)\})"?$/;
 function expandedName$1(text) {
   const match = SHELL_VARIABLE_RE$1.exec(text);
@@ -3257,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());
@@ -3297,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) {
@@ -3350,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);
@@ -3386,7 +3475,7 @@ function programPathFindings(word, program, location) {
   }
   if (!path.endsWith(`${BIN_FOLDER}${GENERATOR_COMMAND}${suffix}`)) {
     const manualStep = { kind: "old-name-in-command", location, word: written };
-    const isGenerator = path.endsWith(`${PATH_SEPARATOR$7}${GENERATOR_COMMAND}${suffix}`);
+    const isGenerator = path.endsWith(`${PATH_SEPARATOR$6}${GENERATOR_COMMAND}${suffix}`);
     return isGenerator ? [{ offset, manualStep }] : [];
   }
   const edit = renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND, suffix);
@@ -3394,7 +3483,7 @@ function programPathFindings(word, program, 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;
@@ -3459,8 +3548,17 @@ function commandWordFindings(commands, locate, variables = NO_VARIABLES, appende
     )
   ]);
 }
+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 = [...found].sort((left, right) => left.offset - right.offset);
+  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]),
@@ -3600,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);
@@ -3631,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) {
@@ -3642,28 +3740,23 @@ function undeclaredImportSteps(imports, filePath, manifests) {
   });
 }
 
-const SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh"]);
-const OPTION_PREFIX = "-";
-const LONG_OPTION_PREFIX = "--";
-const COMMAND_OPTION = "c";
-const SET_OPTION = "-o";
-const PATH_SEPARATOR$5 = "/";
-function shellScript(words) {
-  const program = words[0]?.value.split(PATH_SEPARATOR$5).at(-1) ?? "";
-  if (!SHELLS.has(program)) {
-    return void 0;
-  }
-  let index = 1;
-  for (let option = words[index]?.value; option !== void 0; option = words[index]?.value) {
-    if (!option.startsWith(OPTION_PREFIX)) {
-      return void 0;
-    }
-    if (!option.startsWith(LONG_OPTION_PREFIX) && option.includes(COMMAND_OPTION)) {
-      return words[index + 1];
-    }
-    index += option === SET_OPTION ? 2 : 1;
-  }
-  return void 0;
+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);
@@ -3714,12 +3807,17 @@ function entrypointOf(stages, index) {
   const base = baseStage(stages, index);
   return own ?? (base === -1 ? void 0 : entrypointOf(stages, base));
 }
-function entrypointCommandFindings(text, forms, locate) {
+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;
-    if (entrypoint === void 0 || command === void 0) {
+    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 };
@@ -3727,16 +3825,140 @@ function entrypointCommandFindings(text, forms, 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 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];
@@ -3783,10 +4005,15 @@ function execForms(text) {
     return form === void 0 ? [] : [{ ...form, lineStart: match.index }];
   });
 }
-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) {
@@ -3795,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 = [];
@@ -3816,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;
@@ -3858,20 +4053,21 @@ 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 found = commandWordFindings(commands, locate, shellVariables(definitions));
-  const entry = textFindings(entrypointCommandFindings(text, forms, locate));
+  const entry = textFindings(entrypointCommandFindings(pairs, locate));
   const edits = [...found.edits, ...entry.edits];
   const changes = [...found.changes, ...entry.changes];
   const steps = [...found.manualSteps, ...entry.manualSteps];
@@ -5011,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];
 }
@@ -5029,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 };
   }
@@ -5088,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);
@@ -5509,49 +5705,90 @@ function withInputDefaults(variables, defaults) {
 }
 
 const ARGUMENT_KEYS = /* @__PURE__ */ new Map([
-  ["entrypoint", "command"],
-  ["command", "args"]
+  ["entrypoint", ["command", "args"]],
+  ["command", ["args"]]
 ]);
 const PAIRED_KEYS = /* @__PURE__ */ new Set([
   ...ARGUMENT_KEYS.keys(),
-  ...ARGUMENT_KEYS.values()
+  ...[...ARGUMENT_KEYS.values()].flat()
 ]);
-const TRAILING_KEY = "args";
+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]);
-const mapOf = (string) => JSON.stringify(string.path.slice(0, isItem(string) ? -2 : -1));
+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 = [];
-  const starts = /* @__PURE__ */ new Set();
   for (const string of strings) {
     const key = ownerKey(string.path) ?? "";
     const isValue = isItem(string) ? string.path.at(-2) === key : string.path.at(-1) === key;
-    if (!PAIRED_KEYS.has(key) || !isValue || starts.has(string.start)) {
+    if (!PAIRED_KEYS.has(key) || !isValue) {
       continue;
     }
-    starts.add(string.start);
     const last = values.at(-1);
     if (last !== void 0 && isNextItem(last, string)) {
       last.strings.push(string);
     } else {
-      values.push({ map: mapOf(string), key, strings: [string] });
+      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 [words = []] = shellCommands(isPlaced ? text.slice(start, end) : scalar.value);
-  const at = (word) => isPlaced ? { ...word, start: word.start + start, end: word.end + start } : { ...word, start: scalar.start, end: scalar.start };
-  return { words: words.map(at), isPlaced };
+  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;
@@ -5562,56 +5799,37 @@ function valueWords(value, text) {
     const { start, end } = item.content;
     return { start, end, value: item.value, raw: text.slice(start, end), item };
   });
-  return { words, isPlaced: true };
-}
-function pairOf(left, right) {
-  if (right === void 0 || left.map !== right.map) {
-    return void 0;
-  }
-  if (ARGUMENT_KEYS.get(left.key) === right.key) {
-    return [left, right];
-  }
-  return ARGUMENT_KEYS.get(right.key) === left.key ? [right, left] : void 0;
-}
-function containers(values) {
-  const found = [];
-  for (let index = 0; index < values.length; index++) {
-    const value = values[index];
-    const pair = pairOf(value, values[index + 1]);
-    if (pair !== void 0) {
-      found.push({ entrypoint: pair[0], command: pair[1] });
-      index++;
-    } else if (value.key !== TRAILING_KEY) {
-      found.push({ entrypoint: value, command: void 0 });
-    }
-  }
-  return found;
-}
-function listCommand({ entrypoint, command }, text) {
-  const parts = command === void 0 ? [entrypoint] : [entrypoint, command];
-  return parts.filter(isList).flatMap((part) => valueWords(part, text).words);
+  return { words, isPlaced: true, isWhole: true };
 }
-function argumentFindings(container, text, locate) {
-  const { entrypoint, command } = container;
+const isJoinable = (words) => words.isPlaced && words.isWhole;
+function containerReading({ entrypoint, command }, text, locate) {
+  const first = valueWords(entrypoint, text);
   if (command === void 0) {
-    return [];
-  }
-  const words = valueWords(entrypoint, text).words;
-  if (isList(entrypoint) && isList(command) && shellScript(words) === void 0) {
-    return [];
+    return { commands: isList(entrypoint) ? [first.words] : [], flags: [], scalars: [] };
   }
   const args = valueWords(command, text);
-  const pair = { entrypoint: words, command: args.words, written: entrypoint.key };
-  return entrypointArgumentFindings({ ...pair, isPlaced: args.isPlaced }, locate);
+  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 = containers(keyValues(strings));
-  const commands = found.map((container) => listCommand(container, text));
+  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((container) => argumentFindings(container, text, locate));
+  const flags = found.flatMap((reading) => reading.flags);
   return {
     findings: [commandWordFindings(commands, locate), textFindings(flags)],
-    scripts: new Set(scripts)
+    scripts: new Set(scripts),
+    commandStrings: new Set(found.flatMap((reading) => reading.scalars.map(({ start }) => start)))
   };
 }
 
@@ -5820,15 +6038,40 @@ const AZURE_PIPELINES_FILE = {
   includes: AZURE_TEMPLATES
 };
 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, shellName } = environment;
+  const { reference } = 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);
+    const name = referencedName(environment, groups);
     return names.has(name) ? asShellVariable(written, name) : written;
   });
 }
@@ -5995,18 +6238,21 @@ function appliedFindings(text, found) {
     manualSteps: found.flatMap((findings) => findings.manualSteps)
   };
 }
-function migrateYamlCommands(text, file, strings, { commandKeys, environment, parameters } = 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) => !isContainerListItem(value)));
-  const { findings, scripts } = containerCommands(text, strings, locate);
+  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 defaults = parameterDefaults(strings, parameters);
   const isShellText = (value) => commandValues.has(value) || scripts.has(value) || entries.has(value) || defaults.has(value);
   const shellValues = oncePerPlace(strings.filter(isShellText));
-  const names = new Set([...entries.values()].map((entry) => entry.name));
+  const 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 });
@@ -6063,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;
@@ -6185,7 +6431,7 @@ function usesVariable(text, names) {
   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);
+  return new RegExp(expansion).test(text) || referencedVariables(text).some((found) => names.has(found));
 }
 
 const withSteps = (migration, steps) => ({
@@ -6451,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
+          })
+        )
       ])
     )
   },
@@ -6469,7 +6720,10 @@ const yamlCommandsStep = (path, { apiDescriptionParts, yamlReach }) => (text, re
   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))
+    (current, strings) => migrateYamlCommands(current, path, strings, {
+      ...yamlKindOf(yamlReach, path),
+      outsideVariables: yamlReach.generatorVariables
+    })
   )(text, read);
 };
 const manifestTarget = ({ version, catalogs, aliases }, path) => ({
@@ -6836,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>`;
@@ -6854,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"
 ]);
@@ -6872,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":