@spotpatch/next 0.1.0

package/dist/cli.js

@@ -0,0 +1,1527 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire as createRequire2 } from "module";
+import path4 from "path";
+
+// src/cli-owner.ts
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+import { serializeResolvedSpotPatchOptions } from "@spotpatch/dev-server";
+
+// src/cli-args.ts
+import { isLoopbackHostname } from "@spotpatch/dev-server";
+function parsePort(value) {
+  const port = Number(value);
+  if (!/^\d+$/u.test(value) || !Number.isSafeInteger(port) || port < 1 || port > 65535) {
+    throw new RangeError("SpotPatch Next requires a valid development port.");
+  }
+  return port;
+}
+function parseOptionValue(arguments_, index, longName, shortName) {
+  const argument = arguments_[index];
+  if (argument === longName || argument === shortName) {
+    const value = arguments_[index + 1];
+    if (value === void 0 || value.startsWith("-")) {
+      throw new Error(`SpotPatch Next requires a value after ${argument}.`);
+    }
+    return Object.freeze({ consumed: 1, value });
+  }
+  const longPrefix = `${longName}=`;
+  const shortPrefix = `${shortName}=`;
+  if (argument?.startsWith(longPrefix)) {
+    return Object.freeze({ consumed: 0, value: argument.slice(longPrefix.length) });
+  }
+  if (argument?.startsWith(shortPrefix)) {
+    return Object.freeze({ consumed: 0, value: argument.slice(shortPrefix.length) });
+  }
+  return Object.freeze({ consumed: 0 });
+}
+function parseNextDevArguments(arguments_, environment = process.env, defaultBundler2 = "turbopack") {
+  let hostname;
+  let port;
+  let webpack = false;
+  let turbopack = false;
+  for (let index = 0; index < arguments_.length; index += 1) {
+    const argument = arguments_[index];
+    const hostOption = parseOptionValue(arguments_, index, "--hostname", "-H");
+    if (hostOption.value !== void 0) {
+      if (hostname !== void 0) {
+        throw new Error("SpotPatch Next received duplicate hostname options.");
+      }
+      hostname = hostOption.value;
+      index += hostOption.consumed;
+      continue;
+    }
+    const portOption = parseOptionValue(arguments_, index, "--port", "-p");
+    if (portOption.value !== void 0) {
+      if (port !== void 0) {
+        throw new Error("SpotPatch Next received duplicate port options.");
+      }
+      port = parsePort(portOption.value);
+      index += portOption.consumed;
+      continue;
+    }
+    if (argument === "--webpack") {
+      webpack = true;
+    } else if (argument === "--turbopack" || argument === "--turbo") {
+      turbopack = true;
+    }
+  }
+  const resolvedHostname = hostname ?? "localhost";
+  if (!isLoopbackHostname(resolvedHostname)) {
+    throw new Error(
+      "SpotPatch Next only supports a loopback --hostname in its first release."
+    );
+  }
+  if (webpack && turbopack) {
+    throw new Error("SpotPatch Next cannot enable webpack and Turbopack together.");
+  }
+  const resolvedPort = port ?? (environment.PORT === void 0 ? 3e3 : parsePort(environment.PORT));
+  const hostForUrl = resolvedHostname.includes(":") ? `[${resolvedHostname}]` : resolvedHostname;
+  const nextArguments = [...arguments_];
+  if (hostname === void 0) {
+    nextArguments.push("--hostname", resolvedHostname);
+  }
+  if (port === void 0) {
+    nextArguments.push("--port", String(resolvedPort));
+  }
+  return Object.freeze({
+    bundler: webpack ? "webpack" : turbopack ? "turbopack" : defaultBundler2,
+    hostname: resolvedHostname,
+    nextArguments: Object.freeze(nextArguments),
+    port: resolvedPort,
+    publicOrigin: `http://${hostForUrl}:${String(resolvedPort)}`
+  });
+}
+
+// src/internal/constants.ts
+var NEXT_IPC_PROTOCOL_VERSION = 1;
+var NEXT_IPC_MESSAGE_LIMIT_BYTES = 256 * 1024;
+var NEXT_INTERNAL_REGISTRATION_PATH = "/__spotpatch-internal/register";
+var NEXT_INTERNAL_CONFIGURATION_PATH = "/__spotpatch-internal/configure";
+var NEXT_ENVIRONMENT_KEYS = Object.freeze({
+  appRoot: "SPOTPATCH_NEXT_APP_ROOT",
+  bundler: "SPOTPATCH_NEXT_BUNDLER",
+  configurationSecret: "SPOTPATCH_NEXT_CONFIGURATION_SECRET",
+  internalOrigin: "SPOTPATCH_NEXT_INTERNAL_ORIGIN",
+  internalSecret: "SPOTPATCH_NEXT_INTERNAL_SECRET",
+  launchNonce: "SPOTPATCH_NEXT_LAUNCH_NONCE",
+  registryEpoch: "SPOTPATCH_NEXT_REGISTRY_EPOCH",
+  sidecarOrigin: "SPOTPATCH_NEXT_SIDECAR_ORIGIN"
+});
+var NEXT_SOURCE_RULE_KEYS = Object.freeze(["*.jsx", "*.tsx"]);
+var NEXT_DEFAULT_INCLUDE = Object.freeze([/\.(?:jsx|tsx)$/u]);
+
+// src/internal/ipc.ts
+import path from "path";
+import {
+  parseSerializedSpotPatchOptions
+} from "@spotpatch/dev-server";
+var ID_PATTERN = /^[A-Za-z0-9_-]{16,128}$/u;
+var ENVIRONMENT_NAME_PATTERN = /^[A-Z][A-Z0-9_]{1,127}$/u;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, expectedKeys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...expectedKeys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function assertIpcMessageSize(value) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch (error) {
+    throw new TypeError("The SpotPatch IPC message is not serializable.", {
+      cause: error
+    });
+  }
+  if (Buffer.byteLength(serialized, "utf8") > NEXT_IPC_MESSAGE_LIMIT_BYTES) {
+    throw new RangeError("The SpotPatch IPC message exceeds the size limit.");
+  }
+}
+function parseCredentials(value) {
+  if (!isRecord(value) || Object.keys(value).length > 32) {
+    throw new TypeError("The SpotPatch IPC credentials are invalid.");
+  }
+  const entries = Object.entries(value);
+  const credentials = {};
+  for (const [name, credential] of entries) {
+    if (!ENVIRONMENT_NAME_PATTERN.test(name) || typeof credential !== "string" || credential.length === 0 || credential.length > 16384 || credential.includes("\0")) {
+      throw new TypeError("The SpotPatch IPC credentials are invalid.");
+    }
+    credentials[name] = credential;
+  }
+  return Object.freeze(credentials);
+}
+function parseNextConfigureMessage(value) {
+  assertIpcMessageSize(value);
+  if (!isRecord(value) || !hasExactKeys(value, [
+    "appRoot",
+    "credentials",
+    "nonce",
+    "options",
+    "protocolVersion",
+    "requestId",
+    "type"
+  ]) || value.type !== "spotpatch:next:configure" || value.protocolVersion !== NEXT_IPC_PROTOCOL_VERSION || typeof value.nonce !== "string" || !ID_PATTERN.test(value.nonce) || typeof value.requestId !== "string" || !ID_PATTERN.test(value.requestId) || typeof value.appRoot !== "string" || !path.isAbsolute(value.appRoot) || value.appRoot.length > 4096 || value.appRoot.includes("\0")) {
+    throw new TypeError("The SpotPatch configure IPC message is invalid.");
+  }
+  return Object.freeze({
+    appRoot: value.appRoot,
+    credentials: parseCredentials(value.credentials),
+    nonce: value.nonce,
+    options: parseSerializedSpotPatchOptions(value.options),
+    protocolVersion: NEXT_IPC_PROTOCOL_VERSION,
+    requestId: value.requestId,
+    type: "spotpatch:next:configure"
+  });
+}
+
+// src/project.ts
+import { execFile } from "child_process";
+import { access, readFile, realpath } from "fs/promises";
+import { createRequire } from "module";
+import path2 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var VERSION_PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?$/u;
+async function pathExists(absolutePath) {
+  try {
+    await access(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertSupportedNextVersion(version) {
+  const match = VERSION_PATTERN.exec(version);
+  const major = Number(match?.[1]);
+  const minor = Number(match?.[2]);
+  if (match === null || !Number.isSafeInteger(major) || !Number.isSafeInteger(minor) || major < 15 || major >= 17 || major === 15 && minor < 3) {
+    throw new Error(
+      `SpotPatch Next requires Next.js >=15.3.0 <17.0.0; found ${version}.`
+    );
+  }
+}
+async function detectRouterKind(appRoot) {
+  const [appCandidates, pagesCandidates] = await Promise.all([
+    Promise.all([
+      pathExists(path2.join(appRoot, "app")),
+      pathExists(path2.join(appRoot, "src", "app"))
+    ]),
+    Promise.all([
+      pathExists(path2.join(appRoot, "pages")),
+      pathExists(path2.join(appRoot, "src", "pages"))
+    ])
+  ]);
+  const hasApp = appCandidates.some(Boolean);
+  const hasPages = pagesCandidates.some(Boolean);
+  if (hasApp && hasPages) {
+    return "hybrid";
+  }
+  if (hasApp) {
+    return "app";
+  }
+  if (hasPages) {
+    return "pages";
+  }
+  throw new Error("SpotPatch could not find an App or Pages Router directory.");
+}
+async function findProjectRoot(appRoot) {
+  try {
+    const result = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: appRoot,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    const candidate = await realpath(result.stdout.trim());
+    const relative = path2.relative(candidate, appRoot);
+    if (relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative)) {
+      return candidate;
+    }
+  } catch {
+  }
+  return appRoot;
+}
+async function inspectNextProject(directory = process.cwd()) {
+  const appRoot = await realpath(directory);
+  const resolveFromApplication = createRequire(path2.join(appRoot, "package.json"));
+  let nextEntry;
+  let manifestPath;
+  try {
+    nextEntry = resolveFromApplication.resolve("next/dist/bin/next");
+    manifestPath = resolveFromApplication.resolve("next/package.json");
+  } catch (error) {
+    throw new Error("SpotPatch could not resolve the application's local Next.js.", {
+      cause: error
+    });
+  }
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  if (typeof manifest !== "object" || manifest === null || !("version" in manifest) || typeof manifest.version !== "string") {
+    throw new Error("SpotPatch could not read the local Next.js version.");
+  }
+  assertSupportedNextVersion(manifest.version);
+  const [projectRoot, routerKind] = await Promise.all([
+    findProjectRoot(appRoot),
+    detectRouterKind(appRoot)
+  ]);
+  return Object.freeze({
+    appRoot,
+    nextEntry,
+    nextVersion: manifest.version,
+    projectRoot,
+    routerKind
+  });
+}
+
+// src/sidecar.ts
+import {
+  createServer
+} from "http";
+import {
+  createAgentJobManager,
+  createRuntimeAiConfig,
+  createSession,
+  createSourceRegistrationService,
+  createSourceRegistry,
+  createSpotPatchMiddleware
+} from "@spotpatch/dev-server";
+import {
+  SPOTPATCH_API_BASE,
+  SPOTPATCH_ENDPOINTS,
+  runtimeConfigSchema
+} from "@spotpatch/shared";
+
+// package.json
+var package_default = {
+  name: "@spotpatch/next",
+  version: "0.1.0",
+  description: "Development-only Next.js adapter and CLI for SpotPatch.",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/huanglvjing/spotpatch.git",
+    directory: "packages/next"
+  },
+  homepage: "https://github.com/huanglvjing/spotpatch#readme",
+  bugs: {
+    url: "https://github.com/huanglvjing/spotpatch/issues"
+  },
+  keywords: [
+    "spotpatch",
+    "nextjs",
+    "react",
+    "developer-tools"
+  ],
+  type: "module",
+  sideEffects: [
+    "./dist/client.cjs",
+    "./dist/client.js"
+  ],
+  engines: {
+    node: ">=20.19.0"
+  },
+  files: [
+    "dist",
+    "loader.cjs",
+    "loader.d.cts"
+  ],
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    "spotpatch-next": "./dist/cli.js"
+  },
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    },
+    "./client": {
+      import: {
+        types: "./dist/client.d.ts",
+        default: "./dist/client.js"
+      },
+      require: {
+        types: "./dist/client.d.cts",
+        default: "./dist/client.cjs"
+      }
+    },
+    "./loader": {
+      types: "./loader.d.cts",
+      default: "./loader.cjs"
+    },
+    "./noop": {
+      import: {
+        types: "./dist/noop.d.ts",
+        default: "./dist/noop.js"
+      },
+      require: {
+        types: "./dist/noop.d.cts",
+        default: "./dist/noop.cjs"
+      }
+    }
+  },
+  typesVersions: {
+    "*": {
+      client: [
+        "dist/client.d.ts"
+      ],
+      loader: [
+        "loader.d.cts"
+      ],
+      noop: [
+        "dist/noop.d.ts"
+      ]
+    }
+  },
+  scripts: {
+    build: "tsup src/index.ts --format esm,cjs --dts --sourcemap --clean && tsup --config tsup.cli.config.ts && tsup --config tsup.loader.config.ts && tsup --config tsup.client.config.ts && pnpm verify:loader",
+    clean: `node --input-type=module -e "import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })"`,
+    typecheck: "tsc --noEmit -p tsconfig.json",
+    "verify:loader": "node scripts/verify-loader.cjs"
+  },
+  dependencies: {
+    "@spotpatch/compiler": "workspace:^",
+    "@spotpatch/dev-server": "workspace:^",
+    "@spotpatch/runtime": "workspace:^",
+    "@spotpatch/shared": "workspace:^",
+    bippy: "0.6.1",
+    "magic-string": "1.1.0",
+    "oxc-parser": "0.143.0"
+  },
+  peerDependencies: {
+    next: ">=15.3.0 <17.0.0",
+    react: "^18.2.0 || ^19.0.0",
+    "react-dom": "^18.2.0 || ^19.0.0"
+  },
+  devDependencies: {
+    next: "16.3.0",
+    react: "19.2.8",
+    "react-dom": "19.2.8"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  }
+};
+
+// src/internal/configuration-server.ts
+import { timingSafeEqual } from "crypto";
+import { isLoopbackHostname as isLoopbackHostname2, readJsonRequestBody } from "@spotpatch/dev-server";
+var CONFIGURATION_SECRET_HEADER = "x-spotpatch-configuration";
+var CONFIGURATION_SECRET_PATTERN = /^[A-Za-z0-9_-]{32,128}$/u;
+function getSingleHeader(request, name) {
+  const value = request.headers[name.toLowerCase()];
+  return Array.isArray(value) ? value[0] : value;
+}
+function secretsMatch(actual, expected) {
+  if (actual === void 0) {
+    return false;
+  }
+  const actualBytes = Buffer.from(actual);
+  const expectedBytes = Buffer.from(expected);
+  return actualBytes.byteLength === expectedBytes.byteLength && timingSafeEqual(actualBytes, expectedBytes);
+}
+function hasLoopbackHost(request) {
+  const host = getSingleHeader(request, "host");
+  if (host === void 0) {
+    return false;
+  }
+  try {
+    return isLoopbackHostname2(new URL(`http://${host}`).hostname);
+  } catch {
+    return false;
+  }
+}
+function writeJson(response, statusCode, payload) {
+  const body = JSON.stringify(payload);
+  response.statusCode = statusCode;
+  response.setHeader("Cache-Control", "no-store");
+  response.setHeader("Content-Type", "application/json; charset=utf-8");
+  response.setHeader("Content-Length", Buffer.byteLength(body));
+  response.end(body);
+}
+function createConfigurationRequestHandler(options) {
+  if (!CONFIGURATION_SECRET_PATTERN.test(options.configurationSecret)) {
+    throw new TypeError("The SpotPatch configuration secret is invalid.");
+  }
+  return (request, response) => {
+    const handle = async () => {
+      const contentType = getSingleHeader(request, "content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+      if (request.method !== "POST" || contentType !== "application/json" || !hasLoopbackHost(request) || getSingleHeader(request, "origin") !== void 0 || !secretsMatch(
+        getSingleHeader(request, CONFIGURATION_SECRET_HEADER),
+        options.configurationSecret
+      )) {
+        writeJson(response, 403, { ok: false });
+        return;
+      }
+      const value = await readJsonRequestBody(request, NEXT_IPC_MESSAGE_LIMIT_BYTES);
+      const acknowledgement = await options.onConfiguration(value);
+      if (acknowledgement === void 0) {
+        writeJson(response, 400, { ok: false });
+        return;
+      }
+      assertIpcMessageSize(acknowledgement);
+      writeJson(response, 200, acknowledgement);
+    };
+    void handle().catch(() => {
+      if (response.headersSent) {
+        response.destroy();
+        return;
+      }
+      writeJson(response, 400, { ok: false });
+    });
+  };
+}
+
+// src/sidecar.ts
+var SIDECAR_SELF_CHECK_LIMIT_BYTES = 16384;
+var SIDECAR_SELF_CHECK_TIMEOUT_MS = 3e3;
+function requestPath(url) {
+  try {
+    return new URL(url ?? "/", "http://spotpatch.invalid").pathname;
+  } catch {
+    return "";
+  }
+}
+function writeUnavailable(response, statusCode) {
+  const body = JSON.stringify({ ok: false });
+  response.statusCode = statusCode;
+  response.setHeader("Cache-Control", "no-store");
+  response.setHeader("Content-Type", "application/json; charset=utf-8");
+  response.setHeader("Content-Length", Buffer.byteLength(body));
+  response.end(body);
+}
+function validateCredentialEnvironment(options, credentials) {
+  const expected = options.ai === false ? [] : [
+    ...new Set(
+      Object.values(options.ai.providers).map((provider) => provider.apiKeyEnv)
+    )
+  ].sort();
+  const actual = Object.keys(credentials).sort();
+  if (actual.length !== expected.length || actual.some((name, index) => name !== expected[index])) {
+    throw new TypeError("The SpotPatch credential environment is inconsistent.");
+  }
+}
+async function selfCheckSidecar(sidecarOrigin, publicOrigin, expectedConfig) {
+  const response = await fetch(new URL(SPOTPATCH_ENDPOINTS.bootstrap, sidecarOrigin), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Origin: publicOrigin,
+      "Sec-Fetch-Site": "same-origin"
+    },
+    body: "{}",
+    signal: AbortSignal.timeout(SIDECAR_SELF_CHECK_TIMEOUT_MS)
+  });
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > SIDECAR_SELF_CHECK_LIMIT_BYTES) {
+    await response.body?.cancel();
+    throw new Error("SpotPatch Sidecar self-check failed.");
+  }
+  const text = await response.text();
+  if (!response.ok || !response.headers.get("cache-control")?.toLowerCase().includes("no-store") || Buffer.byteLength(text, "utf8") > SIDECAR_SELF_CHECK_LIMIT_BYTES) {
+    throw new Error("SpotPatch Sidecar self-check failed.");
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    throw new Error("SpotPatch Sidecar self-check failed.", { cause: error });
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value) || Object.keys(value).length !== 2 || !("ok" in value) || value.ok !== true || !("data" in value)) {
+    throw new Error("SpotPatch Sidecar self-check failed.");
+  }
+  const parsed = runtimeConfigSchema.safeParse(value.data);
+  const parsedExpected = runtimeConfigSchema.safeParse(expectedConfig);
+  if (!parsed.success || !parsedExpected.success || JSON.stringify(parsed.data) !== JSON.stringify(parsedExpected.data)) {
+    throw new Error("SpotPatch Sidecar self-check failed.");
+  }
+}
+function closeServer(server) {
+  return new Promise((resolve, reject) => {
+    server.close((error) => {
+      if (error === void 0 || "code" in error && error.code === "ERR_SERVER_NOT_RUNNING") {
+        resolve();
+        return;
+      }
+      reject(error);
+    });
+  });
+}
+async function createNextSidecar(sidecarOptions) {
+  let active = false;
+  let closed = false;
+  let registry;
+  let agentManager;
+  let handler = (_request, response) => {
+    writeUnavailable(response, 503);
+  };
+  const configurationHandler = createConfigurationRequestHandler(
+    sidecarOptions.configuration
+  );
+  const server = createServer((request, response) => {
+    try {
+      if (requestPath(request.url) === NEXT_INTERNAL_CONFIGURATION_PATH) {
+        configurationHandler(request, response);
+        return;
+      }
+      handler(request, response);
+    } catch {
+      writeUnavailable(response, 500);
+    }
+  });
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      reject(error);
+    };
+    server.once("error", onError);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", onError);
+      resolve();
+    });
+  });
+  server.on("error", () => {
+    if (!closed) {
+      sidecarOptions.onFatalError?.();
+    }
+  });
+  const address = server.address();
+  if (address === null || typeof address === "string") {
+    await closeServer(server);
+    throw new Error("SpotPatch Sidecar did not bind a loopback address.");
+  }
+  const sidecarOrigin = `http://127.0.0.1:${String(address.port)}`;
+  return Object.freeze({
+    origin: sidecarOrigin,
+    async activate(input) {
+      if (closed || active) {
+        throw new Error("SpotPatch Sidecar activation is not available.");
+      }
+      validateCredentialEnvironment(input.options, input.credentials);
+      if (!input.options.enabled) {
+        handler = (_request, response) => {
+          writeUnavailable(response, 404);
+        };
+        active = true;
+        return;
+      }
+      const sourceRegistry = createSourceRegistry();
+      const session = createSession();
+      const runtimeConfig = Object.freeze({
+        apiBase: SPOTPATCH_API_BASE,
+        ai: createRuntimeAiConfig(input.options.ai),
+        budget: input.options.budget,
+        bundler: input.bundler,
+        debug: input.options.debug,
+        editor: input.options.editor,
+        framework: "next",
+        frameworkVersion: input.nextVersion,
+        locale: input.options.locale,
+        maxTargets: input.options.maxTargets,
+        redact: input.options.redact,
+        routerKind: input.routerKind,
+        sessionToken: session.token,
+        shortcut: input.options.shortcut,
+        spotPatchVersion: package_default.version
+      });
+      const manager = input.options.ai === false ? void 0 : createAgentJobManager({
+        ai: input.options.ai,
+        environment: input.credentials,
+        root: input.projectRoot
+      });
+      const middleware = createSpotPatchMiddleware({
+        ...manager === void 0 ? {} : { agentManager: manager },
+        bootstrap: {
+          expectedOrigin: input.publicOrigin,
+          runtimeConfig
+        },
+        logger: {
+          warn(message) {
+            process.stderr.write(`${message}
+`);
+          }
+        },
+        options: input.options,
+        registry: sourceRegistry,
+        root: input.appRoot,
+        session
+      });
+      const registration = await createSourceRegistrationService({
+        internalSecret: input.internalSecret,
+        options: input.options,
+        registry: sourceRegistry,
+        registryEpoch: input.registryEpoch,
+        root: input.appRoot
+      });
+      registry = sourceRegistry;
+      agentManager = manager;
+      handler = (request, response) => {
+        if (requestPath(request.url) === NEXT_INTERNAL_REGISTRATION_PATH) {
+          registration.handler(request, response);
+          return;
+        }
+        middleware(request, response, () => {
+          writeUnavailable(response, 404);
+        });
+      };
+      await selfCheckSidecar(sidecarOrigin, input.publicOrigin, runtimeConfig);
+      active = true;
+    },
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      handler = (_request, response) => {
+        writeUnavailable(response, 503);
+      };
+      registry?.clear();
+      await agentManager?.close();
+      server.closeIdleConnections();
+      const closing = closeServer(server);
+      server.closeAllConnections();
+      await closing;
+    }
+  });
+}
+
+// src/cli-owner.ts
+var CONFIGURATION_STARTUP_TIMEOUT_MS = 6e4;
+var FORCED_TERMINATION_TIMEOUT_MS = 5e3;
+var MAX_CONFIGURATION_REQUESTS = 32;
+var ID_PATTERN2 = /^[A-Za-z0-9_-]{16,128}$/u;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function defaultBundler(nextVersion) {
+  return Number(nextVersion.split(".", 1)[0]) >= 16 ? "turbopack" : "webpack";
+}
+function signalExitCode(signal) {
+  return signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1;
+}
+function sortedRecord(value) {
+  return Object.freeze(
+    Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
+    )
+  );
+}
+function configurationSignature(message) {
+  return JSON.stringify({
+    appRoot: message.appRoot,
+    credentials: sortedRecord(message.credentials),
+    options: serializeResolvedSpotPatchOptions(message.options)
+  });
+}
+function readCorrelation(value, nonce) {
+  if (!isRecord2(value) || typeof value.nonce !== "string" || value.nonce !== nonce || !ID_PATTERN2.test(value.nonce) || typeof value.requestId !== "string" || !ID_PATTERN2.test(value.requestId)) {
+    return void 0;
+  }
+  return Object.freeze({ nonce, requestId: value.requestId });
+}
+function createAck(correlation, result) {
+  return Object.freeze({
+    ...result,
+    nonce: correlation.nonce,
+    protocolVersion: NEXT_IPC_PROTOCOL_VERSION,
+    requestId: correlation.requestId,
+    type: "spotpatch:next:configure-ack"
+  });
+}
+function waitForChild(child) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(Object.freeze(result));
+    };
+    child.once("error", () => {
+      finish({ code: null, error: true, signal: null });
+    });
+    child.once("exit", (code, signal) => {
+      finish({ code, error: false, signal });
+    });
+  });
+}
+async function closeSidecar(sidecar) {
+  let timer;
+  try {
+    await Promise.race([
+      sidecar.close(),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+          reject(new Error("SpotPatch Sidecar shutdown timed out."));
+        }, FORCED_TERMINATION_TIMEOUT_MS);
+        timer.unref();
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  }
+}
+async function runNextDevelopment(arguments_) {
+  const project = await inspectNextProject();
+  const dev = parseNextDevArguments(
+    arguments_,
+    process.env,
+    defaultBundler(project.nextVersion)
+  );
+  const launchNonce = randomBytes(24).toString("base64url");
+  const configurationSecret = randomBytes(32).toString("base64url");
+  const internalSecret = randomBytes(32).toString("base64url");
+  const registryEpoch = randomBytes(24).toString("base64url");
+  const lifecycle = {
+    sidecarFailed: false
+  };
+  const seenRequestIds = /* @__PURE__ */ new Set();
+  let acceptedSignature;
+  let activationFailed = false;
+  let configured = false;
+  let failureCode;
+  let configurationQueue = Promise.resolve();
+  const handleConfiguration = async (value) => {
+    const correlation = readCorrelation(value, launchNonce);
+    let message;
+    try {
+      message = parseNextConfigureMessage(value);
+    } catch {
+      failureCode = "INVALID_IPC";
+      if (correlation !== void 0) {
+        lifecycle.child?.kill("SIGTERM");
+        return createAck(correlation, { code: "INVALID_IPC", ok: false });
+      }
+      lifecycle.child?.kill("SIGTERM");
+      return void 0;
+    }
+    if (message.nonce !== launchNonce || message.appRoot !== project.appRoot || message.options.allowLan || seenRequestIds.has(message.requestId) || seenRequestIds.size >= MAX_CONFIGURATION_REQUESTS) {
+      failureCode = "INVALID_IPC";
+      lifecycle.child?.kill("SIGTERM");
+      return createAck(message, { code: "INVALID_IPC", ok: false });
+    }
+    seenRequestIds.add(message.requestId);
+    const signature = configurationSignature(message);
+    if (acceptedSignature !== void 0 && acceptedSignature !== signature) {
+      failureCode = "CONFIGURATION_CONFLICT";
+      return createAck(message, {
+        code: "CONFIGURATION_CONFLICT",
+        ok: false
+      });
+    }
+    if (activationFailed) {
+      return createAck(message, { code: "CONFIGURATION_FAILED", ok: false });
+    }
+    if (acceptedSignature === void 0) {
+      acceptedSignature = signature;
+      const sidecar2 = lifecycle.sidecar;
+      if (sidecar2 === void 0) {
+        activationFailed = true;
+        failureCode = "CONFIGURATION_FAILED";
+        return createAck(message, { code: "CONFIGURATION_FAILED", ok: false });
+      }
+      try {
+        await sidecar2.activate({
+          appRoot: project.appRoot,
+          bundler: dev.bundler,
+          credentials: message.credentials,
+          internalSecret,
+          nextVersion: project.nextVersion,
+          options: message.options,
+          projectRoot: project.projectRoot,
+          publicOrigin: dev.publicOrigin,
+          registryEpoch,
+          routerKind: project.routerKind
+        });
+      } catch {
+        activationFailed = true;
+        failureCode = "CONFIGURATION_FAILED";
+        return createAck(message, { code: "CONFIGURATION_FAILED", ok: false });
+      }
+    }
+    if (!configured) {
+      configured = true;
+      clearTimeout(startupTimer);
+      process.stdout.write(
+        `[spotpatch:next] ready for Next.js ${project.nextVersion} (${dev.bundler}) at ${dev.publicOrigin}
+`
+      );
+    }
+    return createAck(message, { ok: true });
+  };
+  const enqueueConfiguration = (value) => {
+    const result2 = configurationQueue.then(() => handleConfiguration(value));
+    configurationQueue = result2.then(
+      () => void 0,
+      () => void 0
+    );
+    return result2.catch(() => {
+      failureCode = "CONFIGURATION_FAILURE";
+      lifecycle.child?.kill("SIGTERM");
+      return void 0;
+    });
+  };
+  const sidecar = await createNextSidecar({
+    configuration: {
+      configurationSecret,
+      onConfiguration: enqueueConfiguration
+    },
+    onFatalError() {
+      lifecycle.sidecarFailed = true;
+      lifecycle.child?.kill("SIGTERM");
+    }
+  });
+  lifecycle.sidecar = sidecar;
+  const childEnvironment = {
+    ...process.env,
+    [NEXT_ENVIRONMENT_KEYS.appRoot]: project.appRoot,
+    [NEXT_ENVIRONMENT_KEYS.bundler]: dev.bundler,
+    [NEXT_ENVIRONMENT_KEYS.configurationSecret]: configurationSecret,
+    [NEXT_ENVIRONMENT_KEYS.internalOrigin]: sidecar.origin,
+    [NEXT_ENVIRONMENT_KEYS.internalSecret]: internalSecret,
+    [NEXT_ENVIRONMENT_KEYS.launchNonce]: launchNonce,
+    [NEXT_ENVIRONMENT_KEYS.registryEpoch]: registryEpoch,
+    [NEXT_ENVIRONMENT_KEYS.sidecarOrigin]: sidecar.origin
+  };
+  const child = spawn(
+    process.execPath,
+    [project.nextEntry, "dev", ...dev.nextArguments],
+    {
+      cwd: project.appRoot,
+      env: childEnvironment,
+      shell: false,
+      stdio: "inherit",
+      windowsHide: true
+    }
+  );
+  lifecycle.child = child;
+  const startupTimer = setTimeout(() => {
+    failureCode = "CONFIGURATION_TIMEOUT";
+    child.kill("SIGTERM");
+  }, CONFIGURATION_STARTUP_TIMEOUT_MS);
+  startupTimer.unref();
+  let requestedSignal;
+  let forceTimer;
+  const forwardSignal = (signal) => {
+    if (requestedSignal !== void 0) {
+      return;
+    }
+    requestedSignal = signal;
+    child.kill(signal);
+    forceTimer = setTimeout(() => {
+      child.kill("SIGKILL");
+    }, FORCED_TERMINATION_TIMEOUT_MS);
+    forceTimer.unref();
+  };
+  const onSigint = () => {
+    forwardSignal("SIGINT");
+  };
+  const onSigterm = () => {
+    forwardSignal("SIGTERM");
+  };
+  process.once("SIGINT", onSigint);
+  process.once("SIGTERM", onSigterm);
+  const result = await waitForChild(child);
+  clearTimeout(startupTimer);
+  process.off("SIGINT", onSigint);
+  process.off("SIGTERM", onSigterm);
+  if (forceTimer !== void 0) {
+    clearTimeout(forceTimer);
+  }
+  await configurationQueue;
+  try {
+    await closeSidecar(sidecar);
+  } catch {
+    failureCode ??= "SHUTDOWN_FAILED";
+  }
+  if (failureCode !== void 0) {
+    process.stderr.write(`[spotpatch:next] stopped (${failureCode}).
+`);
+    return 1;
+  }
+  if (lifecycle.sidecarFailed || result.error) {
+    process.stderr.write("[spotpatch:next] stopped (PROCESS_FAILURE).\n");
+    return 1;
+  }
+  if (result.signal !== null || requestedSignal !== void 0) {
+    return signalExitCode(result.signal ?? requestedSignal ?? null);
+  }
+  return result.code ?? 1;
+}
+
+// src/initializer.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import {
+  access as access2,
+  lstat,
+  mkdir,
+  readFile as readFile2,
+  rename,
+  stat,
+  unlink,
+  writeFile
+} from "fs/promises";
+import path3 from "path";
+import { MagicString } from "magic-string";
+import {
+  parseSync,
+  Visitor
+} from "oxc-parser";
+var ADAPTER_PACKAGE_NAME = "@spotpatch/next";
+var CLIENT_MODULE_ID = "@spotpatch/next/client";
+var CONFIG_FILE_NAMES = Object.freeze([
+  "next.config.ts",
+  "next.config.mts",
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.cts",
+  "next.config.cjs"
+]);
+var INSTRUMENTATION_EXTENSIONS = Object.freeze([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mts",
+  ".mjs",
+  ".cts",
+  ".cjs"
+]);
+var SIMPLE_SCRIPT_ARGUMENT_PATTERN = /^[A-Za-z0-9._:/=@%+,-]+$/u;
+function isParserErrorSeverity(value) {
+  return value === "Error";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function pathExists2(absolutePath) {
+  try {
+    await access2(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readRegularFile(absolutePath) {
+  const metadata = await lstat(absolutePath);
+  if (!metadata.isFile() || metadata.isSymbolicLink()) {
+    throw new Error(
+      `SpotPatch refuses to modify the non-regular file ${path3.basename(absolutePath)}.`
+    );
+  }
+  return readFile2(absolutePath, "utf8");
+}
+function parseModule(absolutePath, source) {
+  const result = parseSync(absolutePath, source, {
+    sourceType: "module",
+    showSemanticErrors: true
+  });
+  const error = result.errors.find((entry) => isParserErrorSeverity(entry.severity));
+  if (error !== void 0) {
+    throw new SyntaxError(
+      `SpotPatch could not safely parse ${path3.basename(absolutePath)} (${error.message}).`
+    );
+  }
+  return Object.freeze({ program: result.program, source });
+}
+function importsOf(program) {
+  return program.body.filter(
+    (statement) => statement.type === "ImportDeclaration"
+  );
+}
+function importInsertionOffset(program) {
+  const imports = importsOf(program);
+  const lastImport = imports.at(-1);
+  if (lastImport !== void 0) {
+    return lastImport.end;
+  }
+  const directives = program.body.filter(
+    (statement) => statement.type === "ExpressionStatement" && "directive" in statement && typeof statement.directive === "string"
+  );
+  return directives.at(-1)?.end ?? program.hashbang?.end ?? 0;
+}
+function insertStaticImport(magicString, program, statement) {
+  const offset = importInsertionOffset(program);
+  if (offset === 0) {
+    magicString.prepend(`${statement}
+
+`);
+    return;
+  }
+  magicString.appendRight(offset, `
+${statement}`);
+}
+function findDefaultExport(program) {
+  const exports = program.body.filter(
+    (statement) => statement.type === "ExportDefaultDeclaration"
+  );
+  if (exports.length !== 1) {
+    throw new Error(
+      "SpotPatch init requires exactly one ESM default export in next.config."
+    );
+  }
+  const defaultExport = exports[0];
+  if (defaultExport === void 0) {
+    throw new Error("SpotPatch init could not read the next.config default export.");
+  }
+  return defaultExport;
+}
+function importedWrapperName(program) {
+  const adapterImports = importsOf(program).filter(
+    (statement) => statement.source.value === ADAPTER_PACKAGE_NAME
+  );
+  if (adapterImports.length > 1) {
+    throw new Error(
+      "SpotPatch init found multiple @spotpatch/next imports in next.config."
+    );
+  }
+  const adapterImport = adapterImports[0];
+  if (adapterImport === void 0) {
+    return void 0;
+  }
+  const wrapper = adapterImport.specifiers.find(
+    (specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "withSpotPatch" && specifier.importKind !== "type"
+  );
+  if (wrapper === void 0) {
+    throw new Error(
+      "SpotPatch init cannot safely merge the existing @spotpatch/next import."
+    );
+  }
+  return wrapper.local.name;
+}
+function collectIdentifierNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  new Visitor({
+    Identifier(node) {
+      names.add(node.name);
+    }
+  }).visit(program);
+  return names;
+}
+function chooseWrapperName(program) {
+  const names = collectIdentifierNames(program);
+  let suffix = 0;
+  let candidate = "withSpotPatch";
+  while (names.has(candidate)) {
+    suffix += 1;
+    candidate = `withSpotPatch${String(suffix)}`;
+  }
+  return candidate;
+}
+function unwrapParentheses(expression) {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+function isWrappedDefaultExport(declaration, wrapperName) {
+  if (declaration.type !== "CallExpression" || declaration.arguments.length !== 1) {
+    return false;
+  }
+  const factoryCall = unwrapParentheses(declaration.callee);
+  if (factoryCall.type !== "CallExpression") {
+    return false;
+  }
+  const callee = unwrapParentheses(factoryCall.callee);
+  return callee.type === "Identifier" && callee.name === wrapperName;
+}
+function transformNextConfig(absolutePath, source) {
+  if (absolutePath.endsWith(".cjs") || absolutePath.endsWith(".cts")) {
+    throw new Error(
+      "SpotPatch init does not rewrite CommonJS next.config files; add withSpotPatch manually."
+    );
+  }
+  const { program } = parseModule(absolutePath, source);
+  const defaultExport = findDefaultExport(program);
+  const existingWrapperName = importedWrapperName(program);
+  if (existingWrapperName !== void 0 && isWrappedDefaultExport(defaultExport.declaration, existingWrapperName)) {
+    return source;
+  }
+  if (defaultExport.declaration.type === "FunctionDeclaration" || defaultExport.declaration.type === "TSDeclareFunction" || defaultExport.declaration.type === "ClassDeclaration" || defaultExport.declaration.type === "TSInterfaceDeclaration") {
+    throw new Error(
+      "SpotPatch init cannot safely wrap this next.config default declaration; use an exported config expression."
+    );
+  }
+  const magicString = new MagicString(source);
+  const wrapperName = existingWrapperName ?? chooseWrapperName(program);
+  if (existingWrapperName === void 0) {
+    const specifier = wrapperName === "withSpotPatch" ? "withSpotPatch" : `withSpotPatch as ${wrapperName}`;
+    insertStaticImport(
+      magicString,
+      program,
+      `import { ${specifier} } from ${JSON.stringify(ADAPTER_PACKAGE_NAME)};`
+    );
+  }
+  const expression = source.slice(
+    defaultExport.declaration.start,
+    defaultExport.declaration.end
+  );
+  magicString.overwrite(
+    defaultExport.declaration.start,
+    defaultExport.declaration.end,
+    `${wrapperName}()(${expression})`
+  );
+  return magicString.toString();
+}
+function transformInstrumentationClient(absolutePath, source) {
+  const { program } = parseModule(absolutePath, source);
+  const clientImports = importsOf(program).filter(
+    (statement) => statement.source.value === CLIENT_MODULE_ID && statement.importKind !== "type" && (statement.specifiers.length === 0 || statement.specifiers.some(
+      (specifier) => specifier.type !== "ImportSpecifier" || specifier.importKind !== "type"
+    ))
+  );
+  if (clientImports.length > 1) {
+    throw new Error("SpotPatch init found duplicate @spotpatch/next/client imports.");
+  }
+  if (clientImports.length === 1) {
+    return source;
+  }
+  const magicString = new MagicString(source);
+  insertStaticImport(
+    magicString,
+    program,
+    `import ${JSON.stringify(CLIENT_MODULE_ID)};`
+  );
+  return magicString.toString();
+}
+function parsePackageManifest(source) {
+  let value;
+  try {
+    value = JSON.parse(source);
+  } catch (error) {
+    throw new SyntaxError("SpotPatch could not parse package.json.", {
+      cause: error
+    });
+  }
+  if (!isRecord3(value)) {
+    throw new TypeError("SpotPatch requires package.json to contain an object.");
+  }
+  return value;
+}
+function hasAdapterDependency(manifest) {
+  return [
+    manifest.dependencies,
+    manifest.devDependencies,
+    manifest.optionalDependencies
+  ].some(
+    (dependencies) => isRecord3(dependencies) && typeof dependencies[ADAPTER_PACKAGE_NAME] === "string"
+  );
+}
+function transformDevScript(script) {
+  const tokens = script.trim().split(/\s+/u);
+  if (tokens[0] === "spotpatch-next" && tokens[1] === "dev") {
+    if (tokens.every((token) => SIMPLE_SCRIPT_ARGUMENT_PATTERN.test(token))) {
+      return script;
+    }
+    throw new Error("SpotPatch init cannot verify the existing dev script safely.");
+  }
+  if (tokens[0] !== "next" || tokens[1] !== "dev" || !tokens.every((token) => SIMPLE_SCRIPT_ARGUMENT_PATTERN.test(token))) {
+    throw new Error("SpotPatch init only rewrites a simple `next dev` package script.");
+  }
+  return ["spotpatch-next", ...tokens.slice(1)].join(" ");
+}
+function detectIndent(source) {
+  return /^([\t ]+)"/mu.exec(source)?.[1] ?? "  ";
+}
+function transformPackageJson(source) {
+  const manifest = parsePackageManifest(source);
+  if (!hasAdapterDependency(manifest)) {
+    throw new Error(
+      "SpotPatch init requires @spotpatch/next in package dependencies first."
+    );
+  }
+  if (!isRecord3(manifest.scripts) || typeof manifest.scripts.dev !== "string") {
+    throw new Error("SpotPatch init requires a string package script named dev.");
+  }
+  const dev = transformDevScript(manifest.scripts.dev);
+  if (dev === manifest.scripts.dev) {
+    return source;
+  }
+  const nextManifest = {
+    ...manifest,
+    scripts: { ...manifest.scripts, dev }
+  };
+  const lineEnding = source.includes("\r\n") ? "\r\n" : "\n";
+  const serialized = JSON.stringify(nextManifest, void 0, detectIndent(source));
+  return `${serialized.replaceAll("\n", lineEnding)}${lineEnding}`;
+}
+async function findNextConfig(appRoot) {
+  const candidates = (await Promise.all(
+    CONFIG_FILE_NAMES.map(async (name) => {
+      const absolutePath = path3.join(appRoot, name);
+      return await pathExists2(absolutePath) ? absolutePath : void 0;
+    })
+  )).filter((value) => value !== void 0);
+  if (candidates.length !== 1) {
+    throw new Error("SpotPatch init requires exactly one supported next.config file.");
+  }
+  const configPath = candidates[0];
+  if (configPath === void 0) {
+    throw new Error("SpotPatch init could not read the next.config path.");
+  }
+  return configPath;
+}
+async function resolveInstrumentationPath(appRoot, configPath) {
+  const rootRouters = await Promise.all([
+    pathExists2(path3.join(appRoot, "app")),
+    pathExists2(path3.join(appRoot, "pages"))
+  ]);
+  const sourceRouters = await Promise.all([
+    pathExists2(path3.join(appRoot, "src", "app")),
+    pathExists2(path3.join(appRoot, "src", "pages"))
+  ]);
+  const hasRootRouter = rootRouters.some(Boolean);
+  const hasSourceRouter = sourceRouters.some(Boolean);
+  if (hasRootRouter && hasSourceRouter) {
+    throw new Error(
+      "SpotPatch init cannot choose an instrumentation location for mixed root/src routers."
+    );
+  }
+  if (!hasRootRouter && !hasSourceRouter) {
+    throw new Error("SpotPatch init could not find an App or Pages Router.");
+  }
+  const directory = hasSourceRouter ? path3.join(appRoot, "src") : appRoot;
+  const existing = (await Promise.all(
+    INSTRUMENTATION_EXTENSIONS.map(async (extension) => {
+      const absolutePath = path3.join(directory, `instrumentation-client${extension}`);
+      return await pathExists2(absolutePath) ? absolutePath : void 0;
+    })
+  )).filter((value) => value !== void 0);
+  if (existing.length > 1) {
+    throw new Error(
+      "SpotPatch init found multiple instrumentation-client entry files."
+    );
+  }
+  if (existing[0] !== void 0) {
+    return existing[0];
+  }
+  const useTypeScript = configPath.endsWith(".ts") || configPath.endsWith(".mts") || configPath.endsWith(".cts") || await pathExists2(path3.join(appRoot, "tsconfig.json"));
+  return path3.join(directory, `instrumentation-client.${useTypeScript ? "ts" : "js"}`);
+}
+function createChange(appRoot, absolutePath, nextContent, previousContent) {
+  if (previousContent === nextContent) {
+    return void 0;
+  }
+  return Object.freeze({
+    absolutePath,
+    nextContent,
+    ...previousContent === void 0 ? {} : { previousContent },
+    relativePath: path3.relative(appRoot, absolutePath).split(path3.sep).join("/")
+  });
+}
+async function planNextIntegration(directory = process.cwd()) {
+  const appRoot = path3.resolve(directory);
+  const packagePath = path3.join(appRoot, "package.json");
+  const [packageSource, configPath] = await Promise.all([
+    readRegularFile(packagePath),
+    findNextConfig(appRoot)
+  ]);
+  const configSource = await readRegularFile(configPath);
+  const instrumentationPath = await resolveInstrumentationPath(appRoot, configPath);
+  const instrumentationSource = await pathExists2(instrumentationPath) ? await readRegularFile(instrumentationPath) : void 0;
+  const changes = [
+    createChange(
+      appRoot,
+      configPath,
+      transformNextConfig(configPath, configSource),
+      configSource
+    ),
+    createChange(
+      appRoot,
+      instrumentationPath,
+      transformInstrumentationClient(instrumentationPath, instrumentationSource ?? ""),
+      instrumentationSource
+    ),
+    createChange(
+      appRoot,
+      packagePath,
+      transformPackageJson(packageSource),
+      packageSource
+    )
+  ].filter((change) => change !== void 0);
+  return Object.freeze({ appRoot, changes: Object.freeze(changes) });
+}
+function temporaryPath(absolutePath, label) {
+  return path3.join(
+    path3.dirname(absolutePath),
+    `.${path3.basename(absolutePath)}.spotpatch-${label}-${String(process.pid)}-${randomBytes2(8).toString("hex")}`
+  );
+}
+async function writeAtomic(absolutePath, content, mode) {
+  await mkdir(path3.dirname(absolutePath), { recursive: true });
+  const stagedPath = temporaryPath(absolutePath, "stage");
+  try {
+    await writeFile(stagedPath, content, { encoding: "utf8", flag: "wx", mode });
+    await rename(stagedPath, absolutePath);
+  } catch (error) {
+    await unlink(stagedPath).catch(() => void 0);
+    throw error;
+  }
+}
+async function rollbackChange(change) {
+  if (change.previousContent === void 0) {
+    await unlink(change.absolutePath).catch(() => void 0);
+    return;
+  }
+  const mode = (await stat(change.absolutePath)).mode;
+  await writeAtomic(change.absolutePath, change.previousContent, mode);
+}
+async function applyNextIntegrationPlan(plan) {
+  const applied = [];
+  try {
+    for (const change of plan.changes) {
+      const mode = change.previousContent === void 0 ? 384 : (await stat(change.absolutePath)).mode;
+      await writeAtomic(change.absolutePath, change.nextContent, mode);
+      applied.push(change);
+    }
+  } catch (error) {
+    const rollbackResults = await Promise.allSettled(
+      applied.reverse().map(rollbackChange)
+    );
+    if (rollbackResults.some((result) => result.status === "rejected")) {
+      throw new Error(
+        "SpotPatch init failed and could not completely restore the previous files.",
+        { cause: error }
+      );
+    }
+    throw new Error("SpotPatch init failed; all written files were restored.", {
+      cause: error
+    });
+  }
+}
+async function checkNextIntegration(directory = process.cwd()) {
+  try {
+    const plan = await planNextIntegration(directory);
+    const issues = plan.changes.map(
+      (change) => `INTEGRATION_REQUIRED:${change.relativePath}`
+    );
+    return Object.freeze({
+      appRoot: plan.appRoot,
+      issues: Object.freeze(issues),
+      ok: issues.length === 0
+    });
+  } catch (error) {
+    return Object.freeze({
+      appRoot: path3.resolve(directory),
+      issues: Object.freeze([
+        error instanceof Error ? error.message : "SpotPatch integration check failed."
+      ]),
+      ok: false
+    });
+  }
+}
+
+// src/cli.ts
+function writeUsage() {
+  process.stderr.write(
+    "Usage: spotpatch-next <dev|init|check>\n  dev [next dev options]  Start the local Next.js development server.\n  init                    Preview and apply safe integration changes.\n  check                   Verify the integration without writing files.\n"
+  );
+}
+function verifyAdapterExports(appRoot) {
+  const resolveFromApplication = createRequire2(path4.join(appRoot, "package.json"));
+  for (const moduleId of [
+    "@spotpatch/next",
+    "@spotpatch/next/client",
+    "@spotpatch/next/loader",
+    "@spotpatch/next/noop"
+  ]) {
+    try {
+      resolveFromApplication.resolve(moduleId);
+    } catch (error) {
+      throw new Error(`SpotPatch could not resolve the required export ${moduleId}.`, {
+        cause: error
+      });
+    }
+  }
+}
+async function runInit(arguments_) {
+  if (arguments_.length !== 0) {
+    throw new Error("SpotPatch init does not accept positional arguments.");
+  }
+  const project = await inspectNextProject();
+  verifyAdapterExports(project.appRoot);
+  const plan = await planNextIntegration(project.appRoot);
+  if (plan.changes.length === 0) {
+    process.stdout.write("[spotpatch:next] integration is already up to date.\n");
+    return 0;
+  }
+  process.stdout.write("[spotpatch:next] integration preview (resulting files):\n");
+  for (const change of plan.changes) {
+    process.stdout.write(`
+--- ${change.relativePath}
+${change.nextContent}`);
+    if (!change.nextContent.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+  }
+  await applyNextIntegrationPlan(plan);
+  process.stdout.write(
+    `[spotpatch:next] updated ${String(plan.changes.length)} integration file(s).
+`
+  );
+  return 0;
+}
+async function runCheck(arguments_) {
+  if (arguments_.length !== 0) {
+    throw new Error("SpotPatch check does not accept positional arguments.");
+  }
+  const project = await inspectNextProject();
+  verifyAdapterExports(project.appRoot);
+  const result = await checkNextIntegration(project.appRoot);
+  if (!result.ok) {
+    for (const issue of result.issues) {
+      process.stderr.write(`[spotpatch:next] ${issue}
+`);
+    }
+    return 1;
+  }
+  process.stdout.write(
+    `[spotpatch:next] integration verified for Next.js ${project.nextVersion}.
+`
+  );
+  return 0;
+}
+async function main(arguments_) {
+  const [command, ...rest] = arguments_;
+  if (command === "dev") {
+    const integration = await checkNextIntegration();
+    if (!integration.ok) {
+      throw new Error(
+        "SpotPatch Next integration is incomplete; run `spotpatch-next init` first."
+      );
+    }
+    return runNextDevelopment(rest);
+  }
+  if (command === "init") {
+    return runInit(rest);
+  }
+  if (command === "check") {
+    return runCheck(rest);
+  }
+  writeUsage();
+  return 1;
+}
+try {
+  process.exitCode = await main(process.argv.slice(2));
+} catch (error) {
+  process.stderr.write(
+    `[spotpatch:next] ${error instanceof Error ? error.message : "The command failed."}
+`
+  );
+  process.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map