@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/run-pvd8bs1t.js

@@ -0,0 +1,696 @@
+// @bun
+import {
+  latestPnextVersionRange
+} from "./index-jx7bqvw1.js";
+import {
+  pnextOptionalDependencyRange
+} from "./index-20ppawv7.js";
+import"./index-tqn2qnnn.js";
+import {
+  bold,
+  cyan,
+  dim,
+  green
+} from "./index-6kp9r0d9.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/cli/migrate/run.ts
+import { existsSync as existsSync3 } from "fs";
+import { appendFile, readFile as readFile4, rm, writeFile as writeFile3 } from "fs/promises";
+import path4 from "path";
+
+// src/cli/migrate/package-json.ts
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+var SEPARATORS = new Set(["&&", "||", ";", "|", "&"]);
+var MAPPED_SUBCOMMANDS = new Set(["dev", "build", "start", "typegen"]);
+var DROPPED_FLAGS = new Set(["--turbo", "--turbopack"]);
+function rewriteScript(script) {
+  const tokens = script.split(/\s+/).filter(Boolean);
+  const reports = [];
+  const out = [];
+  let commandStart = true;
+  let changed = false;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (SEPARATORS.has(token)) {
+      out.push(token);
+      commandStart = true;
+      continue;
+    }
+    if (commandStart && /^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) {
+      out.push(token);
+      continue;
+    }
+    if (!commandStart || token !== "next") {
+      out.push(token);
+      commandStart = false;
+      continue;
+    }
+    let end = index + 1;
+    while (end < tokens.length && !SEPARATORS.has(tokens[end]))
+      end += 1;
+    const subcommand = tokens[index + 1];
+    const rest = tokens.slice(index + 2, end);
+    if (subcommand && MAPPED_SUBCOMMANDS.has(subcommand)) {
+      out.push("pnext", subcommand, ...translateFlags(subcommand, rest));
+      changed = true;
+    } else if (subcommand === "lint") {
+      out.push(...tokens.slice(index, end));
+      reports.push("`next lint` left as-is \u2014 pnext has no lint command; run eslint directly.");
+    } else {
+      out.push(...tokens.slice(index, end));
+      const command = subcommand ? `next ${subcommand}` : "next";
+      reports.push(`\`${command}\` has no pnext equivalent \u2014 left as-is.`);
+    }
+    index = end - 1;
+    commandStart = false;
+  }
+  return { script: changed ? out.join(" ") : script, reports };
+}
+function translateFlags(subcommand, rest) {
+  const out = [];
+  for (const flag of rest) {
+    if (DROPPED_FLAGS.has(flag))
+      continue;
+    if (flag === "-p" && (subcommand === "dev" || subcommand === "start")) {
+      out.push("--port");
+      continue;
+    }
+    out.push(flag);
+  }
+  return out;
+}
+async function migratePackageJson(root, pkg, result, dryRun) {
+  const scripts = isObject(pkg.scripts) ? pkg.scripts : undefined;
+  if (scripts) {
+    const rewritten = [];
+    for (const [name, value] of Object.entries(scripts)) {
+      if (typeof value !== "string")
+        continue;
+      const { script, reports } = rewriteScript(value);
+      if (script !== value) {
+        scripts[name] = script;
+        rewritten.push(`${name}: ${value} \u2192 ${script}`);
+      }
+      for (const detail of reports) {
+        result.reports.push({ title: `package.json script "${name}"`, detail });
+      }
+    }
+    if (rewritten.length > 0) {
+      result.edits.push({
+        file: "package.json",
+        description: `scripts rewritten (${rewritten.length})`,
+        details: rewritten
+      });
+    }
+  }
+  const dependencies = ensureObject(pkg, "dependencies");
+  const devDependencies = ensureObject(pkg, "devDependencies");
+  for (const [field, bucket] of [
+    ["dependencies", dependencies],
+    ["devDependencies", devDependencies]
+  ]) {
+    if ("next" in bucket) {
+      delete bucket.next;
+      result.edits.push({
+        file: "package.json",
+        description: "next removed",
+        details: [`next removed from ${field}`]
+      });
+    }
+  }
+  if (!("@wular/pnext" in devDependencies) && !("@wular/pnext" in dependencies)) {
+    const versionRange = await latestPnextVersionRange("migrate");
+    devDependencies["@wular/pnext"] = versionRange;
+    result.edits.push({
+      file: "package.json",
+      description: "@wular/pnext added",
+      details: [`devDependencies: @wular/pnext ${versionRange}`]
+    });
+  }
+  const fontRange = pnextOptionalDependencyRange("next-font");
+  if (result.googleFontImports.length > 0 && fontRange && !("next-font" in dependencies) && !("next-font" in devDependencies)) {
+    dependencies["next-font"] = fontRange;
+    result.edits.push({
+      file: "package.json",
+      description: "next-font added",
+      details: [
+        `dependencies: next-font ${fontRange} (next/font/google metadata, used by ${result.googleFontImports.length} file${result.googleFontImports.length === 1 ? "" : "s"})`
+      ]
+    });
+  }
+  if (!("preact" in dependencies) && !("preact" in devDependencies)) {
+    dependencies.preact = "^10";
+    result.edits.push({
+      file: "package.json",
+      description: "preact added",
+      details: ["dependencies: preact ^10 (react/react-dom kept \u2014 compat aliases them)"]
+    });
+  }
+  const leftovers = [...Object.keys(dependencies), ...Object.keys(devDependencies)].filter((name) => name === "eslint-config-next" || name.startsWith("@next/"));
+  if (leftovers.length > 0) {
+    result.reports.push({
+      title: "Next-specific packages still installed",
+      detail: "Optional cleanup \u2014 these are unused under pnext. See https://pnext.dev/docs/compat.",
+      files: leftovers
+    });
+  }
+  pruneEmpty(pkg, "dependencies");
+  pruneEmpty(pkg, "devDependencies");
+  if (!dryRun) {
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify(pkg, null, 2)}
+`);
+  }
+}
+async function readPackageJson(root) {
+  try {
+    const parsed = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"));
+    return isObject(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function ensureObject(pkg, key) {
+  if (!isObject(pkg[key]))
+    pkg[key] = {};
+  return pkg[key];
+}
+function pruneEmpty(pkg, key) {
+  const value = pkg[key];
+  if (isObject(value) && Object.keys(value).length === 0)
+    delete pkg[key];
+}
+
+// src/cli/migrate/report.ts
+var amber = (value) => process.stdout.isTTY ? `\x1B[38;5;214m${value}\x1B[39m` : value;
+function emptyResult() {
+  return { edits: [], reports: [], syncRequestApis: [], googleFontImports: [] };
+}
+function printHeader(root, dryRun) {
+  const suffix = dryRun ? "dry run, nothing will be written" : root;
+  console.log(`
+\u26A1 ${bold("pnext migrate")} ${dim(`\u2014 ${suffix}`)}`);
+}
+function printResult(result, options) {
+  const lines = [];
+  lines.push(`
+${bold("Changes")}`);
+  if (result.edits.length === 0) {
+    lines.push(`  ${dim("nothing to change")}`);
+  }
+  for (const [file, edits] of groupByFile(result.edits)) {
+    lines.push(`${green("\u2713")} ${bold(file)} ${dim(`\u2014 ${edits.map((edit) => edit.description).join(", ")}`)}`);
+    for (const edit of edits) {
+      for (const detail of edit.details ?? [])
+        lines.push(`    ${dim(detail)}`);
+    }
+  }
+  lines.push(`
+${bold("Review")}${result.reports.length > 0 ? ` (${result.reports.length})` : ""}`);
+  if (result.reports.length === 0) {
+    lines.push(`  ${dim("nothing flagged")}`);
+  }
+  for (const item of result.reports) {
+    lines.push(`${amber("!")} ${bold(item.title)}`);
+    lines.push(`    ${dim(item.detail)}`);
+    for (const file of item.files ?? [])
+      lines.push(`    ${dim(`\xB7 ${file}`)}`);
+  }
+  lines.push(`
+${bold("Next steps")}`);
+  lines.push(`  1. Install the new dependencies: ${cyan(options.install)}`);
+  lines.push(`  2. Start the app: ${cyan("pnext dev")}`);
+  console.log(lines.join(`
+`));
+}
+function groupByFile(edits) {
+  const grouped = new Map;
+  for (const edit of edits) {
+    const bucket = grouped.get(edit.file);
+    if (bucket)
+      bucket.push(edit);
+    else
+      grouped.set(edit.file, [edit]);
+  }
+  return grouped;
+}
+
+// src/cli/migrate/scan.ts
+import { existsSync } from "fs";
+import { readdir, readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+var SKIP_DIRS = new Set(["node_modules", ".next", ".pnext", ".git", "dist", "build"]);
+var LOADERS = {
+  ".ts": "ts",
+  ".tsx": "tsx",
+  ".jsx": "jsx",
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js"
+};
+var STREAMING_APIS = ["renderToReadableStream", "renderToPipeableStream"];
+var CALL_THEN_ACCESS = /(await\s+)?\b([\w$]+)\s*\(\s*\)\s*(?:\.\s*([\w$]+)|\[)/g;
+var NEXT_HEADERS_IMPORT = /import\s*\{([^}]*)\}\s*from\s*['"]next\/headers['"]/g;
+var REQUEST_APIS = new Set(["cookies", "headers", "draftMode"]);
+var PROMISE_METHODS = new Set(["then", "catch", "finally"]);
+var SPECIAL_PAGES = ["_app", "_document", "_error"];
+var SEGMENT_FILES = new Set(["page", "layout", "route", "template", "default"]);
+var SEGMENT_HEADS = /export\s+default\s+(?:async\s+)?function\s*[\w$]*\s*\(|export\s+default\s+(?:async\s+)?\(|export\s+(?:async\s+)?function\s+generateMetadata\s*\(|export\s+const\s+generateMetadata\s*(?::[^=]*)?=\s*(?:async\s*)?\(/g;
+var ROUTE_HANDLER_HEADS = /export\s+(?:async\s+)?function\s+(?:GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS)\s*\(|export\s+const\s+(?:GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS)\s*(?::[^=]*)?=\s*(?:async\s*)?\(/g;
+var SYNC_PROPS = ["params", "searchParams"];
+async function scanSources(root, result) {
+  const { SHIMMED_NEXT_DIST_PATHS } = await import("./aliases-j47a10ce.js");
+  const shimmed = new Set(SHIMMED_NEXT_DIST_PATHS);
+  const deepImports = [];
+  const streaming = [];
+  const headImports = [];
+  for await (const file of walk(root)) {
+    const loader = LOADERS[path2.extname(file)];
+    if (!loader)
+      continue;
+    const text = await readFile2(file, "utf8");
+    let specifiers;
+    try {
+      specifiers = new Bun.Transpiler({ loader }).scanImports(text).map((item) => item.path);
+    } catch {
+      continue;
+    }
+    const relative = path2.relative(root, file);
+    for (const specifier of specifiers) {
+      if (specifier.startsWith("next/dist/") && !shimmed.has(specifier.replace(/\.js$/, ""))) {
+        deepImports.push(`${relative} \u2192 ${specifier}`);
+      }
+      if (/^react-dom\/server(\.|\/|$)/.test(specifier) && STREAMING_APIS.some((api) => text.includes(api))) {
+        streaming.push(relative);
+      }
+      if (specifier === "next/head")
+        headImports.push(relative);
+      if (specifier === "next/font/google")
+        result.googleFontImports.push(relative);
+    }
+    if (readsRequestApiSynchronously(text) || readsSyncSegmentProps(file, text)) {
+      result.syncRequestApis.push(relative);
+    }
+  }
+  if (deepImports.length > 0) {
+    result.reports.push({
+      title: "Unsupported next/dist/* deep imports",
+      detail: 'Only five next/dist paths are shimmed \u2014 replace these with public APIs. See https://pnext.dev/docs/compat ("Smaller surfaces").',
+      files: deepImports
+    });
+  }
+  if (streaming.length > 0) {
+    result.reports.push({
+      title: "react-dom/server streaming APIs",
+      detail: "preact/compat does not provide renderToReadableStream/renderToPipeableStream \u2014 use pnext rendering instead. See https://pnext.dev/docs/compat.",
+      files: [...new Set(streaming)]
+    });
+  }
+  if (headImports.length > 0) {
+    result.reports.push({
+      title: "next/head is ignored in the app router",
+      detail: "pnext ignores next/head in app-directory components (matching Next). Move these tags to metadata exports or the root layout <head>. See https://pnext.dev/docs/compat.",
+      files: [...new Set(headImports)]
+    });
+  }
+  scanSpecialPages(root, result);
+  await scanNextConfig(root, result);
+}
+function readsRequestApiSynchronously(text) {
+  const locals = new Set;
+  for (const match of text.matchAll(NEXT_HEADERS_IMPORT)) {
+    for (const binding of match[1].split(",")) {
+      const [imported, local] = binding.trim().split(/\s+as\s+/);
+      if (imported && REQUEST_APIS.has(imported))
+        locals.add(local ?? imported);
+    }
+  }
+  if (locals.size === 0)
+    return false;
+  for (const match of text.matchAll(CALL_THEN_ACCESS)) {
+    if (match[1] || !locals.has(match[2]))
+      continue;
+    if (match[3] && PROMISE_METHODS.has(match[3]))
+      continue;
+    return true;
+  }
+  return false;
+}
+function readsSyncSegmentProps(file, text) {
+  const extension = path2.extname(file);
+  if (!SEGMENT_FILES.has(path2.basename(file, extension)))
+    return false;
+  return readsHeadProps(text, SEGMENT_HEADS, 0) || readsHeadProps(text, ROUTE_HANDLER_HEADS, 1);
+}
+function readsHeadProps(text, heads, index) {
+  for (const head of text.matchAll(heads)) {
+    const list = balanced(text, head.index + head[0].length - 1, "(", ")");
+    const parameter = (splitTopLevel(list)[index] ?? "").trim();
+    if (parameter && readsPropsSynchronously(parameter, text))
+      return true;
+  }
+  return false;
+}
+function readsPropsSynchronously(parameter, text) {
+  const colon = topLevelIndex(parameter, ":");
+  const binding = (colon < 0 ? parameter : parameter.slice(0, colon)).trim();
+  const annotation = colon < 0 ? "" : parameter.slice(colon + 1).trim();
+  const destructured = binding.startsWith("{") ? destructuredKeys(binding) : null;
+  for (const prop of SYNC_PROPS) {
+    if (destructured && !destructured.has(prop))
+      continue;
+    if (annotation) {
+      const declared = propertyType(annotation, text, prop);
+      if (declared && !/^Promise\s*</.test(declared))
+        return true;
+      continue;
+    }
+    if (destructured) {
+      if (!new RegExp(`await\\s+${prop}\\b`).test(text))
+        return true;
+    } else if (/^[\w$]+$/.test(binding)) {
+      const reads = text.matchAll(new RegExp(`(await\\s+)?\\b${binding}\\.${prop}\\b`, "g"));
+      if ([...reads].some((read) => !read[1]))
+        return true;
+    }
+  }
+  return false;
+}
+function propertyType(annotation, text, prop) {
+  let body;
+  if (annotation.startsWith("{")) {
+    body = balanced(annotation, 0, "{", "}");
+  } else {
+    const name = /^[\w$]+/.exec(annotation)?.[0];
+    body = name ? localTypeBody(name, text) : undefined;
+  }
+  if (!body)
+    return;
+  return new RegExp(`(?:^|[{;,\\n])\\s*${prop}\\s*\\??\\s*:\\s*([^;,\\n]+)`).exec(body)?.[1]?.trim();
+}
+function localTypeBody(name, text) {
+  const declaration = new RegExp(`\\b(?:type|interface)\\s+${name}\\b`).exec(text);
+  if (!declaration)
+    return;
+  const open = text.indexOf("{", declaration.index);
+  if (open < 0 || /[;)]/.test(text.slice(declaration.index, open)))
+    return;
+  return balanced(text, open, "{", "}");
+}
+function destructuredKeys(binding) {
+  const keys = new Set;
+  for (const part of splitTopLevel(balanced(binding, 0, "{", "}"))) {
+    const key = /^\s*(?:\.\.\.)?([\w$]+)/.exec(part)?.[1];
+    if (key)
+      keys.add(key);
+  }
+  return keys;
+}
+function balanced(text, from, open, close) {
+  let depth = 0;
+  for (let i = from;i < text.length; i++) {
+    if (text[i] === open)
+      depth++;
+    else if (text[i] === close && --depth === 0)
+      return text.slice(from + 1, i);
+  }
+  return "";
+}
+function splitTopLevel(list) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0;i < list.length; i++) {
+    const char = list[i];
+    if (char === "=" && list[i + 1] === ">")
+      i++;
+    else if ("({[<".includes(char))
+      depth++;
+    else if (")}]>".includes(char))
+      depth--;
+    else if (char === "," && depth === 0) {
+      parts.push(list.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(list.slice(start));
+  return parts;
+}
+function topLevelIndex(text, char) {
+  let depth = 0;
+  for (let i = 0;i < text.length; i++) {
+    const current = text[i];
+    if ("({[<".includes(current))
+      depth++;
+    else if (")}]>".includes(current))
+      depth--;
+    else if (current === char && depth === 0)
+      return i;
+  }
+  return -1;
+}
+function scanSpecialPages(root, result) {
+  const found = [];
+  for (const base of ["pages", path2.join("src", "pages")]) {
+    for (const name of SPECIAL_PAGES) {
+      for (const extension of [".tsx", ".ts", ".jsx", ".js"]) {
+        const relative = path2.join(base, `${name}${extension}`);
+        if (existsSync(path2.join(root, relative)))
+          found.push(relative);
+      }
+    }
+  }
+  if (found.length === 0)
+    return;
+  result.reports.push({
+    title: "pages/_app, _document and _error are ignored",
+    detail: "Move this setup into the app-router root layout \u2014 pnext never loads these files. See https://pnext.dev/docs/compat.",
+    files: found
+  });
+}
+async function scanNextConfig(root, result) {
+  for (const name of ["next.config.ts", "next.config.js", "next.config.mjs", "next.config.cjs"]) {
+    const file = path2.join(root, name);
+    if (!existsSync(file))
+      continue;
+    const text = await readFile2(file, "utf8");
+    if (!text.includes("webpack:") && !text.includes("webpack("))
+      return;
+    const svgr = text.includes("@svgr/webpack");
+    result.reports.push({
+      title: `${name} defines a webpack function`,
+      detail: svgr ? "The webpack function is never executed; SVGR is auto-detected from @svgr/webpack, so SVG imports keep working. See https://pnext.dev/docs/compat." : "The webpack function is never executed \u2014 port any custom loaders/plugins to pnext config. See https://pnext.dev/docs/compat."
+    });
+    return;
+  }
+}
+async function* walk(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name))
+        continue;
+      yield* walk(path2.join(dir, entry.name));
+    } else if (entry.isFile()) {
+      yield path2.join(dir, entry.name);
+    }
+  }
+}
+
+// src/cli/migrate/spinner.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+async function withSpinner(label, run) {
+  if (!process.stdout.isTTY)
+    return run();
+  let frame = 0;
+  const timer = setInterval(() => {
+    process.stdout.write(`\r${FRAMES[frame % FRAMES.length]} ${label}`);
+    frame += 1;
+  }, 80);
+  try {
+    return await run();
+  } finally {
+    clearInterval(timer);
+    process.stdout.write("\r\x1B[2K");
+  }
+}
+
+// src/cli/migrate/tsconfig.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+var MANUAL_STEPS = 'remove { "name": "next" } from compilerOptions.plugins and replace ".next/types" includes with ".pnext/types/**/*.ts".';
+async function migrateTsconfig(root, result, dryRun) {
+  const file = path3.join(root, "tsconfig.json");
+  if (!existsSync2(file))
+    return;
+  const text = await readFile3(file, "utf8");
+  let config;
+  try {
+    config = JSON.parse(text);
+  } catch {
+    result.reports.push({
+      title: "tsconfig.json has comments (JSONC) \u2014 not edited",
+      detail: `Apply by hand: ${MANUAL_STEPS}`
+    });
+    return;
+  }
+  if (typeof config !== "object" || config === null)
+    return;
+  const changes = [];
+  const compilerOptions = config.compilerOptions;
+  if (isObject2(compilerOptions) && Array.isArray(compilerOptions.plugins)) {
+    const kept = compilerOptions.plugins.filter((plugin) => !(isObject2(plugin) && plugin.name === "next"));
+    if (kept.length !== compilerOptions.plugins.length) {
+      if (kept.length === 0)
+        delete compilerOptions.plugins;
+      else
+        compilerOptions.plugins = kept;
+      changes.push("next TypeScript plugin removed");
+    }
+  }
+  if (Array.isArray(config.include)) {
+    const seen = new Set;
+    const include = [];
+    let repointed = false;
+    for (const entry of config.include) {
+      if (typeof entry !== "string") {
+        include.push(entry);
+        continue;
+      }
+      const next = entry.includes(".next/types") || entry.includes(".next/dev/types") ? ".pnext/types/**/*.ts" : entry;
+      if (next !== entry)
+        repointed = true;
+      if (seen.has(next))
+        continue;
+      seen.add(next);
+      include.push(next);
+    }
+    if (repointed) {
+      config.include = include;
+      changes.push("type includes repointed at .pnext/types");
+    }
+  }
+  if (changes.length === 0)
+    return;
+  if (!dryRun)
+    await writeFile2(file, `${JSON.stringify(config, null, 2)}
+`);
+  for (const change of changes) {
+    result.edits.push({ file: "tsconfig.json", description: change });
+  }
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/cli/migrate/run.ts
+var NEXT_CONFIG_FILES = ["next.config.ts", "next.config.js", "next.config.mjs", "next.config.cjs"];
+var PNEXT_CONFIG_FILES = ["pnext.config.ts", "pnext.config.js", "pnext.config.mjs"];
+async function migrateApp(directory, options) {
+  const root = path4.resolve(directory ?? process.cwd());
+  const pkg = await readPackageJson(root);
+  const hasNextDependency = Boolean(pkg && (hasDependency(pkg.dependencies, "next") || hasDependency(pkg.devDependencies, "next")));
+  const hasNextConfig = NEXT_CONFIG_FILES.some((name) => existsSync3(path4.join(root, name)));
+  if (!hasNextDependency && !hasNextConfig) {
+    console.error(`${bold("Not a Next.js app")}: ${root}
+` + `  - ${pkg ? 'package.json has no "next" dependency' : "no readable package.json"}
+` + "  - no next.config.{ts,js,mjs,cjs}");
+    return 1;
+  }
+  printHeader(root, options.dryRun);
+  const result = emptyResult();
+  await withSpinner("Scanning sources ...", () => scanSources(root, result));
+  if (pkg)
+    await migratePackageJson(root, pkg, result, options.dryRun);
+  await createPnextConfig(root, result, options.dryRun);
+  await migrateTsconfig(root, result, options.dryRun);
+  await removeNextEnv(root, result, options.dryRun);
+  await updateGitignore(root, result, options.dryRun);
+  printResult(result, { install: installCommand(root) });
+  return 0;
+}
+async function createPnextConfig(root, result, dryRun) {
+  const legacy = result.syncRequestApis.length > 0;
+  const existing = PNEXT_CONFIG_FILES.find((name) => existsSync3(path4.join(root, name)));
+  if (existing) {
+    result.reports.push({
+      title: `${existing} already exists`,
+      detail: "Make sure it sets compat: { next: true }. See https://pnext.dev/docs/compat."
+    });
+    if (legacy)
+      reportSyncRequestApis(result, existing);
+    return;
+  }
+  if (!dryRun) {
+    await writeFile3(path4.join(root, "pnext.config.ts"), legacy ? `export default {
+` + `  compat: {
+` + "    // Sync cookies()/headers()/params still work; migrate to `await` and drop this.\n" + `    next: { legacyRequestAPIs: true },
+` + `  },
+` + `};
+` : `export default { compat: { next: true } };
+`);
+  }
+  result.edits.push({
+    file: "pnext.config.ts",
+    description: legacy ? "created with compat.next enabled (legacyRequestAPIs)" : "created with compat.next enabled"
+  });
+  if (legacy)
+    reportSyncRequestApis(result);
+}
+function reportSyncRequestApis(result, existingConfig) {
+  result.reports.push({
+    title: "Sync cookies()/headers()/params detected",
+    detail: existingConfig ? `Set compat: { next: { legacyRequestAPIs: true } } in ${existingConfig} to keep these working, then migrate to \`await\` and remove it. See https://pnext.dev/docs/compat` : "Enabled compat.next.legacyRequestAPIs; migrate to `await` and remove it. See https://pnext.dev/docs/compat",
+    files: [...new Set(result.syncRequestApis)]
+  });
+}
+async function removeNextEnv(root, result, dryRun) {
+  const file = path4.join(root, "next-env.d.ts");
+  if (!existsSync3(file))
+    return;
+  if (!dryRun)
+    await rm(file);
+  result.edits.push({ file: "next-env.d.ts", description: "deleted" });
+}
+async function updateGitignore(root, result, dryRun) {
+  const file = path4.join(root, ".gitignore");
+  if (!existsSync3(file))
+    return;
+  const text = await readFile4(file, "utf8");
+  if (text.split(/\r?\n/).some((line) => line.trim() === ".pnext/"))
+    return;
+  if (!dryRun)
+    await appendFile(file, `${text.endsWith(`
+`) || text === "" ? "" : `
+`}.pnext/
+`);
+  result.edits.push({ file: ".gitignore", description: "appended .pnext/" });
+}
+function installCommand(root) {
+  if (existsSync3(path4.join(root, "bun.lock")) || existsSync3(path4.join(root, "bun.lockb"))) {
+    return "bun install";
+  }
+  if (existsSync3(path4.join(root, "pnpm-lock.yaml")))
+    return "pnpm install";
+  if (existsSync3(path4.join(root, "yarn.lock")))
+    return "yarn";
+  return "npm install";
+}
+function hasDependency(bucket, name) {
+  return typeof bucket === "object" && bucket !== null && name in bucket;
+}
+export {
+  migrateApp
+};