openapi-typesafe-migrate 1.0.0-rc.2 → 1.0.0-rc.4

package/dist/cli/main.mjs

@@ -1,11 +1,157 @@
-import { mkdtempSync, writeFileSync, mkdirSync, appendFileSync, readFileSync } from 'node:fs';
+import { constants, mkdtempSync, mkdirSync, appendFileSync, openSync, fstatSync, closeSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join, dirname, basename, isAbsolute, relative, sep, resolve } from 'node:path';
+import { win32, posix, join, dirname, isAbsolute, relative, sep, basename, resolve } from 'node:path';
+import { realpath, lstat, stat, access, readFile, writeFile, chmod, rename, rm, readdir } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
-import { realpath, readFile, lstat, writeFile, chmod, rename, rm, readdir } from 'node:fs/promises';
 import ts from '@typescript/typescript6';
+import { Scalar, parseAllDocuments, isScalar as isScalar$1, isSeq, isMap as isMap$1, isNode, CST } from 'yaml';
 import { parseArgs } from 'node:util';
 
+const WINDOWS = "win32";
+const PATH_VARIABLE = "PATH";
+const GIT_NAME = "git";
+const WINDOWS_EXECUTABLE_EXTENSION = ".exe";
+const GIT_FOLDER = ".git";
+const PARENT_FOLDER = "..";
+const PACKAGES_FOLDER = "node_modules";
+const ABSENT_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR", "EACCES", "EPERM"]);
+function isAbsent(error) {
+  return ABSENT_CODES.has(error?.code ?? "");
+}
+async function unlessAbsent(check, absent) {
+  try {
+    return await check();
+  } catch (error) {
+    if (isAbsent(error)) {
+      return absent;
+    }
+    throw error;
+  }
+}
+const pathsOf = (platform) => platform === WINDOWS ? win32 : posix;
+function pathVariable({ environment, platform }) {
+  const name = platform === WINDOWS ? Object.keys(environment).find((key) => key.toUpperCase() === PATH_VARIABLE) : PATH_VARIABLE;
+  return name === void 0 ? "" : environment[name] ?? "";
+}
+function isAtOrUnder(paths, folder, target) {
+  const path = paths.relative(folder, target);
+  return !(path === PARENT_FOLDER || path.startsWith(`${PARENT_FOLDER}${paths.sep}`)) && !paths.isAbsolute(path);
+}
+function isInPackagesFolder(host, path) {
+  const separator = host.platform === WINDOWS ? /[\\/]/ : posix.sep;
+  return path.split(separator).some((segment) => segment.toLowerCase() === PACKAGES_FOLDER);
+}
+async function isTrustedFolder(host, project, folder) {
+  const paths = pathsOf(host.platform);
+  if (!paths.isAbsolute(folder) || isInPackagesFolder(host, folder)) {
+    return false;
+  }
+  const real = await host.fileSystem.realPath(folder);
+  return real !== void 0 && !isAtOrUnder(paths, project, real) && !isInPackagesFolder(host, real);
+}
+async function findGitExecutable(host) {
+  const paths = pathsOf(host.platform);
+  const name = host.platform === WINDOWS ? `${GIT_NAME}${WINDOWS_EXECUTABLE_EXTENSION}` : GIT_NAME;
+  const root = paths.resolve(host.projectRoot);
+  const project = await host.fileSystem.realPath(root) ?? root;
+  for (const folder of pathVariable(host).split(paths.delimiter)) {
+    const candidate = paths.join(folder, name);
+    const isTrusted = await isTrustedFolder(host, project, folder);
+    if (isTrusted && await host.fileSystem.isExecutableFile(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+async function findWorkTree(directory, { platform, fileSystem }, isRepository) {
+  const paths = pathsOf(platform);
+  let folder = paths.resolve(directory);
+  for (; ; ) {
+    const parent = paths.dirname(folder);
+    const hasGit = await fileSystem.hasEntry(paths.join(folder, GIT_FOLDER));
+    if (hasGit && await isRepository(folder, parent)) {
+      return folder;
+    }
+    if (parent === folder) {
+      return void 0;
+    }
+    folder = parent;
+  }
+}
+function createNodeGitFileSystem() {
+  return {
+    isExecutableFile: (path) => unlessAbsent(async () => {
+      const isFile = (await stat(path)).isFile();
+      await access(path, constants.X_OK);
+      return isFile;
+    }, false),
+    hasEntry: (path) => unlessAbsent(async () => {
+      await lstat(path);
+      return true;
+    }, false),
+    realPath: (path) => unlessAbsent(() => realpath(path), void 0)
+  };
+}
+
+const spawnGitProcess = ({ executable, directory, gitArguments, environment }) => new Promise((resolve) => {
+  const child = spawn(executable, [...gitArguments], { cwd: directory, env: environment });
+  const output = [];
+  const errors = [];
+  child.stdout.on("data", (chunk) => output.push(chunk));
+  child.stderr.on("data", (chunk) => errors.push(chunk));
+  child.on("error", (error) => resolve({ kind: "failed", reason: error.message }));
+  child.on("close", (exitCode) => {
+    resolve({
+      kind: "exited",
+      exitCode,
+      output: Buffer.concat(output).toString("utf8"),
+      errors: Buffer.concat(errors).toString("utf8").trim()
+    });
+  });
+});
+const HARDENED_CONFIG = [
+  "-c",
+  "core.fsmonitor=false",
+  "-c",
+  "protocol.allow=never",
+  "-c",
+  "safe.bareRepository=explicit"
+];
+const HARDENED_ENVIRONMENT = {
+  GIT_ALLOW_PROTOCOL: "",
+  GIT_NO_LAZY_FETCH: "1",
+  GIT_TERMINAL_PROMPT: "0"
+};
+const REPOSITORY_VARIABLES = [
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_COMMON_DIR",
+  "GIT_INDEX_FILE",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES"
+];
+const WORK_TREE_VARIABLE = "GIT_WORK_TREE";
+const CEILING_VARIABLE = "GIT_CEILING_DIRECTORIES";
+function hardenedEnvironment(command) {
+  const kept = Object.entries(command.environment).filter(
+    ([name]) => !REPOSITORY_VARIABLES.includes(name.toUpperCase())
+  );
+  const { workTree, ceiling } = command;
+  const forced = {
+    ...workTree === void 0 ? {} : { [WORK_TREE_VARIABLE]: workTree },
+    ...ceiling === void 0 ? {} : { [CEILING_VARIABLE]: ceiling }
+  };
+  return { ...Object.fromEntries(kept), ...forced, ...HARDENED_ENVIRONMENT };
+}
+function hardenedInvocation(command, gitArguments) {
+  return {
+    executable: command.executable,
+    directory: command.directory,
+    gitArguments: [...HARDENED_CONFIG, ...gitArguments],
+    environment: hardenedEnvironment(command)
+  };
+}
+
 const LS_FILES_ARGUMENTS = [
   "ls-files",
   "--cached",
@@ -15,36 +161,13 @@ const LS_FILES_ARGUMENTS = [
   "-z"
 ];
 const CHECK_IGNORE_ARGUMENTS = ["check-ignore", "--quiet", "."];
+const REPOSITORY_CHECK_ARGUMENTS = ["rev-parse", "--git-dir"];
 const IGNORED_EXIT_CODE = 0;
 const NOT_IGNORED_EXIT_CODE = 1;
 const IGNORED_REASON = "the git repository around the folder ignores it";
-const GIT_COMMAND = "git";
-const HARDENED_CONFIG = [
-  "-c",
-  "core.fsmonitor=false",
-  "-c",
-  "safe.bareRepository=explicit"
-];
+const NO_GIT_REASON = "no git executable in an absolute folder of PATH";
 const TRAILING_SLASH_RE = /\/$/;
 const SELF_PATHS = /* @__PURE__ */ new Set(["", "."]);
-function runGit(directory, gitArguments) {
-  return new Promise((resolve) => {
-    const child = spawn(GIT_COMMAND, [...HARDENED_CONFIG, ...gitArguments], { cwd: directory });
-    const output = [];
-    const errors = [];
-    child.stdout.on("data", (chunk) => output.push(chunk));
-    child.stderr.on("data", (chunk) => errors.push(chunk));
-    child.on("error", (error) => resolve({ kind: "failed", reason: error.message }));
-    child.on("close", (exitCode) => {
-      resolve({
-        kind: "exited",
-        exitCode,
-        output: Buffer.concat(output).toString("utf8"),
-        errors: Buffer.concat(errors).toString("utf8").trim()
-      });
-    });
-  });
-}
 function failureReason(run) {
   if (run.kind === "failed") {
     return run.reason;
@@ -54,27 +177,47 @@ function failureReason(run) {
 function listedPaths$1(output) {
   return output.split("\0").map((path) => path.replace(TRAILING_SLASH_RE, "")).filter((path) => !SELF_PATHS.has(path));
 }
-async function listDirectory(directory) {
-  const ignored = await runGit(directory, CHECK_IGNORE_ARGUMENTS);
+async function listWith(command, run) {
+  const ignored = await run(hardenedInvocation(command, CHECK_IGNORE_ARGUMENTS));
   if (ignored.kind === "exited" && ignored.exitCode === IGNORED_EXIT_CODE) {
     return { kind: "unavailable", reason: IGNORED_REASON };
   }
   if (ignored.kind === "failed" || ignored.exitCode !== NOT_IGNORED_EXIT_CODE) {
     return { kind: "unavailable", reason: failureReason(ignored) };
   }
-  const listed = await runGit(directory, LS_FILES_ARGUMENTS);
+  const listed = await run(hardenedInvocation(command, LS_FILES_ARGUMENTS));
   if (listed.kind === "failed" || listed.exitCode !== 0) {
     return { kind: "unavailable", reason: failureReason(listed) };
   }
   return { kind: "listed", paths: listedPaths$1(listed.output) };
 }
-class SpawnedGitFileList {
-  list(directory) {
-    return listDirectory(directory);
+class HardenedGitFileList {
+  #host;
+  #process;
+  /** PATH is searched once, on the first listing. */
+  #executable;
+  constructor(options) {
+    this.#host = options;
+    this.#process = options.process ?? spawnGitProcess;
+  }
+  async list(directory) {
+    this.#executable ??= findGitExecutable(this.#host);
+    const executable = await this.#executable;
+    if (executable === void 0) {
+      return { kind: "unavailable", reason: NO_GIT_REASON };
+    }
+    const { environment } = this.#host;
+    const isRepository = async (folder, ceiling) => {
+      const command = { executable, directory: folder, environment, workTree: void 0, ceiling };
+      const run = await this.#process(hardenedInvocation(command, REPOSITORY_CHECK_ARGUMENTS));
+      return run.kind === "exited" && run.exitCode === 0;
+    };
+    const workTree = await findWorkTree(directory, this.#host, isRepository);
+    return listWith({ executable, directory, environment, workTree }, this.#process);
   }
 }
-function createGitFileList() {
-  return new SpawnedGitFileList();
+function createGitFileList(options) {
+  return new HardenedGitFileList(options);
 }
 
 const LOG_FILE_MODE = 384;
@@ -82,15 +225,39 @@ const TEMPORARY_FOLDER_PREFIX = "openapi-typesafe-migrate-";
 const LOG_EXTENSION = ".jsonl";
 const TIME_SEPARATOR = ":";
 const FILE_NAME_TIME_SEPARATOR = "-";
+class LogPathIsFolderError extends Error {
+  name = "LogPathIsFolderError";
+  constructor(path) {
+    super(`${path} is a folder; --log takes a file path`);
+  }
+}
+const EXCLUSIVE_CREATE_FLAG = "wx";
+const APPEND_FLAG = "a";
+const IS_A_DIRECTORY_CODE = "EISDIR";
+function openLogFile(path, isExclusive) {
+  let descriptor;
+  try {
+    descriptor = openSync(path, isExclusive ? EXCLUSIVE_CREATE_FLAG : APPEND_FLAG, LOG_FILE_MODE);
+  } catch (error) {
+    throw isDirectoryError(error) ? new LogPathIsFolderError(path) : error;
+  }
+  try {
+    if (fstatSync(descriptor).isDirectory()) {
+      throw new LogPathIsFolderError(path);
+    }
+  } finally {
+    closeSync(descriptor);
+  }
+}
+const isDirectoryError = (error) => error instanceof Error && "code" in error && error.code === IS_A_DIRECTORY_CODE;
 class JsonLinesLogger {
   #options;
   constructor(options) {
     this.#options = options;
-    if (options.isExclusive) {
-      writeFileSync(options.path, "", { flag: "wx", mode: LOG_FILE_MODE });
-    } else {
+    if (!options.isExclusive) {
       mkdirSync(dirname(options.path), { recursive: true });
     }
+    openLogFile(options.path, options.isExclusive);
   }
   info(event, fields = {}) {
     this.#append("info", event, fields);
@@ -114,6 +281,101 @@ function createTemporaryLogPath(parent, startTime) {
   return join(folder, `${name}${LOG_EXTENSION}`);
 }
 
+const FILE_NAME = "document.json";
+const QUOTE_LENGTH = 1;
+const encode = (value) => JSON.stringify(value);
+function spanOf$1(node, file) {
+  return { start: node.getStart(file), end: node.end };
+}
+function convertString(node, file) {
+  const span = spanOf$1(node, file);
+  const content = { start: span.start + QUOTE_LENGTH, end: span.end - QUOTE_LENGTH };
+  return { kind: "scalar", value: node.text, content, isFolded: false, encode, ...span };
+}
+function convertObject(node, file) {
+  const entries = node.properties.filter(ts.isPropertyAssignment).map(
+    (property) => ({
+      key: ts.isStringLiteral(property.name) ? convertString(property.name, file) : { kind: "other", ...spanOf$1(property.name, file) },
+      value: convert$1(property.initializer, file)
+    })
+  );
+  return { kind: "map", entries, ...spanOf$1(node, file) };
+}
+function convert$1(node, file) {
+  if (ts.isObjectLiteralExpression(node)) {
+    return convertObject(node, file);
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    const items = node.elements.map((item) => convert$1(item, file));
+    return { kind: "list", items, ...spanOf$1(node, file) };
+  }
+  if (ts.isStringLiteral(node)) {
+    return convertString(node, file);
+  }
+  return { kind: "other", ...spanOf$1(node, file) };
+}
+function firstError(text) {
+  const { error } = ts.parseConfigFileTextToJson(FILE_NAME, text);
+  return error === void 0 ? void 0 : error.start ?? 0;
+}
+function readTree(text) {
+  const errorAt = firstError(text);
+  if (errorAt !== void 0) {
+    return { kind: "unreadable", offset: errorAt };
+  }
+  const file = ts.parseJsonText(FILE_NAME, text);
+  const documents = file.statements.map((statement) => convert$1(statement.expression, file));
+  return { kind: "read", documents };
+}
+function read$1(text) {
+  try {
+    return readTree(text);
+  } catch (error) {
+    if (error instanceof RangeError) {
+      return { kind: "unreadable", offset: void 0 };
+    }
+    throw error;
+  }
+}
+function createJsonTextReader() {
+  return { read: read$1 };
+}
+
+const PARENT_DIRECTORY = "..";
+const UNRESOLVED_PATH_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR", "ELOOP"]);
+function isRelativeDownward(path) {
+  return !isAbsolute(path) && !path.split("/").includes(PARENT_DIRECTORY);
+}
+function isInFolder(folder, target) {
+  const path = relative(folder, target);
+  return path !== "" && path !== PARENT_DIRECTORY && !path.startsWith(`${PARENT_DIRECTORY}${sep}`) && !isAbsolute(path);
+}
+async function entryAt(root, realRoot, path) {
+  if (!isRelativeDownward(path)) {
+    return "outside";
+  }
+  try {
+    const stats = await lstat(join(root, path));
+    const isListable = stats.isFile() || stats.isDirectory();
+    if (!isListable && !stats.isSymbolicLink()) {
+      return "other";
+    }
+    const realPath = await realpath(join(root, path));
+    if (realPath !== realRoot && !isInFolder(realRoot, realPath)) {
+      return "outside";
+    }
+    if (!isListable) {
+      return "other";
+    }
+    return stats.isFile() ? "file" : "directory";
+  } catch (error) {
+    if (UNRESOLVED_PATH_CODES.has(error.code ?? "")) {
+      return "other";
+    }
+    throw error;
+  }
+}
+
 const SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -129,15 +391,35 @@ const CURRENT_DIRECTORY = ".";
 const TEMPORARY_SUFFIX = ".openapi-typesafe-migrate.tmp";
 const PERMISSION_BITS = 4095;
 const TEMPORARY_MODE = 384;
-const PARENT_DIRECTORY = "..";
+const OUTSIDE_ROOT = { kind: "outside-root" };
+const NOT_UTF_8 = { kind: "not-utf-8" };
+const UTF_8 = "utf-8";
+function decodeUtf8(bytes) {
+  try {
+    const text = new TextDecoder(UTF_8, { fatal: true, ignoreBOM: true }).decode(bytes);
+    return { kind: "read", text };
+  } catch (error) {
+    if (error instanceof TypeError) {
+      return { kind: "skipped", reason: NOT_UTF_8 };
+    }
+    throw error;
+  }
+}
+function ioProblem(error) {
+  const code = error?.code;
+  if (typeof code !== "string") {
+    throw error;
+  }
+  return { kind: "io-error", code };
+}
 function isInSkippedDirectory(path) {
   return path.split("/").slice(0, -1).some((directory) => SKIPPED_DIRECTORIES.has(directory));
 }
-async function listTree(root, relative2) {
-  const entries = await readdir(join(root, relative2), { withFileTypes: true });
+async function listTree(root, relative) {
+  const entries = await readdir(join(root, relative), { withFileTypes: true });
   const nested = await Promise.all(
     entries.map((entry) => {
-      const path = relative2 === "" ? entry.name : `${relative2}/${entry.name}`;
+      const path = relative === "" ? entry.name : `${relative}/${entry.name}`;
       if (entry.isDirectory()) {
         return SKIPPED_DIRECTORIES.has(entry.name) ? [] : listTree(root, path);
       }
@@ -146,33 +428,6 @@ async function listTree(root, relative2) {
   );
   return nested.flat();
 }
-function isRelativeDownward(path) {
-  return !isAbsolute(path) && !path.split("/").includes(PARENT_DIRECTORY);
-}
-function isInFolder(folder, target) {
-  const path = relative(folder, target);
-  return path !== "" && path !== PARENT_DIRECTORY && !path.startsWith(`${PARENT_DIRECTORY}${sep}`) && !isAbsolute(path);
-}
-async function entryAt(root, realRoot, path) {
-  if (!isRelativeDownward(path)) {
-    return "outside";
-  }
-  try {
-    const stats = await lstat(join(root, path));
-    if (!stats.isFile() && !stats.isDirectory()) {
-      return "other";
-    }
-    if (!isInFolder(realRoot, await realpath(join(root, path)))) {
-      return "outside";
-    }
-    return stats.isFile() ? "file" : "directory";
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return "other";
-    }
-    throw error;
-  }
-}
 async function listedPaths(root, realRoot, paths) {
   const candidates = paths.filter((path) => !isInSkippedDirectory(path));
   const entries = await Promise.all(candidates.map((path) => entryAt(root, realRoot, path)));
@@ -180,7 +435,7 @@ async function listedPaths(root, realRoot, paths) {
   return {
     files: withEntry("file"),
     directories: withEntry("directory").filter((path) => !SKIPPED_DIRECTORIES.has(baseName$1(path))),
-    skipped: withEntry("outside").map((path) => ({ path, reason: "outside-root" }))
+    skipped: withEntry("outside").map((path) => ({ path, reason: OUTSIDE_ROOT }))
   };
 }
 function baseName$1(path) {
@@ -240,15 +495,31 @@ class NodeProjectFiles {
     return joinLists([{ files, skipped }, ...nested]);
   }
   async read(path) {
-    return readFile(await this.#pathInRoot(path), "utf8");
+    try {
+      const target = await this.#pathInRoot(path);
+      return target === void 0 ? { kind: "skipped", reason: OUTSIDE_ROOT } : decodeUtf8(await readFile(target));
+    } catch (error) {
+      return { kind: "skipped", reason: ioProblem(error) };
+    }
+  }
+  async write(path, text) {
+    try {
+      const target = await this.#pathInRoot(path);
+      if (target === void 0) {
+        return { kind: "failed", reason: OUTSIDE_ROOT };
+      }
+      await this.#replace(target, text, path);
+      return { kind: "written" };
+    } catch (error) {
+      return { kind: "failed", reason: ioProblem(error) };
+    }
   }
   /**
    * Writes a new file and renames it over the old one, so the write never goes through a link: a
    * hard link to a file outside the root keeps its old text, and is reported in the log. The new
    * file keeps the mode of the old one.
    */
-  async write(path, text) {
-    const target = await this.#pathInRoot(path);
+  async #replace(target, text, path) {
     const { mode, nlink } = await lstat(target);
     const temporary = join(dirname(target), `.${basename(target)}${TEMPORARY_SUFFIX}`);
     await writeFile(temporary, text, { encoding: "utf8", flag: "wx", mode: TEMPORARY_MODE });
@@ -263,11 +534,11 @@ class NodeProjectFiles {
       this.#options.logger.warn("hard_link_separated", { path, linkCount: nlink });
     }
   }
-  /** The real path of a project file; refuses one that resolves outside the root. */
+  /** The real path of a project file, or undefined for one that resolves outside the root. */
   async #pathInRoot(path) {
     const realPath = isRelativeDownward(path) ? await realpath(join(this.#root, path)) : void 0;
     if (realPath === void 0 || !isInFolder(await realpath(this.#root), realPath)) {
-      throw new Error(`${path} is outside the project folder ${this.#root}`);
+      return void 0;
     }
     return realPath;
   }
@@ -275,6 +546,17 @@ class NodeProjectFiles {
 function createNodeProjectFiles(root, options) {
   return new NodeProjectFiles(root, options);
 }
+const MISSING_PATH_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR"]);
+async function inspectProjectRoot(root) {
+  try {
+    return (await stat(root)).isDirectory() ? "directory" : "not-a-directory";
+  } catch (error) {
+    if (MISSING_PATH_CODES.has(error.code ?? "")) {
+      return "missing";
+    }
+    throw error;
+  }
+}
 
 function unchanged(text) {
   return { text, changes: [], manualSteps: [] };
@@ -287,80 +569,213 @@ function lineAt(text, offset) {
   }
   return line;
 }
+function lineLocator(text) {
+  const lineStarts = [0];
+  for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) {
+    lineStarts.push(index + 1);
+  }
+  return (offset) => {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low < high) {
+      const middle = Math.ceil((low + high) / 2);
+      if (lineStarts[middle] <= offset) {
+        low = middle;
+      } else {
+        high = middle - 1;
+      }
+    }
+    return low + 1;
+  };
+}
+function columnAt(text, offset) {
+  return offset - text.lastIndexOf("\n", offset - 1);
+}
+
+function applyTextEdits(text, edits) {
+  const sorted = [...edits].sort((left, right) => left.start - right.start);
+  let edited = "";
+  let copiedUpTo = 0;
+  for (const edit of sorted) {
+    if (edit.start < copiedUpTo) {
+      throw new Error(
+        `Edits overlap at offset ${edit.start}; the file was not changed (a migration bug).`
+      );
+    }
+    edited += `${text.slice(copiedUpTo, edit.start)}${edit.text}`;
+    copiedUpTo = edit.end;
+  }
+  return edited + text.slice(copiedUpTo);
+}
 
 const GENERATOR_MODULES = /* @__PURE__ */ new Set(["openapi-typesafe", "openapi-typescript"]);
 const TYPESCRIPT_MODULES = /* @__PURE__ */ new Set(["typescript", "@typescript/typescript6"]);
-function namedImports(clause, into) {
+const DEFAULT_EXPORT$1 = "default";
+function addNamedImports(clause, isGenerator, into) {
   const bindings = clause.namedBindings;
   if (bindings === void 0 || !ts.isNamedImports(bindings)) {
     return;
   }
   for (const element of bindings.elements) {
-    into.set(element.name.text, (element.propertyName ?? element.name).text);
-  }
-}
-function addTypescriptImport(clause, names) {
-  if (clause.name !== void 0) {
-    names.typescriptModules.add(clause.name.text);
-  }
-  const bindings = clause.namedBindings;
-  if (bindings !== void 0 && ts.isNamespaceImport(bindings)) {
-    names.typescriptModules.add(bindings.name.text);
-  }
-  namedImports(clause, names.typescriptImports);
-}
-function addGeneratorImport(clause, names) {
-  if (clause.name !== void 0) {
-    names.generatorFunctions.add(clause.name.text);
+    const name = (element.propertyName ?? element.name).text;
+    const binding = isGenerator ? name === DEFAULT_EXPORT$1 ? { kind: "generator-function" } : { kind: "helper-import", name } : { kind: "typescript-import", name };
+    into.set(element, binding);
   }
-  namedImports(clause, names.helperImports);
 }
-function addImport(statement, names) {
+function addImport(statement, into) {
   const clause = statement.importClause;
-  if (clause === void 0 || !ts.isStringLiteral(statement.moduleSpecifier)) {
+  const specifier = ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : "";
+  const isGenerator = GENERATOR_MODULES.has(specifier);
+  if (clause === void 0 || !isGenerator && !TYPESCRIPT_MODULES.has(specifier)) {
     return;
   }
-  const specifier = statement.moduleSpecifier.text;
-  if (TYPESCRIPT_MODULES.has(specifier)) {
-    addTypescriptImport(clause, names);
-  } else if (GENERATOR_MODULES.has(specifier)) {
-    addGeneratorImport(clause, names);
+  if (clause.name !== void 0) {
+    into.set(clause, isGenerator ? { kind: "generator-function" } : { kind: "typescript-module" });
+  }
+  const namespace = clause.namedBindings;
+  if (namespace !== void 0 && ts.isNamespaceImport(namespace)) {
+    const kind = isGenerator ? "generator-module" : "typescript-module";
+    into.set(namespace, { kind });
   }
+  addNamedImports(clause, isGenerator, into);
 }
-function addConstants(statement, names) {
+function addConstants(statement, into) {
   if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) {
     return;
   }
   for (const declaration of statement.declarationList.declarations) {
-    const initializer = declaration.initializer;
-    if (!ts.isIdentifier(declaration.name) || initializer === void 0) {
-      continue;
-    }
-    names.constants.set(declaration.name.text, initializer);
-    if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
-      names.functions.set(declaration.name.text, initializer);
+    if (ts.isIdentifier(declaration.name) && declaration.initializer !== void 0) {
+      into.set(declaration, { kind: "constant", initializer: declaration.initializer });
     }
   }
 }
-function collectFileNames(file) {
-  const names = {
-    typescriptModules: /* @__PURE__ */ new Set(),
-    typescriptImports: /* @__PURE__ */ new Map(),
-    helperImports: /* @__PURE__ */ new Map(),
-    constants: /* @__PURE__ */ new Map(),
-    generatorFunctions: /* @__PURE__ */ new Set(),
-    functions: /* @__PURE__ */ new Map()
-  };
+function collectBindings(file) {
+  const bindings = /* @__PURE__ */ new Map();
   for (const statement of file.statements) {
     if (ts.isImportDeclaration(statement)) {
-      addImport(statement, names);
+      addImport(statement, bindings);
     } else if (ts.isVariableStatement(statement)) {
-      addConstants(statement, names);
+      addConstants(statement, bindings);
     } else if (ts.isFunctionDeclaration(statement) && statement.name !== void 0) {
-      names.functions.set(statement.name.text, statement);
+      bindings.set(statement, { kind: "function", declaration: statement });
+    }
+  }
+  return bindings;
+}
+function singleFileHost(file) {
+  return {
+    getSourceFile: (name) => name === file.fileName ? file : void 0,
+    getDefaultLibFileName: () => "lib.d.ts",
+    writeFile: () => void 0,
+    getCurrentDirectory: () => "",
+    getCanonicalFileName: (name) => name,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => "\n",
+    fileExists: (name) => name === file.fileName,
+    readFile: () => void 0
+  };
+}
+function createChecker(file) {
+  const options = { noLib: true, noResolve: true, allowJs: true, types: [] };
+  const host = singleFileHost(file);
+  return ts.createProgram({ rootNames: [file.fileName], options, host }).getTypeChecker();
+}
+function symbolOf(checker, identifier) {
+  const parent = identifier.parent;
+  return ts.isShorthandPropertyAssignment(parent) && parent.name === identifier ? checker.getShorthandAssignmentValueSymbol(parent) : checker.getSymbolAtLocation(identifier);
+}
+function isDeclaredName(identifier, declaration) {
+  const declaredName = declaration.name;
+  return declaredName === identifier || ts.findAncestor(identifier, ts.isImportDeclaration) !== void 0;
+}
+function indexUses(file, bindings) {
+  const uses = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    const declaration = ts.isIdentifier(node) ? bindings.declarationOf(node) : void 0;
+    if (declaration !== void 0 && !isDeclaredName(node, declaration)) {
+      uses.set(declaration, [...uses.get(declaration) ?? [], node]);
     }
+    ts.forEachChild(node, visit);
+  };
+  visit(file);
+  return uses;
+}
+class CheckedFileBindings {
+  hasGenerator;
+  #file;
+  #bindings;
+  declarations;
+  #checker;
+  #uses;
+  constructor(file) {
+    this.#file = file;
+    this.#bindings = collectBindings(file);
+    this.declarations = this.#bindings;
+    this.hasGenerator = [...this.#bindings.values()].some(
+      (binding) => binding.kind === "generator-function" || binding.kind === "generator-module"
+    );
+  }
+  declarationOf(identifier) {
+    this.#checker ??= createChecker(this.#file);
+    const declaration = symbolOf(this.#checker, identifier)?.declarations?.[0];
+    return declaration !== void 0 && this.#bindings.has(declaration) ? declaration : void 0;
+  }
+  bindingOf(identifier) {
+    const declaration = this.declarationOf(identifier);
+    return declaration === void 0 ? void 0 : this.#bindings.get(declaration);
+  }
+  usesOf(declaration) {
+    this.#uses ??= indexUses(this.#file, this);
+    return this.#uses.get(declaration) ?? [];
+  }
+}
+function createFileBindings(file) {
+  return new CheckedFileBindings(file);
+}
+
+const DEFAULT_EXPORT = "default";
+function isGenerator(callee, bindings) {
+  if (ts.isIdentifier(callee)) {
+    return bindings.bindingOf(callee)?.kind === "generator-function";
+  }
+  return ts.isPropertyAccessExpression(callee) && callee.name.text === DEFAULT_EXPORT && ts.isIdentifier(callee.expression) && bindings.bindingOf(callee.expression)?.kind === "generator-module";
+}
+function unwrapped(expression) {
+  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) {
+    return unwrapped(expression.expression);
+  }
+  return expression;
+}
+const isExported$1 = (declaration) => (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Export) !== 0;
+function constantOptions(name, bindings) {
+  const binding = bindings.bindingOf(name);
+  const declaration = bindings.declarationOf(name);
+  const value = binding?.kind === "constant" ? unwrapped(binding.initializer) : void 0;
+  if (value === void 0 || !ts.isObjectLiteralExpression(value)) {
+    return { kind: "unknown", expression: name };
+  }
+  const isOwn = bindings.usesOf(declaration).length === 1;
+  return { kind: isOwn && !isExported$1(declaration) ? "own" : "shared", options: value };
+}
+function optionsOf(argument, bindings) {
+  const value = unwrapped(argument);
+  if (ts.isObjectLiteralExpression(value)) {
+    return { kind: "own", options: value };
   }
-  return names;
+  return ts.isIdentifier(value) ? constantOptions(value, bindings) : { kind: "unknown", expression: argument };
+}
+function generatorCalls(file, bindings) {
+  const calls = [];
+  const visit = (node) => {
+    if (ts.isCallExpression(node) && isGenerator(node.expression, bindings)) {
+      const argument = node.arguments[1];
+      const options = argument === void 0 ? void 0 : optionsOf(argument, bindings);
+      calls.push({ call: node, options });
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(file);
+  return calls;
 }
 
 const SCRIPT_KINDS = /* @__PURE__ */ new Map([
@@ -467,22 +882,19 @@ const HELPER_CONSTANTS = /* @__PURE__ */ new Map([
   ["UNKNOWN", "unknown"]
 ]);
 const TYPE_NAME_RE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/;
-const plain = (text) => ({ text, operator: null });
-function factoryMethod(callee, names) {
-  if (!ts.isPropertyAccessExpression(callee)) {
-    return void 0;
+const plain$1 = (text) => ({ text, operator: null });
+function isTypescriptMember(target, member, names) {
+  if (ts.isIdentifier(target)) {
+    const binding = names.bindings.bindingOf(target);
+    return binding?.kind === "typescript-import" && binding.name === member;
   }
-  const target = callee.expression;
-  const isFactory = ts.isIdentifier(target) ? names.typescriptImports.get(target.text) === "factory" : ts.isPropertyAccessExpression(target) && target.name.text === "factory" && ts.isIdentifier(target.expression) && names.typescriptModules.has(target.expression.text);
-  return isFactory ? callee.name.text : void 0;
+  return ts.isPropertyAccessExpression(target) && target.name.text === member && ts.isIdentifier(target.expression) && names.bindings.bindingOf(target.expression)?.kind === "typescript-module";
+}
+function factoryMethod(callee, names) {
+  return ts.isPropertyAccessExpression(callee) && isTypescriptMember(callee.expression, "factory", names) ? callee.name.text : void 0;
 }
 function syntaxKindMember(expression, names) {
-  if (!ts.isPropertyAccessExpression(expression)) {
-    return void 0;
-  }
-  const target = expression.expression;
-  const isSyntaxKind = ts.isIdentifier(target) ? names.typescriptImports.get(target.text) === "SyntaxKind" : ts.isPropertyAccessExpression(target) && target.name.text === "SyntaxKind" && ts.isIdentifier(target.expression) && names.typescriptModules.has(target.expression.text);
-  return isSyntaxKind ? expression.name.text : void 0;
+  return ts.isPropertyAccessExpression(expression) && isTypescriptMember(expression.expression, "SyntaxKind", names) ? expression.name.text : void 0;
 }
 function typeName(argument, names) {
   if (argument === void 0) {
@@ -496,6 +908,18 @@ function typeName(argument, names) {
   }
   return void 0;
 }
+const digits = (digit) => `${digit}(?:_?${digit})*`;
+const DECIMAL_LITERAL = `(?:(?:0|[1-9](?:_?\\d)*)(?:\\.(?:${digits("\\d")})?)?|\\.${digits("\\d")})(?:[eE][+-]?${digits("\\d")})?`;
+const NUMERIC_LITERAL_RE = new RegExp(
+  `^(?:0[xX]${digits("[\\da-fA-F]")}|0[oO]${digits("[0-7]")}|0[bB]${digits("[01]")}|${DECIMAL_LITERAL})$`
+);
+function numericLiteralText(value) {
+  if (ts.isNumericLiteral(value)) {
+    const number = Number(value.text);
+    return Number.isFinite(number) ? String(number) : void 0;
+  }
+  return ts.isStringLiteralLike(value) && NUMERIC_LITERAL_RE.test(value.text) ? value.text : void 0;
+}
 function literalText(argument, names) {
   if (argument === void 0 || !ts.isCallExpression(argument)) {
     return void 0;
@@ -512,7 +936,7 @@ function literalText(argument, names) {
     case "createStringLiteral":
       return value !== void 0 && ts.isStringLiteralLike(value) ? JSON.stringify(value.text) : void 0;
     case "createNumericLiteral":
-      return value !== void 0 && (ts.isNumericLiteral(value) || ts.isStringLiteralLike(value)) ? String(Number(value.text)) : void 0;
+      return value === void 0 ? void 0 : numericLiteralText(value);
     default:
       return void 0;
   }
@@ -535,15 +959,15 @@ function factoryCallText(call, method, names) {
   switch (method) {
     case "createTypeReferenceNode": {
       const name = second === void 0 ? typeName(first, names) : void 0;
-      return name === void 0 ? void 0 : plain(name);
+      return name === void 0 ? void 0 : plain$1(name);
     }
     case "createKeywordTypeNode": {
       const keyword = first === void 0 ? void 0 : KEYWORDS.get(syntaxKindMember(first, names) ?? "");
-      return keyword === void 0 ? void 0 : plain(keyword);
+      return keyword === void 0 ? void 0 : plain$1(keyword);
     }
     case "createLiteralTypeNode": {
       const literal = literalText(first, names);
-      return literal === void 0 ? void 0 : plain(literal);
+      return literal === void 0 ? void 0 : plain$1(literal);
     }
     case "createUnionTypeNode":
       return joined(first, "|", names);
@@ -551,7 +975,7 @@ function factoryCallText(call, method, names) {
       return joined(first, "&", names);
     case "createArrayTypeNode": {
       const element = first === void 0 ? void 0 : typeTextOf(first, names);
-      return element === void 0 ? void 0 : plain(element.operator ? `(${element.text})[]` : `${element.text}[]`);
+      return element === void 0 ? void 0 : plain$1(element.operator ? `(${element.text})[]` : `${element.text}[]`);
     }
     default:
       return void 0;
@@ -561,20 +985,25 @@ function helperCallText(call, names) {
   if (!ts.isIdentifier(call.expression)) {
     return void 0;
   }
-  const helper = names.helperImports.get(call.expression.text);
+  const binding = names.bindings.bindingOf(call.expression);
+  const helper = binding?.kind === "helper-import" ? binding.name : void 0;
   if (helper === "tsUnion") {
     return joined(call.arguments[0], "|", names);
   }
   return helper === "tsIntersection" ? joined(call.arguments[0], "&", names) : void 0;
 }
 function identifierText(identifier, names) {
-  const helper = names.helperImports.get(identifier.text);
-  const constant = helper === void 0 ? void 0 : HELPER_CONSTANTS.get(helper);
-  if (constant !== void 0) {
-    return plain(constant);
+  const declaration = names.bindings.declarationOf(identifier);
+  const binding = names.bindings.bindingOf(identifier);
+  if (binding?.kind === "helper-import") {
+    const constant = HELPER_CONSTANTS.get(binding.name);
+    return constant === void 0 ? void 0 : plain$1(constant);
   }
-  const initializer = names.constants.get(identifier.text);
-  return initializer === void 0 ? void 0 : typeTextOf(initializer, names);
+  if (binding?.kind !== "constant" || names.following.has(declaration)) {
+    return void 0;
+  }
+  const following = /* @__PURE__ */ new Set([...names.following, declaration]);
+  return typeTextOf(binding.initializer, { ...names, following });
 }
 function typeTextOf(expression, names) {
   if (ts.isParenthesizedExpression(expression)) {
@@ -644,6 +1073,112 @@ 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":
+    case "typescript-import":
+    case "helper-import":
+      return true;
+    case "constant":
+      return !isExported(node) && typeTextOf(binding.initializer, names) !== void 0;
+    default:
+      return false;
+  }
+}
+const isInside = (node, ranges) => ranges.some((range) => node.getStart() >= range.start && node.getEnd() <= range.end);
+function unusedDeclarations(names, replaced) {
+  const ranges = replaced.filter((edit) => edit.end > edit.start);
+  const removed = [];
+  for (let isChanged = true; isChanged; ) {
+    isChanged = false;
+    for (const [node, binding] of names.bindings.declarations) {
+      const uses = names.bindings.usesOf(node);
+      const isUnused = uses.length > 0 && uses.every((use) => isInside(use, ranges));
+      const isNew = removed.every((found) => found.node !== node);
+      if (isNew && isUnused && isRemovable(node, binding, names)) {
+        const name = node.name?.getText() ?? "";
+        removed.push({ node, name });
+        ranges.push({ start: node.getStart(), end: node.getEnd() });
+        isChanged = true;
+      }
+    }
+  }
+  return removed;
+}
+function statementRemoval(statement, text) {
+  const start = statement.getStart(void 0, true);
+  const end = statement.getEnd();
+  const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+  const lineBreak = text.indexOf("\n", end);
+  const lineEnd = lineBreak === -1 ? text.length : lineBreak + 1;
+  const isAlone = text.slice(lineStart, start).trim() === "" && text.slice(end, lineEnd).trim() === "";
+  return isAlone ? { start: lineStart, end: lineEnd, text: "" } : { start, end, text: "" };
+}
+function listRemovals(elements, isRemoved) {
+  const lastKept = elements.findLastIndex((element) => !isRemoved(element));
+  const edits = [];
+  elements.forEach((element, index) => {
+    const next = elements[index + 1];
+    if (index < lastKept && isRemoved(element) && next !== void 0) {
+      edits.push({ start: element.getStart(), end: next.getStart(), text: "" });
+    }
+  });
+  const last = elements.at(-1);
+  if (lastKept !== -1 && last !== void 0 && lastKept < elements.length - 1) {
+    edits.push({ start: elements[lastKept].getEnd(), end: last.getEnd(), text: "" });
+  }
+  return edits;
+}
+function importEdits(statement, isRemoved, text) {
+  const clause = statement.importClause;
+  const bindings = clause.namedBindings;
+  const named = bindings !== void 0 && ts.isNamedImports(bindings) ? bindings : void 0;
+  const namespace = bindings !== void 0 && ts.isNamespaceImport(bindings) ? bindings : void 0;
+  const parts = [
+    ...clause.name === void 0 ? [] : [clause],
+    ...namespace === void 0 ? [] : [namespace],
+    ...named?.elements ?? []
+  ];
+  if (parts.every(isRemoved)) {
+    return [statementRemoval(statement, text)];
+  }
+  const defaultEnd = clause.name?.getEnd() ?? 0;
+  const edits = [];
+  if (clause.name !== void 0 && isRemoved(clause)) {
+    edits.push({ start: clause.name.getStart(), end: bindings.getStart(), text: "" });
+  }
+  if (namespace !== void 0 && isRemoved(namespace)) {
+    edits.push({ start: defaultEnd, end: namespace.getEnd(), text: "" });
+  }
+  if (named !== void 0 && named.elements.length > 0 && named.elements.every(isRemoved)) {
+    edits.push({ start: defaultEnd, end: named.getEnd(), text: "" });
+  } else if (named !== void 0) {
+    edits.push(...listRemovals(named.elements, isRemoved));
+  }
+  return edits;
+}
+function statementEdits(statement, isRemoved, text) {
+  if (ts.isImportDeclaration(statement)) {
+    return importEdits(statement, isRemoved, text);
+  }
+  const declarations = statement.declarationList.declarations;
+  return declarations.every(isRemoved) ? [statementRemoval(statement, text)] : listRemovals(declarations, isRemoved);
+}
+function removalEdits(removed, text) {
+  const nodes = new Set(removed.map((found) => found.node));
+  const isRemoved = (node) => nodes.has(node);
+  const statements = new Set(
+    removed.map(
+      (found) => ts.findAncestor(
+        found.node,
+        (node) => ts.isVariableStatement(node) || ts.isImportDeclaration(node)
+      )
+    )
+  );
+  return [...statements].flatMap((statement) => statementEdits(statement, isRemoved, text));
+}
+
 const TRANSFORM = "transform";
 const LEGACY_ONLY_CALLBACKS = ["postTransform", "transformProperty"];
 const IR_CALLBACKS_OPTION = "irCallbacks";
@@ -653,6 +1188,14 @@ function propertyNamed(options, name) {
     return key !== void 0 && (ts.isIdentifier(key) || ts.isStringLiteral(key)) && key.text === name;
   });
 }
+function namedFunction(name, names) {
+  const binding = names.bindings.bindingOf(name);
+  if (binding?.kind === "function") {
+    return binding.declaration;
+  }
+  const value = binding?.kind === "constant" ? binding.initializer : void 0;
+  return value !== void 0 && (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) ? value : void 0;
+}
 function callbackFunction(property, names) {
   if (ts.isMethodDeclaration(property)) {
     return property;
@@ -662,17 +1205,16 @@ function callbackFunction(property, names) {
   }
   const value = property.initializer;
   if (ts.isIdentifier(value)) {
-    return names.functions.get(value.text);
+    return namedFunction(value, names);
   }
   return ts.isArrowFunction(value) || ts.isFunctionExpression(value) ? value : void 0;
 }
-function isSharedFunction(property, text) {
+function isSharedFunction(property, names) {
   if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.initializer)) {
     return false;
   }
-  const name = property.initializer.text.replaceAll("$", "\\$");
-  const uses = text.match(new RegExp(`(?<![\\w$])${name}(?![\\w$])`, "g")) ?? [];
-  return uses.length > 2;
+  const declaration = names.bindings.declarationOf(property.initializer);
+  return declaration !== void 0 && names.bindings.usesOf(declaration).length > 1;
 }
 function returnTypeEdits(callback, text) {
   const type = callback.type;
@@ -687,7 +1229,7 @@ function transformEdits(property, names, text) {
   if (callback?.body === void 0) {
     return "not-a-function";
   }
-  if (isSharedFunction(property, text)) {
+  if (isSharedFunction(property, names)) {
     return "shared-function";
   }
   const edits = returnTypeEdits(callback, text);
@@ -741,35 +1283,66 @@ function migrateOptions(options, text, names) {
   findings.changes.push({ kind: "transform-rewritten", line });
   return findings;
 }
-function generatorOptions(node, names) {
-  if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
-    return void 0;
+function sharedOptionsFindings(options, text) {
+  const findings = { edits: [], changes: [], manualSteps: [] };
+  if (propertyNamed(options, IR_CALLBACKS_OPTION) !== void 0) {
+    return findings;
+  }
+  findings.manualSteps.push(...legacyCallbackSteps(options, text));
+  const transform = propertyNamed(options, TRANSFORM);
+  if (transform !== void 0) {
+    const line = lineAt(text, transform.getStart());
+    findings.manualSteps.push({ kind: "transform-not-rewritten", line, reason: "shared-options" });
   }
-  const options = node.arguments[1];
-  const isGenerator = names.generatorFunctions.has(node.expression.text);
-  return isGenerator && options !== void 0 && ts.isObjectLiteralExpression(options) ? options : void 0;
+  return findings;
 }
-function applyEdits(text, edits) {
-  return [...edits].sort((left, right) => right.start - left.start).reduce(
-    (result, edit) => result.slice(0, edit.start) + edit.text + result.slice(edit.end),
-    text
-  );
+function callFindings(found, text, names) {
+  const options = found.options;
+  switch (options?.kind) {
+    case void 0:
+      return { edits: [], changes: [], manualSteps: [] };
+    case "own":
+      return migrateOptions(options.options, text, names);
+    case "shared":
+      return sharedOptionsFindings(options.options, text);
+    case "unknown": {
+      const line = lineAt(text, options.expression.getStart());
+      return { edits: [], changes: [], manualSteps: [{ kind: "options-not-inspected", line }] };
+    }
+  }
 }
 function findCallFindings(file, text, names) {
   const all = { edits: [], changes: [], manualSteps: [] };
-  const visit = (node) => {
-    const options = generatorOptions(node, names);
+  const seen = /* @__PURE__ */ new Set();
+  for (const found of generatorCalls(file, names.bindings)) {
+    const options = found.options?.kind === "unknown" ? void 0 : found.options?.options;
+    if (options !== void 0 && seen.has(options)) {
+      continue;
+    }
     if (options !== void 0) {
-      const found = migrateOptions(options, text, names);
-      all.edits.push(...found.edits);
-      all.changes.push(...found.changes);
-      all.manualSteps.push(...found.manualSteps);
+      seen.add(options);
     }
-    ts.forEachChild(node, visit);
-  };
-  visit(file);
+    const findings = callFindings(found, text, names);
+    all.edits.push(...findings.edits);
+    all.changes.push(...findings.changes);
+    all.manualSteps.push(...findings.manualSteps);
+  }
   return all;
 }
+function rewriteFile(file, names) {
+  const text = file.text;
+  const { edits, changes, manualSteps } = findCallFindings(file, text, names);
+  const removed = unusedDeclarations(names, edits);
+  for (const found of removed) {
+    changes.push({
+      kind: "declaration-removed",
+      line: lineAt(text, found.node.getStart()),
+      name: found.name
+    });
+  }
+  const allEdits = [...edits, ...removalEdits(removed, text)];
+  return { text: applyTextEdits(text, allEdits), changes, manualSteps };
+}
 class TypescriptCallbackRewriter {
   rewrite(text, path) {
     const scriptKind = plainScriptKind(path);
@@ -777,12 +1350,11 @@ class TypescriptCallbackRewriter {
       return unchanged(text);
     }
     const file = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, scriptKind);
-    const names = collectFileNames(file);
-    if (names.generatorFunctions.size === 0) {
+    const bindings = createFileBindings(file);
+    if (!bindings.hasGenerator) {
       return unchanged(text);
     }
-    const { edits, changes, manualSteps } = findCallFindings(file, text, names);
-    return { text: applyEdits(text, edits), changes, manualSteps };
+    return rewriteFile(file, { bindings, following: /* @__PURE__ */ new Set() });
   }
 }
 function createTypescriptCallbackRewriter() {
@@ -853,15 +1425,18 @@ function isModuleSpecifier(literal) {
   }
   return ts.isExternalModuleReference(parent);
 }
+function stringValue(node, file) {
+  return ts.isTemplateExpression(node) ? file.text.slice(node.getStart(file) + 1, node.getEnd() - 1) : node.text;
+}
 function collectStrings(root, file, offset, found) {
   const visit = (node) => {
-    if (ts.isStringLiteralLike(node)) {
+    if (ts.isStringLiteralLike(node) || ts.isTemplateExpression(node)) {
       const start = offset + node.getStart(file) + 1;
       const end = offset + node.getEnd() - 1;
       found.set(start, {
         start,
         end,
-        value: node.text,
+        value: stringValue(node, file),
         isModuleSpecifier: isModuleSpecifier(node)
       });
     }
@@ -932,12 +1507,166 @@ function createTypescriptStringScanner() {
   return new TypescriptSourceStringScanner();
 }
 
+const plain = (value) => value;
+const singleQuoted$1 = (value) => `'${value.replaceAll("'", "''")}'`;
+const doubleQuoted$1 = (value) => JSON.stringify(value);
+const QUOTINGS = {
+  [Scalar.PLAIN]: [plain, singleQuoted$1, doubleQuoted$1],
+  [Scalar.QUOTE_SINGLE]: [singleQuoted$1, doubleQuoted$1],
+  [Scalar.QUOTE_DOUBLE]: [doubleQuoted$1]
+};
+function readsBack(written, value, isFlow) {
+  const [document] = parseAllDocuments(isFlow ? `[${written}]` : `- ${written}`);
+  const list = document?.contents;
+  const item = isSeq(list) && list.items.length === 1 ? list.items[0] : void 0;
+  return document?.errors.length === 0 && isScalar$1(item) && item.value === value;
+}
+function encoderFor(quotings, isFlow) {
+  return (value) => quotings.map((quoting) => quoting(value)).find((text) => readsBack(text, value, isFlow)) ?? doubleQuoted$1(value);
+}
+function blockContent(token) {
+  const headerLength = token.props.reduce((length, prop) => length + CST.stringify(prop).length, 0);
+  const start = token.offset + headerLength;
+  return { start, end: start + token.source.trimEnd().length };
+}
+function contentRange(token, node) {
+  switch (token?.type) {
+    case "scalar":
+      return { start: token.offset, end: token.offset + token.source.length };
+    case "single-quoted-scalar":
+    case "double-quoted-scalar":
+      return { start: token.offset + 1, end: token.offset + token.source.length - 1 };
+    case "block-scalar":
+      return blockContent(token);
+    default:
+      return node;
+  }
+}
+function spanOf(node) {
+  const [start, end] = node.range ?? [0, 0];
+  return { start, end };
+}
+function scalarText(node) {
+  if (typeof node.value === "string") {
+    return node.value;
+  }
+  const isWritten = node.type === Scalar.PLAIN && node.value !== null;
+  return isWritten ? node.source : void 0;
+}
+function convertScalar(node, isFlow) {
+  const span = spanOf(node);
+  const value = scalarText(node);
+  if (value === void 0) {
+    return { kind: "other", ...span };
+  }
+  const quotings = node.type === void 0 ? void 0 : QUOTINGS[node.type];
+  const isReplaceable = quotings !== void 0 && node.anchor === void 0 && node.tag === void 0;
+  return {
+    kind: "scalar",
+    value,
+    content: contentRange(node.srcToken, span),
+    isFolded: node.type !== Scalar.BLOCK_LITERAL,
+    encode: isReplaceable ? encoderFor(quotings, isFlow) : void 0,
+    ...span
+  };
+}
+const flowOf = (conversion, node) => ({
+  isFlow: conversion.isFlow || node.flow === true
+});
+function convert(node, conversion) {
+  if (isScalar$1(node)) {
+    return convertScalar(node, conversion.isFlow);
+  }
+  if (isSeq(node)) {
+    const inner = flowOf(conversion, node);
+    return { kind: "list", items: node.items.map((item) => convert(item, inner)), ...spanOf(node) };
+  }
+  if (isMap$1(node)) {
+    const inner = flowOf(conversion, node);
+    const entries = node.items.map((pair) => ({
+      key: convert(pair.key, inner),
+      value: convert(pair.value, inner)
+    }));
+    return { kind: "map", entries, ...spanOf(node) };
+  }
+  return { kind: "other", ...spanOf(isNode(node) ? node : {}) };
+}
+function duplicateKeyOffset(node) {
+  if (isSeq(node)) {
+    return firstOffset(node.items);
+  }
+  if (!isMap$1(node)) {
+    return void 0;
+  }
+  const keys = /* @__PURE__ */ new Set();
+  for (const pair of node.items) {
+    if (isScalar$1(pair.key) && keys.has(pair.key.value)) {
+      return spanOf(pair.key).start;
+    }
+    keys.add(isScalar$1(pair.key) ? pair.key.value : pair.key);
+  }
+  return firstOffset(node.items.flatMap((pair) => [pair.key, pair.value]));
+}
+function firstOffset(nodes) {
+  for (const node of nodes) {
+    const offset = duplicateKeyOffset(node);
+    if (offset !== void 0) {
+      return offset;
+    }
+  }
+  return void 0;
+}
+const YAML_PARSE_OPTIONS = { keepSourceTokens: true, uniqueKeys: false };
+function read(text) {
+  const documents = parseAllDocuments(text, YAML_PARSE_OPTIONS);
+  const error = documents.flatMap((document) => document.errors)[0];
+  if (error !== void 0) {
+    return { kind: "unreadable", offset: error.pos[0] };
+  }
+  const duplicate = firstOffset(documents.map((document) => document.contents));
+  if (duplicate !== void 0) {
+    return { kind: "unreadable", offset: duplicate };
+  }
+  const roots = documents.flatMap(
+    (document) => document.contents === null ? [] : [convert(document.contents, { isFlow: false })]
+  );
+  return { kind: "read", documents: roots };
+}
+function createYamlTextReader() {
+  return { read };
+}
+
+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) || DEFAULT_CATALOG;
+}
+class CatalogEntries {
+  #keys = /* @__PURE__ */ new Set();
+  add(catalog, name) {
+    this.#keys.add(JSON.stringify([catalog, name]));
+  }
+  has(catalog, name) {
+    return this.#keys.has(JSON.stringify([catalog, name]));
+  }
+}
+const NO_CATALOG_PLAN = {
+  inUse: new CatalogEntries(),
+  kept: new CatalogEntries()
+};
+
 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([
@@ -953,71 +1682,328 @@ const DEPENDENCY_FIELDS = [
   "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", "pnpm"];
 const OLD_PEER_DEPENDENTS = /* @__PURE__ */ new Map([
   ["swr-openapi", { peer: "openapi-fetch", range: ">=0.15" }]
 ]);
-
-const COMMAND_RE = new RegExp(`(?<=^|[\\s"'\`;&|(])${GENERATOR_COMMAND}(?=$|[\\s"'\`;&|)])`, "g");
-const VERSIONED_COMMAND_RE = new RegExp(`(?<=^|[\\s"'\`;&|(])${GENERATOR_COMMAND}@`);
-const MIGRATED_COMMAND_RE = new RegExp(
-  `(?<=^|[\\s"'\`;&|(])${MIGRATED_GENERATOR_COMMAND}(?=$|[\\s"'\`;&|)])`
-);
-const FLAG_RE = new RegExp(`(?<=\\s)(${[...FLAG_RENAMES.keys()].join("|")})(?=$|[\\s=])`, "g");
-function renameFlags(text, location, changes) {
-  if (!MIGRATED_COMMAND_RE.test(text)) {
-    return text;
-  }
-  return text.replace(FLAG_RE, (flag) => {
-    const renamed = FLAG_RENAMES.get(flag);
-    changes.push({ kind: "flag-renamed", location, from: flag, to: renamed });
-    return renamed;
-  });
+const PATH_SEPARATOR$7 = "/";
+function renamedSpecifier(value) {
+  const slash = value.indexOf(PATH_SEPARATOR$7);
+  const name = slash === -1 ? value : value.slice(0, slash);
+  const renamed = PACKAGE_RENAMES.get(name);
+  if (renamed === void 0) {
+    return void 0;
+  }
+  const subpath = value.slice(name.length);
+  return { to: `${renamed}${subpath}`, isDeep: subpath !== "" && subpath !== PATH_SEPARATOR$7 };
 }
-function migrateCommand(text, location) {
-  const changes = [];
-  const manualSteps = [];
-  if (VERSIONED_COMMAND_RE.test(text)) {
-    manualSteps.push({ kind: "versioned-command", location });
+
+const isMap = (node) => node?.kind === "map";
+const isScalar = (node) => node.kind === "scalar";
+function textEntries(map) {
+  return map.entries.flatMap(({ key, value }) => isScalar(key) ? [{ key, value }] : []);
+}
+function valuesAt(map, key) {
+  return textEntries(map).filter((entry) => entry.key.value === key).map((entry) => entry.value);
+}
+function mapsAt(map, key) {
+  return valuesAt(map, key).filter(isMap);
+}
+function stringsBelow(node, path) {
+  switch (node.kind) {
+    case "scalar":
+      return [{ ...node, path }];
+    case "list":
+      return node.items.flatMap((item, index) => stringsBelow(item, [...path, index]));
+    case "map":
+      return textEntries(node).flatMap(
+        ({ key, value }) => stringsBelow(value, [...path, key.value])
+      );
+    default:
+      return [];
   }
-  const renamed = text.replace(COMMAND_RE, () => {
-    changes.push({ kind: "command-renamed", location });
-    return MIGRATED_GENERATOR_COMMAND;
-  });
-  return { text: renameFlags(renamed, location, changes), changes, manualSteps };
 }
-function migrateCommandLines(text, file) {
-  const changes = [];
-  const manualSteps = [];
-  const lines = text.split("\n").map((line, index) => {
-    const migrated = migrateCommand(line, `${file}:${index + 1}`);
-    changes.push(...migrated.changes);
-    manualSteps.push(...migrated.manualSteps);
-    return migrated.text;
-  });
-  return { text: lines.join("\n"), changes, manualSteps };
+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 PARENT_SEPARATOR = ">";
-const PATH_SEPARATOR = "/";
-const SCOPE_PREFIX = "@";
+const PATH_SEPARATOR$6 = "/";
+const SCOPE_PREFIX$2 = "@";
 function overrideTarget(key) {
   const child = key.split(PARENT_SEPARATOR).at(-1) ?? key;
-  const segments = child.split(PATH_SEPARATOR);
-  const isScoped = segments.length > 1 && segments.at(-2)?.startsWith(SCOPE_PREFIX) === true;
-  const name = isScoped ? segments.slice(-2).join(PATH_SEPARATOR) : segments.at(-1) ?? child;
-  const versionAt = name.indexOf(SCOPE_PREFIX, 1);
+  const segments = child.split(PATH_SEPARATOR$6);
+  const isScoped = segments.length > 1 && segments.at(-2)?.startsWith(SCOPE_PREFIX$2) === true;
+  const name = isScoped ? segments.slice(-2).join(PATH_SEPARATOR$6) : segments.at(-1) ?? child;
+  const versionAt = name.indexOf(SCOPE_PREFIX$2, 1);
   return versionAt === -1 ? name : name.slice(0, versionAt);
 }
-function keysOf(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+function overriddenPackages(keys) {
+  const targets = keys.map(overrideTarget);
+  return [...new Set(targets.filter((target) => PACKAGE_RENAMES.has(target)))];
+}
+
+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 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 [];
   }
-  return Object.entries(value).flatMap(([key, nested]) => [key, ...keysOf(nested)]);
+  return textEntries(node).flatMap(({ key, value }) => [key.value, ...nestedKeys(value)]);
 }
-function overriddenPackages(value) {
-  const targets = keysOf(value).map(overrideTarget);
-  return [...new Set(targets.filter((target) => PACKAGE_RENAMES.has(target)))];
+
+const PATH_SEPARATOR$5 = ".";
+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$5);
+        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$5}`)
+  )
+];
+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.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 }) {
+  const inUse = entriesInUse(manifests);
+  addOverrideUses([...manifests, ...catalogFiles], inUse);
+  const kept = 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) {
+      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 };
+}
+
+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$4 = "/";
+function namesUninstalledPackage(text) {
+  return [...NO_LONGER_INSTALLED.keys()].some(
+    (name) => text.includes(name) || text.includes(ORIGINAL_NAMES.get(name) ?? name)
+  );
+}
+const directoryOf = (path) => path.slice(0, path.lastIndexOf(PATH_SEPARATOR$4) + 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 packageOfSpecifier = (specifier) => {
+  const slash = specifier.indexOf(PATH_SEPARATOR$4);
+  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 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 "";
+  }
+  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;
+  }
+  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 };
+  }
+  return { kind: "replaced", spec: `${style}${version}` };
+}
+
+const NPM_PROTOCOL = "npm:";
+const SCOPE_PREFIX$1 = "@";
+const PATH_SEPARATOR$3 = "/";
+const VERSION_SEPARATOR = "@";
+function nameEnd(text) {
+  const searchFrom = text.startsWith(SCOPE_PREFIX$1) ? text.indexOf(PATH_SEPARATOR$3) + 1 : 0;
+  const ends = [VERSION_SEPARATOR, PATH_SEPARATOR$3].map((separator) => text.indexOf(separator, Math.max(searchFrom, 1))).filter((index) => index !== -1);
+  return ends.length === 0 ? text.length : Math.min(...ends);
+}
+function parseNpmSpec(spec) {
+  if (!spec.startsWith(NPM_PROTOCOL)) {
+    return void 0;
+  }
+  const body = spec.slice(NPM_PROTOCOL.length);
+  const lead = body.startsWith(PATH_SEPARATOR$3) ? PATH_SEPARATOR$3 : "";
+  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$3, end);
+  const restStart = rangeEnd === -1 ? text.length : rangeEnd;
+  return { lead, name, range: text.slice(end + 1, restStart), rest: text.slice(restStart) };
+}
+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$3;
+  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 = "://";
@@ -1032,140 +2018,1121 @@ function scanAuthority(text, start) {
       userinfoEnd = end;
     }
   }
-  return { end, userinfoEnd };
+  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 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 isFree({ from, to, field, names }, findings) {
+  if (names.has(to)) {
+    findings.manualSteps.push({ kind: "name-collision", field, from, to });
+    return false;
+  }
+  return true;
+}
+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 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 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;
+  return catalog !== void 0 && catalogs.kept.has(catalog, entry.name) ? { kind: "catalog-reference-kept", field: map.field, name: entry.name, catalog } : void 0;
+}
+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 = "imports";
+const SCOPES_FIELD = "scopes";
+const FIELD_SEPARATOR = ".";
+function migrateImports(config, version, findings) {
+  for (const imports of mapsAt(config, IMPORTS_FIELD)) {
+    const map = { kind: "imports", field: IMPORTS_FIELD };
+    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);
+        const map = { kind: "imports", field };
+        migrateSpecMap(specEntries(value), { map, version, findings, catalogs: NO_CATALOG_PLAN });
+      }
+    }
+  }
+}
+const PATH_SEPARATOR$2 = "/";
+const SCOPE_PREFIX = "@";
+function importMapKeys(config) {
+  const scoped = mapsAt(config, SCOPES_FIELD).flatMap(textEntries).flatMap(({ value }) => isMap(value) ? [value] : []);
+  return [...mapsAt(config, IMPORTS_FIELD), ...scoped].flatMap(textEntries).map(({ key }) => key.value);
+}
+function importMapNames(config) {
+  return importMapKeys(config).map((key) => {
+    const parts = key.split(PATH_SEPARATOR$2);
+    return key.startsWith(SCOPE_PREFIX) ? parts.slice(0, 2).join(PATH_SEPARATOR$2) : 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 { 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
+});
+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),
+  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),
+  launcher(["pnpm"], NONE, PACKAGE_MANAGER_OPTIONS),
+  launcher(["yarn"], NONE, PACKAGE_MANAGER_OPTIONS),
+  launcher(["node"], NONE, /* @__PURE__ */ new Set(["-r", "--require", "--import", "--loader", "--env-file"])),
+  launcher(["cross-env"]),
+  launcher(["dotenv"], NONE, /* @__PURE__ */ new Set(["-e", "-c", "-v"])),
+  launcher(["env"], NONE, /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"])),
+  launcher(["exec"]),
+  launcher(["time"]),
+  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"]),
+  ...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 = (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(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(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 COMMAND_SEPARATORS = /* @__PURE__ */ new Set([";", "&", "|", "(", ")", "`", "\n"]);
+const WORD_BREAKS = /* @__PURE__ */ new Set([" ", "	", "\r", "<", ">"]);
+const BACKSLASH$1 = "\\";
+const COMMENT = "#";
+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 { end: Math.min(index + 1, text.length), value };
+}
+const isLineContinuation = (text, index) => text[index] === BACKSLASH$1 && (text[index + 1] === "\n" || text.startsWith("\r\n", index + 1));
+function wordPart(text, index) {
+  const char = text[index];
+  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 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) };
+}
+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 topLevelCommands(text) {
+  const commands = [[]];
+  let index = 0;
+  while (index < text.length) {
+    const afterTrivia = skipTrivia(text, index);
+    if (afterTrivia !== index) {
+      index = afterTrivia;
+    } else if (COMMAND_SEPARATORS.has(text[index])) {
+      commands.push([]);
+      index++;
+    } else {
+      const word = readWord(text, index);
+      commands.at(-1)?.push(word);
+      index = word.end;
+    }
+  }
+  return commands.filter((words) => words.length > 0);
+}
+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;
+}
+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);
+}
+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 shifted = (words, offset) => words.map((word) => ({ ...word, start: word.start + offset, end: word.end + offset }));
+function shellCommandsAt(text, offset) {
+  return shellCommands(text).map((words) => shifted(words, offset));
+}
+function shellCommands(text) {
+  const commands = [];
+  for (const command of topLevelCommands(text).map(simpleCommand)) {
+    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((words) => shifted(words, word.start + 1));
+        commands.push(...nested);
+      }
+    }
+  }
+  return commands;
+}
+
+const QUOTES$1 = /* @__PURE__ */ new Set(["'", '"']);
+const PATH_SEPARATOR$1 = "/";
+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 { start: word.start + at, end: word.start + at + name.length, text: to };
+}
+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 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 } }];
+  }
+  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 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 programFindings(word, location) {
+  if (word.value.includes(PATH_SEPARATOR$1)) {
+    return programPathFindings(word, location);
+  }
+  const { name, isPinned } = packageReference(word.value);
+  if (name !== GENERATOR_COMMAND) {
+    return [];
+  }
+  if (isPinned) {
+    return [{ offset: word.start, manualStep: { kind: "versioned-command", location } }];
+  }
+  const edit = renameAtEnd(word, GENERATOR_COMMAND, MIGRATED_GENERATOR_COMMAND);
+  const change = { kind: "command-renamed", location };
+  return edit === void 0 ? [] : [{ offset: word.start, edit, change }];
+}
+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 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 NO_VARIABLES = {
+  programAt: () => void 0,
+  referenceAt: () => void 0
+};
+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 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 oldFlagsOf = (findings) => findings.flatMap(({ change, manualStep }) => {
+  if (change?.kind === "flag-renamed") {
+    return [change.from];
+  }
+  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 [];
+  }
+  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 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;
+  }
+  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;
+  }
+  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);
+}
+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 migrateShellText(text, locate) {
+  const { edits, changes, manualSteps } = shellTextFindings(text, locate);
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
+}
+function migrateCommand(text, location) {
+  return migrateShellText(text, () => location);
+}
+function migrateCommandLines(text, file) {
+  const lineOf = lineLocator(text);
+  return migrateShellText(text, (offset) => `${file}:${lineOf(offset)}`);
+}
+
+const NO_LOCATION = "";
+function commandStringSteps(text, strings) {
+  const lineOf = lineLocator(text);
+  return strings.flatMap((found) => {
+    if (found.isModuleSpecifier || PACKAGE_RENAMES.has(found.value)) {
+      return [];
+    }
+    const migrated = migrateCommand(found.value, NO_LOCATION).text;
+    return migrated === found.value ? [] : [{ kind: "command-string", line: lineOf(found.start), to: migrated }];
+  });
+}
+
+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);
+  }
+}
+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);
+  }
+}
+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);
+      }
+    }
+  }
+  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 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 programDefinition({ name, value }) {
+  const target = expandedName(value.trim());
+  if (target !== void 0) {
+    return { name, kind: "reference", target };
+  }
+  return { name, kind: "command", runsGenerator: shellCommands(value).some(runsGenerator) };
+}
+function shellVariables(definitions) {
+  const values = /* @__PURE__ */ new Map();
+  for (const { name, value } of definitions) {
+    values.set(name, [values.get(name), value].filter((part) => part !== void 0).join(" "));
+  }
+  const programs = variablePrograms(definitions.map(programDefinition));
+  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 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 = "/";
+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];
+}
+function jsonString(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+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 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 shellScript(words) {
+  const program = words[0]?.value.split(PATH_SEPARATOR).at(-1) ?? "";
+  if (!SHELLS.has(program)) {
+    return void 0;
+  }
+  let index = 1;
+  for (let option = words[index]?.value; option !== void 0; option = words[index]?.value) {
+    if (!option.startsWith(OPTION_PREFIX)) {
+      return void 0;
+    }
+    if (!option.startsWith(LONG_OPTION_PREFIX) && option.includes(COMMAND_OPTION)) {
+      return words[index + 1];
+    }
+    index += option === SET_OPTION ? 2 : 1;
+  }
+  return void 0;
+}
+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 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 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 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) };
+}
+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] }];
+    }
+    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 };
+}
+
+const ANY = "*";
+const PACKAGE_SCRIPT_PATHS = [["scripts", ANY]];
+const NX_COMMAND_PATHS = [
+  ["targets", ANY, "command"],
+  ["targets", ANY, "options", "command"],
+  ["targets", ANY, "options", "commands", ANY],
+  ["targets", ANY, "options", "commands", ANY, "command"]
+];
+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]));
+function migrateJsonCommands(text, strings, patterns) {
+  const changes = [];
+  const manualSteps = [];
+  const edits = [];
+  for (const found of strings.filter((string) => patterns.some((p) => matches(string.path, p)))) {
+    const migrated = migrateCommand(found.value, found.path.join("."));
+    changes.push(...migrated.changes);
+    manualSteps.push(...migrated.manualSteps);
+    if (migrated.text !== found.value) {
+      edits.push({ start: found.start, end: found.end, text: JSON.stringify(migrated.text) });
+    }
+  }
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
+}
+
+const ASSIGNMENT_RE = new RegExp(
+  [
+    "^(?:[^\\s:#=][^:#=\\n]*:[ \\t]*)?",
+    "(?:(?:export|override|private)[ \\t]+)*",
+    "([A-Za-z_][A-Za-z0-9_.-]*)",
+    "[ \\t]*(:::=|::=|:=|\\?=|\\+=|!=|=)"
+  ].join(""),
+  "gm"
+);
+const VARIABLE_REFERENCE_RE = /^\$(?:\(([A-Za-z_][A-Za-z0-9_.-]*)\)|\{([A-Za-z_][A-Za-z0-9_.-]*)\}|([A-Za-z_]))$/;
+const RECIPE_PREFIX_RE = /^[@+-]+/;
+const DOLLAR = "$";
+const CLOSING = { "(": ")", "{": "}" };
+const NOT_LINE_BREAK_RE = /[^\n]/g;
+const MASK = "_";
+const LINE_BREAK = "\n";
+const BACKSLASH = "\\";
+function expansionEnd(text, start) {
+  const open = text[start + 1] ?? "";
+  const close = CLOSING[open];
+  if (close === void 0) {
+    return void 0;
+  }
+  let depth = 0;
+  for (let index = start + 1; index < text.length; index++) {
+    if (text[index] === open) {
+      depth++;
+    } else if (text[index] === close && --depth === 0) {
+      return index + 1;
+    }
+  }
+  return void 0;
 }
-function hideUrlCredentials(text) {
-  let hidden = "";
+function maskExpansions(text) {
+  const parts = [];
   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;
+  for (let index = text.indexOf(DOLLAR); index !== -1; index = text.indexOf(DOLLAR, index + 1)) {
+    if (text[index + 1] === DOLLAR) {
+      index++;
+      continue;
+    }
+    const end = expansionEnd(text, index);
+    if (end !== void 0) {
+      parts.push(text.slice(copiedUpTo, index + 1), MASK.repeat(end - index - 1));
+      copiedUpTo = end;
+      index = end - 1;
     }
-    found = text.indexOf(SCHEME_SEPARATOR, end);
   }
-  return `${hidden}${text.slice(copiedUpTo)}`;
+  parts.push(text.slice(copiedUpTo));
+  return parts.join("");
 }
-
-const VERSION_STYLE_RE = /^([\^~]|>=)?\d/;
-const KEPT_PROTOCOLS = ["catalog:", "workspace:"];
-function migrateVersionSpec(spec, version) {
-  if (KEPT_PROTOCOLS.some((protocol) => spec.startsWith(protocol))) {
-    return { kind: "kept", spec, isReported: false };
+const APPEND_OPERATOR = "+=";
+function logicalLineEnd(text, index) {
+  let end = text.indexOf(LINE_BREAK, index);
+  while (end !== -1 && text[end - 1] === BACKSLASH) {
+    end = text.indexOf(LINE_BREAK, end + 1);
   }
-  const style = VERSION_STYLE_RE.exec(spec);
-  if (style === null) {
-    return { kind: "kept", spec, isReported: true };
+  return end === -1 ? text.length : end;
+}
+const assignmentsOf = (text) => [...text.matchAll(ASSIGNMENT_RE)].map((match) => {
+  const valueStart = match.index + match[0].length;
+  const valueEnd = logicalLineEnd(text, valueStart);
+  const name = match[1];
+  const isAppend = match[2] === APPEND_OPERATOR;
+  return { name, isAppend, start: match.index, valueStart, valueEnd };
+});
+function withoutAssignmentHeads(text, assignments) {
+  const parts = [];
+  let copiedUpTo = 0;
+  for (const { start, valueStart } of assignments) {
+    parts.push(
+      text.slice(copiedUpTo, start),
+      text.slice(start, valueStart).replace(NOT_LINE_BREAK_RE, " ")
+    );
+    copiedUpTo = valueStart;
   }
-  const prefix = style[1] === ">=" ? "^" : style[1] ?? "";
-  return { kind: "replaced", spec: `${prefix}${version}` };
+  parts.push(text.slice(copiedUpTo));
+  return parts.join("");
+}
+function referencedName(written) {
+  const match = VARIABLE_REFERENCE_RE.exec(written.trim().replace(RECIPE_PREFIX_RE, ""));
+  return match === null ? void 0 : match[1] ?? match[2] ?? match[3];
+}
+function programDefinitions(text, commands, assignments) {
+  const generatorStarts = commands.filter(runsGenerator).map((command) => command[0].start);
+  return assignments.map(({ name, isAppend, valueStart, valueEnd }) => {
+    if (isAppend) {
+      return { name, kind: "append" };
+    }
+    const target = referencedName(text.slice(valueStart, valueEnd));
+    if (target !== void 0) {
+      return { name, kind: "reference", target };
+    }
+    const runs = generatorStarts.some((start) => valueStart <= start && start < valueEnd);
+    return { name, kind: "command", runsGenerator: runs };
+  });
+}
+function variableValues(text, assignments) {
+  const values = /* @__PURE__ */ new Map();
+  for (const { name, valueStart, valueEnd } of assignments) {
+    const value = text.slice(valueStart, valueEnd);
+    values.set(name, [values.get(name), value].filter((part) => part !== void 0).join(" "));
+  }
+  return values;
+}
+function makefileVariables(text, assignments, programs) {
+  const values = variableValues(text, assignments);
+  const nameAt = (word) => referencedName(text.slice(word.start, word.end));
+  const variables = {
+    programAt: (program) => {
+      const name = nameAt(program);
+      const found = name === void 0 ? void 0 : programs.get(name);
+      const written = text.slice(program.start, program.end);
+      return found === void 0 ? void 0 : { written, program: found };
+    },
+    referenceAt: (word) => {
+      const name = nameAt(word);
+      const value = name === void 0 ? void 0 : values.get(name);
+      const written = text.slice(word.start, word.end);
+      return value === void 0 ? void 0 : { written, value };
+    }
+  };
+  return variables;
+}
+function migrateMakefile(text, file) {
+  const lineOf = lineLocator(text);
+  const assignments = assignmentsOf(text);
+  const commands = shellCommands(withoutAssignmentHeads(maskExpansions(text), assignments));
+  const programs = variablePrograms(programDefinitions(text, commands, assignments));
+  const locate = (offset) => `${file}:${lineOf(offset)}`;
+  const variables = makefileVariables(text, assignments, programs);
+  const { edits, changes, manualSteps } = commandWordFindings(commands, locate, variables);
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
 
-const INDENT_RE = /^[ \t]+(?=")/m;
-const DEFAULT_INDENT = "  ";
-const LF = "\n";
-const CRLF = "\r\n";
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function formatLike(original, manifest) {
-  const indent = INDENT_RE.exec(original)?.[0] ?? DEFAULT_INDENT;
-  const lineEnding = original.includes(CRLF) ? CRLF : LF;
-  const finalNewline = original.endsWith(LF) ? lineEnding : "";
-  return `${JSON.stringify(manifest, null, indent).replaceAll(LF, lineEnding)}${finalNewline}`;
-}
-function renameDependencies(field, dependencies, version, findings) {
-  return Object.fromEntries(
-    Object.entries(dependencies).map(([name, spec]) => {
-      const renamed = PACKAGE_RENAMES.get(name);
-      if (renamed === void 0 || typeof spec !== "string") {
-        return [name, spec];
-      }
-      const decision = migrateVersionSpec(spec, version);
-      findings.changes.push({
-        kind: "dependency-renamed",
-        field,
-        from: name,
-        to: renamed,
-        spec: hideUrlCredentials(decision.spec)
-      });
-      if (decision.kind === "kept" && decision.isReported) {
-        findings.manualSteps.push({
-          kind: "spec-kept",
-          name: renamed,
-          spec: hideUrlCredentials(spec)
-        });
-      }
-      if (field === "peerDependencies") {
-        findings.manualSteps.push({ kind: "peer-dependency-renamed", name: renamed });
+function migrateDependencyFields(manifest, target, findings) {
+  for (const field of DEPENDENCY_FIELDS) {
+    for (const dependencies of mapsAt(manifest, field)) {
+      const map = { kind: "dependencies", field };
+      migrateSpecMap(specEntries(dependencies), { ...target, map, findings });
+    }
+  }
+}
+function migrateNameKeys(manifest, findings) {
+  for (const field of NAME_KEYED_FIELDS) {
+    for (const meta of mapsAt(manifest, field)) {
+      renameNames(keyEntries(meta), field, findings);
+      const versioned = textEntries(meta).map(({ key }) => key.value).filter((key) => !PACKAGE_RENAMES.has(key));
+      for (const name of overriddenPackages(versioned)) {
+        findings.manualSteps.push({ kind: "override-names-package", field, name });
       }
-      return [renamed, decision.spec];
-    })
-  );
+    }
+  }
 }
-function migrateScripts(scripts, findings) {
-  return Object.fromEntries(
-    Object.entries(scripts).map(([name, script]) => {
-      if (typeof script !== "string") {
-        return [name, script];
+function migrateNameLists(manifest, findings) {
+  for (const field of NAME_LIST_FIELDS) {
+    for (const list of valuesAt(manifest, field)) {
+      if (list.kind === "list") {
+        renameNames(itemEntries(list), field, findings);
       }
-      const migrated = migrateCommand(script, `scripts.${name}`);
-      findings.changes.push(...migrated.changes);
-      findings.manualSteps.push(...migrated.manualSteps);
-      return [name, migrated.text];
-    })
-  );
+    }
+  }
+}
+function migrateCatalogs$1(manifest, target, findings) {
+  for (const { name, label, map } of manifestCatalogMaps(manifest)) {
+    const context = {
+      ...target,
+      map: { kind: "catalog", catalog: label, name },
+      findings
+    };
+    migrateSpecMap(specEntries(map), context);
+  }
 }
 function reportOverrides(manifest, findings) {
   for (const field of OVERRIDE_FIELDS) {
-    for (const name of overriddenPackages(manifest[field])) {
+    const keys = valuesAt(manifest, field).flatMap(nestedKeys);
+    for (const name of overriddenPackages(keys)) {
       findings.manualSteps.push({ kind: "override-names-package", field, name });
     }
   }
 }
 function reportOldPeers(manifest, findings) {
+  const dependencies = new Set(declaredNames(manifest));
   for (const [dependent, { peer, range }] of OLD_PEER_DEPENDENTS) {
-    const isDependency = DEPENDENCY_FIELDS.some((field) => {
-      const dependencies = manifest[field];
-      return isObject(dependencies) && Object.hasOwn(dependencies, dependent);
-    });
-    if (isDependency) {
+    if (dependencies.has(dependent)) {
       findings.manualSteps.push({ kind: "old-peer-needed", dependent, peer, range });
     }
   }
 }
-function migrateFields(manifest, version, findings) {
-  const migrated = { ...manifest };
-  for (const field of DEPENDENCY_FIELDS) {
-    const dependencies = manifest[field];
-    if (isObject(dependencies)) {
-      migrated[field] = renameDependencies(field, dependencies, version, findings);
-    }
-  }
-  if (isObject(manifest.scripts)) {
-    migrated.scripts = migrateScripts(manifest.scripts, findings);
-  }
+function migrateManifestMap(manifest, target, findings) {
+  migrateDependencyFields(manifest, target, findings);
+  migrateNameKeys(manifest, findings);
+  migrateNameLists(manifest, findings);
+  migrateCatalogs$1(manifest, target, findings);
   reportOverrides(manifest, findings);
   reportOldPeers(manifest, findings);
-  return migrated;
 }
-function migratePackageManifest(text, version) {
-  let manifest;
-  try {
-    manifest = JSON.parse(text);
-  } catch (error) {
-    const reason = hideUrlCredentials(error instanceof Error ? error.message : String(error));
-    return { ...unchanged(text), manualSteps: [{ kind: "manifest-unreadable", reason }] };
+function migratePackageManifest(text, read, target) {
+  if (read.kind === "unreadable") {
+    return unreadableConfig(text, read.offset);
   }
-  if (!isObject(manifest)) {
-    return unchanged(text);
+  const findings = newFindings();
+  for (const manifest of read.documents.filter(isMap)) {
+    migrateManifestMap(manifest, target, findings);
   }
-  const findings = { changes: [], manualSteps: [] };
-  const migrated = migrateFields(manifest, version, findings);
-  const isChanged = findings.changes.length > 0;
-  return { text: isChanged ? formatLike(text, migrated) : text, ...findings };
+  const { edits, changes, manualSteps } = findings;
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
+}
+function unreadManifest(text) {
+  return namesOriginalPackage(text) ? { ...unchanged(text), manualSteps: [{ kind: "manifest-not-read" }] } : unchanged(text);
 }
 
 const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -1181,44 +3148,66 @@ const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".svelte",
   ".astro"
 ]);
-function renamedValue(value) {
-  const slash = value.indexOf("/");
-  const name = slash === -1 ? value : value.slice(0, slash);
-  const renamed = PACKAGE_RENAMES.get(name);
-  if (renamed === void 0) {
-    return void 0;
+function renamedValue(value, version) {
+  const npm = migrateNpmSpec(value, version);
+  if (npm === void 0) {
+    return renamedSpecifier(value);
   }
-  return { to: `${renamed}${value.slice(name.length)}`, isDeep: slash !== -1 };
+  const renamed = { to: npm.spec, isDeep: npm.isDeep };
+  return npm.isReported ? { ...renamed, keptSpec: hideUrlCredentials(value) } : renamed;
 }
+const TEMPLATE_SUBSTITUTION = "${";
+function dynamicPackage(value) {
+  const at = value.indexOf(TEMPLATE_SUBSTITUTION);
+  return at === -1 ? void 0 : PACKAGE_RENAMES.get(value.slice(0, at));
+}
+const byStartThenOuter = (left, right) => left.start - right.start || right.end - left.end;
 function distinctStrings(strings) {
   const distinct = [];
-  for (const found of [...strings].sort((left, right) => left.start - right.start)) {
+  const enclosing = [];
+  for (const found of [...strings].sort(byStartThenOuter)) {
     const previous = distinct.at(-1);
-    if (previous === void 0 || found.start >= previous.end) {
-      distinct.push(found);
-    } else if (found.start === previous.start && found.end === previous.end) {
+    if (previous?.start === found.start && previous.end === found.end) {
       const isModuleSpecifier = previous.isModuleSpecifier || found.isModuleSpecifier;
       distinct[distinct.length - 1] = { ...previous, isModuleSpecifier };
-    } else {
+      continue;
+    }
+    let outer = enclosing.at(-1);
+    while (outer !== void 0 && outer.end <= found.start) {
+      enclosing.pop();
+      outer = enclosing.at(-1);
+    }
+    if (outer !== void 0 && found.end > outer.end) {
       throw new Error(
-        `Source strings overlap at offsets ${previous.start}-${previous.end} and ${found.start}-${found.end}; the file was not changed.`
+        `Source strings overlap at offsets ${outer.start}-${outer.end} and ${found.start}-${found.end}; the file was not changed.`
       );
     }
+    enclosing.push(found);
+    distinct.push(found);
   }
   return distinct;
 }
-function migrateModuleSpecifiers(text, strings) {
+const dynamicStep = (line, value, to) => ({
+  kind: "dynamic-specifier",
+  line,
+  value,
+  to
+});
+function migrateModuleSpecifiers(text, strings, version) {
   const changes = [];
   const manualSteps = [];
   let migrated = "";
   let copiedUpTo = 0;
+  const lineOf = lineLocator(text);
   for (const found of distinctStrings(strings)) {
-    const renamed = renamedValue(found.value);
+    const renamed = renamedValue(found.value, version);
+    const line = lineOf(found.start);
+    const dynamic = found.isModuleSpecifier ? dynamicPackage(found.value) : void 0;
     if (renamed === void 0) {
+      manualSteps.push(...dynamic === void 0 ? [] : [dynamicStep(line, found.value, dynamic)]);
       continue;
     }
-    const line = lineAt(text, found.start);
-    if (!found.isModuleSpecifier) {
+    if (!found.isModuleSpecifier || found.start < copiedUpTo) {
       manualSteps.push({ kind: "string-names-package", line, value: found.value, to: renamed.to });
       continue;
     }
@@ -1226,86 +3215,186 @@ function migrateModuleSpecifiers(text, strings) {
     if (renamed.isDeep) {
       manualSteps.push({ kind: "deep-import", line, specifier: renamed.to });
     }
+    if (renamed.keptSpec !== void 0) {
+      manualSteps.push({ kind: "spec-kept", name: renamed.to, spec: renamed.keptSpec });
+    }
     migrated += `${text.slice(copiedUpTo, found.start)}${renamed.to}`;
     copiedUpTo = found.end;
   }
   return { text: migrated + text.slice(copiedUpTo), changes, manualSteps };
 }
+function importedSpecifiers(text, strings) {
+  const lineOf = lineLocator(text);
+  return strings.filter((found) => found.isModuleSpecifier).map((found) => ({
+    specifier: renamedSpecifier(found.value)?.to ?? found.value,
+    line: lineOf(found.start)
+  }));
+}
 
-const ENTRY_RE = /^(\s+)(["']?)([\w@./-]+)\2:\s*(["']?)([^"'#\s]+)\4/;
-const TOP_LEVEL_KEY_RE = /^([\w-]+):/;
-const KEY_RE = /^\s+(["']?)(\S.*?)\1:(?:\s|$)/;
-const CATALOG_SECTIONS = /* @__PURE__ */ new Set(["catalog", "catalogs"]);
-const REPORTED_SECTIONS = /* @__PURE__ */ new Set(["overrides", "patchedDependencies"]);
-function migrateEntry(line, version) {
-  const entry = ENTRY_RE.exec(line);
-  const renamed = entry === null ? void 0 : PACKAGE_RENAMES.get(entry[3]);
-  if (entry === null || renamed === void 0) {
-    return { line };
-  }
-  const [whole, indent, keyQuote, name, specQuote, spec] = entry;
-  const rest = line.slice(whole.length);
-  const decision = migrateVersionSpec(spec, version);
-  const key = `${keyQuote}${renamed}${keyQuote}`;
-  const migrated = `${indent}${key}: ${specQuote}${decision.spec}${specQuote}${rest}`;
-  const change = { kind: "catalog-entry-renamed", from: name, to: renamed };
-  if (decision.kind === "kept" && decision.isReported) {
-    return {
-      line: migrated,
-      change,
-      manualStep: { kind: "spec-kept", name: renamed, spec: hideUrlCredentials(spec) }
+const PNPM_WORKSPACE_FILE = {
+  reportedSections: /* @__PURE__ */ new Set(["overrides", "patchedDependencies"])
+};
+const YARNRC_FILE = { reportedSections: /* @__PURE__ */ new Set() };
+function migrateCatalogs(workspace, target, findings) {
+  for (const { name, label, map } of catalogMaps(workspace)) {
+    const context = {
+      ...target,
+      map: { kind: "catalog", catalog: label, name },
+      findings
     };
+    migrateSpecMap(specEntries(map), context);
   }
-  return { line: migrated, change };
 }
-function reportEntry(line, field) {
-  const key = KEY_RE.exec(line)?.[2];
-  return key === void 0 ? [] : overriddenPackages({ [key]: null }).map((name) => ({
-    kind: "override-names-package",
-    field,
-    name
-  }));
+function reportSections(workspace, file, findings) {
+  for (const field of file.reportedSections) {
+    for (const name of overriddenPackages(valuesAt(workspace, field).flatMap(nestedKeys))) {
+      findings.manualSteps.push({ kind: "override-names-package", field, name });
+    }
+  }
+}
+function migrateWorkspaceCatalogs(text, read, target, file) {
+  if (read.kind === "unreadable") {
+    return unreadableConfig(text, read.offset);
+  }
+  const findings = newFindings();
+  for (const workspace of read.documents.filter(isMap)) {
+    migrateCatalogs(workspace, target, findings);
+    reportSections(workspace, file, findings);
+  }
+  const { edits, changes, manualSteps } = findings;
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
-const LINE_FEED = "\n";
-const CARRIAGE_RETURN = "\r";
-function withoutCarriageReturn(line) {
-  if (!line.endsWith(CARRIAGE_RETURN)) {
-    return { body: line, restore: (body) => body };
+
+const YAML_COMMAND_KEYS = /* @__PURE__ */ new Set([
+  "run",
+  "script",
+  "before_script",
+  "after_script",
+  "before_install",
+  "install",
+  "bash",
+  "pwsh",
+  "powershell",
+  "command",
+  "commands",
+  "entrypoint"
+]);
+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) {
+  return shellVariables(
+    strings.filter(isEnvironmentValue).map((value) => ({ name: String(value.path.at(-1)), value: shellText(text, value) }))
+  );
+}
+const DEPENDABOT_NAME_KEYS = /* @__PURE__ */ new Set([
+  "dependency-name",
+  "patterns",
+  "exclude-patterns"
+]);
+const FOLDED_LINE_BREAK_RE = /(?<=\S[^\S\n]*)\n(?=[^\S\n]*\S)/g;
+const ENV_EXPRESSION_RE = /\$\{\{[ \t]*env\.([A-Za-z_][A-Za-z0-9_]*)[ \t]*\}\}/g;
+const asShellVariable = (expression, name) => `$${name}`.padEnd(expression.length, " ");
+function shellText(text, value) {
+  const slice = text.slice(value.content.start, value.content.end);
+  const unfolded = value.isFolded ? slice.replace(FOLDED_LINE_BREAK_RE, " ") : slice;
+  return unfolded.replace(ENV_EXPRESSION_RE, asShellVariable);
+}
+const valuesOf = (strings, keys) => strings.filter((string) => keys.has(ownerKey(string.path) ?? ""));
+const EXEC_FORM_KEYS = /* @__PURE__ */ new Set(["command", "entrypoint"]);
+const isExecFormItem = (value) => typeof value.path.at(-1) === "number" && EXEC_FORM_KEYS.has(String(value.path.at(-2)));
+const listOf = (item) => item.path.slice(0, -1).join(".");
+const isNextItem = (previous, item) => listOf(previous) === listOf(item) && Number(item.path.at(-1)) > Number(previous.path.at(-1));
+function execFormCommands(text, items) {
+  const commands = [];
+  let previous;
+  let command = [];
+  for (const item of items) {
+    if (previous === void 0 || !isNextItem(previous, item)) {
+      command = [];
+      commands.push(command);
+    }
+    const { start, end } = item.content;
+    command.push({ start, end, value: item.value, raw: text.slice(start, end) });
+    previous = item;
   }
+  return commands;
+}
+function valueFindings(text, value, locate, variables) {
+  const { start } = value.content;
+  const commands = shellCommands(shellText(text, value));
+  const found = commandWordFindings(commands, (offset) => locate(start + offset), variables);
+  return { ...found, edits: shiftedEdits(found.edits, start) };
+}
+const shiftedEdits = (edits, offset) => edits.map((edit) => ({ ...edit, start: edit.start + offset, end: edit.end + offset }));
+function appliedFindings(text, found) {
   return {
-    body: line.slice(0, -CARRIAGE_RETURN.length),
-    restore: (body) => `${body}${CARRIAGE_RETURN}`
+    text: applyTextEdits(
+      text,
+      found.flatMap((findings) => findings.edits)
+    ),
+    changes: found.flatMap((findings) => findings.changes),
+    manualSteps: found.flatMap((findings) => findings.manualSteps)
   };
 }
-function migrateWorkspaceCatalogs(text, version) {
+function migrateYamlCommands(text, file, strings) {
+  const values = valuesOf(strings, YAML_COMMAND_KEYS);
+  const lineOf = lineLocator(text);
+  const locate = (offset) => `${file}:${lineOf(offset)}`;
+  const commandValues = new Set(values.filter((value) => !isExecFormItem(value)));
+  const shellValues = strings.filter(
+    (value) => commandValues.has(value) || isEnvironmentValue(value)
+  );
+  const variables = environmentVariables(text, strings);
+  return appliedFindings(text, [
+    ...shellValues.map((value) => valueFindings(text, value, locate, variables)),
+    commandWordFindings(execFormCommands(text, values.filter(isExecFormItem)), locate)
+  ]);
+}
+const SCRIPTS_KEY = "scripts";
+const isScript = (string) => string.path.length === 2 && string.path[0] === SCRIPTS_KEY;
+function migrateYamlScripts(text, strings) {
+  const scripts = strings.filter(isScript);
+  return appliedFindings(
+    text,
+    scripts.map((script) => valueFindings(text, script, () => script.path.join(".")))
+  );
+}
+function migrateDependabotConfig(text, file, strings) {
   const changes = [];
-  const manualSteps = [];
-  let section;
-  const lines = text.split(LINE_FEED).map((rawLine) => {
-    const { body: line, restore } = withoutCarriageReturn(rawLine);
-    const topLevelKey = TOP_LEVEL_KEY_RE.exec(line)?.[1];
-    if (topLevelKey !== void 0) {
-      section = topLevelKey;
-      return rawLine;
-    }
-    if (section !== void 0 && REPORTED_SECTIONS.has(section)) {
-      manualSteps.push(...reportEntry(line, section));
-      return rawLine;
-    }
-    if (section === void 0 || !CATALOG_SECTIONS.has(section)) {
-      return rawLine;
-    }
-    const result = migrateEntry(line, version);
-    changes.push(...result.change ? [result.change] : []);
-    manualSteps.push(...result.manualStep ? [result.manualStep] : []);
-    return restore(result.line);
-  });
-  return changes.length === 0 ? { ...unchanged(text), manualSteps } : { text: lines.join(LINE_FEED), changes, manualSteps };
+  const edits = [];
+  const lineOf = lineLocator(text);
+  for (const value of valuesOf(strings, DEPENDABOT_NAME_KEYS)) {
+    const from = value.value;
+    const to = PACKAGE_RENAMES.get(from);
+    if (to !== void 0) {
+      const { start, end } = value.content;
+      const location = `${file}:${lineOf(start)}`;
+      changes.push({ kind: "package-name-renamed", location, from, to });
+      edits.push({ start, end, text: to });
+    }
+  }
+  return { text: applyTextEdits(text, edits), changes, manualSteps: [] };
 }
 
-const SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".sh", ".bash", ".zsh", ".yml", ".yaml"]);
-const SCRIPT_NAMES = /* @__PURE__ */ new Set(["Makefile", "justfile", "Dockerfile"]);
+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 DOCKERFILE_NAMES = /* @__PURE__ */ new Set(["Dockerfile", "Containerfile"]);
+const HUSKY_FOLDER = ".husky/";
+const HUSKY_INTERNALS = ".husky/_/";
+const NX_PROJECT_FILE = "project.json";
+const DENO_CONFIG_FILES = /* @__PURE__ */ new Set(["deno.json", "deno.jsonc"]);
+const IMPORT_MAP_FILE = "import_map.json";
+const DEPENDABOT_FILES = /* @__PURE__ */ new Set([
+  ".github/dependabot.yml",
+  ".github/dependabot.yaml"
+]);
 const WORKSPACE_FILE = "pnpm-workspace.yaml";
+const YARNRC_FILE_NAME = ".yarnrc.yml";
+const YAML_MANIFEST_FILES = /* @__PURE__ */ new Set(["package.yaml", "package.yml"]);
+const JSON5_MANIFEST_FILE = "package.json5";
 const MANIFEST_FILE = "package.json";
 const LOCK_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "yarn.lock", "bun.lock"]);
 function baseName(path) {
@@ -1316,31 +3405,121 @@ function extensionOf(path) {
   const dot = name.lastIndexOf(".");
   return dot <= 0 ? "" : name.slice(dot);
 }
+
+const isHuskyHook = (path) => (path.startsWith(HUSKY_FOLDER) || path.includes(`/${HUSKY_FOLDER}`)) && !path.includes(HUSKY_INTERNALS);
+const isDependabotConfig = (path) => [...DEPENDABOT_FILES].some((file) => path === file || path.endsWith(`/${file}`));
+const withSteps = (migration, steps) => ({
+  ...migration,
+  manualSteps: [...migration.manualSteps, ...steps]
+});
+function migrateSource(text, path, context) {
+  const strings = context.scanner.scan(text, path);
+  const migrated = chain(
+    migrateModuleSpecifiers(text, strings, context.version),
+    (renamed) => context.rewriter.rewrite(renamed, path)
+  );
+  const imports = importedSpecifiers(text, strings);
+  const undeclared = undeclaredImportSteps(imports, path, context.manifests);
+  return withSteps(migrated, [...commandStringSteps(text, strings), ...undeclared]);
+}
 function chain(first, next) {
   const second = next(first.text);
   const changes = [...first.changes, ...second.changes];
   const manualSteps = [...first.manualSteps, ...second.manualSteps];
   return { text: second.text, changes, manualSteps };
 }
+function migrateConfig(text, read, steps) {
+  const first = read(text);
+  if (first.kind === "unreadable") {
+    return unreadableConfig(text, first.offset);
+  }
+  return steps.reduce(
+    (done, step) => chain(done, (current) => step(current, current === text ? first : read(current))),
+    unchanged(text)
+  );
+}
+const stringsStep = (migrate) => (text, read) => read.kind === "unreadable" ? unreadableConfig(text, read.offset) : migrate(text, documentStrings(read.documents));
+const jsonCommandsStep = (patterns) => stringsStep((text, strings) => migrateJsonCommands(text, strings, patterns));
+const jsonConfig = (steps) => (text, _path, context) => migrateConfig(text, (current) => context.readers.json.read(current), steps(context));
+const yamlConfig = (steps) => (text, path, context) => migrateConfig(text, (current) => context.readers.yaml.read(current), steps(context, path));
+const whenNamed = (migrate) => (text, path, context) => namesOriginalPackage(text) ? migrate(text, path, context) : unchanged(text);
 const FILE_KINDS = [
   {
     matches: (path) => baseName(path) === MANIFEST_FILE,
-    migrate: (text, _path, context) => migratePackageManifest(text, context.version)
+    migrate: jsonConfig(({ version, catalogs }) => [
+      (text, read) => migratePackageManifest(text, read, { version, catalogs }),
+      jsonCommandsStep(PACKAGE_SCRIPT_PATHS)
+    ])
+  },
+  {
+    matches: (path) => YAML_MANIFEST_FILES.has(baseName(path)),
+    migrate: yamlConfig(({ version, catalogs }) => [
+      (text, read) => migratePackageManifest(text, read, { version, catalogs }),
+      stringsStep(migrateYamlScripts)
+    ])
+  },
+  {
+    matches: (path) => baseName(path) === JSON5_MANIFEST_FILE,
+    migrate: unreadManifest
   },
   {
     matches: (path) => baseName(path) === WORKSPACE_FILE,
-    migrate: (text, _path, context) => migrateWorkspaceCatalogs(text, context.version)
+    migrate: yamlConfig(({ version, catalogs }) => [
+      (text, read) => migrateWorkspaceCatalogs(text, read, { version, catalogs }, PNPM_WORKSPACE_FILE)
+    ])
+  },
+  {
+    matches: (path) => baseName(path) === YARNRC_FILE_NAME,
+    migrate: yamlConfig(({ version, catalogs }) => [
+      (text, read) => migrateWorkspaceCatalogs(text, read, { version, catalogs }, YARNRC_FILE)
+    ])
   },
   {
     matches: (path) => SOURCE_EXTENSIONS.has(extensionOf(path)),
-    migrate: (text, path, context) => chain(
-      migrateModuleSpecifiers(text, context.scanner.scan(text, path)),
-      (renamed) => context.rewriter.rewrite(renamed, path)
+    migrate: migrateSource
+  },
+  {
+    matches: (path) => baseName(path) === NX_PROJECT_FILE,
+    migrate: jsonConfig(() => [jsonCommandsStep(NX_COMMAND_PATHS)])
+  },
+  {
+    matches: (path) => DENO_CONFIG_FILES.has(baseName(path)),
+    migrate: jsonConfig(({ version }) => [
+      (text, read) => migrateImportMap(text, read, version),
+      jsonCommandsStep(DENO_TASK_PATHS)
+    ])
+  },
+  {
+    matches: (path) => baseName(path) === IMPORT_MAP_FILE,
+    migrate: jsonConfig(({ version }) => [(text, read) => migrateImportMap(text, read, version)])
+  },
+  {
+    matches: isDependabotConfig,
+    migrate: whenNamed(
+      yamlConfig((_context, path) => [
+        stringsStep((text, strings) => migrateDependabotConfig(text, path, strings))
+      ])
+    )
+  },
+  {
+    matches: (path) => YAML_EXTENSIONS.has(extensionOf(path)),
+    migrate: whenNamed(
+      yamlConfig((_context, path) => [
+        stringsStep((text, strings) => migrateYamlCommands(text, path, strings))
+      ])
     )
   },
   {
-    matches: (path) => SCRIPT_EXTENSIONS.has(extensionOf(path)) || SCRIPT_NAMES.has(baseName(path)),
-    migrate: (text, path) => migrateCommandLines(text, path)
+    matches: (path) => DOCKERFILE_NAMES.has(baseName(path)),
+    migrate: whenNamed((text, path) => migrateDockerfile(text, path))
+  },
+  {
+    matches: (path) => MAKEFILE_NAMES.has(baseName(path)) || extensionOf(path) === MAKEFILE_EXTENSION,
+    migrate: whenNamed((text, path) => migrateMakefile(text, path))
+  },
+  {
+    matches: (path) => SHELL_EXTENSIONS.has(extensionOf(path)) || SHELL_FILE_NAMES.has(baseName(path)) || isHuskyHook(path),
+    migrate: whenNamed((text, path) => migrateCommandLines(text, path))
   }
 ];
 function fileMigrationFor(path) {
@@ -1350,118 +3529,327 @@ function fileMigrationFor(path) {
   return FILE_KINDS.find((kind) => kind.matches(path))?.migrate;
 }
 
-async function migrateFile(path, dependencies, input) {
+const readJson = (text, readers) => readers.json.read(text);
+const readYaml = (text, readers) => readers.yaml.read(text);
+function planSourceOf(path) {
+  const name = baseName(path);
+  if (name === MANIFEST_FILE) {
+    return { role: "manifest", read: readJson };
+  }
+  if (DENO_CONFIG_FILES.has(name) || name === IMPORT_MAP_FILE) {
+    return { role: "import-map", read: readJson };
+  }
+  if (YAML_MANIFEST_FILES.has(name)) {
+    return { role: "manifest", read: readYaml };
+  }
+  if (name === JSON5_MANIFEST_FILE) {
+    return { role: "manifest", read: void 0 };
+  }
+  const isCatalogFile = name === WORKSPACE_FILE || name === YARNRC_FILE_NAME;
+  return isCatalogFile ? { role: "catalogs", read: readYaml } : void 0;
+}
+
+async function planFile(path, dependencies, target) {
   const migrate = fileMigrationFor(path);
   if (migrate === void 0) {
-    return void 0;
+    return { kind: "not-migrated" };
   }
-  const text = await dependencies.files.read(path);
-  const { rewriter, scanner } = dependencies;
-  const context = { version: input.version, rewriter, scanner };
-  const migration = migrate(text, path, context);
-  const isChanged = migration.text !== text;
-  if (isChanged && input.isWrite) {
-    await dependencies.files.write(path, migration.text);
+  const read = await dependencies.files.read(path);
+  if (read.kind === "skipped") {
+    return read;
   }
+  const { rewriter, scanner, readers } = dependencies;
+  const context = { ...target, 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 });
   }
-  return { path, isChanged, changes, manualSteps };
+  const report = { path, isChanged, changes, manualSteps };
+  return { kind: "planned", file: { report, text: isChanged ? migration.text : void 0 } };
 }
-async function migrateProject(dependencies, input) {
-  const { files, skipped } = await dependencies.files.listFiles();
-  const paths = [...files].sort();
-  dependencies.logger.info("migration_started", { fileCount: paths.length, ...input });
-  const reports = [];
+async function readForPlan(path, source, dependencies) {
+  const read = await dependencies.files.read(path);
+  if (read.kind !== "read") {
+    return { namesOriginal: false, roots: void 0 };
+  }
+  const namesOriginal = namesOriginalPackage(read.text);
+  if (!namesOriginal && !namesUninstalledPackage(read.text)) {
+    return { namesOriginal, roots: [] };
+  }
+  const parsed = source.read?.(read.text, dependencies.readers);
+  const roots = parsed?.kind === "read" ? parsed.documents.filter(isMap) : void 0;
+  return { namesOriginal, roots };
+}
+const DECLARED_NAMES = { manifest: declaredNames, "import-map": importMapNames, catalogs: void 0 };
+async function planProjectTarget(paths, dependencies, version) {
+  const documents = { manifest: [], catalogs: [] };
+  const manifests = [];
   for (const path of paths) {
-    const report = await migrateFile(path, dependencies, input);
-    if (report !== void 0 && (report.isChanged || report.manualSteps.length > 0)) {
-      reports.push(report);
+    const source = planSourceOf(path);
+    if (source === void 0) {
+      continue;
+    }
+    const { namesOriginal, roots } = await readForPlan(path, source, dependencies);
+    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)) });
     }
   }
-  dependencies.logger.info("migration_finished", {
-    changedFiles: reports.length,
-    skippedFiles: skipped.length
+  const catalogs = planCatalogs({
+    manifests: documents.manifest,
+    catalogFiles: documents.catalogs
   });
-  return { files: reports, skipped };
+  return { version, catalogs, manifests };
 }
-
-function assertNever(value) {
-  throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
+async function planProject(paths, dependencies, version) {
+  const files = [];
+  const skipped = [];
+  const target = await planProjectTarget(paths, dependencies, version);
+  for (const path of paths) {
+    const plan = await planFile(path, dependencies, target);
+    if (plan.kind === "skipped") {
+      skipped.push({ path, reason: plan.reason });
+      dependencies.logger.warn("file_skipped", { path, reason: plan.reason });
+    } else if (plan.kind === "planned") {
+      const { report } = plan.file;
+      const isReported = report.isChanged || report.manualSteps.length > 0;
+      files.push(...isReported ? [plan.file] : []);
+    }
+  }
+  return { files, skipped };
+}
+async function writeFiles(planned, dependencies) {
+  const changed = planned.flatMap(
+    ({ report, text }) => text === void 0 ? [] : [{ path: report.path, text }]
+  );
+  const written = [];
+  for (const [index, { path, text }] of changed.entries()) {
+    const result = await dependencies.files.write(path, text);
+    if (result.kind === "failed") {
+      dependencies.logger.warn("file_write_failed", { path, reason: result.reason, written });
+      const notWritten = changed.slice(index + 1).map((file) => file.path);
+      return { kind: "failed", written, failed: { path, reason: result.reason }, notWritten };
+    }
+    written.push(path);
+  }
+  return { kind: "written", paths: written };
+}
+async function migrateProject(dependencies, input) {
+  const listing = await dependencies.files.listFiles();
+  const paths = [...listing.files].sort();
+  dependencies.logger.info("migration_started", { fileCount: paths.length, ...input });
+  const plan = await planProject(paths, dependencies, input.version);
+  const skipped = [...listing.skipped, ...plan.skipped];
+  const write = input.isWrite ? await writeFiles(plan.files, dependencies) : { kind: "dry-run" };
+  dependencies.logger.info("migration_finished", {
+    changedFiles: plan.files.length,
+    skippedFiles: skipped.length,
+    write: write.kind
+  });
+  return { files: plan.files.map((file) => file.report), skipped, write };
 }
 
 const IR_CALLBACKS_GUIDE = "https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs/node.md#ir-callbacks";
 const OPENAPI_FETCH_ALIAS_GUIDE = "https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs/fetch/index.md#libraries-built-on-openapi-fetch";
-function changeMessage(change) {
-  switch (change.kind) {
-    case "dependency-renamed":
-      return `${change.field}: ${change.from} \u2192 ${change.to}@${change.spec}`;
-    case "catalog-entry-renamed":
-      return `catalog: ${change.from} \u2192 ${change.to}`;
-    case "command-renamed":
-      return `${change.location}: openapi-typescript \u2192 openapi-typesafe`;
-    case "flag-renamed":
-      return `${change.location}: ${change.from} \u2192 ${change.to}`;
-    case "specifier-renamed":
-      return `line ${change.line}: "${change.from}" \u2192 "${change.to}"`;
-    case "transform-rewritten":
-      return `line ${change.line}: transform returns type text; irCallbacks: true added`;
-    default:
-      return assertNever(change);
-  }
-}
 const KEEP_REASONS = {
   "other-callbacks": "postTransform or transformProperty are set too, and they need TypeScript nodes",
   "not-a-function": "it is not an inline function or a function of this file",
   "shared-function": "the function it names is used elsewhere too",
+  "shared-options": "its options object is used elsewhere too",
   "unknown-return": "a return value is not a plain ts.factory type"
 };
 const PEER_NOTE = "users of this package must switch too (a breaking change for them)";
 const PINNED_NOTE = "change it to openapi-typesafe@<version>";
+const OLD_FILE_NOTE = "is a file of openapi-typescript, which is no longer installed: run openapi-typesafe instead";
+const FLAGS_IN_VARIABLE_NOTE = "holds old flags of the generator and may serve other commands, so it was kept: rename";
+const NOT_ONLY_GENERATOR_NOTE = "runs openapi-typescript in some of its definitions in this file and another program in others, so the flags after it were kept; where it runs the generator, rename";
+const COMMAND_STRING_NOTE = "a string runs openapi-typescript, so it was kept; change it to";
+const OPTIONS_NOTE = `the options of openapiTS() are not an object written in this file: check them for transform, postTransform and transformProperty. See ${IR_CALLBACKS_GUIDE}`;
+const MANIFEST_NOT_READ_NOTE = "is a JSON5 manifest, which the tool does not read: rename the packages and the generator command by hand, or write it as package.json and run the tool again";
 const DEEP_IMPORT_NOTE = "imports a file inside the package; check that it exists";
+const DYNAMIC_NOTE = "builds its module name at run time from an old package name, so it was kept; rename it to";
 const STRING_NOTE = "is a string, not a module specifier, so it was kept";
 const STRING_FIX_NOTE = "if it names the package, change it to";
 const KEPT_NOTE = `it works, with a deprecation warning. See ${IR_CALLBACKS_GUIDE}`;
 const LEGACY_CALLBACK_NOTE = `receives TypeScript nodes (deprecated). See ${IR_CALLBACKS_GUIDE}`;
+const HELPER_TYPES_ENTRY = "openapi-typesafe-fetch/helpers";
+function packageNotDeclaredMessage(step) {
+  const { line, name, installers } = step;
+  return `line ${line}: no package.json or Deno import map at or above this file lists ${name}; ${installers.join(" and ")} installed it, the openapi-typesafe packages do not: add it to the dependencies, or import the types from ${HELPER_TYPES_ENTRY}`;
+}
 function oldPeerMessage(step) {
   const { dependent, peer, range } = step;
   const successor = PACKAGE_RENAMES.get(peer) ?? peer;
   return `${dependent} takes its client type from ${peer}@${range}, its peer dependency: alias ${peer} to ${successor} with overrides or resolutions, or passing it the ${successor} client fails to type-check. See ${OPENAPI_FETCH_ALIAS_GUIDE}`;
 }
+function pinnedPackageMessage(step) {
+  const successor = PACKAGE_RENAMES.get(step.name) ?? step.name;
+  return `${step.location} names a pinned ${step.name}@<version>: change it to ${successor}@<version>`;
+}
+const flagRenames = (flags) => flags.map((flag) => `${flag} to ${FLAG_RENAMES.get(flag) ?? flag}`).join(", ");
+function flagsInVariableMessage(step) {
+  return `${step.location}: ${step.variable} ${FLAGS_IN_VARIABLE_NOTE} ${flagRenames(step.flags)}`;
+}
+function notOnlyGeneratorMessage(step) {
+  return `${step.location}: ${step.variable} ${NOT_ONLY_GENERATOR_NOTE} ${flagRenames(step.flags)}`;
+}
+const COMMAND_STEP_KINDS = /* @__PURE__ */ new Set([
+  "versioned-command",
+  "flags-in-variable",
+  "variable-not-only-generator",
+  "pinned-package",
+  "old-package-file",
+  "command-string"
+]);
+const isCommandStep = (step) => COMMAND_STEP_KINDS.has(step.kind);
+function commandStepMessage(step) {
+  switch (step.kind) {
+    case "versioned-command":
+      return `${step.location} runs a pinned openapi-typescript@<version>: ${PINNED_NOTE}`;
+    case "flags-in-variable":
+      return flagsInVariableMessage(step);
+    case "variable-not-only-generator":
+      return notOnlyGeneratorMessage(step);
+    case "pinned-package":
+      return pinnedPackageMessage(step);
+    case "old-package-file":
+      return `${step.location}: ${step.path} ${OLD_FILE_NOTE}`;
+    case "command-string":
+      return `line ${step.line}: ${COMMAND_STRING_NOTE} "${step.to}"`;
+    default:
+      return assertNever(step);
+  }
+}
+function uneditedStepMessage(step) {
+  switch (step.kind) {
+    case "config-unreadable":
+      return step.position === void 0 ? "nests too deep to be read; migrate it by hand" : `cannot be parsed at line ${step.position.line}, column ${step.position.column}; migrate it by hand`;
+    case "manifest-not-read":
+      return MANIFEST_NOT_READ_NOTE;
+    case "entry-not-edited":
+      return `${step.field}: ${step.name} has a value the tool does not read; rename it by hand`;
+    case "name-collision":
+      return `${step.field} has both ${step.from} and ${step.to}, so ${step.from} was kept: remove one of them`;
+    case "catalog-reference-kept":
+      return `${step.field}: ${step.name} was kept, because catalog "${step.catalog}" keeps ${step.name}: rename the entry and the dependency together`;
+    case "catalog-entry-in-use":
+      return `${step.catalog}: ${step.name} was kept, because a dependency or an override still names it: rename the entry and what names it together`;
+    default:
+      return assertNever(step);
+  }
+}
+function sourceStepMessage(step) {
+  switch (step.kind) {
+    case "options-not-inspected":
+      return `line ${step.line}: ${OPTIONS_NOTE}`;
+    case "deep-import":
+      return `line ${step.line}: "${step.specifier}" ${DEEP_IMPORT_NOTE}`;
+    case "dynamic-specifier":
+      return `line ${step.line}: \`${step.value}\` ${DYNAMIC_NOTE} ${step.to}`;
+    case "string-names-package":
+      return `line ${step.line}: "${step.value}" ${STRING_NOTE}; ${STRING_FIX_NOTE} "${step.to}"`;
+    case "transform-not-rewritten":
+      return `line ${step.line}: transform kept (${KEEP_REASONS[step.reason]}); ${KEPT_NOTE}`;
+    case "legacy-callback":
+      return `line ${step.line}: ${step.callback} ${LEGACY_CALLBACK_NOTE}`;
+    case "package-not-declared":
+      return packageNotDeclaredMessage(step);
+    default:
+      return assertNever(step);
+  }
+}
 function manualStepMessage(step) {
+  if (isCommandStep(step)) {
+    return commandStepMessage(step);
+  }
   switch (step.kind) {
-    case "manifest-unreadable":
-      return `package.json is not valid JSON (${step.reason}); migrate it by hand`;
+    case "config-unreadable":
+    case "manifest-not-read":
+    case "entry-not-edited":
+    case "name-collision":
+    case "catalog-reference-kept":
+    case "catalog-entry-in-use":
+      return uneditedStepMessage(step);
     case "peer-dependency-renamed":
       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 "override-names-package":
       return `"${step.field}" names ${step.name}: update or remove that override`;
-    case "versioned-command":
-      return `${step.location} runs a pinned openapi-typescript@<version>: ${PINNED_NOTE}`;
+    case "options-not-inspected":
     case "deep-import":
-      return `line ${step.line}: "${step.specifier}" ${DEEP_IMPORT_NOTE}`;
+    case "dynamic-specifier":
     case "string-names-package":
-      return `line ${step.line}: "${step.value}" ${STRING_NOTE}; ${STRING_FIX_NOTE} "${step.to}"`;
-    case "old-peer-needed":
-      return oldPeerMessage(step);
     case "transform-not-rewritten":
-      return `line ${step.line}: transform kept (${KEEP_REASONS[step.reason]}); ${KEPT_NOTE}`;
     case "legacy-callback":
-      return `line ${step.line}: ${step.callback} ${LEGACY_CALLBACK_NOTE}`;
+    case "package-not-declared":
+      return sourceStepMessage(step);
+    case "old-peer-needed":
+      return oldPeerMessage(step);
     default:
       return assertNever(step);
   }
 }
+
+function changeMessage(change) {
+  switch (change.kind) {
+    case "dependency-renamed":
+      return `${change.field}: ${change.from} \u2192 ${change.to}@${change.spec}`;
+    case "catalog-entry-renamed":
+      return `${change.catalog}: ${change.from} \u2192 ${change.to}@${change.spec}`;
+    case "import-renamed":
+      return `${change.field}: "${change.from}" \u2192 "${change.to}" (${change.target})`;
+    case "alias-renamed":
+      return `${change.field}: ${change.name} \u2192 ${change.spec}`;
+    case "command-renamed":
+      return `${change.location}: openapi-typescript \u2192 openapi-typesafe`;
+    case "flag-renamed":
+    case "package-name-renamed":
+      return `${change.location}: ${change.from} \u2192 ${change.to}`;
+    case "specifier-renamed":
+      return `line ${change.line}: "${change.from}" \u2192 "${change.to}"`;
+    case "transform-rewritten":
+      return `line ${change.line}: transform returns type text; irCallbacks: true added`;
+    case "declaration-removed":
+      return `line ${change.line}: ${change.name} removed; only the old transform returns used it`;
+    default:
+      return assertNever(change);
+  }
+}
 const SKIPPED_HEADING = "Skipped (not read, not written):";
-const SKIP_REASONS = {
-  "outside-root": "git listed it, but it is outside the project folder; check where this git index came from"
-};
-function skipReasonMessage(reason) {
-  return SKIP_REASONS[reason];
+function skippedMessage(reason) {
+  switch (reason.kind) {
+    case "outside-root":
+      return "it leads outside the project folder (a link, or a path in the git index)";
+    case "not-utf-8":
+      return "it is not UTF-8 text, so it was not changed; check it by hand";
+    case "io-error":
+      return `it could not be read (${reason.code})`;
+    default:
+      return assertNever(reason);
+  }
+}
+function writeProblemMessage(reason) {
+  switch (reason.kind) {
+    case "outside-root":
+      return "it leads outside the project folder";
+    case "not-utf-8":
+      return "its text is not UTF-8";
+    case "io-error":
+      return reason.code;
+    default:
+      return assertNever(reason);
+  }
 }
+const writeFailedMessage = (path, reason) => `Writing stopped: ${path} could not be written (${writeProblemMessage(reason)}).`;
+const WRITTEN_HEADING = "Written before it:";
+const NOT_WRITTEN_HEADING = "Not written (still as they were):";
+const NONE_WRITTEN = "Nothing was written before it.";
 const NEXT_STEPS = [
   "Install: run your package manager's install, so the lockfile has the new packages.",
   "Regenerate your types and commit them once: the file header names openapi-typesafe now, so `--check` fails until you do.",
@@ -1495,10 +3883,29 @@ function skippedSection(skipped) {
   if (skipped.length === 0) {
     return [];
   }
-  const lines = skipped.map((file) => `  ${file.path}: ${skipReasonMessage(file.reason)}`);
+  const lines = skipped.map((file) => `  ${file.path}: ${skippedMessage(file.reason)}`);
   return [SKIPPED_HEADING, ...lines, ""];
 }
-function renderReport(migration, isWrite) {
+const listed = (paths) => paths.map((path) => `  ${path}`);
+function writeSection(write) {
+  switch (write.kind) {
+    case "dry-run":
+      return [DRY_RUN_NOTE];
+    case "written":
+      return [WRITTEN_NOTE];
+    case "failed":
+      return [
+        writeFailedMessage(write.failed.path, write.failed.reason),
+        ...write.written.length === 0 ? [NONE_WRITTEN] : [WRITTEN_HEADING],
+        ...listed(write.written),
+        ...write.notWritten.length === 0 ? [] : [NOT_WRITTEN_HEADING],
+        ...listed(write.notWritten)
+      ];
+    default:
+      return assertNever(write);
+  }
+}
+function renderReport(migration) {
   const reports = migration.files;
   const skipped = skippedSection(migration.skipped);
   if (reports.length === 0) {
@@ -1512,7 +3919,7 @@ function renderReport(migration, isWrite) {
     "Next steps:",
     ...NEXT_STEPS.map((step, index) => `  ${index + 1}. ${step}`),
     "",
-    isWrite ? WRITTEN_NOTE : DRY_RUN_NOTE
+    ...writeSection(migration.write)
   ];
   return `${lines.join("\n")}
 `;
@@ -1556,7 +3963,8 @@ Options
 
 Exit codes
   0  Done
-  1  The migration failed (the message and the log say why), or the log could not be created
+  1  The migration failed (the message and the log say why), a file could not be written
+     (the report names what was written), or the log could not be created
   2  Unknown option or argument
 `;
 const usageError = (message) => `${message}
@@ -1564,6 +3972,12 @@ Run openapi-typesafe-migrate --help for the options.
 `;
 const logNote = (path) => `Log: ${path}
 `;
+const ROOT_PROBLEMS = {
+  missing: "does not exist",
+  "not-a-directory": "is not a folder; --root takes the project folder"
+};
+const rootError = (root, state) => `The project folder ${root} ${ROOT_PROBLEMS[state]}
+`;
 const logError = (path, message) => `Cannot create the log ${path ?? "in the temporary directory"}: ${message}
 `;
 
@@ -1588,6 +4002,20 @@ function openLog(request, dependencies) {
     return void 0;
   }
 }
+async function migrateRoot(request, root, logger, dependencies) {
+  const rootState = await dependencies.inspectRoot(root);
+  if (rootState !== "directory") {
+    logger.warn("root_unusable", { root, rootState });
+    dependencies.writeStderr(rootError(root, rootState));
+    return EXIT_CODES.failure;
+  }
+  const files = dependencies.createFiles(root, logger);
+  const { rewriter, scanner, readers } = dependencies;
+  const input = { version: dependencies.version, isWrite: request.isWrite };
+  const migration = await migrateProject({ files, rewriter, scanner, readers, logger }, input);
+  dependencies.writeStdout(renderReport(migration));
+  return migration.write.kind === "failed" ? EXIT_CODES.failure : EXIT_CODES.success;
+}
 async function runMigration(request, dependencies) {
   const log = openLog(request, dependencies);
   if (log === void 0) {
@@ -1596,12 +4024,7 @@ async function runMigration(request, dependencies) {
   const { logger, path } = log;
   const root = dependencies.resolvePath(dependencies.cwd, request.root ?? ".");
   try {
-    const files = dependencies.createFiles(root, logger);
-    const { rewriter, scanner } = dependencies;
-    const input = { version: dependencies.version, isWrite: request.isWrite };
-    const migration = await migrateProject({ files, rewriter, scanner, logger }, input);
-    dependencies.writeStdout(renderReport(migration, request.isWrite));
-    return EXIT_CODES.success;
+    return await migrateRoot(request, root, logger, dependencies);
   } catch (error) {
     const message = errorMessage(error);
     logger.warn("migration_failed", { root, message });
@@ -1640,15 +4063,23 @@ function createLogger(path) {
   const logPath = isExclusive ? createTemporaryLogPath(tmpdir(), now()) : resolve(path);
   return { logger: createJsonLinesLogger({ path: logPath, now, isExclusive }), path: logPath };
 }
+const createGit = (root) => createGitFileList({
+  environment: process.env,
+  platform: process.platform,
+  fileSystem: createNodeGitFileSystem(),
+  projectRoot: root
+});
 const dependencies = {
   version: readVersion(),
   cwd: process.cwd(),
   writeStdout: (text) => process.stdout.write(text),
   writeStderr: (text) => process.stderr.write(text),
-  createFiles: (root, logger) => createNodeProjectFiles(root, { git: createGitFileList(), logger }),
+  inspectRoot: inspectProjectRoot,
+  createFiles: (root, logger) => createNodeProjectFiles(root, { git: createGit(root), logger }),
   createLogger,
   rewriter: createTypescriptCallbackRewriter(),
   scanner: createTypescriptStringScanner(),
+  readers: { json: createJsonTextReader(), yaml: createYamlTextReader() },
   resolvePath: resolve
 };
 runCli(process.argv.slice(2), dependencies).then((exitCode) => {