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

package/dist/cli/main.mjs

@@ -12,7 +12,7 @@ const PATH_VARIABLE = "PATH";
 const GIT_NAME = "git";
 const WINDOWS_EXECUTABLE_EXTENSION = ".exe";
 const GIT_FOLDER = ".git";
-const PARENT_FOLDER = "..";
+const PARENT_FOLDER$1 = "..";
 const PACKAGES_FOLDER = "node_modules";
 const ABSENT_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR", "EACCES", "EPERM"]);
 function isAbsent(error) {
@@ -35,7 +35,7 @@ function pathVariable({ environment, platform }) {
 }
 function isAtOrUnder(paths, folder, target) {
   const path = paths.relative(folder, target);
-  return !(path === PARENT_FOLDER || path.startsWith(`${PARENT_FOLDER}${paths.sep}`)) && !paths.isAbsolute(path);
+  return !(path === PARENT_FOLDER$1 || path.startsWith(`${PARENT_FOLDER$1}${paths.sep}`)) && !paths.isAbsolute(path);
 }
 function isInPackagesFolder(host, path) {
   const separator = host.platform === WINDOWS ? /[\\/]/ : posix.sep;
@@ -283,6 +283,7 @@ function createTemporaryLogPath(parent, startTime) {
 
 const FILE_NAME = "document.json";
 const QUOTE_LENGTH = 1;
+const JSON_ESCAPE = "\\";
 const encode = (value) => JSON.stringify(value);
 function spanOf$1(node, file) {
   return { start: node.getStart(file), end: node.end };
@@ -290,7 +291,8 @@ function spanOf$1(node, file) {
 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 };
+  const isEscaped = file.text.slice(content.start, content.end).includes(JSON_ESCAPE);
+  return { kind: "scalar", value: node.text, content, isFolded: false, isEscaped, encode, ...span };
 }
 function convertObject(node, file) {
   const entries = node.properties.filter(ts.isPropertyAssignment).map(
@@ -608,7 +610,10 @@ function applyTextEdits(text, edits) {
   return edited + text.slice(copiedUpTo);
 }
 
-const GENERATOR_MODULES = /* @__PURE__ */ new Set(["openapi-typesafe", "openapi-typescript"]);
+const GENERATOR_MODULES = /* @__PURE__ */ new Set([
+  "openapi-typesafe",
+  "openapi-typescript"
+]);
 const TYPESCRIPT_MODULES = /* @__PURE__ */ new Set(["typescript", "@typescript/typescript6"]);
 const DEFAULT_EXPORT$1 = "default";
 function addNamedImports(clause, isGenerator, into) {
@@ -649,16 +654,21 @@ function addConstants(statement, into) {
     }
   }
 }
+function addStatement(statement, into) {
+  if (ts.isImportDeclaration(statement)) {
+    addImport(statement, into);
+  } else if (ts.isVariableStatement(statement)) {
+    addConstants(statement, into);
+  } else if (ts.isFunctionDeclaration(statement) && statement.name !== void 0) {
+    into.set(statement, { kind: "function", declaration: statement });
+  } else if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) {
+    into.set(statement, { kind: "local-type", declaration: statement });
+  }
+}
 function collectBindings(file) {
   const bindings = /* @__PURE__ */ new Map();
   for (const statement of file.statements) {
-    if (ts.isImportDeclaration(statement)) {
-      addImport(statement, bindings);
-    } else if (ts.isVariableStatement(statement)) {
-      addConstants(statement, bindings);
-    } else if (ts.isFunctionDeclaration(statement) && statement.name !== void 0) {
-      bindings.set(statement, { kind: "function", declaration: statement });
-    }
+    addStatement(statement, bindings);
   }
   return bindings;
 }
@@ -688,6 +698,16 @@ function isDeclaredName(identifier, declaration) {
   const declaredName = declaration.name;
   return declaredName === identifier || ts.findAncestor(identifier, ts.isImportDeclaration) !== void 0;
 }
+function addJSDocBinding(declaration, into) {
+  if (ts.isJSDocTypedefTag(declaration)) {
+    into.set(declaration, { kind: "local-type", declaration });
+    return;
+  }
+  const importTag = ts.findAncestor(declaration, ts.isJSDocImportTag);
+  if (importTag !== void 0) {
+    addImport(importTag, into);
+  }
+}
 function indexUses(file, bindings) {
   const uses = /* @__PURE__ */ new Map();
   const visit = (node) => {
@@ -718,6 +738,9 @@ class CheckedFileBindings {
   declarationOf(identifier) {
     this.#checker ??= createChecker(this.#file);
     const declaration = symbolOf(this.#checker, identifier)?.declarations?.[0];
+    if (declaration !== void 0 && !this.#bindings.has(declaration)) {
+      addJSDocBinding(declaration, this.#bindings);
+    }
     return declaration !== void 0 && this.#bindings.has(declaration) ? declaration : void 0;
   }
   bindingOf(identifier) {
@@ -740,29 +763,48 @@ function isGenerator(callee, bindings) {
   }
   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);
+function jsDocTypes(node) {
+  if ((node.flags & ts.NodeFlags.JavaScriptFile) === 0) {
+    return [];
+  }
+  return ts.getJSDocTags(node).filter((tag) => ts.isJSDocTypeTag(tag) || ts.isJSDocSatisfiesTag(tag)).map((tag) => tag.typeExpression.type);
+}
+function unwrapped(expression, types = []) {
+  if (ts.isParenthesizedExpression(expression)) {
+    return unwrapped(expression.expression, [...types, ...jsDocTypes(expression)]);
+  }
+  if (ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) {
+    return unwrapped(expression.expression, [...types, expression.type]);
   }
-  return expression;
+  return { value: expression, types };
 }
 const isExported$1 = (declaration) => (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Export) !== 0;
-function constantOptions(name, bindings) {
+function constantOptions(name, bindings, outerTypes) {
   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)) {
+  const found = binding?.kind === "constant" ? unwrapped(binding.initializer) : void 0;
+  if (found === void 0 || !ts.isObjectLiteralExpression(found.value)) {
     return { kind: "unknown", expression: name };
   }
-  const isOwn = bindings.usesOf(declaration).length === 1;
-  return { kind: isOwn && !isExported$1(declaration) ? "own" : "shared", options: value };
+  const isOwn = bindings.usesOf(declaration).length === 1 && !isExported$1(declaration);
+  if (!isOwn) {
+    return { kind: "shared", options: found.value };
+  }
+  const declared = declaration.type;
+  const annotations = [
+    ...outerTypes,
+    ...found.types,
+    ...declared === void 0 ? [] : [declared],
+    ...jsDocTypes(declaration)
+  ];
+  return { kind: "own", options: found.value, annotations };
 }
 function optionsOf(argument, bindings) {
-  const value = unwrapped(argument);
+  const { value, types } = unwrapped(argument);
   if (ts.isObjectLiteralExpression(value)) {
-    return { kind: "own", options: value };
+    return { kind: "own", options: value, annotations: types };
   }
-  return ts.isIdentifier(value) ? constantOptions(value, bindings) : { kind: "unknown", expression: argument };
+  return ts.isIdentifier(value) ? constantOptions(value, bindings, types) : { kind: "unknown", expression: argument };
 }
 function generatorCalls(file, bindings) {
   const calls = [];
@@ -778,6 +820,117 @@ function generatorCalls(file, bindings) {
   return calls;
 }
 
+const TS_NODE_OPTIONS = "OpenAPITSOptions";
+const IR_OPTIONS = "OpenAPITSIrOptions";
+const TYPE_MODIFIER = "type ";
+function importTypeName(node) {
+  const { argument, qualifier } = node;
+  const isGeneratorModule = ts.isLiteralTypeNode(argument) && ts.isStringLiteral(argument.literal) && GENERATOR_MODULES.has(argument.literal.text);
+  const isOptions = !node.isTypeOf && qualifier !== void 0 && ts.isIdentifier(qualifier) && qualifier.text === TS_NODE_OPTIONS;
+  return isGeneratorModule && isOptions ? qualifier : void 0;
+}
+function referencedName$1(node) {
+  if (ts.isTypeReferenceNode(node)) {
+    return node.typeName;
+  }
+  return ts.isExpressionWithTypeArguments(node) ? node.expression : void 0;
+}
+function qualifiedParts(name) {
+  if (ts.isQualifiedName(name)) {
+    return { left: name.left, right: name.right };
+  }
+  return ts.isPropertyAccessExpression(name) ? { left: name.expression, right: name.name } : void 0;
+}
+function optionsTypeName(node, bindings) {
+  if (ts.isImportTypeNode(node)) {
+    return importTypeName(node);
+  }
+  const name = referencedName$1(node);
+  if (name !== void 0 && ts.isIdentifier(name)) {
+    const binding = bindings.bindingOf(name);
+    return binding?.kind === "helper-import" && binding.name === TS_NODE_OPTIONS ? name : void 0;
+  }
+  const parts = name === void 0 ? void 0 : qualifiedParts(name);
+  if (parts === void 0 || !ts.isIdentifier(parts.left) || !ts.isIdentifier(parts.right)) {
+    return void 0;
+  }
+  const isGeneratorModule = bindings.bindingOf(parts.left)?.kind === "generator-module";
+  return isGeneratorModule && parts.right.text === TS_NODE_OPTIONS ? parts.right : void 0;
+}
+function localTypeOf(node, bindings) {
+  const name = referencedName$1(node);
+  const binding = name !== void 0 && ts.isIdentifier(name) ? bindings.bindingOf(name) : void 0;
+  return binding?.kind === "local-type" ? binding.declaration : void 0;
+}
+function mentionsOptionsType(node, bindings, seen = /* @__PURE__ */ new Set()) {
+  const local = localTypeOf(node, bindings);
+  const isNewLocal = local !== void 0 && !seen.has(local);
+  if (isNewLocal) {
+    seen.add(local);
+  }
+  const mentions = (child) => mentionsOptionsType(child, bindings, seen) || void 0;
+  return isNewLocal && mentionsOptionsType(local, bindings, seen) || optionsTypeName(node, bindings) !== void 0 || (ts.forEachChild(node, mentions) ?? false);
+}
+function optionsTypeReferences(annotations, bindings) {
+  const references = [];
+  for (const annotation of annotations) {
+    const target = ts.isIndexedAccessTypeNode(annotation) ? annotation.objectType : annotation;
+    const reference = optionsTypeName(target, bindings);
+    if (reference !== void 0) {
+      references.push(reference);
+    } else if (mentionsOptionsType(annotation, bindings)) {
+      return void 0;
+    }
+  }
+  return references;
+}
+const renamed$1 = (identifier, text) => ({
+  start: identifier.getStart(),
+  end: identifier.getEnd(),
+  text
+});
+function importedIrOptions(bindings) {
+  for (const [declaration, binding] of bindings.declarations) {
+    if (binding.kind === "helper-import" && binding.name === IR_OPTIONS) {
+      return declaration.name.text;
+    }
+  }
+  return void 0;
+}
+function importEdits$1(specifier, references, bindings) {
+  const isJavaScript = (specifier.flags & ts.NodeFlags.JavaScriptFile) !== 0;
+  const isOnlyUse = !isJavaScript && bindings.usesOf(specifier).every((use) => references.includes(use));
+  if (isOnlyUse && specifier.propertyName !== void 0) {
+    return [renamed$1(specifier.propertyName, IR_OPTIONS)];
+  }
+  const uses = references.map((reference) => renamed$1(reference, IR_OPTIONS));
+  if (isOnlyUse) {
+    return [renamed$1(specifier.name, IR_OPTIONS), ...uses];
+  }
+  const isTypeImport = specifier.parent.parent.isTypeOnly;
+  const added = `, ${isTypeImport ? "" : TYPE_MODIFIER}${IR_OPTIONS}`;
+  return [{ start: specifier.getEnd(), end: specifier.getEnd(), text: added }, ...uses];
+}
+function optionsTypeEdits(references, bindings) {
+  const edits = [];
+  const byImport = /* @__PURE__ */ new Map();
+  const existing = importedIrOptions(bindings);
+  for (const reference of new Set(references)) {
+    const specifier = bindings.declarationOf(reference);
+    if (specifier === void 0 || !ts.isImportSpecifier(specifier)) {
+      edits.push(renamed$1(reference, IR_OPTIONS));
+    } else if (existing !== void 0) {
+      edits.push(renamed$1(reference, existing));
+    } else {
+      byImport.set(specifier, [...byImport.get(specifier) ?? [], reference]);
+    }
+  }
+  for (const [specifier, found] of byImport) {
+    edits.push(...importEdits$1(specifier, found, bindings));
+  }
+  return edits;
+}
+
 const SCRIPT_KINDS = /* @__PURE__ */ new Map([
   [".ts", ts.ScriptKind.TS],
   [".mts", ts.ScriptKind.TS],
@@ -789,6 +942,10 @@ const SCRIPT_KINDS = /* @__PURE__ */ new Map([
   [".jsx", ts.ScriptKind.JSX]
 ]);
 const ASTRO_EXTENSION = ".astro";
+const MDX_EXTENSION = ".mdx";
+const MDX_ESM_START_RE = /^(?:import|export)\b/;
+const CODE_FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
+const MDX_KIND = ts.ScriptKind.JSX;
 const SCRIPT_OPEN_TAG = "<script";
 const TAG_END = ">";
 const ASTRO_FRONTMATTER_RE = /^(\s*---\r?\n)([\s\S]*?)\r?\n---/;
@@ -849,12 +1006,87 @@ function componentRegions(text, isAstro) {
   }
   return regions;
 }
+function closesFence(line, fence) {
+  const mark = CODE_FENCE_RE.exec(line)?.[1];
+  return mark !== void 0 && mark[0] === fence[0] && mark.length >= fence.length;
+}
+function mdxRegions(text) {
+  const regions = [];
+  let fence;
+  let block;
+  let offset = 0;
+  for (const line of text.split("\n")) {
+    const end = offset + line.length;
+    if (block !== void 0 && line.trim() === "") {
+      regions.push({
+        offset: block.start,
+        text: text.slice(block.start, block.end),
+        kind: MDX_KIND
+      });
+      block = void 0;
+    } else if (block !== void 0) {
+      block.end = end;
+    } else if (fence !== void 0) {
+      fence = closesFence(line, fence) ? void 0 : fence;
+    } else if (MDX_ESM_START_RE.test(line)) {
+      block = { start: offset, end };
+    } else {
+      fence = CODE_FENCE_RE.exec(line)?.[1];
+    }
+    offset = end + 1;
+  }
+  if (block !== void 0) {
+    regions.push({ offset: block.start, text: text.slice(block.start, block.end), kind: MDX_KIND });
+  }
+  return regions;
+}
 function scriptRegions(text, path) {
   const kind = plainScriptKind(path);
   if (kind !== void 0) {
     return [{ offset: 0, text, kind }];
   }
-  return componentRegions(text, extensionOf$1(path) === ASTRO_EXTENSION);
+  const extension = extensionOf$1(path);
+  if (extension === MDX_EXTENSION) {
+    return mdxRegions(text);
+  }
+  return componentRegions(text, extension === ASTRO_EXTENSION);
+}
+
+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 namedValue(property) {
+  if (ts.isShorthandPropertyAssignment(property)) {
+    return property.name;
+  }
+  return ts.isPropertyAssignment(property) && ts.isIdentifier(property.initializer) ? property.initializer : void 0;
+}
+function callbackFunction(property, names) {
+  if (ts.isMethodDeclaration(property)) {
+    return property;
+  }
+  const name = namedValue(property);
+  if (name !== void 0) {
+    return namedFunction(name, names);
+  }
+  const value = ts.isPropertyAssignment(property) ? property.initializer : void 0;
+  return value !== void 0 && (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) ? value : void 0;
+}
+function callbackAnnotations(property, names) {
+  const name = namedValue(property);
+  const declaration = name === void 0 ? void 0 : names.bindings.declarationOf(name);
+  const type = declaration !== void 0 && ts.isVariableDeclaration(declaration) ? declaration.type : void 0;
+  return type === void 0 ? [] : [type];
+}
+function isSharedFunction(property, names) {
+  const name = namedValue(property);
+  const declaration = name === void 0 ? void 0 : names.bindings.declarationOf(name);
+  return declaration !== void 0 && names.bindings.usesOf(declaration).length > 1;
 }
 
 const KEYWORDS = /* @__PURE__ */ new Map([
@@ -1182,40 +1414,18 @@ function removalEdits(removed, text) {
 const TRANSFORM = "transform";
 const LEGACY_ONLY_CALLBACKS = ["postTransform", "transformProperty"];
 const IR_CALLBACKS_OPTION = "irCallbacks";
+const noFindings = () => ({
+  edits: [],
+  changes: [],
+  manualSteps: [],
+  typeReferences: []
+});
 function propertyNamed(options, name) {
   return options.properties.find((property) => {
     const key = property.name;
     return key !== void 0 && (ts.isIdentifier(key) || ts.isStringLiteral(key)) && key.text === name;
   });
 }
-function 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;
-  }
-  if (!ts.isPropertyAssignment(property)) {
-    return void 0;
-  }
-  const value = property.initializer;
-  if (ts.isIdentifier(value)) {
-    return namedFunction(value, names);
-  }
-  return ts.isArrowFunction(value) || ts.isFunctionExpression(value) ? value : void 0;
-}
-function isSharedFunction(property, names) {
-  if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.initializer)) {
-    return false;
-  }
-  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;
   if (type === void 0) {
@@ -1251,7 +1461,10 @@ ${before}` : `${option} `;
 }
 function keepReason(options) {
   const hasOther = LEGACY_ONLY_CALLBACKS.some((name) => propertyNamed(options, name) !== void 0);
-  return hasOther ? "other-callbacks" : void 0;
+  if (hasOther) {
+    return "other-callbacks";
+  }
+  return options.properties.some(ts.isSpreadAssignment) ? "spread-options" : void 0;
 }
 function legacyCallbackSteps(options, text) {
   return LEGACY_ONLY_CALLBACKS.flatMap((callback) => {
@@ -1259,32 +1472,39 @@ function legacyCallbackSteps(options, text) {
     return property === void 0 ? [] : [{ kind: "legacy-callback", line: lineAt(text, property.getStart()), callback }];
   });
 }
+function transformRewrite(transform, options, names, text) {
+  const edits = keepReason(options.options) ?? transformEdits(transform, names, text);
+  if (typeof edits === "string") {
+    return edits;
+  }
+  const annotations = [...options.annotations, ...callbackAnnotations(transform, names)];
+  const typeReferences = optionsTypeReferences(annotations, names.bindings);
+  return typeReferences === void 0 ? "typed-options" : { edits, typeReferences };
+}
 function migrateOptions(options, text, names) {
-  if (propertyNamed(options, IR_CALLBACKS_OPTION) !== void 0) {
-    return { edits: [], changes: [], manualSteps: [] };
+  if (propertyNamed(options.options, IR_CALLBACKS_OPTION) !== void 0) {
+    return noFindings();
   }
-  const findings = {
-    edits: [],
-    changes: [],
-    manualSteps: legacyCallbackSteps(options, text)
-  };
-  const transform = propertyNamed(options, TRANSFORM);
+  const findings = noFindings();
+  findings.manualSteps.push(...legacyCallbackSteps(options.options, text));
+  const transform = propertyNamed(options.options, TRANSFORM);
   if (transform === void 0) {
     return findings;
   }
   const start = transform.getStart();
   const line = lineAt(text, start);
-  const result = keepReason(options) ?? transformEdits(transform, names, text);
+  const result = transformRewrite(transform, options, names, text);
   if (typeof result === "string") {
     findings.manualSteps.push({ kind: "transform-not-rewritten", line, reason: result });
     return findings;
   }
-  findings.edits.push({ start, end: start, text: irCallbacksOption(text, start) }, ...result);
+  findings.edits.push({ start, end: start, text: irCallbacksOption(text, start) }, ...result.edits);
+  findings.typeReferences.push(...result.typeReferences);
   findings.changes.push({ kind: "transform-rewritten", line });
   return findings;
 }
 function sharedOptionsFindings(options, text) {
-  const findings = { edits: [], changes: [], manualSteps: [] };
+  const findings = noFindings();
   if (propertyNamed(options, IR_CALLBACKS_OPTION) !== void 0) {
     return findings;
   }
@@ -1300,19 +1520,19 @@ function callFindings(found, text, names) {
   const options = found.options;
   switch (options?.kind) {
     case void 0:
-      return { edits: [], changes: [], manualSteps: [] };
+      return noFindings();
     case "own":
-      return migrateOptions(options.options, text, names);
+      return migrateOptions(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 }] };
+      return { ...noFindings(), manualSteps: [{ kind: "options-not-inspected", line }] };
     }
   }
 }
 function findCallFindings(file, text, names) {
-  const all = { edits: [], changes: [], manualSteps: [] };
+  const all = noFindings();
   const seen = /* @__PURE__ */ new Set();
   for (const found of generatorCalls(file, names.bindings)) {
     const options = found.options?.kind === "unknown" ? void 0 : found.options?.options;
@@ -1326,12 +1546,13 @@ function findCallFindings(file, text, names) {
     all.edits.push(...findings.edits);
     all.changes.push(...findings.changes);
     all.manualSteps.push(...findings.manualSteps);
+    all.typeReferences.push(...findings.typeReferences);
   }
   return all;
 }
 function rewriteFile(file, names) {
   const text = file.text;
-  const { edits, changes, manualSteps } = findCallFindings(file, text, names);
+  const { edits, changes, manualSteps, typeReferences } = findCallFindings(file, text, names);
   const removed = unusedDeclarations(names, edits);
   for (const found of removed) {
     changes.push({
@@ -1340,7 +1561,8 @@ function rewriteFile(file, names) {
       name: found.name
     });
   }
-  const allEdits = [...edits, ...removalEdits(removed, text)];
+  const typeEdits = optionsTypeEdits(typeReferences, names.bindings);
+  const allEdits = [...edits, ...typeEdits, ...removalEdits(removed, text)];
   return { text: applyTextEdits(text, allEdits), changes, manualSteps };
 }
 class TypescriptCallbackRewriter {
@@ -1553,6 +1775,14 @@ function scalarText(node) {
   const isWritten = node.type === Scalar.PLAIN && node.value !== null;
   return isWritten ? node.source : void 0;
 }
+const ESCAPES = {
+  "single-quoted-scalar": "''",
+  "double-quoted-scalar": "\\"
+};
+function isEscaped(token) {
+  const escapeStart = token === void 0 ? void 0 : ESCAPES[token.type];
+  return escapeStart !== void 0 && token !== void 0 && "source" in token ? token.source.includes(escapeStart) : false;
+}
 function convertScalar(node, isFlow) {
   const span = spanOf(node);
   const value = scalarText(node);
@@ -1566,6 +1796,7 @@ function convertScalar(node, isFlow) {
     value,
     content: contentRange(node.srcToken, span),
     isFolded: node.type !== Scalar.BLOCK_LITERAL,
+    isEscaped: isEscaped(node.srcToken),
     encode: isReplaceable ? encoderFor(quotings, isFlow) : void 0,
     ...span
   };
@@ -1642,7 +1873,7 @@ function catalogOfSpec(spec) {
   if (!spec.startsWith(CATALOG_PROTOCOL)) {
     return void 0;
   }
-  return spec.slice(CATALOG_PROTOCOL.length) || DEFAULT_CATALOG;
+  return spec.slice(CATALOG_PROTOCOL.length).trim() || DEFAULT_CATALOG;
 }
 class CatalogEntries {
   #keys = /* @__PURE__ */ new Set();
@@ -1655,7 +1886,9 @@ class CatalogEntries {
 }
 const NO_CATALOG_PLAN = {
   inUse: new CatalogEntries(),
-  kept: new CatalogEntries()
+  kept: new CatalogEntries(),
+  defined: new CatalogEntries(),
+  isWorkspaceRoot: false
 };
 
 const PACKAGE_RENAMES = /* @__PURE__ */ new Map([
@@ -1687,20 +1920,31 @@ 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 OVERRIDE_FIELDS = ["overrides", "resolutions"];
+const PNPM_SETTINGS_FIELD = "pnpm";
 const OLD_PEER_DEPENDENTS = /* @__PURE__ */ new Map([
   ["swr-openapi", { peer: "openapi-fetch", range: ">=0.15" }]
 ]);
-const PATH_SEPARATOR$7 = "/";
+const PATH_SEPARATOR$9 = "/";
+const QUERY_START = "?";
 function renamedSpecifier(value) {
-  const slash = value.indexOf(PATH_SEPARATOR$7);
-  const name = slash === -1 ? value : value.slice(0, slash);
+  const ends = [value.indexOf(PATH_SEPARATOR$9), value.indexOf(QUERY_START)].filter(
+    (at) => at !== -1
+  );
+  const name = value.slice(0, ends.length === 0 ? value.length : Math.min(...ends));
   const renamed = PACKAGE_RENAMES.get(name);
   if (renamed === void 0) {
     return void 0;
   }
-  const subpath = value.slice(name.length);
-  return { to: `${renamed}${subpath}`, isDeep: subpath !== "" && subpath !== PATH_SEPARATOR$7 };
+  const rest = value.slice(name.length);
+  const subpath = rest.split(QUERY_START, 1)[0] ?? rest;
+  return { to: `${renamed}${rest}`, isDeep: subpath !== "" && subpath !== PATH_SEPARATOR$9 };
+}
+const NODE_MODULES_FOLDER = "node_modules/";
+function oldPackageInNodeModules(path) {
+  return [...PACKAGE_RENAMES.keys()].find(
+    (name) => path.includes(`${NODE_MODULES_FOLDER}${name}${PATH_SEPARATOR$9}`)
+  );
 }
 
 const isMap = (node) => node?.kind === "map";
@@ -1743,13 +1987,13 @@ function unreadableConfig(text, offset) {
 }
 
 const PARENT_SEPARATOR = ">";
-const PATH_SEPARATOR$6 = "/";
+const PATH_SEPARATOR$8 = "/";
 const SCOPE_PREFIX$2 = "@";
 function overrideTarget(key) {
   const child = key.split(PARENT_SEPARATOR).at(-1) ?? key;
-  const segments = child.split(PATH_SEPARATOR$6);
+  const segments = child.split(PATH_SEPARATOR$8);
   const isScoped = segments.length > 1 && segments.at(-2)?.startsWith(SCOPE_PREFIX$2) === true;
-  const name = isScoped ? segments.slice(-2).join(PATH_SEPARATOR$6) : segments.at(-1) ?? child;
+  const name = isScoped ? segments.slice(-2).join(PATH_SEPARATOR$8) : segments.at(-1) ?? child;
   const versionAt = name.indexOf(SCOPE_PREFIX$2, 1);
   return versionAt === -1 ? name : name.slice(0, versionAt);
 }
@@ -1786,7 +2030,7 @@ function nestedKeys(node) {
   return textEntries(node).flatMap(({ key, value }) => [key.value, ...nestedKeys(value)]);
 }
 
-const PATH_SEPARATOR$5 = ".";
+const PATH_SEPARATOR$7 = ".";
 function catalogMaps(root, prefix = "") {
   const maps = mapsAt(root, CATALOG_FIELD).map((map) => ({
     name: DEFAULT_CATALOG,
@@ -1796,7 +2040,7 @@ function catalogMaps(root, prefix = "") {
   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);
+        const label = [prefix + NAMED_CATALOGS_FIELD, key.value].join(PATH_SEPARATOR$7);
         maps.push({ name: key.value, label, map: value });
       }
     }
@@ -1806,7 +2050,7 @@ function catalogMaps(root, prefix = "") {
 const manifestCatalogMaps = (manifest) => [
   ...catalogMaps(manifest),
   ...mapsAt(manifest, WORKSPACES_FIELD).flatMap(
-    (workspaces) => catalogMaps(workspaces, `${WORKSPACES_FIELD}${PATH_SEPARATOR$5}`)
+    (workspaces) => catalogMaps(workspaces, `${WORKSPACES_FIELD}${PATH_SEPARATOR$7}`)
   )
 ];
 function entriesInUse(manifests) {
@@ -1837,7 +2081,7 @@ function nestedTexts(node) {
 }
 function addOverrideUses(documents, inUse) {
   const sections = documents.flatMap(
-    (document) => OVERRIDE_FIELDS.flatMap((field) => valuesAt(document, field))
+    (document) => [...OVERRIDE_FIELDS, PNPM_SETTINGS_FIELD].flatMap((field) => valuesAt(document, field))
   );
   for (const { key, value } of sections.flatMap(nestedTexts)) {
     const catalog = catalogOfSpec(value);
@@ -1847,10 +2091,15 @@ function addOverrideUses(documents, inUse) {
     }
   }
 }
-function planCatalogs({ manifests, catalogFiles }) {
+function planCatalogs({
+  manifests,
+  catalogFiles,
+  isWorkspaceRoot
+}) {
   const inUse = entriesInUse(manifests);
   addOverrideUses([...manifests, ...catalogFiles], inUse);
   const kept = new CatalogEntries();
+  const defined = new CatalogEntries();
   const catalogs = [
     ...catalogFiles.flatMap((file) => catalogMaps(file)),
     ...manifests.flatMap(manifestCatalogMaps)
@@ -1859,6 +2108,7 @@ function planCatalogs({ manifests, catalogFiles }) {
     const entries = specEntries(map);
     const names = new Set(entries.map((entry) => entry.name));
     for (const { name, spec } of entries) {
+      defined.add(catalog, name);
       const to = PACKAGE_RENAMES.get(name);
       const stays = spec === void 0 || inUse.has(catalog, name);
       if (to !== void 0 && !names.has(to) && stays) {
@@ -1866,7 +2116,7 @@ function planCatalogs({ manifests, catalogFiles }) {
       }
     }
   }
-  return { inUse, kept };
+  return { inUse, kept, defined, isWorkspaceRoot };
 }
 
 const NO_LONGER_INSTALLED = /* @__PURE__ */ new Map([
@@ -1875,13 +2125,13 @@ const NO_LONGER_INSTALLED = /* @__PURE__ */ new Map([
 const ORIGINAL_NAMES = new Map(
   [...PACKAGE_RENAMES].map(([original, successor]) => [successor, original])
 );
-const PATH_SEPARATOR$4 = "/";
+const PATH_SEPARATOR$6 = "/";
 function namesUninstalledPackage(text) {
   return [...NO_LONGER_INSTALLED.keys()].some(
     (name) => text.includes(name) || text.includes(ORIGINAL_NAMES.get(name) ?? name)
   );
 }
-const directoryOf = (path) => path.slice(0, path.lastIndexOf(PATH_SEPARATOR$4) + 1);
+const directoryOf = (path) => path.slice(0, path.lastIndexOf(PATH_SEPARATOR$6) + 1);
 function declaredNames(manifest) {
   return DEPENDENCY_FIELDS.flatMap((field) => mapsAt(manifest, field)).flatMap(textEntries).map(({ key }) => key.value);
 }
@@ -1892,7 +2142,7 @@ function isDeclaredFor(manifests, filePath, name) {
   return containing.length === 0 || containing.some(declares);
 }
 const packageOfSpecifier = (specifier) => {
-  const slash = specifier.indexOf(PATH_SEPARATOR$4);
+  const slash = specifier.indexOf(PATH_SEPARATOR$6);
   return slash === -1 ? specifier : specifier.slice(0, slash);
 };
 function undeclaredImportSteps(imports, filePath, manifests) {
@@ -1966,11 +2216,11 @@ function migrateVersionSpec(spec, version) {
 
 const NPM_PROTOCOL = "npm:";
 const SCOPE_PREFIX$1 = "@";
-const PATH_SEPARATOR$3 = "/";
+const PATH_SEPARATOR$5 = "/";
 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);
+  const searchFrom = text.startsWith(SCOPE_PREFIX$1) ? text.indexOf(PATH_SEPARATOR$5) + 1 : 0;
+  const ends = [VERSION_SEPARATOR, PATH_SEPARATOR$5].map((separator) => text.indexOf(separator, Math.max(searchFrom, 1))).filter((index) => index !== -1);
   return ends.length === 0 ? text.length : Math.min(...ends);
 }
 function parseNpmSpec(spec) {
@@ -1978,17 +2228,21 @@ function parseNpmSpec(spec) {
     return void 0;
   }
   const body = spec.slice(NPM_PROTOCOL.length);
-  const lead = body.startsWith(PATH_SEPARATOR$3) ? PATH_SEPARATOR$3 : "";
+  const lead = body.startsWith(PATH_SEPARATOR$5) ? PATH_SEPARATOR$5 : "";
   const text = body.slice(lead.length);
   const end = nameEnd(text);
   const name = text.slice(0, end);
   if (!text.startsWith(VERSION_SEPARATOR, end)) {
     return { lead, name, range: void 0, rest: text.slice(end) };
   }
-  const rangeEnd = text.indexOf(PATH_SEPARATOR$3, end);
+  const rangeEnd = text.indexOf(PATH_SEPARATOR$5, end);
   const restStart = rangeEnd === -1 ? text.length : rangeEnd;
   return { lead, name, range: text.slice(end + 1, restStart), rest: text.slice(restStart) };
 }
+function isOldPackageNpmSpec(spec) {
+  const parsed = parseNpmSpec(spec);
+  return parsed !== void 0 && PACKAGE_RENAMES.has(parsed.name);
+}
 function migrateNpmSpec(spec, version) {
   const parsed = parseNpmSpec(spec);
   const renamed = parsed === void 0 ? void 0 : PACKAGE_RENAMES.get(parsed.name);
@@ -1996,7 +2250,7 @@ function migrateNpmSpec(spec, version) {
     return void 0;
   }
   const head = `${NPM_PROTOCOL}${parsed.lead}${renamed}`;
-  const isDeep = parsed.rest !== "" && parsed.rest !== PATH_SEPARATOR$3;
+  const isDeep = parsed.rest !== "" && parsed.rest !== PATH_SEPARATOR$5;
   if (parsed.range === void 0) {
     return { spec: `${head}${parsed.rest}`, isReported: false, isDeep };
   }
@@ -2099,7 +2353,15 @@ function catalogHold(entry, spec, { map, catalogs }) {
     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;
+  if (catalog === void 0) {
+    return void 0;
+  }
+  const reference = { field: mapLabel(map), name: entry.name, catalog };
+  if (!catalogs.defined.has(catalog, entry.name)) {
+    const kind = catalogs.isWorkspaceRoot ? "catalog-entry-missing" : "catalog-entry-outside";
+    return { kind, ...reference };
+  }
+  return catalogs.kept.has(catalog, entry.name) ? { kind: "catalog-reference-kept", ...reference } : void 0;
 }
 function migrateSpecMap(entries, context) {
   const names = new Set(entries.map((entry) => entry.name));
@@ -2139,34 +2401,34 @@ function renameNames(entries, field, findings) {
   }
 }
 
-const IMPORTS_FIELD = "imports";
+const IMPORTS_FIELD$1 = "imports";
 const SCOPES_FIELD = "scopes";
-const FIELD_SEPARATOR = ".";
+const FIELD_SEPARATOR$2 = ".";
 function migrateImports(config, version, findings) {
-  for (const imports of mapsAt(config, IMPORTS_FIELD)) {
-    const map = { kind: "imports", field: IMPORTS_FIELD };
+  for (const imports of mapsAt(config, IMPORTS_FIELD$1)) {
+    const map = { kind: "imports", field: IMPORTS_FIELD$1 };
     migrateSpecMap(specEntries(imports), { map, version, findings, catalogs: NO_CATALOG_PLAN });
   }
   for (const scopes of mapsAt(config, SCOPES_FIELD)) {
     for (const { key, value } of textEntries(scopes)) {
       if (isMap(value)) {
-        const field = [SCOPES_FIELD, key.value].join(FIELD_SEPARATOR);
+        const field = [SCOPES_FIELD, key.value].join(FIELD_SEPARATOR$2);
         const map = { kind: "imports", field };
         migrateSpecMap(specEntries(value), { map, version, findings, catalogs: NO_CATALOG_PLAN });
       }
     }
   }
 }
-const PATH_SEPARATOR$2 = "/";
+const PATH_SEPARATOR$4 = "/";
 const SCOPE_PREFIX = "@";
 function importMapKeys(config) {
   const scoped = mapsAt(config, SCOPES_FIELD).flatMap(textEntries).flatMap(({ value }) => isMap(value) ? [value] : []);
-  return [...mapsAt(config, IMPORTS_FIELD), ...scoped].flatMap(textEntries).map(({ key }) => key.value);
+  return [...mapsAt(config, IMPORTS_FIELD$1), ...scoped].flatMap(textEntries).map(({ key }) => key.value);
 }
 function importMapNames(config) {
   return importMapKeys(config).map((key) => {
-    const parts = key.split(PATH_SEPARATOR$2);
-    return key.startsWith(SCOPE_PREFIX) ? parts.slice(0, 2).join(PATH_SEPARATOR$2) : parts[0] ?? key;
+    const parts = key.split(PATH_SEPARATOR$4);
+    return key.startsWith(SCOPE_PREFIX) ? parts.slice(0, 2).join(PATH_SEPARATOR$4) : parts[0] ?? key;
   });
 }
 function migrateImportMap(text, read, version) {
@@ -2223,6 +2485,32 @@ const container = (words) => ({
   ...launcher(words, NONE, CONTAINER_OPTIONS),
   operands: 1
 });
+const withOperands = (words, operands, valueOptions = NONE) => ({ ...launcher(words, NONE, valueOptions), operands });
+const XARGS_OPTIONS = /* @__PURE__ */ new Set([
+  "-I",
+  "-J",
+  "-L",
+  "-n",
+  "-P",
+  "-R",
+  "-S",
+  "-s",
+  "-d",
+  "-E",
+  "-a",
+  "--max-args",
+  "--max-procs",
+  "--max-lines",
+  "--delimiter",
+  "--arg-file"
+]);
+const NODE_OPTIONS = /* @__PURE__ */ new Set([
+  "-r",
+  "--require",
+  "--import",
+  "--loader",
+  "--env-file"
+]);
 const LAUNCHERS = [
   launcher(["npm", "exec"], PACKAGE_OPTIONS),
   launcher(["npm", "x"], PACKAGE_OPTIONS),
@@ -2231,19 +2519,36 @@ const LAUNCHERS = [
   launcher(["yarn", "dlx"], PACKAGE_OPTIONS),
   launcher(["yarn", "exec"]),
   launcher(["bun", "x"], PACKAGE_OPTIONS),
+  withOperands(["yarn", "workspace"], 1),
+  launcher(["dotenvx", "run"], NONE, /* @__PURE__ */ new Set(["-f", "--env-file", "-e", "--env", "--convention"])),
+  launcher(
+    ["doppler", "run"],
+    NONE,
+    /* @__PURE__ */ new Set(["-p", "--project", "-c", "--config", "--token", "--mount", "--scope"])
+  ),
+  launcher(["nx", "exec"], NONE, /* @__PURE__ */ new Set(["--projects", "-p", "--exclude"])),
   launcher(["deno", "run"], NONE, /* @__PURE__ */ new Set(["--config", "-c", "--import-map", "--location"])),
   launcher(["deno", "x"]),
   launcher(["npx"], PACKAGE_OPTIONS, /* @__PURE__ */ new Set(["-c", "--call"])),
   launcher(["pnpx"], PACKAGE_OPTIONS),
   launcher(["bunx"], PACKAGE_OPTIONS),
+  // Like a bare `pnpm <name>`, a bare `bun <name>` runs the binary when no script has the name.
+  launcher(["bun"], NONE, /* @__PURE__ */ new Set(["--cwd", "--filter", "-F"])),
+  launcher(["corepack"]),
   launcher(["pnpm"], NONE, PACKAGE_MANAGER_OPTIONS),
   launcher(["yarn"], NONE, PACKAGE_MANAGER_OPTIONS),
-  launcher(["node"], NONE, /* @__PURE__ */ new Set(["-r", "--require", "--import", "--loader", "--env-file"])),
+  launcher(["node"], NONE, NODE_OPTIONS),
+  launcher(["tsx"], NONE, NODE_OPTIONS),
+  launcher(["ts-node"], NONE, /* @__PURE__ */ new Set([...NODE_OPTIONS, "-P", "--project", "-O", "--compiler"])),
   launcher(["cross-env"]),
   launcher(["dotenv"], NONE, /* @__PURE__ */ new Set(["-e", "-c", "-v"])),
   launcher(["env"], NONE, /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"])),
-  launcher(["exec"]),
+  launcher(["exec"], NONE, /* @__PURE__ */ new Set(["-a"])),
+  launcher(["command"]),
   launcher(["time"]),
+  launcher(["nice"], NONE, /* @__PURE__ */ new Set(["-n", "--adjustment"])),
+  withOperands(["timeout"], 1, /* @__PURE__ */ new Set(["-s", "--signal", "-k", "--kill-after"])),
+  launcher(["xargs"], NONE, XARGS_OPTIONS),
   launcher(["nohup"]),
   launcher(["sudo"], NONE, /* @__PURE__ */ new Set(["-u", "-g"])),
   // The shell form of Dockerfile instructions runs the rest of the line in a shell.
@@ -2263,6 +2568,9 @@ const INSTALLERS = [
   ...installers("npm", NPM_INSTALL),
   ...installers("pnpm", ["add", "update", "up", "remove", "rm", "uninstall", "un"]),
   ...installers("yarn", ["add", "upgrade", "up", "remove"]),
+  // Yarn 1 installs global packages with `yarn global add`.
+  { words: ["yarn", "global", "add"] },
+  { words: ["yarn", "global", "remove"] },
   ...installers("bun", ["add", "a", "update", "remove", "rm", "install", "i"]),
   ...installers("deno", ["add", "install", "i", "remove", "uninstall"])
 ];
@@ -2270,7 +2578,7 @@ 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;
+const isOption$1 = (word) => word.value.startsWith("-") && word.value.length > 1;
 function skipAssignments(words, start) {
   let index = start;
   while (index < words.length && ASSIGNMENT_RE$1.test(words[index].raw)) {
@@ -2290,7 +2598,7 @@ function inlineOptionPackage(word, launcher) {
 }
 function launchedProgram(words, start, launcher, packages) {
   let index = start;
-  while (index < words.length && isOption(words[index])) {
+  while (index < words.length && isOption$1(words[index])) {
     const option = words[index++];
     if (option.value === END_OF_OPTIONS) {
       break;
@@ -2309,7 +2617,7 @@ function launchedProgram(words, start, launcher, packages) {
   }
   return index;
 }
-const installArguments = (words, start) => words.slice(start).filter((word) => !isOption(word)).map((word) => ({ word, value: word.value }));
+const installArguments = (words, start) => words.slice(start).filter((word) => !isOption$1(word)).map((word) => ({ word, value: word.value }));
 function commandRoles(words) {
   const packages = [];
   let index = skipAssignments(words, 0);
@@ -2330,10 +2638,32 @@ function commandRoles(words) {
   return { program: void 0, packages };
 }
 
-const COMMAND_SEPARATORS = /* @__PURE__ */ new Set([";", "&", "|", "(", ")", "`", "\n"]);
+function packageReference(value) {
+  const bare = value.startsWith(NPM_SPECIFIER_PREFIX) ? value.slice(NPM_SPECIFIER_PREFIX.length) : value;
+  const at = bare.indexOf("@", 1);
+  return { name: at === -1 ? bare : bare.slice(0, at), isPinned: at !== -1 };
+}
+function namesOldPackage(value) {
+  return PACKAGE_RENAMES.has(packageReference(value).name) || oldPackageInNodeModules(value) !== void 0 || value.endsWith(`/${GENERATOR_COMMAND}`);
+}
+function unmigratedWordFindings(words, handledOffsets, locate) {
+  return words.filter((word) => !handledOffsets.has(word.start) && namesOldPackage(word.value)).map((word) => ({
+    offset: word.start,
+    manualStep: { kind: "old-name-in-command", location: locate(word.start), word: word.value }
+  }));
+}
+
+const COMMAND_SEPARATORS = /* @__PURE__ */ new Set([
+  ";",
+  "&",
+  "|",
+  "(",
+  ")",
+  "`",
+  "\n"
+]);
 const WORD_BREAKS = /* @__PURE__ */ new Set([" ", "	", "\r", "<", ">"]);
 const BACKSLASH$1 = "\\";
-const COMMENT = "#";
 const DOUBLE_QUOTE_ESCAPES = /* @__PURE__ */ new Set(["$", "`", '"', BACKSLASH$1, "\n"]);
 function singleQuoted(text, start) {
   const close = text.indexOf("'", start + 1);
@@ -2352,8 +2682,26 @@ function doubleQuoted(text, start) {
   return { end: Math.min(index + 1, text.length), value };
 }
 const isLineContinuation = (text, index) => text[index] === BACKSLASH$1 && (text[index + 1] === "\n" || text.startsWith("\r\n", index + 1));
+const ARITHMETIC_OPEN = "$((";
+const NESTING_OPEN = "(";
+const NESTING_CLOSE = ")";
+const ARITHMETIC_DEPTH = 2;
+function arithmeticExpansion(text, start) {
+  let depth = ARITHMETIC_DEPTH;
+  for (let index = start + ARITHMETIC_OPEN.length; index < text.length; index++) {
+    depth += text[index] === NESTING_OPEN ? 1 : text[index] === NESTING_CLOSE ? -1 : 0;
+    if (depth === 0) {
+      return { end: index + 1, value: text.slice(start, index + 1) };
+    }
+  }
+  return void 0;
+}
 function wordPart(text, index) {
   const char = text[index];
+  const arithmetic = text.startsWith(ARITHMETIC_OPEN, index) ? arithmeticExpansion(text, index) : void 0;
+  if (arithmetic !== void 0) {
+    return arithmetic;
+  }
   if (char === "'") {
     return singleQuoted(text, index);
   }
@@ -2379,6 +2727,65 @@ function readWord(text, start) {
   }
   return { start, end: index, value, raw: text.slice(start, index) };
 }
+
+const HEREDOC_OPERATOR = "<<";
+const HERE_STRING_OPERATOR = "<<<";
+const STRIP_TABS = "-";
+const LINE_BREAK$2 = "\n";
+const LEADING_TABS_RE = /^\t+/;
+const CARRIAGE_RETURN_RE = /\r$/;
+function heredocAt(text, index, where) {
+  if (text.startsWith(HERE_STRING_OPERATOR, index)) {
+    return { end: index + HERE_STRING_OPERATOR.length };
+  }
+  if (!text.startsWith(HEREDOC_OPERATOR, index)) {
+    return void 0;
+  }
+  let start = index + HEREDOC_OPERATOR.length;
+  const isTabStripped = text[start] === STRIP_TABS;
+  start += isTabStripped ? 1 : 0;
+  while (text[start] === " " || text[start] === "	") {
+    start++;
+  }
+  const word = readWord(text, start);
+  const pending = { delimiter: word.value, isTabStripped, ...where };
+  return word.value === "" ? void 0 : { pending, end: word.end };
+}
+function isDelimiterLine(text, lineStart, end, heredoc) {
+  let first = lineStart;
+  while (first < lineStart + heredoc.indent && text[first] === " ") {
+    first++;
+  }
+  const line = text.slice(first, end).replace(CARRIAGE_RETURN_RE, "");
+  const compared = heredoc.isTabStripped ? line.replace(LEADING_TABS_RE, "") : line;
+  return compared === heredoc.delimiter;
+}
+function readBody(text, start, heredoc) {
+  let lineStart = start;
+  while (lineStart < text.length) {
+    const lineEnd = text.indexOf(LINE_BREAK$2, lineStart);
+    const end = lineEnd === -1 ? text.length : lineEnd;
+    if (isDelimiterLine(text, lineStart, end, heredoc)) {
+      const body = { command: heredoc.command, start, text: text.slice(start, lineStart) };
+      return { body, end: Math.min(end + 1, text.length) };
+    }
+    lineStart = end + 1;
+  }
+  return { body: { command: heredoc.command, start, text: text.slice(start) }, end: text.length };
+}
+function readBodies(text, start, pending) {
+  const bodies = [];
+  let end = start;
+  for (const heredoc of pending) {
+    const read = readBody(text, end, heredoc);
+    bodies.push(read.body);
+    end = read.end;
+  }
+  return { bodies, end };
+}
+
+const COMMENT = "#";
+const LINE_BREAK$1 = "\n";
 function skipTrivia(text, index) {
   const char = text[index];
   if (WORD_BREAKS.has(char)) {
@@ -2393,14 +2800,31 @@ function skipTrivia(text, index) {
   }
   return index;
 }
-function topLevelCommands(text) {
+const PIPE = "|";
+function topLevelCommands(text, indent) {
   const commands = [[]];
+  const heredocs = [];
+  const pipes = /* @__PURE__ */ new Set();
+  let pending = [];
   let index = 0;
   while (index < text.length) {
     const afterTrivia = skipTrivia(text, index);
-    if (afterTrivia !== index) {
+    const heredoc = heredocAt(text, index, { command: commands.length - 1, indent });
+    if (heredoc !== void 0) {
+      pending.push(...heredoc.pending === void 0 ? [] : [heredoc.pending]);
+      index = heredoc.end;
+    } else if (afterTrivia !== index) {
       index = afterTrivia;
+    } else if (text[index] === LINE_BREAK$1 && pending.length > 0) {
+      const read = readBodies(text, index + 1, pending);
+      heredocs.push(...read.bodies);
+      pending = [];
+      commands.push([]);
+      index = read.end;
     } else if (COMMAND_SEPARATORS.has(text[index])) {
+      if (text[index] === PIPE) {
+        pipes.add(commands.length - 1);
+      }
       commands.push([]);
       index++;
     } else {
@@ -2409,7 +2833,7 @@ function topLevelCommands(text) {
       index = word.end;
     }
   }
-  return commands.filter((words) => words.length > 0);
+  return { commands, heredocs, pipes };
 }
 const COMMAND_PREFIX_WORDS = /* @__PURE__ */ new Set([
   "if",
@@ -2451,29 +2875,57 @@ function nestedCommandText(word) {
   const isOneQuotedString = QUOTES$2.has(quote) && word.raw.length > 1 && word.raw.endsWith(quote) && wordPart(word.raw, 0).end === word.raw.length;
   return isOneQuotedString && NESTED_COMMAND_RE.test(word.value) ? word.raw.slice(1, -1) : void 0;
 }
+const SHELLS$1 = /* @__PURE__ */ new Set(["sh", "bash", "dash", "ash", "zsh", "ksh"]);
+const DOCKER_RUN = "RUN";
+const PASS_THROUGH = "cat";
+const PATH_SEPARATOR$3 = "/";
+const OPTION_PREFIX$1 = "-";
+const programName = (command) => command[0]?.value.split(PATH_SEPARATOR$3).at(-1) ?? "";
+const isOption = (word) => word.value.startsWith(OPTION_PREFIX$1);
+const isScriptShell = (command) => SHELLS$1.has(programName(command)) && command.slice(1).every(isOption);
+function readsScript(command) {
+  if (programName(command) !== DOCKER_RUN) {
+    return isScriptShell(command);
+  }
+  const after = command.slice(1);
+  const shell = after.slice(after.findIndex((word) => !isOption(word)));
+  return after.every(isOption) || isScriptShell(shell);
+}
+const passesThrough = (command) => programName(command) === PASS_THROUGH && command.slice(1).every(isOption);
+function scriptsRunBy(top, index, command) {
+  const previous = index - 1;
+  const isPipedScript = top.pipes.has(previous) && isScriptShell(command) && passesThrough(simpleCommand(top.commands[previous] ?? []));
+  return top.heredocs.filter(
+    (body) => body.command === index && readsScript(command) || body.command === previous && isPipedScript
+  );
+}
 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 shellCommandsAt(text, offset, indent = 0) {
+  return shellCommands(text, indent).map((words) => shifted(words, offset));
 }
-function shellCommands(text) {
+function shellCommands(text, indent = 0) {
+  const top = topLevelCommands(text, indent);
   const commands = [];
-  for (const command of topLevelCommands(text).map(simpleCommand)) {
+  for (const [index, words] of top.commands.entries()) {
+    const command = simpleCommand(words);
     if (command.length > 0) {
       commands.push(command);
     }
     for (const word of command) {
       const inner = nestedCommandText(word);
       if (inner !== void 0) {
-        const nested = shellCommands(inner).map((words) => shifted(words, word.start + 1));
+        const nested = shellCommands(inner).map((found) => shifted(found, word.start + 1));
         commands.push(...nested);
       }
     }
+    const scripts = scriptsRunBy(top, index, command);
+    commands.push(...scripts.flatMap((body) => shellCommandsAt(body.text, body.start, indent)));
   }
   return commands;
 }
 
 const QUOTES$1 = /* @__PURE__ */ new Set(["'", '"']);
-const PATH_SEPARATOR$1 = "/";
+const PATH_SEPARATOR$2 = "/";
 const BIN_FOLDER = "/.bin/";
 const OLD_PACKAGE_FOLDER = `node_modules/${GENERATOR_COMMAND}/`;
 function renameAtEnd(word, name, to) {
@@ -2484,11 +2936,6 @@ function renameAtEnd(word, name, to) {
   }
   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);
@@ -2514,7 +2961,7 @@ function programPathFindings(word, location) {
   return edit === void 0 ? [] : [{ offset, edit, change: { kind: "command-renamed", location } }];
 }
 function programFindings(word, location) {
-  if (word.value.includes(PATH_SEPARATOR$1)) {
+  if (word.value.includes(PATH_SEPARATOR$2)) {
     return programPathFindings(word, location);
   }
   const { name, isPinned } = packageReference(word.value);
@@ -2594,6 +3041,11 @@ function uncertainFlagSteps(program, variable, found, locate) {
 }
 function commandFindings(command, locate, variables) {
   const words = withoutRecipePrefix(command);
+  const found = knownFindings(words, locate, variables);
+  const handled = new Set(found.map((finding) => finding.offset));
+  return [...found, ...unmigratedWordFindings(words, handled, locate)];
+}
+function knownFindings(words, locate, variables) {
   const roles = commandRoles(words);
   const findings = roles.packages.flatMap((found2) => packageFindings(found2, locate));
   const program = roles.program === void 0 ? void 0 : words[roles.program];
@@ -2646,6 +3098,45 @@ function migrateCommandLines(text, file) {
   return migrateShellText(text, (offset) => `${file}:${lineOf(offset)}`);
 }
 
+const ANY = "*";
+const nxOptionPaths = (prefix) => [
+  [...prefix, "command"],
+  [...prefix, "commands", ANY],
+  [...prefix, "commands", ANY, "command"]
+];
+const nxTargetPaths = (prefix) => [
+  [...prefix, ANY, "command"],
+  ...nxOptionPaths([...prefix, ANY, "options"]),
+  ...nxOptionPaths([...prefix, ANY, "configurations", ANY])
+];
+const lintStagedPaths = (prefix) => [
+  [...prefix, ANY],
+  [...prefix, ANY, ANY]
+];
+const simpleGitHooksPaths = (prefix) => [
+  [...prefix, ANY]
+];
+const NX_PROJECT_COMMAND_PATHS = nxTargetPaths(["targets"]);
+const NX_WORKSPACE_COMMAND_PATHS = nxTargetPaths([
+  "targetDefaults"
+]);
+const MANIFEST_COMMAND_PATHS = [
+  ["scripts", ANY],
+  ...simpleGitHooksPaths(["simple-git-hooks"]),
+  ...lintStagedPaths(["lint-staged"]),
+  ...nxTargetPaths(["nx", "targets"])
+];
+const LINT_STAGED_COMMAND_PATHS = lintStagedPaths([]);
+const SIMPLE_GIT_HOOKS_COMMAND_PATHS = simpleGitHooksPaths(
+  []
+);
+const DENO_TASK_PATHS = [
+  ["tasks", ANY],
+  ["tasks", ANY, "command"]
+];
+const matches = (path, pattern) => path.length === pattern.length && pattern.every((part, index) => part === ANY || part === String(path[index]));
+const isCommandPath = (path, patterns) => patterns.some((pattern) => matches(path, pattern));
+
 const NO_LOCATION = "";
 function commandStringSteps(text, strings) {
   const lineOf = lineLocator(text);
@@ -2745,7 +3236,7 @@ const OPTION_PREFIX = "-";
 const LONG_OPTION_PREFIX = "--";
 const COMMAND_OPTION = "c";
 const SET_OPTION = "-o";
-const PATH_SEPARATOR = "/";
+const PATH_SEPARATOR$1 = "/";
 const ARRAY_BLANK_RE = /(?:[ \t\r\n]|\\\r?\n)*/y;
 const QUOTED_RE = /"(?:[^"\\\n]|\\.)*"/y;
 const ITEM_SEPARATOR = ",";
@@ -2802,7 +3293,7 @@ function execForms(text) {
   });
 }
 function shellScript(words) {
-  const program = words[0]?.value.split(PATH_SEPARATOR).at(-1) ?? "";
+  const program = words[0]?.value.split(PATH_SEPARATOR$1).at(-1) ?? "";
   if (!SHELLS.has(program)) {
     return void 0;
   }
@@ -2895,77 +3386,251 @@ function migrateDockerfile(text, file) {
   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) });
+const IMPORT_MAP_FIELD = "importMap";
+const SEPARATOR = "/";
+const CURRENT_FOLDER = ".";
+const PARENT_FOLDER = "..";
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/i;
+function importMapReferences(roots) {
+  return roots.flatMap((root) => valuesAt(root, IMPORT_MAP_FIELD)).flatMap((value) => isScalar(value) ? [value.value] : []);
+}
+function resolvedPath(configPath, reference) {
+  const parts = configPath.split(SEPARATOR).slice(0, -1);
+  for (const part of reference.split(SEPARATOR)) {
+    if (part === PARENT_FOLDER) {
+      if (parts.pop() === void 0) {
+        return void 0;
+      }
+    } else if (part !== CURRENT_FOLDER && part !== "") {
+      parts.push(part);
     }
   }
-  return { text: applyTextEdits(text, edits), changes, manualSteps };
+  return parts.join(SEPARATOR);
+}
+function importMapLocation(configPath, reference) {
+  const isOutside = URL_SCHEME.test(reference) || reference.startsWith(SEPARATOR);
+  const path = isOutside ? void 0 : resolvedPath(configPath, reference);
+  return path === void 0 || path === "" ? { kind: "not-editable", reference } : { kind: "in-project", path };
+}
+const importMapLocations = (configPath, roots) => importMapReferences(roots).map((reference) => importMapLocation(configPath, reference));
+function importMapSteps(configPath, read) {
+  const roots = read.kind === "read" ? read.documents.filter(isMap) : [];
+  return importMapLocations(configPath, roots).flatMap(
+    (location) => location.kind === "not-editable" ? [{ kind: "import-map-not-editable", reference: location.reference }] : []
+  );
 }
 
-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;
-    }
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".mdx"
+]);
+function renamedValue(value, version) {
+  const npm = migrateNpmSpec(value, version);
+  if (npm === void 0) {
+    return renamedSpecifier(value);
   }
-  return void 0;
+  const renamed = { to: npm.spec, isDeep: npm.isDeep };
+  return npm.isReported ? { ...renamed, keptSpec: hideUrlCredentials(value) } : renamed;
 }
-function maskExpansions(text) {
-  const parts = [];
-  let copiedUpTo = 0;
-  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) {
+const namesRenamedModule = (value) => isOldPackageNpmSpec(value) || renamedSpecifier(value) !== void 0;
+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 = [];
+  const enclosing = [];
+  for (const found of [...strings].sort(byStartThenOuter)) {
+    const previous = distinct.at(-1);
+    if (previous?.start === found.start && previous.end === found.end) {
+      const isModuleSpecifier = previous.isModuleSpecifier || found.isModuleSpecifier;
+      distinct[distinct.length - 1] = { ...previous, isModuleSpecifier };
+      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 ${outer.start}-${outer.end} and ${found.start}-${found.end}; the file was not changed.`
+      );
+    }
+    enclosing.push(found);
+    distinct.push(found);
+  }
+  return distinct;
+}
+const dynamicStep = (line, value, to) => ({
+  kind: "dynamic-specifier",
+  line,
+  value,
+  to
+});
+function unrenamedSteps(found, line, dynamic) {
+  if (dynamic !== void 0) {
+    return [dynamicStep(line, found.value, dynamic)];
+  }
+  const name = found.isModuleSpecifier ? oldPackageInNodeModules(found.value) : void 0;
+  const to = name === void 0 ? void 0 : PACKAGE_RENAMES.get(name);
+  return name === void 0 || to === void 0 ? [] : [{ kind: "old-package-import", line, specifier: found.value, name, to }];
+}
+function migrateModuleSpecifiers(text, strings, version) {
+  const changes = [];
+  const manualSteps = [];
+  let migrated = "";
+  let copiedUpTo = 0;
+  const lineOf = lineLocator(text);
+  for (const found of distinctStrings(strings)) {
+    const renamed = renamedValue(found.value, version);
+    const line = lineOf(found.start);
+    const dynamic = found.isModuleSpecifier ? dynamicPackage(found.value) : void 0;
+    if (renamed === void 0) {
+      manualSteps.push(...unrenamedSteps(found, line, dynamic));
+      continue;
+    }
+    if (!found.isModuleSpecifier || found.start < copiedUpTo) {
+      manualSteps.push({ kind: "string-names-package", line, value: found.value, to: renamed.to });
+      continue;
+    }
+    changes.push({ kind: "specifier-renamed", line, from: found.value, to: renamed.to });
+    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 JEST_CONFIG_RE = /^jest\.config\.(?:[cm]?[jt]s|json)$/;
+const JEST_FIELD = "jest";
+const NAME_CHARACTER_RE = /[\w-]/;
+const FIELD_SEPARATOR$1 = ".";
+const isJestConfig = (fileName) => JEST_CONFIG_RE.test(fileName);
+function hasWholeName(value, name) {
+  for (let at = value.indexOf(name); at !== -1; at = value.indexOf(name, at + 1)) {
+    const before = value[at - 1] ?? "";
+    const after = value[at + name.length] ?? "";
+    if (!NAME_CHARACTER_RE.test(before) && !NAME_CHARACTER_RE.test(after)) {
+      return true;
+    }
+  }
+  return false;
+}
+const oldPackagesInPattern = (value) => [...PACKAGE_RENAMES.keys()].filter((name) => hasWholeName(value, name));
+const patternSteps = (value, location, isNameReported) => isNameReported && namesRenamedModule(value) ? [] : oldPackagesInPattern(value).map((name) => ({
+  kind: "pattern-names-package",
+  location,
+  value,
+  name,
+  to: PACKAGE_RENAMES.get(name) ?? name
+}));
+function jestScriptSteps(text, strings) {
+  const lineOf = lineLocator(text);
+  return strings.filter((string) => !string.isModuleSpecifier).flatMap((string) => patternSteps(string.value, `line ${lineOf(string.start)}`, true));
+}
+function textsAt(node, path) {
+  switch (node.kind) {
+    case "scalar":
+      return [{ value: node.value, path }];
+    case "list":
+      return node.items.flatMap((item, index) => textsAt(item, [...path, index]));
+    case "map":
+      return textEntries(node).flatMap(({ key, value }) => [
+        { value: key.value, path },
+        ...textsAt(value, [...path, key.value])
+      ]);
+    default:
+      return [];
+  }
+}
+const jestConfigSteps = (node, path) => textsAt(node, path).flatMap(
+  ({ value, path: at }) => patternSteps(value, at.join(FIELD_SEPARATOR$1), false)
+);
+const jestJsonSteps = (read) => read.kind === "read" ? read.documents.filter(isMap).flatMap((root) => jestConfigSteps(root, [])) : [];
+
+function migrateJsonCommands(text, strings, patterns) {
+  const changes = [];
+  const manualSteps = [];
+  const edits = [];
+  for (const found of strings.filter((string) => isCommandPath(string.path, patterns))) {
+    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 maskExpansions(text) {
+  const parts = [];
+  let copiedUpTo = 0;
+  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;
@@ -3058,6 +3723,90 @@ function migrateMakefile(text, file) {
   return { text: applyTextEdits(text, edits), changes, manualSteps };
 }
 
+function oldPackagesNamedBy(node) {
+  const values = documentStrings([node]).map((string) => packageReference(string.value).name);
+  const names = [...nestedKeys(node).map(overrideTarget), ...values];
+  return [...new Set(names.filter((name) => PACKAGE_RENAMES.has(name)))];
+}
+function reportSettingSections(settings, file, findings) {
+  for (const { key, value } of textEntries(settings)) {
+    if (file.migratedSections.has(key.value)) {
+      continue;
+    }
+    const field = `${file.prefix}${key.value}`;
+    const isOverride = file.overrideSections.has(key.value);
+    for (const name of oldPackagesNamedBy(value)) {
+      findings.manualSteps.push(
+        isOverride ? { kind: "override-names-package", field, name } : { kind: "setting-names-package", field, name }
+      );
+    }
+  }
+}
+
+const PATH_SEPARATOR = ".";
+const IMPORTS_FIELD = "imports";
+const BROWSER_FIELD = "browser";
+function reportDeep(renamed, location, findings) {
+  if (renamed.isDeep) {
+    findings.manualSteps.push({ kind: "deep-target", location, specifier: renamed.to });
+  }
+}
+function renameSpecifierTargets(nodes, field, findings) {
+  for (const target of documentStrings(nodes)) {
+    const renamed = renamedSpecifier(target.value);
+    if (renamed === void 0) {
+      continue;
+    }
+    const location = [field, ...target.path].join(PATH_SEPARATOR);
+    if (target.encode === void 0) {
+      findings.manualSteps.push({ kind: "entry-not-edited", field: location, name: target.value });
+      continue;
+    }
+    findings.edits.push(replaceScalar({ ...target, encode: target.encode }, renamed.to));
+    findings.changes.push({
+      kind: "package-name-renamed",
+      location,
+      from: target.value,
+      to: renamed.to
+    });
+    reportDeep(renamed, location, findings);
+  }
+}
+function renameSpecifierKeys(map, field, findings) {
+  const keys = textEntries(map).map(({ key }) => key);
+  const names = new Set(keys.map((key) => key.value));
+  return keys.flatMap((key) => {
+    const renamed = renamedSpecifier(key.value);
+    if (renamed === void 0) {
+      return [];
+    }
+    if (key.encode === void 0) {
+      findings.manualSteps.push({ kind: "entry-not-edited", field, name: key.value });
+      return [];
+    }
+    const { to } = renamed;
+    if (!isFree({ from: key.value, to, field, names }, findings)) {
+      return [];
+    }
+    findings.edits.push(replaceScalar({ ...key, encode: key.encode }, to));
+    findings.changes.push({ kind: "package-name-renamed", location: field, from: key.value, to });
+    return [{ location: `${field}${PATH_SEPARATOR}${key.value}`, renamed }];
+  });
+}
+function migrateSubpathImports(manifest, findings) {
+  renameSpecifierTargets(valuesAt(manifest, IMPORTS_FIELD), IMPORTS_FIELD, findings);
+}
+function migrateBrowserField(manifest, findings) {
+  for (const browser of valuesAt(manifest, BROWSER_FIELD).filter(isMap)) {
+    for (const { location, renamed } of renameSpecifierKeys(browser, BROWSER_FIELD, findings)) {
+      reportDeep(renamed, location, findings);
+    }
+    for (const { key, value } of textEntries(browser)) {
+      renameSpecifierTargets([value], `${BROWSER_FIELD}${PATH_SEPARATOR}${key.value}`, findings);
+    }
+  }
+}
+
 function migrateDependencyFields(manifest, target, findings) {
   for (const field of DEPENDENCY_FIELDS) {
     for (const dependencies of mapsAt(manifest, field)) {
@@ -3096,13 +3845,20 @@ function migrateCatalogs$1(manifest, target, findings) {
     migrateSpecMap(specEntries(map), context);
   }
 }
-function reportOverrides(manifest, findings) {
+const PNPM_SETTINGS = {
+  migratedSections: /* @__PURE__ */ new Set(),
+  overrideSections: /* @__PURE__ */ new Set(["overrides", "patchedDependencies"]),
+  prefix: `${PNPM_SETTINGS_FIELD}.`
+};
+function reportSettings(manifest, findings) {
   for (const field of OVERRIDE_FIELDS) {
-    const keys = valuesAt(manifest, field).flatMap(nestedKeys);
-    for (const name of overriddenPackages(keys)) {
+    for (const name of valuesAt(manifest, field).flatMap(oldPackagesNamedBy)) {
       findings.manualSteps.push({ kind: "override-names-package", field, name });
     }
   }
+  for (const settings of mapsAt(manifest, PNPM_SETTINGS_FIELD)) {
+    reportSettingSections(settings, PNPM_SETTINGS, findings);
+  }
 }
 function reportOldPeers(manifest, findings) {
   const dependencies = new Set(declaredNames(manifest));
@@ -3117,7 +3873,12 @@ function migrateManifestMap(manifest, target, findings) {
   migrateNameKeys(manifest, findings);
   migrateNameLists(manifest, findings);
   migrateCatalogs$1(manifest, target, findings);
-  reportOverrides(manifest, findings);
+  migrateSubpathImports(manifest, findings);
+  migrateBrowserField(manifest, findings);
+  reportSettings(manifest, findings);
+  for (const jest of valuesAt(manifest, JEST_FIELD)) {
+    findings.manualSteps.push(...jestConfigSteps(jest, [JEST_FIELD]));
+  }
   reportOldPeers(manifest, findings);
 }
 function migratePackageManifest(text, read, target) {
@@ -3135,134 +3896,22 @@ function unreadManifest(text) {
   return namesOriginalPackage(text) ? { ...unchanged(text), manualSteps: [{ kind: "manifest-not-read" }] } : unchanged(text);
 }
 
-const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".vue",
-  ".svelte",
-  ".astro"
-]);
-function renamedValue(value, version) {
-  const npm = migrateNpmSpec(value, version);
-  if (npm === void 0) {
-    return renamedSpecifier(value);
-  }
-  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 = [];
-  const enclosing = [];
-  for (const found of [...strings].sort(byStartThenOuter)) {
-    const previous = distinct.at(-1);
-    if (previous?.start === found.start && previous.end === found.end) {
-      const isModuleSpecifier = previous.isModuleSpecifier || found.isModuleSpecifier;
-      distinct[distinct.length - 1] = { ...previous, isModuleSpecifier };
-      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 ${outer.start}-${outer.end} and ${found.start}-${found.end}; the file was not changed.`
-      );
-    }
-    enclosing.push(found);
-    distinct.push(found);
-  }
-  return distinct;
-}
-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, 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;
-    }
-    if (!found.isModuleSpecifier || found.start < copiedUpTo) {
-      manualSteps.push({ kind: "string-names-package", line, value: found.value, to: renamed.to });
-      continue;
-    }
-    changes.push({ kind: "specifier-renamed", line, from: found.value, to: renamed.to });
-    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 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);
-  }
-}
-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 });
-    }
+const PATCH_EXTENSION = ".patch";
+const NESTED_SEPARATOR = "++";
+const NAME_ENDS = ["+", "@", "-npm-"];
+function patchedOldPackage(fileName) {
+  if (!fileName.endsWith(PATCH_EXTENSION)) {
+    return void 0;
   }
+  const innermost = fileName.split(NESTED_SEPARATOR).at(-1) ?? fileName;
+  return [...PACKAGE_RENAMES.keys()].find(
+    (name) => NAME_ENDS.some((end) => innermost.startsWith(`${name}${end}`))
+  );
 }
-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 };
+function oldPackagePatchSteps(fileName) {
+  const name = patchedOldPackage(fileName);
+  const to = name === void 0 ? void 0 : PACKAGE_RENAMES.get(name);
+  return name === void 0 || to === void 0 ? [] : [{ kind: "old-package-patch", name, to }];
 }
 
 const YAML_COMMAND_KEYS = /* @__PURE__ */ new Set([
@@ -3279,11 +3928,24 @@ const YAML_COMMAND_KEYS = /* @__PURE__ */ new Set([
   "commands",
   "entrypoint"
 ]);
+const TASKFILE_COMMAND_KEYS = /* @__PURE__ */ new Set([
+  ...YAML_COMMAND_KEYS,
+  "cmds",
+  "cmd",
+  "defer",
+  "sh",
+  "preconditions",
+  "status"
+]);
+
 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) }))
+    strings.filter(isEnvironmentValue).map((value) => ({
+      name: String(value.path.at(-1)),
+      value: value.isEscaped ? value.value : shellText(text, value)
+    }))
   );
 }
 const DEPENDABOT_NAME_KEYS = /* @__PURE__ */ new Set([
@@ -3299,6 +3961,12 @@ function shellText(text, value) {
   const unfolded = value.isFolded ? slice.replace(FOLDED_LINE_BREAK_RE, " ") : slice;
   return unfolded.replace(ENV_EXPRESSION_RE, asShellVariable);
 }
+const LEADING_SPACES_RE = /^ */;
+function blockIndent(shell) {
+  const lines = shell.split("\n").slice(1).filter((line) => line.trim() !== "");
+  const indents = lines.map((line) => LEADING_SPACES_RE.exec(line)?.[0].length ?? 0);
+  return indents.length === 0 ? 0 : Math.min(...indents);
+}
 const valuesOf = (strings, keys) => strings.filter((string) => keys.has(ownerKey(string.path) ?? ""));
 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)));
@@ -3319,9 +3987,21 @@ function execFormCommands(text, items) {
   }
   return commands;
 }
+function escapedValueFindings(value, encode, locate, variables) {
+  const commands = shellCommands(value.value);
+  const found = commandWordFindings(commands, () => locate(value.start), variables);
+  const migrated = applyTextEdits(value.value, found.edits);
+  const isChanged = migrated !== value.value;
+  const edits = isChanged ? [{ start: value.start, end: value.end, text: encode(migrated) }] : [];
+  return { ...found, edits };
+}
 function valueFindings(text, value, locate, variables) {
+  if (value.isEscaped && value.encode !== void 0) {
+    return escapedValueFindings(value, value.encode, locate, variables);
+  }
   const { start } = value.content;
-  const commands = shellCommands(shellText(text, value));
+  const shell = shellText(text, value);
+  const commands = shellCommands(shell, blockIndent(shell));
   const found = commandWordFindings(commands, (offset) => locate(start + offset), variables);
   return { ...found, edits: shiftedEdits(found.edits, start) };
 }
@@ -3336,8 +4016,8 @@ function appliedFindings(text, found) {
     manualSteps: found.flatMap((findings) => findings.manualSteps)
   };
 }
