@uniformdev/next-app-router-upgrade 0.0.0-stage → 0.2.0

package/src/edge/vercel.js

@@ -0,0 +1,38 @@
+// Phase 2 on Vercel: turn on edge mode with vercelUniformEdgeMiddleware.
+// The steps follow "Set up edge mode on Vercel" in the docs.
+
+import { migrateEdgeMiddleware, migrateRouteFile as migrateRoutes, planEdge, SDK } from "./common.js";
+
+const VERCEL = `${SDK}/vercel`;
+const VERCEL_FUNCTIONS_RANGE = "^3.7.2";
+
+const HOST = {
+  factory: "vercelUniformEdgeMiddleware",
+  module: VERCEL,
+  runtime: true,
+  onRevalidateTags: {
+    name: "expireVercelRuntimeCacheTags",
+    module: VERCEL,
+    description: "Expire the Vercel runtime cache when content is published: onRevalidateTags: expireVercelRuntimeCacheTags.",
+  },
+  packages: [{ name: "@vercel/functions", range: VERCEL_FUNCTIONS_RANGE, description: "vercelUniformEdgeMiddleware needs it." }],
+  reminders: [
+    "If the deployment uses Vercel Deployment Protection, turn on Protection Bypass for Automation in the project settings. Then the edge middleware can fetch the page that it processes.",
+  ],
+};
+
+/**
+ * Returns { changes, contents, manual, reminders } for phase 2 on Vercel. Reminders are not code changes.
+ * `base` maps absolute paths to the text after phase 1, so that the two phases make one plan.
+ */
+export function planVercelEdge(root, { base } = {}) {
+  return planEdge(root, { base, host: HOST });
+}
+
+export function migrateMiddleware(root, file, text) {
+  return migrateEdgeMiddleware(root, file, text, HOST);
+}
+
+export function migrateRouteFile(root, file, text) {
+  return migrateRoutes(root, file, text, { onRevalidateTags: HOST.onRevalidateTags });
+}

package/src/interactive.js

