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

package/README.md

@@ -1,3 +1,249 @@
-# Temporary Holding Version
+# @uniformdev/next-app-router-upgrade
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This CLI helps you move a Next.js App Router app that uses `@uniformdev/next-app-router` to the developer preview of the SDK (`20.81.1-alpha.25.sha-f076f9b857`). The upgrade has two phases:
+
+- **Phase 1: upgrade the SDK.** The minimum changes. After phase 1, the app works in lite mode: the browser chooses the personalization and test variants after hydration.
+- **Phase 2: turn on edge mode.** The edge chooses the variants of each visitor, so the first paint is correct. The steps depend on the host of the app.
+
+The CLI has these commands:
+
+| Command | What it does |
+|---|---|
+| (no command, in a terminal) | Starts the interactive guide. |
+| `interactive` | A guide through the check, phase 1 and phase 2, with questions. |
+| `check` | Scans the app, and tells you if it can move to the developer preview without code changes. Without a terminal, this is the default. |
+| `migrate` | Phase 1: applies the code changes that are safe to do automatically, and lists the manual changes. |
+| `migrate --edge <host>` | Phase 1 and phase 2 in one plan. |
+
+## Interactive guide
+
+Run the CLI in the root folder of your Next.js app, without a command:
+
+```bash
+npx @uniformdev/next-app-router-upgrade
+```
+
+The guide shows the status of the app: the SDK version, the result of the check, and the mode (lite mode or edge mode). Then it asks what you want to do:
+
+1. **Check compatibility.** Shows the full report. It changes nothing.
+2. **Phase 1: upgrade the SDK.** Shows the automatic changes, the diff if you want it, and the manual changes. It writes only after you say yes.
+3. **Phase 2: turn on edge mode.** Asks for the host of your app. If phase 1 is not done, the plan includes phase 1 too.
+
+After a write, the guide can run `npm install` (or `pnpm install`, or `yarn`) for you. Then it goes back to the menu, with the new status.
+
+The guide uses the same safety checks as `migrate`. One difference: when a file contains changes that are not committed, the guide asks if you want to continue. `migrate` stops, unless you use `--allow-dirty`.
+
+### Hosts for edge mode
+
+| Host | Status |
+|---|---|
+| Vercel | Available: `--edge vercel` |
+| Cloudflare | Coming soon. Follow the docs for other hosts. |
+| Netlify | Coming soon. Follow the docs for other hosts. |
+| Akamai | Coming soon. Follow the docs for other hosts. |
+
+## Usage
+
+Run the check in the root folder of your Next.js app:
+
+```bash
+npx @uniformdev/next-app-router-upgrade
+```
+
+Or give the folder:
+
+```bash
+npx @uniformdev/next-app-router-upgrade ./apps/web
+```
+
+| Option | Description |
+|---|---|
+| `--json` | Print the result as JSON, for CI. |
+| `--strict` | Fail on warnings too. |
+| `--uniform-data <dir>` | The folder of serialized Uniform content. The default is `uniform-data`. |
+| `--no-color` | Print without colors. |
+
+| Exit code | Meaning |
+|---|---|
+| `0` | Safe to install. Read the warnings: they are behavior changes. |
+| `1` | Code changes needed. |
+| `2` | The check could not run, for example because there is no `package.json`. |
+
+## Migrate
+
+Run the migration in the root folder of your Next.js app. First, see the changes without writing files:
+
+```bash
+npx @uniformdev/next-app-router-upgrade migrate --dry-run
+```
+
+The command shows a list of the changes, a diff for each file, the manual changes and the behavior changes to review. Then write the changes:
+
+```bash
+npx @uniformdev/next-app-router-upgrade migrate
+```
+
+The command asks before it writes. After the migration:
+
+1. Install the new versions with `npm install`, `pnpm install` or `yarn`.
+2. Do the manual changes.
+3. Run `check` again.
+4. Build and test the app with `next build`.
+5. Read the changes with `git diff`.
+
+| Option | Description |
+|---|---|
+| `--dry-run` | Show the changes. Do not write files. |
+| `--yes` | Write the changes without a question. Necessary in CI and in a shell without a terminal. |
+| `--allow-dirty` | Write also when the files contain changes that are not committed, or when the app is not in a git repository. |
+| `--no-color` | Print without colors. |
+
+| Exit code | Meaning |
+|---|---|
+| `0` | No code changes are left. |
+| `1` | Manual code changes are left. The automatic changes were written, if you did not use `--dry-run`. |
+| `2` | Nothing was written, because of an error or a safety check. |
+
+### Automatic changes
+
+The migration changes only code where the result has the same behavior:
+
+| Change | When |
+|---|---|
+| Set each `@uniformdev` package to the target version | The npm registry has the package at that version. `@uniformdev/toolbar-react` and `@uniformdev/context-edge` have their own version lines, so they do not change. |
+| Add `@vercel/functions` `^3.7.2` to `dependencies` | The app imports `@vercel/functions`, and `package.json` does not list it. Version 20.82 installed it for you. |
+| Add an override for `@uniformdev/context` | The target is a prerelease, and the app uses `@uniformdev/toolbar-react`. npm gets `overrides`, and yarn gets `resolutions`. For pnpm, the migration gives a manual step. |
+| Remove the `pathPatternsWithVariations` option | Always. The option has no effect in the developer preview. |
+| Remove `dataClient: new DefaultDataClient()` and the `dataClient={new DefaultDataClient()}` prop | Only for the default data client. A custom data client stays, and the migration lists it as a manual change. |
+| Remove `middlewareRuntimeCache` and `experimental.disableSwrMiddlewareCache` | In the server configuration: `uniform.server.config.*`, or an object of the type `UniformServerConfig`. |
+| Remove the import of a removed API | Only when no code uses it after the changes above. |
+
+All other findings of `check` are manual changes. Examples are a custom data client, `result.code`, `route.compositionApiResponse` without a type check, old page codes and the Next.js version. The migration shows each one with its file and line.
+
+### Phase 2 on Vercel (`--edge vercel`)
+
+```bash
+npx @uniformdev/next-app-router-upgrade migrate --edge vercel --dry-run
+npx @uniformdev/next-app-router-upgrade migrate --edge vercel
+```
+
+The steps follow "Set up edge mode on Vercel" in the docs:
+
+| Change | When |
+|---|---|
+| Add `@vercel/functions` `^3.7.2` | `package.json` does not list it. |
+| Replace `uniformMiddleware(...)` with `vercelUniformEdgeMiddleware(...)`, and import it from `@uniformdev/next-app-router/vercel` | Each reference to `uniformMiddleware` is a call. The edge middleware accepts the same options. |
+| Add `missing: [{ type: "header", key: "x-uniform-edge-origin" }]` to each matcher | A string matcher becomes `{ source, missing }`. An object matcher gets the `missing` rule. |
+| Add `runtime: "experimental-edge"` | The config has no runtime. |
+| Add a config with the default matcher of the docs | `middleware.ts` has no config. Before, the middleware ran on all paths. |
+| Add `edgeMode: [true, false]` to `createUniformStaticParams` | The options do not have `edgeMode`. |
+| Add `onRevalidateTags: expireVercelRuntimeCacheTags` to `createPreviewPOSTRouteHandler`, and its import | The handler does not have `onRevalidateTags`. |
+
+These cases are manual changes:
+
+- A custom middleware that calls `handleUniformRoute`.
+- A `proxy.ts` file. Edge mode needs `middleware.ts` with the edge runtime (vercel/next.js#82344).
+- A runtime other than `experimental-edge` or `edge`.
+- A matcher or options that are not literals.
+- An own `onRevalidateTags` function. Call `expireVercelRuntimeCacheTags(tags)` from it.
+
+The CLI also reminds you to check the Uniform webhook. It cannot see the webhook settings.
+
+### Safety
+
+- **Nothing is written without your approval.** The command asks first. In a shell without a terminal, it writes only with `--yes`.
+- **You can undo the changes with git.** The command stops in two cases: a file to change contains changes that are not committed, or the app is not in a git repository. Use `--allow-dirty` to write in these cases.
+- **The changes must parse.** The command parses each changed file again. If a change adds a syntax error, nothing is written.
+- **All files or none.** The command writes each file to a temporary file first. If a write fails, it writes the original files back.
+- **A second run changes nothing.** The changes do not repeat.
+- **The format stays.** The migration changes only the necessary text. Other lines, comments and the format of `package.json` stay the same.
+- **The migration does not install packages.** It does not change the lock file. Run your package manager after the migration.
+
+## What `check` finds
+
+The check reads `package.json`, all source files (`.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, `.cjs`) with the TypeScript parser, and the `uniform-data` folder when it exists. It skips `node_modules`, `.next` and build folders.
+
+### Code changes needed (errors)
+
+Each of these fails the TypeScript build, or fails at runtime, with the developer preview:
+
+| Rule | What it finds |
+|---|---|
+| `removed-export` | Imports of `DataClient`, `DefaultDataClient`, `EnhanceRouteOptions`, `GetRouteOptions`, `GetRouteFromMiddlewareOptions`, `GetRouteFromPageStateOptions`, `RewriteRouteOptions`, `RewriteRouteResult`, `expireMiddlewareCacheTag`, `precomputeComposition` (`@uniformdev/next-app-router`), `getRuleId`, `resolveComponentFromPageState`, `resolveRuleFromPageState`, `PageStateComponent`, `PageStateComponentFields` (`-shared`) and `ClientContextTestTransfer` (`-client`). |
+| `removed-option` | The `dataClient` and `pathPatternsWithVariations` options and props. |
+| `removed-config-key` | `middlewareRuntimeCache` and `experimental.disableSwrMiddlewareCache` in the server configuration. |
+| `removed-page-state-field` | `pageState.components`, `.rules`, `.quirks`, `.isPrefetch` and `.requestPath`. |
+| `result-code` | `.code` on the result of `resolveRouteFromCode` or `resolvePlaygroundRoute`. |
+| `old-page-code` | Hard-coded `/uniform/2~…` page codes. |
+| `next-version` | Next.js lower than 16.0.7. |
+| `vercel-functions-transitive` | Imports of `@vercel/functions` when `package.json` does not list it. Version 20.82 installed it for you. |
+
+### Behavior changes (warnings)
+
+| Rule | What it finds |
+|---|---|
+| `lite-mode-flicker` | `uniformMiddleware` or `handleUniformRoute`. The browser now chooses personalization and test variants after hydration. |
+| `not-found-html` | All apps. The HTML of the 404 page is empty until hydration. |
+| `route-union` | `route.compositionApiResponse` without a `route.type === "composition"` check. |
+| `placement-props` | `PersonalizeProps` or `TestProps`. Their props changed. |
+| `project-map-query-strings` | Project map nodes with query strings in `uniform-data`. |
+| `visibility-rules` | Compositions with visibility rules in `uniform-data`. |
+| `not-found-page` | `app/**/404/page.*` routes. The middleware no longer rewrites to `/404`. |
+| `per-request-consent` | A `defaultConsent` value that is not a literal in the middleware. |
+| `uniform-version-mismatch` | Different versions of `@uniformdev` packages. |
+| `prerelease-peer-range` | `@uniformdev/toolbar-react` without an override for prerelease versions. |
+
+### Notes (info)
+
+`cached-resolver`, `static-params`, `context-edge-dependency` and `redirect-status` tell you about changes that need no code change.
+
+## Limits
+
+- The check reads the code. It does not run it. The check can miss a `pageState` with a different variable name, or a removed API that the code gets through a re-export.
+- `uniform-data` is optional. Without it, the check cannot see query strings, visibility rules or personalizations in your content.
+- To be sure, also install the developer preview in a branch and run `next build`.
+
+## Development
+
+```bash
+npm install
+npm test
+node bin/cli.js test/fixtures/breaking-app
+```
+
+### Test the package on a local app before you publish
+
+`npm pack` makes the same package that npm will publish. Use it to make sure that the package contains all the files that the CLI needs.
+
+1. Make the package:
+
+   ```bash
+   cd /path/to/the-cli-repo
+   npm pack
+   ```
+
+   The command makes the file `uniformdev-next-app-router-upgrade-<version>.tgz`.
+
+2. Go to the root folder of the app to check. This is the folder with the `package.json` of the app:
+
+   ```bash
+   cd /path/to/your-app
+   ```
+
+3. Run the CLI from the package:
+
+   ```bash
+   npx --package /path/to/the-cli-repo/uniformdev-next-app-router-upgrade-<version>.tgz uniform-next-app-router-upgrade
+   ```
+
+   Use the full path of the `.tgz` file, and give the command name after it. `npx <file>.tgz` without `--package` fails with "Permission denied".
+
+4. Read the exit code:
+
+   ```bash
+   echo $?
+   ```
+
+After each change to the CLI, run `npm pack` again. If the version does not change, npx can use a copy from its cache. To prevent this, add `--prefer-online` to the `npx` command, or change the version in `package.json`.
+
+The check only reads the app. It does not change files in the app. `.gitignore` excludes the `.tgz` files.

package/bin/cli.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+
+import { PROVIDERS, providerNames } from "../src/edge/index.js";
+import { runInteractive } from "../src/interactive.js";
+import { planMigration } from "../src/migrate.js";
+import { formatText, TARGET_VERSION, verdict } from "../src/report.js";
+import { scanProject } from "../src/scan.js";
+import { colors, executeMigration, NAME } from "../src/session.js";
+
+const HOSTS = Object.entries(PROVIDERS)
+  .map(([key, provider]) => `${key}${provider.available ? "" : " (coming soon)"}`)
+  .join(", ");
+
+const HELP = `Usage:
+  ${NAME}                             In a terminal: the interactive guide. Otherwise: check.
+  ${NAME} interactive [dir]           The interactive guide through the check, phase 1 and phase 2.
+  ${NAME} check [dir] [options]       Check if the app can move to the developer preview.
+  ${NAME} migrate [dir] [options]     Phase 1: apply the safe code changes for the SDK upgrade.
+  ${NAME} migrate --edge <host>       Phase 1 and phase 2: also turn on edge mode for a host.
+
+The developer preview of @uniformdev/next-app-router is ${TARGET_VERSION}.
+
+Options for check:
+  --json                 Print the result as JSON.
+  --strict               Fail on warnings too.
+
+Options for migrate:
+  --edge <host>          Also turn on edge mode. Hosts: ${HOSTS}.
+  --dry-run              Show the changes. Do not write files.
+  --yes                  Write the changes without a question.
+  --allow-dirty          Write also when the files contain changes that are not committed, or when there is no git repository.
+
+Options for all commands:
+  --uniform-data <dir>   The folder of serialized Uniform content (default: uniform-data).
+  --no-color             Print without colors.
+  -h, --help             Show this help.
+
+Exit codes:
+  check     0 safe to install, 1 code changes needed, 2 the check could not run.
+  migrate   0 no code changes left, 1 manual code changes left, 2 nothing was written because of an error or a safety check.`;
+
+let args;
+try {
+  args = parseArgs({
+    allowPositionals: true,
+    options: {
+      json: { type: "boolean" },
+      strict: { type: "boolean" },
+      "uniform-data": { type: "string" },
+      edge: { type: "string" },
+      "dry-run": { type: "boolean" },
+      yes: { type: "boolean", short: "y" },
+      "allow-dirty": { type: "boolean" },
+      "no-color": { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+    },
+  });
+} catch (error) {
+  console.error(error.message);
+  console.error(HELP);
+  process.exit(2);
+}
+
+if (args.values.help) {
+  console.log(HELP);
+  process.exit(0);
+}
+
+const COMMANDS = new Set(["check", "migrate", "interactive"]);
+const positionals = [...args.positionals];
+const terminal = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+let command = COMMANDS.has(positionals[0]) ? positionals.shift() : undefined;
+command ??= terminal && !args.values.json && !args.values.strict ? "interactive" : "check";
+
+const root = path.resolve(positionals[0] ?? ".");
+const color = !args.values["no-color"] && process.stdout.isTTY;
+const uniformData = args.values["uniform-data"];
+const c = colors(color);
+
+const edge = args.values.edge?.toLowerCase();
+if (edge !== undefined) {
+  if (command !== "migrate") {
+    console.error("--edge works only with migrate.");
+    process.exit(2);
+  }
+  if (!PROVIDERS[edge]) {
+    console.error(`Unknown host "${edge}". Hosts: ${providerNames().join(", ")}.`);
+    process.exit(2);
+  }
+  if (!PROVIDERS[edge].available) {
+    console.error(`Edge mode for ${PROVIDERS[edge].name} is not in this CLI yet. To set it up by hand, follow the docs:`);
+    console.error(`  ${PROVIDERS[edge].docs}`);
+    process.exit(2);
+  }
+}
+
+const scan = preflight(root);
+if (command === "check") runCheck(scan);
+else if (command === "interactive") {
+  if (!terminal) {
+    console.error("The interactive mode needs a terminal. Use check or migrate.");
+    process.exit(2);
+  }
+  process.exit(await runInteractive({ root, color, uniformData }));
+} else {
+  console.log(c("1", "Uniform Next.js App Router SDK migration"));
+  console.log(`Target version: ${TARGET_VERSION}`);
+  console.log(`Project: ${root}`);
+  if (edge) console.log(`Edge mode: ${PROVIDERS[edge].name}`);
+  console.log("");
+  const ask = terminal ? confirmInTerminal : undefined;
+  const code = await executeMigration({
+    root,
+    edge,
+    dryRun: args.values["dry-run"],
+    yes: args.values.yes,
+    allowDirty: args.values["allow-dirty"],
+    color,
+    uniformData,
+    ask,
+  });
+  process.exit(code);
+}
+
+function preflight(dir) {
+  if (!fs.existsSync(path.join(dir, "package.json"))) {
+    console.error(`No package.json in ${dir}. Run the command in the root folder of your Next.js app.`);
+    process.exit(2);
+  }
+  const result = scanProject(dir, { uniformDataDir: uniformData });
+  if (result.project.usesV1 && !result.project.sdkVersion) {
+    console.error("This app uses v1 of the SDK (@uniformdev/canvas-next-rsc). Upgrade to v2 first:");
+    console.error("https://docs.uniform.app/docs/sdk/nextjs-app-router/upgrade-from-v1");
+    process.exit(2);
+  }
+  if (!result.project.sdkVersion) {
+    console.error("This app does not list @uniformdev/next-app-router in package.json.");
+    process.exit(2);
+  }
+  return result;
+}
+
+function runCheck(result) {
+  const outcome = verdict(result.findings, { strict: args.values.strict });
+  if (args.values.json) {
+    console.log(JSON.stringify({ targetVersion: TARGET_VERSION, verdict: outcome, ...result }, null, 2));
+  } else {
+    console.log(formatText(result, outcome, { color }));
+    const { changes } = planMigration(root);
+    if (changes.length) {
+      console.log("");
+      console.log(`${changes.length} change(s) can be applied automatically. To see them, run: ${NAME} migrate --dry-run`);
+    }
+  }
+  process.exit(outcome.safe ? 0 : 1);
+}
+
+async function confirmInTerminal(question, defaultYes = false) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = (await rl.question(`${question} ${defaultYes ? "[Y/n]" : "[y/N]"} `)).trim();
+  rl.close();
+  return answer ? /^y(es)?$/i.test(answer) : defaultYes;
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@uniformdev/next-app-router-upgrade",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Check and upgrade a Next.js App Router app to the developer preview of the Uniform SDK (@uniformdev/next-app-router), with edge mode.",
+  "keywords": [
+    "uniform",
+    "uniformdev",
+    "nextjs",
+    "app-router",
+    "upgrade",
+    "codemod",
+    "migration",
+    "edge"
+  ],
+  "type": "module",
+  "bin": {
+    "uniform-next-app-router-upgrade": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "dependencies": {
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/src/apply.js

@@ -0,0 +1,124 @@
+// Safety checks and file writes for the migration.
+
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+import { countSyntaxErrors } from "./migrate.js";
+
+/**
+ * Returns the files of the plan that have uncommitted changes, or { notGit: true } when the
+ * project is not in a git repository.
+ */
+export function gitState(root, files) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: root, stdio: "pipe" });
+  } catch {
+    return { notGit: true, dirty: [] };
+  }
+  const relative = files.map((file) => path.relative(root, file));
+  const out = execFileSync("git", ["status", "--porcelain", "--", ...relative], { cwd: root, encoding: "utf8" });
+  return { notGit: false, dirty: out.split("\n").filter(Boolean).map((line) => line.slice(3)) };
+}
+
+/** Returns the files where the new text has more syntax errors than the old text. */
+export function validate(contents) {
+  const problems = [];
+  for (const [file, text] of contents) {
+    if (file.endsWith(".json")) {
+      try {
+        JSON.parse(text);
+      } catch (error) {
+        problems.push({ file, message: error.message });
+      }
+      continue;
+    }
+    const before = countSyntaxErrors(file, fs.readFileSync(file, "utf8"));
+    const after = countSyntaxErrors(file, text);
+    if (after > before) problems.push({ file, message: `${after - before} new syntax error(s)` });
+  }
+  return problems;
+}
+
+/**
+ * Writes all files, or none. Each file goes to a temporary file first, and then replaces the
+ * original. If a step fails, the original texts are written back.
+ */
+export function writeAll(contents) {
+  const originals = new Map([...contents.keys()].map((file) => [file, fs.readFileSync(file, "utf8")]));
+  const temps = [];
+  try {
+    for (const [file, text] of contents) {
+      const temp = `${file}.uniform-migrate-${process.pid}.tmp`;
+      fs.writeFileSync(temp, text, { mode: fs.statSync(file).mode });
+      temps.push([temp, file]);
+    }
+    const done = [];
+    try {
+      for (const [temp, file] of temps) {
+        fs.renameSync(temp, file);
+        done.push(file);
+      }
+    } catch (error) {
+      for (const file of done) fs.writeFileSync(file, originals.get(file));
+      throw error;
+    }
+  } finally {
+    for (const [temp] of temps) fs.rmSync(temp, { force: true });
+  }
+}
+
+/** A unified diff with 2 lines of context, for the dry run. */
+export function unifiedDiff(name, before, after, { color = false } = {}) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  const c = (code, s) => (color ? `\u001b[${code}m${s}\u001b[0m` : s);
+
+  // Longest common subsequence of the lines. The files of an app are small enough for this.
+  const n = a.length;
+  const m = b.length;
+  const lcs = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && a[i] === b[j]) ops.push({ type: " ", line: a[i], i: i++, j: j++ });
+    else if (i < n && (j === m || lcs[i + 1][j] >= lcs[i][j + 1])) ops.push({ type: "-", line: a[i], i: i++, j });
+    else ops.push({ type: "+", line: b[j], i, j: j++ });
+  }
+
+  const CONTEXT = 2;
+  const out = [c("1", `--- ${name}`), c("1", `+++ ${name}`)];
+  let k = 0;
+  while (k < ops.length) {
+    if (ops[k].type === " ") {
+      k++;
+      continue;
+    }
+    let start = Math.max(0, k - CONTEXT);
+    let end = k;
+    // Extend the hunk while the next change is near.
+    while (end < ops.length) {
+      if (ops[end].type !== " ") {
+        end++;
+        continue;
+      }
+      let next = end;
+      while (next < ops.length && ops[next].type === " ") next++;
+      if (next < ops.length && next - end <= CONTEXT * 2) end = next;
+      else break;
+    }
+    end = Math.min(ops.length, end + CONTEXT);
+    const first = ops[start];
+    out.push(c("36", `@@ -${first.i + 1} +${first.j + 1} @@`));
+    for (const op of ops.slice(start, end)) {
+      const line = `${op.type}${op.line}`;
+      out.push(op.type === "+" ? c("32", line) : op.type === "-" ? c("31", line) : line);
+    }
+    k = end;
+  }
+  return out.join("\n");
+}

package/src/edge/index.js

@@ -0,0 +1,37 @@
+// Phase 2: edge mode for each host. Add a provider here when its migration is ready.
+
+import { planVercelEdge } from "./vercel.js";
+
+const DOCS = "https://docs.uniform.app/docs/sdk/nextjs-app-router/edge-mode";
+
+export const PROVIDERS = {
+  vercel: {
+    name: "Vercel",
+    available: true,
+    summary: "vercelUniformEdgeMiddleware, the Vercel runtime cache and per-visitor ETags.",
+    docs: `${DOCS}#set-up-edge-mode-on-vercel`,
+    plan: planVercelEdge,
+  },
+  cloudflare: {
+    name: "Cloudflare",
+    available: false,
+    summary: "Coming soon.",
+    docs: `${DOCS}#set-up-edge-mode-on-other-hosts`,
+  },
+  netlify: {
+    name: "Netlify",
+    available: false,
+    summary: "Coming soon.",
+    docs: `${DOCS}#set-up-edge-mode-on-other-hosts`,
+  },
+  akamai: {
+    name: "Akamai",
+    available: false,
+    summary: "Coming soon.",
+    docs: `${DOCS}#set-up-edge-mode-on-other-hosts`,
+  },
+};
+
+export function providerNames() {
+  return Object.keys(PROVIDERS);
+}