openapi-typesafe-migrate 1.0.0-rc.7 → 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";
@@ -609,15 +609,17 @@ function columnAt(text, offset) {
   return offset - text.lastIndexOf("\n", offset - 1);
 }
 
+class MigrationBugError extends Error {
+  name = "MigrationBugError";
+}
+
 function applyTextEdits(text, edits) {
   const sorted = [...edits].sort((left, right) => left.start - right.start);
   let edited = "";
   let copiedUpTo = 0;
   for (const edit of sorted) {
     if (edit.start < copiedUpTo) {
-      throw new Error(
-        `Edits overlap at offset ${edit.start}; the file was not changed (a migration bug).`
-      );
+      throw new MigrationBugError(`edits overlap at offset ${edit.start}`);
     }
     edited += `${text.slice(copiedUpTo, edit.start)}${edit.text}`;
     copiedUpTo = edit.end;
@@ -625,6 +627,80 @@ function applyTextEdits(text, edits) {
   return edited + text.slice(copiedUpTo);
 }
 
+const TYPE_TEXT = "string";
+const TYPESCRIPT_MODULES$1 = /* @__PURE__ */ new Set(["typescript", "@typescript/typescript6"]);
+function isTypescriptReference(node, bindings) {
+  const name = node.typeName;
+  if (ts.isIdentifier(name)) {
+    return bindings.bindingOf(name)?.kind === "typescript-import";
+  }
+  return ts.isIdentifier(name.left) && bindings.bindingOf(name.left)?.kind === "typescript-module";
+}
+function isTypescriptImportType(node) {
+  const { argument } = node;
+  return !node.isTypeOf && ts.isLiteralTypeNode(argument) && ts.isStringLiteral(argument.literal) && TYPESCRIPT_MODULES$1.has(argument.literal.text);
+}
+function joined$1(found) {
+  const edits = [];
+  for (const part of found) {
+    if (part === void 0) {
+      return void 0;
+    }
+    edits.push(...part);
+  }
+  return edits;
+}
+const memberEdits = (node, bindings) => joined$1(
+  node.members.map(
+    (member) => ts.isPropertySignature(member) ? typeEdits(member.type, bindings) : void 0
+  )
+);
+const replaced = (node) => [
+  { start: node.getStart(), end: node.getEnd(), text: TYPE_TEXT }
+];
+const isKeyword = (node) => node.kind >= ts.SyntaxKind.FirstKeyword && node.kind <= ts.SyntaxKind.LastKeyword;
+function typeEdits(node, bindings) {
+  if (node === void 0) {
+    return void 0;
+  }
+  if (ts.isLiteralTypeNode(node) || isKeyword(node)) {
+    return [];
+  }
+  if (ts.isUnionTypeNode(node) || ts.isIntersectionTypeNode(node)) {
+    return joined$1(node.types.map((part) => typeEdits(part, bindings)));
+  }
+  if (ts.isParenthesizedTypeNode(node)) {
+    return typeEdits(node.type, bindings);
+  }
+  if (ts.isTypeLiteralNode(node)) {
+    return memberEdits(node, bindings);
+  }
+  const isNodeType = ts.isTypeReferenceNode(node) ? isTypescriptReference(node, bindings) : ts.isImportTypeNode(node) && isTypescriptImportType(node);
+  return isNodeType ? replaced(node) : void 0;
+}
+function functionReturnType(node) {
+  return ts.isFunctionTypeNode(node) || ts.isJSDocFunctionType(node) ? node.type : void 0;
+}
+function declaredType(node) {
+  const annotation = ts.isVariableDeclaration(node) ? node.type : void 0;
+  const isJavaScript = (node.flags & ts.NodeFlags.JavaScriptFile) !== 0;
+  return annotation ?? (isJavaScript ? ts.getJSDocType(node) : void 0);
+}
+function annotationEdits(type, bindings) {
+  const returned = functionReturnType(type);
+  if (returned !== void 0) {
+    return typeEdits(returned, bindings);
+  }
+  return ts.isIndexedAccessTypeNode(type) || isKeyword(type) ? [] : void 0;
+}
+function callbackTypeEdits(annotations, callback, bindings) {
+  const returnsTag = ts.getJSDocReturnTag(callback)?.typeExpression?.type;
+  return joined$1([
+    ...annotations.map((type) => annotationEdits(type, bindings)),
+    returnsTag === void 0 ? [] : typeEdits(returnsTag, bindings)
+  ]);
+}
+
 const hasExportModifier = (declaration) => (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Export) !== 0;
 const GENERATOR_MODULES = /* @__PURE__ */ new Set([
   "openapi-typesafe",
@@ -848,6 +924,22 @@ function generatorCalls(file, bindings) {
   return calls;
 }
 
+const TRANSFORM = "transform";
+const LEGACY_ONLY_CALLBACKS = ["postTransform", "transformProperty"];
+const IR_CALLBACKS_OPTION = "irCallbacks";
+function propertyNamed(options, name) {
+  return options.properties.find((property) => {
+    const key = property.name;
+    return key !== void 0 && (ts.isIdentifier(key) || ts.isStringLiteral(key)) && key.text === name;
+  });
+}
+function legacyCallbackSteps(options, text) {
+  return LEGACY_ONLY_CALLBACKS.flatMap((callback) => {
+    const property = propertyNamed(options, callback);
+    return property === void 0 ? [] : [{ kind: "legacy-callback", line: lineAt(text, property.getStart()), callback }];
+  });
+}
+
 const TS_NODE_OPTIONS = "OpenAPITSOptions";
 const IR_OPTIONS = "OpenAPITSIrOptions";
 const TYPE_MODIFIER = "type ";
@@ -1080,6 +1172,41 @@ function scriptRegions(text, path) {
   return componentRegions(text, extension === ASTRO_EXTENSION);
 }
 
+function spreadObject(expression, bindings) {
+  const { value } = unwrapped(expression);
+  if (ts.isObjectLiteralExpression(value)) {
+    return value;
+  }
+  const binding = ts.isIdentifier(value) ? bindings.bindingOf(value) : void 0;
+  const initializer = binding?.kind === "constant" ? unwrapped(binding.initializer).value : void 0;
+  return initializer !== void 0 && ts.isObjectLiteralExpression(initializer) ? initializer : void 0;
+}
+function spreadObjectSteps(source, text, bindings, seen) {
+  if (seen.has(source) || propertyNamed(source, IR_CALLBACKS_OPTION) !== void 0) {
+    return [];
+  }
+  seen.add(source);
+  const transform = propertyNamed(source, TRANSFORM);
+  const kept = transform === void 0 ? [] : [
+    {
+      kind: "transform-not-rewritten",
+      line: lineAt(text, transform.getStart()),
+      reason: "in-spread"
+    }
+  ];
+  return [
+    ...legacyCallbackSteps(source, text),
+    ...kept,
+    ...spreadSteps(source, text, bindings, seen)
+  ];
+}
+function spreadSteps(options, text, bindings, seen = /* @__PURE__ */ new Set()) {
+  return options.properties.filter(ts.isSpreadAssignment).flatMap((spread) => {
+    const source = spreadObject(spread.expression, bindings);
+    return source === void 0 ? [{ kind: "options-spread-not-inspected", line: lineAt(text, spread.getStart()) }] : spreadObjectSteps(source, text, bindings, seen);
+  });
+}
+
 function namedFunction(name, names) {
   const binding = names.bindings.bindingOf(name);
   if (binding?.kind === "function") {
@@ -1108,7 +1235,7 @@ function callbackFunction(property, names) {
 function callbackAnnotations(property, names) {
   const name = namedValue(property);
   const declaration = name === void 0 ? void 0 : names.bindings.declarationOf(name);
-  const type = declaration !== void 0 && ts.isVariableDeclaration(declaration) ? declaration.type : void 0;
+  const type = declaredType(declaration ?? property);
   return type === void 0 ? [] : [type];
 }
 function isSharedFunction(property, names) {
@@ -1209,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;
@@ -1438,9 +1569,6 @@ function removalEdits(removed, text) {
   return [...statements].flatMap((statement) => statementEdits(statement, isRemoved, 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)";
@@ -1450,12 +1578,6 @@ const noFindings = () => ({
   manualSteps: [],
   typeReferences: []
 });
-function propertyNamed(options, name) {
-  return options.properties.find((property) => {
-    const key = property.name;
-    return key !== void 0 && (ts.isIdentifier(key) || ts.isStringLiteral(key)) && key.text === name;
-  });
-}
 function returnTypeEdits(callback, text) {
   const type = callback.type;
   if (type === void 0) {
@@ -1472,7 +1594,15 @@ function transformEdits(property, names, text) {
   if (isSharedFunction(property, names)) {
     return "shared-function";
   }
-  const edits = returnTypeEdits(callback, text);
+  const declared = callbackTypeEdits(
+    callbackAnnotations(property, names),
+    callback,
+    names.bindings
+  );
+  if (declared === void 0) {
+    return "declared-type";
+  }
+  const edits = [...returnTypeEdits(callback, text), ...declared];
   for (const returned of returnedExpressions(callback.body)) {
     const returnEditList = returnEdits(returned, names);
     if (returnEditList === void 0) {
@@ -1503,12 +1633,6 @@ function keepReason(options) {
   }
   return options.properties.some(ts.isSpreadAssignment) ? "spread-options" : void 0;
 }
-function legacyCallbackSteps(options, text) {
-  return LEGACY_ONLY_CALLBACKS.flatMap((callback) => {
-    const property = propertyNamed(options, callback);
-    return property === void 0 ? [] : [{ kind: "legacy-callback", line: lineAt(text, property.getStart()), callback }];
-  });
-}
 function transformRewrite(transform, options, names, text) {
   const edits = keepReason(options.options) ?? transformEdits(transform, names, text);
   if (typeof edits === "string") {
@@ -1524,6 +1648,7 @@ function migrateOptions(options, text, names) {
   }
   const findings = noFindings();
   findings.manualSteps.push(...legacyCallbackSteps(options.options, text));
+  findings.manualSteps.push(...spreadSteps(options.options, text, names.bindings));
   const transform = propertyNamed(options.options, TRANSFORM);
   if (transform === void 0) {
     return findings;
@@ -1542,12 +1667,13 @@ function migrateOptions(options, text, names) {
   findings.changes.push({ kind: "transform-rewritten", line });
   return findings;
 }
-function sharedOptionsFindings(options, text) {
+function sharedOptionsFindings(options, text, bindings) {
   const findings = noFindings();
   if (propertyNamed(options, IR_CALLBACKS_OPTION) !== void 0) {
     return findings;
   }
   findings.manualSteps.push(...legacyCallbackSteps(options, text));
+  findings.manualSteps.push(...spreadSteps(options, text, bindings));
   const transform = propertyNamed(options, TRANSFORM);
   if (transform !== void 0) {
     const line = lineAt(text, transform.getStart());
@@ -1563,7 +1689,7 @@ function callFindings(found, text, names) {
     case "own":
       return migrateOptions(options, text, names);
     case "shared":
-      return sharedOptionsFindings(options.options, text);
+      return sharedOptionsFindings(options.options, text, names.bindings);
     case "unknown": {
       const line = lineAt(text, options.expression.getStart());
       return { ...noFindings(), manualSteps: [{ kind: "options-not-inspected", line }] };
@@ -1832,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,
@@ -1840,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
 });
@@ -1849,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);
@@ -1857,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 : {}) };
 }
@@ -1940,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));
@@ -1953,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}`)
+    (name) => path.includes(`${NODE_MODULES_FOLDER}${name}${PATH_SEPARATOR$a}`) || path.endsWith(`${NODE_MODULES_FOLDER}${name}`)
   );
 }
 
@@ -1973,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");
@@ -2037,8 +2187,11 @@ const DESCRIPTION_KEY_LINE_RE = new RegExp(
   "m"
 );
 const mayBeApiDescription = (text) => DESCRIPTION_KEY_LINE_RE.test(text);
+const SPEC_VERSION_RE = /^\d+\.\d+(?:\.\d+)?(?:-[0-9A-Za-z.-]+)?$/;
 const isApiDescription = (documents) => documents.some(
-  (root) => isMap(root) && textEntries(root).some(({ key }) => API_DESCRIPTION_KEY_SET.has(key.value))
+  (root) => isMap(root) && textEntries(root).some(
+    ({ key, value }) => API_DESCRIPTION_KEY_SET.has(key.value) && isScalar(value) && SPEC_VERSION_RE.test(value.value)
+  )
 );
 const REF_KEY = "$ref";
 const FRAGMENT_START = "#";
@@ -2183,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([
   ";",
   "&",
@@ -2231,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) {
@@ -2363,9 +2576,13 @@ function skipAssignments(words, start) {
   }
   return index;
 }
+const WINDOWS_PROGRAM_SUFFIX_RE = /\.(?:cmd|exe|ps1)$/i;
+const windowsSuffix = (value) => WINDOWS_PROGRAM_SUFFIX_RE.exec(value)?.[0] ?? "";
+const withoutWindowsSuffix = (value) => value.slice(0, value.length - windowsSuffix(value).length);
+const entryWord = (word) => word === void 0 ? void 0 : withoutWindowsSuffix(word.value);
 function matchingPrefix(entries, words, index) {
   return entries.find(
-    (entry) => entry.words.every((name, offset) => words[index + offset]?.value === name)
+    (entry) => entry.words.every((name, offset) => entryWord(words[index + offset]) === name)
   );
 }
 function inlineOptionPackage(word, launcher) {
@@ -2446,7 +2663,58 @@ 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([
+  ["python", /* @__PURE__ */ new Set(["-c"])],
+  ["node", /* @__PURE__ */ new Set(["-e", "--eval", "-p", "--print"])],
+  ["bun", /* @__PURE__ */ new Set(["-e", "--eval", "-p", "--print"])],
+  ["ruby", /* @__PURE__ */ new Set(["-e"])],
+  ["perl", /* @__PURE__ */ new Set(["-e", "-E"])]
+]);
+const PYTHON_RE = /^(?:python[0-9.]*|py)$/;
+const PYTHON = "python";
+const PATH_SEPARATOR_RE$1 = /[/\\]/;
+const WINDOWS_EXECUTABLE_RE$1 = /\.exe$/i;
+const OPTION_START$1 = "-";
+function interpreterOf(word) {
+  const name = (word.value.split(PATH_SEPARATOR_RE$1).at(-1) ?? "").replace(
+    WINDOWS_EXECUTABLE_RE$1,
+    ""
+  );
+  return PYTHON_RE.test(name) ? PYTHON : name;
+}
+function codeAfter(command, program) {
+  const options = CODE_OPTIONS.get(interpreterOf(command[program]));
+  for (let index = program + 1; options !== void 0 && index < command.length; index += 1) {
+    const word = command[index];
+    if (!word.value.startsWith(OPTION_START$1)) {
+      return void 0;
+    }
+    if (options.has(word.value)) {
+      return command[index + 1];
+    }
+  }
+  return void 0;
+}
+function inlineCode(command) {
+  for (const [index, program] of command.entries()) {
+    const code = codeAfter(command, index);
+    if (code !== void 0) {
+      return { code, program };
+    }
+  }
+  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_]*):?([-=+])/;
@@ -2504,7 +2772,7 @@ function wholeWordExpansion(raw) {
 const HEREDOC_OPERATOR = "<<";
 const HERE_STRING_OPERATOR = "<<<";
 const STRIP_TABS = "-";
-const LINE_BREAK$4 = "\n";
+const LINE_BREAK$5 = "\n";
 const LEADING_TABS_RE = /^\t+/;
 const CARRIAGE_RETURN_RE = /\r$/;
 function heredocAt(text, index, where) {
@@ -2536,7 +2804,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$4, lineStart);
+    const lineEnd = text.indexOf(LINE_BREAK$5, lineStart);
     const end = lineEnd === -1 ? text.length : lineEnd;
     if (isDelimiterLine(text, lineStart, end, heredoc)) {
       const body = { command: heredoc.command, start, text: text.slice(start, lineStart) };
@@ -2558,7 +2826,7 @@ function readBodies(text, start, pending) {
 }
 
 const COMMENT = "#";
-const LINE_BREAK$3 = "\n";
+const LINE_BREAK$4 = "\n";
 function skipTrivia(text, index) {
   const char = text[index];
   if (WORD_BREAKS.has(char)) {
@@ -2588,7 +2856,7 @@ function topLevelCommands(text, indent) {
       index = heredoc.end;
     } else if (afterTrivia !== index) {
       index = afterTrivia;
-    } else if (text[index] === LINE_BREAK$3 && pending.length > 0) {
+    } else if (text[index] === LINE_BREAK$4 && pending.length > 0) {
       const read = readBodies(text, index + 1, pending);
       heredocs.push(...read.bodies);
       pending = [];
@@ -2676,13 +2944,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 expansionCommands(word) {
+  const expansions = wordExpansions(word.raw);
+  const literals = expressionLiterals(word.raw).filter(
+    ({ start }) => expansions.every((expansion) => start < expansion.start || start >= expansion.expansionEnd)
+  );
+  return [...expansions, ...literals].flatMap(
+    (part) => shellCommandsAt(part.text, word.start + part.start)
+  );
+}
 function innerCommands(command) {
   const assignments = new Map(shellAssignments(command).map((found) => [found.word, found]));
+  const code = inlineCode(command)?.code;
   return command.flatMap((word) => {
-    const inner = nestedCommandText(word);
+    const inner = word === code ? void 0 : nestedCommandText(word);
     if (inner !== void 0) {
       return shellCommandsAt(inner, word.start + 1);
     }
@@ -2718,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);
   }
@@ -2730,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);
   }
@@ -2758,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);
@@ -2784,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);
@@ -2829,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);
@@ -2847,7 +3135,7 @@ const VARIABLE_WORD_RE = new RegExp(
 );
 function withUnreadVariables(variables) {
   return {
-    programAt: (program) => variables.programAt(program) ?? (VARIABLE_WORD_RE.test(program.raw) ? { written: program.raw, program: "generator-or-other" } : void 0),
+    programAt: (program) => variables.programAt(program) ?? (VARIABLE_WORD_RE.test(program.raw) || isWholeExpression(program.raw) ? { written: program.raw, program: "generator-or-other" } : void 0),
     referenceAt: (word) => variables.referenceAt(word)
   };
 }
@@ -2856,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 };
@@ -2879,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 }];
 }
@@ -2961,6 +3253,14 @@ function commandFindings(command, locate, variables) {
   const handled = new Set(found.map((finding) => finding.offset));
   return [...found, ...unmigratedWordFindings(words, handled, locate)];
 }
+function inlineCodeFindings({ code, program }, locate) {
+  if (!namesOriginalPackage(code.value)) {
+    return [];
+  }
+  const location = locate(code.start);
+  const manualStep = { kind: "script-not-shell", location, shell: program.value };
+  return [{ offset: code.start, manualStep }];
+}
 function knownFindings(words, locate, variables) {
   const roles = commandRoles(words);
   const findings = roles.packages.flatMap((found2) => packageFindings(found2, locate));
@@ -2968,6 +3268,10 @@ function knownFindings(words, locate, variables) {
   if (program === void 0) {
     return findings;
   }
+  const code = inlineCode(words);
+  if (code !== void 0) {
+    return [...findings, ...inlineCodeFindings(code, locate)];
+  }
   const found = programFindings(program, locate(program.start));
   findings.push(...found);
   const isRenamed = found.some((finding) => finding.change?.kind === "command-renamed");
@@ -3289,36 +3593,52 @@ function assignedVariable(word) {
   const isQuoted = raw.length >= 2 && QUOTES.has(raw[0]) && raw.at(-1) === raw[0];
   const value = isQuoted ? raw.slice(1, -1) : raw;
   const start = word.start + at + 1 + (isQuoted ? 1 : 0);
-  return { name: word.raw.slice(0, at), commands: shellCommandsAt(value, start) };
+  return { name: word.raw.slice(0, at), value, start };
 }
-function dockerVariables(commands) {
-  return commands.flatMap(([instruction, first, ...rest]) => {
+function instructionVariables(text, words) {
+  const [instruction, first, ...rest] = words;
+  const last = rest.at(-1);
+  if (instruction.value === LEGACY_ENV_INSTRUCTION && !first.raw.includes(ASSIGNMENT$1)) {
+    const value = last === void 0 ? "" : text.slice(rest[0]?.start, last.end);
+    return [{ name: first.value, value, start: rest[0]?.start ?? first.end }];
+  }
+  return [first, ...rest].flatMap((word) => assignedVariable(word) ?? []);
+}
+function variableInstructions(text, commands) {
+  return commands.flatMap((words) => {
+    const [instruction, first] = words;
     if (instruction === void 0 || first === void 0) {
       return [];
     }
     if (!VARIABLE_INSTRUCTIONS.has(instruction.value)) {
       return [];
     }
-    if (instruction.value === LEGACY_ENV_INSTRUCTION && !first.raw.includes(ASSIGNMENT$1)) {
-      return [{ name: first.value, commands: [rest] }];
-    }
-    return [first, ...rest].flatMap((word) => assignedVariable(word) ?? []);
+    const end = words.at(-1).end;
+    return [{ start: instruction.start, end, variables: instructionVariables(text, words) }];
   });
 }
-const definitionOf = ({ name, commands }) => ({
-  name,
-  value: commands.flatMap((words) => words.map((word) => word.raw)).join(" ")
-});
+function withoutVariableInstructions(commands, instructions) {
+  const isInInstruction = (words) => {
+    const start = words[0]?.start ?? -1;
+    return instructions.some(
+      (instruction) => start >= instruction.start && start < instruction.end
+    );
+  };
+  return commands.filter((words) => !isInInstruction(words));
+}
+const valueCommands = ({ value, start }) => shellCommandsAt(value, start);
 function migrateDockerfile(text, file) {
   const lineOf = lineLocator(text);
   const locate = (offset) => `${file}:${lineOf(offset)}`;
   const forms = execForms(text);
   const exec = execCommands(forms);
   const shellForm = shellCommands(withoutExecForms(text, forms));
-  const definitions = dockerVariables(shellForm);
-  const values = definitions.flatMap((variable) => variable.commands);
-  const commands = [...shellForm, ...values, ...exec.commands];
-  const variables = shellVariables(definitions.map(definitionOf));
+  const instructions = variableInstructions(text, shellForm);
+  const definitions = instructions.flatMap((instruction) => instruction.variables);
+  const values = definitions.flatMap(valueCommands);
+  const run = withoutVariableInstructions(shellForm, instructions);
+  const commands = [...run, ...values, ...exec.commands];
+  const variables = shellVariables(definitions);
   const { edits, changes, manualSteps } = commandWordFindings(commands, locate, variables);
   const steps = [...manualSteps, ...escapedScriptSteps(exec.escaped, lineOf)];
   return { text: applyTextEdits(text, edits), changes, manualSteps: steps };
@@ -3670,8 +3990,8 @@ function distinctStrings(strings) {
       outer = enclosing.at(-1);
     }
     if (outer !== void 0 && found.end > outer.end) {
-      throw new Error(
-        `Source strings overlap at offsets ${outer.start}-${outer.end} and ${found.start}-${found.end}; the file was not changed.`
+      throw new MigrationBugError(
+        `source strings overlap at offsets ${outer.start}-${outer.end} and ${found.start}-${found.end}`
       );
     }
     enclosing.push(found);
@@ -3799,7 +4119,7 @@ const BACKTICK = "`";
 const ESCAPING_DELIMITER = '"';
 const ESCAPE = "\\";
 const COMMENT_START$1 = "#";
-const LINE_BREAK$2 = "\n";
+const LINE_BREAK$3 = "\n";
 function closingOffset(text, delimiter, from) {
   if (delimiter !== ESCAPING_DELIMITER) {
     const close = text.indexOf(delimiter, from);
@@ -3809,7 +4129,7 @@ function closingOffset(text, delimiter, from) {
     const char = text[index];
     if (char === ESCAPE) {
       index += 1;
-    } else if (char === ESCAPING_DELIMITER || char === LINE_BREAK$2) {
+    } else if (char === ESCAPING_DELIMITER || char === LINE_BREAK$3) {
       return char === ESCAPING_DELIMITER ? index : void 0;
     }
   }
@@ -3832,7 +4152,7 @@ function literalAt(text, offset) {
 function expressionAt(text, start) {
   const literals = [];
   let index = start;
-  while (index < text.length && text[index] !== LINE_BREAK$2 && text[index] !== COMMENT_START$1) {
+  while (index < text.length && text[index] !== LINE_BREAK$3 && text[index] !== COMMENT_START$1) {
     const literal = literalAt(text, index);
     literals.push(...literal === void 0 ? [] : [literal]);
     index = literal?.end ?? index + 1;
@@ -3856,7 +4176,7 @@ function interpolationAt(text, start) {
     if (text.startsWith(INTERPOLATION_CLOSE, index)) {
       return { start, end: index + INTERPOLATION_CLOSE.length, literals };
     }
-    if (text[index] === LINE_BREAK$2) {
+    if (text[index] === LINE_BREAK$3) {
       return void 0;
     }
     const literal = literalAt(text, index);
@@ -3877,18 +4197,19 @@ 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 = "=";
 const OPEN_PAREN = "(";
 const CLOSE_PAREN = ")";
 const COMMENT_START = "#";
-const LINE_BREAK$1 = "\n";
+const LINE_BREAK$2 = "\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; ) {
+  for (let index = from; index < text.length && text[index] !== LINE_BREAK$2; ) {
     const literal = literalAt(text, index);
     const char = text[index];
     if (literal !== void 0) {
@@ -3924,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) => {
@@ -3946,7 +4268,136 @@ function recipeHeaders(text) {
   });
 }
 
-const ASSIGNMENT_RE$1 = /^(?:export[ \t]+)?([A-Za-z_][A-Za-z0-9_-]*)[ \t]*:=[ \t]*/gm;
+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"],
+  ...["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 EXECUTORS_KEY = "executors";
+const EXECUTOR_SHELL_PATH_LENGTH = 3;
+const EXECUTOR_KEY = "executor";
+const EXECUTOR_NAME_KEY = "name";
+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 isCommandLineShell = (shell) => COMMAND_LINE_SHELLS.has(shellProgram(shell));
+const endsWith = (path, keys) => keys.every((key, index) => path[path.length - keys.length + index] === key);
+const isDefaultShell = (value) => endsWith(value.path, DEFAULT_SHELL_PATH);
+function scopeOf(value) {
+  const keys = isDefaultShell(value) ? DEFAULT_SHELL_PATH.length : 1;
+  return JSON.stringify(value.path.slice(0, -keys));
+}
+function executorShells(shells) {
+  const isExecutorShell = ({ path }) => path.length === EXECUTOR_SHELL_PATH_LENGTH && path[0] === EXECUTORS_KEY;
+  return new Map(
+    shells.filter(isExecutorShell).map((shell) => [String(shell.path[1]), shell.value])
+  );
+}
+function executorJob({ path }) {
+  if (path.at(-1) === EXECUTOR_KEY) {
+    return path.slice(0, -1);
+  }
+  const isNamed = path.at(-1) === EXECUTOR_NAME_KEY && path.at(-2) === EXECUTOR_KEY;
+  return isNamed ? path.slice(0, -2) : void 0;
+}
+function inheritedShells(strings, shells) {
+  const byExecutor = executorShells(shells);
+  return strings.flatMap((value) => {
+    const job = executorJob(value);
+    const shell = byExecutor.get(value.value);
+    return job === void 0 || shell === void 0 ? [] : [[JSON.stringify(job), shell]];
+  });
+}
+function stepShells(strings) {
+  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([
+    ...inheritedShells(strings, shells),
+    ...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 isCommandLineShell(shell) ? void 0 : shell;
+      }
+    }
+    return void 0;
+  };
+}
+function otherShellFindings(values, shellOf, locate) {
+  const manualSteps = values.flatMap((value) => {
+    const shell = shellOf(value);
+    return shell === void 0 || !namesOriginalPackage(value.value) ? [] : [{ kind: "script-not-shell", location: locate(value.start), shell }];
+  });
+  return { edits: [], changes: [], manualSteps };
+}
+
+const LINE_BREAK$1 = "\n";
+const SHEBANG = "#!";
+const BODY_LINE_RE = /^(?:[ \t][^\n]*|[ \t]*\r?)$/;
+function nextLineStart(text, offset) {
+  const lineBreak = text.indexOf(LINE_BREAK$1, offset);
+  return lineBreak === -1 ? text.length : lineBreak + 1;
+}
+function bodyEnd(text, start) {
+  let end = start;
+  while (end < text.length) {
+    const lineEnd = nextLineStart(text, end);
+    if (!BODY_LINE_RE.test(text.slice(end, lineEnd).replace(LINE_BREAK$1, ""))) {
+      break;
+    }
+    end = lineEnd;
+  }
+  return end;
+}
+function shebangRecipe(text, header) {
+  const start = nextLineStart(text, header.end);
+  const end = bodyEnd(text, start);
+  const firstLine = text.slice(start, end).split(LINE_BREAK$1).map((line) => line.trim()).find((line) => line.length > 0);
+  if (firstLine === void 0 || !firstLine.startsWith(SHEBANG)) {
+    return [];
+  }
+  const shell = firstLine.slice(SHEBANG.length).trim();
+  const shebang = text.indexOf(SHEBANG, start);
+  return isCommandLineShell(shell) ? [] : [{ start, end, shebang, shell }];
+}
+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 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 = "_";
@@ -3956,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 }) {
@@ -4001,11 +4453,15 @@ function shellText$1(text, spans) {
   return { text: masked, interpolations };
 }
 const literalCommands = (literals) => literals.flatMap((literal) => shellCommandsAt(literal.content, literal.contentStart));
-function variableValues$1(assignments) {
+const defaultValue = ({ literals }) => literals.map((literal) => literal.content).join(BLANK);
+function variableValues$1(assignments, defaults) {
   const values = /* @__PURE__ */ new Map();
-  for (const assignment of assignments) {
-    const value = onlyString(assignment)?.content ?? assignment.value;
-    values.set(assignment.name, [values.get(assignment.name), value].join(" ").trim());
+  const named = [
+    ...assignments.map((found) => ({ ...found, value: onlyString(found)?.content ?? found.value })),
+    ...defaults.map((found) => ({ name: found.name, value: defaultValue(found) }))
+  ];
+  for (const { name, value } of named) {
+    values.set(name, [values.get(name), value].join(BLANK).trim());
   }
   return values;
 }
@@ -4013,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);
@@ -4030,6 +4497,7 @@ function justfileVariables(text, values, programs) {
     }
   };
 }
+const shebangSteps = (text, recipes, locate) => recipes.filter((recipe) => namesOriginalPackage(text.slice(recipe.start, recipe.end))).map(({ shebang, shell }) => ({ kind: "script-not-shell", location: locate(shebang), shell }));
 function migrateJustfile(text, file) {
   const lineOf = lineLocator(text);
   const assignments = assignmentsOf$1(text);
@@ -4039,8 +4507,13 @@ function migrateJustfile(text, file) {
     ...assignments.flatMap(assignmentDefinitions),
     ...defaults.flatMap(parameterDefinitions)
   ]);
-  const variables = justfileVariables(text, variableValues$1(assignments), programs);
-  const shell = shellText$1(text, [...assignments, ...headers]);
+  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 = [
     ...shellCommands(shell.text),
     ...literalCommands(assignments.flatMap((assignment) => assignment.literals)),
@@ -4049,26 +4522,14 @@ function migrateJustfile(text, file) {
   ];
   const locate = (offset) => `${file}:${lineOf(offset)}`;
   const { edits, changes, manualSteps } = commandWordFindings(commands, locate, variables);
-  return { text: applyTextEdits(text, edits), changes, manualSteps };
+  const steps = [...manualSteps, ...shebangSteps(text, scripts, locate)];
+  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];
@@ -4085,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++;
@@ -4095,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) {
@@ -4115,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 = [];
@@ -4131,22 +4651,40 @@ function withoutAssignmentHeads(text, assignments) {
   parts.push(text.slice(copiedUpTo));
   return parts.join("");
 }
+const COMPUTED_RE = /^\$[({]/;
+const isComputed = (written) => COMPUTED_RE.test(written.trim().replace(RECIPE_PREFIX_RE, ""));
 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) {
@@ -4162,10 +4700,12 @@ function makefileVariables(text, assignments, programs) {
   const nameAt = (word) => referencedName(text.slice(word.start, word.end));
   const variables = {
     programAt: (program) => {
-      const name = nameAt(program);
-      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 };
+      const name = nameAt(program);
+      if (name === void 0) {
+        return isComputed(written) ? { written, program: "generator-or-other" } : void 0;
+      }
+      return { written, program: programs.get(name) ?? "generator-or-other" };
     },
     referenceAt: (word) => {
       const name = nameAt(word);
@@ -4179,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);
@@ -4527,72 +5070,30 @@ function oldPackagePatchSteps(fileName) {
   return name === void 0 || to === void 0 ? [] : [{ kind: "old-package-patch", name, to }];
 }
 
-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"],
-  ...["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 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 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(" ")
+    );
   }
-  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 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 {
+    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 });
     }
-    return void 0;
   };
 }
-function otherShellFindings(values, shellOf, locate) {
-  const manualSteps = values.flatMap((value) => {
-    const shell = shellOf(value);
-    return shell === void 0 || !namesOriginalPackage(value.value) ? [] : [{ kind: "script-not-shell", location: locate(value.start), shell }];
-  });
-  return { edits: [], changes: [], manualSteps };
-}
 
 const YAML_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "run",
@@ -4647,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(".");
@@ -4702,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)
+  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),
@@ -4879,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);
@@ -4927,6 +5439,28 @@ const JSON5_MANIFEST_FILE = "package.json5";
 const MANIFEST_FILE = "package.json";
 const PROJECT_CONFIG_NAME = /^[jt]sconfig(\.[^/]+)?\.json$/;
 const LOCK_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "yarn.lock", "bun.lock"]);
+const CI_CONFIG_FILES = /* @__PURE__ */ new Set([
+  ".gitlab-ci.yml",
+  ".gitlab-ci.yaml",
+  "bitbucket-pipelines.yml",
+  "azure-pipelines.yml",
+  ".drone.yml",
+  ".woodpecker.yml",
+  ".travis.yml"
+]);
+const CI_CONFIG_FOLDERS = [
+  ".github/workflows/",
+  ".gitea/workflows/",
+  ".forgejo/workflows/",
+  ".circleci/",
+  ".gitlab/",
+  ".woodpecker/"
+];
+const FOLDER_SEPARATOR = "/";
+function isCiConfigFile(path) {
+  const inFolder = (folder) => path.startsWith(folder) || path.includes(`${FOLDER_SEPARATOR}${folder}`);
+  return CI_CONFIG_FILES.has(baseName(path)) || CI_CONFIG_FOLDERS.some(inFolder);
+}
 function baseName(path) {
   return path.slice(path.lastIndexOf("/") + 1);
 }
@@ -5012,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)
         )
       ])
@@ -5027,7 +5561,10 @@ const COMMAND_CONFIG_KINDS = [
     )
   }
 ];
-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 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,
@@ -5139,7 +5676,7 @@ function fileMigrationFor(path, namedImportMaps = NO_NAMED_IMPORT_MAPS) {
 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;
+const isDescriptionFormat = (path) => (isYaml(path) || extensionOf(path) === JSON_EXTENSION) && !isCiConfigFile(path);
 async function textOf(path, files) {
   const read = await files.read(path);
   return read.kind === "read" ? read.text : void 0;
@@ -5275,6 +5812,16 @@ async function planProjectTarget(paths, dependencies, version) {
   };
 }
 
+function attemptMigration(migrate) {
+  try {
+    return { kind: "migrated", migration: migrate() };
+  } catch (error) {
+    if (error instanceof MigrationBugError) {
+      return { kind: "skipped", reason: { kind: "migration-bug", message: error.message } };
+    }
+    throw error;
+  }
+}
 async function planFile(path, dependencies, target) {
   const migrate = fileMigrationFor(path, target.importMaps);
   if (migrate === void 0) {
@@ -5290,7 +5837,11 @@ async function planFile(path, dependencies, target) {
     ...{ version, catalogs, manifests, aliases, apiDescriptionParts },
     ...{ rewriter, scanner, readers }
   };
-  const migration = migrate(read.text, path, context);
+  const attempt = attemptMigration(() => migrate(read.text, path, context));
+  if (attempt.kind === "skipped") {
+    return attempt;
+  }
+  const { migration } = attempt;
   const isChanged = migration.text !== read.text;
   const { changes, manualSteps } = migration;
   if (isChanged || manualSteps.length > 0) {
@@ -5418,7 +5969,7 @@ function commandStepMessage(step) {
     case "old-name-in-command":
       return `${step.location}: "${step.word}" ${OLD_NAME_IN_COMMAND_NOTE}`;
     case "script-not-shell":
-      return `${step.location}: the step runs with shell: ${step.shell}, ${SCRIPT_NOT_SHELL_NOTE}`;
+      return `${step.location}: the script runs with ${step.shell}, ${SCRIPT_NOT_SHELL_NOTE}`;
     case "command-string":
       return `line ${step.line}: ${COMMAND_STRING_NOTE} "${step.to}"`;
     default:
@@ -5434,9 +5985,12 @@ const KEEP_REASONS = {
   "shared-options": "its options object is used elsewhere too",
   "unknown-return": "a return value is not a plain ts.factory type",
   "typed-options": "its options are declared with a type built from OpenAPITSOptions, which the tool cannot change to OpenAPITSIrOptions",
-  "spread-options": "its options take keys from another object (`...base`), whose callbacks and type the tool cannot see"
+  "spread-options": "its options take keys from another object (`...base`), whose callbacks and type the tool cannot see",
+  "declared-type": "its declared type (a `const` type, JSDoc `@type` or `@returns`) names a type the tool cannot change to type text",
+  "in-spread": "it is in an object that the options take keys from (`...base`), and the tool rewrites only a transform written in the options"
 };
 const OPTIONS_NOTE = `the options of openapiTS() are not an object written in this file: check them for transform, postTransform and transformProperty. See ${IR_CALLBACKS_GUIDE}`;
+const SPREAD_NOTE = `the options of openapiTS() take keys from an object the tool cannot read (\`...base\`): check it for transform, postTransform and transformProperty. See ${IR_CALLBACKS_GUIDE}`;
 const DEEP_IMPORT_NOTE = "imports a file inside the package; check that it exists";
 const OLD_FILE_NOTE = "imports a file from node_modules of";
 const OLD_FILE_FIX_NOTE = "which is no longer installed: import from";
@@ -5452,6 +6006,7 @@ function packageNotDeclaredMessage(step) {
 }
 const SOURCE_STEP_KINDS = /* @__PURE__ */ new Set([
   "options-not-inspected",
+  "options-spread-not-inspected",
   "deep-import",
   "old-package-import",
   "dynamic-specifier",
@@ -5465,6 +6020,8 @@ function sourceStepMessage(step) {
   switch (step.kind) {
     case "options-not-inspected":
       return `line ${step.line}: ${OPTIONS_NOTE}`;
+    case "options-spread-not-inspected":
+      return `line ${step.line}: ${SPREAD_NOTE}`;
     case "deep-import":
       return `line ${step.line}: "${step.specifier}" ${DEEP_IMPORT_NOTE}`;
     case "old-package-import":
@@ -5619,7 +6176,7 @@ function changeMessage(change) {
       return assertNever(change);
   }
 }
-const SKIPPED_HEADING = "Skipped (not read, not written):";
+const SKIPPED_HEADING = "Skipped (not migrated, not written):";
 function skippedMessage(reason) {
   switch (reason.kind) {
     case "outside-root":
@@ -5628,6 +6185,8 @@ function skippedMessage(reason) {
       return "it is not UTF-8 text, so it was not changed; check it by hand";
     case "io-error":
       return `it could not be read (${reason.code})`;
+    case "migration-bug":
+      return `the tool could not migrate it (${reason.message}), a bug of the tool: it was not changed, so migrate it by hand, and please report the bug`;
     default:
       return assertNever(reason);
   }
@@ -5656,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);
@@ -5711,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),
@@ -5814,7 +6375,8 @@ async function migrateRoot(request, root, logger, dependencies) {
   const input = { version: dependencies.version, isWrite: request.isWrite };
   const migration = await migrateProject({ files, rewriter, scanner, readers, logger }, input);
   dependencies.writeStdout(renderReport(migration));
-  return migration.write.kind === "failed" ? EXIT_CODES.failure : EXIT_CODES.success;
+  const hasBug = migration.skipped.some((file) => file.reason.kind === "migration-bug");
+  return migration.write.kind === "failed" || hasBug ? EXIT_CODES.failure : EXIT_CODES.success;
 }
 async function runMigration(request, dependencies) {
   const log = openLog(request, dependencies);