-function migrateYamlCommands(text, file, strings) {
-  const values = valuesOf(strings, YAML_COMMAND_KEYS);
+function migrateYamlCommands(text, file, strings, keys = YAML_COMMAND_KEYS) {
+  const values = valuesOf(strings, keys);
   const lineOf = lineLocator(text);
   const locate = (offset) => `${file}:${lineOf(offset)}`;
   const commandValues = new Set(values.filter((value) => !isExecFormItem(value)));
@@ -3350,31 +4030,186 @@ function migrateYamlCommands(text, file, strings) {
     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 migrateYamlPathCommands(text, strings, patterns) {
+  const commands = strings.filter((string) => isCommandPath(string.path, patterns));
+  return appliedFindings(
+    text,
+    commands.map((command) => valueFindings(text, command, () => command.path.join(".")))
+  );
+}
+function migrateDependabotConfig(text, file, strings) {
+  const changes = [];
+  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 ENTRY_KEY = "entry";
+const ARGS_KEY = "args";
+const DEPENDENCIES_KEY = "additional_dependencies";
+const hookOf = (path) => path.slice(0, -1).join(".");
+function listsByHook(strings, key) {
+  const lists = /* @__PURE__ */ new Map();
+  for (const item of strings) {
+    if (item.path.at(-2) === key) {
+      const hook = item.path.slice(0, -2).join(".");
+      lists.set(hook, [...lists.get(hook) ?? [], item]);
+    }
+  }
+  return lists;
+}
+function entryWords(text, entry) {
+  const { start } = entry.content;
+  return shellCommands(shellText(text, entry)).flat().map((word) => ({ ...word, start: word.start + start, end: word.end + start }));
+}
+const itemWord = (text, item) => {
+  const { start, end } = item.content;
+  return { start, end, value: item.value, raw: text.slice(start, end) };
+};
+function hookCommands(text, strings) {
+  const args = listsByHook(strings, ARGS_KEY);
+  return strings.filter((string) => string.path.at(-1) === ENTRY_KEY).map((entry) => [
+    ...entryWords(text, entry),
+    ...(args.get(hookOf(entry.path)) ?? []).map((item) => itemWord(text, item))
+  ]);
+}
+function dependencyFindings(strings, locate) {
+  const found = {
+    edits: [],
+    changes: [],
+    manualSteps: []
+  };
+  for (const item of [...listsByHook(strings, DEPENDENCIES_KEY).values()].flat()) {
+    const { name, isPinned } = packageReference(item.value);
+    const to = PACKAGE_RENAMES.get(name);
+    const location = locate(item.content.start);
+    if (to !== void 0 && isPinned) {
+      found.manualSteps.push({ kind: "pinned-package", location, name });
+    } else if (to !== void 0) {
+      found.edits.push({ start: item.content.start, end: item.content.end, text: to });
+      found.changes.push({ kind: "package-name-renamed", location, from: name, to });
+    }
+  }
+  return found;
+}
+function migratePreCommitHooks(text, file, strings) {
+  const lineOf = lineLocator(text);
+  const locate = (offset) => `${file}:${lineOf(offset)}`;
+  return appliedFindings(text, [
+    commandWordFindings(hookCommands(text, strings), locate),
+    dependencyFindings(strings, locate)
+  ]);
+}
+
+const COMPILER_OPTIONS_FIELD = "compilerOptions";
+const PATHS_FIELD = "paths";
+const TYPES_FIELD = "types";
+const FIELD_SEPARATOR = ".";
+function reportOldPackagePaths(config, findings) {
+  for (const value of documentStrings([config])) {
+    const name = oldPackageInNodeModules(value.value);
+    const to = name === void 0 ? void 0 : PACKAGE_RENAMES.get(name);
+    if (name !== void 0 && to !== void 0) {
+      const location = value.path.join(FIELD_SEPARATOR);
+      findings.manualSteps.push({ kind: "old-package-path", location, path: value.value, to });
+    }
+  }
+}
+function migrateCompilerOptions(options, findings) {
+  for (const paths of mapsAt(options, PATHS_FIELD)) {
+    const field = [COMPILER_OPTIONS_FIELD, PATHS_FIELD].join(FIELD_SEPARATOR);
+    renameSpecifierKeys(paths, field, findings);
+  }
+  for (const types of valuesAt(options, TYPES_FIELD)) {
+    if (types.kind === "list") {
+      const field = [COMPILER_OPTIONS_FIELD, TYPES_FIELD].join(FIELD_SEPARATOR);
+      renameNames(itemEntries(types), field, findings);
+    }
+  }
+}
+function migrateTsconfig(text, read) {
+  if (read.kind === "unreadable") {
+    return unreadableConfig(text, read.offset);
+  }
+  const findings = newFindings();
+  for (const config of read.documents.filter(isMap)) {
+    for (const options of mapsAt(config, COMPILER_OPTIONS_FIELD)) {
+      migrateCompilerOptions(options, findings);
+    }
+    reportOldPackagePaths(config, findings);
+  }
+  const { edits, changes, manualSteps } = findings;
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
+}
+
+const CATALOG_SECTIONS = [CATALOG_FIELD, NAMED_CATALOGS_FIELD];
+const PNPM_WORKSPACE_FILE = {
+  migratedSections: /* @__PURE__ */ new Set([...CATALOG_SECTIONS, "packages"]),
+  overrideSections: /* @__PURE__ */ new Set(["overrides", "patchedDependencies"]),
+  prefix: ""
+};
+const YARNRC_FILE = {
+  migratedSections: new Set(CATALOG_SECTIONS),
+  overrideSections: /* @__PURE__ */ new Set(),
+  prefix: ""
+};
+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);
+  }
+}
+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);
+    reportSettingSections(workspace, file, findings);
+  }
+  const { edits, changes, manualSteps } = findings;
+  return { text: applyTextEdits(text, edits), changes, manualSteps };
+}
+
+const withSteps = (migration, steps) => ({
+  ...migration,
+  manualSteps: [...migration.manualSteps, ...steps]
+});
+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 migrateDependabotConfig(text, file, strings) {
-  const changes = [];
-  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 });
-    }
+function migrateConfig(text, read, steps) {
+  const first = read(text);
+  if (first.kind === "unreadable") {
+    return unreadableConfig(text, first.offset);
   }
-  return { text: applyTextEdits(text, edits), changes, manualSteps: [] };
+  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 jsonConfig = (steps) => (text, path, context) => migrateConfig(text, (current) => context.readers.json.read(current), steps(context, path));
+const yamlConfig = (steps) => (text, path, context) => migrateConfig(text, (current) => context.readers.yaml.read(current), steps(context, path));
+const whenNamed = (migrate) => (text, path, context) => namesOriginalPackage(text) ? migrate(text, path, context) : unchanged(text);
 
 const SHELL_EXTENSIONS = /* @__PURE__ */ new Set([".sh", ".bash", ".zsh"]);
 const MAKEFILE_EXTENSION = ".mk";
@@ -3385,6 +4220,28 @@ const DOCKERFILE_NAMES = /* @__PURE__ */ new Set(["Dockerfile", "Containerfile"]
 const HUSKY_FOLDER = ".husky/";
 const HUSKY_INTERNALS = ".husky/_/";
 const NX_PROJECT_FILE = "project.json";
+const NX_WORKSPACE_FILE = "nx.json";
+const JEST_JSON_CONFIG_FILE = "jest.config.json";
+const TASKFILE_NAMES = new Set(
+  ["Taskfile", "taskfile", "Taskfile.dist", "taskfile.dist"].flatMap((name) => [
+    `${name}.yml`,
+    `${name}.yaml`
+  ])
+);
+const PRE_COMMIT_FILES = /* @__PURE__ */ new Set([
+  ".pre-commit-config.yaml",
+  ".pre-commit-config.yml"
+]);
+const LINT_STAGED_YAML_FILES = /* @__PURE__ */ new Set([
+  ".lintstagedrc",
+  ".lintstagedrc.yaml",
+  ".lintstagedrc.yml"
+]);
+const LINT_STAGED_JSON_FILE = ".lintstagedrc.json";
+const SIMPLE_GIT_HOOKS_FILES = /* @__PURE__ */ new Set([
+  ".simple-git-hooks.json",
+  "simple-git-hooks.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([
@@ -3396,6 +4253,7 @@ 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 PROJECT_CONFIG_NAME = /^[jt]sconfig(\.[^/]+)?\.json$/;
 const LOCK_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "yarn.lock", "bun.lock"]);
 function baseName(path) {
   return path.slice(path.lastIndexOf("/") + 1);
@@ -3406,12 +4264,40 @@ function extensionOf(path) {
   return dot <= 0 ? "" : name.slice(dot);
 }
 
+const NO_NAMED_IMPORT_MAPS = /* @__PURE__ */ new Map();
+async function importMapsOf(path, files, readers) {
+  const read = await files.read(path);
+  const parsed = read.kind === "read" ? readers.json.read(read.text) : void 0;
+  if (parsed?.kind !== "read") {
+    return [];
+  }
+  return importMapLocations(path, parsed.documents.filter(isMap)).flatMap(
+    (location) => location.kind === "in-project" ? [location.path] : []
+  );
+}
+async function namedImportMaps(paths, files, readers) {
+  const named = /* @__PURE__ */ new Map();
+  for (const path of paths.filter((candidate) => DENO_CONFIG_FILES.has(baseName(candidate)))) {
+    for (const map of await importMapsOf(path, files, readers)) {
+      named.set(map, [...named.get(map) ?? [], path]);
+    }
+  }
+  return named;
+}
+function joinedNames(sets) {
+  return sets.some((names) => names === void 0) ? void 0 : new Set(sets.flatMap((names) => [...names ?? []]));
+}
+function withNamedImportMaps(declarations, importMaps) {
+  const mapNames = new Map(declarations.map(({ path, names }) => [path, names]));
+  return declarations.filter(({ path }) => !importMaps.has(path)).map(({ path, names }) => {
+    const maps = [...importMaps].filter(([, configs]) => configs.includes(path));
+    const named = maps.flatMap(([map]) => mapNames.has(map) ? [mapNames.get(map)] : []);
+    return { path, names: joinedNames([names, ...named]) };
+  });
+}
+
 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(
@@ -3420,42 +4306,66 @@ function migrateSource(text, path, context) {
   );
   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 patterns = isJestConfig(baseName(path)) ? jestScriptSteps(text, strings) : [];
+  return withSteps(migrated, [...commandStringSteps(text, strings), ...undeclared, ...patterns]);
 }
-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 importMapStep = (version) => (text, read) => migrateImportMap(text, read, version);
+const importMapFile = jsonConfig(({ version }) => [importMapStep(version)]);
+const yamlPathCommands = (patterns) => stringsStep((text, strings) => migrateYamlPathCommands(text, strings, patterns));
+const COMMAND_CONFIG_KINDS = [
+  {
+    matches: (path) => baseName(path) === NX_PROJECT_FILE,
+    migrate: jsonConfig(() => [jsonCommandsStep(NX_PROJECT_COMMAND_PATHS)])
+  },
+  {
+    matches: (path) => baseName(path) === NX_WORKSPACE_FILE,
+    migrate: jsonConfig(() => [jsonCommandsStep(NX_WORKSPACE_COMMAND_PATHS)])
+  },
+  {
+    matches: (path) => baseName(path) === LINT_STAGED_JSON_FILE,
+    migrate: jsonConfig(() => [jsonCommandsStep(LINT_STAGED_COMMAND_PATHS)])
+  },
+  {
+    matches: (path) => LINT_STAGED_YAML_FILES.has(baseName(path)),
+    migrate: whenNamed(yamlConfig(() => [yamlPathCommands(LINT_STAGED_COMMAND_PATHS)]))
+  },
+  {
+    matches: (path) => SIMPLE_GIT_HOOKS_FILES.has(baseName(path)),
+    migrate: jsonConfig(() => [jsonCommandsStep(SIMPLE_GIT_HOOKS_COMMAND_PATHS)])
+  },
+  {
+    matches: (path) => TASKFILE_NAMES.has(baseName(path)),
+    migrate: whenNamed(
+      yamlConfig((_context, path) => [
+        stringsStep(
+          (text, strings) => migrateYamlCommands(text, path, strings, TASKFILE_COMMAND_KEYS)
+        )
+      ])
+    )
+  },
+  {
+    matches: (path) => PRE_COMMIT_FILES.has(baseName(path)),
+    migrate: whenNamed(
+      yamlConfig((_context, path) => [
+        stringsStep((text, strings) => migratePreCommitHooks(text, path, strings))
+      ])
+    )
+  }
+];
 const FILE_KINDS = [
   {
     matches: (path) => baseName(path) === MANIFEST_FILE,
     migrate: jsonConfig(({ version, catalogs }) => [
       (text, read) => migratePackageManifest(text, read, { version, catalogs }),
-      jsonCommandsStep(PACKAGE_SCRIPT_PATHS)
+      jsonCommandsStep(MANIFEST_COMMAND_PATHS)
     ])
   },
   {
     matches: (path) => YAML_MANIFEST_FILES.has(baseName(path)),
     migrate: yamlConfig(({ version, catalogs }) => [
       (text, read) => migratePackageManifest(text, read, { version, catalogs }),
-      stringsStep(migrateYamlScripts)
+      yamlPathCommands(MANIFEST_COMMAND_PATHS)
     ])
   },
   {
@@ -3475,23 +4385,33 @@ const FILE_KINDS = [
     ])
   },
   {
-    matches: (path) => SOURCE_EXTENSIONS.has(extensionOf(path)),
-    migrate: migrateSource
+    matches: (path) => baseName(path) === JEST_JSON_CONFIG_FILE,
+    migrate: jsonConfig(() => [(text, read) => withSteps(unchanged(text), jestJsonSteps(read))])
   },
   {
-    matches: (path) => baseName(path) === NX_PROJECT_FILE,
-    migrate: jsonConfig(() => [jsonCommandsStep(NX_COMMAND_PATHS)])
+    matches: (path) => patchedOldPackage(baseName(path)) !== void 0,
+    migrate: (text, path) => withSteps(unchanged(text), oldPackagePatchSteps(baseName(path)))
+  },
+  {
+    matches: (path) => SOURCE_EXTENSIONS.has(extensionOf(path)),
+    migrate: migrateSource
   },
+  ...COMMAND_CONFIG_KINDS,
   {
     matches: (path) => DENO_CONFIG_FILES.has(baseName(path)),
-    migrate: jsonConfig(({ version }) => [
-      (text, read) => migrateImportMap(text, read, version),
+    migrate: jsonConfig(({ version }, path) => [
+      importMapStep(version),
+      (text, read) => withSteps(unchanged(text), importMapSteps(path, read)),
       jsonCommandsStep(DENO_TASK_PATHS)
     ])
   },
   {
     matches: (path) => baseName(path) === IMPORT_MAP_FILE,
-    migrate: jsonConfig(({ version }) => [(text, read) => migrateImportMap(text, read, version)])
+    migrate: importMapFile
+  },
+  {
+    matches: (path) => PROJECT_CONFIG_NAME.test(baseName(path)),
+    migrate: whenNamed(jsonConfig(() => [migrateTsconfig]))
   },
   {
     matches: isDependabotConfig,
@@ -3522,23 +4442,26 @@ const FILE_KINDS = [
     migrate: whenNamed((text, path) => migrateCommandLines(text, path))
   }
 ];
-function fileMigrationFor(path) {
+function fileMigrationFor(path, namedImportMaps = NO_NAMED_IMPORT_MAPS) {
   if (LOCK_FILES.has(baseName(path))) {
     return void 0;
   }
+  if (namedImportMaps.has(path)) {
+    return importMapFile;
+  }
   return FILE_KINDS.find((kind) => kind.matches(path))?.migrate;
 }
 
 const readJson = (text, readers) => readers.json.read(text);
 const readYaml = (text, readers) => readers.yaml.read(text);
-function planSourceOf(path) {
+function planSourceOf(path, namedImportMaps) {
   const name = baseName(path);
+  if (namedImportMaps.has(path) || DENO_CONFIG_FILES.has(name) || name === IMPORT_MAP_FILE) {
+    return { role: "import-map", read: readJson };
+  }
   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 };
   }
@@ -3550,7 +4473,7 @@ function planSourceOf(path) {
 }
 
 async function planFile(path, dependencies, target) {
-  const migrate = fileMigrationFor(path);
+  const migrate = fileMigrationFor(path, target.importMaps);
   if (migrate === void 0) {
     return { kind: "not-migrated" };
   }
@@ -3559,7 +4482,8 @@ async function planFile(path, dependencies, target) {
     return read;
   }
   const { rewriter, scanner, readers } = dependencies;
-  const context = { ...target, rewriter, scanner, readers };
+  const { version, catalogs, manifests } = target;
+  const context = { version, catalogs, manifests, rewriter, scanner, readers };
   const migration = migrate(read.text, path, context);
   const isChanged = migration.text !== read.text;
   const { changes, manualSteps } = migration;
@@ -3575,23 +4499,35 @@ async function readForPlan(path, source, dependencies) {
     return { namesOriginal: false, roots: void 0 };
   }
   const namesOriginal = namesOriginalPackage(read.text);
-  if (!namesOriginal && !namesUninstalledPackage(read.text)) {
+  const isNeeded = namesOriginal || namesUninstalledPackage(read.text) || path === MANIFEST_FILE;
+  if (!isNeeded) {
     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 ROOT_WORKSPACE_FILES = /* @__PURE__ */ new Set([WORKSPACE_FILE, YARNRC_FILE_NAME]);
+function marksWorkspaceRoot(path, roots) {
+  if (ROOT_WORKSPACE_FILES.has(path)) {
+    return true;
+  }
+  const manifests = path === MANIFEST_FILE ? roots ?? [] : [];
+  return manifests.some((manifest) => valuesAt(manifest, WORKSPACES_FIELD).length > 0);
+}
 const DECLARED_NAMES = { manifest: declaredNames, "import-map": importMapNames, catalogs: void 0 };
 async function planProjectTarget(paths, dependencies, version) {
   const documents = { manifest: [], catalogs: [] };
   const manifests = [];
+  let isWorkspaceRoot = false;
+  const importMaps = await namedImportMaps(paths, dependencies.files, dependencies.readers);
   for (const path of paths) {
-    const source = planSourceOf(path);
+    const source = planSourceOf(path, importMaps);
     if (source === void 0) {
       continue;
     }
     const { namesOriginal, roots } = await readForPlan(path, source, dependencies);
+    isWorkspaceRoot ||= marksWorkspaceRoot(path, roots);
     if (namesOriginal && source.role !== "import-map") {
       documents[source.role].push(...roots ?? []);
     }
@@ -3602,9 +4538,10 @@ async function planProjectTarget(paths, dependencies, version) {
   }
   const catalogs = planCatalogs({
     manifests: documents.manifest,
-    catalogFiles: documents.catalogs
+    catalogFiles: documents.catalogs,
+    isWorkspaceRoot
   });
-  return { version, catalogs, manifests };
+  return { version, catalogs, manifests: withNamedImportMaps(manifests, importMaps), importMaps };
 }
 async function planProject(paths, dependencies, version) {
   const files = [];
@@ -3654,39 +4591,39 @@ async function migrateProject(dependencies, input) {
   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";
-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 CONTROL_RANGES = [
+  [0, 8],
+  [10, 31],
+  [127, 159],
+  [8232, 8233],
+  [8234, 8238],
+  [8294, 8297]
+];
+const SHORT_ESCAPES = { "\n": "\\n", "\r": "\\r" };
+const HEX_DIGITS = 4;
+const HEX_RADIX = 16;
+function isControl(codePoint) {
+  return CONTROL_RANGES.some(([first, last]) => codePoint >= first && codePoint <= last);
+}
+function escapeOf(character, codePoint) {
+  const hex = codePoint.toString(HEX_RADIX).padStart(HEX_DIGITS, "0");
+  return SHORT_ESCAPES[character] ?? `\\u${hex}`;
+}
+function terminalSafeText(text) {
+  let shown = "";
+  for (const character of text) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    shown += isControl(codePoint) ? escapeOf(character, codePoint) : character;
+  }
+  return shown;
+}
+
 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 OLD_FILE_NOTE$1 = "is a file of openapi-typescript, which is no longer installed: run openapi-typesafe instead";
 const FLAGS_IN_VARIABLE_NOTE = "holds old flags of the generator and may serve other commands, so it was kept: rename";
 const NOT_ONLY_GENERATOR_NOTE = "runs openapi-typescript in some of its definitions in this file and another program in others, so the flags after it were kept; where it runs the generator, rename";
+const OLD_NAME_IN_COMMAND_NOTE = "names an old package where the tool cannot tell what runs it (a script name, an argument of a program it does not know), so it was kept: migrate it by hand";
 const 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>`;
@@ -3704,6 +4641,7 @@ const COMMAND_STEP_KINDS = /* @__PURE__ */ new Set([
   "variable-not-only-generator",
   "pinned-package",
   "old-package-file",
+  "old-name-in-command",
   "command-string"
 ]);
 const isCommandStep = (step) => COMMAND_STEP_KINDS.has(step.kind);
@@ -3718,47 +4656,141 @@ function commandStepMessage(step) {
     case "pinned-package":
       return pinnedPackageMessage(step);
     case "old-package-file":
-      return `${step.location}: ${step.path} ${OLD_FILE_NOTE}`;
+      return `${step.location}: ${step.path} ${OLD_FILE_NOTE$1}`;
+    case "old-name-in-command":
+      return `${step.location}: "${step.word}" ${OLD_NAME_IN_COMMAND_NOTE}`;
     case "command-string":
       return `line ${step.line}: ${COMMAND_STRING_NOTE} "${step.to}"`;
     default:
       return assertNever(step);
   }
 }
+
+const IR_CALLBACKS_GUIDE = "https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs/node.md#ir-callbacks";
+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",
+  "typed-options": "its options are declared with a type built from OpenAPITSOptions, which the tool cannot change to OpenAPITSIrOptions",
+  "spread-options": "its options take keys from another object (`...base`), whose callbacks and type the tool cannot see"
+};
+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 DEEP_IMPORT_NOTE = "imports a file inside the package; check that it exists";
+const OLD_FILE_NOTE = "imports a file from node_modules of";
+const OLD_FILE_FIX_NOTE = "which is no longer installed: import from";
+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}`;
+}
+const SOURCE_STEP_KINDS = /* @__PURE__ */ new Set([
+  "options-not-inspected",
+  "deep-import",
+  "old-package-import",
+  "dynamic-specifier",
+  "string-names-package",
+  "transform-not-rewritten",
+  "legacy-callback",
+  "package-not-declared"
+]);
+const isSourceStep = (step) => SOURCE_STEP_KINDS.has(step.kind);
+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 "old-package-import":
+      return `line ${step.line}: "${step.specifier}" ${OLD_FILE_NOTE} ${step.name}, ${OLD_FILE_FIX_NOTE} ${step.to}`;
+    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);
+  }
+}
+
+const OPENAPI_FETCH_ALIAS_GUIDE = "https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs/fetch/index.md#libraries-built-on-openapi-fetch";
+const PEER_NOTE = "users of this package must switch too (a breaking change for them)";
+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 IMPORT_MAP_NOTE = "is a URL or a file outside the project folder, so it was not migrated: rename the old packages in it by hand";
+const PATCH_NOTE = "check whether the fix is still needed, then make the patch again or delete it";
+const PATTERN_NOTE = "is a pattern that names";
+const PATTERN_FIX_NOTE = "where it means the package, make it match";
+const SETTING_NOTE = "remove the setting if it no longer applies, or make it name";
+const DEEP_TARGET_NOTE = "points at a file inside the package; check that it exists";
+const OLD_PATH_NOTE = "is a path into node_modules of an old package, which is no longer installed:";
+const OLD_PATH_FIX_NOTE = "point it at the files of";
+const renamed = (name) => PACKAGE_RENAMES.get(name) ?? name;
+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 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 "import-map-not-editable":
+      return `importMap "${step.reference}" ${IMPORT_MAP_NOTE}`;
+    case "old-package-patch":
+      return `patches the code of ${step.name}, which ${step.to} does not share: ${PATCH_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`;
+    default:
+      return assertNever(step);
+  }
+}
+function catalogStepMessage(step) {
+  switch (step.kind) {
     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-outside":
+      return `${step.field}: ${step.name} was kept, because no catalog of this project has its "${step.catalog}" entry; a catalog above the root (pnpm-workspace.yaml, .yarnrc.yml or the workspace package.json) may hold it: rename the entry and the dependency together`;
+    case "catalog-entry-missing":
+      return `${step.field}: ${step.name} was kept, because no catalog of the workspace has its "${step.catalog}" entry: add the entry, or give the dependency a version`;
     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) {
+function packageStepMessage(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);
+    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 "setting-names-package":
+      return `"${step.field}" names ${step.name}: ${SETTING_NOTE} ${renamed(step.name)}`;
+    case "pattern-names-package":
+      return `${step.location}: "${step.value}" ${PATTERN_NOTE} ${step.name}: ${PATTERN_FIX_NOTE} ${step.to}`;
+    case "deep-target":
+      return `${step.location}: "${step.specifier}" ${DEEP_TARGET_NOTE}`;
+    case "old-package-path":
+      return `${step.location}: "${step.path}" ${OLD_PATH_NOTE} ${OLD_PATH_FIX_NOTE} ${step.to}`;
+    case "old-peer-needed":
+      return oldPeerMessage(step);
     default:
       return assertNever(step);
   }
@@ -3767,30 +4799,31 @@ function manualStepMessage(step) {
   if (isCommandStep(step)) {
     return commandStepMessage(step);
   }
+  if (isSourceStep(step)) {
+    return sourceStepMessage(step);
+  }
   switch (step.kind) {
     case "config-unreadable":
     case "manifest-not-read":
+    case "import-map-not-editable":
+    case "old-package-patch":
     case "entry-not-edited":
     case "name-collision":
+      return uneditedStepMessage(step);
     case "catalog-reference-kept":
+    case "catalog-entry-outside":
+    case "catalog-entry-missing":
     case "catalog-entry-in-use":
-      return uneditedStepMessage(step);
+      return catalogStepMessage(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 "options-not-inspected":
-    case "deep-import":
-    case "dynamic-specifier":
-    case "string-names-package":
-    case "transform-not-rewritten":
-    case "legacy-callback":
-    case "package-not-declared":
-      return sourceStepMessage(step);
+    case "setting-names-package":
+    case "pattern-names-package":
+    case "deep-target":
+    case "old-package-path":
     case "old-peer-needed":
-      return oldPeerMessage(step);
+      return packageStepMessage(step);
     default:
       return assertNever(step);
   }
@@ -3905,12 +4938,15 @@ function writeSection(write) {
       return assertNever(write);
   }
 }
+function printed(lines) {
+  return `${lines.map(terminalSafeText).join("\n")}
+`;
+}
 function renderReport(migration) {
   const reports = migration.files;
   const skipped = skippedSection(migration.skipped);
   if (reports.length === 0) {
-    return `${[...skipped, NOTHING_FOUND].join("\n")}
-`;
+    return printed([...skipped, NOTHING_FOUND]);
   }
   const lines = [
     ...changesSection(reports),
@@ -3921,8 +4957,7 @@ function renderReport(migration) {
     "",
     ...writeSection(migration.write)
   ];
-  return `${lines.join("\n")}
-`;
+  return printed(lines);
 }
 
 const OPTIONS = {
@@ -4028,7 +5063,7 @@ async function runMigration(request, dependencies) {
   } catch (error) {
     const message = errorMessage(error);
     logger.warn("migration_failed", { root, message });
-    dependencies.writeStderr(`${message}
+    dependencies.writeStderr(`${terminalSafeText(message)}
 `);
     return EXIT_CODES.failure;
   } finally {