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

package/src/migrate.js

@@ -0,0 +1,356 @@
+// 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 { 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"]);
+// 20.82.0 installed this version of @vercel/functions as a dependency of the SDK.
+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. Version 20.82 installed 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);
+
+  if (!removals.length) return { text, changes: [], importsVercelFunctions };
+
+  const edits = editsForRemovals(sf, removals);
+
+  // 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 };
+}
+
+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 the file outside the import and outside the removed ranges.
+function hasReference(sf, local, importElement, removedRanges) {
+  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 !== importElement.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(sf);
+  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);
+}

package/src/report.js

@@ -0,0 +1,44 @@
+const ORDER = { error: 0, warning: 1, info: 2 };
+const LABEL = { error: "CODE CHANGE NEEDED", warning: "REVIEW", info: "NOTE" };
+
+export const TARGET_VERSION = "20.81.1-alpha.25.sha-f076f9b857";
+
+export function verdict(findings, { strict = false } = {}) {
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  if (errors || (strict && warnings)) return { safe: false, label: "CODE CHANGES NEEDED", errors, warnings };
+  return { safe: true, label: warnings ? "SAFE TO INSTALL (review the behavior changes)" : "SAFE TO INSTALL", errors, warnings };
+}
+
+export function formatText({ project, findings }, result, { color = true } = {}) {
+  const c = (code, s) => (color ? `\u001b[${code}m${s}\u001b[0m` : s);
+  const sev = { error: (s) => c("31;1", s), warning: (s) => c("33;1", s), info: (s) => c("36", s) };
+  const lines = [];
+
+  lines.push(c("1", "Uniform Next.js App Router SDK upgrade check"));
+  lines.push(`Target version: ${TARGET_VERSION}`);
+  lines.push(`Project: ${project.name ?? "(no name)"} at ${project.root}`);
+  lines.push(`Installed @uniformdev/next-app-router: ${project.sdkVersion ?? "not found"}`);
+  lines.push(`Files scanned: ${project.filesScanned}`);
+  lines.push("");
+
+  const sorted = [...findings].sort((a, b) => ORDER[a.severity] - ORDER[b.severity] || (a.file ?? "").localeCompare(b.file ?? "") || (a.line ?? 0) - (b.line ?? 0));
+  let current;
+  for (const f of sorted) {
+    if (f.severity !== current) {
+      current = f.severity;
+      lines.push(sev[current](`${LABEL[current]}`));
+    }
+    const where = f.file ? `${f.file}${f.line ? `:${f.line}` : ""}` : "";
+    lines.push(`  ${sev[f.severity]("•")} ${f.title}${where ? c("2", `  (${where})`) : ""}`);
+    lines.push(`    ${f.message}`);
+    lines.push(`    Fix: ${f.fix}`);
+    lines.push(c("2", `    Docs: ${f.docs}`));
+  }
+  if (!findings.length) lines.push("No findings.");
+
+  lines.push("");
+  lines.push(`Errors: ${result.errors}   Warnings: ${result.warnings}   Notes: ${findings.length - result.errors - result.warnings}`);
+  lines.push(c(result.safe ? "32;1" : "31;1", `Verdict: ${result.label}`));
+  return lines.join("\n");
+}

package/src/rules.js

