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

package/dist/cli/main.mjs

@@ -560,6 +560,21 @@ async function inspectProjectRoot(root) {
   }
 }
 
+const BROKEN_PIPE = "EPIPE";
+function isBrokenPipe(error) {
+  return error.code === BROKEN_PIPE;
+}
+function createPipeSafeWriter(stream) {
+  stream.on("error", (error) => {
+    if (!isBrokenPipe(error)) {
+      throw error;
+    }
+  });
+  return (text) => {
+    stream.write(text);
+  };
+}
+
 function unchanged(text) {
   return { text, changes: [], manualSteps: [] };
 }
@@ -610,6 +625,7 @@ function applyTextEdits(text, edits) {
   return edited + text.slice(copiedUpTo);
 }
 
+const hasExportModifier = (declaration) => (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Export) !== 0;
 const GENERATOR_MODULES = /* @__PURE__ */ new Set([
   "openapi-typesafe",
   "openapi-typescript"
@@ -692,7 +708,13 @@ function createChecker(file) {
 }
 function symbolOf(checker, identifier) {
   const parent = identifier.parent;
-  return ts.isShorthandPropertyAssignment(parent) && parent.name === identifier ? checker.getShorthandAssignmentValueSymbol(parent) : checker.getSymbolAtLocation(identifier);
+  if (ts.isShorthandPropertyAssignment(parent) && parent.name === identifier) {
+    return checker.getShorthandAssignmentValueSymbol(parent);
+  }
+  if (ts.isExportSpecifier(parent)) {
+    return checker.getExportSpecifierLocalTargetSymbol(parent);
+  }
+  return checker.getSymbolAtLocation(identifier);
 }
 function isDeclaredName(identifier, declaration) {
   const declaredName = declaration.name;
@@ -778,7 +800,6 @@ function unwrapped(expression, types = []) {
   }
   return { value: expression, types };
 }
-const isExported$1 = (declaration) => (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Export) !== 0;
 function constantOptions(name, bindings, outerTypes) {
   const binding = bindings.bindingOf(name);
   const declaration = bindings.declarationOf(name);
@@ -786,7 +807,7 @@ function constantOptions(name, bindings, outerTypes) {
   if (found === void 0 || !ts.isObjectLiteralExpression(found.value)) {
     return { kind: "unknown", expression: name };
   }
-  const isOwn = bindings.usesOf(declaration).length === 1 && !isExported$1(declaration);
+  const isOwn = bindings.usesOf(declaration).length === 1 && !hasExportModifier(declaration);
   if (!isOwn) {
     return { kind: "shared", options: found.value };
   }
@@ -1086,7 +1107,7 @@ function callbackAnnotations(property, names) {
 function isSharedFunction(property, names) {
   const name = namedValue(property);
   const declaration = name === void 0 ? void 0 : names.bindings.declarationOf(name);
-  return declaration !== void 0 && names.bindings.usesOf(declaration).length > 1;
+  return declaration !== void 0 && (names.bindings.usesOf(declaration).length > 1 || hasExportModifier(declaration));
 }
 
 const KEYWORDS = /* @__PURE__ */ new Map([
@@ -1305,7 +1326,6 @@ function returnEdits(expression, names) {
   return typeTextEdit(expression, names);
 }
 
-const isExported = (node) => (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0;
 function isRemovable(node, binding, names) {
   switch (binding.kind) {
     case "typescript-module":
@@ -1313,7 +1333,7 @@ function isRemovable(node, binding, names) {
     case "helper-import":
       return true;
     case "constant":
-      return !isExported(node) && typeTextOf(binding.initializer, names) !== void 0;
+      return !hasExportModifier(node) && typeTextOf(binding.initializer, names) !== void 0;
     default:
       return false;
   }
@@ -1647,7 +1667,7 @@ function isModuleSpecifier(literal) {
   }
   return ts.isExternalModuleReference(parent);
 }
-function stringValue(node, file) {
+function stringValue$1(node, file) {
   return ts.isTemplateExpression(node) ? file.text.slice(node.getStart(file) + 1, node.getEnd() - 1) : node.text;
 }
 function collectStrings(root, file, offset, found) {
@@ -1658,7 +1678,7 @@ function collectStrings(root, file, offset, found) {
       found.set(start, {
         start,
         end,
-        value: stringValue(node, file),
+        value: stringValue$1(node, file),
         isModuleSpecifier: isModuleSpecifier(node)
       });
     }
@@ -1867,60 +1887,341 @@ function createYamlTextReader() {
   return { read };
 }
 
-const CATALOG_PROTOCOL = "catalog:";
-const DEFAULT_CATALOG = "default";
-function catalogOfSpec(spec) {
-  if (!spec.startsWith(CATALOG_PROTOCOL)) {
-    return void 0;
+const NONE = /* @__PURE__ */ new Set();
+const PACKAGE_OPTIONS = /* @__PURE__ */ new Set(["-p", "--package"]);
+const PACKAGE_MANAGER_OPTIONS = /* @__PURE__ */ new Set([
+  "--filter",
+  "-F",
+  "--dir",
+  "-C",
+  "--prefix",
+  "--cwd",
+  "--workspace"
+]);
+const launcher = (words, packageOptions = NONE, valueOptions = NONE) => {
+  const allValueOptions = /* @__PURE__ */ new Set([...valueOptions, ...packageOptions]);
+  return { words, packageOptions, valueOptions: allValueOptions, operands: 0 };
+};
+const CONTAINER_OPTIONS = /* @__PURE__ */ new Set([
+  "-e",
+  "--env",
+  "--env-file",
+  "-v",
+  "--volume",
+  "--mount",
+  "-p",
+  "--publish",
+  "-w",
+  "--workdir",
+  "-u",
+  "--user",
+  "--name",
+  "--network",
+  "--entrypoint",
+  "--platform",
+  "-l",
+  "--label",
+  "-h",
+  "--hostname",
+  "--add-host"
+]);
+const container = (words) => ({
+  ...launcher(words, NONE, CONTAINER_OPTIONS),
+  operands: 1
+});
+const withOperands = (words, operands, valueOptions = NONE) => ({ ...launcher(words, NONE, valueOptions), operands });
+const XARGS_OPTIONS = /* @__PURE__ */ new Set([
+  "-I",
+  "-J",
+  "-L",
+  "-n",
+  "-P",
+  "-R",
+  "-S",
+  "-s",
+  "-d",
+  "-E",
+  "-a",
+  "--max-args",
+  "--max-procs",
+  "--max-lines",
+  "--delimiter",
+  "--arg-file"
+]);
+const NODE_OPTIONS = /* @__PURE__ */ new Set([
+  "-r",
+  "--require",
+  "--import",
+  "--loader",
+  "--env-file"
+]);
+const LAUNCHERS = [
+  launcher(["npm", "exec"], PACKAGE_OPTIONS),
+  launcher(["npm", "x"], PACKAGE_OPTIONS),
+  launcher(["pnpm", "exec"], NONE, PACKAGE_MANAGER_OPTIONS),
+  launcher(["pnpm", "dlx"], /* @__PURE__ */ new Set(["--package"])),
+  launcher(["yarn", "dlx"], PACKAGE_OPTIONS),
+  launcher(["yarn", "exec"]),
+  launcher(["bun", "x"], PACKAGE_OPTIONS),
+  withOperands(["yarn", "workspace"], 1),
+  launcher(["dotenvx", "run"], NONE, /* @__PURE__ */ new Set(["-f", "--env-file", "-e", "--env", "--convention"])),
+  launcher(
+    ["doppler", "run"],
+    NONE,
+    /* @__PURE__ */ new Set(["-p", "--project", "-c", "--config", "--token", "--mount", "--scope"])
+  ),
+  launcher(["nx", "exec"], NONE, /* @__PURE__ */ new Set(["--projects", "-p", "--exclude"])),
+  launcher(["deno", "run"], NONE, /* @__PURE__ */ new Set(["--config", "-c", "--import-map", "--location"])),
+  launcher(["deno", "x"]),
+  launcher(["npx"], PACKAGE_OPTIONS, /* @__PURE__ */ new Set(["-c", "--call"])),
+  launcher(["pnpx"], PACKAGE_OPTIONS),
+  launcher(["bunx"], PACKAGE_OPTIONS),
+  // Like a bare `pnpm <name>`, a bare `bun <name>` runs the binary when no script has the name.
+  launcher(["bun"], NONE, /* @__PURE__ */ new Set(["--cwd", "--filter", "-F"])),
+  launcher(["corepack"]),
+  launcher(["pnpm"], NONE, PACKAGE_MANAGER_OPTIONS),
+  launcher(["yarn"], NONE, PACKAGE_MANAGER_OPTIONS),
+  launcher(["node"], NONE, NODE_OPTIONS),
+  launcher(["tsx"], NONE, NODE_OPTIONS),
+  launcher(["ts-node"], NONE, /* @__PURE__ */ new Set([...NODE_OPTIONS, "-P", "--project", "-O", "--compiler"])),
+  launcher(["cross-env"]),
+  launcher(["dotenv"], NONE, /* @__PURE__ */ new Set(["-e", "-c", "-v"])),
+  launcher(["env"], NONE, /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"])),
+  launcher(["exec"], NONE, /* @__PURE__ */ new Set(["-a"])),
+  launcher(["command"]),
+  launcher(["time"]),
+  launcher(["nice"], NONE, /* @__PURE__ */ new Set(["-n", "--adjustment"])),
+  withOperands(["timeout"], 1, /* @__PURE__ */ new Set(["-s", "--signal", "-k", "--kill-after"])),
+  launcher(["xargs"], NONE, XARGS_OPTIONS),
+  launcher(["nohup"]),
+  launcher(["sudo"], NONE, /* @__PURE__ */ new Set(["-u", "-g"])),
+  // The shell form of Dockerfile instructions runs the rest of the line in a shell.
+  launcher(["RUN"], NONE, /* @__PURE__ */ new Set(["--mount", "--network", "--security"])),
+  launcher(["CMD"]),
+  launcher(["ENTRYPOINT"]),
+  container(["docker", "run"]),
+  container(["docker", "exec"]),
+  container(["docker", "compose", "run"]),
+  container(["docker", "compose", "exec"]),
+  container(["podman", "run"]),
+  container(["podman", "exec"])
+];
+const installers = (manager, subcommands) => subcommands.map((subcommand) => ({ words: [manager, subcommand] }));
+const NPM_INSTALL = ["install", "i", "add", "update", "up", "uninstall", "remove", "rm", "un"];
+const INSTALLERS = [
+  ...installers("npm", NPM_INSTALL),
+  ...installers("pnpm", ["add", "update", "up", "remove", "rm", "uninstall", "un"]),
+  ...installers("yarn", ["add", "upgrade", "up", "remove"]),
+  // Yarn 1 installs global packages with `yarn global add`.
+  { words: ["yarn", "global", "add"] },
+  { words: ["yarn", "global", "remove"] },
+  ...installers("bun", ["add", "a", "update", "remove", "rm", "install", "i"]),
+  ...installers("deno", ["add", "install", "i", "remove", "uninstall"])
+];
+const NPM_SPECIFIER_PREFIX = "npm:";
+
+const COMMAND_SEPARATORS = /* @__PURE__ */ new Set([
+  ";",
+  "&",
+  "|",
+  "(",
+  ")",
+  "`",
+  "\n"
+]);
+const WORD_BREAKS = /* @__PURE__ */ new Set([" ", "	", "\r", "<", ">"]);
+const BACKSLASH$1 = "\\";
+const DOUBLE_QUOTE_ESCAPES = /* @__PURE__ */ new Set(["$", "`", '"', BACKSLASH$1, "\n"]);
+function singleQuoted(text, start) {
+  const close = text.indexOf("'", start + 1);
+  const end = close === -1 ? text.length : close + 1;
+  return { end, value: text.slice(start + 1, close === -1 ? text.length : close) };
+}
+function doubleQuoted(text, start) {
+  let value = "";
+  let index = start + 1;
+  while (index < text.length && text[index] !== '"') {
+    const next = text[index + 1] ?? "";
+    const isEscape = text[index] === BACKSLASH$1 && DOUBLE_QUOTE_ESCAPES.has(next);
+    value += isEscape ? next === "\n" ? "" : next : text[index];
+    index += isEscape ? 2 : 1;
   }
-  return spec.slice(CATALOG_PROTOCOL.length).trim() || DEFAULT_CATALOG;
+  return { end: Math.min(index + 1, text.length), value };
 }
-class CatalogEntries {
-  #keys = /* @__PURE__ */ new Set();
-  add(catalog, name) {
-    this.#keys.add(JSON.stringify([catalog, name]));
+const isLineContinuation = (text, index) => text[index] === BACKSLASH$1 && (text[index + 1] === "\n" || text.startsWith("\r\n", index + 1));
+const ARITHMETIC_OPEN = "$((";
+const NESTING_OPEN = "(";
+const NESTING_CLOSE = ")";
+const ARITHMETIC_DEPTH = 2;
+function arithmeticExpansion(text, start) {
+  let depth = ARITHMETIC_DEPTH;
+  for (let index = start + ARITHMETIC_OPEN.length; index < text.length; index++) {
+    depth += text[index] === NESTING_OPEN ? 1 : text[index] === NESTING_CLOSE ? -1 : 0;
+    if (depth === 0) {
+      return { end: index + 1, value: text.slice(start, index + 1) };
+    }
   }
-  has(catalog, name) {
-    return this.#keys.has(JSON.stringify([catalog, name]));
+  return void 0;
+}
+function wordPart(text, index) {
+  const char = text[index];
+  const arithmetic = text.startsWith(ARITHMETIC_OPEN, index) ? arithmeticExpansion(text, index) : void 0;
+  if (arithmetic !== void 0) {
+    return arithmetic;
+  }
+  if (char === "'") {
+    return singleQuoted(text, index);
+  }
+  if (char === '"') {
+    return doubleQuoted(text, index);
+  }
+  if (char === BACKSLASH$1 && index + 1 < text.length) {
+    return { end: index + 2, value: text[index + 1] };
   }
+  return { end: index + 1, value: char };
 }
-const NO_CATALOG_PLAN = {
-  inUse: new CatalogEntries(),
-  kept: new CatalogEntries(),
-  defined: new CatalogEntries(),
-  isWorkspaceRoot: false
+const endsWord = (text, index) => {
+  const char = text[index];
+  return WORD_BREAKS.has(char) || COMMAND_SEPARATORS.has(char) || isLineContinuation(text, index);
 };
+function readWord(text, start) {
+  let value = "";
+  let index = start;
+  while (index < text.length && !endsWord(text, index)) {
+    const part = wordPart(text, index);
+    value += part.value;
+    index = part.end;
+  }
+  return { start, end: index, value, raw: text.slice(start, index) };
+}
 
-const PACKAGE_RENAMES = /* @__PURE__ */ new Map([
-  ["openapi-typescript", "openapi-typesafe"],
-  ["openapi-fetch", "openapi-typesafe-fetch"],
-  ["openapi-react-query", "openapi-typesafe-react-query"],
-  ["openapi-typescript-helpers", "openapi-typesafe-helpers"]
+const ASSIGNMENT_RE$2 = /^([A-Za-z_][A-Za-z0-9_]*)=/;
+const DECLARATION_BUILTINS = /* @__PURE__ */ new Set([
+  "export",
+  "readonly",
+  "local",
+  "declare",
+  "typeset"
 ]);
-function namesOriginalPackage(text) {
-  return [...PACKAGE_RENAMES.keys()].some((name) => text.includes(name));
+const QUOTES$3 = /* @__PURE__ */ new Set(["'", '"']);
+const UNPLAIN_RE = /['"\\$`]/;
+function leadingAssignments(command) {
+  const index = command.findIndex((word) => !ASSIGNMENT_RE$2.test(word.raw));
+  return index === -1 ? command.length : index;
+}
+function shellAssignments(command) {
+  const count = leadingAssignments(command);
+  const isDeclaration = DECLARATION_BUILTINS.has(command[count]?.value ?? "");
+  const words = [...command.slice(0, count), ...isDeclaration ? command.slice(count + 1) : []];
+  return words.flatMap((word) => {
+    const match = ASSIGNMENT_RE$2.exec(word.raw);
+    const name = match?.[1];
+    return name === void 0 ? [] : [{ name, value: word.value.slice(name.length + 1), word }];
+  });
 }
-const GENERATOR_COMMAND = "openapi-typescript";
-const MIGRATED_GENERATOR_COMMAND = "openapi-typesafe";
-const FLAG_RENAMES = /* @__PURE__ */ new Map([
-  ["--immutable-types", "--immutable"],
-  ["-it", "--immutable"],
-  ["--support-array-length", "--array-length"],
-  ["--redoc", "--redocly"],
-  ["-ap", "--additional-properties"]
-]);
-const DEPENDENCY_FIELDS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies"
-];
-const NAME_KEYED_FIELDS = ["peerDependenciesMeta", "dependenciesMeta"];
-const NAME_LIST_FIELDS = ["bundleDependencies", "bundledDependencies"];
-const CATALOG_FIELD = "catalog";
-const NAMED_CATALOGS_FIELD = "catalogs";
-const WORKSPACES_FIELD = "workspaces";
-const OVERRIDE_FIELDS = ["overrides", "resolutions"];
+function assignmentValueText(assignment) {
+  const at = assignment.name.length + 1;
+  const raw = assignment.word.raw.slice(at);
+  const start = assignment.word.start + at;
+  const quote = raw[0] ?? "";
+  if (QUOTES$3.has(quote)) {
+    const isOneString = raw.length > 1 && raw.endsWith(quote) && wordPart(raw, 0).end === raw.length;
+    return isOneString ? { text: raw.slice(1, -1), start: start + 1 } : void 0;
+  }
+  return UNPLAIN_RE.test(raw) ? void 0 : { text: raw, start };
+}
+
+const END_OF_OPTIONS = "--";
+const isOption$1 = (word) => word.value.startsWith("-") && word.value.length > 1;
+function skipAssignments(words, start) {
+  let index = start;
+  while (index < words.length && ASSIGNMENT_RE$2.test(words[index].raw)) {
+    index++;
+  }
+  return index;
+}
+function matchingPrefix(entries, words, index) {
+  return entries.find(
+    (entry) => entry.words.every((name, offset) => words[index + offset]?.value === name)
+  );
+}
+function inlineOptionPackage(word, launcher) {
+  const equals = word.value.indexOf("=");
+  const name = word.value.slice(0, equals);
+  return launcher.packageOptions.has(name) ? { word, value: word.value.slice(equals + 1) } : void 0;
+}
+function launchedProgram(words, start, launcher, packages) {
+  let index = start;
+  while (index < words.length && isOption$1(words[index])) {
+    const option = words[index++];
+    if (option.value === END_OF_OPTIONS) {
+      break;
+    }
+    const inline = option.value.includes("=") ? inlineOptionPackage(option, launcher) : void 0;
+    if (inline !== void 0) {
+      packages.push(inline);
+    }
+    const value = words[index];
+    if (!option.value.includes("=") && launcher.valueOptions.has(option.value) && value) {
+      if (launcher.packageOptions.has(option.value)) {
+        packages.push({ word: value, value: value.value });
+      }
+      index++;
+    }
+  }
+  return index;
+}
+const installArguments = (words, start) => words.slice(start).filter((word) => !isOption$1(word)).map((word) => ({ word, value: word.value }));
+function commandRoles(words) {
+  const packages = [];
+  let index = skipAssignments(words, 0);
+  while (index < words.length) {
+    const installer = matchingPrefix(INSTALLERS, words, index);
+    if (installer !== void 0) {
+      packages.push(...installArguments(words, index + installer.words.length));
+      return { program: void 0, packages };
+    }
+    const launcher = matchingPrefix(LAUNCHERS, words, index);
+    if (launcher === void 0) {
+      return { program: index, packages };
+    }
+    const start = index + launcher.words.length;
+    const afterOptions = launchedProgram(words, start, launcher, packages);
+    index = skipAssignments(words, afterOptions + launcher.operands);
+  }
+  return { program: void 0, packages };
+}
+
+const PACKAGE_RENAMES = /* @__PURE__ */ new Map([
+  ["openapi-typescript", "openapi-typesafe"],
+  ["openapi-fetch", "openapi-typesafe-fetch"],
+  ["openapi-react-query", "openapi-typesafe-react-query"],
+  ["openapi-typescript-helpers", "openapi-typesafe-helpers"]
+]);
+function namesOriginalPackage(text) {
+  return [...PACKAGE_RENAMES.keys()].some((name) => text.includes(name));
+}
+const GENERATOR_COMMAND = "openapi-typescript";
+const MIGRATED_GENERATOR_COMMAND = "openapi-typesafe";
+const FLAG_RENAMES = /* @__PURE__ */ new Map([
+  ["--immutable-types", "--immutable"],
+  ["-it", "--immutable"],
+  ["--support-array-length", "--array-length"],
+  ["--redoc", "--redocly"],
+  ["-ap", "--additional-properties"]
+]);
+const DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+const NAME_KEYED_FIELDS = ["peerDependenciesMeta", "dependenciesMeta"];
+const NAME_LIST_FIELDS = ["bundleDependencies", "bundledDependencies"];
+const CATALOG_FIELD = "catalog";
+const NAMED_CATALOGS_FIELD = "catalogs";
+const WORKSPACES_FIELD = "workspaces";
+const OVERRIDE_FIELDS = ["overrides", "resolutions"];
 const PNPM_SETTINGS_FIELD = "pnpm";
 const OLD_PEER_DEPENDENTS = /* @__PURE__ */ new Map([
   ["swr-openapi", { peer: "openapi-fetch", range: ">=0.15" }]
@@ -1947,1443 +2248,1133 @@ function oldPackageInNodeModules(path) {
   );
 }
 
-const isMap = (node) => node?.kind === "map";
-const isScalar = (node) => node.kind === "scalar";
-function textEntries(map) {
-  return map.entries.flatMap(({ key, value }) => isScalar(key) ? [{ key, value }] : []);
+function packageReference(value) {
+  const bare = value.startsWith(NPM_SPECIFIER_PREFIX) ? value.slice(NPM_SPECIFIER_PREFIX.length) : value;
+  const at = bare.indexOf("@", 1);
+  return { name: at === -1 ? bare : bare.slice(0, at), isPinned: at !== -1 };
 }
-function valuesAt(map, key) {
-  return textEntries(map).filter((entry) => entry.key.value === key).map((entry) => entry.value);
+function namesOldPackage(value) {
+  return PACKAGE_RENAMES.has(packageReference(value).name) || oldPackageInNodeModules(value) !== void 0 || value.endsWith(`/${GENERATOR_COMMAND}`);
 }
-function mapsAt(map, key) {
-  return valuesAt(map, key).filter(isMap);
+function unmigratedWordFindings(words, handledOffsets, locate) {
+  return words.filter((word) => !handledOffsets.has(word.start) && namesOldPackage(word.value)).map((word) => ({
+    offset: word.start,
+    manualStep: { kind: "old-name-in-command", location: locate(word.start), word: word.value }
+  }));
 }
-function stringsBelow(node, path) {
-  switch (node.kind) {
-    case "scalar":
-      return [{ ...node, path }];
-    case "list":
-      return node.items.flatMap((item, index) => stringsBelow(item, [...path, index]));
-    case "map":
-      return textEntries(node).flatMap(
-        ({ key, value }) => stringsBelow(value, [...path, key.value])
-      );
-    default:
-      return [];
+
+const RECIPE_PREFIX_RE$1 = /^[@+-]+(?=.)/;
+function withoutRecipePrefix(words) {
+  const [first, ...rest] = words;
+  if (first === void 0 || !RECIPE_PREFIX_RE$1.test(first.value)) {
+    return words;
   }
+  return [{ ...first, value: first.value.replace(RECIPE_PREFIX_RE$1, "") }, ...rest];
 }
-function documentStrings(documents) {
-  return documents.flatMap((document) => stringsBelow(document, []));
-}
-function ownerKey(path) {
-  return path.findLast((part) => typeof part === "string");
-}
-function unreadableConfig(text, offset) {
-  if (!namesOriginalPackage(text)) {
-    return unchanged(text);
-  }
-  const position = offset === void 0 ? void 0 : { line: lineAt(text, offset), column: columnAt(text, offset) };
-  return { ...unchanged(text), manualSteps: [{ kind: "config-unreadable", position }] };
+const NO_VARIABLES = {
+  programAt: () => void 0,
+  referenceAt: () => void 0
+};
+function runsGenerator(command) {
+  const words = withoutRecipePrefix(command);
+  const { program } = commandRoles(words);
+  const word = program === void 0 ? void 0 : words[program];
+  return word !== void 0 && packageReference(word.value).name === GENERATOR_COMMAND;
 }
 
-const PARENT_SEPARATOR = ">";
-const PATH_SEPARATOR$8 = "/";
-const SCOPE_PREFIX$2 = "@";
-function overrideTarget(key) {
-  const child = key.split(PARENT_SEPARATOR).at(-1) ?? key;
-  const segments = child.split(PATH_SEPARATOR$8);
-  const isScoped = segments.length > 1 && segments.at(-2)?.startsWith(SCOPE_PREFIX$2) === true;
-  const name = isScoped ? segments.slice(-2).join(PATH_SEPARATOR$8) : segments.at(-1) ?? child;
-  const versionAt = name.indexOf(SCOPE_PREFIX$2, 1);
-  return versionAt === -1 ? name : name.slice(0, versionAt);
+const HEREDOC_OPERATOR = "<<";
+const HERE_STRING_OPERATOR = "<<<";
+const STRIP_TABS = "-";
+const LINE_BREAK$2 = "\n";
+const LEADING_TABS_RE = /^\t+/;
+const CARRIAGE_RETURN_RE = /\r$/;
+function heredocAt(text, index, where) {
+  if (text.startsWith(HERE_STRING_OPERATOR, index)) {
+    return { end: index + HERE_STRING_OPERATOR.length };
+  }
+  if (!text.startsWith(HEREDOC_OPERATOR, index)) {
+    return void 0;
+  }
+  let start = index + HEREDOC_OPERATOR.length;
+  const isTabStripped = text[start] === STRIP_TABS;
+  start += isTabStripped ? 1 : 0;
+  while (text[start] === " " || text[start] === "	") {
+    start++;
+  }
+  const word = readWord(text, start);
+  const pending = { delimiter: word.value, isTabStripped, ...where };
+  return word.value === "" ? void 0 : { pending, end: word.end };
 }
-function overriddenPackages(keys) {
-  const targets = keys.map(overrideTarget);
-  return [...new Set(targets.filter((target) => PACKAGE_RENAMES.has(target)))];
+function isDelimiterLine(text, lineStart, end, heredoc) {
+  let first = lineStart;
+  while (first < lineStart + heredoc.indent && text[first] === " ") {
+    first++;
+  }
+  const line = text.slice(first, end).replace(CARRIAGE_RETURN_RE, "");
+  const compared = heredoc.isTabStripped ? line.replace(LEADING_TABS_RE, "") : line;
+  return compared === heredoc.delimiter;
 }
-
-const isEditable = (node) => node.kind === "scalar" && node.encode !== void 0;
-const replaceScalar = (scalar, value) => ({
-  start: scalar.start,
-  end: scalar.end,
-  text: scalar.encode(value)
-});
-function specEntries(map) {
-  return textEntries(map).flatMap(({ key, value }) => {
-    if (!isEditable(key)) {
-      return [];
+function readBody(text, start, heredoc) {
+  let lineStart = start;
+  while (lineStart < text.length) {
+    const lineEnd = text.indexOf(LINE_BREAK$2, lineStart);
+    const end = lineEnd === -1 ? text.length : lineEnd;
+    if (isDelimiterLine(text, lineStart, end, heredoc)) {
+      const body = { command: heredoc.command, start, text: text.slice(start, lineStart) };
+      return { body, end: Math.min(end + 1, text.length) };
     }
-    const spec = isEditable(value) ? { value: value.value, replace: (to) => replaceScalar(value, to) } : void 0;
-    return [{ name: key.value, spec, renameKey: (name) => replaceScalar(key, name) }];
-  });
-}
-function keyEntries(map) {
-  return textEntries(map).map(({ key }) => key).filter(isEditable).map((key) => ({ name: key.value, rename: (name) => replaceScalar(key, name) }));
-}
-function itemEntries(list) {
-  return list.items.filter(isEditable).map((item) => ({ name: item.value, rename: (name) => replaceScalar(item, name) }));
+    lineStart = end + 1;
+  }
+  return { body: { command: heredoc.command, start, text: text.slice(start) }, end: text.length };
 }
-function nestedKeys(node) {
-  if (node.kind !== "map") {
-    return [];
+function readBodies(text, start, pending) {
+  const bodies = [];
+  let end = start;
+  for (const heredoc of pending) {
+    const read = readBody(text, end, heredoc);
+    bodies.push(read.body);
+    end = read.end;
   }
-  return textEntries(node).flatMap(({ key, value }) => [key.value, ...nestedKeys(value)]);
+  return { bodies, end };
 }
 
-const PATH_SEPARATOR$7 = ".";
-function catalogMaps(root, prefix = "") {
-  const maps = mapsAt(root, CATALOG_FIELD).map((map) => ({
-    name: DEFAULT_CATALOG,
-    label: `${prefix}${CATALOG_FIELD}`,
-    map
-  }));
-  for (const catalogs of mapsAt(root, NAMED_CATALOGS_FIELD)) {
-    for (const { key, value } of textEntries(catalogs)) {
-      if (isMap(value)) {
-        const label = [prefix + NAMED_CATALOGS_FIELD, key.value].join(PATH_SEPARATOR$7);
-        maps.push({ name: key.value, label, map: value });
-      }
-    }
+const COMMENT = "#";
+const LINE_BREAK$1 = "\n";
+function skipTrivia(text, index) {
+  const char = text[index];
+  if (WORD_BREAKS.has(char)) {
+    return index + 1;
   }
-  return maps;
-}
-const manifestCatalogMaps = (manifest) => [
-  ...catalogMaps(manifest),
-  ...mapsAt(manifest, WORKSPACES_FIELD).flatMap(
-    (workspaces) => catalogMaps(workspaces, `${WORKSPACES_FIELD}${PATH_SEPARATOR$7}`)
-  )
-];
-function entriesInUse(manifests) {
-  const inUse = new CatalogEntries();
-  const fields = manifests.flatMap(
-    (manifest) => DEPENDENCY_FIELDS.flatMap((field) => mapsAt(manifest, field))
-  );
-  for (const dependencies of fields) {
-    const entries = specEntries(dependencies);
-    const names = new Set(entries.map((entry) => entry.name));
-    for (const { name, spec } of entries) {
-      const catalog = spec === void 0 ? void 0 : catalogOfSpec(spec.value);
-      const to = PACKAGE_RENAMES.get(name);
-      if (catalog !== void 0 && to !== void 0 && names.has(to)) {
-        inUse.add(catalog, name);
+  if (isLineContinuation(text, index)) {
+    return text.indexOf("\n", index) + 1;
+  }
+  if (char === COMMENT) {
+    const lineEnd = text.indexOf("\n", index);
+    return lineEnd === -1 ? text.length : lineEnd;
+  }
+  return index;
+}
+const PIPE = "|";
+function topLevelCommands(text, indent) {
+  const commands = [[]];
+  const heredocs = [];
+  const pipes = /* @__PURE__ */ new Set();
+  let pending = [];
+  let index = 0;
+  while (index < text.length) {
+    const afterTrivia = skipTrivia(text, index);
+    const heredoc = heredocAt(text, index, { command: commands.length - 1, indent });
+    if (heredoc !== void 0) {
+      pending.push(...heredoc.pending === void 0 ? [] : [heredoc.pending]);
+      index = heredoc.end;
+    } else if (afterTrivia !== index) {
+      index = afterTrivia;
+    } else if (text[index] === LINE_BREAK$1 && pending.length > 0) {
+      const read = readBodies(text, index + 1, pending);
+      heredocs.push(...read.bodies);
+      pending = [];
+      commands.push([]);
+      index = read.end;
+    } else if (COMMAND_SEPARATORS.has(text[index])) {
+      if (text[index] === PIPE) {
+        pipes.add(commands.length - 1);
       }
+      commands.push([]);
+      index++;
+    } else {
+      const word = readWord(text, index);
+      commands.at(-1)?.push(word);
+      index = word.end;
     }
   }
-  return inUse;
+  return { commands, heredocs, pipes };
 }
-function nestedTexts(node) {
-  if (node.kind !== "map") {
-    return [];
+const COMMAND_PREFIX_WORDS = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "elif",
+  "else",
+  "fi",
+  "while",
+  "until",
+  "do",
+  "done",
+  "!",
+  "{",
+  "}",
+  "esac"
+]);
+const CLAUSE_WORDS = /* @__PURE__ */ new Set(["for", "select", "case", "[["]);
+const FUNCTION_WORD = "function";
+const FUNCTION_HEADER_LENGTH = 2;
+const isReserved = (word, words) => word !== void 0 && word.raw === word.value && words.has(word.value);
+function prefixLength(words, index) {
+  if (isReserved(words[index], COMMAND_PREFIX_WORDS)) {
+    return 1;
   }
-  return textEntries(node).flatMap(
-    ({ key, value }) => value.kind === "scalar" ? [{ key: key.value, value: value.value }] : nestedTexts(value)
-  );
+  const word = words[index];
+  return word?.raw === FUNCTION_WORD ? FUNCTION_HEADER_LENGTH : 0;
 }
-function addOverrideUses(documents, inUse) {
-  const sections = documents.flatMap(
-    (document) => [...OVERRIDE_FIELDS, PNPM_SETTINGS_FIELD].flatMap((field) => valuesAt(document, field))
-  );
-  for (const { key, value } of sections.flatMap(nestedTexts)) {
-    const catalog = catalogOfSpec(value);
-    const name = overrideTarget(key);
-    if (catalog !== void 0 && PACKAGE_RENAMES.has(name)) {
-      inUse.add(catalog, name);
-    }
+function simpleCommand(words) {
+  let first = 0;
+  for (let length = prefixLength(words, 0); length > 0; length = prefixLength(words, first)) {
+    first += length;
   }
+  return isReserved(words[first], CLAUSE_WORDS) ? [] : words.slice(first);
 }
-function planCatalogs({
-  manifests,
-  catalogFiles,
-  isWorkspaceRoot
-}) {
-  const inUse = entriesInUse(manifests);
-  addOverrideUses([...manifests, ...catalogFiles], inUse);
-  const kept = new CatalogEntries();
-  const defined = new CatalogEntries();
-  const catalogs = [
-    ...catalogFiles.flatMap((file) => catalogMaps(file)),
-    ...manifests.flatMap(manifestCatalogMaps)
-  ];
-  for (const { name: catalog, map } of catalogs) {
-    const entries = specEntries(map);
-    const names = new Set(entries.map((entry) => entry.name));
-    for (const { name, spec } of entries) {
-      defined.add(catalog, name);
-      const to = PACKAGE_RENAMES.get(name);
-      const stays = spec === void 0 || inUse.has(catalog, name);
-      if (to !== void 0 && !names.has(to) && stays) {
-        kept.add(catalog, name);
-      }
-    }
+const QUOTES$2 = /* @__PURE__ */ new Set(["'", '"']);
+const NESTED_COMMAND_RE = /[\s;&|()`]/;
+function nestedCommandText(word) {
+  const quote = word.raw[0];
+  const isOneQuotedString = QUOTES$2.has(quote) && word.raw.length > 1 && word.raw.endsWith(quote) && wordPart(word.raw, 0).end === word.raw.length;
+  return isOneQuotedString && NESTED_COMMAND_RE.test(word.value) ? word.raw.slice(1, -1) : void 0;
+}
+const SHELLS$1 = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh", "ksh"]);
+const DOCKER_RUN = "RUN";
+const PASS_THROUGH = "cat";
+const PATH_SEPARATOR$8 = "/";
+const OPTION_PREFIX$1 = "-";
+const programName = (command) => command[0]?.value.split(PATH_SEPARATOR$8).at(-1) ?? "";
+const isOption = (word) => word.value.startsWith(OPTION_PREFIX$1);
+const isScriptShell = (command) => SHELLS$1.has(programName(command)) && command.slice(1).every(isOption);
+function readsScript(command) {
+  if (programName(command) !== DOCKER_RUN) {
+    return isScriptShell(command);
   }
-  return { inUse, kept, defined, isWorkspaceRoot };
+  const after = command.slice(1);
+  const shell = after.slice(after.findIndex((word) => !isOption(word)));
+  return after.every(isOption) || isScriptShell(shell);
 }
-
-const NO_LONGER_INSTALLED = /* @__PURE__ */ new Map([
-  ["openapi-typesafe-helpers", ["openapi-fetch", "openapi-react-query"]]
-]);
-const ORIGINAL_NAMES = new Map(
-  [...PACKAGE_RENAMES].map(([original, successor]) => [successor, original])
-);
-const PATH_SEPARATOR$6 = "/";
-function namesUninstalledPackage(text) {
-  return [...NO_LONGER_INSTALLED.keys()].some(
-    (name) => text.includes(name) || text.includes(ORIGINAL_NAMES.get(name) ?? name)
+const passesThrough = (command) => programName(command) === PASS_THROUGH && command.slice(1).every(isOption);
+function scriptsRunBy(top, index, command) {
+  const previous = index - 1;
+  const isPipedScript = top.pipes.has(previous) && isScriptShell(command) && passesThrough(simpleCommand(top.commands[previous] ?? []));
+  return top.heredocs.filter(
+    (body) => body.command === index && readsScript(command) || body.command === previous && isPipedScript
   );
 }
-const directoryOf = (path) => path.slice(0, path.lastIndexOf(PATH_SEPARATOR$6) + 1);
-function declaredNames(manifest) {
-  return DEPENDENCY_FIELDS.flatMap((field) => mapsAt(manifest, field)).flatMap(textEntries).map(({ key }) => key.value);
-}
-function isDeclaredFor(manifests, filePath, name) {
-  const original = ORIGINAL_NAMES.get(name);
-  const containing = manifests.filter(({ path }) => filePath.startsWith(directoryOf(path)));
-  const declares = ({ names }) => names === void 0 || names.has(name) || original !== void 0 && names.has(original);
-  return containing.length === 0 || containing.some(declares);
+const shifted = (words, offset) => words.map((word) => ({ ...word, start: word.start + offset, end: word.end + offset }));
+function shellCommandsAt(text, offset, indent = 0) {
+  return shellCommands(text, indent).map((words) => shifted(words, offset));
 }
-const packageOfSpecifier = (specifier) => {
-  const slash = specifier.indexOf(PATH_SEPARATOR$6);
-  return slash === -1 ? specifier : specifier.slice(0, slash);
-};
-function undeclaredImportSteps(imports, filePath, manifests) {
-  return imports.flatMap(({ specifier, line }) => {
-    const name = packageOfSpecifier(specifier);
-    const installers = NO_LONGER_INSTALLED.get(name);
-    return installers === void 0 || isDeclaredFor(manifests, filePath, name) ? [] : [{ kind: "package-not-declared", line, name, installers }];
+function innerCommands(command) {
+  const quoted = command.flatMap((word) => {
+    const inner = nestedCommandText(word);
+    return inner === void 0 ? [] : shellCommandsAt(inner, word.start + 1);
   });
+  const assigned = shellAssignments(command).flatMap((assignment) => {
+    const value = assignmentValueText(assignment);
+    return value === void 0 ? [] : shellCommandsAt(value.text, value.start);
+  });
+  return [...quoted, ...assigned];
+}
+function shellCommands(text, indent = 0) {
+  const top = topLevelCommands(text, indent);
+  const commands = [];
+  for (const [index, words] of top.commands.entries()) {
+    const command = simpleCommand(words);
+    if (command.length > 0) {
+      commands.push(command);
+    }
+    commands.push(...innerCommands(command));
+    const scripts = scriptsRunBy(top, index, command);
+    commands.push(...scripts.flatMap((body) => shellCommandsAt(body.text, body.start, indent)));
+  }
+  return commands;
 }
 
 function assertNever(value) {
   throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
 }
 
-const KEPT_PROTOCOLS = ["catalog:", "workspace:"];
-const RANGE_SEPARATOR = "||";
-const HYPHEN = "-";
-const WHITE_SPACE_RE = /\s+/;
-const SPACED_OPERATOR_RE = /(<=|>=|<|>|=|~>|~|\^)\s+/g;
-const OPERATOR = String.raw`(<=|>=|<|>|=|~>|~|\^)?`;
-const VERSION_PART = String.raw`(\d+|[xX*])`;
-const LABELS = String.raw`(?:-[\w.-]+)?(?:\+[\w.-]+)?`;
-const COMPARATOR_RE = new RegExp(
-  String.raw`^${OPERATOR}v?${VERSION_PART}(?:\.${VERSION_PART})?(?:\.${VERSION_PART})?${LABELS}$`
-);
-const NUMBER_RE = /^\d+$/;
-const OPERATOR_STYLES = {
-  "^": "^",
-  // `>=` means "this or newer"; with a new package line, a caret range says the same safely.
-  ">=": "^",
-  ">": "^",
-  "~": "~",
-  "~>": "~"
-};
-const isNumber = (part) => part !== void 0 && NUMBER_RE.test(part);
-function versionStyle(major, minor, patch) {
-  if (!isNumber(major)) {
-    return void 0;
-  }
-  if (isNumber(minor) && isNumber(patch)) {
-    return "";
+function canRunGenerator(definition, generators) {
+  switch (definition.kind) {
+    case "command":
+      return definition.runsGenerator;
+    case "reference":
+      return generators.has(definition.target);
+    case "append":
+      return false;
+    default:
+      return assertNever(definition);
   }
-  return isNumber(minor) ? "~" : "^";
 }
-function rangeStyle(spec) {
-  const sets = spec.replace(SPACED_OPERATOR_RE, "$1").split(RANGE_SEPARATOR);
-  const tokens = sets.map((set) => set.trim().split(WHITE_SPACE_RE));
-  const comparators = tokens.flat().filter((token) => token !== HYPHEN);
-  const matches = comparators.map((comparator) => COMPARATOR_RE.exec(comparator));
-  const first = matches[0];
-  if (first === void 0 || first === null || matches.includes(null)) {
-    return void 0;
+function canRunOther(definition, others, defined) {
+  switch (definition.kind) {
+    case "command":
+      return !definition.runsGenerator;
+    case "reference":
+      return others.has(definition.target) || !defined.has(definition.target);
+    case "append":
+      return false;
+    default:
+      return assertNever(definition);
   }
-  const operator = first[1];
-  const isHyphenRange = tokens[0]?.[1] === HYPHEN;
-  if (operator !== void 0 && operator !== "=") {
-    return OPERATOR_STYLES[operator];
-  }
-  return isHyphenRange ? "^" : versionStyle(first[2], first[3], first[4]);
 }
-function migrateVersionSpec(spec, version) {
-  if (KEPT_PROTOCOLS.some((protocol) => spec.startsWith(protocol))) {
-    return { kind: "kept", spec, isReported: false };
-  }
-  const style = rangeStyle(spec);
-  if (style === void 0) {
-    return { kind: "kept", spec, isReported: true };
+function variablePrograms(definitions) {
+  const defined = new Set(definitions.map((definition) => definition.name));
+  const generators = /* @__PURE__ */ new Set();
+  const others = /* @__PURE__ */ new Set();
+  for (let size = -1; size !== generators.size + others.size; ) {
+    size = generators.size + others.size;
+    for (const definition of definitions) {
+      if (canRunGenerator(definition, generators)) {
+        generators.add(definition.name);
+      }
+      if (canRunOther(definition, others, defined)) {
+        others.add(definition.name);
+      }
+    }
   }
-  return { kind: "replaced", spec: `${style}${version}` };
+  const programOf = (name) => {
+    if (!generators.has(name)) {
+      return "other";
+    }
+    return others.has(name) ? "generator-or-other" : "generator";
+  };
+  return new Map([...defined].map((name) => [name, programOf(name)]));
 }
 
-const NPM_PROTOCOL = "npm:";
-const SCOPE_PREFIX$1 = "@";
-const PATH_SEPARATOR$5 = "/";
-const VERSION_SEPARATOR = "@";
-function nameEnd(text) {
-  const searchFrom = text.startsWith(SCOPE_PREFIX$1) ? text.indexOf(PATH_SEPARATOR$5) + 1 : 0;
-  const ends = [VERSION_SEPARATOR, PATH_SEPARATOR$5].map((separator) => text.indexOf(separator, Math.max(searchFrom, 1))).filter((index) => index !== -1);
-  return ends.length === 0 ? text.length : Math.min(...ends);
+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);
+  return match === null ? void 0 : match[1] ?? match[2];
 }
-function parseNpmSpec(spec) {
-  if (!spec.startsWith(NPM_PROTOCOL)) {
-    return void 0;
-  }
-  const body = spec.slice(NPM_PROTOCOL.length);
-  const lead = body.startsWith(PATH_SEPARATOR$5) ? PATH_SEPARATOR$5 : "";
-  const text = body.slice(lead.length);
-  const end = nameEnd(text);
-  const name = text.slice(0, end);
-  if (!text.startsWith(VERSION_SEPARATOR, end)) {
-    return { lead, name, range: void 0, rest: text.slice(end) };
+function programDefinition$1({ name, value }) {
+  const target = expandedName(value.trim());
+  if (target !== void 0) {
+    return { name, kind: "reference", target };
   }
-  const rangeEnd = text.indexOf(PATH_SEPARATOR$5, end);
-  const restStart = rangeEnd === -1 ? text.length : rangeEnd;
-  return { lead, name, range: text.slice(end + 1, restStart), rest: text.slice(restStart) };
-}
-function isOldPackageNpmSpec(spec) {
-  const parsed = parseNpmSpec(spec);
-  return parsed !== void 0 && PACKAGE_RENAMES.has(parsed.name);
+  return { name, kind: "command", runsGenerator: shellCommands(value).some(runsGenerator) };
 }
-function migrateNpmSpec(spec, version) {
-  const parsed = parseNpmSpec(spec);
-  const renamed = parsed === void 0 ? void 0 : PACKAGE_RENAMES.get(parsed.name);
-  if (parsed === void 0 || renamed === void 0) {
-    return void 0;
-  }
-  const head = `${NPM_PROTOCOL}${parsed.lead}${renamed}`;
-  const isDeep = parsed.rest !== "" && parsed.rest !== PATH_SEPARATOR$5;
-  if (parsed.range === void 0) {
-    return { spec: `${head}${parsed.rest}`, isReported: false, isDeep };
+function shellVariables(definitions) {
+  const values = /* @__PURE__ */ new Map();
+  for (const { name, value } of definitions) {
+    values.set(name, [values.get(name), value].filter((part) => part !== void 0).join(" "));
   }
-  const decision = migrateVersionSpec(parsed.range, version);
-  const isReported = decision.kind === "kept" && decision.isReported;
-  const migrated = `${head}${VERSION_SEPARATOR}${decision.spec}${parsed.rest}`;
-  return { spec: migrated, isReported, isDeep };
-}
-
-const SCHEME_SEPARATOR = "://";
-const HIDDEN_USERINFO = "***";
-const USERINFO_END = "@";
-const AUTHORITY_END_RE = /[/?#"'`\s]/;
-function scanAuthority(text, start) {
-  let userinfoEnd = -1;
-  let end = start;
-  for (; end < text.length && !AUTHORITY_END_RE.test(text.charAt(end)); end++) {
-    if (text.charAt(end) === USERINFO_END) {
-      userinfoEnd = end;
+  const programs = variablePrograms(definitions.map(programDefinition$1));
+  const nameAt = (word) => expandedName(word.raw);
+  return {
+    programAt: (program) => {
+      const name = nameAt(program);
+      const found = name === void 0 ? void 0 : programs.get(name);
+      return found === void 0 ? void 0 : { written: program.raw, program: found };
+    },
+    referenceAt: (word) => {
+      const name = nameAt(word);
+      const value = name === void 0 ? void 0 : values.get(name);
+      return value === void 0 ? void 0 : { written: word.raw, value };
     }
-  }
-  return { end, userinfoEnd };
+  };
 }
-function hideUrlCredentials(text) {
-  let hidden = "";
-  let copiedUpTo = 0;
-  for (let found = text.indexOf(SCHEME_SEPARATOR); found !== -1; ) {
-    const start = found + SCHEME_SEPARATOR.length;
-    const { end, userinfoEnd } = scanAuthority(text, start);
-    if (userinfoEnd !== -1) {
-      hidden += `${text.slice(copiedUpTo, start)}${HIDDEN_USERINFO}`;
-      copiedUpTo = userinfoEnd;
-    }
-    found = text.indexOf(SCHEME_SEPARATOR, end);
+function combinedUse(left, right) {
+  if (left === void 0 || right === void 0) {
+    return left ?? right;
   }
-  return `${hidden}${text.slice(copiedUpTo)}`;
+  return left.program === right.program ? left : { ...left, program: "generator-or-other" };
 }
-
-const newFindings = () => ({ edits: [], changes: [], manualSteps: [] });
-const PEER_FIELD = "peerDependencies";
-const mapLabel = (map) => map.kind === "catalog" ? map.catalog : map.field;
-const renamedKey = (name, map) => map.kind === "imports" ? renamedSpecifier(name)?.to : PACKAGE_RENAMES.get(name);
-function migrateSpec(spec, version) {
-  const npm = migrateNpmSpec(spec, version);
-  if (npm !== void 0) {
-    return { spec: npm.spec, isReported: npm.isReported };
+function withShellAssignments(commands, file) {
+  const definitions = commands.flatMap(shellAssignments);
+  if (definitions.length === 0) {
+    return file;
   }
-  const decision = migrateVersionSpec(spec, version);
-  return { spec: decision.spec, isReported: decision.kind === "kept" && decision.isReported };
+  const own = shellVariables(definitions);
+  return {
+    programAt: (program) => combinedUse(own.programAt(program), file.programAt(program)),
+    referenceAt: (word) => own.referenceAt(word) ?? file.referenceAt(word)
+  };
 }
-function isFree({ from, to, field, names }, findings) {
-  if (names.has(to)) {
-    findings.manualSteps.push({ kind: "name-collision", field, from, to });
-    return false;
+
+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) {
+  const at = word.raw.lastIndexOf(name);
+  const tail = word.raw.slice(at + name.length);
+  if (at === -1 || tail !== "" && !QUOTES$1.has(tail)) {
+    return void 0;
   }
-  return true;
+  return { start: word.start + at, end: word.start + at + name.length, text: to };
 }
-function migrateAlias(entry, { map, version, findings }) {
-  const migrated = entry.spec === void 0 ? void 0 : migrateNpmSpec(entry.spec.value, version);
-  if (entry.spec === void 0 || migrated === void 0) {
-    return;
+function packageFindings(found, locate) {
+  const { name, isPinned } = packageReference(found.value);
+  const to = PACKAGE_RENAMES.get(name);
+  const offset = found.word.start;
+  if (to === void 0) {
+    return [];
   }
-  findings.edits.push(entry.spec.replace(migrated.spec));
-  const spec = hideUrlCredentials(migrated.spec);
-  findings.changes.push({ kind: "alias-renamed", field: mapLabel(map), name: entry.name, spec });
-  if (migrated.isReported) {
-    findings.manualSteps.push({ kind: "spec-kept", name: entry.name, spec });
+  const location = locate(offset);
+  if (isPinned) {
+    return [{ offset, manualStep: { kind: "pinned-package", location, name } }];
   }
+  const edit = renameAtEnd(found.word, name, to);
+  const change = { kind: "package-name-renamed", location, from: name, to };
+  return edit === void 0 ? [] : [{ offset, edit, change }];
 }
-function renamedChange(map, from, to, spec) {
-  switch (map.kind) {
-    case "dependencies":
-      return { kind: "dependency-renamed", field: map.field, from, to, spec };
-    case "catalog":
-      return { kind: "catalog-entry-renamed", catalog: map.catalog, from, to, spec };
-    case "imports":
-      return { kind: "import-renamed", field: map.field, from, to, target: spec };
-    default:
-      return assertNever(map);
+function programPathFindings(word, location) {
+  const offset = word.start;
+  if (word.value.includes(OLD_PACKAGE_FOLDER)) {
+    return [{ offset, manualStep: { kind: "old-package-file", location, path: word.value } }];
   }
+  const isBin = word.value.endsWith(`${BIN_FOLDER}${GENERATOR_COMMAND}`);
+  const edit = isBin ? renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND) : void 0;
+  return edit === void 0 ? [] : [{ offset, edit, change: { kind: "command-renamed", location } }];
 }
-function migrateEntry(entry, spec, to, { map, version, findings }) {
-  const old = spec.value;
-  const migrated = migrateSpec(old, version);
-  findings.edits.push(entry.renameKey(to));
-  if (migrated.spec !== old) {
-    findings.edits.push(spec.replace(migrated.spec));
+function programFindings(word, location) {
+  if (word.value.includes(PATH_SEPARATOR$7)) {
+    return programPathFindings(word, location);
   }
-  findings.changes.push(renamedChange(map, entry.name, to, hideUrlCredentials(migrated.spec)));
-  if (migrated.isReported) {
-    findings.manualSteps.push({ kind: "spec-kept", name: to, spec: hideUrlCredentials(old) });
+  const { name, isPinned } = packageReference(word.value);
+  if (name !== GENERATOR_COMMAND) {
+    return [];
   }
-  if (map.kind === "dependencies" && map.field === PEER_FIELD) {
-    findings.manualSteps.push({ kind: "peer-dependency-renamed", name: to });
+  if (isPinned) {
+    return [{ offset: word.start, manualStep: { kind: "versioned-command", location } }];
   }
+  const edit = renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND);
+  const change = { kind: "command-renamed", location };
+  return edit === void 0 ? [] : [{ offset: word.start, edit, change }];
 }
-function catalogHold(entry, spec, { map, catalogs }) {
-  if (map.kind === "catalog") {
-    const isInUse = catalogs.inUse.has(map.name, entry.name);
-    return isInUse ? { kind: "catalog-entry-in-use", catalog: map.catalog, name: entry.name } : void 0;
+function flagFindings(word, locate) {
+  const flag = word.raw.split("=", 1)[0];
+  const to = FLAG_RENAMES.get(flag);
+  if (to === void 0) {
+    return [];
   }
-  const catalog = map.kind === "dependencies" ? catalogOfSpec(spec.value) : void 0;
-  if (catalog === void 0) {
-    return void 0;
+  const offset = word.start;
+  const edit = { start: offset, end: offset + flag.length, text: to };
+  return [
+    { offset, edit, change: { kind: "flag-renamed", location: locate(offset), from: flag, to } }
+  ];
+}
+function renamedFlags(value) {
+  const flags = shellCommands(value).flat().map((word) => word.raw.split("=", 1)[0]);
+  return [...new Set(flags.filter((flag) => FLAG_RENAMES.has(flag)))];
+}
+function argumentFindings(word, locate, variables) {
+  const reference = variables.referenceAt(word);
+  if (reference === void 0) {
+    return flagFindings(word, locate);
   }
-  const reference = { field: mapLabel(map), name: entry.name, catalog };
-  if (!catalogs.defined.has(catalog, entry.name)) {
-    const kind = catalogs.isWorkspaceRoot ? "catalog-entry-missing" : "catalog-entry-outside";
-    return { kind, ...reference };
+  const flags = renamedFlags(reference.value);
+  if (flags.length === 0) {
+    return [];
   }
-  return catalogs.kept.has(catalog, entry.name) ? { kind: "catalog-reference-kept", ...reference } : void 0;
+  const manualStep = {
+    kind: "flags-in-variable",
+    location: locate(word.start),
+    variable: reference.written,
+    flags
+  };
+  return [{ offset: word.start, manualStep }];
 }
-function migrateSpecMap(entries, context) {
-  const names = new Set(entries.map((entry) => entry.name));
-  for (const entry of entries) {
-    const to = renamedKey(entry.name, context.map);
-    const field = mapLabel(context.map);
-    if (to === void 0) {
-      migrateAlias(entry, context);
-      continue;
-    }
-    if (!isFree({ from: entry.name, to, field, names }, context.findings)) {
-      continue;
-    }
-    const hold = entry.spec === void 0 ? void 0 : catalogHold(entry, entry.spec, context);
-    if (entry.spec === void 0) {
-      context.findings.manualSteps.push({ kind: "entry-not-edited", field, name: entry.name });
-    } else if (hold !== void 0) {
-      context.findings.manualSteps.push(hold);
-    } else {
-      migrateEntry(entry, entry.spec, to, context);
-    }
-  }
-}
-function renameNames(entries, field, findings) {
-  const names = new Set(entries.map((entry) => entry.name));
-  for (const entry of entries) {
-    const to = PACKAGE_RENAMES.get(entry.name);
-    if (to !== void 0 && isFree({ from: entry.name, to, field, names }, findings)) {
-      findings.edits.push(entry.rename(to));
-      findings.changes.push({
-        kind: "package-name-renamed",
-        location: field,
-        from: entry.name,
-        to
-      });
-    }
-  }
-}
-
-const IMPORTS_FIELD$1 = "imports";
-const SCOPES_FIELD = "scopes";
-const FIELD_SEPARATOR$2 = ".";
-function migrateImports(config, version, findings) {
-  for (const imports of mapsAt(config, IMPORTS_FIELD$1)) {
-    const map = { kind: "imports", field: IMPORTS_FIELD$1 };
-    migrateSpecMap(specEntries(imports), { map, version, findings, catalogs: NO_CATALOG_PLAN });
-  }
-  for (const scopes of mapsAt(config, SCOPES_FIELD)) {
-    for (const { key, value } of textEntries(scopes)) {
-      if (isMap(value)) {
-        const field = [SCOPES_FIELD, key.value].join(FIELD_SEPARATOR$2);
-        const map = { kind: "imports", field };
-        migrateSpecMap(specEntries(value), { map, version, findings, catalogs: NO_CATALOG_PLAN });
-      }
-    }
-  }
-}
-const PATH_SEPARATOR$4 = "/";
-const SCOPE_PREFIX = "@";
-function importMapKeys(config) {
-  const scoped = mapsAt(config, SCOPES_FIELD).flatMap(textEntries).flatMap(({ value }) => isMap(value) ? [value] : []);
-  return [...mapsAt(config, IMPORTS_FIELD$1), ...scoped].flatMap(textEntries).map(({ key }) => key.value);
-}
-function importMapNames(config) {
-  return importMapKeys(config).map((key) => {
-    const parts = key.split(PATH_SEPARATOR$4);
-    return key.startsWith(SCOPE_PREFIX) ? parts.slice(0, 2).join(PATH_SEPARATOR$4) : parts[0] ?? key;
-  });
-}
-function migrateImportMap(text, read, version) {
-  if (read.kind === "unreadable") {
-    return unreadableConfig(text, read.offset);
-  }
-  const findings = newFindings();
-  for (const config of read.documents.filter(isMap)) {
-    migrateImports(config, version, findings);
+const oldFlagsOf = (findings) => findings.flatMap(({ change, manualStep }) => {
+  if (change?.kind === "flag-renamed") {
+    return [change.from];
   }
-  const { edits, changes, manualSteps } = findings;
-  return { text: applyTextEdits(text, edits), changes, manualSteps };
-}
-
-const NONE = /* @__PURE__ */ new Set();
-const PACKAGE_OPTIONS = /* @__PURE__ */ new Set(["-p", "--package"]);
-const PACKAGE_MANAGER_OPTIONS = /* @__PURE__ */ new Set([
-  "--filter",
-  "-F",
-  "--dir",
-  "-C",
-  "--prefix",
-  "--cwd",
-  "--workspace"
-]);
-const launcher = (words, packageOptions = NONE, valueOptions = NONE) => {
-  const allValueOptions = /* @__PURE__ */ new Set([...valueOptions, ...packageOptions]);
-  return { words, packageOptions, valueOptions: allValueOptions, operands: 0 };
-};
-const CONTAINER_OPTIONS = /* @__PURE__ */ new Set([
-  "-e",
-  "--env",
-  "--env-file",
-  "-v",
-  "--volume",
-  "--mount",
-  "-p",
-  "--publish",
-  "-w",
-  "--workdir",
-  "-u",
-  "--user",
-  "--name",
-  "--network",
-  "--entrypoint",
-  "--platform",
-  "-l",
-  "--label",
-  "-h",
-  "--hostname",
-  "--add-host"
-]);
-const container = (words) => ({
-  ...launcher(words, NONE, CONTAINER_OPTIONS),
-  operands: 1
+  return manualStep?.kind === "flags-in-variable" ? [...manualStep.flags] : [];
 });
-const withOperands = (words, operands, valueOptions = NONE) => ({ ...launcher(words, NONE, valueOptions), operands });
-const XARGS_OPTIONS = /* @__PURE__ */ new Set([
-  "-I",
-  "-J",
-  "-L",
-  "-n",
-  "-P",
-  "-R",
-  "-S",
-  "-s",
-  "-d",
-  "-E",
-  "-a",
-  "--max-args",
-  "--max-procs",
-  "--max-lines",
-  "--delimiter",
-  "--arg-file"
-]);
-const NODE_OPTIONS = /* @__PURE__ */ new Set([
-  "-r",
-  "--require",
-  "--import",
-  "--loader",
-  "--env-file"
-]);
-const LAUNCHERS = [
-  launcher(["npm", "exec"], PACKAGE_OPTIONS),
-  launcher(["npm", "x"], PACKAGE_OPTIONS),
-  launcher(["pnpm", "exec"], NONE, PACKAGE_MANAGER_OPTIONS),
-  launcher(["pnpm", "dlx"], /* @__PURE__ */ new Set(["--package"])),
-  launcher(["yarn", "dlx"], PACKAGE_OPTIONS),
-  launcher(["yarn", "exec"]),
-  launcher(["bun", "x"], PACKAGE_OPTIONS),
-  withOperands(["yarn", "workspace"], 1),
-  launcher(["dotenvx", "run"], NONE, /* @__PURE__ */ new Set(["-f", "--env-file", "-e", "--env", "--convention"])),
-  launcher(
-    ["doppler", "run"],
-    NONE,
-    /* @__PURE__ */ new Set(["-p", "--project", "-c", "--config", "--token", "--mount", "--scope"])
-  ),
-  launcher(["nx", "exec"], NONE, /* @__PURE__ */ new Set(["--projects", "-p", "--exclude"])),
-  launcher(["deno", "run"], NONE, /* @__PURE__ */ new Set(["--config", "-c", "--import-map", "--location"])),
-  launcher(["deno", "x"]),
-  launcher(["npx"], PACKAGE_OPTIONS, /* @__PURE__ */ new Set(["-c", "--call"])),
-  launcher(["pnpx"], PACKAGE_OPTIONS),
-  launcher(["bunx"], PACKAGE_OPTIONS),
-  // Like a bare `pnpm <name>`, a bare `bun <name>` runs the binary when no script has the name.
-  launcher(["bun"], NONE, /* @__PURE__ */ new Set(["--cwd", "--filter", "-F"])),
-  launcher(["corepack"]),
-  launcher(["pnpm"], NONE, PACKAGE_MANAGER_OPTIONS),
-  launcher(["yarn"], NONE, PACKAGE_MANAGER_OPTIONS),
-  launcher(["node"], NONE, NODE_OPTIONS),
-  launcher(["tsx"], NONE, NODE_OPTIONS),
-  launcher(["ts-node"], NONE, /* @__PURE__ */ new Set([...NODE_OPTIONS, "-P", "--project", "-O", "--compiler"])),
-  launcher(["cross-env"]),
-  launcher(["dotenv"], NONE, /* @__PURE__ */ new Set(["-e", "-c", "-v"])),
-  launcher(["env"], NONE, /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"])),
-  launcher(["exec"], NONE, /* @__PURE__ */ new Set(["-a"])),
-  launcher(["command"]),
-  launcher(["time"]),
-  launcher(["nice"], NONE, /* @__PURE__ */ new Set(["-n", "--adjustment"])),
-  withOperands(["timeout"], 1, /* @__PURE__ */ new Set(["-s", "--signal", "-k", "--kill-after"])),
-  launcher(["xargs"], NONE, XARGS_OPTIONS),
-  launcher(["nohup"]),
-  launcher(["sudo"], NONE, /* @__PURE__ */ new Set(["-u", "-g"])),
-  // The shell form of Dockerfile instructions runs the rest of the line in a shell.
-  launcher(["RUN"], NONE, /* @__PURE__ */ new Set(["--mount", "--network", "--security"])),
-  launcher(["CMD"]),
-  launcher(["ENTRYPOINT"]),
-  container(["docker", "run"]),
-  container(["docker", "exec"]),
-  container(["docker", "compose", "run"]),
-  container(["docker", "compose", "exec"]),
-  container(["podman", "run"]),
-  container(["podman", "exec"])
-];
-const installers = (manager, subcommands) => subcommands.map((subcommand) => ({ words: [manager, subcommand] }));
-const NPM_INSTALL = ["install", "i", "add", "update", "up", "uninstall", "remove", "rm", "un"];
-const INSTALLERS = [
-  ...installers("npm", NPM_INSTALL),
-  ...installers("pnpm", ["add", "update", "up", "remove", "rm", "uninstall", "un"]),
-  ...installers("yarn", ["add", "upgrade", "up", "remove"]),
-  // Yarn 1 installs global packages with `yarn global add`.
-  { words: ["yarn", "global", "add"] },
-  { words: ["yarn", "global", "remove"] },
-  ...installers("bun", ["add", "a", "update", "remove", "rm", "install", "i"]),
-  ...installers("deno", ["add", "install", "i", "remove", "uninstall"])
-];
-const NPM_SPECIFIER_PREFIX = "npm:";
-
-const ASSIGNMENT_RE$1 = /^[A-Za-z_][A-Za-z0-9_]*=/;
-const END_OF_OPTIONS = "--";
-const isOption$1 = (word) => word.value.startsWith("-") && word.value.length > 1;
-function skipAssignments(words, start) {
-  let index = start;
-  while (index < words.length && ASSIGNMENT_RE$1.test(words[index].raw)) {
-    index++;
-  }
-  return index;
-}
-function matchingPrefix(entries, words, index) {
-  return entries.find(
-    (entry) => entry.words.every((name, offset) => words[index + offset]?.value === name)
-  );
-}
-function inlineOptionPackage(word, launcher) {
-  const equals = word.value.indexOf("=");
-  const name = word.value.slice(0, equals);
-  return launcher.packageOptions.has(name) ? { word, value: word.value.slice(equals + 1) } : void 0;
-}
-function launchedProgram(words, start, launcher, packages) {
-  let index = start;
-  while (index < words.length && isOption$1(words[index])) {
-    const option = words[index++];
-    if (option.value === END_OF_OPTIONS) {
-      break;
-    }
-    const inline = option.value.includes("=") ? inlineOptionPackage(option, launcher) : void 0;
-    if (inline !== void 0) {
-      packages.push(inline);
-    }
-    const value = words[index];
-    if (!option.value.includes("=") && launcher.valueOptions.has(option.value) && value) {
-      if (launcher.packageOptions.has(option.value)) {
-        packages.push({ word: value, value: value.value });
-      }
-      index++;
-    }
-  }
-  return index;
-}
-const installArguments = (words, start) => words.slice(start).filter((word) => !isOption$1(word)).map((word) => ({ word, value: word.value }));
-function commandRoles(words) {
-  const packages = [];
-  let index = skipAssignments(words, 0);
-  while (index < words.length) {
-    const installer = matchingPrefix(INSTALLERS, words, index);
-    if (installer !== void 0) {
-      packages.push(...installArguments(words, index + installer.words.length));
-      return { program: void 0, packages };
-    }
-    const launcher = matchingPrefix(LAUNCHERS, words, index);
-    if (launcher === void 0) {
-      return { program: index, packages };
-    }
-    const start = index + launcher.words.length;
-    const afterOptions = launchedProgram(words, start, launcher, packages);
-    index = skipAssignments(words, afterOptions + launcher.operands);
-  }
-  return { program: void 0, packages };
-}
-
-function packageReference(value) {
-  const bare = value.startsWith(NPM_SPECIFIER_PREFIX) ? value.slice(NPM_SPECIFIER_PREFIX.length) : value;
-  const at = bare.indexOf("@", 1);
-  return { name: at === -1 ? bare : bare.slice(0, at), isPinned: at !== -1 };
-}
-function namesOldPackage(value) {
-  return PACKAGE_RENAMES.has(packageReference(value).name) || oldPackageInNodeModules(value) !== void 0 || value.endsWith(`/${GENERATOR_COMMAND}`);
-}
-function unmigratedWordFindings(words, handledOffsets, locate) {
-  return words.filter((word) => !handledOffsets.has(word.start) && namesOldPackage(word.value)).map((word) => ({
-    offset: word.start,
-    manualStep: { kind: "old-name-in-command", location: locate(word.start), word: word.value }
-  }));
-}
-
-const COMMAND_SEPARATORS = /* @__PURE__ */ new Set([
-  ";",
-  "&",
-  "|",
-  "(",
-  ")",
-  "`",
-  "\n"
-]);
-const WORD_BREAKS = /* @__PURE__ */ new Set([" ", "	", "\r", "<", ">"]);
-const BACKSLASH$1 = "\\";
-const DOUBLE_QUOTE_ESCAPES = /* @__PURE__ */ new Set(["$", "`", '"', BACKSLASH$1, "\n"]);
-function singleQuoted(text, start) {
-  const close = text.indexOf("'", start + 1);
-  const end = close === -1 ? text.length : close + 1;
-  return { end, value: text.slice(start + 1, close === -1 ? text.length : close) };
-}
-function doubleQuoted(text, start) {
-  let value = "";
-  let index = start + 1;
-  while (index < text.length && text[index] !== '"') {
-    const next = text[index + 1] ?? "";
-    const isEscape = text[index] === BACKSLASH$1 && DOUBLE_QUOTE_ESCAPES.has(next);
-    value += isEscape ? next === "\n" ? "" : next : text[index];
-    index += isEscape ? 2 : 1;
+function uncertainFlagSteps(program, variable, found, locate) {
+  const flags = [...new Set(oldFlagsOf(found))];
+  if (flags.length === 0) {
+    return [];
   }
-  return { end: Math.min(index + 1, text.length), value };
+  const manualStep = {
+    kind: "variable-not-only-generator",
+    location: locate(program.start),
+    variable,
+    flags
+  };
+  return [{ offset: program.start, manualStep }];
 }
-const isLineContinuation = (text, index) => text[index] === BACKSLASH$1 && (text[index + 1] === "\n" || text.startsWith("\r\n", index + 1));
-const ARITHMETIC_OPEN = "$((";
-const NESTING_OPEN = "(";
-const NESTING_CLOSE = ")";
-const ARITHMETIC_DEPTH = 2;
-function arithmeticExpansion(text, start) {
-  let depth = ARITHMETIC_DEPTH;
-  for (let index = start + ARITHMETIC_OPEN.length; index < text.length; index++) {
-    depth += text[index] === NESTING_OPEN ? 1 : text[index] === NESTING_CLOSE ? -1 : 0;
-    if (depth === 0) {
-      return { end: index + 1, value: text.slice(start, index + 1) };
-    }
-  }
-  return void 0;
+function commandFindings(command, locate, variables) {
+  const words = withoutRecipePrefix(command);
+  const found = knownFindings(words, locate, variables);
+  const handled = new Set(found.map((finding) => finding.offset));
+  return [...found, ...unmigratedWordFindings(words, handled, locate)];
 }
-function wordPart(text, index) {
-  const char = text[index];
-  const arithmetic = text.startsWith(ARITHMETIC_OPEN, index) ? arithmeticExpansion(text, index) : void 0;
-  if (arithmetic !== void 0) {
-    return arithmetic;
-  }
-  if (char === "'") {
-    return singleQuoted(text, index);
-  }
-  if (char === '"') {
-    return doubleQuoted(text, index);
-  }
-  if (char === BACKSLASH$1 && index + 1 < text.length) {
-    return { end: index + 2, value: text[index + 1] };
+function knownFindings(words, locate, variables) {
+  const roles = commandRoles(words);
+  const findings = roles.packages.flatMap((found2) => packageFindings(found2, locate));
+  const program = roles.program === void 0 ? void 0 : words[roles.program];
+  if (program === void 0) {
+    return findings;
   }
-  return { end: index + 1, value: char };
-}
-const endsWord = (text, index) => {
-  const char = text[index];
-  return WORD_BREAKS.has(char) || COMMAND_SEPARATORS.has(char) || isLineContinuation(text, index);
-};
-function readWord(text, start) {
-  let value = "";
-  let index = start;
-  while (index < text.length && !endsWord(text, index)) {
-    const part = wordPart(text, index);
-    value += part.value;
-    index = part.end;
+  const found = programFindings(program, locate(program.start));
+  findings.push(...found);
+  const isRenamed = found.some((finding) => finding.change?.kind === "command-renamed");
+  const variable = variables.programAt(program);
+  if (!isRenamed && (variable === void 0 || variable.program === "other")) {
+    return findings;
   }
-  return { start, end: index, value, raw: text.slice(start, index) };
+  const flags = words.slice(roles.program + 1);
+  const flagFound = flags.flatMap((word) => argumentFindings(word, locate, variables));
+  const isUncertain = variable?.program === "generator-or-other";
+  findings.push(
+    ...isUncertain ? uncertainFlagSteps(program, variable.written, flagFound, locate) : flagFound
+  );
+  return findings;
 }
-
-const HEREDOC_OPERATOR = "<<";
-const HERE_STRING_OPERATOR = "<<<";
-const STRIP_TABS = "-";
-const LINE_BREAK$2 = "\n";
-const LEADING_TABS_RE = /^\t+/;
-const CARRIAGE_RETURN_RE = /\r$/;
-function heredocAt(text, index, where) {
-  if (text.startsWith(HERE_STRING_OPERATOR, index)) {
-    return { end: index + HERE_STRING_OPERATOR.length };
-  }
-  if (!text.startsWith(HEREDOC_OPERATOR, index)) {
-    return void 0;
-  }
-  let start = index + HEREDOC_OPERATOR.length;
-  const isTabStripped = text[start] === STRIP_TABS;
-  start += isTabStripped ? 1 : 0;
-  while (text[start] === " " || text[start] === "	") {
-    start++;
-  }
-  const word = readWord(text, start);
-  const pending = { delimiter: word.value, isTabStripped, ...where };
-  return word.value === "" ? void 0 : { pending, end: word.end };
+function shellTextFindings(text, locate) {
+  return commandWordFindings(shellCommands(text), locate);
 }
-function isDelimiterLine(text, lineStart, end, heredoc) {
-  let first = lineStart;
-  while (first < lineStart + heredoc.indent && text[first] === " ") {
-    first++;
-  }
-  const line = text.slice(first, end).replace(CARRIAGE_RETURN_RE, "");
-  const compared = heredoc.isTabStripped ? line.replace(LEADING_TABS_RE, "") : line;
-  return compared === heredoc.delimiter;
+function commandWordFindings(commands, locate, variables = NO_VARIABLES) {
+  const known = withShellAssignments(commands, variables);
+  const findings = commands.flatMap((words) => commandFindings(words, locate, known)).sort((left, right) => left.offset - right.offset);
+  return {
+    edits: findings.flatMap((finding) => finding.edit === void 0 ? [] : [finding.edit]),
+    changes: findings.flatMap((finding) => finding.change === void 0 ? [] : [finding.change]),
+    manualSteps: findings.flatMap(
+      (finding) => finding.manualStep === void 0 ? [] : [finding.manualStep]
+    )
+  };
 }
-function readBody(text, start, heredoc) {
-  let lineStart = start;
-  while (lineStart < text.length) {
-    const lineEnd = text.indexOf(LINE_BREAK$2, lineStart);
-    const end = lineEnd === -1 ? text.length : lineEnd;
-    if (isDelimiterLine(text, lineStart, end, heredoc)) {
-      const body = { command: heredoc.command, start, text: text.slice(start, lineStart) };
-      return { body, end: Math.min(end + 1, text.length) };
-    }
-    lineStart = end + 1;
-  }
-  return { body: { command: heredoc.command, start, text: text.slice(start) }, end: text.length };
+function migrateShellText(text, locate) {
+  const { edits, changes, manualSteps } = shellTextFindings(text, locate);
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
-function readBodies(text, start, pending) {
-  const bodies = [];
-  let end = start;
-  for (const heredoc of pending) {
-    const read = readBody(text, end, heredoc);
-    bodies.push(read.body);
-    end = read.end;
-  }
-  return { bodies, end };
+function migrateCommand(text, location) {
+  return migrateShellText(text, () => location);
 }
-
-const COMMENT = "#";
-const LINE_BREAK$1 = "\n";
-function skipTrivia(text, index) {
-  const char = text[index];
-  if (WORD_BREAKS.has(char)) {
-    return index + 1;
-  }
-  if (isLineContinuation(text, index)) {
-    return text.indexOf("\n", index) + 1;
-  }
-  if (char === COMMENT) {
-    const lineEnd = text.indexOf("\n", index);
-    return lineEnd === -1 ? text.length : lineEnd;
-  }
-  return index;
+function migrateCommandLines(text, file) {
+  const lineOf = lineLocator(text);
+  return migrateShellText(text, (offset) => `${file}:${lineOf(offset)}`);
 }
-const PIPE = "|";
-function topLevelCommands(text, indent) {
-  const commands = [[]];
-  const heredocs = [];
-  const pipes = /* @__PURE__ */ new Set();
-  let pending = [];
-  let index = 0;
-  while (index < text.length) {
-    const afterTrivia = skipTrivia(text, index);
-    const heredoc = heredocAt(text, index, { command: commands.length - 1, indent });
-    if (heredoc !== void 0) {
-      pending.push(...heredoc.pending === void 0 ? [] : [heredoc.pending]);
-      index = heredoc.end;
-    } else if (afterTrivia !== index) {
-      index = afterTrivia;
-    } else if (text[index] === LINE_BREAK$1 && pending.length > 0) {
-      const read = readBodies(text, index + 1, pending);
-      heredocs.push(...read.bodies);
-      pending = [];
-      commands.push([]);
-      index = read.end;
-    } else if (COMMAND_SEPARATORS.has(text[index])) {
-      if (text[index] === PIPE) {
-        pipes.add(commands.length - 1);
-      }
-      commands.push([]);
-      index++;
-    } else {
-      const word = readWord(text, index);
-      commands.at(-1)?.push(word);
-      index = word.end;
+
+const ANY = "*";
+const nxOptionPaths = (prefix) => [
+  [...prefix, "command"],
+  [...prefix, "commands", ANY],
+  [...prefix, "commands", ANY, "command"]
+];
+const nxTargetPaths = (prefix) => [
+  [...prefix, ANY, "command"],
+  ...nxOptionPaths([...prefix, ANY, "options"]),
+  ...nxOptionPaths([...prefix, ANY, "configurations", ANY])
+];
+const lintStagedPaths = (prefix) => [
+  [...prefix, ANY],
+  [...prefix, ANY, ANY]
+];
+const simpleGitHooksPaths = (prefix) => [
+  [...prefix, ANY]
+];
+const NX_PROJECT_COMMAND_PATHS = nxTargetPaths(["targets"]);
+const NX_WORKSPACE_COMMAND_PATHS = nxTargetPaths([
+  "targetDefaults"
+]);
+const MANIFEST_COMMAND_PATHS = [
+  ["scripts", ANY],
+  ["wireit", ANY, "command"],
+  ...simpleGitHooksPaths(["simple-git-hooks"]),
+  ...lintStagedPaths(["lint-staged"]),
+  ...nxTargetPaths(["nx", "targets"])
+];
+const LINT_STAGED_COMMAND_PATHS = lintStagedPaths([]);
+const SIMPLE_GIT_HOOKS_COMMAND_PATHS = simpleGitHooksPaths(
+  []
+);
+const DENO_TASK_PATHS = [
+  ["tasks", ANY],
+  ["tasks", ANY, "command"]
+];
+const matches = (path, pattern) => path.length === pattern.length && pattern.every((part, index) => part === ANY || part === String(path[index]));
+const isCommandPath = (path, patterns) => patterns.some((pattern) => matches(path, pattern));
+
+const NO_LOCATION = "";
+function commandStringSteps(text, strings) {
+  const lineOf = lineLocator(text);
+  return strings.flatMap((found) => {
+    if (found.isModuleSpecifier || PACKAGE_RENAMES.has(found.value)) {
+      return [];
     }
-  }
-  return { commands, heredocs, pipes };
+    const migrated = migrateCommand(found.value, NO_LOCATION).text;
+    return migrated === found.value ? [] : [{ kind: "command-string", line: lineOf(found.start), to: migrated }];
+  });
 }
-const COMMAND_PREFIX_WORDS = /* @__PURE__ */ new Set([
-  "if",
-  "then",
-  "elif",
-  "else",
-  "fi",
-  "while",
-  "until",
-  "do",
-  "done",
-  "!",
-  "{",
-  "}",
-  "esac"
-]);
-const CLAUSE_WORDS = /* @__PURE__ */ new Set(["for", "select", "case", "[["]);
-const FUNCTION_WORD = "function";
-const FUNCTION_HEADER_LENGTH = 2;
-const isReserved = (word, words) => word !== void 0 && word.raw === word.value && words.has(word.value);
-function prefixLength(words, index) {
-  if (isReserved(words[index], COMMAND_PREFIX_WORDS)) {
-    return 1;
-  }
-  const word = words[index];
-  return word?.raw === FUNCTION_WORD ? FUNCTION_HEADER_LENGTH : 0;
+
+const isMap = (node) => node?.kind === "map";
+const isScalar = (node) => node.kind === "scalar";
+function textEntries(map) {
+  return map.entries.flatMap(({ key, value }) => isScalar(key) ? [{ key, value }] : []);
 }
-function simpleCommand(words) {
-  let first = 0;
-  for (let length = prefixLength(words, 0); length > 0; length = prefixLength(words, first)) {
-    first += length;
-  }
-  return isReserved(words[first], CLAUSE_WORDS) ? [] : words.slice(first);
+function valuesAt(map, key) {
+  return textEntries(map).filter((entry) => entry.key.value === key).map((entry) => entry.value);
 }
-const QUOTES$2 = /* @__PURE__ */ new Set(["'", '"']);
-const NESTED_COMMAND_RE = /[\s;&|()`]/;
-function nestedCommandText(word) {
-  const quote = word.raw[0];
-  const isOneQuotedString = QUOTES$2.has(quote) && word.raw.length > 1 && word.raw.endsWith(quote) && wordPart(word.raw, 0).end === word.raw.length;
-  return isOneQuotedString && NESTED_COMMAND_RE.test(word.value) ? word.raw.slice(1, -1) : void 0;
+function mapsAt(map, key) {
+  return valuesAt(map, key).filter(isMap);
 }
-const SHELLS$1 = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh", "ksh"]);
-const DOCKER_RUN = "RUN";
-const PASS_THROUGH = "cat";
-const PATH_SEPARATOR$3 = "/";
-const OPTION_PREFIX$1 = "-";
-const programName = (command) => command[0]?.value.split(PATH_SEPARATOR$3).at(-1) ?? "";
-const isOption = (word) => word.value.startsWith(OPTION_PREFIX$1);
-const isScriptShell = (command) => SHELLS$1.has(programName(command)) && command.slice(1).every(isOption);
-function readsScript(command) {
-  if (programName(command) !== DOCKER_RUN) {
-    return isScriptShell(command);
+function stringsBelow(node, path) {
+  switch (node.kind) {
+    case "scalar":
+      return [{ ...node, path }];
+    case "list":
+      return node.items.flatMap((item, index) => stringsBelow(item, [...path, index]));
+    case "map":
+      return textEntries(node).flatMap(
+        ({ key, value }) => stringsBelow(value, [...path, key.value])
+      );
+    default:
+      return [];
   }
-  const after = command.slice(1);
-  const shell = after.slice(after.findIndex((word) => !isOption(word)));
-  return after.every(isOption) || isScriptShell(shell);
 }
-const passesThrough = (command) => programName(command) === PASS_THROUGH && command.slice(1).every(isOption);
-function scriptsRunBy(top, index, command) {
-  const previous = index - 1;
-  const isPipedScript = top.pipes.has(previous) && isScriptShell(command) && passesThrough(simpleCommand(top.commands[previous] ?? []));
-  return top.heredocs.filter(
-    (body) => body.command === index && readsScript(command) || body.command === previous && isPipedScript
-  );
+function documentStrings(documents) {
+  return documents.flatMap((document) => stringsBelow(document, []));
 }
-const shifted = (words, offset) => words.map((word) => ({ ...word, start: word.start + offset, end: word.end + offset }));
-function shellCommandsAt(text, offset, indent = 0) {
-  return shellCommands(text, indent).map((words) => shifted(words, offset));
+function ownerKey(path) {
+  return path.findLast((part) => typeof part === "string");
 }
-function shellCommands(text, indent = 0) {
-  const top = topLevelCommands(text, indent);
-  const commands = [];
-  for (const [index, words] of top.commands.entries()) {
-    const command = simpleCommand(words);
-    if (command.length > 0) {
-      commands.push(command);
-    }
-    for (const word of command) {
-      const inner = nestedCommandText(word);
-      if (inner !== void 0) {
-        const nested = shellCommands(inner).map((found) => shifted(found, word.start + 1));
-        commands.push(...nested);
-      }
-    }
-    const scripts = scriptsRunBy(top, index, command);
-    commands.push(...scripts.flatMap((body) => shellCommandsAt(body.text, body.start, indent)));
+function unreadableConfig(text, offset) {
+  if (!namesOriginalPackage(text)) {
+    return unchanged(text);
   }
-  return commands;
+  const position = offset === void 0 ? void 0 : { line: lineAt(text, offset), column: columnAt(text, offset) };
+  return { ...unchanged(text), manualSteps: [{ kind: "config-unreadable", position }] };
 }
 
-const QUOTES$1 = /* @__PURE__ */ new Set(["'", '"']);
-const PATH_SEPARATOR$2 = "/";
-const BIN_FOLDER = "/.bin/";
-const OLD_PACKAGE_FOLDER = `node_modules/${GENERATOR_COMMAND}/`;
-function renameAtEnd(word, name, to) {
-  const at = word.raw.lastIndexOf(name);
-  const tail = word.raw.slice(at + name.length);
-  if (at === -1 || tail !== "" && !QUOTES$1.has(tail)) {
+const KEPT_PROTOCOLS = ["catalog:", "workspace:"];
+const LOCAL_PROTOCOLS = ["workspace:", "link:", "file:", "portal:"];
+const RANGE_SEPARATOR = "||";
+const HYPHEN = "-";
+const WHITE_SPACE_RE = /\s+/;
+const SPACED_OPERATOR_RE = /(<=|>=|<|>|=|~>|~|\^)\s+/g;
+const OPERATOR = String.raw`(<=|>=|<|>|=|~>|~|\^)?`;
+const VERSION_PART = String.raw`(\d+|[xX*])`;
+const LABELS = String.raw`(?:-[\w.-]+)?(?:\+[\w.-]+)?`;
+const COMPARATOR_RE = new RegExp(
+  String.raw`^${OPERATOR}v?${VERSION_PART}(?:\.${VERSION_PART})?(?:\.${VERSION_PART})?${LABELS}$`
+);
+const NUMBER_RE = /^\d+$/;
+const OPERATOR_STYLES = {
+  "^": "^",
+  // `>=` means "this or newer"; with a new package line, a caret range says the same safely.
+  ">=": "^",
+  ">": "^",
+  "~": "~",
+  "~>": "~"
+};
+const isNumber = (part) => part !== void 0 && NUMBER_RE.test(part);
+function versionStyle(major, minor, patch) {
+  if (!isNumber(major)) {
     return void 0;
   }
-  return { start: word.start + at, end: word.start + at + name.length, text: to };
-}
-function packageFindings(found, locate) {
-  const { name, isPinned } = packageReference(found.value);
-  const to = PACKAGE_RENAMES.get(name);
-  const offset = found.word.start;
-  if (to === void 0) {
-    return [];
-  }
-  const location = locate(offset);
-  if (isPinned) {
-    return [{ offset, manualStep: { kind: "pinned-package", location, name } }];
+  if (isNumber(minor) && isNumber(patch)) {
+    return "";
   }
-  const edit = renameAtEnd(found.word, name, to);
-  const change = { kind: "package-name-renamed", location, from: name, to };
-  return edit === void 0 ? [] : [{ offset, edit, change }];
+  return isNumber(minor) ? "~" : "^";
 }
-function programPathFindings(word, location) {
-  const offset = word.start;
-  if (word.value.includes(OLD_PACKAGE_FOLDER)) {
-    return [{ offset, manualStep: { kind: "old-package-file", location, path: word.value } }];
+function rangeStyle(spec) {
+  const sets = spec.replace(SPACED_OPERATOR_RE, "$1").split(RANGE_SEPARATOR);
+  const tokens = sets.map((set) => set.trim().split(WHITE_SPACE_RE));
+  const comparators = tokens.flat().filter((token) => token !== HYPHEN);
+  const matches = comparators.map((comparator) => COMPARATOR_RE.exec(comparator));
+  const first = matches[0];
+  if (first === void 0 || first === null || matches.includes(null)) {
+    return void 0;
   }
-  const isBin = word.value.endsWith(`${BIN_FOLDER}${GENERATOR_COMMAND}`);
-  const edit = isBin ? renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND) : void 0;
-  return edit === void 0 ? [] : [{ offset, edit, change: { kind: "command-renamed", location } }];
-}
-function programFindings(word, location) {
-  if (word.value.includes(PATH_SEPARATOR$2)) {
-    return programPathFindings(word, location);
+  const operator = first[1];
+  const isHyphenRange = tokens[0]?.[1] === HYPHEN;
+  if (operator !== void 0 && operator !== "=") {
+    return OPERATOR_STYLES[operator];
   }
-  const { name, isPinned } = packageReference(word.value);
-  if (name !== GENERATOR_COMMAND) {
-    return [];
+  return isHyphenRange ? "^" : versionStyle(first[2], first[3], first[4]);
+}
+const isLocalPackageSpec = (spec) => LOCAL_PROTOCOLS.some((protocol) => spec.startsWith(protocol));
+function migrateVersionSpec(spec, version) {
+  if (KEPT_PROTOCOLS.some((protocol) => spec.startsWith(protocol))) {
+    return { kind: "kept", spec, isReported: false };
   }
-  if (isPinned) {
-    return [{ offset: word.start, manualStep: { kind: "versioned-command", location } }];
+  const style = rangeStyle(spec);
+  if (style === void 0) {
+    return { kind: "kept", spec, isReported: true };
   }
-  const edit = renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND);
-  const change = { kind: "command-renamed", location };
-  return edit === void 0 ? [] : [{ offset: word.start, edit, change }];
+  return { kind: "replaced", spec: `${style}${version}` };
 }
-function flagFindings(word, locate) {
-  const flag = word.raw.split("=", 1)[0];
-  const to = FLAG_RENAMES.get(flag);
-  if (to === void 0) {
-    return [];
-  }
-  const offset = word.start;
-  const edit = { start: offset, end: offset + flag.length, text: to };
-  return [
-    { offset, edit, change: { kind: "flag-renamed", location: locate(offset), from: flag, to } }
-  ];
+
+const NO_LONGER_INSTALLED = /* @__PURE__ */ new Map([
+  ["openapi-typesafe-helpers", ["openapi-fetch", "openapi-react-query"]]
+]);
+const ORIGINAL_NAMES = new Map(
+  [...PACKAGE_RENAMES].map(([original, successor]) => [successor, original])
+);
+const PATH_SEPARATOR$6 = "/";
+function namesUninstalledPackage(text) {
+  return [...NO_LONGER_INSTALLED.keys()].some(
+    (name) => text.includes(name) || text.includes(ORIGINAL_NAMES.get(name) ?? name)
+  );
 }
-const RECIPE_PREFIX_RE$1 = /^[@+-]+(?=.)/;
-function withoutRecipePrefix(words) {
-  const [first, ...rest] = words;
-  if (first === void 0 || !RECIPE_PREFIX_RE$1.test(first.value)) {
-    return words;
-  }
-  return [{ ...first, value: first.value.replace(RECIPE_PREFIX_RE$1, "") }, ...rest];
+const directoryOf = (path) => path.slice(0, path.lastIndexOf(PATH_SEPARATOR$6) + 1);
+const isAtOrAbove = (path, filePath) => filePath.startsWith(directoryOf(path));
+function declaredNames(manifest) {
+  return DEPENDENCY_FIELDS.flatMap((field) => mapsAt(manifest, field)).flatMap(textEntries).map(({ key }) => key.value);
 }
-const NO_VARIABLES = {
-  programAt: () => void 0,
-  referenceAt: () => void 0
+function localPackageNames(manifest) {
+  return DEPENDENCY_FIELDS.flatMap((field) => mapsAt(manifest, field)).flatMap(textEntries).flatMap(
+    ({ key, value }) => isScalar(value) && isLocalPackageSpec(value.value) ? [key.value] : []
+  );
+}
+function localPackagesFor(manifests, filePath) {
+  const containing = manifests.filter(({ path }) => isAtOrAbove(path, filePath));
+  return new Set(containing.flatMap(({ localPackages }) => [...localPackages ?? []]));
+}
+function isDeclaredFor(manifests, filePath, name) {
+  const original = ORIGINAL_NAMES.get(name);
+  const containing = manifests.filter(({ path }) => isAtOrAbove(path, filePath));
+  const declares = ({ names }) => names === void 0 || names.has(name) || original !== void 0 && names.has(original);
+  return containing.length === 0 || containing.some(declares);
+}
+const packageOfSpecifier = (specifier) => {
+  const slash = specifier.indexOf(PATH_SEPARATOR$6);
+  return slash === -1 ? specifier : specifier.slice(0, slash);
 };
-function renamedFlags(value) {
-  const flags = shellCommands(value).flat().map((word) => word.raw.split("=", 1)[0]);
-  return [...new Set(flags.filter((flag) => FLAG_RENAMES.has(flag)))];
+function undeclaredImportSteps(imports, filePath, manifests) {
+  return imports.flatMap(({ specifier, line }) => {
+    const name = packageOfSpecifier(specifier);
+    const installers = NO_LONGER_INSTALLED.get(name);
+    return installers === void 0 || isDeclaredFor(manifests, filePath, name) ? [] : [{ kind: "package-not-declared", line, name, installers }];
+  });
 }
-function argumentFindings(word, locate, variables) {
-  const reference = variables.referenceAt(word);
-  if (reference === void 0) {
-    return flagFindings(word, locate);
-  }
-  const flags = renamedFlags(reference.value);
-  if (flags.length === 0) {
-    return [];
-  }
-  const manualStep = {
-    kind: "flags-in-variable",
-    location: locate(word.start),
-    variable: reference.written,
-    flags
-  };
-  return [{ offset: word.start, manualStep }];
+
+const EXEC_FORM_START_RE = /^[ \t]*(?:RUN|CMD|ENTRYPOINT)(?:[ \t]+--\S+)*[ \t]+\[/gm;
+const SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh"]);
+const OPTION_PREFIX = "-";
+const LONG_OPTION_PREFIX = "--";
+const COMMAND_OPTION = "c";
+const SET_OPTION = "-o";
+const PATH_SEPARATOR$5 = "/";
+const ARRAY_BLANK_RE = /(?:[ \t\r\n]|\\\r?\n)*/y;
+const QUOTED_RE = /"(?:[^"\\\n]|\\.)*"/y;
+const ITEM_SEPARATOR = ",";
+const NOT_LINE_BREAK_RE$1 = /[^\n]/g;
+const ARRAY_END = "]";
+const VARIABLE_INSTRUCTIONS = /* @__PURE__ */ new Set(["ARG", "ENV"]);
+const LEGACY_ENV_INSTRUCTION = "ENV";
+const ASSIGNMENT = "=";
+const QUOTES = /* @__PURE__ */ new Set(['"', "'"]);
+function matchAt(pattern, text, index) {
+  pattern.lastIndex = index;
+  return pattern.exec(text)?.[0];
 }
-const oldFlagsOf = (findings) => findings.flatMap(({ change, manualStep }) => {
-  if (change?.kind === "flag-renamed") {
-    return [change.from];
+function jsonString(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return void 0;
+    }
+    throw error;
   }
-  return manualStep?.kind === "flags-in-variable" ? [...manualStep.flags] : [];
-});
-function uncertainFlagSteps(program, variable, found, locate) {
-  const flags = [...new Set(oldFlagsOf(found))];
-  if (flags.length === 0) {
-    return [];
+}
+function execFormAt(text, start) {
+  const words = [];
+  let index = start + 1;
+  for (; ; ) {
+    index += matchAt(ARRAY_BLANK_RE, text, index)?.length ?? 0;
+    const raw = matchAt(QUOTED_RE, text, index);
+    if (raw === void 0) {
+      const isEmpty = text[index] === ARRAY_END && words.length === 0;
+      return isEmpty ? { start, end: index + 1, words } : void 0;
+    }
+    const value = jsonString(raw);
+    if (value === void 0) {
+      return void 0;
+    }
+    words.push({ start: index + 1, end: index + raw.length - 1, value, raw: raw.slice(1, -1) });
+    index += raw.length;
+    index += matchAt(ARRAY_BLANK_RE, text, index)?.length ?? 0;
+    if (text[index] === ARRAY_END) {
+      return { start, end: index + 1, words };
+    }
+    if (text[index] !== ITEM_SEPARATOR) {
+      return void 0;
+    }
+    index++;
   }
-  const manualStep = {
-    kind: "variable-not-only-generator",
-    location: locate(program.start),
-    variable,
-    flags
-  };
-  return [{ offset: program.start, manualStep }];
 }
-function commandFindings(command, locate, variables) {
-  const words = withoutRecipePrefix(command);
-  const found = knownFindings(words, locate, variables);
-  const handled = new Set(found.map((finding) => finding.offset));
-  return [...found, ...unmigratedWordFindings(words, handled, locate)];
+function execForms(text) {
+  return [...text.matchAll(EXEC_FORM_START_RE)].flatMap((match) => {
+    const form = execFormAt(text, match.index + match[0].length - 1);
+    return form === void 0 ? [] : [form];
+  });
 }
-function knownFindings(words, locate, variables) {
-  const roles = commandRoles(words);
-  const findings = roles.packages.flatMap((found2) => packageFindings(found2, locate));
-  const program = roles.program === void 0 ? void 0 : words[roles.program];
-  if (program === void 0) {
-    return findings;
+function shellScript(words) {
+  const program = words[0]?.value.split(PATH_SEPARATOR$5).at(-1) ?? "";
+  if (!SHELLS.has(program)) {
+    return void 0;
   }
-  const found = programFindings(program, locate(program.start));
-  findings.push(...found);
-  const isRenamed = found.some((finding) => finding.change?.kind === "command-renamed");
-  const variable = variables.programAt(program);
-  if (!isRenamed && (variable === void 0 || variable.program === "other")) {
-    return findings;
+  let index = 1;
+  for (let option = words[index]?.value; option !== void 0; option = words[index]?.value) {
+    if (!option.startsWith(OPTION_PREFIX)) {
+      return void 0;
+    }
+    if (!option.startsWith(LONG_OPTION_PREFIX) && option.includes(COMMAND_OPTION)) {
+      return words[index + 1];
+    }
+    index += option === SET_OPTION ? 2 : 1;
   }
-  const flags = words.slice(roles.program + 1);
-  const flagFound = flags.flatMap((word) => argumentFindings(word, locate, variables));
-  const isUncertain = variable?.program === "generator-or-other";
-  findings.push(
-    ...isUncertain ? uncertainFlagSteps(program, variable.written, flagFound, locate) : flagFound
-  );
-  return findings;
-}
-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;
-}
-function shellTextFindings(text, locate) {
-  return commandWordFindings(shellCommands(text), locate);
+  return void 0;
 }
-function commandWordFindings(commands, locate, variables = NO_VARIABLES) {
-  const findings = commands.flatMap((words) => commandFindings(words, locate, variables)).sort((left, right) => left.offset - right.offset);
-  return {
-    edits: findings.flatMap((finding) => finding.edit === void 0 ? [] : [finding.edit]),
-    changes: findings.flatMap((finding) => finding.change === void 0 ? [] : [finding.change]),
-    manualSteps: findings.flatMap(
-      (finding) => finding.manualStep === void 0 ? [] : [finding.manualStep]
-    )
-  };
+function execCommands(forms) {
+  const commands = [];
+  const escaped = [];
+  for (const { words } of forms) {
+    commands.push(words);
+    const script = shellScript(words);
+    if (script !== void 0 && script.raw === script.value) {
+      commands.push(...shellCommandsAt(script.value, script.start));
+    } else if (script !== void 0) {
+      escaped.push(script);
+    }
+  }
+  return { commands, escaped };
 }
-function migrateShellText(text, locate) {
-  const { edits, changes, manualSteps } = shellTextFindings(text, locate);
-  return { text: applyTextEdits(text, edits), changes, manualSteps };
+function withoutExecForms(text, forms) {
+  const parts = [];
+  let copiedUpTo = 0;
+  for (const { start, end } of forms) {
+    parts.push(
+      text.slice(copiedUpTo, start),
+      text.slice(start, end).replace(NOT_LINE_BREAK_RE$1, " ")
+    );
+    copiedUpTo = end;
+  }
+  parts.push(text.slice(copiedUpTo));
+  return parts.join("");
 }
-function migrateCommand(text, location) {
-  return migrateShellText(text, () => location);
+function escapedScriptSteps(scripts, lineOf) {
+  return scripts.flatMap((script) => {
+    const migrated = migrateCommand(script.value, "").text;
+    return migrated === script.value ? [] : [{ kind: "command-string", line: lineOf(script.start), to: migrated }];
+  });
 }
-function migrateCommandLines(text, file) {
-  const lineOf = lineLocator(text);
-  return migrateShellText(text, (offset) => `${file}:${lineOf(offset)}`);
+function assignedVariable(word) {
+  const at = word.raw.indexOf(ASSIGNMENT);
+  if (at <= 0) {
+    return void 0;
+  }
+  const raw = word.raw.slice(at + 1);
+  const isQuoted = raw.length >= 2 && QUOTES.has(raw[0]) && raw.at(-1) === raw[0];
+  const value = isQuoted ? raw.slice(1, -1) : raw;
+  const start = word.start + at + 1 + (isQuoted ? 1 : 0);
+  return { name: word.raw.slice(0, at), commands: shellCommandsAt(value, start) };
 }
-
-const ANY = "*";
-const nxOptionPaths = (prefix) => [
-  [...prefix, "command"],
-  [...prefix, "commands", ANY],
-  [...prefix, "commands", ANY, "command"]
-];
-const nxTargetPaths = (prefix) => [
-  [...prefix, ANY, "command"],
-  ...nxOptionPaths([...prefix, ANY, "options"]),
-  ...nxOptionPaths([...prefix, ANY, "configurations", ANY])
-];
-const lintStagedPaths = (prefix) => [
-  [...prefix, ANY],
-  [...prefix, ANY, ANY]
-];
-const simpleGitHooksPaths = (prefix) => [
-  [...prefix, ANY]
-];
-const NX_PROJECT_COMMAND_PATHS = nxTargetPaths(["targets"]);
-const NX_WORKSPACE_COMMAND_PATHS = nxTargetPaths([
-  "targetDefaults"
-]);
-const MANIFEST_COMMAND_PATHS = [
-  ["scripts", ANY],
-  ...simpleGitHooksPaths(["simple-git-hooks"]),
-  ...lintStagedPaths(["lint-staged"]),
-  ...nxTargetPaths(["nx", "targets"])
-];
-const LINT_STAGED_COMMAND_PATHS = lintStagedPaths([]);
-const SIMPLE_GIT_HOOKS_COMMAND_PATHS = simpleGitHooksPaths(
-  []
-);
-const DENO_TASK_PATHS = [
-  ["tasks", ANY],
-  ["tasks", ANY, "command"]
-];
-const matches = (path, pattern) => path.length === pattern.length && pattern.every((part, index) => part === ANY || part === String(path[index]));
-const isCommandPath = (path, patterns) => patterns.some((pattern) => matches(path, pattern));
-
-const NO_LOCATION = "";
-function commandStringSteps(text, strings) {
-  const lineOf = lineLocator(text);
-  return strings.flatMap((found) => {
-    if (found.isModuleSpecifier || PACKAGE_RENAMES.has(found.value)) {
+function dockerVariables(commands) {
+  return commands.flatMap(([instruction, first, ...rest]) => {
+    if (instruction === void 0 || first === void 0) {
       return [];
     }
-    const migrated = migrateCommand(found.value, NO_LOCATION).text;
-    return migrated === found.value ? [] : [{ kind: "command-string", line: lineOf(found.start), to: migrated }];
+    if (!VARIABLE_INSTRUCTIONS.has(instruction.value)) {
+      return [];
+    }
+    if (instruction.value === LEGACY_ENV_INSTRUCTION && !first.raw.includes(ASSIGNMENT)) {
+      return [{ name: first.value, commands: [rest] }];
+    }
+    return [first, ...rest].flatMap((word) => assignedVariable(word) ?? []);
   });
 }
+const definitionOf = ({ name, commands }) => ({
+  name,
+  value: commands.flatMap((words) => words.map((word) => word.raw)).join(" ")
+});
+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 { edits, changes, manualSteps } = commandWordFindings(commands, locate, variables);
+  const steps = [...manualSteps, ...escapedScriptSteps(exec.escaped, lineOf)];
+  return { text: applyTextEdits(text, edits), changes, manualSteps: steps };
+}
 
-function canRunGenerator(definition, generators) {
-  switch (definition.kind) {
-    case "command":
-      return definition.runsGenerator;
-    case "reference":
-      return generators.has(definition.target);
-    case "append":
-      return false;
-    default:
-      return assertNever(definition);
+const CATALOG_PROTOCOL = "catalog:";
+const DEFAULT_CATALOG = "default";
+function catalogOfSpec(spec) {
+  if (!spec.startsWith(CATALOG_PROTOCOL)) {
+    return void 0;
   }
+  return spec.slice(CATALOG_PROTOCOL.length).trim() || DEFAULT_CATALOG;
 }
-function canRunOther(definition, others, defined) {
-  switch (definition.kind) {
-    case "command":
-      return !definition.runsGenerator;
-    case "reference":
-      return others.has(definition.target) || !defined.has(definition.target);
-    case "append":
-      return false;
-    default:
-      return assertNever(definition);
+class CatalogEntries {
+  #keys = /* @__PURE__ */ new Set();
+  add(catalog, name) {
+    this.#keys.add(JSON.stringify([catalog, name]));
   }
-}
-function variablePrograms(definitions) {
-  const defined = new Set(definitions.map((definition) => definition.name));
-  const generators = /* @__PURE__ */ new Set();
-  const others = /* @__PURE__ */ new Set();
-  for (let size = -1; size !== generators.size + others.size; ) {
-    size = generators.size + others.size;
-    for (const definition of definitions) {
-      if (canRunGenerator(definition, generators)) {
-        generators.add(definition.name);
-      }
-      if (canRunOther(definition, others, defined)) {
-        others.add(definition.name);
-      }
-    }
+  has(catalog, name) {
+    return this.#keys.has(JSON.stringify([catalog, name]));
   }
-  const programOf = (name) => {
-    if (!generators.has(name)) {
-      return "other";
-    }
-    return others.has(name) ? "generator-or-other" : "generator";
-  };
-  return new Map([...defined].map((name) => [name, programOf(name)]));
 }
+const NO_CATALOG_PLAN = {
+  inUse: new CatalogEntries(),
+  kept: new CatalogEntries(),
+  defined: new CatalogEntries(),
+  isWorkspaceRoot: false
+};
 
-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);
-  return match === null ? void 0 : match[1] ?? match[2];
+const NPM_PROTOCOL = "npm:";
+const SCOPE_PREFIX$2 = "@";
+const PATH_SEPARATOR$4 = "/";
+const VERSION_SEPARATOR = "@";
+function nameEnd(text) {
+  const searchFrom = text.startsWith(SCOPE_PREFIX$2) ? text.indexOf(PATH_SEPARATOR$4) + 1 : 0;
+  const ends = [VERSION_SEPARATOR, PATH_SEPARATOR$4].map((separator) => text.indexOf(separator, Math.max(searchFrom, 1))).filter((index) => index !== -1);
+  return ends.length === 0 ? text.length : Math.min(...ends);
 }
-function programDefinition({ name, value }) {
-  const target = expandedName(value.trim());
-  if (target !== void 0) {
-    return { name, kind: "reference", target };
+function parseNpmSpec(spec) {
+  if (!spec.startsWith(NPM_PROTOCOL)) {
+    return void 0;
   }
-  return { name, kind: "command", runsGenerator: shellCommands(value).some(runsGenerator) };
+  const body = spec.slice(NPM_PROTOCOL.length);
+  const lead = body.startsWith(PATH_SEPARATOR$4) ? PATH_SEPARATOR$4 : "";
+  const text = body.slice(lead.length);
+  const end = nameEnd(text);
+  const name = text.slice(0, end);
+  if (!text.startsWith(VERSION_SEPARATOR, end)) {
+    return { lead, name, range: void 0, rest: text.slice(end) };
+  }
+  const rangeEnd = text.indexOf(PATH_SEPARATOR$4, end);
+  const restStart = rangeEnd === -1 ? text.length : rangeEnd;
+  return { lead, name, range: text.slice(end + 1, restStart), rest: text.slice(restStart) };
 }
-function shellVariables(definitions) {
-  const values = /* @__PURE__ */ new Map();
-  for (const { name, value } of definitions) {
-    values.set(name, [values.get(name), value].filter((part) => part !== void 0).join(" "));
+function isOldPackageNpmSpec(spec) {
+  const parsed = parseNpmSpec(spec);
+  return parsed !== void 0 && PACKAGE_RENAMES.has(parsed.name);
+}
+function migrateNpmSpec(spec, version) {
+  const parsed = parseNpmSpec(spec);
+  const renamed = parsed === void 0 ? void 0 : PACKAGE_RENAMES.get(parsed.name);
+  if (parsed === void 0 || renamed === void 0) {
+    return void 0;
   }
-  const programs = variablePrograms(definitions.map(programDefinition));
-  const nameAt = (word) => expandedName(word.raw);
-  return {
-    programAt: (program) => {
-      const name = nameAt(program);
-      const found = name === void 0 ? void 0 : programs.get(name);
-      return found === void 0 ? void 0 : { written: program.raw, program: found };
-    },
-    referenceAt: (word) => {
-      const name = nameAt(word);
-      const value = name === void 0 ? void 0 : values.get(name);
-      return value === void 0 ? void 0 : { written: word.raw, value };
+  const head = `${NPM_PROTOCOL}${parsed.lead}${renamed}`;
+  const isDeep = parsed.rest !== "" && parsed.rest !== PATH_SEPARATOR$4;
+  if (parsed.range === void 0) {
+    return { spec: `${head}${parsed.rest}`, isReported: false, isDeep };
+  }
+  const decision = migrateVersionSpec(parsed.range, version);
+  const isReported = decision.kind === "kept" && decision.isReported;
+  const migrated = `${head}${VERSION_SEPARATOR}${decision.spec}${parsed.rest}`;
+  return { spec: migrated, isReported, isDeep };
+}
+
+const SCHEME_SEPARATOR = "://";
+const HIDDEN_USERINFO = "***";
+const USERINFO_END = "@";
+const AUTHORITY_END_RE = /[/?#"'`\s]/;
+function scanAuthority(text, start) {
+  let userinfoEnd = -1;
+  let end = start;
+  for (; end < text.length && !AUTHORITY_END_RE.test(text.charAt(end)); end++) {
+    if (text.charAt(end) === USERINFO_END) {
+      userinfoEnd = end;
+    }
+  }
+  return { end, userinfoEnd };
+}
+function hideUrlCredentials(text) {
+  let hidden = "";
+  let copiedUpTo = 0;
+  for (let found = text.indexOf(SCHEME_SEPARATOR); found !== -1; ) {
+    const start = found + SCHEME_SEPARATOR.length;
+    const { end, userinfoEnd } = scanAuthority(text, start);
+    if (userinfoEnd !== -1) {
+      hidden += `${text.slice(copiedUpTo, start)}${HIDDEN_USERINFO}`;
+      copiedUpTo = userinfoEnd;
     }
-  };
+    found = text.indexOf(SCHEME_SEPARATOR, end);
+  }
+  return `${hidden}${text.slice(copiedUpTo)}`;
 }
 
-const EXEC_FORM_START_RE = /^[ \t]*(?:RUN|CMD|ENTRYPOINT)(?:[ \t]+--\S+)*[ \t]+\[/gm;
-const SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh"]);
-const OPTION_PREFIX = "-";
-const LONG_OPTION_PREFIX = "--";
-const COMMAND_OPTION = "c";
-const SET_OPTION = "-o";
-const PATH_SEPARATOR$1 = "/";
-const ARRAY_BLANK_RE = /(?:[ \t\r\n]|\\\r?\n)*/y;
-const QUOTED_RE = /"(?:[^"\\\n]|\\.)*"/y;
-const ITEM_SEPARATOR = ",";
-const NOT_LINE_BREAK_RE$1 = /[^\n]/g;
-const ARRAY_END = "]";
-const VARIABLE_INSTRUCTIONS = /* @__PURE__ */ new Set(["ARG", "ENV"]);
-const LEGACY_ENV_INSTRUCTION = "ENV";
-const ASSIGNMENT = "=";
-const QUOTES = /* @__PURE__ */ new Set(['"', "'"]);
-function matchAt(pattern, text, index) {
-  pattern.lastIndex = index;
-  return pattern.exec(text)?.[0];
+const newFindings = () => ({ edits: [], changes: [], manualSteps: [] });
+const PEER_FIELD = "peerDependencies";
+const mapLabel = (map) => map.kind === "catalog" ? map.catalog : map.field;
+const renamedKey = (name, map) => map.kind === "imports" ? renamedSpecifier(name)?.to : PACKAGE_RENAMES.get(name);
+function migrateSpec(spec, version) {
+  const npm = migrateNpmSpec(spec, version);
+  if (npm !== void 0) {
+    return { spec: npm.spec, isReported: npm.isReported };
+  }
+  const decision = migrateVersionSpec(spec, version);
+  return { spec: decision.spec, isReported: decision.kind === "kept" && decision.isReported };
 }
-function jsonString(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      return void 0;
-    }
-    throw error;
+function isFree({ from, to, field, names }, findings) {
+  if (names.has(to)) {
+    findings.manualSteps.push({ kind: "name-collision", field, from, to });
+    return false;
   }
+  return true;
 }
-function execFormAt(text, start) {
-  const words = [];
-  let index = start + 1;
-  for (; ; ) {
-    index += matchAt(ARRAY_BLANK_RE, text, index)?.length ?? 0;
-    const raw = matchAt(QUOTED_RE, text, index);
-    if (raw === void 0) {
-      const isEmpty = text[index] === ARRAY_END && words.length === 0;
-      return isEmpty ? { start, end: index + 1, words } : void 0;
-    }
-    const value = jsonString(raw);
-    if (value === void 0) {
-      return void 0;
-    }
-    words.push({ start: index + 1, end: index + raw.length - 1, value, raw: raw.slice(1, -1) });
-    index += raw.length;
-    index += matchAt(ARRAY_BLANK_RE, text, index)?.length ?? 0;
-    if (text[index] === ARRAY_END) {
-      return { start, end: index + 1, words };
-    }
-    if (text[index] !== ITEM_SEPARATOR) {
-      return void 0;
-    }
-    index++;
+function migrateAlias(entry, { map, version, findings }) {
+  const migrated = entry.spec === void 0 ? void 0 : migrateNpmSpec(entry.spec.value, version);
+  if (entry.spec === void 0 || migrated === void 0) {
+    return;
+  }
+  findings.edits.push(entry.spec.replace(migrated.spec));
+  const spec = hideUrlCredentials(migrated.spec);
+  findings.changes.push({ kind: "alias-renamed", field: mapLabel(map), name: entry.name, spec });
+  if (migrated.isReported) {
+    findings.manualSteps.push({ kind: "spec-kept", name: entry.name, spec });
   }
 }
-function execForms(text) {
-  return [...text.matchAll(EXEC_FORM_START_RE)].flatMap((match) => {
-    const form = execFormAt(text, match.index + match[0].length - 1);
-    return form === void 0 ? [] : [form];
-  });
+function renamedChange(map, from, to, spec) {
+  switch (map.kind) {
+    case "dependencies":
+      return { kind: "dependency-renamed", field: map.field, from, to, spec };
+    case "catalog":
+      return { kind: "catalog-entry-renamed", catalog: map.catalog, from, to, spec };
+    case "imports":
+      return { kind: "import-renamed", field: map.field, from, to, target: spec };
+    default:
+      return assertNever(map);
+  }
 }
-function shellScript(words) {
-  const program = words[0]?.value.split(PATH_SEPARATOR$1).at(-1) ?? "";
-  if (!SHELLS.has(program)) {
+function migrateEntry(entry, spec, to, { map, version, findings }) {
+  const old = spec.value;
+  const migrated = migrateSpec(old, version);
+  findings.edits.push(entry.renameKey(to));
+  if (migrated.spec !== old) {
+    findings.edits.push(spec.replace(migrated.spec));
+  }
+  findings.changes.push(renamedChange(map, entry.name, to, hideUrlCredentials(migrated.spec)));
+  if (migrated.isReported) {
+    findings.manualSteps.push({ kind: "spec-kept", name: to, spec: hideUrlCredentials(old) });
+  }
+  if (map.kind === "dependencies" && map.field === PEER_FIELD) {
+    findings.manualSteps.push({ kind: "peer-dependency-renamed", name: to });
+  }
+}
+function catalogHold(entry, spec, { map, catalogs }) {
+  if (map.kind === "catalog") {
+    const isInUse = catalogs.inUse.has(map.name, entry.name);
+    return isInUse ? { kind: "catalog-entry-in-use", catalog: map.catalog, name: entry.name } : void 0;
+  }
+  const catalog = map.kind === "dependencies" ? catalogOfSpec(spec.value) : void 0;
+  if (catalog === void 0) {
     return void 0;
   }
-  let index = 1;
-  for (let option = words[index]?.value; option !== void 0; option = words[index]?.value) {
-    if (!option.startsWith(OPTION_PREFIX)) {
-      return void 0;
-    }
-    if (!option.startsWith(LONG_OPTION_PREFIX) && option.includes(COMMAND_OPTION)) {
-      return words[index + 1];
-    }
-    index += option === SET_OPTION ? 2 : 1;
+  const reference = { field: mapLabel(map), name: entry.name, catalog };
+  if (!catalogs.defined.has(catalog, entry.name)) {
+    const kind = catalogs.isWorkspaceRoot ? "catalog-entry-missing" : "catalog-entry-outside";
+    return { kind, ...reference };
   }
-  return void 0;
+  return catalogs.kept.has(catalog, entry.name) ? { kind: "catalog-reference-kept", ...reference } : void 0;
 }
-function execCommands(forms) {
-  const commands = [];
-  const escaped = [];
-  for (const { words } of forms) {
-    commands.push(words);
-    const script = shellScript(words);
-    if (script !== void 0 && script.raw === script.value) {
-      commands.push(...shellCommandsAt(script.value, script.start));
-    } else if (script !== void 0) {
-      escaped.push(script);
+function localPackageHold(entry, spec, { map }) {
+  return map.kind === "dependencies" && isLocalPackageSpec(spec.value) ? { kind: "local-package", field: map.field, name: entry.name, spec: spec.value } : void 0;
+}
+const holdOf = (entry, spec, context) => localPackageHold(entry, spec, context) ?? catalogHold(entry, spec, context);
+function migrateSpecMap(entries, context) {
+  const names = new Set(entries.map((entry) => entry.name));
+  for (const entry of entries) {
+    const to = renamedKey(entry.name, context.map);
+    const field = mapLabel(context.map);
+    if (to === void 0) {
+      migrateAlias(entry, context);
+      continue;
+    }
+    if (!isFree({ from: entry.name, to, field, names }, context.findings)) {
+      continue;
+    }
+    const hold = entry.spec === void 0 ? void 0 : holdOf(entry, entry.spec, context);
+    if (entry.spec === void 0) {
+      context.findings.manualSteps.push({ kind: "entry-not-edited", field, name: entry.name });
+    } else if (hold !== void 0) {
+      context.findings.manualSteps.push(hold);
+    } else {
+      migrateEntry(entry, entry.spec, to, context);
     }
   }
-  return { commands, escaped };
 }
-function withoutExecForms(text, forms) {
-  const parts = [];
-  let copiedUpTo = 0;
-  for (const { start, end } of forms) {
-    parts.push(
-      text.slice(copiedUpTo, start),
-      text.slice(start, end).replace(NOT_LINE_BREAK_RE$1, " ")
-    );
-    copiedUpTo = end;
+function renameNames(entries, field, findings) {
+  const names = new Set(entries.map((entry) => entry.name));
+  for (const entry of entries) {
+    const to = PACKAGE_RENAMES.get(entry.name);
+    if (to !== void 0 && isFree({ from: entry.name, to, field, names }, findings)) {
+      findings.edits.push(entry.rename(to));
+      findings.changes.push({
+        kind: "package-name-renamed",
+        location: field,
+        from: entry.name,
+        to
+      });
+    }
   }
-  parts.push(text.slice(copiedUpTo));
-  return parts.join("");
 }
-function escapedScriptSteps(scripts, lineOf) {
-  return scripts.flatMap((script) => {
-    const migrated = migrateCommand(script.value, "").text;
-    return migrated === script.value ? [] : [{ kind: "command-string", line: lineOf(script.start), to: migrated }];
+
+const isEditable = (node) => node.kind === "scalar" && node.encode !== void 0;
+const replaceScalar = (scalar, value) => ({
+  start: scalar.start,
+  end: scalar.end,
+  text: scalar.encode(value)
+});
+function specEntries(map) {
+  return textEntries(map).flatMap(({ key, value }) => {
+    if (!isEditable(key)) {
+      return [];
+    }
+    const spec = isEditable(value) ? { value: value.value, replace: (to) => replaceScalar(value, to) } : void 0;
+    return [{ name: key.value, spec, renameKey: (name) => replaceScalar(key, name) }];
   });
 }
-function assignedVariable(word) {
-  const at = word.raw.indexOf(ASSIGNMENT);
-  if (at <= 0) {
-    return void 0;
+function keyEntries(map) {
+  return textEntries(map).map(({ key }) => key).filter(isEditable).map((key) => ({ name: key.value, rename: (name) => replaceScalar(key, name) }));
+}
+function itemEntries(list) {
+  return list.items.filter(isEditable).map((item) => ({ name: item.value, rename: (name) => replaceScalar(item, name) }));
+}
+function nestedKeys(node) {
+  if (node.kind !== "map") {
+    return [];
   }
-  const raw = word.raw.slice(at + 1);
-  const isQuoted = raw.length >= 2 && QUOTES.has(raw[0]) && raw.at(-1) === raw[0];
-  const value = isQuoted ? raw.slice(1, -1) : raw;
-  const start = word.start + at + 1 + (isQuoted ? 1 : 0);
-  return { name: word.raw.slice(0, at), commands: shellCommandsAt(value, start) };
+  return textEntries(node).flatMap(({ key, value }) => [key.value, ...nestedKeys(value)]);
 }
-function dockerVariables(commands) {
-  return commands.flatMap(([instruction, first, ...rest]) => {
-    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)) {
-      return [{ name: first.value, commands: [rest] }];
+
+const IMPORTS_FIELD$1 = "imports";
+const SCOPES_FIELD = "scopes";
+const FIELD_SEPARATOR$2 = ".";
+function migrateImports(config, version, findings) {
+  for (const imports of mapsAt(config, IMPORTS_FIELD$1)) {
+    const map = { kind: "imports", field: IMPORTS_FIELD$1 };
+    migrateSpecMap(specEntries(imports), { map, version, findings, catalogs: NO_CATALOG_PLAN });
+  }
+  for (const scopes of mapsAt(config, SCOPES_FIELD)) {
+    for (const { key, value } of textEntries(scopes)) {
+      if (isMap(value)) {
+        const field = [SCOPES_FIELD, key.value].join(FIELD_SEPARATOR$2);
+        const map = { kind: "imports", field };
+        migrateSpecMap(specEntries(value), { map, version, findings, catalogs: NO_CATALOG_PLAN });
+      }
     }
-    return [first, ...rest].flatMap((word) => assignedVariable(word) ?? []);
+  }
+}
+const PATH_SEPARATOR$3 = "/";
+const SCOPE_PREFIX$1 = "@";
+function importMapKeys(config) {
+  const scoped = mapsAt(config, SCOPES_FIELD).flatMap(textEntries).flatMap(({ value }) => isMap(value) ? [value] : []);
+  return [...mapsAt(config, IMPORTS_FIELD$1), ...scoped].flatMap(textEntries).map(({ key }) => key.value);
+}
+function importMapNames(config) {
+  return importMapKeys(config).map((key) => {
+    const parts = key.split(PATH_SEPARATOR$3);
+    return key.startsWith(SCOPE_PREFIX$1) ? parts.slice(0, 2).join(PATH_SEPARATOR$3) : parts[0] ?? key;
   });
 }
-const definitionOf = ({ name, commands }) => ({
-  name,
-  value: commands.flatMap((words) => words.map((word) => word.raw)).join(" ")
-});
-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 { edits, changes, manualSteps } = commandWordFindings(commands, locate, variables);
-  const steps = [...manualSteps, ...escapedScriptSteps(exec.escaped, lineOf)];
-  return { text: applyTextEdits(text, edits), changes, manualSteps: steps };
+function migrateImportMap(text, read, version) {
+  if (read.kind === "unreadable") {
+    return unreadableConfig(text, read.offset);
+  }
+  const findings = newFindings();
+  for (const config of read.documents.filter(isMap)) {
+    migrateImports(config, version, findings);
+  }
+  const { edits, changes, manualSteps } = findings;
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
 
 const IMPORT_MAP_FIELD = "importMap";
@@ -3488,14 +3479,15 @@ function unrenamedSteps(found, line, dynamic) {
   const to = name === void 0 ? void 0 : PACKAGE_RENAMES.get(name);
   return name === void 0 || to === void 0 ? [] : [{ kind: "old-package-import", line, specifier: found.value, name, to }];
 }
-function migrateModuleSpecifiers(text, strings, version) {
+function migrateModuleSpecifiers(text, strings, version, kept = /* @__PURE__ */ new Set()) {
   const changes = [];
   const manualSteps = [];
   let migrated = "";
   let copiedUpTo = 0;
   const lineOf = lineLocator(text);
   for (const found of distinctStrings(strings)) {
-    const renamed = renamedValue(found.value, version);
+    const isKept = kept.has(packageOfSpecifier(found.value));
+    const renamed = isKept ? void 0 : renamedValue(found.value, version);
     const line = lineOf(found.start);
     const dynamic = found.isModuleSpecifier ? dynamicPackage(found.value) : void 0;
     if (renamed === void 0) {
@@ -3588,6 +3580,80 @@ function migrateJsonCommands(text, strings, patterns) {
   return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
 
+const ASSIGNMENT_RE$1 = /^(?:export[ \t]+)?([A-Za-z_][A-Za-z0-9_-]*)[ \t]*:=[ \t]*(.*)$/gm;
+const STRING_VALUE_RE = /^(?:"((?:[^"\\\n]|\\.)*)"|'([^'\n]*)')(?:[ \t]+#.*)?$/;
+const NAME_VALUE_RE = /^([A-Za-z_][A-Za-z0-9_-]*)(?:[ \t]+#.*)?$/;
+const INTERPOLATION_RE = /\{\{[^\n]*?\}\}/g;
+const VARIABLE_INTERPOLATION_RE = /^[@+-]*\{\{[ \t]*([A-Za-z_][A-Za-z0-9_-]*)[ \t]*\}\}$/;
+const MASK$1 = "_";
+const BLANK = " ";
+const assignmentsOf$1 = (text) => [...text.matchAll(ASSIGNMENT_RE$1)].map((match) => {
+  const written = match[2];
+  const valueStart = match.index + match[0].length - written.length;
+  return { name: match[1], value: written.trim(), start: match.index, valueStart };
+});
+function stringValue(value) {
+  const match = STRING_VALUE_RE.exec(value);
+  return match === null ? void 0 : match[1] ?? match[2];
+}
+function programDefinition({ name, value }) {
+  const target = NAME_VALUE_RE.exec(value)?.[1];
+  if (target !== void 0) {
+    return { name, kind: "reference", target };
+  }
+  const text = stringValue(value);
+  const runs = text !== void 0 && shellCommands(text).some(runsGenerator);
+  return { name, kind: "command", runsGenerator: runs };
+}
+function shellText$1(text, assignments) {
+  const parts = [];
+  let copiedUpTo = 0;
+  for (const { start, valueStart, value } of assignments) {
+    const end = valueStart + value.length;
+    parts.push(text.slice(copiedUpTo, start), BLANK.repeat(end - start));
+    copiedUpTo = end;
+  }
+  parts.push(text.slice(copiedUpTo));
+  return parts.join("").replace(INTERPOLATION_RE, (found) => MASK$1.repeat(found.length));
+}
+function valueCommands({ value, valueStart }) {
+  const inner = stringValue(value);
+  return inner === void 0 ? [] : shellCommandsAt(inner, valueStart + 1);
+}
+function justfileVariables(text, assignments, programs) {
+  const values = /* @__PURE__ */ new Map();
+  for (const { name, value } of assignments) {
+    values.set(name, [values.get(name), stringValue(value) ?? value].join(" ").trim());
+  }
+  const writtenAt = (word) => text.slice(word.start, word.end);
+  const nameAt = (word) => VARIABLE_INTERPOLATION_RE.exec(writtenAt(word))?.[1];
+  return {
+    programAt: (program) => {
+      const name = nameAt(program);
+      const found = name === void 0 ? void 0 : programs.get(name);
+      return found === void 0 ? void 0 : { written: writtenAt(program), program: found };
+    },
+    referenceAt: (word) => {
+      const name = nameAt(word);
+      const value = name === void 0 ? void 0 : values.get(name);
+      return value === void 0 ? void 0 : { written: writtenAt(word), value };
+    }
+  };
+}
+function migrateJustfile(text, file) {
+  const lineOf = lineLocator(text);
+  const assignments = assignmentsOf$1(text);
+  const programs = variablePrograms(assignments.map(programDefinition));
+  const variables = justfileVariables(text, assignments, programs);
+  const commands = [
+    ...shellCommands(shellText$1(text, assignments)),
+    ...assignments.flatMap(valueCommands)
+  ];
+  const locate = (offset) => `${file}:${lineOf(offset)}`;
+  const { edits, changes, manualSteps } = commandWordFindings(commands, locate, variables);
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
+}
+
 const ASSIGNMENT_RE = new RegExp(
   [
     "^(?:[^\\s:#=][^:#=\\n]*:[ \\t]*)?",
@@ -3723,6 +3789,140 @@ function migrateMakefile(text, file) {
   return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
 
+const PARENT_SEPARATOR = ">";
+const PATH_SEPARATOR$2 = "/";
+const SCOPE_PREFIX = "@";
+function overrideTarget(key) {
+  const child = key.split(PARENT_SEPARATOR).at(-1) ?? key;
+  const segments = child.split(PATH_SEPARATOR$2);
+  const isScoped = segments.length > 1 && segments.at(-2)?.startsWith(SCOPE_PREFIX) === true;
+  const name = isScoped ? segments.slice(-2).join(PATH_SEPARATOR$2) : segments.at(-1) ?? child;
+  const versionAt = name.indexOf(SCOPE_PREFIX, 1);
+  return versionAt === -1 ? name : name.slice(0, versionAt);
+}
+function overriddenPackages(keys) {
+  const targets = keys.map(overrideTarget);
+  return [...new Set(targets.filter((target) => PACKAGE_RENAMES.has(target)))];
+}
+
+const PATH_SEPARATOR$1 = ".";
+function catalogMaps(root, prefix = "") {
+  const maps = mapsAt(root, CATALOG_FIELD).map((map) => ({
+    name: DEFAULT_CATALOG,
+    label: `${prefix}${CATALOG_FIELD}`,
+    map
+  }));
+  for (const catalogs of mapsAt(root, NAMED_CATALOGS_FIELD)) {
+    for (const { key, value } of textEntries(catalogs)) {
+      if (isMap(value)) {
+        const label = [prefix + NAMED_CATALOGS_FIELD, key.value].join(PATH_SEPARATOR$1);
+        maps.push({ name: key.value, label, map: value });
+      }
+    }
+  }
+  return maps;
+}
+const manifestCatalogMaps = (manifest) => [
+  ...catalogMaps(manifest),
+  ...mapsAt(manifest, WORKSPACES_FIELD).flatMap(
+    (workspaces) => catalogMaps(workspaces, `${WORKSPACES_FIELD}${PATH_SEPARATOR$1}`)
+  )
+];
+function entriesInUse(manifests) {
+  const inUse = new CatalogEntries();
+  const fields = manifests.flatMap(
+    (manifest) => DEPENDENCY_FIELDS.flatMap((field) => mapsAt(manifest, field))
+  );
+  for (const dependencies of fields) {
+    const entries = specEntries(dependencies);
+    const names = new Set(entries.map((entry) => entry.name));
+    for (const { name, spec } of entries) {
+      const catalog = spec === void 0 ? void 0 : catalogOfSpec(spec.value);
+      const to = PACKAGE_RENAMES.get(name);
+      if (catalog !== void 0 && to !== void 0 && names.has(to)) {
+        inUse.add(catalog, name);
+      }
+    }
+  }
+  return inUse;
+}
+function nestedTexts(node) {
+  if (node.kind !== "map") {
+    return [];
+  }
+  return textEntries(node).flatMap(
+    ({ key, value }) => value.kind === "scalar" ? [{ key: key.value, value: value.value }] : nestedTexts(value)
+  );
+}
+function addOverrideUses(documents, inUse) {
+  const sections = documents.flatMap(
+    (document) => [...OVERRIDE_FIELDS, PNPM_SETTINGS_FIELD].flatMap((field) => valuesAt(document, field))
+  );
+  for (const { key, value } of sections.flatMap(nestedTexts)) {
+    const catalog = catalogOfSpec(value);
+    const name = overrideTarget(key);
+    if (catalog !== void 0 && PACKAGE_RENAMES.has(name)) {
+      inUse.add(catalog, name);
+    }
+  }
+}
+function planCatalogs({
+  manifests,
+  catalogFiles,
+  isWorkspaceRoot
+}) {
+  const inUse = entriesInUse(manifests);
+  addOverrideUses([...manifests, ...catalogFiles], inUse);
+  const kept = new CatalogEntries();
+  const defined = new CatalogEntries();
+  const catalogs = [
+    ...catalogFiles.flatMap((file) => catalogMaps(file)),
+    ...manifests.flatMap(manifestCatalogMaps)
+  ];
+  for (const { name: catalog, map } of catalogs) {
+    const entries = specEntries(map);
+    const names = new Set(entries.map((entry) => entry.name));
+    for (const { name, spec } of entries) {
+      defined.add(catalog, name);
+      const to = PACKAGE_RENAMES.get(name);
+      const stays = spec === void 0 || inUse.has(catalog, name);
+      if (to !== void 0 && !names.has(to) && stays) {
+        kept.add(catalog, name);
+      }
+    }
+  }
+  return { inUse, kept, defined, isWorkspaceRoot };
+}
+
+const PNPM_OVERRIDES = "overrides";
+function isSuccessorAlias(key, value) {
+  const successor = PACKAGE_RENAMES.get(overrideTarget(key));
+  return value.kind === "scalar" && value.value.startsWith(NPM_SPECIFIER_PREFIX) && packageReference(value.value).name === successor;
+}
+function overriddenOldPackages(node) {
+  const names = node.kind === "map" ? textEntries(node).flatMap(
+    ({ key, value }) => isSuccessorAlias(key.value, value) ? [] : [overrideTarget(key.value), ...overriddenOldPackages(value)]
+  ) : documentStrings([node]).map((string) => packageReference(string.value).name);
+  return [...new Set(names.filter((name) => PACKAGE_RENAMES.has(name)))];
+}
+function aliasedIn(node) {
+  if (node.kind !== "map") {
+    return [];
+  }
+  return textEntries(node).flatMap(
+    ({ key, value }) => isSuccessorAlias(key.value, value) ? [overrideTarget(key.value)] : aliasedIn(value)
+  );
+}
+function successorAliasedPackages(root) {
+  const fields = [...OVERRIDE_FIELDS].flatMap((field) => mapsAt(root, field));
+  const pnpm = mapsAt(root, PNPM_SETTINGS_FIELD).flatMap((map) => mapsAt(map, PNPM_OVERRIDES));
+  return [...new Set([...fields, ...pnpm].flatMap(aliasedIn))];
+}
+function aliasedPackagesFor(aliases, filePath) {
+  const applying = aliases.filter(({ path }) => isAtOrAbove(path, filePath));
+  return new Set(applying.flatMap(({ names }) => [...names]));
+}
+
 function oldPackagesNamedBy(node) {
   const values = documentStrings([node]).map((string) => packageReference(string.value).name);
   const names = [...nestedKeys(node).map(overrideTarget), ...values];
@@ -3735,7 +3935,8 @@ function reportSettingSections(settings, file, findings) {
     }
     const field = `${file.prefix}${key.value}`;
     const isOverride = file.overrideSections.has(key.value);
-    for (const name of oldPackagesNamedBy(value)) {
+    const names = isOverride ? overriddenOldPackages(value) : oldPackagesNamedBy(value);
+    for (const name of names) {
       findings.manualSteps.push(
         isOverride ? { kind: "override-names-package", field, name } : { kind: "setting-names-package", field, name }
       );
@@ -3806,7 +4007,18 @@ function migrateBrowserField(manifest, findings) {
     }
   }
 }
+function reportOldPackagePaths(node, prefix, findings) {
+  for (const value of documentStrings([node])) {
+    const name = oldPackageInNodeModules(value.value);
+    const to = name === void 0 ? void 0 : PACKAGE_RENAMES.get(name);
+    if (name !== void 0 && to !== void 0) {
+      const location = [...prefix, ...value.path].join(PATH_SEPARATOR);
+      findings.manualSteps.push({ kind: "old-package-path", location, path: value.value, to });
+    }
+  }
+}
 
+const TYPES_VERSIONS_FIELD = "typesVersions";
 function migrateDependencyFields(manifest, target, findings) {
   for (const field of DEPENDENCY_FIELDS) {
     for (const dependencies of mapsAt(manifest, field)) {
@@ -3852,7 +4064,7 @@ const PNPM_SETTINGS = {
 };
 function reportSettings(manifest, findings) {
   for (const field of OVERRIDE_FIELDS) {
-    for (const name of valuesAt(manifest, field).flatMap(oldPackagesNamedBy)) {
+    for (const name of valuesAt(manifest, field).flatMap(overriddenOldPackages)) {
       findings.manualSteps.push({ kind: "override-names-package", field, name });
     }
   }
@@ -3860,10 +4072,10 @@ function reportSettings(manifest, findings) {
     reportSettingSections(settings, PNPM_SETTINGS, findings);
   }
 }
-function reportOldPeers(manifest, findings) {
+function reportOldPeers(manifest, aliased, findings) {
   const dependencies = new Set(declaredNames(manifest));
   for (const [dependent, { peer, range }] of OLD_PEER_DEPENDENTS) {
-    if (dependencies.has(dependent)) {
+    if (dependencies.has(dependent) && !aliased.has(peer)) {
       findings.manualSteps.push({ kind: "old-peer-needed", dependent, peer, range });
     }
   }
@@ -3875,11 +4087,14 @@ function migrateManifestMap(manifest, target, findings) {
   migrateCatalogs$1(manifest, target, findings);
   migrateSubpathImports(manifest, findings);
   migrateBrowserField(manifest, findings);
+  for (const versions of valuesAt(manifest, TYPES_VERSIONS_FIELD)) {
+    reportOldPackagePaths(versions, [TYPES_VERSIONS_FIELD], findings);
+  }
   reportSettings(manifest, findings);
   for (const jest of valuesAt(manifest, JEST_FIELD)) {
     findings.manualSteps.push(...jestConfigSteps(jest, [JEST_FIELD]));
   }
-  reportOldPeers(manifest, findings);
+  reportOldPeers(manifest, target.aliased ?? /* @__PURE__ */ new Set(), findings);
 }
 function migratePackageManifest(text, read, target) {
   if (read.kind === "unreadable") {
@@ -3914,6 +4129,29 @@ function oldPackagePatchSteps(fileName) {
   return name === void 0 || to === void 0 ? [] : [{ kind: "old-package-patch", name, to }];
 }
 
+const STEP_SHELL_KEY = "shell";
+const COMMAND_LINE_SHELLS = /* @__PURE__ */ new Set([
+  ...["sh", "bash", "dash", "ash", "zsh", "ksh"],
+  ...["pwsh", "powershell", "cmd"]
+]);
+const PATH_SEPARATOR_RE = /[/\\]/;
+const WHITESPACE_RE = /\s+/;
+const shellProgram = (shell) => shell.trim().split(WHITESPACE_RE)[0]?.split(PATH_SEPARATOR_RE).at(-1) ?? "";
+function stepShells(strings) {
+  const stepOf = (path) => JSON.stringify(path.slice(0, -1));
+  const others = new Map(
+    strings.filter((value) => value.path.at(-1) === STEP_SHELL_KEY).filter((value) => !COMMAND_LINE_SHELLS.has(shellProgram(value.value))).map((value) => [stepOf(value.path), value.value])
+  );
+  return (value) => others.get(stepOf(value.path));
+}
+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",
   "script",
@@ -3938,6 +4176,10 @@ const TASKFILE_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "status"
 ]);
 
+const API_DESCRIPTION_KEYS = /* @__PURE__ */ new Set(["openapi", "swagger", "asyncapi"]);
+const isApiDescription = (documents) => documents.some(
+  (root) => isMap(root) && textEntries(root).some(({ key }) => API_DESCRIPTION_KEYS.has(key.value))
+);
 const ENVIRONMENT_KEYS = /* @__PURE__ */ new Set(["env"]);
 const isEnvironmentValue = (value) => value.path.length >= 2 && ENVIRONMENT_KEYS.has(String(value.path.at(-2)));
 function environmentVariables(text, strings) {
@@ -4017,9 +4259,10 @@ function appliedFindings(text, found) {
   };
 }
 function migrateYamlCommands(text, file, strings, keys = YAML_COMMAND_KEYS) {
-  const values = valuesOf(strings, keys);
   const lineOf = lineLocator(text);
   const locate = (offset) => `${file}:${lineOf(offset)}`;
+  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)
@@ -4027,7 +4270,8 @@ function migrateYamlCommands(text, file, strings, keys = YAML_COMMAND_KEYS) {
   const variables = environmentVariables(text, strings);
   return appliedFindings(text, [
     ...shellValues.map((value) => valueFindings(text, value, locate, variables)),
-    commandWordFindings(execFormCommands(text, values.filter(isExecFormItem)), locate)
+    commandWordFindings(execFormCommands(text, values.filter(isExecFormItem)), locate),
+    otherShellFindings(valuesOf(strings, keys), shellOf, locate)
   ]);
 }
 function migrateYamlPathCommands(text, strings, patterns) {
@@ -4115,16 +4359,6 @@ const COMPILER_OPTIONS_FIELD = "compilerOptions";
 const PATHS_FIELD = "paths";
 const TYPES_FIELD = "types";
 const FIELD_SEPARATOR = ".";
-function reportOldPackagePaths(config, findings) {
-  for (const value of documentStrings([config])) {
-    const name = oldPackageInNodeModules(value.value);
-    const to = name === void 0 ? void 0 : PACKAGE_RENAMES.get(name);
-    if (name !== void 0 && to !== void 0) {
-      const location = value.path.join(FIELD_SEPARATOR);
-      findings.manualSteps.push({ kind: "old-package-path", location, path: value.value, to });
-    }
-  }
-}
 function migrateCompilerOptions(options, findings) {
   for (const paths of mapsAt(options, PATHS_FIELD)) {
     const field = [COMPILER_OPTIONS_FIELD, PATHS_FIELD].join(FIELD_SEPARATOR);
@@ -4146,7 +4380,7 @@ function migrateTsconfig(text, read) {
     for (const options of mapsAt(config, COMPILER_OPTIONS_FIELD)) {
       migrateCompilerOptions(options, findings);
     }
-    reportOldPackagePaths(config, findings);
+    reportOldPackagePaths(config, [], findings);
   }
   const { edits, changes, manualSteps } = findings;
   return { text: applyTextEdits(text, edits), changes, manualSteps };
@@ -4215,7 +4449,7 @@ const SHELL_EXTENSIONS = /* @__PURE__ */ new Set([".sh", ".bash", ".zsh"]);
 const MAKEFILE_EXTENSION = ".mk";
 const YAML_EXTENSIONS = /* @__PURE__ */ new Set([".yml", ".yaml"]);
 const MAKEFILE_NAMES = /* @__PURE__ */ new Set(["Makefile", "makefile", "GNUmakefile"]);
-const SHELL_FILE_NAMES = /* @__PURE__ */ new Set(["justfile", "Justfile", ".justfile"]);
+const JUSTFILE_NAMES = /* @__PURE__ */ new Set(["justfile", "Justfile", ".justfile"]);
 const DOCKERFILE_NAMES = /* @__PURE__ */ new Set(["Dockerfile", "Containerfile"]);
 const HUSKY_FOLDER = ".husky/";
 const HUSKY_INTERNALS = ".husky/_/";
@@ -4289,10 +4523,11 @@ function joinedNames(sets) {
 }
 function withNamedImportMaps(declarations, importMaps) {
   const mapNames = new Map(declarations.map(({ path, names }) => [path, names]));
-  return declarations.filter(({ path }) => !importMaps.has(path)).map(({ path, names }) => {
+  return declarations.filter(({ path }) => !importMaps.has(path)).map((declaration) => {
+    const { path, names } = declaration;
     const maps = [...importMaps].filter(([, configs]) => configs.includes(path));
     const named = maps.flatMap(([map]) => mapNames.has(map) ? [mapNames.get(map)] : []);
-    return { path, names: joinedNames([names, ...named]) };
+    return { ...declaration, names: joinedNames([names, ...named]) };
   });
 }
 
@@ -4300,8 +4535,9 @@ const isHuskyHook = (path) => (path.startsWith(HUSKY_FOLDER) || path.includes(`/
 const isDependabotConfig = (path) => [...DEPENDABOT_FILES].some((file) => path === file || path.endsWith(`/${file}`));
 function migrateSource(text, path, context) {
   const strings = context.scanner.scan(text, path);
+  const kept = localPackagesFor(context.manifests, path);
   const migrated = chain(
-    migrateModuleSpecifiers(text, strings, context.version),
+    migrateModuleSpecifiers(text, strings, context.version, kept),
     (renamed) => context.rewriter.rewrite(renamed, path)
   );
   const imports = importedSpecifiers(text, strings);
@@ -4353,18 +4589,24 @@ const COMMAND_CONFIG_KINDS = [
     )
   }
 ];
+const yamlCommandsStep = (path) => (text, read) => read.kind === "read" && isApiDescription(read.documents) ? unchanged(text) : stringsStep((current, strings) => migrateYamlCommands(current, path, strings))(text, read);
+const manifestTarget = ({ version, catalogs, aliases }, path) => ({
+  version,
+  catalogs,
+  aliased: aliasedPackagesFor(aliases, path)
+});
 const FILE_KINDS = [
   {
     matches: (path) => baseName(path) === MANIFEST_FILE,
-    migrate: jsonConfig(({ version, catalogs }) => [
-      (text, read) => migratePackageManifest(text, read, { version, catalogs }),
+    migrate: jsonConfig((context, path) => [
+      (text, read) => migratePackageManifest(text, read, manifestTarget(context, path)),
       jsonCommandsStep(MANIFEST_COMMAND_PATHS)
     ])
   },
   {
     matches: (path) => YAML_MANIFEST_FILES.has(baseName(path)),
-    migrate: yamlConfig(({ version, catalogs }) => [
-      (text, read) => migratePackageManifest(text, read, { version, catalogs }),
+    migrate: yamlConfig((context, path) => [
+      (text, read) => migratePackageManifest(text, read, manifestTarget(context, path)),
       yamlPathCommands(MANIFEST_COMMAND_PATHS)
     ])
   },
@@ -4423,11 +4665,7 @@ const FILE_KINDS = [
   },
   {
     matches: (path) => YAML_EXTENSIONS.has(extensionOf(path)),
-    migrate: whenNamed(
-      yamlConfig((_context, path) => [
-        stringsStep((text, strings) => migrateYamlCommands(text, path, strings))
-      ])
-    )
+    migrate: whenNamed(yamlConfig((_context, path) => [yamlCommandsStep(path)]))
   },
   {
     matches: (path) => DOCKERFILE_NAMES.has(baseName(path)),
@@ -4438,7 +4676,11 @@ const FILE_KINDS = [
     migrate: whenNamed((text, path) => migrateMakefile(text, path))
   },
   {
-    matches: (path) => SHELL_EXTENSIONS.has(extensionOf(path)) || SHELL_FILE_NAMES.has(baseName(path)) || isHuskyHook(path),
+    matches: (path) => JUSTFILE_NAMES.has(baseName(path)),
+    migrate: whenNamed((text, path) => migrateJustfile(text, path))
+  },
+  {
+    matches: (path) => SHELL_EXTENSIONS.has(extensionOf(path)) || isHuskyHook(path),
     migrate: whenNamed((text, path) => migrateCommandLines(text, path))
   }
 ];
@@ -4472,27 +4714,6 @@ function planSourceOf(path, namedImportMaps) {
   return isCatalogFile ? { role: "catalogs", read: readYaml } : void 0;
 }
 
-async function planFile(path, dependencies, target) {
-  const migrate = fileMigrationFor(path, target.importMaps);
-  if (migrate === void 0) {
-    return { kind: "not-migrated" };
-  }
-  const read = await dependencies.files.read(path);
-  if (read.kind === "skipped") {
-    return read;
-  }
-  const { rewriter, scanner, readers } = dependencies;
-  const { version, catalogs, manifests } = target;
-  const context = { version, catalogs, manifests, rewriter, scanner, readers };
-  const migration = migrate(read.text, path, context);
-  const isChanged = migration.text !== read.text;
-  const { changes, manualSteps } = migration;
-  if (isChanged || manualSteps.length > 0) {
-    dependencies.logger.info("file_migrated", { path, isChanged, changes, manualSteps });
-  }
-  const report = { path, isChanged, changes, manualSteps };
-  return { kind: "planned", file: { report, text: isChanged ? migration.text : void 0 } };
-}
 async function readForPlan(path, source, dependencies) {
   const read = await dependencies.files.read(path);
   if (read.kind !== "read") {
@@ -4516,9 +4737,22 @@ function marksWorkspaceRoot(path, roots) {
   return manifests.some((manifest) => valuesAt(manifest, WORKSPACES_FIELD).length > 0);
 }
 const DECLARED_NAMES = { manifest: declaredNames, "import-map": importMapNames, catalogs: void 0 };
+function declarationsOf(path, role, roots) {
+  const names = DECLARED_NAMES[role];
+  if (names === void 0) {
+    return [];
+  }
+  const local = role === "manifest" ? (roots ?? []).flatMap(localPackageNames) : [];
+  return [{ path, names: roots && new Set(roots.flatMap(names)), localPackages: new Set(local) }];
+}
+function aliasesOf(path, roots) {
+  const names = (roots ?? []).flatMap(successorAliasedPackages);
+  return names.length === 0 ? [] : [{ path, names: new Set(names) }];
+}
 async function planProjectTarget(paths, dependencies, version) {
   const documents = { manifest: [], catalogs: [] };
   const manifests = [];
+  const aliases = [];
   let isWorkspaceRoot = false;
   const importMaps = await namedImportMaps(paths, dependencies.files, dependencies.readers);
   for (const path of paths) {
@@ -4531,17 +4765,41 @@ async function planProjectTarget(paths, dependencies, version) {
     if (namesOriginal && source.role !== "import-map") {
       documents[source.role].push(...roots ?? []);
     }
-    const names = DECLARED_NAMES[source.role];
-    if (names !== void 0) {
-      manifests.push({ path, names: roots && new Set(roots.flatMap(names)) });
-    }
+    manifests.push(...declarationsOf(path, source.role, roots));
+    aliases.push(...aliasesOf(path, roots));
   }
   const catalogs = planCatalogs({
     manifests: documents.manifest,
     catalogFiles: documents.catalogs,
     isWorkspaceRoot
   });
-  return { version, catalogs, manifests: withNamedImportMaps(manifests, importMaps), importMaps };
+  const declarations = withNamedImportMaps(manifests, importMaps);
+  return { version, catalogs, manifests: declarations, aliases, importMaps };
+}
+
+async function planFile(path, dependencies, target) {
+  const migrate = fileMigrationFor(path, target.importMaps);
+  if (migrate === void 0) {
+    return { kind: "not-migrated" };
+  }
+  const read = await dependencies.files.read(path);
+  if (read.kind === "skipped") {
+    return read;
+  }
+  const { rewriter, scanner, readers } = dependencies;
+  const { version, catalogs, manifests, aliases } = target;
+  const context = {
+    ...{ version, catalogs, manifests, aliases },
+    ...{ rewriter, scanner, readers }
+  };
+  const migration = migrate(read.text, path, context);
+  const isChanged = migration.text !== read.text;
+  const { changes, manualSteps } = migration;
+  if (isChanged || manualSteps.length > 0) {
+    dependencies.logger.info("file_migrated", { path, isChanged, changes, manualSteps });
+  }
+  const report = { path, isChanged, changes, manualSteps };
+  return { kind: "planned", file: { report, text: isChanged ? migration.text : void 0 } };
 }
 async function planProject(paths, dependencies, version) {
   const files = [];
@@ -4623,6 +4881,7 @@ const OLD_FILE_NOTE$1 = "is a file of openapi-typescript, which is no longer ins
 const FLAGS_IN_VARIABLE_NOTE = "holds old flags of the generator and may serve other commands, so it was kept: rename";
 const NOT_ONLY_GENERATOR_NOTE = "runs openapi-typescript in some of its definitions in this file and another program in others, so the flags after it were kept; where it runs the generator, rename";
 const OLD_NAME_IN_COMMAND_NOTE = "names an old package where the tool cannot tell what runs it (a script name, an argument of a program it does not know), so it was kept: migrate it by hand";
+const SCRIPT_NOT_SHELL_NOTE = "so the tool does not read it as commands: migrate the old package names in it by hand";
 const COMMAND_STRING_NOTE = "a string runs openapi-typescript, so it was kept; change it to";
 function pinnedPackageMessage(step) {
   const successor = PACKAGE_RENAMES.get(step.name) ?? step.name;
@@ -4642,6 +4901,7 @@ const COMMAND_STEP_KINDS = /* @__PURE__ */ new Set([
   "pinned-package",
   "old-package-file",
   "old-name-in-command",
+  "script-not-shell",
   "command-string"
 ]);
 const isCommandStep = (step) => COMMAND_STEP_KINDS.has(step.kind);
@@ -4659,6 +4919,8 @@ function commandStepMessage(step) {
       return `${step.location}: ${step.path} ${OLD_FILE_NOTE$1}`;
     case "old-name-in-command":
       return `${step.location}: "${step.word}" ${OLD_NAME_IN_COMMAND_NOTE}`;
+    case "script-not-shell":
+      return `${step.location}: the step runs with shell: ${step.shell}, ${SCRIPT_NOT_SHELL_NOTE}`;
     case "command-string":
       return `line ${step.line}: ${COMMAND_STRING_NOTE} "${step.to}"`;
     default:
@@ -4732,10 +4994,12 @@ const PATCH_NOTE = "check whether the fix is still needed, then make the patch a
 const PATTERN_NOTE = "is a pattern that names";
 const PATTERN_FIX_NOTE = "where it means the package, make it match";
 const SETTING_NOTE = "remove the setting if it no longer applies, or make it name";
+const LOCAL_PACKAGE_NOTE = "points at a local package, not the npm package, so it and the imports of it were kept: if that package is a copy of the original, move it to";
 const DEEP_TARGET_NOTE = "points at a file inside the package; check that it exists";
 const OLD_PATH_NOTE = "is a path into node_modules of an old package, which is no longer installed:";
 const OLD_PATH_FIX_NOTE = "point it at the files of";
 const renamed = (name) => PACKAGE_RENAMES.get(name) ?? name;
+const localPackageMessage = (step) => `${step.field}: ${step.name} "${step.spec}" ${LOCAL_PACKAGE_NOTE} ${renamed(step.name)}`;
 function oldPeerMessage(step) {
   const { dependent, peer, range } = step;
   const successor = PACKAGE_RENAMES.get(peer) ?? peer;
@@ -4779,6 +5043,8 @@ function packageStepMessage(step) {
       return `${step.name} is a peer dependency: ${PEER_NOTE}`;
     case "spec-kept":
       return `${step.name} kept the spec "${step.spec}": point it at an openapi-typesafe version`;
+    case "local-package":
+      return localPackageMessage(step);
     case "override-names-package":
       return `"${step.field}" names ${step.name}: update or remove that override`;
     case "setting-names-package":
@@ -4817,6 +5083,7 @@ function manualStepMessage(step) {
       return catalogStepMessage(step);
     case "peer-dependency-renamed":
     case "spec-kept":
+    case "local-package":
     case "override-names-package":
     case "setting-names-package":
     case "pattern-names-package":
@@ -5107,8 +5374,8 @@ const createGit = (root) => createGitFileList({
 const dependencies = {
   version: readVersion(),
   cwd: process.cwd(),
-  writeStdout: (text) => process.stdout.write(text),
-  writeStderr: (text) => process.stderr.write(text),
+  writeStdout: createPipeSafeWriter(process.stdout),
+  writeStderr: createPipeSafeWriter(process.stderr),
   inspectRoot: inspectProjectRoot,
   createFiles: (root, logger) => createNodeProjectFiles(root, { git: createGit(root), logger }),
   createLogger,