@@ -0,0 +1,111 @@
+// The interactive mode: a guide through the check, phase 1 (the SDK upgrade) and phase 2 (edge mode).
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+
+import { PROVIDERS } from "./edge/index.js";
+import { formatText, TARGET_VERSION, verdict } from "./report.js";
+import { colors, executeMigration, NAME, projectStatus } from "./session.js";
+
+export async function runInteractive({ root, color, uniformData }) {
+  const c = colors(color);
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = async (question, defaultYes = false) => {
+    const answer = (await rl.question(`${c("36", "?")} ${question} ${c("2", defaultYes ? "[Y/n]" : "[y/N]")} `)).trim();
+    return answer ? /^y(es)?$/i.test(answer) : defaultYes;
+  };
+  const choose = async (question, options) => {
+    console.log(`${c("36", "?")} ${c("1", question)}`);
+    options.forEach((option, i) => {
+      const label = option.disabled ? c("2", `${option.label}  (${option.hint})`) : `${option.label}${option.hint ? c("2", `  ${option.hint}`) : ""}`;
+      console.log(`  ${c("36", String(i + 1))}) ${label}`);
+    });
+    for (;;) {
+      const answer = Number((await rl.question(`  Select 1-${options.length}: `)).trim());
+      const option = options[answer - 1];
+      if (option) {
+        console.log("");
+        return option;
+      }
+    }
+  };
+
+  try {
+    for (;;) {
+      const status = projectStatus(root, { uniformData });
+      printHeader(root, status, c);
+
+      const phase1Hint = status.phase1Pending ? `${status.phase1Pending} automatic change(s) to do` : "done";
+      const phase2Hint = status.edgeMode ? `edge mode is on (${status.edgeMode})` : "lite mode now";
+      const action = await choose("What do you want to do?", [
+        { value: "check", label: "Check compatibility", hint: "a full report, no changes" },
+        { value: "phase1", label: "Phase 1: upgrade the SDK", hint: phase1Hint },
+        { value: "phase2", label: "Phase 2: turn on edge mode", hint: phase2Hint },
+        { value: "exit", label: "Exit" },
+      ]);
+
+      if (action.value === "exit") return 0;
+
+      if (action.value === "check") {
+        console.log(formatText(status.scan, verdict(status.scan.findings), { color }));
+        console.log("");
+        await rl.question(c("2", "Press Enter to go back to the menu. "));
+        continue;
+      }
+
+      let edge;
+      if (action.value === "phase2") {
+        const host = await choose("Which host serves your app?", [
+          ...Object.entries(PROVIDERS).map(([key, provider]) => ({
+            value: key,
+            label: provider.name,
+            hint: provider.available ? provider.summary : "coming soon",
+            disabled: !provider.available,
+          })),
+          { value: "back", label: "Back" },
+        ]);
+        if (host.value === "back") continue;
+        if (host.disabled) {
+          console.log(`${PROVIDERS[host.value].name} is not in this CLI yet. To set up edge mode by hand, follow the docs:`);
+          console.log(c("36", `  ${PROVIDERS[host.value].docs}`));
+          console.log("");
+          continue;
+        }
+        edge = host.value;
+        if (status.phase1Pending) {
+          console.log(c("33", `Phase 1 is not done. The plan includes its ${status.phase1Pending} change(s) too.`));
+          console.log("");
+        }
+      }
+
+      const code = await executeMigration({ root, edge, color, uniformData, ask, interactive: true, diff: "ask" });
+      if (code !== 2 && fs.existsSync(path.join(root, "package.json"))) await offerInstall(root, ask, c);
+      await rl.question(c("2", "Press Enter to go back to the menu. "));
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+function printHeader(root, status, c) {
+  const { scan } = status;
+  const result = verdict(scan.findings);
+  console.log("");
+  console.log(c("1", "Uniform Next.js App Router SDK upgrade"));
+  console.log(`  Project   ${scan.project.name ?? path.basename(root)} ${c("2", `(${root})`)}`);
+  console.log(`  SDK       ${status.sdkVersion}${status.atTarget ? c("32", "  (target version)") : c("2", `  → ${TARGET_VERSION}`)}`);
+  console.log(`  Check     ${c(result.safe ? "32" : "31", result.label)} ${c("2", `(${result.errors} error(s), ${result.warnings} warning(s))`)}`);
+  console.log(`  Mode      ${status.edgeMode ? c("32", `edge mode (${status.edgeMode})`) : "lite mode: the browser chooses the variants after hydration"}`);
+  console.log("");
+}
+
+async function offerInstall(root, ask, c) {
+  const manager = fs.existsSync(path.join(root, "pnpm-lock.yaml")) ? "pnpm" : fs.existsSync(path.join(root, "yarn.lock")) ? "yarn" : "npm";
+  if (!(await ask(`Run "${manager} install" now?`, false))) return;
+  const result = spawnSync(manager, ["install"], { cwd: root, stdio: "inherit", shell: process.platform === "win32" });
+  console.log(result.status === 0 ? c("32", "Install done.") : c("31", `${manager} install failed. Run it yourself, and read the error.`));
+  console.log(c("2", `Then run: ${NAME} check`));
+  console.log("");
+}

package/src/json-text.js

@@ -0,0 +1,95 @@
+// Small edits to JSON text that keep the formatting of all other lines.
+
+/** Returns [start, end] of the object value of a top-level key, from "{" to "}" inclusive. */
+export function findTopLevelObject(text, key) {
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '"') {
+      const end = endOfString(text, i);
+      if (depth === 1) {
+        const name = JSON.parse(text.slice(i, end + 1));
+        const rest = /^\s*:\s*/.exec(text.slice(end + 1));
+        if (name === key && rest && text[end + 1 + rest[0].length] === "{") {
+          const start = end + 1 + rest[0].length;
+          return [start, matchBrace(text, start)];
+        }
+      }
+      i = end;
+    } else if (ch === "{" || ch === "[") depth++;
+    else if (ch === "}" || ch === "]") depth--;
+  }
+  return undefined;
+}
+
+function endOfString(text, start) {
+  for (let i = start + 1; i < text.length; i++) {
+    if (text[i] === "\\") i++;
+    else if (text[i] === '"') return i;
+  }
+  throw new Error("Unterminated string in JSON");
+}
+
+function matchBrace(text, start) {
+  let depth = 0;
+  for (let i = start; i < text.length; i++) {
+    if (text[i] === '"') i = endOfString(text, i);
+    else if (text[i] === "{" || text[i] === "[") depth++;
+    else if (text[i] === "}" || text[i] === "]") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  throw new Error("Unbalanced JSON");
+}
+
+const quote = (s) => JSON.stringify(s);
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/** Changes the value of `name` inside the top-level object `block`. Returns the new text, or undefined. */
+export function setValueInBlock(text, block, name, value) {
+  const range = findTopLevelObject(text, block);
+  if (!range) return undefined;
+  const inner = text.slice(range[0], range[1] + 1);
+  const re = new RegExp(`(${escapeRe(quote(name))}\\s*:\\s*)"(?:[^"\\\\]|\\\\.)*"`);
+  if (!re.test(inner)) return undefined;
+  return text.slice(0, range[0]) + inner.replace(re, `$1${quote(value)}`) + text.slice(range[1] + 1);
+}
+
+/**
+ * Adds `name: value` to the top-level object `block`, in alphabetical order when the keys are in
+ * alphabetical order. Adds the block when it does not exist.
+ */
+export function addToBlock(text, block, name, value) {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const unit = /^([ \t]+)"/m.exec(text)?.[1] ?? "  ";
+  const range = findTopLevelObject(text, block);
+
+  if (!range) {
+    // Add the block before the last "}" of the file.
+    const close = text.lastIndexOf("}");
+    const before = text.slice(0, close).replace(/\s*$/, "");
+    const entry = `${unit}${quote(block)}: {${eol}${unit}${unit}${quote(name)}: ${quote(value)}${eol}${unit}}`;
+    return `${before},${eol}${entry}${eol}${text.slice(close)}`;
+  }
+
+  const [start, end] = range;
+  const body = text.slice(start + 1, end);
+  const keys = [...body.matchAll(/"((?:[^"\\]|\\.)*)"\s*:/g)].map((m) => ({ name: JSON.parse(`"${m[1]}"`), index: start + 1 + m.index }));
+  if (!keys.length) return text.slice(0, start) + `{ ${quote(name)}: ${quote(value)} }` + text.slice(end + 1);
+
+  const indent = /([ \t]*)$/.exec(text.slice(0, keys[0].index))[1];
+  const multiline = body.includes("\n");
+  const sorted = keys.every((key, i) => i === 0 || keys[i - 1].name.localeCompare(key.name) <= 0);
+  const next = sorted ? keys.find((key) => key.name.localeCompare(name) > 0) : undefined;
+
+  if (next) {
+    const entry = multiline ? `${quote(name)}: ${quote(value)},${eol}${indent}` : `${quote(name)}: ${quote(value)}, `;
+    return text.slice(0, next.index) + entry + text.slice(next.index);
+  }
+  // Add after the last value.
+  const lastValueEnd = start + 1 + body.replace(/\s*$/, "").length;
+  const hasComma = text[lastValueEnd - 1] === ",";
+  const entry = multiline ? `${hasComma ? "" : ","}${eol}${indent}${quote(name)}: ${quote(value)}` : `${hasComma ? "" : ","} ${quote(name)}: ${quote(value)}`;
+  return text.slice(0, lastValueEnd) + entry + text.slice(lastValueEnd);
+}

package/src/migrate.js

@@ -0,0 +1,386 @@
+// Plans the code changes for the upgrade to the developer preview. The plan contains only changes
+// that keep the behavior of the app: each removed option either had no effect, or set the default.
+// All other findings stay for the developer, with a file and a line.
+
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+
+import { COMPOSITION_METADATA, findClientContextIssues } from "./client-context.js";
+import { TARGET_VERSION } from "./report.js";
+import { addToBlock, setValueInBlock } from "./json-text.js";
+import { REMOVED_EXPORTS } from "./rules.js";
+import { listSourceFiles, scriptKind } from "./scan.js";
+
+const SDK = "@uniformdev/next-app-router";
+// These packages have their own version line. The registry check also finds such packages.
+const SEPARATE_VERSION_LINE = new Set(["@uniformdev/toolbar-react", "@uniformdev/context-edge"]);
+// The stable SDK (20.82 to 20.85) installs this version of @vercel/functions as a dependency.
+const VERCEL_FUNCTIONS_RANGE = "^3.7.2";
+const DEFAULT_DATA_CLIENT = "DefaultDataClient";
+
+/**
+ * Returns { changes, contents, manual } for the project at `root`.
+ * `changes` lists each change with its file, line and description.
+ * `contents` maps each changed absolute path to its new text. Nothing is written.
+ * `manual` lists package.json steps that the migration could not do.
+ * `published` maps @uniformdev package names to true, false or undefined (refer to registry.js).
+ * Without it, the plan assumes that each package exists at the target version.
+ */
+export function planMigration(root, { published } = {}) {
+  const changes = [];
+  const contents = new Map();
+
+  const sourceFiles = listSourceFiles(root);
+  const importsVercelFunctions = [];
+  for (const file of sourceFiles) {
+    const text = fs.readFileSync(file, "utf8");
+    const result = migrateSourceFile(root, file, text);
+    if (result.importsVercelFunctions) importsVercelFunctions.push(file);
+    if (result.text !== text) {
+      contents.set(file, result.text);
+      changes.push(...result.changes);
+    }
+  }
+
+  const pkgFile = path.join(root, "package.json");
+  const pkgText = fs.readFileSync(pkgFile, "utf8");
+  const pkgResult = migratePackageJson(pkgText, {
+    importsVercelFunctions: importsVercelFunctions.length > 0,
+    packageManager: detectPackageManager(root),
+    published,
+  });
+  if (pkgResult.text !== pkgText) {
+    contents.set(pkgFile, pkgResult.text);
+  }
+  changes.push(...pkgResult.changes.map((change) => ({ file: "package.json", ...change })));
+
+  return { changes, contents, manual: pkgResult.manual };
+}
+
+/** The @uniformdev dependencies that the migration sets to the target version. */
+export function uniformDependencies(pkg) {
+  const names = new Set();
+  for (const field of ["dependencies", "devDependencies"]) {
+    for (const [name, version] of Object.entries(pkg[field] ?? {})) {
+      if (name.startsWith("@uniformdev/") && !SEPARATE_VERSION_LINE.has(name) && !/^(file|link|workspace|git|github|https?):/.test(version)) names.add(name);
+    }
+  }
+  return [...names];
+}
+
+function detectPackageManager(root) {
+  if (fs.existsSync(path.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(root, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+
+// package.json
+
+export function migratePackageJson(text, { importsVercelFunctions, packageManager = "npm", published }) {
+  const pkg = JSON.parse(text);
+  const changes = [];
+  const manual = [];
+  let out = text;
+
+  for (const name of uniformDependencies(pkg)) {
+    const isPublished = published ? published.get(name) : true;
+    if (isPublished === false) continue; // This package has its own version line.
+    if (isPublished === undefined) {
+      manual.push(`Could not ask the npm registry if ${name}@${TARGET_VERSION} exists. Set its version yourself.`);
+      continue;
+    }
+    for (const field of ["dependencies", "devDependencies"]) {
+      const version = pkg[field]?.[name];
+      if (!version || version === TARGET_VERSION) continue;
+      out = setValueInBlock(out, field, name, TARGET_VERSION) ?? out;
+      changes.push({ rule: "version", description: `Set ${name} from ${version} to ${TARGET_VERSION}.` });
+    }
+  }
+
+  const listed = pkg.dependencies?.["@vercel/functions"] || pkg.devDependencies?.["@vercel/functions"];
+  if (importsVercelFunctions && !listed) {
+    out = addToBlock(out, "dependencies", "@vercel/functions", VERCEL_FUNCTIONS_RANGE);
+    changes.push({
+      rule: "vercel-functions-transitive",
+      description: `Add @vercel/functions ${VERCEL_FUNCTIONS_RANGE} to dependencies. The stable SDK installs it for you.`,
+    });
+  }
+
+  // A prerelease does not match the ^20.x peer range of @uniformdev/toolbar-react. Without an
+  // override, npm fails with ERESOLVE, and the app can get two copies of @uniformdev/context.
+  const usesToolbar = pkg.dependencies?.["@uniformdev/toolbar-react"] || pkg.devDependencies?.["@uniformdev/toolbar-react"];
+  if (TARGET_VERSION.includes("-") && usesToolbar) {
+    const field = { npm: "overrides", yarn: "resolutions" }[packageManager];
+    if (!field) {
+      manual.push(`Add "@uniformdev/context": "${TARGET_VERSION}" to the pnpm overrides, so that @uniformdev/toolbar-react accepts the prerelease version.`);
+    } else if (!pkg[field]?.["@uniformdev/context"]) {
+      out = addToBlock(out, field, "@uniformdev/context", TARGET_VERSION);
+      changes.push({
+        rule: "prerelease-peer-range",
+        description: `Add "@uniformdev/context": "${TARGET_VERSION}" to ${field}. @uniformdev/toolbar-react does not accept a prerelease version without it.`,
+      });
+    }
+  }
+
+  return { text: out, changes, manual };
+}
+
+// Source files
+
+export function migrateSourceFile(root, file, text) {
+  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, scriptKind(file));
+  const rel = path.relative(root, file);
+  const lineOf = (node) => sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+  const changes = [];
+  const removals = []; // { list, element } items, grouped by list later.
+  const record = (node, rule, description) => changes.push({ file: rel, line: lineOf(node), rule, description });
+
+  const sdkLocals = new Map();
+  let importsVercelFunctions = false;
+  for (const statement of sf.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const module = statement.moduleSpecifier.text;
+    if (module === "@vercel/functions" || module.startsWith("@vercel/functions/")) importsVercelFunctions = true;
+    if (!module.startsWith(SDK)) continue;
+    const bindings = statement.importClause?.namedBindings;
+    if (bindings && ts.isNamedImports(bindings)) {
+      for (const element of bindings.elements) {
+        sdkLocals.set(element.name.text, { module, imported: (element.propertyName ?? element.name).text, element, statement });
+      }
+    }
+  }
+
+  const isConfigFile = /^uniform\.server\.config\.[cm]?[jt]s$/.test(path.basename(file));
+  if (!sdkLocals.size && !isConfigFile) return { text, changes, importsVercelFunctions };
+
+  const isSdkCallee = (expression) => ts.isIdentifier(expression) && sdkLocals.has(expression.text);
+  const isDefaultDataClient = (expression) =>
+    expression &&
+    ts.isNewExpression(expression) &&
+    ts.isIdentifier(expression.expression) &&
+    sdkLocals.get(expression.expression.text)?.imported === DEFAULT_DATA_CLIENT &&
+    !(expression.arguments ?? []).length;
+
+  const visit = (node) => {
+    // Options of SDK functions: uniformMiddleware({ ... }), resolveRouteFromCode({ ... }) and others.
+    if (ts.isCallExpression(node) && isSdkCallee(node.expression)) {
+      for (const argument of node.arguments) {
+        if (!ts.isObjectLiteralExpression(argument)) continue;
+        for (const property of argument.properties) {
+          const name = property.name && propertyName(property.name);
+          if (name === "pathPatternsWithVariations") {
+            removals.push({ list: argument.properties, element: property, owner: argument });
+            record(property, "removed-option", 'Remove the "pathPatternsWithVariations" option. The middleware no longer evaluates variants.');
+          }
+          if (name === "dataClient" && ts.isPropertyAssignment(property) && isDefaultDataClient(property.initializer)) {
+            removals.push({ list: argument.properties, element: property, owner: argument });
+            record(property, "removed-option", 'Remove "dataClient: new DefaultDataClient()". It set the default data client.');
+          }
+        }
+      }
+    }
+
+    // <UniformComposition dataClient={new DefaultDataClient()} />
+    if (ts.isJsxAttribute(node) && node.name.getText(sf) === "dataClient") {
+      const tag = node.parent.parent;
+      const expression = node.initializer && ts.isJsxExpression(node.initializer) ? node.initializer.expression : undefined;
+      if (ts.isIdentifier(tag.tagName) && sdkLocals.has(tag.tagName.text) && isDefaultDataClient(expression)) {
+        removals.push({ jsx: node });
+        record(node, "removed-option", 'Remove the prop "dataClient={new DefaultDataClient()}". It set the default data client.');
+      }
+    }
+
+    // The server configuration.
+    if (ts.isObjectLiteralExpression(node) && isServerConfigObject(node, isConfigFile)) {
+      for (const property of node.properties) {
+        const name = property.name && propertyName(property.name);
+        if (name === "middlewareRuntimeCache") {
+          removals.push({ list: node.properties, element: property, owner: node });
+          record(property, "removed-config-key", 'Remove "middlewareRuntimeCache". The middleware makes no API calls.');
+        }
+        if (name === "experimental" && ts.isPropertyAssignment(property) && ts.isObjectLiteralExpression(property.initializer)) {
+          const inner = property.initializer.properties;
+          const flags = inner.filter((p) => p.name && propertyName(p.name) === "disableSwrMiddlewareCache");
+          if (!flags.length) continue;
+          if (flags.length === inner.length) {
+            removals.push({ list: node.properties, element: property, owner: node });
+            record(property, "removed-config-key", 'Remove "experimental: { disableSwrMiddlewareCache }". The middleware makes no API calls.');
+          } else {
+            for (const flag of flags) {
+              removals.push({ list: inner, element: flag, owner: property.initializer });
+              record(flag, "removed-config-key", 'Remove "experimental.disableSwrMiddlewareCache". The middleware makes no API calls.');
+            }
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+
+  const edits = [...editsForRemovals(sf, removals), ...editsForClientContext(sf, sdkLocals, record)];
+  if (!edits.length) return { text, changes: [], importsVercelFunctions };
+
+  // Remove the imports of removed exports that the changes leave without a reference.
+  const removedRanges = edits.map((edit) => [edit.start, edit.end]);
+  const unusedImports = [];
+  for (const [local, info] of sdkLocals) {
+    if (!REMOVED_EXPORTS[info.module]?.[info.imported]) continue;
+    if (!hasReference(sf, local, info.element, removedRanges)) {
+      unusedImports.push(info);
+      record(info.element, "removed-export", `Remove the import of "${info.imported}". No code uses it after the changes.`);
+    }
+  }
+  edits.push(...editsForImportRemovals(sf, unusedImports));
+
+  return { text: applyEdits(text, edits), changes, importsVercelFunctions };
+}
+
+// The SDK now sends the composition metadata of the page composition to the Context, so the
+// compositionMetadata argument of useInitUniformContext and its prop have no effect.
+function editsForClientContext(sf, sdkLocals, record) {
+  const text = sf.getFullText();
+  const { hookArguments, props } = findClientContextIssues(sf, sdkLocals);
+  const edits = [];
+  for (const { call, argument, removable } of hookArguments) {
+    if (!removable) continue;
+    let end = argument.end;
+    const comma = /^\s*,/.exec(text.slice(end));
+    if (comma) end += comma[0].length;
+    edits.push({ start: call.arguments[0].end, end, text: "" });
+    record(argument, "context-composition-metadata", "Remove the compositionMetadata argument of useInitUniformContext. The SDK sends the metadata of the page composition.");
+  }
+
+  const removedRanges = edits.map((edit) => [edit.start, edit.end]);
+  const byPattern = new Map();
+  for (const { element, pattern, fn, name } of props) {
+    if (name !== COMPOSITION_METADATA || !ts.isIdentifier(element.name)) continue;
+    if (hasReference(fn, element.name.text, element, removedRanges, sf)) continue;
+    if (!byPattern.has(pattern)) byPattern.set(pattern, new Set());
+    byPattern.get(pattern).add(element);
+    record(element, "context-composition-metadata", "Remove the compositionMetadata prop. ClientContextComponentProps no longer has it.");
+  }
+  for (const [pattern, elements] of byPattern) {
+    edits.push(...editsForListRemoval(sf, pattern.elements, elements, () => ({ start: pattern.getStart(sf), end: pattern.end, text: "{}" })));
+  }
+  return edits;
+}
+
+function propertyName(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+  return undefined;
+}
+
+function isServerConfigObject(node, isConfigFile) {
+  const parent = node.parent;
+  const typed = (type) => type && /\bUniformServerConfig\b/.test(type.getText());
+  if (ts.isVariableDeclaration(parent) && typed(parent.type)) return true;
+  if (ts.isSatisfiesExpression?.(parent) && typed(parent.type)) return true;
+  if (ts.isAsExpression(parent) && typed(parent.type)) return true;
+  if (isConfigFile && ts.isExportAssignment(parent)) return true;
+  return false;
+}
+
+// True when `local` has a reference in `scope` outside its declaration and outside the removed ranges.
+function hasReference(scope, local, declaration, removedRanges, sf = scope) {
+  let found = false;
+  const inside = (pos) => removedRanges.some(([start, end]) => pos >= start && pos < end);
+  const visit = (node) => {
+    if (found) return;
+    if (ts.isImportDeclaration(node)) return;
+    if (ts.isIdentifier(node) && node.text === local && node !== declaration.name && !inside(node.getStart(sf))) {
+      // Skip the name part of a property access (x.local) and property names ({ local: x }).
+      const parent = node.parent;
+      const isMemberName = (ts.isPropertyAccessExpression(parent) && parent.name === node) || (ts.isPropertyAssignment(parent) && parent.name === node);
+      if (!isMemberName) found = true;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(scope);
+  return found;
+}
+
+// Edits
+
+/** Turns the removals into text edits that keep commas and indentation correct. */
+function editsForRemovals(sf, removals) {
+  const edits = [];
+  const byList = new Map();
+  for (const removal of removals) {
+    if (removal.jsx) {
+      edits.push({ start: removal.jsx.getFullStart(), end: removal.jsx.end, text: "" });
+      continue;
+    }
+    if (!byList.has(removal.list)) byList.set(removal.list, { owner: removal.owner, elements: new Set() });
+    byList.get(removal.list).elements.add(removal.element);
+  }
+
+  // A removal inside a property that is also removed is not necessary.
+  const removedElements = [...byList.values()].flatMap((group) => [...group.elements]);
+  const isInsideRemoved = (owner) => removedElements.some((element) => owner.pos >= element.pos && owner.end <= element.end && owner !== element);
+
+  for (const [list, { owner, elements }] of byList) {
+    if (isInsideRemoved(owner)) continue;
+    edits.push(...editsForListRemoval(sf, list, elements, () => ({ start: owner.getStart(sf), end: owner.end, text: "{}" })));
+  }
+  return edits;
+}
+
+function editsForListRemoval(sf, list, removed, whenEmpty) {
+  const items = [...list];
+  let lastKept = -1;
+  items.forEach((item, i) => {
+    if (!removed.has(item)) lastKept = i;
+  });
+  if (lastKept === -1) return [whenEmpty()];
+
+  const edits = [];
+  items.forEach((item, i) => {
+    if (removed.has(item) && i < lastKept) edits.push({ start: item.getStart(sf), end: items[i + 1].getStart(sf), text: "" });
+  });
+  if (lastKept < items.length - 1) edits.push({ start: items[lastKept].end, end: items[items.length - 1].end, text: "" });
+  return edits;
+}
+
+function editsForImportRemovals(sf, unusedImports) {
+  const edits = [];
+  const byStatement = new Map();
+  for (const info of unusedImports) {
+    if (!byStatement.has(info.statement)) byStatement.set(info.statement, new Set());
+    byStatement.get(info.statement).add(info.element);
+  }
+  for (const [statement, elements] of byStatement) {
+    const clause = statement.importClause;
+    const named = clause.namedBindings;
+    edits.push(
+      ...editsForListRemoval(sf, named.elements, elements, () => {
+        if (clause.name) return { start: clause.name.end, end: named.end, text: "" };
+        // Remove the full import statement and its line break.
+        const text = sf.getFullText();
+        let end = statement.end;
+        if (text[end] === "\r") end++;
+        if (text[end] === "\n") end++;
+        return { start: statement.getStart(sf), end, text: "" };
+      })
+    );
+  }
+  return edits;
+}
+
+export function applyEdits(text, edits) {
+  const sorted = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i].end > sorted[i - 1].start) throw new Error("Internal error: two changes overlap in one file.");
+  }
+  let out = text;
+  for (const edit of sorted) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+  return out;
+}
+
+/** Returns the number of syntax errors that TypeScript finds when it parses the text. */
+export function countSyntaxErrors(file, text) {
+  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, scriptKind(file));
+  return sf.parseDiagnostics?.length ?? 0;
+}

package/src/registry.js

@@ -0,0 +1,25 @@
+// Asks the npm registry which packages exist at a version.
+
+const REGISTRY = process.env.npm_config_registry?.replace(/\/$/, "") || "https://registry.npmjs.org";
+
+/**
+ * Returns a Map from package name to true (published), false (not published) or undefined (the
+ * registry did not answer).
+ */
+export async function publishedAt(names, version, { timeoutMs = 10000 } = {}) {
+  const entries = await Promise.all(
+    names.map(async (name) => {
+      try {
+        const response = await fetch(`${REGISTRY}/${name.replace("/", "%2f")}/${encodeURIComponent(version)}`, {
+          signal: AbortSignal.timeout(timeoutMs),
+          headers: { accept: "application/json" },
+        });
+        if (response.status === 404) return [name, false];
+        return [name, response.ok ? true : undefined];
+      } catch {
+        return [name, undefined];
+      }
+    })
+  );
+  return new Map(entries);
+}