@@ -0,0 +1,156 @@
+// Each rule describes one change between @uniformdev/next-app-router 20.82 and the
+// developer preview (20.81.1-alpha.25). "error" rules fail to compile or break at
+// runtime. "warning" rules change behavior. "info" rules need no change.
+
+const DOCS = "https://docs.uniform.app/docs/sdk/nextjs-app-router";
+const UPGRADE = `${DOCS}/upgrade-to-developer-preview`;
+
+export const REMOVED_EXPORTS = {
+  "@uniformdev/next-app-router": {
+    DataClient: "Resolve the composition on the page and change it before render.",
+    DefaultDataClient: "Resolve the composition on the page and change it before render.",
+    EnhanceRouteOptions: "Resolve the composition on the page and change it before render.",
+    GetRouteOptions: "No replacement.",
+    GetRouteFromMiddlewareOptions: "No replacement.",
+    GetRouteFromPageStateOptions: "No replacement.",
+    RewriteRouteOptions: "No replacement.",
+    RewriteRouteResult: "No replacement.",
+    expireMiddlewareCacheTag: "Use the onRevalidateTags option of createPreviewPOSTRouteHandler.",
+    precomputeComposition: "Use edge mode: the edge chooses the variants of each visitor.",
+  },
+  "@uniformdev/next-app-router-shared": {
+    getRuleId: "No replacement.",
+    resolveComponentFromPageState: "No replacement.",
+    resolveRuleFromPageState: "No replacement.",
+    PageStateComponent: "No replacement.",
+    PageStateComponentFields: "No replacement.",
+  },
+  "@uniformdev/next-app-router-client": {
+    ClientContextTestTransfer: "No replacement.",
+  },
+};
+
+export const REMOVED_OPTIONS = {
+  dataClient: "Remove it. Resolve the composition on the page and change it before render.",
+  pathPatternsWithVariations: "Remove it. The middleware no longer evaluates variants.",
+};
+
+export const REMOVED_CONFIG_KEYS = {
+  middlewareRuntimeCache: "Remove it. The middleware makes no API calls.",
+  disableSwrMiddlewareCache: "Remove experimental.disableSwrMiddlewareCache. The middleware makes no API calls.",
+};
+
+export const REMOVED_PAGE_STATE_FIELDS = ["components", "rules", "quirks", "isPrefetch", "requestPath"];
+
+export const RULES = {
+  "removed-export": {
+    severity: "error",
+    title: "Import of an API that the developer preview removes",
+    docs: `${UPGRADE}#step-5-replace-the-removed-apis`,
+  },
+  "removed-option": {
+    severity: "error",
+    title: "Option or prop that the developer preview removes",
+    docs: `${UPGRADE}#step-2-remove-the-removed-middleware-options`,
+  },
+  "removed-config-key": {
+    severity: "error",
+    title: "Server configuration option that the developer preview removes",
+    docs: `${UPGRADE}#step-4-clean-up-the-server-configuration`,
+  },
+  "removed-page-state-field": {
+    severity: "error",
+    title: "Page state field that the developer preview removes",
+    docs: `${UPGRADE}#step-5-replace-the-removed-apis`,
+  },
+  "result-code": {
+    severity: "error",
+    title: "Use of result.code from a route resolver",
+    docs: `${UPGRADE}#step-5-replace-the-removed-apis`,
+  },
+  "old-page-code": {
+    severity: "error",
+    title: "Hard-coded page code in the old format (2~)",
+    docs: `${UPGRADE}#behavior-changes`,
+  },
+  "next-version": {
+    severity: "error",
+    title: "Next.js version is lower than 16.0.7",
+    docs: `${DOCS}#prerequisites`,
+  },
+  "vercel-functions-transitive": {
+    severity: "error",
+    title: "@vercel/functions is imported but not a dependency",
+    docs: `${UPGRADE}#step-7-install-the-vercel-functions-package`,
+  },
+  "route-union": {
+    severity: "warning",
+    title: "Direct access to route.compositionApiResponse",
+    docs: `${DOCS}/resolving-compositions#the-result`,
+  },
+  "placement-props": {
+    severity: "warning",
+    title: "Use of PersonalizeProps or TestProps",
+    docs: `${UPGRADE}#behavior-changes`,
+  },
+  "lite-mode-flicker": {
+    severity: "warning",
+    title: "Personalizations and tests change from middleware evaluation to the browser (lite mode)",
+    docs: `${DOCS}/edge-personalization`,
+  },
+  "project-map-query-strings": {
+    severity: "warning",
+    title: "Project map nodes with query strings",
+    docs: `${DOCS}/middleware#keep-query-strings-in-the-route`,
+  },
+  "visibility-rules": {
+    severity: "warning",
+    title: "Components with visibility rules are not in the server HTML",
+    docs: `${DOCS}/personalization#visibility-rules`,
+  },
+  "not-found-page": {
+    severity: "warning",
+    title: "Missing routes no longer rewrite to /404",
+    docs: `${DOCS}/recipes/not-found`,
+  },
+  "not-found-html": {
+    severity: "warning",
+    title: "The HTML of the 404 page is empty until hydration",
+    docs: `${DOCS}/recipes/not-found`,
+  },
+  "per-request-consent": {
+    severity: "warning",
+    title: "defaultConsent is set for each request in the middleware",
+    docs: `${DOCS}/incremental-static-regeneration-isr#consent-and-edge-mode-values`,
+  },
+  "uniform-version-mismatch": {
+    severity: "warning",
+    title: "@uniformdev packages have different versions",
+    docs: `${UPGRADE}#step-1-install-the-packages`,
+  },
+  "prerelease-peer-range": {
+    severity: "warning",
+    title: "A package has a peer range that does not accept prerelease versions",
+    docs: `${UPGRADE}#step-1-install-the-packages`,
+  },
+  "cached-resolver": {
+    severity: "info",
+    title: "The 'use cache' resolver now caches only published content",
+    docs: `${DOCS}/caching#cache-components`,
+  },
+  "static-params": {
+    severity: "info",
+    title: "createUniformStaticParams makes one code for each path",
+    docs: `${DOCS}/incremental-static-regeneration-isr`,
+  },
+  "context-edge-dependency": {
+    severity: "info",
+    title: "@uniformdev/context-edge is no longer necessary",
+    docs: `${UPGRADE}#step-1-install-the-packages`,
+  },
+  "redirect-status": {
+    severity: "info",
+    title: "Uniform redirects now come from the page (308 or 307)",
+    docs: `${UPGRADE}#behavior-changes`,
+  },
+};