openapi-typesafe-migrate 1.0.0-rc.6 → 1.0.0-rc.7

package/dist/cli/main.mjs

@@ -737,7 +737,9 @@ function indexUses(file, bindings) {
     if (declaration !== void 0 && !isDeclaredName(node, declaration)) {
       uses.set(declaration, [...uses.get(declaration) ?? [], node]);
     }
-    ts.forEachChild(node, visit);
+    for (const child of node.getChildren(file)) {
+      visit(child);
+    }
   };
   visit(file);
   return uses;
@@ -812,18 +814,23 @@ function constantOptions(name, bindings, outerTypes) {
     return { kind: "shared", options: found.value };
   }
   const declared = declaration.type;
-  const annotations = [
-    ...outerTypes,
+  const ownTypes = [
     ...found.types,
     ...declared === void 0 ? [] : [declared],
     ...jsDocTypes(declaration)
   ];
-  return { kind: "own", options: found.value, annotations };
+  const annotations = [...outerTypes, ...ownTypes];
+  return {
+    kind: "own",
+    options: found.value,
+    annotations,
+    isContextuallyTyped: ownTypes.length > 0
+  };
 }
 function optionsOf(argument, bindings) {
   const { value, types } = unwrapped(argument);
   if (ts.isObjectLiteralExpression(value)) {
-    return { kind: "own", options: value, annotations: types };
+    return { kind: "own", options: value, annotations: types, isContextuallyTyped: true };
   }
   return ts.isIdentifier(value) ? constantOptions(value, bindings, types) : { kind: "unknown", expression: argument };
 }
