openapi-typesafe-migrate 1.0.0-rc.8 → 1.0.0-rc.9

package/dist/cli/main.mjs

@@ -4,7 +4,7 @@ import { win32, posix, join, dirname, isAbsolute, relative, sep, basename, resol
 import { realpath, lstat, stat, access, readFile, writeFile, chmod, rename, rm, readdir } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 import ts from '@typescript/typescript6';
-import { Scalar, parseAllDocuments, isScalar as isScalar$1, isSeq, isMap as isMap$1, isNode, CST } from 'yaml';
+import { Scalar, parseAllDocuments, isScalar as isScalar$1, isSeq, isMap as isMap$1, isAlias, isNode, CST } from 'yaml';
 import { parseArgs } from 'node:util';
 
 const WINDOWS = "win32";
@@ -1336,10 +1336,14 @@ function joined(elements, operator, names) {
   if (parts.some((part) => part === void 0)) {
     return void 0;
   }
-  const texts = parts.map(
-    (part) => operator === "&" && part.operator === "|" ? `(${part.text})` : part.text
+  const members = parts.map(
+    (part) => operator === "&" && part.operator === "|" ? plain$1(`(${part.text})`) : part
   );
-  return { text: texts.join(` ${operator} `), operator: texts.length > 1 ? operator : null };
+  const [only] = members;
+  if (members.length === 1 && only !== void 0) {
+    return only;
+  }
+  return { text: members.map((member) => member.text).join(` ${operator} `), operator };
 }
 function factoryCallText(call, method, names) {
   const [first, second] = call.arguments;
@@ -1954,6 +1958,7 @@ function convertScalar(node, isFlow) {
   const isReplaceable = quotings !== void 0 && node.anchor === void 0 && node.tag === void 0;
   return {
     kind: "scalar",
+    ...anchorOf(node),
     value,
     content: contentRange(node.srcToken, span),
     isFolded: node.type !== Scalar.BLOCK_LITERAL,
@@ -1962,6 +1967,7 @@ function convertScalar(node, isFlow) {
     ...span
   };
 }
+const anchorOf = (node) => node.anchor === void 0 ? {} : { anchor: node.anchor };
 const flowOf = (conversion, node) => ({
   isFlow: conversion.isFlow || node.flow === true
 });
@@ -1971,7 +1977,8 @@ function convert(node, conversion) {
   }
   if (isSeq(node)) {
     const inner = flowOf(conversion, node);
-    return { kind: "list", items: node.items.map((item) => convert(item, inner)), ...spanOf(node) };
+    const items = node.items.map((item) => convert(item, inner));
+    return { kind: "list", items, ...anchorOf(node), ...spanOf(node) };
   }
   if (isMap$1(node)) {
     const inner = flowOf(conversion, node);
@@ -1979,7 +1986,10 @@ function convert(node, conversion) {
       key: convert(pair.key, inner),
       value: convert(pair.value, inner)
     }));
-    return { kind: "map", entries, ...spanOf(node) };
+    return { kind: "map", entries, ...anchorOf(node), ...spanOf(node) };
+  }
+  if (isAlias(node)) {
+    return { kind: "other", alias: node.source, ...spanOf(node) };
   }
   return { kind: "other", ...spanOf(isNode(node) ? node : {}) };
 }
@@ -2062,10 +2072,10 @@ 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 PATH_SEPARATOR$a = "/";
 const QUERY_START = "?";
 function renamedSpecifier(value) {
-  const ends = [value.indexOf(PATH_SEPARATOR$9), value.indexOf(QUERY_START)].filter(
+  const ends = [value.indexOf(PATH_SEPARATOR$a), value.indexOf(QUERY_START)].filter(
     (at) => at !== -1
   );
   const name = value.slice(0, ends.length === 0 ? value.length : Math.min(...ends));
@@ -2075,12 +2085,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$9 };
+  return { to: `${renamed}${rest}`, isDeep: subpath !== "" && subpath !== PATH_SEPARATOR$a };
 }
 const NODE_MODULES_FOLDER = "node_modules/";
 function oldPackageInNodeModules(path) {
   return [...PACKAGE_RENAMES.keys()].find(
-    (name) => path.includes(`${NODE_MODULES_FOLDER}${name}${PATH_SEPARATOR$9}`) || path.endsWith(`${NODE_MODULES_FOLDER}${name}`)
+    (name) => path.includes(`${NODE_MODULES_FOLDER}${name}${PATH_SEPARATOR$a}`) || path.endsWith(`${NODE_MODULES_FOLDER}${name}`)
   );
 }
 
@@ -2095,22 +2105,40 @@ function valuesAt(map, key) {
 function mapsAt(map, key) {
   return valuesAt(map, key).filter(isMap);
 }
-function stringsBelow(node, path) {
+const NO_ALIASES = () => void 0;
+function stringsBelow(node, path, targetOf) {
   switch (node.kind) {
     case "scalar":
       return [{ ...node, path }];
     case "list":
-      return node.items.flatMap((item, index) => stringsBelow(item, [...path, index]));
+      return node.items.flatMap((item, index) => stringsBelow(item, [...path, index], targetOf));
     case "map":
       return textEntries(node).flatMap(
-        ({ key, value }) => stringsBelow(value, [...path, key.value])
+        ({ key, value }) => stringsBelow(value, [...path, key.value], targetOf)
       );
-    default:
-      return [];
+    default: {
+      const target = targetOf(node);
+      return target === void 0 ? [] : stringsBelow(target, path, targetOf);
+    }
   }
 }
 function documentStrings(documents) {
-  return documents.flatMap((document) => stringsBelow(document, []));
+  return documents.flatMap((document) => stringsBelow(document, [], NO_ALIASES));
+}
+function nodesBelow(node) {
+  const children = node.kind === "list" ? node.items : node.kind === "map" ? node.entries.flatMap(({ key, value }) => [key, value]) : [];
+  return [node, ...children.flatMap(nodesBelow)];
+}
+function aliasTargets(document) {
+  const anchored = nodesBelow(document).filter(
+    (node) => node.kind !== "other" && node.anchor !== void 0
+  );
+  return (alias) => anchored.findLast(
+    (node) => node.kind !== "other" && node.anchor === alias.alias && node.end <= alias.start
+  );
+}
+function usedDocumentStrings(documents) {
+  return documents.flatMap((document) => stringsBelow(document, [], aliasTargets(document)));
 }
 function ownerKey(path) {
   return path.findLast((part) => typeof part === "string");
@@ -2308,6 +2336,64 @@ const INSTALLERS = [
 ];
 const NPM_SPECIFIER_PREFIX = "npm:";
 
+const EXPRESSION_OPEN = "${{";
+const EXPRESSION_CLOSE = "}}";
+const LITERAL_QUOTE = "'";
+const SHELL_SINGLE_QUOTE = "'";
+const BACKSLASH$3 = "\\";
+const DOUBLE_QUOTE$1 = '"';
+function expressionEnd(text, start) {
+  for (let index = start + EXPRESSION_OPEN.length; index < text.length; ) {
+    if (text.startsWith(EXPRESSION_CLOSE, index)) {
+      return index + EXPRESSION_CLOSE.length;
+    }
+    const close = text[index] === LITERAL_QUOTE ? text.indexOf(LITERAL_QUOTE, index + 1) : index;
+    index = close === -1 ? text.length : close + 1;
+  }
+  return void 0;
+}
+function literalsIn(raw, start, end) {
+  const found = [];
+  let open = raw.indexOf(LITERAL_QUOTE, start);
+  while (open !== -1 && open < end) {
+    let close = raw.indexOf(LITERAL_QUOTE, open + 1);
+    let isEscaped = false;
+    while (close !== -1 && raw[close + 1] === LITERAL_QUOTE) {
+      isEscaped = true;
+      close = raw.indexOf(LITERAL_QUOTE, close + 2);
+    }
+    if (close === -1) {
+      break;
+    }
+    found.push(...isEscaped ? [] : [{ text: raw.slice(open + 1, close), start: open + 1 }]);
+    open = raw.indexOf(LITERAL_QUOTE, close + 1);
+  }
+  return found;
+}
+function expressionLiterals(raw) {
+  const found = [];
+  for (let index = 0; index < raw.length; ) {
+    if (raw[index] === SHELL_SINGLE_QUOTE) {
+      const close = raw.indexOf(SHELL_SINGLE_QUOTE, index + 1);
+      index = close === -1 ? raw.length : close + 1;
+    } else if (raw[index] === BACKSLASH$3) {
+      index += 2;
+    } else if (raw.startsWith(EXPRESSION_OPEN, index)) {
+      const end = expressionEnd(raw, index) ?? raw.length;
+      found.push(...literalsIn(raw, index + EXPRESSION_OPEN.length, end));
+      index = end;
+    } else {
+      index += 1;
+    }
+  }
+  return found;
+}
+function isWholeExpression(raw) {
+  const isQuoted = raw.length > 1 && raw.startsWith(DOUBLE_QUOTE$1) && raw.endsWith(DOUBLE_QUOTE$1);
+  const inner = isQuoted ? 1 : 0;
+  return raw.startsWith(EXPRESSION_OPEN, inner) && expressionEnd(raw, inner) === raw.length - inner;
+}
+
 const COMMAND_SEPARATORS = /* @__PURE__ */ new Set([
   ";",
   "&",
@@ -2318,8 +2404,8 @@ const COMMAND_SEPARATORS = /* @__PURE__ */ new Set([
   "\n"
 ]);
 const WORD_BREAKS = /* @__PURE__ */ new Set([" ", "	", "\r", "<", ">"]);
-const BACKSLASH$3 = "\\";
-const DOUBLE_QUOTE_ESCAPES = /* @__PURE__ */ new Set(["$", "`", '"', BACKSLASH$3, "\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;
@@ -2330,13 +2416,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$3 && 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$3 && (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 = ")";
@@ -2356,7 +2442,9 @@ 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)) {
+    if (text.startsWith(EXPRESSION_OPEN, index)) {
+      index = expressionEnd(text, index) ?? text.length;
+    } else if (text.startsWith(PARAMETER_OPEN, index)) {
       depth += 1;
       index += PARAMETER_OPEN.length;
     } else if (text[index] === PARAMETER_CLOSE) {
@@ -2379,7 +2467,7 @@ function quotedOrEscapedEnd(text, index) {
   if (char === '"') {
     return doubleQuoted(text, index).end;
   }
-  return char === BACKSLASH$3 ? index + 2 : void 0;
+  return char === BACKSLASH$2 ? index + 2 : void 0;
 }
 function expansionPart(text, index) {
   if (text.startsWith(ARITHMETIC_OPEN, index)) {
@@ -2400,7 +2488,7 @@ function wordPart(text, index) {
   if (char === '"') {
     return doubleQuoted(text, index);
   }
-  if (char === BACKSLASH$3 && 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 };
@@ -2489,7 +2577,9 @@ function skipAssignments(words, start) {
   return index;
 }
 const WINDOWS_PROGRAM_SUFFIX_RE = /\.(?:cmd|exe|ps1)$/i;
-const entryWord = (word) => word?.value.replace(WINDOWS_PROGRAM_SUFFIX_RE, "");
+const windowsSuffix = (value) => WINDOWS_PROGRAM_SUFFIX_RE.exec(value)?.[0] ?? "";
+const withoutWindowsSuffix = (value) => value.slice(0, value.length - windowsSuffix(value).length);
+const entryWord = (word) => word === void 0 ? void 0 : withoutWindowsSuffix(word.value);
 function matchingPrefix(entries, words, index) {
   return entries.find(
     (entry) => entry.words.every((name, offset) => entryWord(words[index + offset]) === name)
@@ -2573,7 +2663,7 @@ 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(word.value).name === GENERATOR_COMMAND;
+  return word !== void 0 && packageReference(withoutWindowsSuffix(word.value)).name === GENERATOR_COMMAND;
 }
 
 const CODE_OPTIONS = /* @__PURE__ */ new Map([
@@ -2618,6 +2708,15 @@ function inlineCode(command) {
   return void 0;
 }
 
+const PATH_SEPARATOR$9 = "/";
+const WINDOWS_SEPARATOR_RE = /\\/g;
+const QUOTE_RE = /["']/g;
+function programPath(word) {
+  const suffix = windowsSuffix(word.value);
+  const windowsPath = word.raw.replace(QUOTE_RE, "").replace(WINDOWS_SEPARATOR_RE, PATH_SEPARATOR$9);
+  return { path: suffix === "" ? word.value : windowsPath, suffix };
+}
+
 const EXPANSION_HEAD_RE = /^\$\{([A-Za-z_][A-Za-z0-9_]*):?([-=+])/;
 const USES = {
   "-": "default",
@@ -2625,7 +2724,7 @@ const USES = {
   "+": "alternative"
 };
 const SINGLE_QUOTE = "'";
-const BACKSLASH$2 = "\\";
+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);
@@ -2649,7 +2748,7 @@ function wordExpansions(raw) {
     if (char === SINGLE_QUOTE) {
       const close = raw.indexOf(SINGLE_QUOTE, index + 1);
       index = close === -1 ? raw.length : close + 1;
-    } else if (char === BACKSLASH$2) {
+    } else if (char === BACKSLASH$1) {
       index += 2;
     } else if (raw.startsWith(PARAMETER_OPEN, index)) {
       const expansion = expansionAt(raw, index);
@@ -2661,9 +2760,9 @@ function wordExpansions(raw) {
   }
   return found;
 }
-const DOUBLE_QUOTE$1 = '"';
+const DOUBLE_QUOTE = '"';
 function wholeWordExpansion(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) && raw.endsWith(DOUBLE_QUOTE);
   const inner = isQuoted ? 1 : 0;
   const [expansion] = wordExpansions(raw);
   const isWhole = expansion?.expansionStart === inner && expansion.expansionEnd === raw.length - inner;
@@ -2726,64 +2825,6 @@ function readBodies(text, start, pending) {
   return { bodies, end };
 }
 
-const EXPRESSION_OPEN = "${{";
-const EXPRESSION_CLOSE = "}}";
-const LITERAL_QUOTE = "'";
-const SHELL_SINGLE_QUOTE = "'";
-const BACKSLASH$1 = "\\";
-const DOUBLE_QUOTE = '"';
-function expressionEnd(text, start) {
-  for (let index = start + EXPRESSION_OPEN.length; index < text.length; ) {
-    if (text.startsWith(EXPRESSION_CLOSE, index)) {
-      return index + EXPRESSION_CLOSE.length;
-    }
-    const close = text[index] === LITERAL_QUOTE ? text.indexOf(LITERAL_QUOTE, index + 1) : index;
-    index = close === -1 ? text.length : close + 1;
-  }
-  return void 0;
-}
-function literalsIn(raw, start, end) {
-  const found = [];
-  let open = raw.indexOf(LITERAL_QUOTE, start);
-  while (open !== -1 && open < end) {
-    let close = raw.indexOf(LITERAL_QUOTE, open + 1);
-    let isEscaped = false;
-    while (close !== -1 && raw[close + 1] === LITERAL_QUOTE) {
-      isEscaped = true;
-      close = raw.indexOf(LITERAL_QUOTE, close + 2);
-    }
-    if (close === -1) {
-      break;
-    }
-    found.push(...isEscaped ? [] : [{ text: raw.slice(open + 1, close), start: open + 1 }]);
-    open = raw.indexOf(LITERAL_QUOTE, close + 1);
-  }
-  return found;
-}
-function expressionLiterals(raw) {
-  const found = [];
-  for (let index = 0; index < raw.length; ) {
-    if (raw[index] === SHELL_SINGLE_QUOTE) {
-      const close = raw.indexOf(SHELL_SINGLE_QUOTE, index + 1);
-      index = close === -1 ? raw.length : close + 1;
-    } else if (raw[index] === BACKSLASH$1) {
-      index += 2;
-    } else if (raw.startsWith(EXPRESSION_OPEN, index)) {
-      const end = expressionEnd(raw, index) ?? raw.length;
-      found.push(...literalsIn(raw, index + EXPRESSION_OPEN.length, end));
-      index = end;
-    } else {
-      index += 1;
-    }
-  }
-  return found;
-}
-function isWholeExpression(raw) {
-  const isQuoted = raw.length > 1 && raw.startsWith(DOUBLE_QUOTE) && raw.endsWith(DOUBLE_QUOTE);
-  const inner = isQuoted ? 1 : 0;
-  return raw.startsWith(EXPRESSION_OPEN, inner) && expressionEnd(raw, inner) === raw.length - inner;
-}
-
 const COMMENT = "#";
 const LINE_BREAK$4 = "\n";
 function skipTrivia(text, index) {
@@ -2903,9 +2944,15 @@ 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), ...expressionLiterals(word.raw)].flatMap(
-  (part) => shellCommandsAt(part.text, word.start + part.start)
-);
+function expansionCommands(word) {
+  const expansions = wordExpansions(word.raw);
+  const literals = expressionLiterals(word.raw).filter(
+    ({ start }) => expansions.every((expansion) => start < expansion.start || start >= expansion.expansionEnd)
+  );
+  return [...expansions, ...literals].flatMap(
+    (part) => shellCommandsAt(part.text, word.start + part.start)
+  );
+}
 function innerCommands(command) {
   const assignments = new Map(shellAssignments(command).map((found) => [found.word, found]));
   const code = inlineCode(command)?.code;
@@ -2946,6 +2993,8 @@ function canRunGenerator(definition, generators) {
       return generators.has(definition.target);
     case "append":
       return false;
+    case "run-time":
+      return true;
     default:
       return assertNever(definition);
   }
@@ -2958,6 +3007,8 @@ function canRunOther(definition, others, defined) {
       return others.has(definition.target) || !defined.has(definition.target);
     case "append":
       return false;
+    case "run-time":
+      return true;
     default:
       return assertNever(definition);
   }
@@ -2986,15 +3037,24 @@ function variablePrograms(definitions) {
   return new Map([...defined].map((name) => [name, programOf(name)]));
 }
 
-const SHELL_VARIABLE_RE = /^"?\$(?:([A-Za-z_][A-Za-z0-9_]*)|\{([A-Za-z_][A-Za-z0-9_]*)\})"?$/;
-function expandedName(text) {
-  const match = SHELL_VARIABLE_RE.exec(text);
+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);
   return match === null ? void 0 : match[1] ?? match[2];
 }
 const textRunsGenerator = (text) => shellCommands(text).some(runsGenerator);
+function runsExpression(command) {
+  const { program } = commandRoles(command);
+  const word = program === void 0 ? void 0 : command[program];
+  return word !== void 0 && isWholeExpression(word.raw);
+}
 function textDefinition(name, text) {
-  const target = expandedName(text.trim());
-  return target === void 0 ? { name, kind: "command", runsGenerator: textRunsGenerator(text) } : { name, kind: "reference", target };
+  const target = expandedName$1(text.trim());
+  if (target !== void 0) {
+    return { name, kind: "reference", target };
+  }
+  const commands = shellCommands(text);
+  return commands.some(runsExpression) ? { name, kind: "run-time" } : { name, kind: "command", runsGenerator: commands.some(runsGenerator) };
 }
 function expansionDefinitions(name, expansion) {
   const word = textDefinition(name, expansion.text);
@@ -3012,7 +3072,7 @@ function shellVariables(definitions) {
     values.set(name, [values.get(name), value].filter((part) => part !== void 0).join(" "));
   }
   const programs = variablePrograms(definitions.flatMap(programDefinitions$1));
-  const nameAt = (word) => expandedName(word.raw);
+  const nameAt = (word) => expandedName$1(word.raw);
   return {
     programAt: (program) => {
       const name = nameAt(program);
@@ -3057,7 +3117,7 @@ function expansionUse(word, variables) {
     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 target = expandedName$1(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);
@@ -3084,10 +3144,11 @@ const QUOTES$1 = /* @__PURE__ */ new Set(["'", '"']);
 const PATH_SEPARATOR$7 = "/";
 const BIN_FOLDER = "/.bin/";
 const OLD_PACKAGE_FOLDER = `node_modules/${GENERATOR_COMMAND}/`;
-function renameAtEnd(word, name, to) {
+function renameAtEnd(word, name, to, suffix = "") {
   const at = word.raw.lastIndexOf(name);
   const tail = word.raw.slice(at + name.length);
-  if (at === -1 || tail !== "" && !QUOTES$1.has(tail)) {
+  const quote = tail.slice(suffix.length);
+  if (at === -1 || quote !== "" && !QUOTES$1.has(quote)) {
     return void 0;
   }
   return { start: word.start + at, end: word.start + at + name.length, text: to };
@@ -3107,27 +3168,30 @@ function packageFindings(found, locate) {
   const change = { kind: "package-name-renamed", location, from: name, to };
   return edit === void 0 ? [] : [{ offset, edit, change }];
 }
-function programPathFindings(word, location) {
+function programPathFindings(word, { path, suffix }, location) {
   const offset = word.start;
-  if (word.value.includes(OLD_PACKAGE_FOLDER)) {
-    return [{ offset, manualStep: { kind: "old-package-file", location, path: word.value } }];
+  if (path.includes(OLD_PACKAGE_FOLDER)) {
+    return [{ offset, manualStep: { kind: "old-package-file", location, path } }];
   }
-  const isBin = word.value.endsWith(`${BIN_FOLDER}${GENERATOR_COMMAND}`);
-  const edit = isBin ? renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND) : void 0;
+  const isBin = path.endsWith(`${BIN_FOLDER}${GENERATOR_COMMAND}${suffix}`);
+  const to = MIGRATED_GENERATOR_COMMAND;
+  const edit = isBin ? renameAtEnd(word, GENERATOR_COMMAND, to, suffix) : void 0;
   return edit === void 0 ? [] : [{ offset, edit, change: { kind: "command-renamed", location } }];
 }
 function programFindings(word, location) {
-  if (word.value.includes(PATH_SEPARATOR$7)) {
-    return programPathFindings(word, location);
+  const program = programPath(word);
+  if (program.path.includes(PATH_SEPARATOR$7)) {
+    return programPathFindings(word, program, location);
   }
-  const { name, isPinned } = packageReference(word.value);
+  const { path, suffix } = program;
+  const { name, isPinned } = packageReference(path.slice(0, path.length - suffix.length));
   if (name !== GENERATOR_COMMAND) {
     return [];
   }
   if (isPinned) {
     return [{ offset: word.start, manualStep: { kind: "versioned-command", location } }];
   }
-  const edit = renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND);
+  const edit = renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND, suffix);
   const change = { kind: "command-renamed", location };
   return edit === void 0 ? [] : [{ offset: word.start, edit, change }];
 }
@@ -4133,7 +4197,8 @@ function interpolationsOf(text) {
 }
 
 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 PARAMETER_RE = /^([+*$]*)([A-Za-z_][A-Za-z0-9_-]*)(?:=([\s\S]*))?$/;
+const EXPORT_PREFIX = "$";
 const NAME_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
 const COLON = ":";
 const EQUALS = "=";
@@ -4180,14 +4245,15 @@ function parameterWords(text, start, end) {
 function parameterDefault(text, word) {
   const written = text.slice(word.start, word.end);
   const match = PARAMETER_RE.exec(written);
-  const value = match?.[2];
+  const value = match?.[3];
   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 }];
+  const isExported = match[1].includes(EXPORT_PREFIX);
+  return [{ name: match[2], isExported, literals, target }];
 }
 function recipeHeaders(text) {
   return [...text.matchAll(RECIPE_NAME_RE)].flatMap((match) => {
@@ -4329,7 +4395,9 @@ function shebangRecipe(text, header) {
 }
 const shebangRecipes = (text, headers) => headers.flatMap((header) => shebangRecipe(text, header));
 
-const ASSIGNMENT_RE$1 = /^(?:export[ \t]+)?([A-Za-z_][A-Za-z0-9_-]*)[ \t]*:=[ \t]*/gm;
+const ASSIGNMENT_RE$1 = /^(export[ \t]+)?([A-Za-z_][A-Za-z0-9_-]*)[ \t]*:=[ \t]*/gm;
+const SET_EXPORT_RE = /^set[ \t]+export(?:[ \t]*:=[ \t]*true)?[ \t]*(?:#.*)?$/m;
+const SHELL_VARIABLE_RE = /^[@+-]*"?\$(?:([A-Za-z_][A-Za-z0-9_]*)|\{([A-Za-z_][A-Za-z0-9_]*)\})"?$/;
 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 = "_";
@@ -4339,7 +4407,8 @@ function assignmentsOf$1(text) {
     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 };
+    const name = match[2];
+    return { name, isExported: match[1] !== void 0, value, start: match.index, end, literals };
   });
 }
 function onlyString({ value, literals }) {
@@ -4400,9 +4469,20 @@ 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) {
+function exportedNames(text, assignments, defaults) {
+  const isAll = SET_EXPORT_RE.test(text);
+  const names = [...assignments, ...defaults].filter((found) => isAll || found.isExported);
+  return new Set(names.map((found) => found.name));
+}
+function expandedName(written, exported) {
+  const interpolated = VARIABLE_INTERPOLATION_RE.exec(written)?.[1];
+  const match = SHELL_VARIABLE_RE.exec(written);
+  const shellName = match === null ? void 0 : match[1] ?? match[2];
+  return interpolated ?? (shellName !== void 0 && exported.has(shellName) ? shellName : void 0);
+}
+function justfileVariables(text, { values, programs, exported }) {
   const writtenAt = (word) => text.slice(word.start, word.end);
-  const nameAt = (word) => VARIABLE_INTERPOLATION_RE.exec(writtenAt(word))?.[1];
+  const nameAt = (word) => expandedName(writtenAt(word), exported);
   return {
     programAt: (word) => {
       const name = nameAt(word);
@@ -4427,7 +4507,11 @@ function migrateJustfile(text, file) {
     ...assignments.flatMap(assignmentDefinitions),
     ...defaults.flatMap(parameterDefinitions)
   ]);
-  const variables = justfileVariables(text, variableValues$1(assignments, defaults), programs);
+  const variables = justfileVariables(text, {
+    values: variableValues$1(assignments, defaults),
+    programs,
+    exported: exportedNames(text, assignments, defaults)
+  });
   const scripts = shebangRecipes(text, headers);
   const shell = shellText$1(text, [...assignments, ...headers, ...scripts]);
   const commands = [
@@ -4442,23 +4526,10 @@ function migrateJustfile(text, file) {
   return { text: applyTextEdits(text, edits), changes, manualSteps: steps };
 }
 
-const ASSIGNMENT_RE = new RegExp(
-  [
-    "^(?:[^\\s:#=][^:#=\\n]*:[ \\t]*)?",
-    "(?:(?:export|override|private)[ \\t]+)*",
-    "([A-Za-z_][A-Za-z0-9_.-]*)",
-    "[ \\t]*(:::=|::=|:=|\\?=|\\+=|!=|=)"
-  ].join(""),
-  "gm"
-);
-const VARIABLE_REFERENCE_RE = /^\$(?:\(([A-Za-z_][A-Za-z0-9_.-]*)\)|\{([A-Za-z_][A-Za-z0-9_.-]*)\}|([A-Za-z_]))$/;
-const RECIPE_PREFIX_RE = /^[@+-]+/;
 const DOLLAR = "$";
 const CLOSING = { "(": ")", "{": "}" };
-const NOT_LINE_BREAK_RE = /[^\n]/g;
 const MASK = "_";
-const LINE_BREAK = "\n";
-const BACKSLASH = "\\";
+const ARGUMENT_SEPARATOR = ",";
 function expansionEnd(text, start) {
   const open = text[start + 1] ?? "";
   const close = CLOSING[open];
@@ -4475,9 +4546,8 @@ function expansionEnd(text, start) {
   }
   return void 0;
 }
-function maskExpansions(text) {
-  const parts = [];
-  let copiedUpTo = 0;
+function expansionsOf(text) {
+  const found = [];
   for (let index = text.indexOf(DOLLAR); index !== -1; index = text.indexOf(DOLLAR, index + 1)) {
     if (text[index + 1] === DOLLAR) {
       index++;
@@ -4485,15 +4555,75 @@ function maskExpansions(text) {
     }
     const end = expansionEnd(text, index);
     if (end !== void 0) {
-      parts.push(text.slice(copiedUpTo, index + 1), MASK.repeat(end - index - 1));
-      copiedUpTo = end;
+      found.push({ start: index, end });
       index = end - 1;
     }
   }
+  return found;
+}
+function maskExpansions(text) {
+  const parts = [];
+  let copiedUpTo = 0;
+  for (const { start, end } of expansionsOf(text)) {
+    parts.push(text.slice(copiedUpTo, start + 1), MASK.repeat(end - start - 1));
+    copiedUpTo = end;
+  }
   parts.push(text.slice(copiedUpTo));
   return parts.join("");
 }
+const VALUE_ARGUMENTS = /* @__PURE__ */ new Map([
+  ["if", 1],
+  ["or", 0],
+  ["and", 0]
+]);
+const FUNCTION_HEAD_RE = /^\$[({]([a-z]+)[ \t]+/;
+const OPENING = new Set(Object.keys(CLOSING));
+const CLOSINGS = new Set(Object.values(CLOSING));
+function callArguments(text, start, end) {
+  const found = [];
+  let argumentStart = start;
+  let depth = 0;
+  for (let index = start; index < end; index++) {
+    const char = text[index];
+    depth += OPENING.has(char) ? 1 : CLOSINGS.has(char) ? -1 : 0;
+    if (char === ARGUMENT_SEPARATOR && depth === 0) {
+      found.push({ text: text.slice(argumentStart, index), start: argumentStart });
+      argumentStart = index + 1;
+    }
+  }
+  return [...found, { text: text.slice(argumentStart, end), start: argumentStart }];
+}
+function valueArguments(text, { start, end }) {
+  const head = FUNCTION_HEAD_RE.exec(text.slice(start, end));
+  const first = head === null ? void 0 : VALUE_ARGUMENTS.get(head[1]);
+  if (head === null || first === void 0) {
+    return [];
+  }
+  return callArguments(text, start + head[0].length, end - 1).slice(first);
+}
+function functionCommands(text, offset = 0) {
+  return expansionsOf(text).flatMap((expansion) => valueArguments(text, expansion)).flatMap((argument) => [
+    ...shellCommandsAt(maskExpansions(argument.text), offset + argument.start),
+    ...functionCommands(argument.text, offset + argument.start)
+  ]);
+}
+
+const ASSIGNMENT_RE = new RegExp(
+  [
+    "^(?:[^\\s:#=][^:#=\\n]*:[ \\t]*)?",
+    "(?:(?:export|override|private)[ \\t]+)*",
+    "([A-Za-z_][A-Za-z0-9_.-]*)",
+    "[ \\t]*(:::=|::=|:=|\\?=|\\+=|!=|=)"
+  ].join(""),
+  "gm"
+);
+const VARIABLE_REFERENCE_RE = /^\$(?:\(([A-Za-z_][A-Za-z0-9_.-]*)\)|\{([A-Za-z_][A-Za-z0-9_.-]*)\}|([A-Za-z_]))$/;
+const RECIPE_PREFIX_RE = /^[@+-]+/;
+const NOT_LINE_BREAK_RE = /[^\n]/g;
+const LINE_BREAK = "\n";
+const BACKSLASH = "\\";
 const APPEND_OPERATOR = "+=";
+const CONDITIONAL_OPERATOR = "?=";
 function logicalLineEnd(text, index) {
   let end = text.indexOf(LINE_BREAK, index);
   while (end !== -1 && text[end - 1] === BACKSLASH) {
@@ -4505,8 +4635,8 @@ const assignmentsOf = (text) => [...text.matchAll(ASSIGNMENT_RE)].map((match) =>
   const valueStart = match.index + match[0].length;
   const valueEnd = logicalLineEnd(text, valueStart);
   const name = match[1];
-  const isAppend = match[2] === APPEND_OPERATOR;
-  return { name, isAppend, start: match.index, valueStart, valueEnd };
+  const operator = match[2];
+  return { name, operator, start: match.index, valueStart, valueEnd };
 });
 function withoutAssignmentHeads(text, assignments) {
   const parts = [];
@@ -4527,18 +4657,34 @@ function referencedName(written) {
   const match = VARIABLE_REFERENCE_RE.exec(written.trim().replace(RECIPE_PREFIX_RE, ""));
   return match === null ? void 0 : match[1] ?? match[2] ?? match[3];
 }
+function programWritten(text, command) {
+  const { program } = commandRoles(command);
+  const word = program === void 0 ? void 0 : command[program];
+  return word === void 0 ? "" : text.slice(word.start, word.end);
+}
+function valueDefinition(text, { name, valueStart, valueEnd }, commands) {
+  const inValue = commands.filter(
+    ([first2]) => first2 !== void 0 && valueStart <= first2.start && first2.start < valueEnd
+  );
+  const [first] = inValue.sort((left, right) => (left[0]?.start ?? 0) - (right[0]?.start ?? 0));
+  const program = first === void 0 ? "" : programWritten(text, first);
+  const target = referencedName(program);
+  if (target !== void 0) {
+    return { name, kind: "reference", target };
+  }
+  if (isComputed(program)) {
+    return { name, kind: "run-time" };
+  }
+  return { name, kind: "command", runsGenerator: inValue.some(runsGenerator) };
+}
 function programDefinitions(text, commands, assignments) {
-  const generatorStarts = commands.filter(runsGenerator).map((command) => command[0].start);
-  return assignments.map(({ name, isAppend, valueStart, valueEnd }) => {
-    if (isAppend) {
-      return { name, kind: "append" };
-    }
-    const target = referencedName(text.slice(valueStart, valueEnd));
-    if (target !== void 0) {
-      return { name, kind: "reference", target };
+  return assignments.flatMap((assignment) => {
+    const { name, operator } = assignment;
+    if (operator === APPEND_OPERATOR) {
+      return [{ name, kind: "append" }];
     }
-    const runs = generatorStarts.some((start) => valueStart <= start && start < valueEnd);
-    return { name, kind: "command", runsGenerator: runs };
+    const value = valueDefinition(text, assignment, commands);
+    return operator === CONDITIONAL_OPERATOR ? [value, { name, kind: "run-time" }] : [value];
   });
 }
 function variableValues(text, assignments) {
@@ -4573,7 +4719,10 @@ function makefileVariables(text, assignments, programs) {
 function migrateMakefile(text, file) {
   const lineOf = lineLocator(text);
   const assignments = assignmentsOf(text);
-  const commands = shellCommands(withoutAssignmentHeads(maskExpansions(text), assignments));
+  const commands = [
+    ...shellCommands(withoutAssignmentHeads(maskExpansions(text), assignments)),
+    ...functionCommands(text)
+  ];
   const programs = variablePrograms(programDefinitions(text, commands, assignments));
   const locate = (offset) => `${file}:${lineOf(offset)}`;
   const variables = makefileVariables(text, assignments, programs);
@@ -4921,6 +5070,31 @@ function oldPackagePatchSteps(fileName) {
   return name === void 0 || to === void 0 ? [] : [{ kind: "old-package-patch", name, to }];
 }
 
+const INPUTS_KEY = "inputs";
+const DEFAULT_KEY = "default";
+const INPUT_DEFAULT_DEPTH = 3;
+const INPUT_NAME_INDEX = -2;
+const isInputDefault = (value) => value.path.length >= INPUT_DEFAULT_DEPTH && value.path.at(-1) === DEFAULT_KEY && value.path.at(-INPUT_DEFAULT_DEPTH) === INPUTS_KEY;
+const INPUT_EXPRESSION_RE = /^"?\$\{\{[ \t]*inputs\.([A-Za-z_][A-Za-z0-9_-]*)[ \t]*\}\}"?$/;
+function withInputDefaults(variables, strings) {
+  const values = /* @__PURE__ */ new Map();
+  for (const value of strings.filter(isInputDefault)) {
+    const name = String(value.path.at(INPUT_NAME_INDEX));
+    values.set(
+      name,
+      [values.get(name), value.value].filter((part) => part !== void 0).join(" ")
+    );
+  }
+  return {
+    programAt: (program) => variables.programAt(program),
+    referenceAt: (word) => {
+      const name = INPUT_EXPRESSION_RE.exec(word.raw)?.[1];
+      const value = name === void 0 ? void 0 : values.get(name);
+      return variables.referenceAt(word) ?? (value === void 0 ? void 0 : { written: word.raw, value });
+    }
+  };
+}
+
 const YAML_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "run",
   "script",
@@ -4947,10 +5121,6 @@ const TASKFILE_COMMAND_KEYS = /* @__PURE__ */ new Set([
 
 const ENVIRONMENT_KEYS = /* @__PURE__ */ new Set(["env"]);
 const isEnvironmentValue = (value) => value.path.length >= 2 && ENVIRONMENT_KEYS.has(String(value.path.at(-2)));
-const INPUTS_KEY = "inputs";
-const DEFAULT_KEY = "default";
-const INPUT_DEFAULT_DEPTH = 3;
-const isInputDefault = (value) => value.path.length >= INPUT_DEFAULT_DEPTH && value.path.at(-1) === DEFAULT_KEY && value.path.at(-INPUT_DEFAULT_DEPTH) === INPUTS_KEY;
 function environmentVariables(text, strings) {
   return shellVariables(
     strings.filter(isEnvironmentValue).map((value) => ({
@@ -4978,7 +5148,15 @@ function blockIndent(shell) {
   const indents = lines.map((line) => LEADING_SPACES_RE.exec(line)?.[0].length ?? 0);
   return indents.length === 0 ? 0 : Math.min(...indents);
 }
-const valuesOf = (strings, keys) => strings.filter((string) => keys.has(ownerKey(string.path) ?? ""));
+function oncePerPlace(strings) {
+  const starts = /* @__PURE__ */ new Set();
+  return strings.filter((string) => {
+    const isFirst = !starts.has(string.start);
+    starts.add(string.start);
+    return isFirst;
+  });
+}
+const valuesOf = (strings, keys) => oncePerPlace(strings.filter((string) => keys.has(ownerKey(string.path) ?? "")));
 const EXEC_FORM_KEYS = /* @__PURE__ */ new Set(["command", "entrypoint"]);
 const isExecFormItem = (value) => typeof value.path.at(-1) === "number" && EXEC_FORM_KEYS.has(String(value.path.at(-2)));
 const listOf = (item) => item.path.slice(0, -1).join(".");
@@ -5033,10 +5211,12 @@ function migrateYamlCommands(text, file, strings, keys = YAML_COMMAND_KEYS) {
   const shellOf = stepShells(strings);
   const values = valuesOf(strings, keys).filter((value) => shellOf(value) === void 0);
   const commandValues = new Set(values.filter((value) => !isExecFormItem(value)));
-  const shellValues = strings.filter(
-    (value) => commandValues.has(value) || isEnvironmentValue(value) || isInputDefault(value)
+  const shellValues = oncePerPlace(
+    strings.filter(
+      (value) => commandValues.has(value) || isEnvironmentValue(value) || isInputDefault(value)
+    )
   );
-  const variables = environmentVariables(text, strings);
+  const variables = withInputDefaults(environmentVariables(text, strings), strings);
   return appliedFindings(text, [
     ...shellValues.map((value) => valueFindings(text, value, locate, variables)),
     commandWordFindings(execFormCommands(text, values.filter(isExecFormItem)), locate),
@@ -5210,6 +5390,7 @@ function migrateConfig(text, read, steps) {
   );
 }
 const stringsStep = (migrate) => (text, read) => read.kind === "unreadable" ? unreadableConfig(text, read.offset) : migrate(text, documentStrings(read.documents));
+const usedStringsStep = (migrate) => (text, read) => read.kind === "unreadable" ? unreadableConfig(text, read.offset) : migrate(text, usedDocumentStrings(read.documents));
 const jsonConfig = (steps) => (text, path, context) => migrateConfig(text, (current) => context.readers.json.read(current), steps(context, path));
 const yamlConfig = (steps) => (text, path, context) => migrateConfig(text, (current) => context.readers.yaml.read(current), steps(context, path));
 const whenNamed = (migrate) => (text, path, context) => namesOriginalPackage(text) ? migrate(text, path, context) : unchanged(text);
@@ -5365,7 +5546,7 @@ const COMMAND_CONFIG_KINDS = [
     matches: (path) => TASKFILE_NAMES.has(baseName(path)),
     migrate: whenNamed(
       yamlConfig((_context, path) => [
-        stringsStep(
+        usedStringsStep(
           (text, strings) => migrateYamlCommands(text, path, strings, TASKFILE_COMMAND_KEYS)
         )
       ])
@@ -5380,7 +5561,10 @@ const COMMAND_CONFIG_KINDS = [
     )
   }
 ];
-const yamlCommandsStep = (path, isPart) => (text, read) => isPart || !isCiConfigFile(path) && read.kind === "read" && isApiDescription(read.documents) ? unchanged(text) : stringsStep((current, strings) => migrateYamlCommands(current, path, strings))(text, read);
+const yamlCommandsStep = (path, isPart) => (text, read) => isPart || !isCiConfigFile(path) && read.kind === "read" && isApiDescription(read.documents) ? unchanged(text) : usedStringsStep((current, strings) => migrateYamlCommands(current, path, strings))(
+  text,
+  read
+);
 const manifestTarget = ({ version, catalogs, aliases }, path) => ({
   version,
   catalogs,
@@ -6031,6 +6215,7 @@ const NEXT_STEPS = [
 const DRY_RUN_NOTE = "Dry run: nothing was written. Run again with --write to apply.";
 const WRITTEN_NOTE = "Files were written.";
 const NOTHING_FOUND = "Nothing to migrate: no openapi-typescript, openapi-fetch, openapi-react-query or openapi-typescript-helpers found.";
+const NOTHING_ELSE_FOUND = "Nothing else to migrate: migrate the skipped files above by hand.";
 
 function changesSection(reports) {
   const changed = reports.filter((report) => report.changes.length > 0);
@@ -6086,7 +6271,8 @@ function renderReport(migration) {
   const reports = migration.files;
   const skipped = skippedSection(migration.skipped);
   if (reports.length === 0) {
-    return printed([...skipped, NOTHING_FOUND]);
+    const hasBug = migration.skipped.some((file) => file.reason.kind === "migration-bug");
+    return printed([...skipped, hasBug ? NOTHING_ELSE_FOUND : NOTHING_FOUND]);
   }
   const lines = [
     ...changesSection(reports),