@@ -1434,6 +1441,9 @@ function removalEdits(removed, text) {
 const TRANSFORM = "transform";
 const LEGACY_ONLY_CALLBACKS = ["postTransform", "transformProperty"];
 const IR_CALLBACKS_OPTION = "irCallbacks";
+const IR_CALLBACKS_TRUE = "true";
+const IR_CALLBACKS_TRUE_CONST = "true as const";
+const IR_CALLBACKS_TRUE_CONST_JS = "/** @type {const} */ (true)";
 const noFindings = () => ({
   edits: [],
   changes: [],
@@ -1472,10 +1482,17 @@ function transformEdits(property, names, text) {
   }
   return edits;
 }
-function irCallbacksOption(text, transformStart) {
+function irCallbacksValue(options) {
+  if (options.isContextuallyTyped) {
+    return IR_CALLBACKS_TRUE;
+  }
+  const isJavaScript = (options.options.flags & ts.NodeFlags.JavaScriptFile) !== 0;
+  return isJavaScript ? IR_CALLBACKS_TRUE_CONST_JS : IR_CALLBACKS_TRUE_CONST;
+}
+function irCallbacksOption(text, transformStart, value) {
   const lineStart = text.lastIndexOf("\n", transformStart - 1) + 1;
   const before = text.slice(lineStart, transformStart);
-  const option = `${IR_CALLBACKS_OPTION}: true,`;
+  const option = `${IR_CALLBACKS_OPTION}: ${value},`;
   return /^\s*$/.test(before) ? `${option}
 ${before}` : `${option} `;
 }
@@ -1518,7 +1535,9 @@ function migrateOptions(options, text, names) {
     findings.manualSteps.push({ kind: "transform-not-rewritten", line, reason: result });
     return findings;
   }
-  findings.edits.push({ start, end: start, text: irCallbacksOption(text, start) }, ...result.edits);
+  const at = transform.getStart(void 0, true);
+  const option = irCallbacksOption(text, at, irCallbacksValue(options));
+  findings.edits.push({ start: at, end: at, text: option }, ...result.edits);
   findings.typeReferences.push(...result.typeReferences);
   findings.changes.push({ kind: "transform-rewritten", line });
   return findings;
@@ -1667,7 +1686,7 @@ function isModuleSpecifier(literal) {
   }
   return ts.isExternalModuleReference(parent);
 }
-function stringValue$1(node, file) {
+function stringValue(node, file) {
   return ts.isTemplateExpression(node) ? file.text.slice(node.getStart(file) + 1, node.getEnd() - 1) : node.text;
 }
 function collectStrings(root, file, offset, found) {
@@ -1678,7 +1697,7 @@ function collectStrings(root, file, offset, found) {
       found.set(start, {
         start,
         end,
-        value: stringValue$1(node, file),
+        value: stringValue(node, file),
         isModuleSpecifier: isModuleSpecifier(node)
       });
     }
@@ -1887,6 +1906,150 @@ function createYamlTextReader() {
   return { read };
 }
 
+const PACKAGE_RENAMES = /* @__PURE__ */ new Map([
+  ["openapi-typescript", "openapi-typesafe"],
+  ["openapi-fetch", "openapi-typesafe-fetch"],
+  ["openapi-react-query", "openapi-typesafe-react-query"],
+  ["openapi-typescript-helpers", "openapi-typesafe-helpers"]
+]);
+function namesOriginalPackage(text) {
+  return [...PACKAGE_RENAMES.keys()].some((name) => text.includes(name));
+}
+const GENERATOR_COMMAND = "openapi-typescript";
+const MIGRATED_GENERATOR_COMMAND = "openapi-typesafe";
+const FLAG_RENAMES = /* @__PURE__ */ new Map([
+  ["--immutable-types", "--immutable"],
+  ["-it", "--immutable"],
+  ["--support-array-length", "--array-length"],
+  ["--redoc", "--redocly"],
+  ["-ap", "--additional-properties"]
+]);
+const DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+const NAME_KEYED_FIELDS = ["peerDependenciesMeta", "dependenciesMeta"];
+const NAME_LIST_FIELDS = ["bundleDependencies", "bundledDependencies"];
+const CATALOG_FIELD = "catalog";
+const NAMED_CATALOGS_FIELD = "catalogs";
+const WORKSPACES_FIELD = "workspaces";
+const OVERRIDE_FIELDS = ["overrides", "resolutions"];
+const PNPM_SETTINGS_FIELD = "pnpm";
+const OLD_PEER_DEPENDENTS = /* @__PURE__ */ new Map([
+  ["swr-openapi", { peer: "openapi-fetch", range: ">=0.15" }]
+]);
+const PATH_SEPARATOR$9 = "/";
+const QUERY_START = "?";
+function renamedSpecifier(value) {
+  const ends = [value.indexOf(PATH_SEPARATOR$9), value.indexOf(QUERY_START)].filter(
+    (at) => at !== -1
+  );
+  const name = value.slice(0, ends.length === 0 ? value.length : Math.min(...ends));
+  const renamed = PACKAGE_RENAMES.get(name);
+  if (renamed === void 0) {
+    return void 0;
+  }
+  const rest = value.slice(name.length);
+  const subpath = rest.split(QUERY_START, 1)[0] ?? rest;
+  return { to: `${renamed}${rest}`, isDeep: subpath !== "" && subpath !== PATH_SEPARATOR$9 };
+}
+const NODE_MODULES_FOLDER = "node_modules/";
+function oldPackageInNodeModules(path) {
+  return [...PACKAGE_RENAMES.keys()].find(
+    (name) => path.includes(`${NODE_MODULES_FOLDER}${name}${PATH_SEPARATOR$9}`)
+  );
+}
+
+const isMap = (node) => node?.kind === "map";
+const isScalar = (node) => node.kind === "scalar";
+function textEntries(map) {
+  return map.entries.flatMap(({ key, value }) => isScalar(key) ? [{ key, value }] : []);
+}
+function valuesAt(map, key) {
+  return textEntries(map).filter((entry) => entry.key.value === key).map((entry) => entry.value);
+}
+function mapsAt(map, key) {
+  return valuesAt(map, key).filter(isMap);
+}
+function stringsBelow(node, path) {
+  switch (node.kind) {
+    case "scalar":
+      return [{ ...node, path }];
+    case "list":
+      return node.items.flatMap((item, index) => stringsBelow(item, [...path, index]));
+    case "map":
+      return textEntries(node).flatMap(
+        ({ key, value }) => stringsBelow(value, [...path, key.value])
+      );
+    default:
+      return [];
+  }
+}
+function documentStrings(documents) {
+  return documents.flatMap((document) => stringsBelow(document, []));
+}
+function ownerKey(path) {
+  return path.findLast((part) => typeof part === "string");
+}
+function unreadableConfig(text, offset) {
+  if (!namesOriginalPackage(text)) {
+    return unchanged(text);
+  }
+  const position = offset === void 0 ? void 0 : { line: lineAt(text, offset), column: columnAt(text, offset) };
+  return { ...unchanged(text), manualSteps: [{ kind: "config-unreadable", position }] };
+}
+
+const SEPARATOR = "/";
+const CURRENT_FOLDER = ".";
+const PARENT_FOLDER = "..";
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/i;
+function resolvedPath(fromPath, reference) {
+  const parts = fromPath.split(SEPARATOR).slice(0, -1);
+  for (const part of reference.split(SEPARATOR)) {
+    if (part === PARENT_FOLDER) {
+      if (parts.pop() === void 0) {
+        return void 0;
+      }
+    } else if (part !== CURRENT_FOLDER && part !== "") {
+      parts.push(part);
+    }
+  }
+  return parts.join(SEPARATOR);
+}
+function referencedProjectPath(fromPath, reference) {
+  const isOutside = URL_SCHEME.test(reference) || reference.startsWith(SEPARATOR);
+  const path = isOutside ? void 0 : resolvedPath(fromPath, reference);
+  return path === "" ? void 0 : path;
+}
+
+const API_DESCRIPTION_KEYS = [
+  "openapi",
+  "swagger",
+  "asyncapi",
+  "overlay",
+  "arazzo"
+];
+const API_DESCRIPTION_KEY_SET = new Set(API_DESCRIPTION_KEYS);
+const DESCRIPTION_KEY_LINE_RE = new RegExp(
+  `^[ \\t{]*["']?(?:${API_DESCRIPTION_KEYS.join("|")})["']?[ \\t]*:`,
+  "m"
+);
+const mayBeApiDescription = (text) => DESCRIPTION_KEY_LINE_RE.test(text);
+const isApiDescription = (documents) => documents.some(
+  (root) => isMap(root) && textEntries(root).some(({ key }) => API_DESCRIPTION_KEY_SET.has(key.value))
+);
+const REF_KEY = "$ref";
+const FRAGMENT_START = "#";
+function referencedFiles(path, documents) {
+  return documentStrings(documents).filter((string) => string.path.at(-1) === REF_KEY).flatMap(({ value }) => {
+    const file = value.split(FRAGMENT_START)[0] ?? "";
+    const referenced = referencedProjectPath(path, file);
+    return referenced === void 0 ? [] : [referenced];
+  });
+}
+
 const NONE = /* @__PURE__ */ new Set();
 const PACKAGE_OPTIONS = /* @__PURE__ */ new Set(["-p", "--package"]);
 const PACKAGE_MANAGER_OPTIONS = /* @__PURE__ */ new Set([
@@ -2030,8 +2193,8 @@ const COMMAND_SEPARATORS = /* @__PURE__ */ new Set([
   "\n"
 ]);
 const WORD_BREAKS = /* @__PURE__ */ new Set([" ", "	", "\r", "<", ">"]);
-const BACKSLASH$1 = "\\";
-const DOUBLE_QUOTE_ESCAPES = /* @__PURE__ */ new Set(["$", "`", '"', BACKSLASH$1, "\n"]);
+const BACKSLASH$2 = "\\";
+const DOUBLE_QUOTE_ESCAPES = /* @__PURE__ */ new Set(["$", "`", '"', BACKSLASH$2, "\n"]);
 function singleQuoted(text, start) {
   const close = text.indexOf("'", start + 1);
   const end = close === -1 ? text.length : close + 1;
@@ -2042,13 +2205,13 @@ function doubleQuoted(text, start) {
   let index = start + 1;
   while (index < text.length && text[index] !== '"') {
     const next = text[index + 1] ?? "";
-    const isEscape = text[index] === BACKSLASH$1 && DOUBLE_QUOTE_ESCAPES.has(next);
+    const isEscape = text[index] === BACKSLASH$2 && DOUBLE_QUOTE_ESCAPES.has(next);
     value += isEscape ? next === "\n" ? "" : next : text[index];
     index += isEscape ? 2 : 1;
   }
   return { end: Math.min(index + 1, text.length), value };
 }
-const isLineContinuation = (text, index) => text[index] === BACKSLASH$1 && (text[index + 1] === "\n" || text.startsWith("\r\n", index + 1));
+const isLineContinuation = (text, index) => text[index] === BACKSLASH$2 && (text[index + 1] === "\n" || text.startsWith("\r\n", index + 1));
 const ARITHMETIC_OPEN = "$((";
 const NESTING_OPEN = "(";
 const NESTING_CLOSE = ")";
@@ -2063,11 +2226,48 @@ function arithmeticExpansion(text, start) {
   }
   return void 0;
 }
+const PARAMETER_OPEN = "${";
+const PARAMETER_CLOSE = "}";
+function parameterExpansionEnd(text, start) {
+  let depth = 1;
+  for (let index = start + PARAMETER_OPEN.length; index < text.length; ) {
+    if (text.startsWith(PARAMETER_OPEN, index)) {
+      depth += 1;
+      index += PARAMETER_OPEN.length;
+    } else if (text[index] === PARAMETER_CLOSE) {
+      depth -= 1;
+      index += 1;
+      if (depth === 0) {
+        return index;
+      }
+    } else {
+      index = quotedOrEscapedEnd(text, index) ?? index + 1;
+    }
+  }
+  return void 0;
+}
+function quotedOrEscapedEnd(text, index) {
+  const char = text[index];
+  if (char === "'") {
+    return singleQuoted(text, index).end;
+  }
+  if (char === '"') {
+    return doubleQuoted(text, index).end;
+  }
+  return char === BACKSLASH$2 ? index + 2 : void 0;
+}
+function expansionPart(text, index) {
+  if (text.startsWith(ARITHMETIC_OPEN, index)) {
+    return arithmeticExpansion(text, index);
+  }
+  const end = text.startsWith(PARAMETER_OPEN, index) ? parameterExpansionEnd(text, index) : void 0;
+  return end === void 0 ? void 0 : { end, value: text.slice(index, end) };
+}
 function wordPart(text, index) {
   const char = text[index];
-  const arithmetic = text.startsWith(ARITHMETIC_OPEN, index) ? arithmeticExpansion(text, index) : void 0;
-  if (arithmetic !== void 0) {
-    return arithmetic;
+  const expansion = expansionPart(text, index);
+  if (expansion !== void 0) {
+    return expansion;
   }
   if (char === "'") {
     return singleQuoted(text, index);
@@ -2075,11 +2275,23 @@ function wordPart(text, index) {
   if (char === '"') {
     return doubleQuoted(text, index);
   }
-  if (char === BACKSLASH$1 && index + 1 < text.length) {
+  if (char === BACKSLASH$2 && index + 1 < text.length) {
     return { end: index + 2, value: text[index + 1] };
   }
   return { end: index + 1, value: char };
 }
+const ARRAY_HEAD_RE = /^[A-Za-z_][A-Za-z0-9_]*\+?=$/;
+function arrayListEnd(text, index) {
+  let depth = 0;
+  for (let at = index; at < text.length; ) {
+    depth += text[at] === NESTING_OPEN ? 1 : text[at] === NESTING_CLOSE ? -1 : 0;
+    if (depth === 0) {
+      return at + 1;
+    }
+    at = quotedOrEscapedEnd(text, at) ?? at + 1;
+  }
+  return void 0;
+}
 const endsWord = (text, index) => {
   const char = text[index];
   return WORD_BREAKS.has(char) || COMMAND_SEPARATORS.has(char) || isLineContinuation(text, index);
@@ -2087,8 +2299,13 @@ const endsWord = (text, index) => {
 function readWord(text, start) {
   let value = "";
   let index = start;
-  while (index < text.length && !endsWord(text, index)) {
-    const part = wordPart(text, index);
+  while (index < text.length) {
+    const isArrayList = text[index] === NESTING_OPEN && ARRAY_HEAD_RE.test(text.slice(start, index));
+    const list = isArrayList ? arrayListEnd(text, index) : void 0;
+    if (list === void 0 && endsWord(text, index)) {
+      break;
+    }
+    const part = list === void 0 ? wordPart(text, index) : { end: list, value: text.slice(index, list) };
     value += part.value;
     index = part.end;
   }
@@ -2119,11 +2336,17 @@ function shellAssignments(command) {
     return name === void 0 ? [] : [{ name, value: word.value.slice(name.length + 1), word }];
   });
 }
+const ARRAY_OPEN = "(";
+const ARRAY_CLOSE = ")";
+const isArrayAssignment = (assignment) => assignment.word.raw.startsWith(ARRAY_OPEN, assignment.name.length + 1);
 function assignmentValueText(assignment) {
   const at = assignment.name.length + 1;
   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;
@@ -2192,62 +2415,6 @@ function commandRoles(words) {
   return { program: void 0, packages };
 }
 
-const PACKAGE_RENAMES = /* @__PURE__ */ new Map([
-  ["openapi-typescript", "openapi-typesafe"],
-  ["openapi-fetch", "openapi-typesafe-fetch"],
-  ["openapi-react-query", "openapi-typesafe-react-query"],
-  ["openapi-typescript-helpers", "openapi-typesafe-helpers"]
-]);
-function namesOriginalPackage(text) {
-  return [...PACKAGE_RENAMES.keys()].some((name) => text.includes(name));
-}
-const GENERATOR_COMMAND = "openapi-typescript";
-const MIGRATED_GENERATOR_COMMAND = "openapi-typesafe";
-const FLAG_RENAMES = /* @__PURE__ */ new Map([
-  ["--immutable-types", "--immutable"],
-  ["-it", "--immutable"],
-  ["--support-array-length", "--array-length"],
-  ["--redoc", "--redocly"],
-  ["-ap", "--additional-properties"]
-]);
-const DEPENDENCY_FIELDS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies"
-];
-const NAME_KEYED_FIELDS = ["peerDependenciesMeta", "dependenciesMeta"];
-const NAME_LIST_FIELDS = ["bundleDependencies", "bundledDependencies"];
-const CATALOG_FIELD = "catalog";
-const NAMED_CATALOGS_FIELD = "catalogs";
-const WORKSPACES_FIELD = "workspaces";
-const OVERRIDE_FIELDS = ["overrides", "resolutions"];
-const PNPM_SETTINGS_FIELD = "pnpm";
-const OLD_PEER_DEPENDENTS = /* @__PURE__ */ new Map([
-  ["swr-openapi", { peer: "openapi-fetch", range: ">=0.15" }]
-]);
-const PATH_SEPARATOR$9 = "/";
-const QUERY_START = "?";
-function renamedSpecifier(value) {
-  const ends = [value.indexOf(PATH_SEPARATOR$9), value.indexOf(QUERY_START)].filter(
-    (at) => at !== -1
-  );
-  const name = value.slice(0, ends.length === 0 ? value.length : Math.min(...ends));
-  const renamed = PACKAGE_RENAMES.get(name);
-  if (renamed === void 0) {
-    return void 0;
-  }
-  const rest = value.slice(name.length);
-  const subpath = rest.split(QUERY_START, 1)[0] ?? rest;
-  return { to: `${renamed}${rest}`, isDeep: subpath !== "" && subpath !== PATH_SEPARATOR$9 };
-}
-const NODE_MODULES_FOLDER = "node_modules/";
-function oldPackageInNodeModules(path) {
-  return [...PACKAGE_RENAMES.keys()].find(
-    (name) => path.includes(`${NODE_MODULES_FOLDER}${name}${PATH_SEPARATOR$9}`)
-  );
-}
-
 function packageReference(value) {
   const bare = value.startsWith(NPM_SPECIFIER_PREFIX) ? value.slice(NPM_SPECIFIER_PREFIX.length) : value;
   const at = bare.indexOf("@", 1);
@@ -2282,10 +2449,62 @@ function runsGenerator(command) {
   return word !== void 0 && packageReference(word.value).name === GENERATOR_COMMAND;
 }
 
+const EXPANSION_HEAD_RE = /^\$\{([A-Za-z_][A-Za-z0-9_]*):?([-=+])/;
+const USES = {
+  "-": "default",
+  "=": "assign",
+  "+": "alternative"
+};
+const SINGLE_QUOTE = "'";
+const BACKSLASH$1 = "\\";
+function expansionAt(text, start) {
+  const head = EXPANSION_HEAD_RE.exec(text.slice(start));
+  const end = head === null ? void 0 : parameterExpansionEnd(text, start);
+  if (head === null || end === void 0) {
+    return void 0;
+  }
+  const wordStart = start + head[0].length;
+  return {
+    name: head[1],
+    use: USES[head[2]],
+    text: text.slice(wordStart, end - 1),
+    start: wordStart,
+    expansionStart: start,
+    expansionEnd: end
+  };
+}
+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);
+      index = close === -1 ? raw.length : close + 1;
+    } else if (char === BACKSLASH$1) {
+      index += 2;
+    } else if (raw.startsWith(PARAMETER_OPEN, index)) {
+      const expansion = expansionAt(raw, index);
+      found.push(...expansion === void 0 ? [] : [expansion]);
+      index = expansion?.expansionEnd ?? index + PARAMETER_OPEN.length;
+    } else {
+      index += 1;
+    }
+  }
+  return found;
+}
+const DOUBLE_QUOTE = '"';
+function wholeWordExpansion(raw) {
+  const isQuoted = raw.length > 1 && raw.startsWith(DOUBLE_QUOTE) && raw.endsWith(DOUBLE_QUOTE);
+  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 HEREDOC_OPERATOR = "<<";
 const HERE_STRING_OPERATOR = "<<<";
 const STRIP_TABS = "-";
-const LINE_BREAK$2 = "\n";
+const LINE_BREAK$4 = "\n";
 const LEADING_TABS_RE = /^\t+/;
 const CARRIAGE_RETURN_RE = /\r$/;
 function heredocAt(text, index, where) {
@@ -2317,7 +2536,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$2, lineStart);
+    const lineEnd = text.indexOf(LINE_BREAK$4, 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) };
@@ -2339,7 +2558,7 @@ function readBodies(text, start, pending) {
 }
 
 const COMMENT = "#";
-const LINE_BREAK$1 = "\n";
+const LINE_BREAK$3 = "\n";
 function skipTrivia(text, index) {
   const char = text[index];
   if (WORD_BREAKS.has(char)) {
@@ -2369,7 +2588,7 @@ function topLevelCommands(text, indent) {
       index = heredoc.end;
     } else if (afterTrivia !== index) {
       index = afterTrivia;
-    } else if (text[index] === LINE_BREAK$1 && pending.length > 0) {
+    } else if (text[index] === LINE_BREAK$3 && pending.length > 0) {
       const read = readBodies(text, index + 1, pending);
       heredocs.push(...read.bodies);
       pending = [];
@@ -2434,18 +2653,18 @@ const DOCKER_RUN = "RUN";
 const PASS_THROUGH = "cat";
 const PATH_SEPARATOR$8 = "/";
 const OPTION_PREFIX$1 = "-";
-const programName = (command) => command[0]?.value.split(PATH_SEPARATOR$8).at(-1) ?? "";
+const programName$1 = (command) => command[0]?.value.split(PATH_SEPARATOR$8).at(-1) ?? "";
 const isOption = (word) => word.value.startsWith(OPTION_PREFIX$1);
-const isScriptShell = (command) => SHELLS$1.has(programName(command)) && command.slice(1).every(isOption);
+const isScriptShell = (command) => SHELLS$1.has(programName$1(command)) && command.slice(1).every(isOption);
 function readsScript(command) {
-  if (programName(command) !== DOCKER_RUN) {
+  if (programName$1(command) !== DOCKER_RUN) {
     return isScriptShell(command);
   }
   const after = command.slice(1);
   const shell = after.slice(after.findIndex((word) => !isOption(word)));
   return after.every(isOption) || isScriptShell(shell);
 }
-const passesThrough = (command) => programName(command) === PASS_THROUGH && command.slice(1).every(isOption);
+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] ?? []));
@@ -2457,16 +2676,20 @@ const shifted = (words, offset) => words.map((word) => ({ ...word, start: word.s
 function shellCommandsAt(text, offset, indent = 0) {
   return shellCommands(text, indent).map((words) => shifted(words, offset));
 }
+const expansionCommands = (word) => wordExpansions(word.raw).flatMap(
+  (expansion) => shellCommandsAt(expansion.text, word.start + expansion.start)
+);
 function innerCommands(command) {
-  const quoted = command.flatMap((word) => {
+  const assignments = new Map(shellAssignments(command).map((found) => [found.word, found]));
+  return command.flatMap((word) => {
     const inner = nestedCommandText(word);
-    return inner === void 0 ? [] : shellCommandsAt(inner, word.start + 1);
-  });
-  const assigned = shellAssignments(command).flatMap((assignment) => {
-    const value = assignmentValueText(assignment);
-    return value === void 0 ? [] : shellCommandsAt(value.text, value.start);
+    if (inner !== void 0) {
+      return shellCommandsAt(inner, word.start + 1);
+    }
+    const assignment = assignments.get(word);
+    const value = assignment === void 0 ? void 0 : assignmentValueText(assignment);
+    return value === void 0 ? expansionCommands(word) : shellCommandsAt(value.text, value.start);
   });
-  return [...quoted, ...assigned];
 }
 function shellCommands(text, indent = 0) {
   const top = topLevelCommands(text, indent);
@@ -2540,19 +2763,27 @@ function expandedName(text) {
   const match = SHELL_VARIABLE_RE.exec(text);
   return match === null ? void 0 : match[1] ?? match[2];
 }
-function programDefinition$1({ name, value }) {
-  const target = expandedName(value.trim());
-  if (target !== void 0) {
-    return { name, kind: "reference", target };
-  }
-  return { name, kind: "command", runsGenerator: shellCommands(value).some(runsGenerator) };
+const textRunsGenerator = (text) => shellCommands(text).some(runsGenerator);
+function textDefinition(name, text) {
+  const target = expandedName(text.trim());
+  return target === void 0 ? { name, kind: "command", runsGenerator: textRunsGenerator(text) } : { name, kind: "reference", target };
+}
+function expansionDefinitions(name, expansion) {
+  const word = textDefinition(name, expansion.text);
+  const isOutside = expansion.use === "alternative" || expansion.name === name;
+  const variable = isOutside ? { name, kind: "command", runsGenerator: false } : { name, kind: "reference", target: expansion.name };
+  return [word, variable];
+}
+function programDefinitions$1({ name, value }) {
+  const expansion = wholeWordExpansion(value.trim());
+  return expansion === void 0 ? [textDefinition(name, value)] : expansionDefinitions(name, expansion);
 }
 function shellVariables(definitions) {
   const values = /* @__PURE__ */ new Map();
   for (const { name, value } of definitions) {
     values.set(name, [values.get(name), value].filter((part) => part !== void 0).join(" "));
   }
-  const programs = variablePrograms(definitions.map(programDefinition$1));
+  const programs = variablePrograms(definitions.flatMap(programDefinitions$1));
   const nameAt = (word) => expandedName(word.raw);
   return {
     programAt: (program) => {
@@ -2573,8 +2804,15 @@ function combinedUse(left, right) {
   }
   return left.program === right.program ? left : { ...left, program: "generator-or-other" };
 }
+function assignedByExpansions(commands) {
+  return commands.flat().flatMap((word) => wordExpansions(word.raw)).filter((expansion) => expansion.use === "assign").flatMap(({ name, text }) => [
+    { name, value: text },
+    { name, value: "" }
+  ]);
+}
 function withShellAssignments(commands, file) {
-  const definitions = commands.flatMap(shellAssignments);
+  const assigned = commands.flatMap(shellAssignments).filter((found) => !isArrayAssignment(found));
+  const definitions = [...assigned, ...assignedByExpansions(commands)];
   if (definitions.length === 0) {
     return file;
   }
@@ -2584,6 +2822,35 @@ function withShellAssignments(commands, file) {
     referenceAt: (word) => own.referenceAt(word) ?? file.referenceAt(word)
   };
 }
+const joinedProgram = (left, right) => left === right ? left : "generator-or-other";
+function expansionUse(word, variables) {
+  const expansion = wholeWordExpansion(word.raw);
+  if (expansion === void 0) {
+    return void 0;
+  }
+  const programOf = (name) => (name === void 0 ? void 0 : variables.programAt({ ...word, raw: `$${name}` })?.program) ?? "other";
+  const target = expandedName(expansion.text.trim());
+  const textProgram = textRunsGenerator(expansion.text) ? "generator" : "other";
+  const own = target === void 0 ? textProgram : programOf(target);
+  const variable = programOf(expansion.use === "alternative" ? void 0 : expansion.name);
+  return { written: word.raw, program: joinedProgram(own, variable) };
+}
+function withWordExpansions(variables) {
+  return {
+    programAt: (program) => variables.programAt(program) ?? expansionUse(program, variables),
+    referenceAt: (word) => variables.referenceAt(word)
+  };
+}
+const VARIABLE_NAME = "[A-Za-z_][A-Za-z0-9_]*";
+const VARIABLE_WORD_RE = new RegExp(
+  `^"?\\$\\$?(?:${VARIABLE_NAME}|\\{${VARIABLE_NAME}(?:\\[[^\\]]*\\])?\\})"?$`
+);
+function withUnreadVariables(variables) {
+  return {
+    programAt: (program) => variables.programAt(program) ?? (VARIABLE_WORD_RE.test(program.raw) ? { written: program.raw, program: "generator-or-other" } : void 0),
+    referenceAt: (word) => variables.referenceAt(word)
+  };
+}
 
 const QUOTES$1 = /* @__PURE__ */ new Set(["'", '"']);
 const PATH_SEPARATOR$7 = "/";
@@ -2720,7 +2987,7 @@ function shellTextFindings(text, locate) {
   return commandWordFindings(shellCommands(text), locate);
 }
 function commandWordFindings(commands, locate, variables = NO_VARIABLES) {
-  const known = withShellAssignments(commands, variables);
+  const known = withUnreadVariables(withWordExpansions(withShellAssignments(commands, variables)));
   const findings = commands.flatMap((words) => commandFindings(words, locate, known)).sort((left, right) => left.offset - right.offset);
   return {
     edits: findings.flatMap((finding) => finding.edit === void 0 ? [] : [finding.edit]),
@@ -2794,45 +3061,6 @@ function commandStringSteps(text, strings) {
   });
 }
 
-const isMap = (node) => node?.kind === "map";
-const isScalar = (node) => node.kind === "scalar";
-function textEntries(map) {
-  return map.entries.flatMap(({ key, value }) => isScalar(key) ? [{ key, value }] : []);
-}
-function valuesAt(map, key) {
-  return textEntries(map).filter((entry) => entry.key.value === key).map((entry) => entry.value);
-}
-function mapsAt(map, key) {
-  return valuesAt(map, key).filter(isMap);
-}
-function stringsBelow(node, path) {
-  switch (node.kind) {
-    case "scalar":
-      return [{ ...node, path }];
-    case "list":
-      return node.items.flatMap((item, index) => stringsBelow(item, [...path, index]));
-    case "map":
-      return textEntries(node).flatMap(
-        ({ key, value }) => stringsBelow(value, [...path, key.value])
-      );
-    default:
-      return [];
-  }
-}
-function documentStrings(documents) {
-  return documents.flatMap((document) => stringsBelow(document, []));
-}
-function ownerKey(path) {
-  return path.findLast((part) => typeof part === "string");
-}
-function unreadableConfig(text, offset) {
-  if (!namesOriginalPackage(text)) {
-    return unchanged(text);
-  }
-  const position = offset === void 0 ? void 0 : { line: lineAt(text, offset), column: columnAt(text, offset) };
-  return { ...unchanged(text), manualSteps: [{ kind: "config-unreadable", position }] };
-}
-
 const KEPT_PROTOCOLS = ["catalog:", "workspace:"];
 const LOCAL_PROTOCOLS = ["workspace:", "link:", "file:", "portal:"];
 const RANGE_SEPARATOR = "||";
@@ -2915,8 +3143,12 @@ function localPackageNames(manifest) {
   );
 }
 function localPackagesFor(manifests, filePath) {
-  const containing = manifests.filter(({ path }) => isAtOrAbove(path, filePath));
-  return new Set(containing.flatMap(({ localPackages }) => [...localPackages ?? []]));
+  const nearestFirst = manifests.filter(({ path }) => isAtOrAbove(path, filePath)).sort((left, right) => directoryOf(right.path).length - directoryOf(left.path).length);
+  const candidates = new Set(
+    nearestFirst.flatMap(({ localPackages }) => [...localPackages ?? []])
+  );
+  const isLocal = (name) => nearestFirst.find(({ names }) => names?.has(name) === true)?.localPackages?.has(name) === true;
+  return new Set([...candidates].filter(isLocal));
 }
 function isDeclaredFor(manifests, filePath, name) {
   const original = ORIGINAL_NAMES.get(name);
@@ -2950,7 +3182,7 @@ 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 = "=";
+const ASSIGNMENT$1 = "=";
 const QUOTES = /* @__PURE__ */ new Set(['"', "'"]);
 function matchAt(pattern, text, index) {
   pattern.lastIndex = index;
@@ -3049,7 +3281,7 @@ function escapedScriptSteps(scripts, lineOf) {
   });
 }
 function assignedVariable(word) {
-  const at = word.raw.indexOf(ASSIGNMENT);
+  const at = word.raw.indexOf(ASSIGNMENT$1);
   if (at <= 0) {
     return void 0;
   }
@@ -3067,7 +3299,7 @@ function dockerVariables(commands) {
     if (!VARIABLE_INSTRUCTIONS.has(instruction.value)) {
       return [];
     }
-    if (instruction.value === LEGACY_ENV_INSTRUCTION && !first.raw.includes(ASSIGNMENT)) {
+    if (instruction.value === LEGACY_ENV_INSTRUCTION && !first.raw.includes(ASSIGNMENT$1)) {
       return [{ name: first.value, commands: [rest] }];
     }
     return [first, ...rest].flatMap((word) => assignedVariable(word) ?? []);
@@ -3378,30 +3610,12 @@ function migrateImportMap(text, read, version) {
 }
 
 const IMPORT_MAP_FIELD = "importMap";
-const SEPARATOR = "/";
-const CURRENT_FOLDER = ".";
-const PARENT_FOLDER = "..";
-const URL_SCHEME = /^[a-z][a-z\d+.-]*:/i;
 function importMapReferences(roots) {
   return roots.flatMap((root) => valuesAt(root, IMPORT_MAP_FIELD)).flatMap((value) => isScalar(value) ? [value.value] : []);
 }
-function resolvedPath(configPath, reference) {
-  const parts = configPath.split(SEPARATOR).slice(0, -1);
-  for (const part of reference.split(SEPARATOR)) {
-    if (part === PARENT_FOLDER) {
-      if (parts.pop() === void 0) {
-        return void 0;
-      }
-    } else if (part !== CURRENT_FOLDER && part !== "") {
-      parts.push(part);
-    }
-  }
-  return parts.join(SEPARATOR);
-}
 function importMapLocation(configPath, reference) {
-  const isOutside = URL_SCHEME.test(reference) || reference.startsWith(SEPARATOR);
-  const path = isOutside ? void 0 : resolvedPath(configPath, reference);
-  return path === void 0 || path === "" ? { kind: "not-editable", reference } : { kind: "in-project", path };
+  const path = referencedProjectPath(configPath, reference);
+  return path === void 0 ? { kind: "not-editable", reference } : { kind: "in-project", path };
 }
 const importMapLocations = (configPath, roots) => importMapReferences(roots).map((reference) => importMapLocation(configPath, reference));
 function importMapSteps(configPath, read) {
@@ -3580,58 +3794,234 @@ function migrateJsonCommands(text, strings, patterns) {
   return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
 
-const ASSIGNMENT_RE$1 = /^(?:export[ \t]+)?([A-Za-z_][A-Za-z0-9_-]*)[ \t]*:=[ \t]*(.*)$/gm;
-const STRING_VALUE_RE = /^(?:"((?:[^"\\\n]|\\.)*)"|'([^'\n]*)')(?:[ \t]+#.*)?$/;
-const NAME_VALUE_RE = /^([A-Za-z_][A-Za-z0-9_-]*)(?:[ \t]+#.*)?$/;
-const INTERPOLATION_RE = /\{\{[^\n]*?\}\}/g;
+const DELIMITERS = ['"""', "'''", "```", '"', "'", "`"];
+const BACKTICK = "`";
+const ESCAPING_DELIMITER = '"';
+const ESCAPE = "\\";
+const COMMENT_START$1 = "#";
+const LINE_BREAK$2 = "\n";
+function closingOffset(text, delimiter, from) {
+  if (delimiter !== ESCAPING_DELIMITER) {
+    const close = text.indexOf(delimiter, from);
+    return close === -1 ? void 0 : close;
+  }
+  for (let index = from; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === ESCAPE) {
+      index += 1;
+    } else if (char === ESCAPING_DELIMITER || char === LINE_BREAK$2) {
+      return char === ESCAPING_DELIMITER ? index : void 0;
+    }
+  }
+  return void 0;
+}
+function literalAt(text, offset) {
+  const delimiter = DELIMITERS.find((candidate) => text.startsWith(candidate, offset));
+  if (delimiter === void 0) {
+    return void 0;
+  }
+  const contentStart = offset + delimiter.length;
+  const close = closingOffset(text, delimiter, contentStart);
+  if (close === void 0) {
+    return void 0;
+  }
+  const kind = delimiter.startsWith(BACKTICK) ? "backtick" : "string";
+  const content = text.slice(contentStart, close);
+  return { kind, start: offset, end: close + delimiter.length, contentStart, content };
+}
+function expressionAt(text, start) {
+  const literals = [];
+  let index = start;
+  while (index < text.length && text[index] !== LINE_BREAK$2 && text[index] !== COMMENT_START$1) {
+    const literal = literalAt(text, index);
+    literals.push(...literal === void 0 ? [] : [literal]);
+    index = literal?.end ?? index + 1;
+  }
+  return { literals, end: index };
+}
+function literalsBetween(text, start, end) {
+  const literals = [];
+  for (let index = start; index < end; ) {
+    const literal = literalAt(text, index);
+    literals.push(...literal === void 0 ? [] : [literal]);
+    index = literal?.end ?? index + 1;
+  }
+  return literals;
+}
+const INTERPOLATION_OPEN = "{{";
+const INTERPOLATION_CLOSE = "}}";
+function interpolationAt(text, start) {
+  const literals = [];
+  for (let index = start + INTERPOLATION_OPEN.length; index < text.length; ) {
+    if (text.startsWith(INTERPOLATION_CLOSE, index)) {
+      return { start, end: index + INTERPOLATION_CLOSE.length, literals };
+    }
+    if (text[index] === LINE_BREAK$2) {
+      return void 0;
+    }
+    const literal = literalAt(text, index);
+    literals.push(...literal === void 0 ? [] : [literal]);
+    index = literal?.end ?? index + 1;
+  }
+  return void 0;
+}
+function interpolationsOf(text) {
+  const found = [];
+  for (let open = text.indexOf(INTERPOLATION_OPEN); open !== -1; ) {
+    const interpolation = interpolationAt(text, open);
+    found.push(...interpolation === void 0 ? [] : [interpolation]);
+    const next = interpolation?.end ?? open + INTERPOLATION_OPEN.length;
+    open = text.indexOf(INTERPOLATION_OPEN, next);
+  }
+  return found;
+}
+
+const RECIPE_NAME_RE = /^@?[A-Za-z_][A-Za-z0-9_-]*(?=[ \t:])/gm;
+const PARAMETER_RE = /^[+*$]*([A-Za-z_][A-Za-z0-9_-]*)(?:=([\s\S]*))?$/;
+const NAME_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+const COLON = ":";
+const EQUALS = "=";
+const OPEN_PAREN = "(";
+const CLOSE_PAREN = ")";
+const COMMENT_START = "#";
+const LINE_BREAK$1 = "\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$1; ) {
+    const literal = literalAt(text, index);
+    const char = text[index];
+    if (literal !== void 0) {
+      index = literal.end;
+      continue;
+    }
+    if (char === COMMENT_START || char === COLON && text[index + 1] === EQUALS) {
+      return void 0;
+    }
+    if (char === COLON) {
+      return index;
+    }
+    index += 1;
+  }
+  return void 0;
+}
+function parameterWords(text, start, end) {
+  const words = [];
+  let wordStart;
+  let depth = 0;
+  for (let index = start; index < end; ) {
+    const isBreak = depth === 0 && BLANK_RE.test(text[index] ?? "");
+    if (isBreak && wordStart !== void 0) {
+      words.push({ start: wordStart, end: index });
+    }
+    wordStart = isBreak ? void 0 : wordStart ?? index;
+    const literal = isBreak ? void 0 : literalAt(text, index);
+    depth += literal === void 0 ? depthChange(text[index]) : 0;
+    index = literal?.end ?? index + 1;
+  }
+  return wordStart === void 0 ? words : [...words, { start: wordStart, end }];
+}
+function parameterDefault(text, word) {
+  const written = text.slice(word.start, word.end);
+  const match = PARAMETER_RE.exec(written);
+  const value = match?.[2];
+  if (match === null || value === void 0) {
+    return [];
+  }
+  const defaultStart = word.end - value.length;
+  const literals = literalsBetween(text, defaultStart, word.end);
+  const target = NAME_RE.test(value) ? value : void 0;
+  return [{ name: match[1], literals, target }];
+}
+function recipeHeaders(text) {
+  return [...text.matchAll(RECIPE_NAME_RE)].flatMap((match) => {
+    const nameEnd = match.index + match[0].length;
+    const colon = headerColon(text, nameEnd);
+    if (colon === void 0) {
+      return [];
+    }
+    const words = parameterWords(text, nameEnd, colon);
+    const defaults = words.flatMap((word) => parameterDefault(text, word));
+    return [{ start: match.index, end: colon, defaults }];
+  });
+}
+
+const ASSIGNMENT_RE$1 = /^(?:export[ \t]+)?([A-Za-z_][A-Za-z0-9_-]*)[ \t]*:=[ \t]*/gm;
+const NAME_VALUE_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
 const VARIABLE_INTERPOLATION_RE = /^[@+-]*\{\{[ \t]*([A-Za-z_][A-Za-z0-9_-]*)[ \t]*\}\}$/;
 const MASK$1 = "_";
 const BLANK = " ";
-const assignmentsOf$1 = (text) => [...text.matchAll(ASSIGNMENT_RE$1)].map((match) => {
-  const written = match[2];
-  const valueStart = match.index + match[0].length - written.length;
-  return { name: match[1], value: written.trim(), start: match.index, valueStart };
-});
-function stringValue(value) {
-  const match = STRING_VALUE_RE.exec(value);
-  return match === null ? void 0 : match[1] ?? match[2];
+function assignmentsOf$1(text) {
+  return [...text.matchAll(ASSIGNMENT_RE$1)].map((match) => {
+    const valueStart = match.index + match[0].length;
+    const { literals, end } = expressionAt(text, valueStart);
+    const value = text.slice(valueStart, end).trim();
+    return { name: match[1], value, start: match.index, end, literals };
+  });
+}
+function onlyString({ value, literals }) {
+  const [literal] = literals;
+  if (literals.length !== 1 || literal?.kind !== "string") {
+    return void 0;
+  }
+  return value.length === literal.end - literal.start ? literal : void 0;
+}
+const stringRunsGenerator = (literal) => literal.kind === "string" && shellCommands(literal.content).some(runsGenerator);
+function computedDefinitions(name, literals) {
+  const other = { name, kind: "command", runsGenerator: false };
+  const isMaybeGenerator = literals.some(stringRunsGenerator);
+  return isMaybeGenerator ? [{ name, kind: "command", runsGenerator: true }, other] : [other];
 }
-function programDefinition({ name, value }) {
-  const target = NAME_VALUE_RE.exec(value)?.[1];
-  if (target !== void 0) {
-    return { name, kind: "reference", target };
+function assignmentDefinitions(assignment) {
+  const { name, value } = assignment;
+  if (NAME_VALUE_RE.test(value)) {
+    return [{ name, kind: "reference", target: value }];
   }
-  const text = stringValue(value);
-  const runs = text !== void 0 && shellCommands(text).some(runsGenerator);
-  return { name, kind: "command", runsGenerator: runs };
+  const literal = onlyString(assignment);
+  return literal === void 0 ? computedDefinitions(name, assignment.literals) : [{ name, kind: "command", runsGenerator: stringRunsGenerator(literal) }];
+}
+function parameterDefinitions({ name, literals, target }) {
+  const fromCommandLine = computedDefinitions(name, literals);
+  return target === void 0 ? fromCommandLine : [{ name, kind: "reference", target }, ...fromCommandLine];
 }
-function shellText$1(text, assignments) {
+function shellText$1(text, spans) {
   const parts = [];
   let copiedUpTo = 0;
-  for (const { start, valueStart, value } of assignments) {
-    const end = valueStart + value.length;
+  for (const { start, end } of [...spans].sort((left, right) => left.start - right.start)) {
     parts.push(text.slice(copiedUpTo, start), BLANK.repeat(end - start));
     copiedUpTo = end;
   }
   parts.push(text.slice(copiedUpTo));
-  return parts.join("").replace(INTERPOLATION_RE, (found) => MASK$1.repeat(found.length));
-}
-function valueCommands({ value, valueStart }) {
-  const inner = stringValue(value);
-  return inner === void 0 ? [] : shellCommandsAt(inner, valueStart + 1);
+  const blanked = parts.join("");
+  const interpolations = interpolationsOf(blanked);
+  const masked = interpolations.reduce(
+    (current, { start, end }) => current.slice(0, start) + MASK$1.repeat(end - start) + current.slice(end),
+    blanked
+  );
+  return { text: masked, interpolations };
 }
-function justfileVariables(text, assignments, programs) {
+const literalCommands = (literals) => literals.flatMap((literal) => shellCommandsAt(literal.content, literal.contentStart));
+function variableValues$1(assignments) {
   const values = /* @__PURE__ */ new Map();
-  for (const { name, value } of assignments) {
-    values.set(name, [values.get(name), stringValue(value) ?? value].join(" ").trim());
+  for (const assignment of assignments) {
+    const value = onlyString(assignment)?.content ?? assignment.value;
+    values.set(assignment.name, [values.get(assignment.name), value].join(" ").trim());
   }
+  return values;
+}
+function computedProgram(written) {
+  const literals = interpolationsOf(written).flatMap((interpolation) => interpolation.literals);
+  return literals.some(stringRunsGenerator) ? "generator-or-other" : void 0;
+}
+function justfileVariables(text, values, programs) {
   const writtenAt = (word) => text.slice(word.start, word.end);
   const nameAt = (word) => VARIABLE_INTERPOLATION_RE.exec(writtenAt(word))?.[1];
   return {
-    programAt: (program) => {
-      const name = nameAt(program);
-      const found = name === void 0 ? void 0 : programs.get(name);
-      return found === void 0 ? void 0 : { written: writtenAt(program), program: found };
+    programAt: (word) => {
+      const name = nameAt(word);
+      const written = writtenAt(word);
+      const found = name === void 0 ? computedProgram(written) : programs.get(name);
+      return found === void 0 ? void 0 : { written, program: found };
     },
     referenceAt: (word) => {
       const name = nameAt(word);
@@ -3643,11 +4033,19 @@ function justfileVariables(text, assignments, programs) {
 function migrateJustfile(text, file) {
   const lineOf = lineLocator(text);
   const assignments = assignmentsOf$1(text);
-  const programs = variablePrograms(assignments.map(programDefinition));
-  const variables = justfileVariables(text, assignments, programs);
+  const headers = recipeHeaders(text);
+  const defaults = headers.flatMap((header) => header.defaults);
+  const programs = variablePrograms([
+    ...assignments.flatMap(assignmentDefinitions),
+    ...defaults.flatMap(parameterDefinitions)
+  ]);
+  const variables = justfileVariables(text, variableValues$1(assignments), programs);
+  const shell = shellText$1(text, [...assignments, ...headers]);
   const commands = [
-    ...shellCommands(shellText$1(text, assignments)),
-    ...assignments.flatMap(valueCommands)
+    ...shellCommands(shell.text),
+    ...literalCommands(assignments.flatMap((assignment) => assignment.literals)),
+    ...literalCommands(defaults.flatMap((found) => found.literals)),
+    ...literalCommands(shell.interpolations.flatMap((found) => found.literals))
   ];
   const locate = (offset) => `${file}:${lineOf(offset)}`;
   const { edits, changes, manualSteps } = commandWordFindings(commands, locate, variables);
@@ -3765,7 +4163,7 @@ function makefileVariables(text, assignments, programs) {
   const variables = {
     programAt: (program) => {
       const name = nameAt(program);
-      const found = name === void 0 ? void 0 : programs.get(name);
+      const found = name === void 0 ? void 0 : programs.get(name) ?? "generator-or-other";
       const written = text.slice(program.start, program.end);
       return found === void 0 ? void 0 : { written, program: found };
     },
@@ -4130,19 +4528,63 @@ function oldPackagePatchSteps(fileName) {
 }
 
 const STEP_SHELL_KEY = "shell";
+const DEFAULT_SHELL_PATH = ["defaults", "run", STEP_SHELL_KEY];
 const COMMAND_LINE_SHELLS = /* @__PURE__ */ new Set([
   ...["sh", "bash", "dash", "ash", "zsh", "ksh"],
-  ...["pwsh", "powershell", "cmd"]
+  ...["pwsh", "powershell", "cmd"],
+  ...["msys2", "wsl-bash"]
 ]);
+const ENV_PROGRAM = "env";
+const ENV_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"]);
+const OPTION_START = "-";
+const ASSIGNMENT = "=";
 const PATH_SEPARATOR_RE = /[/\\]/;
+const WINDOWS_EXECUTABLE_RE = /\.exe$/i;
 const WHITESPACE_RE = /\s+/;
-const shellProgram = (shell) => shell.trim().split(WHITESPACE_RE)[0]?.split(PATH_SEPARATOR_RE).at(-1) ?? "";
+const programName = (word) => (word.split(PATH_SEPARATOR_RE).at(-1) ?? "").replace(WINDOWS_EXECUTABLE_RE, "");
+function envPrefixLength(words) {
+  let index = 0;
+  while (index < words.length) {
+    const word = words[index] ?? "";
+    if (ENV_OPTIONS_WITH_VALUE.has(word)) {
+      index += 2;
+    } else if (word.startsWith(OPTION_START) || word.includes(ASSIGNMENT)) {
+      index += 1;
+    } else {
+      break;
+    }
+  }
+  return index;
+}
+function shellProgram(shell) {
+  const words = shell.trim().split(WHITESPACE_RE);
+  const first = programName(words[0] ?? "");
+  if (first !== ENV_PROGRAM) {
+    return first;
+  }
+  const rest = words.slice(1);
+  return programName(rest[envPrefixLength(rest)] ?? "");
+}
+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) {
+  const keys = isDefaultShell(value) ? DEFAULT_SHELL_PATH.length : 1;
+  return JSON.stringify(value.path.slice(0, -keys));
+}
 function stepShells(strings) {
-  const stepOf = (path) => JSON.stringify(path.slice(0, -1));
-  const others = new Map(
-    strings.filter((value) => value.path.at(-1) === STEP_SHELL_KEY).filter((value) => !COMMAND_LINE_SHELLS.has(shellProgram(value.value))).map((value) => [stepOf(value.path), value.value])
-  );
-  return (value) => others.get(stepOf(value.path));
+  const shells = strings.filter((value) => value.path.at(-1) === STEP_SHELL_KEY);
+  const isOwnShell = (value) => !isDefaultShell(value);
+  const ordered = [...shells.filter(isDefaultShell), ...shells.filter(isOwnShell)];
+  const byScope = new Map(ordered.map((value) => [scopeOf(value), value.value]));
+  return (value) => {
+    for (let depth = value.path.length - 1; depth >= 0; depth -= 1) {
+      const shell = byScope.get(JSON.stringify(value.path.slice(0, depth)));
+      if (shell !== void 0) {
+        return COMMAND_LINE_SHELLS.has(shellProgram(shell)) ? void 0 : shell;
+      }
+    }
+    return void 0;
+  };
 }
 function otherShellFindings(values, shellOf, locate) {
   const manualSteps = values.flatMap((value) => {
@@ -4176,10 +4618,6 @@ const TASKFILE_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "status"
 ]);
 
-const API_DESCRIPTION_KEYS = /* @__PURE__ */ new Set(["openapi", "swagger", "asyncapi"]);
-const isApiDescription = (documents) => documents.some(
-  (root) => isMap(root) && textEntries(root).some(({ key }) => API_DESCRIPTION_KEYS.has(key.value))
-);
 const ENVIRONMENT_KEYS = /* @__PURE__ */ new Set(["env"]);
 const isEnvironmentValue = (value) => value.path.length >= 2 && ENVIRONMENT_KEYS.has(String(value.path.at(-2)));
 function environmentVariables(text, strings) {
@@ -4589,7 +5027,7 @@ const COMMAND_CONFIG_KINDS = [
     )
   }
 ];
-const yamlCommandsStep = (path) => (text, read) => read.kind === "read" && isApiDescription(read.documents) ? unchanged(text) : stringsStep((current, strings) => migrateYamlCommands(current, path, strings))(text, read);
+const yamlCommandsStep = (path, isPart) => (text, read) => isPart || read.kind === "read" && isApiDescription(read.documents) ? unchanged(text) : stringsStep((current, strings) => migrateYamlCommands(current, path, strings))(text, read);
 const manifestTarget = ({ version, catalogs, aliases }, path) => ({
   version,
   catalogs,
@@ -4665,7 +5103,11 @@ const FILE_KINDS = [
   },
   {
     matches: (path) => YAML_EXTENSIONS.has(extensionOf(path)),
-    migrate: whenNamed(yamlConfig((_context, path) => [yamlCommandsStep(path)]))
+    migrate: whenNamed(
+      yamlConfig((context, path) => [
+        yamlCommandsStep(path, context.apiDescriptionParts.has(path))
+      ])
+    )
   },
   {
     matches: (path) => DOCKERFILE_NAMES.has(baseName(path)),
@@ -4694,6 +5136,58 @@ function fileMigrationFor(path, namedImportMaps = NO_NAMED_IMPORT_MAPS) {
   return FILE_KINDS.find((kind) => kind.matches(path))?.migrate;
 }
 
+const NO_API_DESCRIPTION_PARTS = /* @__PURE__ */ new Set();
+const JSON_EXTENSION = ".json";
+const isYaml = (path) => YAML_EXTENSIONS.has(extensionOf(path));
+const isDescriptionFormat = (path) => isYaml(path) || extensionOf(path) === JSON_EXTENSION;
+async function textOf(path, files) {
+  const read = await files.read(path);
+  return read.kind === "read" ? read.text : void 0;
+}
+function documentsOf(path, text, readers) {
+  const parsed = (isYaml(path) ? readers.yaml : readers.json).read(text);
+  return parsed.kind === "read" ? [...parsed.documents] : void 0;
+}
+async function hasNamingYaml(paths, files) {
+  for (const path of paths.filter(isYaml)) {
+    const text = await textOf(path, files);
+    if (text !== void 0 && namesOriginalPackage(text)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function descriptionRoots(paths, { files, readers }) {
+  const roots = /* @__PURE__ */ new Map();
+  for (const path of paths.filter(isDescriptionFormat)) {
+    const text = await textOf(path, files);
+    const documents = text !== void 0 && mayBeApiDescription(text) ? documentsOf(path, text, readers) : void 0;
+    if (documents !== void 0 && isApiDescription(documents)) {
+      roots.set(path, documents);
+    }
+  }
+  return roots;
+}
+async function apiDescriptionParts(paths, dependencies) {
+  if (!await hasNamingYaml(paths, dependencies.files)) {
+    return NO_API_DESCRIPTION_PARTS;
+  }
+  const listed = new Set(paths.filter(isDescriptionFormat));
+  const roots = await descriptionRoots(paths, dependencies);
+  const parts = /* @__PURE__ */ new Set();
+  const pending = [...roots].flatMap(([path, documents]) => referencedFiles(path, documents));
+  for (let path = pending.pop(); path !== void 0; path = pending.pop()) {
+    if (!listed.has(path) || roots.has(path) || parts.has(path)) {
+      continue;
+    }
+    parts.add(path);
+    const text = await textOf(path, dependencies.files);
+    const documents = text === void 0 ? void 0 : documentsOf(path, text, dependencies.readers);
+    pending.push(...documents === void 0 ? [] : referencedFiles(path, documents));
+  }
+  return parts;
+}
+
 const readJson = (text, readers) => readers.json.read(text);
 const readYaml = (text, readers) => readers.yaml.read(text);
 function planSourceOf(path, namedImportMaps) {
@@ -4774,7 +5268,11 @@ async function planProjectTarget(paths, dependencies, version) {
     isWorkspaceRoot
   });
   const declarations = withNamedImportMaps(manifests, importMaps);
-  return { version, catalogs, manifests: declarations, aliases, importMaps };
+  const parts = await apiDescriptionParts(paths, dependencies);
+  return {
+    ...{ version, catalogs, manifests: declarations, aliases, importMaps },
+    apiDescriptionParts: parts
+  };
 }
 
 async function planFile(path, dependencies, target) {
@@ -4787,9 +5285,9 @@ async function planFile(path, dependencies, target) {
     return read;
   }
   const { rewriter, scanner, readers } = dependencies;
-  const { version, catalogs, manifests, aliases } = target;
+  const { version, catalogs, manifests, aliases, apiDescriptionParts } = target;
   const context = {
-    ...{ version, catalogs, manifests, aliases },
+    ...{ version, catalogs, manifests, aliases, apiDescriptionParts },
     ...{ rewriter, scanner, readers }
   };
   const migration = migrate(read.text, path, context);
@@ -4879,7 +5377,7 @@ function terminalSafeText(text) {
 const PINNED_NOTE = "change it to openapi-typesafe@<version>";
 const OLD_FILE_NOTE$1 = "is a file of openapi-typescript, which is no longer installed: run openapi-typesafe instead";
 const FLAGS_IN_VARIABLE_NOTE = "holds old flags of the generator and may serve other commands, so it was kept: rename";
-const NOT_ONLY_GENERATOR_NOTE = "runs openapi-typescript in some of its definitions in this file and another program in others, so the flags after it were kept; where it runs the generator, rename";
+const NOT_ONLY_GENERATOR_NOTE = "may run openapi-typescript or another program (set elsewhere in the file, in another step or outside it), so the flags after it were kept; where it runs the generator, rename";
 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";