@bigcommerce/catalyst 1.2.0 → 1.4.0

package/dist/cli.js

@@ -25,7 +25,7 @@ import { randomBytes, randomUUID } from "crypto";
 // package.json
 var package_default = {
   name: "@bigcommerce/catalyst",
-  version: "1.2.0",
+  version: "1.4.0",
   type: "module",
   repository: {
     type: "git",
@@ -49,7 +49,7 @@ var package_default = {
     build: "tsup"
   },
   engines: {
-    node: "^20.0.0 || ^22.0.0 || ^24.0.0"
+    node: "^22.0.0 || ^24.0.0"
   },
   dependencies: {
     "@commander-js/extra-typings": "^14.0.0",
@@ -69,6 +69,7 @@ var package_default = {
     semver: "^7.7.4",
     "std-env": "^3.9.0",
     tar: "^7.5.7",
+    tldts: "^7.4.12",
     "yocto-spinner": "^1.0.0",
     zod: "^4.0.5"
   },
@@ -91,7 +92,12 @@ var package_default = {
     vitest: "^3.2.4"
   },
   peerDependencies: {
-    "@opennextjs/cloudflare": "1.17.3"
+    "@opennextjs/cloudflare": "^1.17.3"
+  },
+  peerDependenciesMeta: {
+    "@opennextjs/cloudflare": {
+      optional: true
+    }
   }
 };
 
@@ -594,9 +600,9 @@ async function deleteProject(projectUuid, storeHash, accessToken, apiHost) {
 // src/cli/lib/project-config.ts
 import Conf2 from "conf";
 import { join } from "path";
-function getProjectConfig() {
+function getProjectConfig(cwd = process.cwd()) {
   return new Conf2({
-    cwd: join(process.cwd(), ".bigcommerce"),
+    cwd: join(cwd, ".bigcommerce"),
     projectSuffix: "",
     configName: "project",
     schema: {
@@ -647,7 +653,7 @@ var resolveProjectUuid = (options) => {
   const projectUuid = options.projectUuid ?? config2.get("projectUuid");
   if (!projectUuid) {
     throw new Error(
-      "Project UUID is required. Please run either `catalyst project link` or `catalyst project create` or this command again with --project-uuid <uuid>."
+      "Project UUID is required. Please run either `catalyst projects link` or `catalyst projects create` or this command again with --project-uuid <uuid>."
     );
   }
   return projectUuid;
@@ -703,8 +709,8 @@ Example:
     const store = await fetchStoreProfile2(storeHash, accessToken, apiHost);
     const projectUuid = config2.get("projectUuid");
     if (projectUuid) {
-      const projects = await fetchProjects(storeHash, accessToken, apiHost);
-      const linkedProject = projects.find((p) => p.uuid === projectUuid);
+      const projects2 = await fetchProjects(storeHash, accessToken, apiHost);
+      const linkedProject = projects2.find((p) => p.uuid === projectUuid);
       if (linkedProject) {
         consola.info(
           `Logged in to ${store.store_name} (${storeHash}), connected to project ${linkedProject.name} (${projectUuid})`
@@ -804,7 +810,7 @@ var auth = new Command("auth").configureHelp({ showGlobalOptions: true }).descri
 import { Command as Command2, InvalidArgumentError, Option as Option2 } from "commander";
 import { execa as execa2 } from "execa";
 import { copyFile, cp, rm, writeFile } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 import { valid as validSemver } from "semver";
 
 // src/cli/lib/build-env.ts
@@ -839,223 +845,679 @@ function loadBuildEnv({ envPath, cwd = process.cwd() }) {
   }
 }
 
-// src/cli/lib/get-module-cli-path.ts
+// src/cli/lib/commerce-hosting.ts
+import { confirm as confirm2, input as input2, select, Separator } from "@inquirer/prompts";
+import { colorize as colorize3 } from "consola/utils";
+import { existsSync as existsSync2, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { dirname, join as join2 } from "path";
-import { fileURLToPath } from "url";
-function getModuleCliPath() {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  return join2(__dirname, "..");
+import { minVersion, satisfies, lt as semverLt, validRange } from "semver";
+import { z as z6 } from "zod";
+
+// src/cli/lib/sort-package-json.ts
+var FIELD_ORDER = [
+  "name",
+  "description",
+  "version",
+  "private",
+  "engines",
+  "scripts",
+  "dependencies",
+  "devDependencies"
+];
+function sortPackageJsonFields(pkg) {
+  const ordered = {};
+  FIELD_ORDER.forEach((field) => {
+    if (field in pkg) {
+      ordered[field] = pkg[field];
+    }
+  });
+  Object.keys(pkg).forEach((key) => {
+    if (!(key in ordered)) {
+      ordered[key] = pkg[key];
+    }
+  });
+  return ordered;
 }
 
-// src/cli/lib/project-state.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join3 } from "path";
-import { z as z6 } from "zod";
-var projectJsonSchema = z6.looseObject({
-  projectUuid: z6.string().optional()
-});
-var packageJsonSchema = z6.looseObject({
+// src/cli/lib/commerce-hosting.ts
+var OPENNEXT_CLOUDFLARE_VERSION = "1.20.6";
+var OPENNEXT_REQUIRED_NEXT_RANGE = ">=15.5.24 <16 || >=16.3.3";
+var corePackageJsonSchema = z6.looseObject({
   dependencies: z6.record(z6.string(), z6.string()).optional()
 });
-var safeReadJson = (path) => {
+var projectJsonSchema = z6.looseObject({});
+var readProjectJson = (path) => {
+  if (!existsSync2(path)) return {};
   try {
-    return JSON.parse(readFileSync(path, "utf-8"));
+    const parsed = projectJsonSchema.safeParse(JSON.parse(readFileSync(path, "utf-8")));
+    return parsed.success ? parsed.data : {};
   } catch {
-    return null;
+    return {};
   }
 };
-function getProjectState(cwd = process.cwd()) {
-  const projectJson = projectJsonSchema.safeParse(
-    safeReadJson(join3(cwd, ".bigcommerce", "project.json"))
-  );
-  const projectUuid = projectJson.success ? projectJson.data.projectUuid : void 0;
-  const hasMiddleware = existsSync2(join3(cwd, "middleware.ts"));
-  const hasProxy = existsSync2(join3(cwd, "proxy.ts"));
-  const pkgJson = packageJsonSchema.safeParse(safeReadJson(join3(cwd, "package.json")));
-  const hasOpenNextDep = pkgJson.success ? Boolean(pkgJson.data.dependencies?.["@opennextjs/cloudflare"]) : false;
-  const isLinked = Boolean(projectUuid);
-  const isTransformed = hasMiddleware && !hasProxy && hasOpenNextDep;
-  const isFullySetUp = isLinked && isTransformed;
-  return {
-    projectUuid,
-    hasMiddleware,
-    hasProxy,
-    hasOpenNextDep,
-    isLinked,
-    isTransformed,
-    isFullySetUp
-  };
-}
-
-// src/cli/lib/required-build-env.ts
-var REQUIRED_BUILD_ENV_VARS = [
-  "BIGCOMMERCE_STORE_HASH",
-  "BIGCOMMERCE_STOREFRONT_TOKEN",
-  "BIGCOMMERCE_CHANNEL_ID",
-  "AUTH_SECRET"
-];
-var findMissingBuildEnv = (env2 = process.env) => {
-  return REQUIRED_BUILD_ENV_VARS.filter((name) => {
-    const value = env2[name];
-    return value === void 0 || value.trim() === "";
-  });
+var writeJson = (path, value) => {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`);
 };
-var assertRequiredBuildEnv = (env2 = process.env) => {
-  const missing = findMissingBuildEnv(env2);
-  if (missing.length === 0) {
+var convertProxyToMiddleware = (projectDir) => {
+  const proxyPath = join2(projectDir, "proxy.ts");
+  const middlewarePath = join2(projectDir, "middleware.ts");
+  if (!existsSync2(proxyPath)) return;
+  const contents = readFileSync(proxyPath, "utf-8").replace("export const proxy", "export const middleware").replace("export const config = {", "export const config = {\n  runtime: 'experimental-edge',");
+  writeFileSync(middlewarePath, contents);
+  unlinkSync(proxyPath);
+};
+var cleanupCloudflareIncompatibilities = async (projectDir) => {
+  const instrumentationPath = join2(projectDir, "instrumentation.ts");
+  if (!existsSync2(instrumentationPath)) return;
+  if (!process.stdin.isTTY) {
+    consola.warn(
+      "instrumentation.ts is present and may be incompatible with the Cloudflare Workers bundle (the default @vercel/otel scaffolding throws at cold start under workerd). Skipping automatic cleanup in non-interactive mode \u2014 re-run interactively to remove it, or delete/gate it manually."
+    );
     return;
   }
-  const missingList = missing.map((name) => `  - ${name}`).join("\n");
-  throw new UserActionableError(
-    `Missing required environment variable${missing.length === 1 ? "" : "s"} for the build:
-${missingList}
-
-These are read by the build itself, so they must be set before it runs. The build automatically loads \`.env.local\` and \`.env\` from the current directory (${process.cwd()}) \u2014 add the variables above to one of those files (\`.env.local\` takes precedence).
-To load an env file from a different location, pass \`--env-path <path>\` (for example \`--env-path ../.env.local\` when running from a subdirectory).`
-  );
-};
-
-// src/cli/lib/wrangler-config.ts
-function getCompatibilityDate(now = /* @__PURE__ */ new Date()) {
-  const date = new Date(now);
-  date.setUTCMonth(date.getUTCMonth() - 1);
-  return date.toISOString().slice(0, 10);
-}
-function getWranglerConfig(projectUuid) {
-  return {
-    $schema: "node_modules/wrangler/config-schema.json",
-    main: "../.open-next/worker.js",
-    name: `project-${projectUuid}`,
-    compatibility_date: getCompatibilityDate(),
-    compatibility_flags: ["nodejs_compat", "global_fetch_strictly_public"],
-    observability: {
-      enabled: true,
-      head_sampling_rate: 0.05,
-      logs: {
-        enabled: true,
-        head_sampling_rate: 1,
-        invocation_logs: false
-      }
-    },
-    assets: {
-      directory: "../.open-next/assets",
-      binding: "ASSETS"
-    },
-    services: [
-      {
-        binding: "WORKER_SELF_REFERENCE",
-        service: `project-${projectUuid}`
-      }
-    ],
-    r2_buckets: [
-      {
-        binding: "NEXT_INC_CACHE_R2_BUCKET",
-        bucket_name: `project-${projectUuid}`
-      }
-    ],
-    durable_objects: {
-      bindings: [
-        {
-          name: "NEXT_CACHE_DO_QUEUE",
-          class_name: "DOQueueHandler"
-        },
-        {
-          name: "NEXT_TAG_CACHE_DO_SHARDED",
-          class_name: "DOShardedTagCache"
-        },
-        {
-          name: "NEXT_CACHE_DO_PURGE",
-          class_name: "BucketCachePurge"
-        }
-      ]
-    },
-    migrations: [
-      {
-        tag: "v1",
-        new_sqlite_classes: ["DOQueueHandler", "DOShardedTagCache", "BucketCachePurge"]
-      }
-    ]
-  };
-}
-
-// src/cli/commands/build.ts
-var WRANGLER_VERSION = "4.90.0";
-var DIST_TAG_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var parseWranglerVersion = (value) => {
-  if (!validSemver(value) && !DIST_TAG_PATTERN.test(value)) {
-    throw new InvalidArgumentError(
-      `"${value}" is not a valid Wrangler version or dist-tag (e.g. 4.90.0 or latest).`
+  const shouldRemove = await confirm2({
+    message: 'Catalyst found instrumentation.ts, which is incompatible with the Cloudflare Workers bundle when it uses @vercel/otel (causes "Failed to prepare server" at cold start). Remove it and drop @vercel/otel from package.json?',
+    default: true
+  });
+  if (!shouldRemove) {
+    consola.info(
+      'Leaving instrumentation.ts in place. The Cloudflare worker will continue to log "Failed to prepare server" at cold start until this is resolved manually.'
     );
+    return;
   }
-  return value;
-};
-async function buildCatalystProject(projectUuid, wranglerVersion = WRANGLER_VERSION) {
-  assertRequiredBuildEnv();
-  const coreDir = process.cwd();
-  const openNextOutDir = join4(coreDir, ".open-next");
-  const bigcommerceDistDir = join4(coreDir, ".bigcommerce", "dist");
-  const wranglerConfig = getWranglerConfig(projectUuid);
-  await rm(bigcommerceDistDir, { recursive: true, force: true });
-  consola.start("Copying templates...");
-  await copyFile(
-    join4(getModuleCliPath(), "templates", "open-next.config.ts"),
-    join4(coreDir, ".bigcommerce", "open-next.config.ts")
-  );
-  await writeFile(
-    join4(coreDir, ".bigcommerce", "wrangler.jsonc"),
-    JSON.stringify(wranglerConfig, null, 2)
-  );
-  consola.success("Templates copied");
-  consola.start("Building project...");
-  await execa2(
-    "pnpm",
-    [
-      "exec",
-      "opennextjs-cloudflare",
-      "build",
-      "--skipWranglerConfigCheck",
-      "--openNextConfigPath",
-      join4(coreDir, ".bigcommerce", "open-next.config.ts")
-    ],
-    {
-      stdout: ["pipe", "inherit"],
-      cwd: coreDir
-    }
-  );
-  await execa2(
-    "pnpm",
-    [
-      "dlx",
-      `wrangler@${wranglerVersion}`,
-      "deploy",
-      "--config",
-      join4(coreDir, ".bigcommerce", "wrangler.jsonc"),
-      "--keep-vars",
-      "--outdir",
-      bigcommerceDistDir,
-      "--dry-run"
-    ],
-    {
-      stdout: ["pipe", "inherit"],
-      cwd: coreDir
+  unlinkSync(instrumentationPath);
+  consola.info("Removed instrumentation.ts (incompatible with Cloudflare Workers).");
+  const corePackageJsonPath = join2(projectDir, "package.json");
+  if (existsSync2(corePackageJsonPath)) {
+    const pkg = corePackageJsonSchema.parse(JSON.parse(readFileSync(corePackageJsonPath, "utf-8")));
+    if (pkg.dependencies && "@vercel/otel" in pkg.dependencies) {
+      const { "@vercel/otel": _removedVercelOtel, ...preservedDeps } = pkg.dependencies;
+      pkg.dependencies = preservedDeps;
+      writeJson(corePackageJsonPath, sortPackageJsonFields(pkg));
+      consola.info("Dropped @vercel/otel from package.json.");
     }
-  );
-  consola.success("Project built");
-  await cp(join4(openNextOutDir, "assets"), join4(bigcommerceDistDir, "assets"), {
-    recursive: true,
-    force: true
+  }
+};
+var reconcileOpenNextVersion = async (projectDir, packageManager, { canUpgrade }) => {
+  const corePackageJsonPath = join2(projectDir, "package.json");
+  if (!existsSync2(corePackageJsonPath)) return false;
+  const pkg = corePackageJsonSchema.parse(JSON.parse(readFileSync(corePackageJsonPath, "utf-8")));
+  const range = pkg.dependencies?.["@opennextjs/cloudflare"];
+  if (range === void 0) return false;
+  if (!validRange(range)) return false;
+  if (satisfies(OPENNEXT_CLOUDFLARE_VERSION, range)) return false;
+  const current = minVersion(range)?.version;
+  if (current === void 0 || !semverLt(current, OPENNEXT_CLOUDFLARE_VERSION)) return false;
+  const manualStep = `\`${packageManager} add @opennextjs/cloudflare@${OPENNEXT_CLOUDFLARE_VERSION}\``;
+  const behind = `This project pins @opennextjs/cloudflare ${current}, but this CLI targets ${OPENNEXT_CLOUDFLARE_VERSION}.`;
+  const nextRange = pkg.dependencies?.next;
+  const nextVersion = nextRange !== void 0 && validRange(nextRange) ? minVersion(nextRange) : null;
+  if (nextVersion !== null && !satisfies(nextVersion.version, OPENNEXT_REQUIRED_NEXT_RANGE)) {
+    consola.warn(
+      `${behind} That release needs Next.js ${OPENNEXT_REQUIRED_NEXT_RANGE}, but this project is on ${nextVersion.version}. Run \`catalyst upgrade\` to move core and Next first, then re-run the deploy to pick up the adapter.`
+    );
+    return false;
+  }
+  if (!canUpgrade) {
+    consola.warn(
+      `${behind} The deploy will use the existing build output. Re-run without \`--prebuilt\`, or update it with ${manualStep}, to pick up adapter fixes released since then.`
+    );
+    return false;
+  }
+  if (!process.stdin.isTTY) {
+    consola.warn(
+      `${behind} Skipping the upgrade prompt in a non-interactive environment. Update it with ${manualStep} and commit the lockfile to pick up adapter fixes released since then.`
+    );
+    return false;
+  }
+  const shouldUpgrade = await confirm2({
+    message: `${behind} Adapter fixes released since then are not applied. Update it to ${OPENNEXT_CLOUDFLARE_VERSION} and reinstall now?`,
+    default: true
   });
-}
-var build = new Command2("build").configureHelp({ showGlobalOptions: true }).description(
-  "Build your Catalyst project using the OpenNext/Cloudflare build pipeline. Also runs a Wrangler dry-run to generate deployment artifacts."
-).addHelpText(
-  "after",
-  `
-Examples:
-  $ catalyst build
-
-  # Include project UUID
+  if (!shouldUpgrade) {
+    consola.info(`Keeping @opennextjs/cloudflare ${current}. Update it later with ${manualStep}.`);
+    return false;
+  }
+  pkg.dependencies = {
+    ...pkg.dependencies,
+    "@opennextjs/cloudflare": OPENNEXT_CLOUDFLARE_VERSION
+  };
+  writeJson(corePackageJsonPath, sortPackageJsonFields(pkg));
+  consola.info(`Updated @opennextjs/cloudflare to ${OPENNEXT_CLOUDFLARE_VERSION}.`);
+  return true;
+};
+var setupCommerceHosting = async ({
+  projectDir,
+  projectUuid,
+  storeHash,
+  accessToken
+}) => {
+  await cleanupCloudflareIncompatibilities(projectDir);
+  const corePackageJsonPath = join2(projectDir, "package.json");
+  const pkg = corePackageJsonSchema.parse(JSON.parse(readFileSync(corePackageJsonPath, "utf-8")));
+  pkg.dependencies = {
+    ...pkg.dependencies,
+    "@opennextjs/cloudflare": OPENNEXT_CLOUDFLARE_VERSION
+  };
+  writeJson(corePackageJsonPath, sortPackageJsonFields(pkg));
+  const projectJsonPath = join2(projectDir, ".bigcommerce", "project.json");
+  const projectJson = {
+    ...readProjectJson(projectJsonPath),
+    projectUuid,
+    framework: "catalyst"
+  };
+  if (storeHash) projectJson.storeHash = storeHash;
+  if (accessToken) projectJson.accessToken = accessToken;
+  writeJson(projectJsonPath, projectJson);
+  convertProxyToMiddleware(projectDir);
+};
+var NoLinkedProjectError = class extends Error {
+  constructor() {
+    super("No infrastructure project linked: user declined to create one.");
+    this.name = "NoLinkedProjectError";
+  }
+};
+async function promptForNewProjectName(api) {
+  const newProjectName = await input2({ message: "Enter a name for the new project:" });
+  const data = await createProject(newProjectName, api.storeHash, api.accessToken, api.apiHost);
+  consola.success(`Project "${data.name}" created successfully.`);
+  return { uuid: data.uuid, name: data.name, deployment_hostnames: [] };
+}
+async function selectOrCreateInfrastructureProject(api, linkedProjectUuid) {
+  consola.start("Fetching projects...");
+  const existingProjects = await fetchProjects(api.storeHash, api.accessToken, api.apiHost);
+  consola.success("Projects fetched.");
+  if (existingProjects.length === 0) {
+    const shouldCreate = await confirm2({
+      message: "There are not any hosting projects that you can link to yet. Would you like to create one?",
+      default: true
+    });
+    if (!shouldCreate) {
+      throw new NoLinkedProjectError();
+    }
+    return promptForNewProjectName(api);
+  }
+  const choices = [
+    ...existingProjects.map((p) => ({
+      name: p.uuid === linkedProjectUuid ? `${p.name} ${colorize3("green", "[linked]")}` : p.name,
+      value: p.uuid,
+      description: p.uuid
+    })),
+    {
+      name: "Create a new project",
+      value: "create",
+      description: "Create a new hosting project for this Catalyst storefront."
+    }
+  ];
+  const selected = await select({
+    message: "Select a project or create a new project (Press <enter> to select).",
+    choices
+  });
+  if (selected === "create") {
+    return promptForNewProjectName(api);
+  }
+  const matched = existingProjects.find((p) => p.uuid === selected);
+  if (!matched) {
+    throw new Error(`Selected project ${String(selected)} not found in fetched list.`);
+  }
+  return matched;
+}
+async function promptForCommerceHostingProject(api, defaultName, autoUseDefaultName, useExistingOnCollision) {
+  const existingProjects = await fetchProjects(api.storeHash, api.accessToken, api.apiHost);
+  const takenNames = existingProjects.map((project) => project.name);
+  if (autoUseDefaultName) {
+    return autoCreateCommerceHostingProject(
+      api,
+      defaultName,
+      existingProjects,
+      useExistingOnCollision
+    );
+  }
+  const conflict = existingProjects.find(
+    (project) => project.name.toLowerCase() === defaultName.toLowerCase()
+  );
+  if (!conflict) {
+    return autoCreateCommerceHostingProject(
+      api,
+      defaultName,
+      existingProjects,
+      useExistingOnCollision
+    );
+  }
+  const hasOtherProjects = existingProjects.length > 1;
+  const choices = [
+    { name: `Use "${conflict.name}"`, value: "use-named" }
+  ];
+  if (hasOtherProjects) {
+    choices.push({ name: "Select from my projects", value: "select-from-list" });
+  }
+  choices.push({ name: "Create a new project", value: "create" });
+  const action = await select({
+    message: hasOtherProjects ? `It looks like you already have an existing Commerce Hosting project named "${conflict.name}". Would you like to use it, select from your projects, or create a new one?` : `It looks like you already have an existing Commerce Hosting project named "${conflict.name}". Would you like to use it, or create a new one?`,
+    choices
+  });
+  if (action === "use-named") {
+    consola.success(`Using existing Commerce Hosting project "${conflict.name}"`);
+    return conflict;
+  }
+  if (action === "create") {
+    return promptAndCreateCommerceHostingProject(api, takenNames, defaultName);
+  }
+  const selected = await select({
+    message: "Which Commerce Hosting project would you like to use?",
+    choices: [
+      ...existingProjects.map((project) => ({
+        name: project.name,
+        value: project,
+        description: project.uuid
+      })),
+      new Separator(),
+      { name: "Create a new project", value: "create-new" }
+    ]
+  });
+  if (selected === "create-new") {
+    return promptAndCreateCommerceHostingProject(api, takenNames, defaultName);
+  }
+  consola.success(`Using existing Commerce Hosting project "${selected.name}"`);
+  return selected;
+}
+async function promptAndCreateCommerceHostingProject(api, takenNames, defaultName) {
+  const projectName = await input2({
+    message: "What would you like to name your Commerce Hosting project?",
+    default: defaultName,
+    validate: (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) return "Project name is required";
+      const conflict = takenNames.find((taken) => taken.toLowerCase() === trimmed.toLowerCase());
+      if (conflict) {
+        return `A Commerce Hosting project named "${conflict}" already exists`;
+      }
+      return true;
+    },
+    theme: {
+      style: {
+        help: () => colorize3(
+          "dim",
+          "(The project that hosts your storefront on Commerce \u2014 often matches your folder name.)"
+        )
+      }
+    }
+  });
+  try {
+    const created = await createProject(
+      projectName.trim(),
+      api.storeHash,
+      api.accessToken,
+      api.apiHost
+    );
+    consola.success(`Commerce Hosting project "${created.name}" created successfully`);
+    return { uuid: created.uuid, name: created.name, deployment_hostnames: [] };
+  } catch (error) {
+    if (error instanceof InfrastructureProjectValidationError) {
+      consola.error(error.message);
+      return promptAndCreateCommerceHostingProject(api, takenNames, defaultName);
+    }
+    throw error;
+  }
+}
+async function resolveCollisionChoice(existingName, useExistingOnCollision) {
+  if (useExistingOnCollision === true) return true;
+  if (!process.stdin.isTTY) return false;
+  return select({
+    message: `A Commerce Hosting project named "${existingName}" already exists. Use the existing project?`,
+    choices: [
+      { name: "Yes", value: true },
+      { name: "No", value: false }
+    ]
+  });
+}
+async function autoCreateCommerceHostingProject(api, name, existingProjects, useExistingOnCollision) {
+  const existing = existingProjects.find(
+    (project) => project.name.toLowerCase() === name.toLowerCase()
+  );
+  if (existing) {
+    const shouldUseExisting = await resolveCollisionChoice(existing.name, useExistingOnCollision);
+    if (shouldUseExisting) {
+      consola.success(`Using existing Commerce Hosting project "${existing.name}"`);
+      return existing;
+    }
+    consola.error(
+      "Not reusing the existing project. Re-run with a different --project-name, or pass --use-existing to reuse it."
+    );
+    process.exit(1);
+  }
+  try {
+    const created = await createProject(name, api.storeHash, api.accessToken, api.apiHost);
+    consola.success(`Commerce Hosting project "${created.name}" created successfully`);
+    return { uuid: created.uuid, name: created.name, deployment_hostnames: [] };
+  } catch (error) {
+    if (error instanceof InfrastructureProjectValidationError) {
+      consola.error(
+        `Failed to create Commerce Hosting project "${name}": ${error.message}
+Re-run with a different --project-name.`
+      );
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+// src/cli/lib/detect-package-manager.ts
+import { access } from "fs/promises";
+import { join as join3 } from "path";
+import { detectPackageManager as detectFromDir } from "nypm";
+var PROJECT_LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["package-lock.json", "npm"]
+];
+var detectLockfileManager = async (dir) => {
+  const found = await Promise.all(
+    PROJECT_LOCKFILES.map(
+      async ([file, manager]) => access(join3(dir, file)).then(() => manager).catch(() => null)
+    )
+  );
+  return found.find((manager) => manager !== null) ?? null;
+};
+var detectPackageManager = () => {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  const name = userAgent.split(" ")[0]?.split("/")[0];
+  if (name === "pnpm" || name === "yarn" || name === "bun") {
+    return name;
+  }
+  if (process.versions.bun) {
+    return "bun";
+  }
+  return "npm";
+};
+var detectProjectPackageManager = async (projectDir) => {
+  const detected = await detectFromDir(projectDir);
+  const name = detected?.name;
+  if (name === "pnpm" || name === "yarn" || name === "bun" || name === "npm") {
+    return name;
+  }
+  return "npm";
+};
+
+// src/cli/lib/get-module-cli-path.ts
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath } from "url";
+function getModuleCliPath() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname2(__filename);
+  return join4(__dirname, "..");
+}
+
+// src/cli/lib/install-dependencies.ts
+import { installDependencies as installDeps } from "nypm";
+import yoctoSpinner2 from "yocto-spinner";
+var restoreEnv = (key, previous) => {
+  if (previous === void 0) {
+    Reflect.deleteProperty(process.env, key);
+  } else {
+    process.env[key] = previous;
+  }
+};
+var withQuietInstallEnv = async (run2) => {
+  var _a, _b;
+  const prevNodeNoWarnings = process.env.NODE_NO_WARNINGS;
+  const prevDownloadPrompt = process.env.COREPACK_ENABLE_DOWNLOAD_PROMPT;
+  (_a = process.env).NODE_NO_WARNINGS ?? (_a.NODE_NO_WARNINGS = "1");
+  (_b = process.env).COREPACK_ENABLE_DOWNLOAD_PROMPT ?? (_b.COREPACK_ENABLE_DOWNLOAD_PROMPT = "0");
+  try {
+    return await run2();
+  } finally {
+    restoreEnv("NODE_NO_WARNINGS", prevNodeNoWarnings);
+    restoreEnv("COREPACK_ENABLE_DOWNLOAD_PROMPT", prevDownloadPrompt);
+  }
+};
+var installDependencies = async (projectDir, packageManager = "pnpm") => {
+  const spinner = yoctoSpinner2().start(
+    `Installing dependencies with ${packageManager}. This could take a minute...`
+  );
+  try {
+    await withQuietInstallEnv(() => installDeps({ cwd: projectDir, silent: true, packageManager }));
+    spinner.success("Dependencies installed successfully.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "unknown error";
+    spinner.error(`Failed to install dependencies: ${message}`);
+    throw error;
+  }
+};
+
+// src/cli/lib/project-state.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join5 } from "path";
+import { z as z7 } from "zod";
+var projectJsonSchema2 = z7.looseObject({
+  projectUuid: z7.string().optional()
+});
+var packageJsonSchema = z7.looseObject({
+  dependencies: z7.record(z7.string(), z7.string()).optional()
+});
+var safeReadJson = (path) => {
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+function getProjectState(cwd = process.cwd()) {
+  const projectJson = projectJsonSchema2.safeParse(
+    safeReadJson(join5(cwd, ".bigcommerce", "project.json"))
+  );
+  const projectUuid = projectJson.success ? projectJson.data.projectUuid : void 0;
+  const hasMiddleware = existsSync3(join5(cwd, "middleware.ts"));
+  const hasProxy = existsSync3(join5(cwd, "proxy.ts"));
+  const pkgJson = packageJsonSchema.safeParse(safeReadJson(join5(cwd, "package.json")));
+  const hasOpenNextDep = pkgJson.success ? Boolean(pkgJson.data.dependencies?.["@opennextjs/cloudflare"]) : false;
+  const isLinked = Boolean(projectUuid);
+  const isTransformed = hasMiddleware && !hasProxy && hasOpenNextDep;
+  const isFullySetUp = isLinked && isTransformed;
+  return {
+    projectUuid,
+    hasMiddleware,
+    hasProxy,
+    hasOpenNextDep,
+    isLinked,
+    isTransformed,
+    isFullySetUp
+  };
+}
+
+// src/cli/lib/required-build-env.ts
+var REQUIRED_BUILD_ENV_VARS = [
+  "BIGCOMMERCE_STORE_HASH",
+  "BIGCOMMERCE_STOREFRONT_TOKEN",
+  "BIGCOMMERCE_CHANNEL_ID",
+  "AUTH_SECRET"
+];
+var findMissingBuildEnv = (env2 = process.env) => {
+  return REQUIRED_BUILD_ENV_VARS.filter((name) => {
+    const value = env2[name];
+    return value === void 0 || value.trim() === "";
+  });
+};
+var assertRequiredBuildEnv = (env2 = process.env) => {
+  const missing = findMissingBuildEnv(env2);
+  if (missing.length === 0) {
+    return;
+  }
+  const missingList = missing.map((name) => `  - ${name}`).join("\n");
+  throw new UserActionableError(
+    `Missing required environment variable${missing.length === 1 ? "" : "s"} for the build:
+${missingList}
+
+These are read by the build itself, so they must be set before it runs. The build automatically loads \`.env.local\` and \`.env\` from the current directory (${process.cwd()}) \u2014 add the variables above to one of those files (\`.env.local\` takes precedence).
+To load an env file from a different location, pass \`--env-path <path>\` (for example \`--env-path ../.env.local\` when running from a subdirectory).`
+  );
+};
+
+// src/cli/lib/wrangler-config.ts
+function getCompatibilityDate(now = /* @__PURE__ */ new Date()) {
+  const date = new Date(now);
+  date.setUTCMonth(date.getUTCMonth() - 1);
+  return date.toISOString().slice(0, 10);
+}
+var LOCAL_ROUTES_KV_NAMESPACE_ID = "catalyst-routes-kv-local";
+function getWranglerConfig(projectUuid) {
+  return {
+    $schema: "node_modules/wrangler/config-schema.json",
+    main: "../.open-next/worker.js",
+    name: `project-${projectUuid}`,
+    compatibility_date: getCompatibilityDate(),
+    compatibility_flags: ["nodejs_compat", "global_fetch_strictly_public"],
+    observability: {
+      enabled: true,
+      head_sampling_rate: 0.05,
+      logs: {
+        enabled: true,
+        head_sampling_rate: 1,
+        invocation_logs: false
+      }
+    },
+    assets: {
+      directory: "../.open-next/assets",
+      binding: "ASSETS"
+    },
+    services: [
+      {
+        binding: "WORKER_SELF_REFERENCE",
+        service: `project-${projectUuid}`
+      }
+    ],
+    r2_buckets: [
+      {
+        binding: "NEXT_INC_CACHE_R2_BUCKET",
+        bucket_name: `project-${projectUuid}`
+      }
+    ],
+    kv_namespaces: [
+      {
+        binding: "CATALYST_ROUTES_KV",
+        id: LOCAL_ROUTES_KV_NAMESPACE_ID
+      }
+    ],
+    durable_objects: {
+      bindings: [
+        {
+          name: "NEXT_CACHE_DO_QUEUE",
+          class_name: "DOQueueHandler"
+        },
+        {
+          name: "NEXT_TAG_CACHE_DO_SHARDED",
+          class_name: "DOShardedTagCache"
+        },
+        {
+          name: "NEXT_CACHE_DO_PURGE",
+          class_name: "BucketCachePurge"
+        }
+      ]
+    },
+    migrations: [
+      {
+        tag: "v1",
+        new_sqlite_classes: ["DOQueueHandler", "DOShardedTagCache", "BucketCachePurge"]
+      }
+    ]
+  };
+}
+
+// src/cli/commands/build.ts
+var WRANGLER_VERSION = "4.128.0";
+var DIST_TAG_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var parseWranglerVersion = (value) => {
+  if (!validSemver(value) && !DIST_TAG_PATTERN.test(value)) {
+    throw new InvalidArgumentError(
+      `"${value}" is not a valid Wrangler version or dist-tag (e.g. 4.90.0 or latest).`
+    );
+  }
+  return value;
+};
+async function buildCatalystProject(projectUuid, wranglerVersion = WRANGLER_VERSION) {
+  assertRequiredBuildEnv();
+  const coreDir = process.cwd();
+  const projectPackageManager = await detectProjectPackageManager(coreDir);
+  if (await reconcileOpenNextVersion(coreDir, projectPackageManager, { canUpgrade: true })) {
+    await installDependencies(coreDir, projectPackageManager);
+  }
+  const openNextOutDir = join6(coreDir, ".open-next");
+  const bigcommerceDistDir = join6(coreDir, ".bigcommerce", "dist");
+  consola.start("Generating GraphQL types...");
+  await execa2("node", [join6(coreDir, "scripts", "generate.cjs")], {
+    stdio: "inherit",
+    cwd: coreDir
+  });
+  consola.success("GraphQL types generated");
+  const wranglerConfig = getWranglerConfig(projectUuid);
+  await rm(bigcommerceDistDir, { recursive: true, force: true });
+  consola.start("Copying templates...");
+  await copyFile(
+    join6(getModuleCliPath(), "templates", "open-next.config.ts"),
+    join6(coreDir, ".bigcommerce", "open-next.config.ts")
+  );
+  await writeFile(
+    join6(coreDir, ".bigcommerce", "wrangler.jsonc"),
+    JSON.stringify(wranglerConfig, null, 2)
+  );
+  consola.success("Templates copied");
+  consola.start("Building project...");
+  await execa2(
+    "pnpm",
+    [
+      "exec",
+      "opennextjs-cloudflare",
+      "build",
+      "--skipWranglerConfigCheck",
+      "--openNextConfigPath",
+      join6(coreDir, ".bigcommerce", "open-next.config.ts")
+    ],
+    {
+      stdout: ["pipe", "inherit"],
+      cwd: coreDir
+    }
+  );
+  await copyFile(
+    join6(getModuleCliPath(), "templates", "public_headers"),
+    join6(openNextOutDir, "assets", "_headers")
+  );
+  await execa2(
+    "pnpm",
+    [
+      "dlx",
+      `wrangler@${wranglerVersion}`,
+      "deploy",
+      "--config",
+      join6(coreDir, ".bigcommerce", "wrangler.jsonc"),
+      "--keep-vars",
+      "--outdir",
+      bigcommerceDistDir,
+      "--dry-run"
+    ],
+    {
+      stdout: ["pipe", "inherit"],
+      cwd: coreDir
+    }
+  );
+  consola.success("Project built");
+  await cp(join6(openNextOutDir, "assets"), join6(bigcommerceDistDir, "assets"), {
+    recursive: true,
+    force: true
+  });
+}
+var build = new Command2("build").configureHelp({ showGlobalOptions: true }).description(
+  "Build your Catalyst project using the OpenNext/Cloudflare build pipeline. Also runs a Wrangler dry-run to generate deployment artifacts."
+).addHelpText(
+  "after",
+  `
+Examples:
+  $ catalyst build
+
+  # Include project UUID
   $ catalyst build --project-uuid <UUID>
 
   # Build with a specific Wrangler version
@@ -1087,22 +1549,25 @@ Examples:
   const projectUuid = options.projectUuid ?? config2.get("projectUuid");
   if (!projectUuid) {
     throw new Error(
-      "Project UUID is required. Please run `catalyst project create` or `catalyst project link` or this command again with --project-uuid <uuid>."
+      "Project UUID is required. Please run `catalyst projects create` or `catalyst projects link` or this command again with --project-uuid <uuid>."
     );
   }
   await buildCatalystProject(projectUuid, options.wranglerVersion);
 });
 
-// src/cli/commands/channel.ts
-import { select as select4 } from "@inquirer/prompts";
+// src/cli/commands/channels.ts
+import { confirm as confirm3, select as select4 } from "@inquirer/prompts";
 import { Command as Command3, InvalidArgumentError as InvalidArgumentError2, Option as Option3 } from "commander";
 import { colorize as colorize5 } from "consola/utils";
 
+// src/cli/lib/channel-checkout-url-flow.ts
+import { input as input3 } from "@inquirer/prompts";
+
 // src/cli/lib/channel-site-flow.ts
 import { select as select2 } from "@inquirer/prompts";
 
 // src/cli/lib/channels.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var cliApiUrl = (origin, storeHash, path) => `${origin}/stores/${storeHash}/cli-api/v3${path}`;
 var channelsUrl = (storeHash, apiHost, query2 = {}) => {
   const params = new URLSearchParams(query2).toString();
@@ -1113,18 +1578,18 @@ var authHeaders2 = (accessToken) => ({
   "X-Correlation-Id": getTelemetry().correlationId,
   Accept: "application/json"
 });
-var envVarsSchema = z7.record(z7.string(), z7.coerce.string());
-var channelSchema = z7.object({
-  id: z7.number(),
-  name: z7.string(),
-  platform: z7.string()
+var envVarsSchema = z8.record(z8.string(), z8.coerce.string());
+var channelSchema = z8.object({
+  id: z8.number(),
+  name: z8.string(),
+  platform: z8.string()
 });
-var channelsResponseSchema = z7.object({
-  data: z7.array(channelSchema)
+var channelsResponseSchema = z8.object({
+  data: z8.array(channelSchema)
 });
 var CHANNEL_PLATFORM_ORDER = ["catalyst", "next", "bigcommerce"];
-function sortChannelsByPlatform(channels) {
-  return [...channels].sort((a, b) => {
+function sortChannelsByPlatform(channels2) {
+  return [...channels2].sort((a, b) => {
     const aIndex = CHANNEL_PLATFORM_ORDER.indexOf(a.platform);
     const bIndex = CHANNEL_PLATFORM_ORDER.indexOf(b.platform);
     if (aIndex === -1 && bIndex === -1) return 0;
@@ -1136,32 +1601,46 @@ function sortChannelsByPlatform(channels) {
 function channelPlatformLabel(platform) {
   return platform === "bigcommerce" ? "Stencil" : platform.charAt(0).toUpperCase() + platform.slice(1);
 }
-var initResponseSchema = z7.object({
-  data: z7.object({
-    storefront_api_token: z7.string(),
+var initResponseSchema = z8.object({
+  data: z8.object({
+    storefront_api_token: z8.string(),
     envVars: envVarsSchema
   })
 });
-var createChannelResponseSchema = z7.object({
-  data: z7.object({
-    id: z7.number(),
-    storefront_api_token: z7.string(),
+var createChannelResponseSchema = z8.object({
+  data: z8.object({
+    id: z8.number(),
+    storefront_api_token: z8.string(),
     envVars: envVarsSchema
   })
 });
-var eligibilityResponseSchema = z7.object({
-  data: z7.object({
-    eligible: z7.boolean(),
-    message: z7.string()
+var eligibilityResponseSchema = z8.object({
+  data: z8.object({
+    eligible: z8.boolean(),
+    message: z8.string()
   })
 });
-var channelSiteSchema = z7.object({
-  data: z7.object({
-    id: z7.number(),
-    url: z7.string(),
-    channel_id: z7.number()
+var siteUrlSchema = z8.object({
+  url: z8.string(),
+  type: z8.string()
+});
+var channelSiteSchema = z8.object({
+  data: z8.object({
+    id: z8.number(),
+    url: z8.string(),
+    channel_id: z8.number(),
+    ssl_status: z8.string().nullable().optional(),
+    is_checkout_url_customized: z8.boolean().optional(),
+    urls: z8.array(siteUrlSchema).optional()
   })
 });
+function assertChannelSettingsAuthorized(response, action) {
+  if (response.status === 401 || response.status === 403) {
+    throw new UserActionableError(
+      `${action} (${response.status}). Re-run \`catalyst auth login\` to refresh your access token with the store_channel_settings and store_sites scopes.`
+    );
+  }
+}
 async function getChannelInit(channelId, storeHash, accessToken, origin) {
   const response = await fetch(cliApiUrl(origin, storeHash, `/channels/${channelId}/init`), {
     method: "GET",
@@ -1194,358 +1673,196 @@ async function createChannel(name, storefrontLocale, additionalLocales, installS
       devOrigin: "http://localhost:3000",
       storefrontLanguage: storefrontLocale,
       additionalLocales
-    })
-  });
-  if (!response.ok) {
-    throw await httpError(response, "Failed to create channel");
-  }
-  const { data } = createChannelResponseSchema.parse(await response.json());
-  return {
-    channelId: data.id,
-    storefrontToken: data.storefront_api_token,
-    envVars: data.envVars
-  };
-}
-async function fetchAvailableChannels(storeHash, accessToken, apiHost) {
-  const response = await fetch(
-    channelsUrl(storeHash, apiHost, { available: "true", type: "storefront" }),
-    {
-      method: "GET",
-      headers: {
-        "X-Auth-Token": accessToken,
-        "X-Correlation-Id": getTelemetry().correlationId,
-        Accept: "application/json"
-      }
-    }
-  );
-  assertAuthorized(response);
-  if (!response.ok) {
-    throw await httpError(response, "Failed to fetch channels");
-  }
-  return channelsResponseSchema.parse(await response.json()).data;
-}
-async function updateChannelSiteUrl(channelId, siteUrl, storeHash, accessToken, apiHost) {
-  const response = await fetch(
-    `https://${apiHost}/stores/${storeHash}/v3/channels/${channelId}/site`,
-    {
-      method: "PUT",
-      headers: {
-        "X-Auth-Token": accessToken,
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "X-Correlation-Id": getTelemetry().correlationId
-      },
-      body: JSON.stringify({ url: siteUrl })
-    }
-  );
-  if (response.status === 401 || response.status === 403) {
-    throw new UserActionableError(
-      `Failed to update channel site (${response.status}). Re-run \`catalyst auth login\` to refresh your access token with the store_channel_settings scope.`
-    );
-  }
-  if (!response.ok) {
-    throw await httpError(response, "Failed to update channel site");
-  }
-  const res = await response.json();
-  const { data } = channelSiteSchema.parse(res);
-  return { id: data.id, url: data.url, channelId: data.channel_id };
-}
-
-// src/cli/lib/commerce-hosting.ts
-import { confirm as confirm2, input as input2, select, Separator } from "@inquirer/prompts";
-import { colorize as colorize3 } from "consola/utils";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
-import { dirname as dirname2, join as join5 } from "path";
-import { z as z8 } from "zod";
-
-// src/cli/lib/sort-package-json.ts
-var FIELD_ORDER = [
-  "name",
-  "description",
-  "version",
-  "private",
-  "engines",
-  "scripts",
-  "dependencies",
-  "devDependencies"
-];
-function sortPackageJsonFields(pkg) {
-  const ordered = {};
-  FIELD_ORDER.forEach((field) => {
-    if (field in pkg) {
-      ordered[field] = pkg[field];
-    }
-  });
-  Object.keys(pkg).forEach((key) => {
-    if (!(key in ordered)) {
-      ordered[key] = pkg[key];
-    }
-  });
-  return ordered;
-}
-
-// src/cli/lib/commerce-hosting.ts
-var OPENNEXT_CLOUDFLARE_VERSION = "1.17.3";
-var corePackageJsonSchema = z8.looseObject({
-  dependencies: z8.record(z8.string(), z8.string()).optional()
-});
-var writeJson = (path, value) => {
-  mkdirSync(dirname2(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`);
-};
-var convertProxyToMiddleware = (projectDir) => {
-  const proxyPath = join5(projectDir, "proxy.ts");
-  const middlewarePath = join5(projectDir, "middleware.ts");
-  if (!existsSync3(proxyPath)) return;
-  const contents = readFileSync2(proxyPath, "utf-8").replace("export const proxy", "export const middleware").replace("export const config = {", "export const config = {\n  runtime: 'experimental-edge',");
-  writeFileSync(middlewarePath, contents);
-  unlinkSync(proxyPath);
-};
-var cleanupCloudflareIncompatibilities = async (projectDir) => {
-  const instrumentationPath = join5(projectDir, "instrumentation.ts");
-  if (!existsSync3(instrumentationPath)) return;
-  if (!process.stdin.isTTY) {
-    consola.warn(
-      "instrumentation.ts is present and may be incompatible with the Cloudflare Workers bundle (the default @vercel/otel scaffolding throws at cold start under workerd). Skipping automatic cleanup in non-interactive mode \u2014 re-run interactively to remove it, or delete/gate it manually."
-    );
-    return;
-  }
-  const shouldRemove = await confirm2({
-    message: 'Catalyst found instrumentation.ts, which is incompatible with the Cloudflare Workers bundle when it uses @vercel/otel (causes "Failed to prepare server" at cold start). Remove it and drop @vercel/otel from package.json?',
-    default: true
-  });
-  if (!shouldRemove) {
-    consola.info(
-      'Leaving instrumentation.ts in place. The Cloudflare worker will continue to log "Failed to prepare server" at cold start until this is resolved manually.'
-    );
-    return;
-  }
-  unlinkSync(instrumentationPath);
-  consola.info("Removed instrumentation.ts (incompatible with Cloudflare Workers).");
-  const corePackageJsonPath = join5(projectDir, "package.json");
-  if (existsSync3(corePackageJsonPath)) {
-    const pkg = corePackageJsonSchema.parse(JSON.parse(readFileSync2(corePackageJsonPath, "utf-8")));
-    if (pkg.dependencies && "@vercel/otel" in pkg.dependencies) {
-      const { "@vercel/otel": _removedVercelOtel, ...preservedDeps } = pkg.dependencies;
-      pkg.dependencies = preservedDeps;
-      writeJson(corePackageJsonPath, sortPackageJsonFields(pkg));
-      consola.info("Dropped @vercel/otel from package.json.");
-    }
-  }
-};
-var setupCommerceHosting = async ({
-  projectDir,
-  projectUuid,
-  storeHash,
-  accessToken
-}) => {
-  await cleanupCloudflareIncompatibilities(projectDir);
-  const corePackageJsonPath = join5(projectDir, "package.json");
-  const pkg = corePackageJsonSchema.parse(JSON.parse(readFileSync2(corePackageJsonPath, "utf-8")));
-  pkg.dependencies = {
-    ...pkg.dependencies,
-    "@opennextjs/cloudflare": OPENNEXT_CLOUDFLARE_VERSION
-  };
-  writeJson(corePackageJsonPath, sortPackageJsonFields(pkg));
-  const projectJson = {
-    projectUuid,
-    framework: "catalyst"
-  };
-  if (storeHash) projectJson.storeHash = storeHash;
-  if (accessToken) projectJson.accessToken = accessToken;
-  writeJson(join5(projectDir, ".bigcommerce", "project.json"), projectJson);
-  convertProxyToMiddleware(projectDir);
-};
-var NoLinkedProjectError = class extends Error {
-  constructor() {
-    super("No infrastructure project linked: user declined to create one.");
-    this.name = "NoLinkedProjectError";
-  }
-};
-async function promptForNewProjectName(api) {
-  const newProjectName = await input2({ message: "Enter a name for the new project:" });
-  const data = await createProject(newProjectName, api.storeHash, api.accessToken, api.apiHost);
-  consola.success(`Project "${data.name}" created successfully.`);
-  return { uuid: data.uuid, name: data.name, deployment_hostnames: [] };
+    })
+  });
+  if (!response.ok) {
+    throw await httpError(response, "Failed to create channel");
+  }
+  const { data } = createChannelResponseSchema.parse(await response.json());
+  return {
+    channelId: data.id,
+    storefrontToken: data.storefront_api_token,
+    envVars: data.envVars
+  };
 }
-async function selectOrCreateInfrastructureProject(api, linkedProjectUuid) {
-  consola.start("Fetching projects...");
-  const existingProjects = await fetchProjects(api.storeHash, api.accessToken, api.apiHost);
-  consola.success("Projects fetched.");
-  if (existingProjects.length === 0) {
-    const shouldCreate = await confirm2({
-      message: "There are not any hosting projects that you can link to yet. Would you like to create one?",
-      default: true
-    });
-    if (!shouldCreate) {
-      throw new NoLinkedProjectError();
+async function fetchAvailableChannels(storeHash, accessToken, apiHost) {
+  const response = await fetch(
+    channelsUrl(storeHash, apiHost, { available: "true", type: "storefront" }),
+    {
+      method: "GET",
+      headers: {
+        "X-Auth-Token": accessToken,
+        "X-Correlation-Id": getTelemetry().correlationId,
+        Accept: "application/json"
+      }
     }
-    return promptForNewProjectName(api);
+  );
+  assertAuthorized(response);
+  if (!response.ok) {
+    throw await httpError(response, "Failed to fetch channels");
   }
-  const choices = [
-    ...existingProjects.map((p) => ({
-      name: p.uuid === linkedProjectUuid ? `${p.name} ${colorize3("green", "[linked]")}` : p.name,
-      value: p.uuid,
-      description: p.uuid
-    })),
+  return channelsResponseSchema.parse(await response.json()).data;
+}
+async function updateChannelSiteUrl(channelId, siteUrl, storeHash, accessToken, apiHost) {
+  const response = await fetch(
+    `https://${apiHost}/stores/${storeHash}/v3/channels/${channelId}/site`,
     {
-      name: "Create a new project",
-      value: "create",
-      description: "Create a new hosting project for this Catalyst storefront."
+      method: "PUT",
+      headers: {
+        "X-Auth-Token": accessToken,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "X-Correlation-Id": getTelemetry().correlationId
+      },
+      body: JSON.stringify({ url: siteUrl })
     }
-  ];
-  const selected = await select({
-    message: "Select a project or create a new project (Press <enter> to select).",
-    choices
-  });
-  if (selected === "create") {
-    return promptForNewProjectName(api);
-  }
-  const matched = existingProjects.find((p) => p.uuid === selected);
-  if (!matched) {
-    throw new Error(`Selected project ${String(selected)} not found in fetched list.`);
+  );
+  assertChannelSettingsAuthorized(response, "Failed to update channel site");
+  if (!response.ok) {
+    throw await httpError(response, "Failed to update channel site");
   }
-  return matched;
+  const res = await response.json();
+  const { data } = channelSiteSchema.parse(res);
+  return { id: data.id, url: data.url, channelId: data.channel_id };
 }
-async function promptForCommerceHostingProject(api, defaultName, autoUseDefaultName, useExistingOnCollision) {
-  const existingProjects = await fetchProjects(api.storeHash, api.accessToken, api.apiHost);
-  const takenNames = existingProjects.map((project2) => project2.name);
-  if (autoUseDefaultName) {
-    return autoCreateCommerceHostingProject(
-      api,
-      defaultName,
-      existingProjects,
-      useExistingOnCollision
-    );
-  }
-  const conflict = existingProjects.find(
-    (project2) => project2.name.toLowerCase() === defaultName.toLowerCase()
+var toChannelSiteDetails = (data) => ({
+  id: data.id,
+  url: data.url,
+  channelId: data.channel_id,
+  sslStatus: data.ssl_status ?? null,
+  isCheckoutUrlCustomized: data.is_checkout_url_customized ?? false,
+  urls: data.urls ?? []
+});
+function findChannelSiteUrl(site, type) {
+  return site.urls.find((entry) => entry.type === type)?.url;
+}
+async function getChannelSite(channelId, storeHash, accessToken, apiHost) {
+  const response = await fetch(
+    `https://${apiHost}/stores/${storeHash}/v3/channels/${channelId}/site`,
+    { method: "GET", headers: authHeaders2(accessToken) }
   );
-  if (!conflict) {
-    return autoCreateCommerceHostingProject(
-      api,
-      defaultName,
-      existingProjects,
-      useExistingOnCollision
-    );
-  }
-  const hasOtherProjects = existingProjects.length > 1;
-  const choices = [
-    { name: `Use "${conflict.name}"`, value: "use-named" }
-  ];
-  if (hasOtherProjects) {
-    choices.push({ name: "Select from my projects", value: "select-from-list" });
+  assertChannelSettingsAuthorized(response, "Failed to fetch channel site");
+  if (!response.ok) {
+    throw await httpError(response, "Failed to fetch channel site");
   }
-  choices.push({ name: "Create a new project", value: "create" });
-  const action = await select({
-    message: hasOtherProjects ? `It looks like you already have an existing Commerce Hosting project named "${conflict.name}". Would you like to use it, select from your projects, or create a new one?` : `It looks like you already have an existing Commerce Hosting project named "${conflict.name}". Would you like to use it, or create a new one?`,
-    choices
+  const res = await response.json();
+  return toChannelSiteDetails(channelSiteSchema.parse(res).data);
+}
+var checkoutUrlPath = (storeHash, apiHost, channelId) => `https://${apiHost}/stores/${storeHash}/v3/channels/${channelId}/site/checkout-url`;
+async function updateChannelCheckoutUrl(channelId, checkoutUrl, storeHash, accessToken, apiHost) {
+  const response = await fetch(checkoutUrlPath(storeHash, apiHost, channelId), {
+    method: "PUT",
+    headers: { ...authHeaders2(accessToken), "Content-Type": "application/json" },
+    body: JSON.stringify({ url: checkoutUrl })
   });
-  if (action === "use-named") {
-    consola.success(`Using existing Commerce Hosting project "${conflict.name}"`);
-    return conflict;
-  }
-  if (action === "create") {
-    return promptAndCreateCommerceHostingProject(api, takenNames, defaultName);
+  assertChannelSettingsAuthorized(response, "Failed to update channel checkout URL");
+  if (!response.ok) {
+    throw await httpError(response, "Failed to update channel checkout URL");
   }
-  const selected = await select({
-    message: "Which Commerce Hosting project would you like to use?",
-    choices: [
-      ...existingProjects.map((project2) => ({
-        name: project2.name,
-        value: project2,
-        description: project2.uuid
-      })),
-      new Separator(),
-      { name: "Create a new project", value: "create-new" }
-    ]
+  const res = await response.json();
+  return toChannelSiteDetails(channelSiteSchema.parse(res).data);
+}
+async function deleteChannelCheckoutUrl(channelId, storeHash, accessToken, apiHost) {
+  const response = await fetch(checkoutUrlPath(storeHash, apiHost, channelId), {
+    method: "DELETE",
+    headers: authHeaders2(accessToken)
   });
-  if (selected === "create-new") {
-    return promptAndCreateCommerceHostingProject(api, takenNames, defaultName);
+  assertChannelSettingsAuthorized(response, "Failed to remove channel checkout URL");
+  if (!response.ok) {
+    throw await httpError(response, "Failed to remove channel checkout URL");
   }
-  consola.success(`Using existing Commerce Hosting project "${selected.name}"`);
-  return selected;
 }
-async function promptAndCreateCommerceHostingProject(api, takenNames, defaultName) {
-  const projectName = await input2({
-    message: "What would you like to name your Commerce Hosting project?",
-    default: defaultName,
-    validate: (value) => {
-      const trimmed = value.trim();
-      if (!trimmed) return "Project name is required";
-      const conflict = takenNames.find((taken) => taken.toLowerCase() === trimmed.toLowerCase());
-      if (conflict) {
-        return `A Commerce Hosting project named "${conflict}" already exists`;
-      }
-      return true;
-    },
-    theme: {
-      style: {
-        help: () => colorize3(
-          "dim",
-          "(The project that hosts your storefront on Commerce \u2014 often matches your folder name.)"
-        )
-      }
-    }
-  });
+
+// src/cli/lib/checkout-url.ts
+import { getDomain } from "tldts";
+var normalizeHostname = (hostname) => hostname.toLowerCase().replace(/\.$/, "");
+var parentDomain = (hostname) => hostname.split(".").slice(1).join(".");
+var isSubdomainOf = (hostname, parent) => hostname.endsWith(`.${parent}`);
+function hostnameOf(url) {
   try {
-    const created = await createProject(
-      projectName.trim(),
-      api.storeHash,
-      api.accessToken,
-      api.apiHost
+    return new URL(url).hostname;
+  } catch {
+    return void 0;
+  }
+}
+function sharesMainDomain(a, b) {
+  const first = getDomain(normalizeHostname(a));
+  return first !== null && first === getDomain(normalizeHostname(b));
+}
+function suggestCheckoutUrl(storefrontUrl) {
+  const host = hostnameOf(storefrontUrl);
+  if (!host) return void 0;
+  const base = normalizeHostname(host).replace(/^www\./, "");
+  return `https://checkout.${base}`;
+}
+function normalizeCheckoutUrl(value) {
+  const withScheme = /^[a-z][a-z\d+.-]*:\/\//i.test(value) ? value : `https://${value}`;
+  let parsed;
+  try {
+    parsed = new URL(withScheme);
+  } catch {
+    throw new UserActionableError(
+      `"${value}" is not a valid URL. Pass a hostname or an https URL, e.g. https://checkout.example.com.`
+    );
+  }
+  if (parsed.protocol !== "https:") {
+    throw new UserActionableError(
+      `The checkout URL must use https, but "${value}" uses ${parsed.protocol.replace(":", "")}.`
     );
-    consola.success(`Commerce Hosting project "${created.name}" created successfully`);
-    return { uuid: created.uuid, name: created.name, deployment_hostnames: [] };
-  } catch (error) {
-    if (error instanceof InfrastructureProjectValidationError) {
-      consola.error(error.message);
-      return promptAndCreateCommerceHostingProject(api, takenNames, defaultName);
-    }
-    throw error;
   }
+  return parsed.origin;
 }
-async function resolveCollisionChoice(existingName, useExistingOnCollision) {
-  if (useExistingOnCollision === true) return true;
-  if (!process.stdin.isTTY) return false;
-  return select({
-    message: `A Commerce Hosting project named "${existingName}" already exists. Use the existing project?`,
-    choices: [
-      { name: "Yes", value: true },
-      { name: "No", value: false }
-    ]
-  });
+async function isManagedHostingHostname(hostname, context) {
+  try {
+    const projects2 = await fetchProjects(context.storeHash, context.accessToken, context.apiHost);
+    const zones = projects2.flatMap((project) => project.deployment_hostnames).map((deploymentHostname) => parentDomain(normalizeHostname(deploymentHostname))).filter((zone) => zone.includes("."));
+    if (zones.length === 0) return void 0;
+    const host = normalizeHostname(hostname);
+    return zones.some((zone) => host === zone || isSubdomainOf(host, zone));
+  } catch {
+    return void 0;
+  }
 }
-async function autoCreateCommerceHostingProject(api, name, existingProjects, useExistingOnCollision) {
-  const existing = existingProjects.find(
-    (project2) => project2.name.toLowerCase() === name.toLowerCase()
+async function warnOnCrossDomainCheckout(site, context) {
+  const storefrontUrl = findChannelSiteUrl(site, "primary") ?? site.url;
+  const storefrontHost = hostnameOf(storefrontUrl);
+  const checkoutUrl = findChannelSiteUrl(site, "checkout");
+  if (!storefrontHost) return { crossDomain: false };
+  const suggestion = suggestCheckoutUrl(storefrontUrl);
+  const checkoutHost = checkoutUrl ? hostnameOf(checkoutUrl) : void 0;
+  if (!checkoutHost || sharesMainDomain(storefrontHost, checkoutHost)) {
+    return { crossDomain: false, suggestion };
+  }
+  if (site.isCheckoutUrlCustomized) {
+    consola.warn(
+      `This channel's checkout URL (${checkoutHost}) is on a different domain than its storefront (${storefrontHost}) \u2014 most likely a storefront URL change left it behind.`
+    );
+  } else {
+    consola.warn(
+      `Checkout is on the default channel's domain (${checkoutHost}), not this channel's storefront (${storefrontHost}).`
+    );
+  }
+  consola.info(
+    "Shopper sessions and carts may not carry into checkout in browsers that restrict cross-domain cookies."
   );
-  if (existing) {
-    const shouldUseExisting = await resolveCollisionChoice(existing.name, useExistingOnCollision);
-    if (shouldUseExisting) {
-      consola.success(`Using existing Commerce Hosting project "${existing.name}"`);
-      return existing;
-    }
-    consola.error(
-      "Not reusing the existing project. Re-run with a different --project-name, or pass --use-existing to reuse it."
+  const storefrontOnManagedZone = await isManagedHostingHostname(storefrontHost, context);
+  const report = { crossDomain: true, storefrontOnManagedZone, suggestion };
+  if (storefrontOnManagedZone === false) {
+    consola.info(
+      `To put checkout on this channel's own domain, point ${suggestion?.replace("https://", "") ?? "your checkout subdomain"} at BigCommerce and provision a certificate for it there.`
     );
-    process.exit(1);
+    return report;
   }
-  try {
-    const created = await createProject(name, api.storeHash, api.accessToken, api.apiHost);
-    consola.success(`Commerce Hosting project "${created.name}" created successfully`);
-    return { uuid: created.uuid, name: created.name, deployment_hostnames: [] };
-  } catch (error) {
-    if (error instanceof InfrastructureProjectValidationError) {
-      consola.error(
-        `Failed to create Commerce Hosting project "${name}": ${error.message}
-Re-run with a different --project-name.`
-      );
-      process.exit(1);
-    }
-    throw error;
+  if (storefrontOnManagedZone === true) {
+    consola.info(
+      `${storefrontHost} is an auto-generated deployment hostname, and a checkout subdomain of one cannot be issued a certificate \u2014 so no checkout URL can be set for this channel until its storefront is on a custom domain. Add one with \`catalyst domains add\`.`
+    );
+    return report;
   }
+  consola.info(
+    "BigCommerce requires the checkout URL to share a main domain with the storefront. Set one with `catalyst channels update --checkout-url <domain>` once it points at BigCommerce."
+  );
+  return report;
 }
 
 // src/cli/lib/channel-site-flow.ts
@@ -1556,8 +1873,8 @@ async function resolveProject(options) {
     apiHost: options.apiHost
   };
   if (options.projectUuid) {
-    const projects = await fetchProjects(api.storeHash, api.accessToken, api.apiHost);
-    const matched = projects.find((p) => p.uuid === options.projectUuid);
+    const projects2 = await fetchProjects(api.storeHash, api.accessToken, api.apiHost);
+    const matched = projects2.find((p) => p.uuid === options.projectUuid);
     if (matched) return matched;
     consola.warn(
       `Project ${options.projectUuid} not found on this store. Pick another to continue.`
@@ -1570,13 +1887,13 @@ async function resolveChannel(options) {
     return { id: options.channelId };
   }
   consola.start("Fetching channels...");
-  const channels = await fetchAvailableChannels(
+  const channels2 = await fetchAvailableChannels(
     options.storeHash,
     options.accessToken,
     options.apiHost
   );
   consola.success("Channels fetched.");
-  const catalystChannels = channels.filter((c) => c.platform === "catalyst");
+  const catalystChannels = channels2.filter((c) => c.platform === "catalyst");
   if (catalystChannels.length === 0) {
     throw new Error(
       "No Catalyst channels found on this store. Create one with `catalyst create` and try again."
@@ -1593,19 +1910,19 @@ async function resolveChannel(options) {
   const matched = catalystChannels.find((c) => c.id === id);
   return { id, name: matched?.name };
 }
-async function resolveHostname(project2, options) {
+async function resolveHostname(project, options) {
   if (options.hostname) {
     return options.hostname;
   }
-  if (project2.deployment_hostnames.length === 0) {
+  if (project.deployment_hostnames.length === 0) {
     throw new Error(
-      `Project "${project2.name}" has no deployment hostnames yet. Run \`catalyst deploy\` first to create one.`
+      `Project "${project.name}" has no deployment hostnames yet. Run \`catalyst deploy\` first to create one.`
     );
   }
   const ordered = options.preferHostname ? [
-    ...project2.deployment_hostnames.filter((h) => h === options.preferHostname),
-    ...project2.deployment_hostnames.filter((h) => h !== options.preferHostname)
-  ] : project2.deployment_hostnames;
+    ...project.deployment_hostnames.filter((h) => h === options.preferHostname),
+    ...project.deployment_hostnames.filter((h) => h !== options.preferHostname)
+  ] : project.deployment_hostnames;
   const selected = await select2({
     message: "Select the hostname to point the channel at.",
     choices: ordered.map((h) => ({ name: h, value: h }))
@@ -1613,23 +1930,80 @@ async function resolveHostname(project2, options) {
   return selected;
 }
 async function runChannelSiteUrlFlow(options) {
-  const project2 = await resolveProject(options);
-  const channel2 = await resolveChannel(options);
-  const hostname = await resolveHostname(project2, options);
+  const project = await resolveProject(options);
+  const channel = await resolveChannel(options);
+  const hostname = await resolveHostname(project, options);
   const siteUrl = hostname.startsWith("https://") ? hostname : `https://${hostname}`;
   await updateChannelSiteUrl(
-    channel2.id,
+    channel.id,
     siteUrl,
     options.storeHash,
     options.accessToken,
     options.apiHost
   );
-  const channelLabel = channel2.name ? `"${channel2.name}" (${channel2.id})` : String(channel2.id);
+  const channelLabel = channel.name ? `"${channel.name}" (${channel.id})` : String(channel.id);
   consola.success(`Updated channel ${channelLabel} site URL to ${siteUrl}.`);
+  try {
+    const site = await getChannelSite(
+      channel.id,
+      options.storeHash,
+      options.accessToken,
+      options.apiHost
+    );
+    const report = await warnOnCrossDomainCheckout(site, {
+      storeHash: options.storeHash,
+      accessToken: options.accessToken,
+      apiHost: options.apiHost
+    });
+    if (report.crossDomain && report.storefrontOnManagedZone !== true) {
+      consola.info("Set a checkout URL for this channel with:");
+      consola.log(
+        `  catalyst channels update --channel-id ${channel.id} --checkout-url ${report.suggestion ?? "<domain>"}`
+      );
+    }
+  } catch {
+  }
+  return { channelId: channel.id };
+}
+
+// src/cli/lib/channel-checkout-url-flow.ts
+async function runChannelCheckoutUrlFlow(options) {
+  const channel = options.channelId !== void 0 ? { id: options.channelId, name: options.channelName } : await resolveChannel(options);
+  const label = channel.name ? `"${channel.name}" (${channel.id})` : String(channel.id);
+  let storefrontUrl = options.storefrontUrl;
+  if (!storefrontUrl) {
+    const site = await getChannelSite(
+      channel.id,
+      options.storeHash,
+      options.accessToken,
+      options.apiHost
+    );
+    storefrontUrl = findChannelSiteUrl(site, "primary") ?? site.url;
+    const currentCheckoutUrl = findChannelSiteUrl(site, "checkout");
+    consola.info(`Channel ${label} storefront is ${storefrontUrl}.`);
+    if (currentCheckoutUrl) {
+      consola.info(
+        `Checkout is currently ${currentCheckoutUrl}${site.isCheckoutUrlCustomized ? "" : ", inherited from the default channel"}.`
+      );
+    }
+  }
+  const answer = options.url ?? await input3({
+    message: "Checkout URL for this channel (must share a main domain with the storefront)",
+    default: suggestCheckoutUrl(storefrontUrl)
+  });
+  const checkoutUrl = normalizeCheckoutUrl(answer);
+  await updateChannelCheckoutUrl(
+    channel.id,
+    checkoutUrl,
+    options.storeHash,
+    options.accessToken,
+    options.apiHost
+  );
+  consola.success(`Updated channel ${label} checkout URL to ${checkoutUrl}.`);
 }
 
 // src/cli/lib/create-channel-flow.ts
-import { checkbox, input as input3, select as select3 } from "@inquirer/prompts";
+import { checkbox, input as input4, select as select3 } from "@inquirer/prompts";
 import { colorize as colorize4 } from "consola/utils";
 
 // src/cli/lib/localization.ts
@@ -1704,7 +2078,7 @@ async function runCreateChannelFlow(options) {
       throw new UserActionableError(nameError);
     }
   }
-  const name = options.name ?? await input3({
+  const name = options.name ?? await input4({
     message: "What would you like to name your new channel?",
     validate: (value) => getChannelNameError(value) ?? true
   });
@@ -1749,7 +2123,8 @@ async function runCreateChannelFlow(options) {
       { name: "No", value: false }
     ]
   });
-  return createChannel(
+  consola.start("Creating channel...");
+  const channel = await createChannel(
     name,
     storefrontLocale,
     additionalLocales,
@@ -1758,19 +2133,21 @@ async function runCreateChannelFlow(options) {
     accessToken,
     cliApiOrigin
   );
+  consola.success("Channel created.");
+  return channel;
 }
 
 // src/cli/lib/env-config.ts
 var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-var parseEnvAssignment = (input6) => {
-  const separatorIndex = input6.indexOf("=");
+var parseEnvAssignment = (input7) => {
+  const separatorIndex = input7.indexOf("=");
   if (separatorIndex === -1) {
-    throw new Error(`Invalid env var format: ${input6}. Expected format: KEY=VALUE`);
+    throw new Error(`Invalid env var format: ${input7}. Expected format: KEY=VALUE`);
   }
-  const key = input6.slice(0, separatorIndex).trim();
-  const value = input6.slice(separatorIndex + 1).trim();
+  const key = input7.slice(0, separatorIndex).trim();
+  const value = input7.slice(separatorIndex + 1).trim();
   if (!key || !value) {
-    throw new Error(`Invalid env var format: ${input6}. Expected format: KEY=VALUE`);
+    throw new Error(`Invalid env var format: ${input7}. Expected format: KEY=VALUE`);
   }
   if (!ENV_KEY_PATTERN.test(key)) {
     throw new Error(
@@ -1810,7 +2187,7 @@ function resolveCredentials(options, config2) {
 // src/cli/lib/write-env.ts
 import { outputFileSync } from "fs-extra/esm";
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var ACTIVE_KEY_LINE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
 var keyFromLine = (line) => {
   const match = ACTIVE_KEY_LINE.exec(line);
@@ -1827,8 +2204,8 @@ var parseEnvValues = (contents) => {
   return values;
 };
 var writeEnv = (projectDir, envVars) => {
-  const examplePath = join6(projectDir, ".env.example");
-  const localPath = join6(projectDir, ".env.local");
+  const examplePath = join7(projectDir, ".env.example");
+  const localPath = join7(projectDir, ".env.local");
   const existingLocal = existsSync4(localPath) ? parseEnvValues(readFileSync3(localPath, "utf-8")) : /* @__PURE__ */ new Map();
   const resolve2 = (key) => {
     if (key in envVars && envVars[key] !== "") {
@@ -1874,7 +2251,7 @@ var writeEnv = (projectDir, envVars) => {
 `);
 };
 
-// src/cli/commands/channel.ts
+// src/cli/commands/channels.ts
 var parseChannelId = (value) => {
   const parsed = Number.parseInt(value, 10);
   if (Number.isNaN(parsed)) {
@@ -1882,6 +2259,22 @@ var parseChannelId = (value) => {
   }
   return parsed;
 };
+var parseCheckoutUrl = (value) => {
+  try {
+    return normalizeCheckoutUrl(value);
+  } catch (error) {
+    throw new InvalidArgumentError2(error instanceof Error ? error.message : String(error));
+  }
+};
+var CHECKOUT_URL_NOTES = `
+Checkout is hosted by BigCommerce, so a checkout URL must be a domain you have
+pointed at BigCommerce with a certificate provisioned there \u2014 not one added with
+\`catalyst domains add\`, which only routes traffic to this project.
+
+BigCommerce also requires the checkout URL to share a main domain with the
+channel's storefront URL, so that sessions carry between the two. This means a
+custom checkout URL is only possible on a custom storefront domain; channels on
+an auto-generated deployment hostname use the shared checkout domain.`;
 async function resolveCredentialsWithLogin(options, config2, apiHost) {
   const storeHash = options.storeHash ?? config2.get("storeHash");
   const accessToken = options.accessToken ?? config2.get("accessToken");
@@ -1900,17 +2293,29 @@ async function resolveCredentialsWithLogin(options, config2, apiHost) {
     throw error;
   }
 }
-var update = new Command3("update").configureHelp({ showGlobalOptions: true }).description(
-  "Update a BigCommerce channel's site URL to point at one of your project's deployment hostnames."
-).addHelpText(
+var update = new Command3("update").configureHelp({ showGlobalOptions: true }).description("Update a BigCommerce channel's storefront and checkout URLs.").addHelpText(
   "after",
-  `
+  `${CHECKOUT_URL_NOTES}
+
+With no flags, this updates the storefront URL and prompts for the hostname.
+Pass a checkout flag on its own to change only the checkout URL, leaving the
+storefront URL alone.
+
 Examples:
   # Pick a channel and hostname interactively
-  $ catalyst channel update
+  $ catalyst channels update
+
+  # Point the storefront at a deployment hostname
+  $ catalyst channels update --channel-id 123 --hostname my-storefront.example.com
+
+  # Set both at once
+  $ catalyst channels update --channel-id 123 --hostname my-storefront.example.com --checkout-url checkout.example.com
+
+  # Change only the checkout URL
+  $ catalyst channels update --channel-id 123 --checkout-url checkout.example.com
 
-  # Skip both prompts
-  $ catalyst channel update --channel-id 123 --hostname my-storefront.example.com`
+  # Fall back to the shared checkout domain
+  $ catalyst channels update --channel-id 123 --remove-checkout-url`
 ).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).addOption(projectUuidOption()).addOption(
   new Option3(
     "--channel-id <id>",
@@ -1921,29 +2326,68 @@ Examples:
     "--hostname <hostname>",
     "Skip the hostname prompt and use this hostname directly. Must be one of the project's deployment_hostnames."
   )
+).addOption(
+  new Option3(
+    "--checkout-url <url>",
+    "Set the channel's checkout URL. Must share a main domain with the storefront URL."
+  ).argParser(parseCheckoutUrl)
+).addOption(
+  new Option3(
+    "--remove-checkout-url",
+    "Remove the channel's custom checkout URL so checkout falls back to the shared checkout domain."
+  ).conflicts("checkoutUrl")
 ).action(async (options) => {
   const config2 = getProjectConfig();
   const apiHost = resolveApiHost(options, config2);
   const { storeHash, accessToken } = resolveCredentials(options, config2);
   await getTelemetry().identify(storeHash);
-  try {
-    await runChannelSiteUrlFlow({
-      storeHash,
-      accessToken,
-      apiHost,
-      projectUuid: options.projectUuid ?? config2.get("projectUuid"),
-      channelId: options.channelId,
-      hostname: options.hostname
-    });
-  } catch (error) {
-    if (error instanceof NoLinkedProjectError) {
-      consola.info(
-        "When you're ready to create a project, run `catalyst project create` or re-run `catalyst channel update`."
+  const touchesCheckout = options.checkoutUrl !== void 0 || options.removeCheckoutUrl === true;
+  const updatesSiteUrl = options.hostname !== void 0 || !touchesCheckout;
+  let channelId = options.channelId;
+  if (updatesSiteUrl) {
+    try {
+      ({ channelId } = await runChannelSiteUrlFlow({
+        storeHash,
+        accessToken,
+        apiHost,
+        projectUuid: options.projectUuid ?? config2.get("projectUuid"),
+        channelId: options.channelId,
+        hostname: options.hostname
+      }));
+    } catch (error) {
+      if (error instanceof NoLinkedProjectError) {
+        consola.info(
+          "When you're ready to create a project, run `catalyst projects create` or re-run `catalyst channels update`."
+        );
+        process.exit(0);
+        return;
+      }
+      throw error;
+    }
+  }
+  if (touchesCheckout) {
+    const channel = channelId === void 0 ? await resolveChannel({ storeHash, accessToken, apiHost }) : { id: channelId, name: void 0 };
+    const label = channel.name ? `"${channel.name}" (${channel.id})` : String(channel.id);
+    if (options.checkoutUrl !== void 0) {
+      const updated = await updateChannelCheckoutUrl(
+        channel.id,
+        options.checkoutUrl,
+        storeHash,
+        accessToken,
+        apiHost
       );
-      process.exit(0);
-      return;
+      consola.success(`Updated channel ${label} checkout URL to ${options.checkoutUrl}.`);
+      reportChannelSite(updated);
+      await warnOnCrossDomainCheckout(updated, { storeHash, accessToken, apiHost });
+    } else {
+      await deleteChannelCheckoutUrl(channel.id, storeHash, accessToken, apiHost);
+      consola.success(
+        `Removed the custom checkout URL from channel ${label}. Checkout now uses the shared checkout domain.`
+      );
+      const reverted = await getChannelSite(channel.id, storeHash, accessToken, apiHost);
+      reportChannelSite(reverted);
+      await warnOnCrossDomainCheckout(reverted, { storeHash, accessToken, apiHost });
     }
-    throw error;
   }
   process.exit(0);
 });
@@ -1954,13 +2398,13 @@ var link = new Command3("link").configureHelp({ showGlobalOptions: true }).descr
   `
 Examples:
   # Pick a channel interactively (logs you in if needed)
-  $ catalyst channel link
+  $ catalyst channels link
 
   # Non-interactive
-  $ catalyst channel link --store-hash <hash> --access-token <token> --channel-id 123
+  $ catalyst channels link --store-hash <hash> --access-token <token> --channel-id 123
 
   # Append extra environment variables to .env.local
-  $ catalyst channel link --channel-id 123 --env MY_FLAG=1`
+  $ catalyst channels link --channel-id 123 --env MY_FLAG=1`
 ).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).addOption(loginUrlOption()).addOption(
   new Option3("--channel-id <id>", "Link this channel directly, skipping the picker.").argParser(
     parseChannelId
@@ -1976,7 +2420,7 @@ Examples:
   const credentials = await resolveCredentialsWithLogin(options, config2, apiHost);
   if (!credentials) {
     consola.info(
-      "Login aborted. Re-run `catalyst channel link` when you have your credentials ready."
+      "Login aborted. Re-run `catalyst channels link` when you have your credentials ready."
     );
     process.exit(0);
     return;
@@ -1986,8 +2430,8 @@ Examples:
   let channelId = options.channelId;
   let channelName;
   if (channelId === void 0) {
-    const channels = await fetchAvailableChannels(storeHash, accessToken, apiHost);
-    if (channels.length === 0) {
+    const availableChannels = await fetchAvailableChannels(storeHash, accessToken, apiHost);
+    if (availableChannels.length === 0) {
       consola.info(
         "No storefront channels found on this store. Create one with `catalyst create` and try again."
       );
@@ -1996,13 +2440,13 @@ Examples:
     }
     channelId = await select4({
       message: "Which channel would you like to link?",
-      choices: sortChannelsByPlatform(channels).map((c) => ({
+      choices: sortChannelsByPlatform(availableChannels).map((c) => ({
         name: c.name,
         value: c.id,
         description: channelPlatformLabel(c.platform)
       }))
     });
-    channelName = channels.find((c) => c.id === channelId)?.name;
+    channelName = availableChannels.find((c) => c.id === channelId)?.name;
   }
   const initData = await getChannelInit(channelId, storeHash, accessToken, options.cliApiOrigin);
   const envVars = { ...initData.envVars };
@@ -2027,13 +2471,13 @@ var create = new Command3("create").configureHelp({ showGlobalOptions: true }).d
   `
 Examples:
   # Create a channel interactively (logs you in if needed)
-  $ catalyst channel create
+  $ catalyst channels create
 
   # Non-interactive, and link it to this project afterwards
-  $ catalyst channel create --name "My Store" --locale en --no-sample-data --link
+  $ catalyst channels create --name "My Store" --locale en --no-sample-data --link
 
   # Add additional storefront languages (max 4)
-  $ catalyst channel create --name "My Store" --additional-locales es fr`
+  $ catalyst channels create --name "My Store" --additional-locales es fr`
 ).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).addOption(loginUrlOption()).option("--name <name>", "Name for the new channel. Skips the name prompt.").option(
   "--locale <locale>",
   'Default storefront locale (e.g. "en"). Skips the default-language prompt.'
@@ -2056,7 +2500,7 @@ Examples:
   const credentials = await resolveCredentialsWithLogin(options, config2, apiHost);
   if (!credentials) {
     consola.info(
-      "Login aborted. Re-run `catalyst channel create` when you have your credentials ready."
+      "Login aborted. Re-run `catalyst channels create` when you have your credentials ready."
     );
     process.exit(0);
     return;
@@ -2101,38 +2545,106 @@ Examples:
   }
   process.exit(0);
 });
-var channel = new Command3("channel").configureHelp({ showGlobalOptions: true }).description("Manage BigCommerce channels.").addCommand(create).addCommand(link).addCommand(update);
+var CHECKOUT_LABEL_WIDTH = "Storefront".length;
+var row = (label, value) => `  ${label.padEnd(CHECKOUT_LABEL_WIDTH)}  ${value}`;
+function reportChannelSite(site) {
+  const canonical = findChannelSiteUrl(site, "canonical");
+  const checkout = findChannelSiteUrl(site, "checkout");
+  consola.log(row("Storefront", findChannelSiteUrl(site, "primary") ?? site.url));
+  if (canonical) {
+    consola.log(row("Canonical", canonical));
+  }
+  consola.log(row("Checkout", checkout ?? "(none)"));
+  if (!site.isCheckoutUrlCustomized) {
+    consola.info(
+      "This channel has no checkout URL of its own, so checkout uses the default channel's primary URL."
+    );
+  }
+}
+async function resolveChannelTarget(options) {
+  const config2 = getProjectConfig();
+  const apiHost = resolveApiHost(options, config2);
+  const { storeHash, accessToken } = resolveCredentials(options, config2);
+  await getTelemetry().identify(storeHash);
+  const channel = await resolveChannel({
+    storeHash,
+    accessToken,
+    apiHost,
+    channelId: options.channelId
+  });
+  return {
+    config: config2,
+    apiHost,
+    storeHash,
+    accessToken,
+    channel,
+    label: channel.name ? `"${channel.name}" (${channel.id})` : String(channel.id)
+  };
+}
+var info = new Command3("info").configureHelp({ showGlobalOptions: true }).description("Show a channel's site URLs \u2014 storefront, canonical and checkout.").addHelpText(
+  "after",
+  `${CHECKOUT_URL_NOTES}
+
+Examples:
+  # Pick a channel interactively; the same as bare \`catalyst channels\`
+  $ catalyst channels info
+
+  # Target a channel directly
+  $ catalyst channels info --channel-id 123`
+).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).addOption(
+  new Option3(
+    "--channel-id <id>",
+    "Skip the channel prompt and target this channel directly."
+  ).argParser(parseChannelId)
+).action(async (options) => {
+  const { apiHost, storeHash, accessToken, channel, label } = await resolveChannelTarget(options);
+  consola.start("Fetching channel site...");
+  const site = await getChannelSite(channel.id, storeHash, accessToken, apiHost);
+  consola.success(`Channel ${label}:`);
+  reportChannelSite(site);
+  const report = await warnOnCrossDomainCheckout(site, { storeHash, accessToken, apiHost });
+  if (report.crossDomain && report.storefrontOnManagedZone !== true) {
+    const suggested = report.suggestion ?? "<domain>";
+    if (!process.stdin.isTTY) {
+      consola.info(
+        `Set one with \`catalyst channels update --channel-id ${channel.id} --checkout-url ${suggested}\`.`
+      );
+      process.exit(0);
+      return;
+    }
+    const shouldSet = await confirm3({
+      message: "Set a checkout URL for this channel now?",
+      default: true
+    });
+    if (shouldSet) {
+      await runChannelCheckoutUrlFlow({
+        storeHash,
+        accessToken,
+        apiHost,
+        // Already chosen above; don't ask again.
+        channelId: channel.id,
+        channelName: channel.name,
+        storefrontUrl: findChannelSiteUrl(site, "primary") ?? site.url
+      });
+      process.exit(0);
+      return;
+    }
+    consola.info(
+      `When you're ready, run \`catalyst channels update --channel-id ${channel.id} --checkout-url <domain>\`.`
+    );
+  }
+  process.exit(0);
+});
+var channels = new Command3("channels").alias("channel").configureHelp({ showGlobalOptions: true }).description("Manage BigCommerce channels.").addCommand(info, { isDefault: true }).addCommand(create).addCommand(link).addCommand(update);
 
 // src/cli/commands/create.ts
 import { Command as Command4, InvalidArgumentError as InvalidArgumentError3, Option as Option4 } from "@commander-js/extra-typings";
-import { input as input4, select as select5 } from "@inquirer/prompts";
+import { input as input5, select as select5 } from "@inquirer/prompts";
 import { execSync as execSync2 } from "child_process";
 import { colorize as colorize6 } from "consola/utils";
 import { pathExistsSync } from "fs-extra/esm";
 import kebabCase from "lodash.kebabcase";
-import { join as join10 } from "path";
-
-// src/cli/lib/detect-package-manager.ts
-import { detectPackageManager as detectFromDir } from "nypm";
-var detectPackageManager = () => {
-  const userAgent = process.env.npm_config_user_agent ?? "";
-  const name = userAgent.split(" ")[0]?.split("/")[0];
-  if (name === "pnpm" || name === "yarn" || name === "bun") {
-    return name;
-  }
-  if (process.versions.bun) {
-    return "bun";
-  }
-  return "npm";
-};
-var detectProjectPackageManager = async (projectDir) => {
-  const detected = await detectFromDir(projectDir);
-  const name = detected?.name;
-  if (name === "pnpm" || name === "yarn" || name === "bun" || name === "npm") {
-    return name;
-  }
-  return "npm";
-};
+import { join as join11 } from "path";
 
 // src/cli/lib/extract-catalyst.ts
 import { mkdirSync as mkdirSync2 } from "fs";
@@ -2189,7 +2701,7 @@ var extractCatalyst = async ({
 // src/cli/lib/init-git-repo.ts
 import { execSync } from "child_process";
 import { rmSync } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var run = (command, cwd) => execSync(command, { cwd, stdio: "ignore" });
 var initGitRepo = (projectDir) => {
   try {
@@ -2198,51 +2710,14 @@ var initGitRepo = (projectDir) => {
     run('git commit -m "Initial commit from Catalyst"', projectDir);
     consola.success("Initialized a git repository.");
   } catch {
-    rmSync(join7(projectDir, ".git"), { recursive: true, force: true });
+    rmSync(join8(projectDir, ".git"), { recursive: true, force: true });
     consola.warn("Could not initialize a git repository. Skipping.");
   }
 };
 
-// src/cli/lib/install-dependencies.ts
-import { installDependencies as installDeps } from "nypm";
-import yoctoSpinner2 from "yocto-spinner";
-var restoreEnv = (key, previous) => {
-  if (previous === void 0) {
-    Reflect.deleteProperty(process.env, key);
-  } else {
-    process.env[key] = previous;
-  }
-};
-var withQuietInstallEnv = async (run2) => {
-  var _a, _b;
-  const prevNodeNoWarnings = process.env.NODE_NO_WARNINGS;
-  const prevDownloadPrompt = process.env.COREPACK_ENABLE_DOWNLOAD_PROMPT;
-  (_a = process.env).NODE_NO_WARNINGS ?? (_a.NODE_NO_WARNINGS = "1");
-  (_b = process.env).COREPACK_ENABLE_DOWNLOAD_PROMPT ?? (_b.COREPACK_ENABLE_DOWNLOAD_PROMPT = "0");
-  try {
-    return await run2();
-  } finally {
-    restoreEnv("NODE_NO_WARNINGS", prevNodeNoWarnings);
-    restoreEnv("COREPACK_ENABLE_DOWNLOAD_PROMPT", prevDownloadPrompt);
-  }
-};
-var installDependencies = async (projectDir, packageManager = "pnpm") => {
-  const spinner = yoctoSpinner2().start(
-    `Installing dependencies with ${packageManager}. This could take a minute...`
-  );
-  try {
-    await withQuietInstallEnv(() => installDeps({ cwd: projectDir, silent: true, packageManager }));
-    spinner.success("Dependencies installed successfully.");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "unknown error";
-    spinner.error(`Failed to install dependencies: ${message}`);
-    throw error;
-  }
-};
-
 // src/cli/lib/rewrite-core-package.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { z as z10 } from "zod";
 var NATIVE_BUILD_ALLOWLIST = [
   "@parcel/watcher",
@@ -2284,7 +2759,7 @@ var resolvePublishedVersion = async (pkgName) => {
   return `^${version2}`;
 };
 var rewriteCorePackage = async (projectDir, ref) => {
-  const packageJsonPath = join8(projectDir, "package.json");
+  const packageJsonPath = join9(projectDir, "package.json");
   const pkg = corePackageJsonSchema2.parse(JSON.parse(readFileSync4(packageJsonPath, "utf-8")));
   const workspaceDeps = DEP_FIELDS.flatMap((field) => {
     const deps = pkg[field];
@@ -2309,12 +2784,12 @@ var rewriteCorePackage = async (projectDir, ref) => {
   pkg.catalyst = { ...pkg.catalyst, version: pkg.version, ref };
   writeFileSync2(packageJsonPath, `${JSON.stringify(sortPackageJsonFields(pkg), null, 2)}
 `);
-  writeFileSync2(join8(projectDir, ".npmrc"), "legacy-peer-deps=true\n");
+  writeFileSync2(join9(projectDir, ".npmrc"), "legacy-peer-deps=true\n");
 };
 
 // src/cli/lib/setup-core-project.ts
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join9 } from "path";
+import { dirname as dirname3, join as join10 } from "path";
 import { z as z11 } from "zod";
 var corePackageJsonSchema3 = z11.looseObject({
   scripts: z11.record(z11.string(), z11.string()).optional(),
@@ -2326,7 +2801,7 @@ var writeJson2 = (path, value) => {
 `);
 };
 var setupCoreProject = (projectDir) => {
-  const corePackageJsonPath = join9(projectDir, "package.json");
+  const corePackageJsonPath = join10(projectDir, "package.json");
   const pkg = corePackageJsonSchema3.parse(JSON.parse(readFileSync5(corePackageJsonPath, "utf-8")));
   pkg.scripts = {
     ...pkg.scripts,
@@ -2366,10 +2841,10 @@ function parseEnvFlag(value, previous = {}) {
   return { ...previous, [key]: val };
 }
 async function handleChannelSelection(storeHash, accessToken, apiHost) {
-  const channels = await fetchAvailableChannels(storeHash, accessToken, apiHost);
+  const channels2 = await fetchAvailableChannels(storeHash, accessToken, apiHost);
   const existingChannel = await select5({
     message: "Which channel would you like to use?",
-    choices: sortChannelsByPlatform(channels).map((ch) => ({
+    choices: sortChannelsByPlatform(channels2).map((ch) => ({
       name: ch.name,
       value: ch,
       description: `Channel Platform: ${channelPlatformLabel(ch.platform)}`
@@ -2385,7 +2860,7 @@ async function setupProject(options) {
   }
   if (projectName) {
     projectName = kebabCase(projectName);
-    projectDir = join10(options.projectDir, projectName);
+    projectDir = join11(options.projectDir, projectName);
     if (pathExistsSync(projectDir)) {
       consola.error(`${projectDir} already exists`);
       process.exit(1);
@@ -2395,13 +2870,13 @@ async function setupProject(options) {
     const validateProjectName = (i) => {
       const formatted = kebabCase(i);
       if (!formatted) return "Project name is required";
-      const targetDir = join10(options.projectDir, formatted);
+      const targetDir = join11(options.projectDir, formatted);
       if (pathExistsSync(targetDir)) return `Destination '${targetDir}' already exists`;
       projectName = formatted;
       projectDir = targetDir;
       return true;
     };
-    await input4({
+    await input5({
       message: "What do you want to name your project directory?",
       default: "my-catalyst-app",
       validate: validateProjectName
@@ -2546,7 +3021,6 @@ Examples:
   if (useCommerceHosting && accessToken) {
     envVars.BIGCOMMERCE_ACCESS_TOKEN = accessToken;
   }
-  if (accessToken) envVars.CATALYST_ACCESS_TOKEN = accessToken;
   let commerceHostingProject;
   if (useCommerceHosting && storeHash && accessToken) {
     const apiHost = `api.${options.bigcommerceHostname}`;
@@ -2578,6 +3052,11 @@ Examples:
         accessToken
       });
     }
+    if (storeHash && accessToken) {
+      const projectConfig = getProjectConfig(projectDir);
+      projectConfig.set("storeHash", storeHash);
+      projectConfig.set("accessToken", accessToken);
+    }
     writeEnv(projectDir, envVars);
     await installDependencies(projectDir, packageManager);
     initGitRepo(projectDir);
@@ -2610,7 +3089,7 @@ import { Command as Command5, Option as Option5 } from "commander";
 import { parse } from "dotenv";
 import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { release } from "os";
-import { dirname as dirname4, join as join11 } from "path";
+import { dirname as dirname4, join as join12 } from "path";
 import { z as z12 } from "zod";
 var CLI_ENV_VARS = [
   "CATALYST_STORE_HASH",
@@ -2627,7 +3106,7 @@ var BUILD_ENV_VARS = [
   "AUTH_SECRET"
 ];
 var ENV_FILES = [".env.local", ".env"];
-var PROJECT_LOCKFILES = [
+var PROJECT_LOCKFILES2 = [
   ["pnpm-lock.yaml", "pnpm"],
   ["yarn.lock", "yarn"],
   ["bun.lock", "bun"],
@@ -2638,7 +3117,7 @@ var hasValue = (value) => value !== void 0 && value.trim() !== "";
 var buildEnvLayers = (cwd, env2) => {
   const layers = [{ source: "process.env", values: env2 }];
   ENV_FILES.forEach((file) => {
-    const path = join11(cwd, file);
+    const path = join12(cwd, file);
     if (!existsSync5(path)) {
       return;
     }
@@ -2661,7 +3140,7 @@ var resolveValue = (envSource, configValue) => {
   return { present: false, source: "unset" };
 };
 var asString = (value) => typeof value === "string" ? value : void 0;
-var lockfileManager = (dir) => PROJECT_LOCKFILES.find(([file]) => existsSync5(join11(dir, file)))?.[1];
+var lockfileManager = (dir) => PROJECT_LOCKFILES2.find(([file]) => existsSync5(join12(dir, file)))?.[1];
 var detectProjectPackageManager2 = (cwd) => {
   let dir = cwd;
   for (; ; ) {
@@ -2676,7 +3155,7 @@ var detectProjectPackageManager2 = (cwd) => {
     dir = parent;
   }
 };
-var projectJsonSchema2 = z12.looseObject({});
+var projectJsonSchema3 = z12.looseObject({});
 var safeReadJson2 = (path) => {
   try {
     return JSON.parse(readFileSync6(path, "utf-8"));
@@ -2684,9 +3163,9 @@ var safeReadJson2 = (path) => {
     return null;
   }
 };
-var readProjectJson = (cwd) => {
-  const result = projectJsonSchema2.safeParse(
-    safeReadJson2(join11(cwd, ".bigcommerce", "project.json"))
+var readProjectJson2 = (cwd) => {
+  const result = projectJsonSchema3.safeParse(
+    safeReadJson2(join12(cwd, ".bigcommerce", "project.json"))
   );
   return result.success ? result.data : null;
 };
@@ -2696,7 +3175,7 @@ var storefrontPackageSchema = z12.looseObject({
   catalyst: z12.looseObject({ version: z12.string().optional() }).optional()
 });
 var readStorefrontInfo = (cwd) => {
-  const result = storefrontPackageSchema.safeParse(safeReadJson2(join11(cwd, "package.json")));
+  const result = storefrontPackageSchema.safeParse(safeReadJson2(join12(cwd, "package.json")));
   if (!result.success) {
     return { name: null, version: null };
   }
@@ -2718,7 +3197,7 @@ function collectDiagnostics({
 } = {}) {
   const state = getProjectState(cwd);
   const telemetry2 = getTelemetry();
-  const projectJson = readProjectJson(cwd);
+  const projectJson = readProjectJson2(cwd);
   const storefront = readStorefrontInfo(cwd);
   const cliEnv = [{ source: "process.env", values: env2 }];
   const buildEnv = buildEnvLayers(cwd, env2);
@@ -2773,12 +3252,12 @@ function collectDiagnostics({
       correlationId: telemetry2.correlationId
     },
     files: {
-      ".env.local": existsSync5(join11(cwd, ".env.local")),
-      ".env": existsSync5(join11(cwd, ".env")),
-      ".bigcommerce/project.json": existsSync5(join11(cwd, ".bigcommerce", "project.json")),
-      ".bigcommerce/wrangler.jsonc": existsSync5(join11(cwd, ".bigcommerce", "wrangler.jsonc")),
-      ".open-next/": existsSync5(join11(cwd, ".open-next")),
-      "package.json": existsSync5(join11(cwd, "package.json"))
+      ".env.local": existsSync5(join12(cwd, ".env.local")),
+      ".env": existsSync5(join12(cwd, ".env")),
+      ".bigcommerce/project.json": existsSync5(join12(cwd, ".bigcommerce", "project.json")),
+      ".bigcommerce/wrangler.jsonc": existsSync5(join12(cwd, ".bigcommerce", "wrangler.jsonc")),
+      ".open-next/": existsSync5(join12(cwd, ".open-next")),
+      "package.json": existsSync5(join12(cwd, "package.json"))
     }
   };
 }
@@ -2865,12 +3344,12 @@ Examples:
 });
 
 // src/cli/commands/deploy.ts
-import { confirm as confirm3 } from "@inquirer/prompts";
+import { confirm as confirm4 } from "@inquirer/prompts";
 import AdmZip from "adm-zip";
 import { Command as Command6, Option as Option6 } from "commander";
 import { colorize as colorize7 } from "consola/utils";
-import { access, readdir, readFile } from "fs/promises";
-import { join as join12 } from "path";
+import { access as access2, readdir, readFile } from "fs/promises";
+import { join as join13 } from "path";
 import yoctoSpinner3 from "yocto-spinner";
 import { z as z13 } from "zod";
 
@@ -2942,10 +3421,10 @@ var DeploymentStatusSchema = z13.object({
 });
 var generateBundleZip = async () => {
   consola.info("Generating bundle...");
-  const bigcommerceDir = join12(process.cwd(), ".bigcommerce");
-  const distDir = join12(process.cwd(), ".bigcommerce", "dist");
+  const bigcommerceDir = join13(process.cwd(), ".bigcommerce");
+  const distDir = join13(process.cwd(), ".bigcommerce", "dist");
   try {
-    await access(distDir);
+    await access2(distDir);
   } catch {
     throw new Error(`Dist directory not found: ${distDir}`);
   }
@@ -2953,7 +3432,7 @@ var generateBundleZip = async () => {
   if (buildDirContents.length === 0) {
     throw new Error(`Dist directory is empty: ${distDir}`);
   }
-  const outputZip = join12(bigcommerceDir, "bundle.zip");
+  const outputZip = join13(bigcommerceDir, "bundle.zip");
   const zip = new AdmZip();
   zip.addLocalFolder(distDir, "output");
   zip.writeZip(outputZip);
@@ -2985,7 +3464,7 @@ var generateUploadSignature = async (storeHash, accessToken, apiHost) => {
 };
 var uploadBundleZip = async (uploadUrl) => {
   consola.info("Uploading bundle...");
-  const zipPath = join12(process.cwd(), ".bigcommerce", "bundle.zip");
+  const zipPath = join13(process.cwd(), ".bigcommerce", "bundle.zip");
   const fileBuffer = await readFile(zipPath);
   const response = await fetch(uploadUrl, {
     method: "PUT",
@@ -3120,7 +3599,7 @@ var fetchProject = async (projectUuid, storeHash, accessToken, apiHost) => {
   }
   const res = await response.json();
   const { data } = ProjectSchema.parse(res);
-  return data.find((project2) => project2.uuid === projectUuid);
+  return data.find((project) => project.uuid === projectUuid);
 };
 var deploy = new Command6("deploy").configureHelp({ showGlobalOptions: true }).description("Deploy your application to Cloudflare.").addHelpText(
   "after",
@@ -3133,6 +3612,9 @@ Example:
 ).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).addOption(projectUuidOption()).option(
   "--update-site-url",
   "After a successful deploy, prompt to update a channel's site URL to the new hostname."
+).option(
+  "--update-checkout-url",
+  "After a successful deploy, prompt to update a channel's checkout URL."
 ).addOption(
   new Option6(
     "--secret <value>",
@@ -3166,7 +3648,7 @@ Example:
     } catch (error) {
       if (error instanceof NoLinkedProjectError) {
         consola.info(
-          "When you're ready to create a project, run `catalyst project create` or re-run `catalyst deploy`."
+          "When you're ready to create a project, run `catalyst projects create` or re-run `catalyst deploy`."
         );
         process.exit(0);
       }
@@ -3194,7 +3676,7 @@ Example:
     consola.success(`Linked project "${selected.name}".`);
   }
   if (!getProjectState().isTransformed) {
-    const shouldSetup = await confirm3({
+    const shouldSetup = await confirm4({
       message: "Your project is not yet set up for Commerce Hosting deployments. Would you like to run the Commerce Hosting setup now?",
       default: true
     });
@@ -3209,11 +3691,17 @@ Example:
     await installDependencies(projectDir, packageManager);
   } else {
     await cleanupCloudflareIncompatibilities(process.cwd());
+    if (options.prebuilt) {
+      const projectDir = process.cwd();
+      await reconcileOpenNextVersion(projectDir, await detectProjectPackageManager(projectDir), {
+        canUpgrade: false
+      });
+    }
   }
   if (options.prebuilt) {
-    const distDir = join12(process.cwd(), ".bigcommerce", "dist");
+    const distDir = join13(process.cwd(), ".bigcommerce", "dist");
     try {
-      await access(distDir);
+      await access2(distDir);
     } catch {
       throw new Error(
         "No build output found at .bigcommerce/dist/. Run `catalyst build` first or remove `--prebuilt` to build automatically."
@@ -3259,29 +3747,44 @@ Example:
     accessToken,
     apiHost
   );
-  if (!options.updateSiteUrl) {
-    return;
-  }
-  try {
-    await runChannelSiteUrlFlow({
-      storeHash,
-      accessToken,
-      apiHost,
-      projectUuid,
-      preferHostname: deploymentHostname
-    });
-  } catch (error) {
+  const warnChannelFlowFailed = (what, error) => {
     consola.warn(
-      `Failed to update channel site URL: ${error instanceof Error ? error.message : String(error)}`
+      `Failed to update channel ${what}: ${error instanceof Error ? error.message : String(error)}`
     );
     consola.info(
       "Update it manually in the control panel, or re-run `catalyst auth login` if the token is missing the store_channel_settings scope."
     );
+  };
+  let resolvedChannelId;
+  if (options.updateSiteUrl) {
+    try {
+      ({ channelId: resolvedChannelId } = await runChannelSiteUrlFlow({
+        storeHash,
+        accessToken,
+        apiHost,
+        projectUuid,
+        preferHostname: deploymentHostname
+      }));
+    } catch (error) {
+      warnChannelFlowFailed("site URL", error);
+    }
+  }
+  if (options.updateCheckoutUrl) {
+    try {
+      await runChannelCheckoutUrlFlow({
+        storeHash,
+        accessToken,
+        apiHost,
+        channelId: resolvedChannelId
+      });
+    } catch (error) {
+      warnChannelFlowFailed("checkout URL", error);
+    }
   }
 });
 
 // src/cli/commands/domains.ts
-import { confirm as confirm4, select as select6 } from "@inquirer/prompts";
+import { confirm as confirm5, select as select6 } from "@inquirer/prompts";
 import { Command as Command7, Option as Option7 } from "commander";
 import { colorize as colorize9 } from "consola/utils";
 
@@ -3295,6 +3798,7 @@ var LOG_LEVELS = ["debug", "info", "warn", "error"];
 var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
 var logEntrySchema = z14.object({
   timestamp: z14.string().nullable().optional(),
+  entry_type: z14.string().optional(),
   level: z14.string().optional(),
   messages: z14.array(z14.unknown()).optional(),
   is_exception: z14.boolean().optional(),
@@ -3411,8 +3915,16 @@ function isRedundantExceptionName(name, message) {
   return parts.length > 0 && parts.every((part) => message.includes(part));
 }
 var stringifyMessage = (message) => typeof message === "string" ? message : JSON.stringify(message);
+var joinMessages = (messages) => (messages ?? []).map(stringifyMessage).join(" ").replace(/\s+/g, " ").trim();
+function isRequestLogEntry(entry) {
+  if (entry.entry_type != null) return entry.entry_type === "request";
+  const method = entry.request?.method;
+  const url = entry.request?.url;
+  if (!method || !url) return false;
+  return joinMessages(entry.messages) === `${method} ${url}`;
+}
 function formatLogEntry(entry, format = "default") {
-  const message = (entry.messages ?? []).map(stringifyMessage).join(" ").replace(/\s+/g, " ").trim();
+  const message = joinMessages(entry.messages);
   if (format === "short") return message;
   const level = entry.level ?? "unknown";
   const coloredLevel = colorize8(LEVEL_COLORS[level.toLowerCase()] ?? "white", level.toUpperCase());
@@ -3425,12 +3937,16 @@ function formatLogEntry(entry, format = "default") {
     const status = entry.request.status_code ? ` (${entry.request.status_code})` : "";
     if (parts.length > 0) requestStr = ` ${parts.join(" ")}${status}`;
   }
-  return `[${entry.timestamp ?? UNKNOWN_TIME}] [${coloredLevel}]${requestStr}${exceptionStr} ${message}`;
+  if (format === "request" && isRequestLogEntry(entry)) {
+    return `[${entry.timestamp ?? UNKNOWN_TIME}]${requestStr}`;
+  }
+  return `[${entry.timestamp ?? UNKNOWN_TIME}]${requestStr} [${coloredLevel}]${exceptionStr} ${message}`;
 }
 async function queryLogs(projectUuid, storeHash, accessToken, apiHost, params) {
   const search = new URLSearchParams();
   search.set("start", params.start);
   search.set("end", params.end);
+  if (params.entryType) search.set("entry_type", params.entryType);
   if (params.method) search.set("method", params.method);
   if (params.statusCode != null) search.set("status_code", String(params.statusCode));
   if (params.urlLike) search.set("url:like", params.urlLike);
@@ -3473,11 +3989,18 @@ async function queryLogs(projectUuid, storeHash, accessToken, apiHost, params) {
 
 // src/cli/lib/domains.ts
 var domainStatusSchema = z15.enum(["pending", "verified", "failed", "unknown"]);
+var pointingRecordsSchema = z15.object({
+  a_record_value: z15.string().nullish(),
+  cname_record_value: z15.string().nullish()
+});
 var domainSchema = z15.object({
   domain: z15.string(),
   project_uuid: z15.string(),
   verification_status: domainStatusSchema
 });
+var createdDomainSchema = domainSchema.extend({
+  pointing_records: pointingRecordsSchema.nullish()
+});
 var ownershipVerificationSchema = z15.object({
   type: z15.string(),
   name: z15.string(),
@@ -3518,6 +4041,9 @@ function parseBoundProjectUuid(body) {
 var domainResponseSchema = z15.object({
   data: domainSchema
 });
+var createdDomainResponseSchema = z15.object({
+  data: createdDomainSchema
+});
 var domainListResponseSchema = z15.object({
   data: z15.array(domainSchema)
 });
@@ -3586,9 +4112,9 @@ async function createDomain(domain, projectUuid, storeHash, accessToken, apiHost
   });
   await assertDomainResponse(response, "Failed to add domain");
   const result = await response.json();
-  return domainResponseSchema.parse(result).data;
+  return createdDomainResponseSchema.parse(result).data;
 }
-async function getDomain(domain, projectUuid, storeHash, accessToken, apiHost) {
+async function getDomain2(domain, projectUuid, storeHash, accessToken, apiHost) {
   const response = await fetch(domainUrl(storeHash, projectUuid, domain, apiHost), {
     method: "GET",
     headers: authHeaders3(accessToken)
@@ -3657,6 +4183,7 @@ async function transferDomain(domain, projectUuid, newProjectUuid, storeHash, ac
 var WAIT_INTERVAL_MS = 5e3;
 var WAIT_TIMEOUT_MS = 5 * 60 * 1e3;
 var DOMAIN_STATUS_FILTERS = ["pending", "verified", "failed"];
+var RECORD_TYPE_WIDTH = "CNAME".length;
 var STATUS_COLORS = {
   pending: "yellow",
   verified: "green",
@@ -3690,20 +4217,20 @@ async function resolveDestinationProject(domain, context, toProjectUuid) {
     return toProjectUuid;
   }
   consola.start("Fetching projects...");
-  const projects = await fetchProjects(context.storeHash, context.accessToken, context.apiHost);
+  const projects2 = await fetchProjects(context.storeHash, context.accessToken, context.apiHost);
   consola.success("Projects fetched.");
-  const destinations = projects.filter((project2) => project2.uuid !== context.projectUuid);
+  const destinations = projects2.filter((project) => project.uuid !== context.projectUuid);
   if (destinations.length === 0) {
     throw new UserActionableError(
-      "No other projects to transfer to. Create another project with `catalyst project create` first."
+      "No other projects to transfer to. Create another project with `catalyst projects create` first."
     );
   }
   return select6({
     message: `Select the project to transfer ${domain} to (Press <enter> to select).`,
-    choices: destinations.map((project2) => ({
-      name: project2.name,
-      value: project2.uuid,
-      description: project2.uuid
+    choices: destinations.map((project) => ({
+      name: project.name,
+      value: project.uuid,
+      description: project.uuid
     }))
   });
 }
@@ -3713,6 +4240,19 @@ function formatDomainStatus(status) {
 function formatDomain(domain) {
   return `${domain.domain} ${formatDomainStatus(domain.verification_status)}`;
 }
+function formatPointingRecords(records) {
+  const rows = [];
+  if (records?.a_record_value) {
+    rows.push(`${"A".padEnd(RECORD_TYPE_WIDTH)}  ${records.a_record_value}`);
+  }
+  if (records?.cname_record_value) {
+    rows.push(`${"CNAME".padEnd(RECORD_TYPE_WIDTH)}  ${records.cname_record_value}`);
+  }
+  if (rows.length === 0) {
+    return null;
+  }
+  return rows.map((row2) => `  ${row2}`).join("\n");
+}
 function formatOwnershipVerification(record) {
   const lines = [
     "Add this DNS record to verify ownership:",
@@ -3734,16 +4274,20 @@ async function waitForDomainVerification({
   timeoutMs = WAIT_TIMEOUT_MS
 }) {
   const startedAt = Date.now();
-  let current = await getDomain(domain, projectUuid, storeHash, accessToken, apiHost);
+  let current = await getDomain2(domain, projectUuid, storeHash, accessToken, apiHost);
   while (current.verification_status === "pending" && Date.now() - startedAt < timeoutMs) {
     await sleep(intervalMs);
-    current = await getDomain(domain, projectUuid, storeHash, accessToken, apiHost);
+    current = await getDomain2(domain, projectUuid, storeHash, accessToken, apiHost);
   }
   return current;
 }
 var add = new Command7("add").configureHelp({ showGlobalOptions: true }).description("Add a custom domain to the current Native Hosting project.").argument("<domain>", "Custom domain to add.").addHelpText(
   "after",
   `
+The DNS records that point the domain at this project are printed once the domain
+is added. They are returned only by this command, so save them: publish the CNAME
+for a subdomain, or the A record for an apex domain.
+
 Examples:
   $ catalyst domains add www.example.com
 
@@ -3753,9 +4297,9 @@ Examples:
   const context = resolveDomainCommandContext(options);
   await getTelemetry().identify(context.storeHash);
   consola.start(`Adding domain ${domain}...`);
-  let result;
+  let created;
   try {
-    result = await createDomain(
+    created = await createDomain(
       domain,
       context.projectUuid,
       context.storeHash,
@@ -3782,12 +4326,26 @@ Examples:
     }
     throw error;
   }
-  consola.success(`Domain ${result.domain} added.`);
+  consola.success(`Domain ${created.domain} added.`);
+  const records = formatPointingRecords(created.pointing_records);
+  let result = created;
   if (options.wait && result.verification_status === "pending") {
     consola.start(`Waiting for ${result.domain} to verify...`);
     result = await waitForDomainVerification({ domain: result.domain, ...context });
   }
   consola.log(formatDomain(result));
+  if (records) {
+    consola.info(`Point ${created.domain} at this project with one of these DNS records:`);
+    consola.log(records);
+    consola.info(
+      "Use the CNAME for a subdomain, or the A record for an apex domain. Save them now \u2014 only `domains add` returns them."
+    );
+  }
+  if (result.verification_status === "pending") {
+    consola.info(
+      `Run \`catalyst domains status ${result.domain}\` to check verification progress.`
+    );
+  }
   process.exit(0);
 });
 var list = new Command7("list").configureHelp({ showGlobalOptions: true }).description("List custom domains for the current Native Hosting project.").addHelpText(
@@ -3837,7 +4395,7 @@ Examples:
   const context = resolveDomainCommandContext(options);
   await getTelemetry().identify(context.storeHash);
   consola.start(`Fetching status for ${domain}...`);
-  let result = await getDomain(
+  let result = await getDomain2(
     domain,
     context.projectUuid,
     context.storeHash,
@@ -3888,7 +4446,7 @@ Examples:
     throw error;
   }
   consola.success(`Domain ${domain} claimed.`);
-  let result = await getDomain(
+  let result = await getDomain2(
     domain,
     context.projectUuid,
     context.storeHash,
@@ -3927,14 +4485,14 @@ Examples:
   );
   if (!owned) {
     consola.start(`Locating the project that owns ${domain}...`);
-    const projects = await fetchProjects(context.storeHash, context.accessToken, context.apiHost);
-    const candidates = projects.filter((project2) => project2.uuid !== context.projectUuid);
+    const projects2 = await fetchProjects(context.storeHash, context.accessToken, context.apiHost);
+    const candidates = projects2.filter((project) => project.uuid !== context.projectUuid);
     const matches = await Promise.all(
-      candidates.map(async (project2) => ({
-        project: project2,
+      candidates.map(async (project) => ({
+        project,
         found: await findDomain(
           domain,
-          project2.uuid,
+          project.uuid,
           context.storeHash,
           context.accessToken,
           context.apiHost
@@ -3968,7 +4526,7 @@ Examples:
     context.apiHost
   );
   consola.success(`Domain ${domain} transferred.`);
-  let result = await getDomain(
+  let result = await getDomain2(
     domain,
     newProjectUuid,
     context.storeHash,
@@ -4000,7 +4558,7 @@ Examples:
   const context = resolveDomainCommandContext(options);
   await getTelemetry().identify(context.storeHash);
   consola.start(`Fetching status for ${domain}...`);
-  const current = await getDomain(
+  const current = await getDomain2(
     domain,
     context.projectUuid,
     context.storeHash,
@@ -4008,7 +4566,7 @@ Examples:
     context.apiHost
   );
   if (current.verification_status === "verified" && !options.force) {
-    const confirmed = await confirm4({
+    const confirmed = await confirm5({
       message: `Remove active domain ${current.domain}? Traffic may stop routing to this project.`,
       default: false
     });
@@ -4029,7 +4587,7 @@ Examples:
   consola.success(`Domain ${current.domain} removed.`);
   process.exit(0);
 });
-var domains = new Command7("domains").configureHelp({ showGlobalOptions: true }).description("Manage custom domains for the current Native Hosting project.").addCommand(add).addCommand(list).addCommand(showStatus).addCommand(claim).addCommand(transfer).addCommand(remove);
+var domains = new Command7("domains").alias("domain").configureHelp({ showGlobalOptions: true }).description("Manage custom domains for the current Native Hosting project.").addCommand(add).addCommand(list).addCommand(showStatus).addCommand(claim).addCommand(transfer).addCommand(remove);
 
 // src/cli/commands/env.ts
 import { Command as Command8 } from "commander";
@@ -4141,8 +4699,19 @@ var StreamError = class extends Error {
   }
 };
 var formatMessages = (messages) => messages.map((m) => typeof m === "string" ? m : JSON.stringify(m)).join(" ");
+var formatRequestLine = (event, entry) => {
+  const { request } = event;
+  const msg = entry ? formatMessages(entry.messages) : "";
+  const msgPart = msg ? ` ${msg}` : "";
+  const level = msg ? entry?.level.toUpperCase() : void 0;
+  const levelPart = level ? ` [${colorize10(LEVEL_COLORS2[level] ?? "white", level)}]` : "";
+  return `[${entry?.timestamp ?? event.timestamp}] ${request.method} ${request.url} (${request.status_code})${levelPart}${msgPart}`;
+};
 var formatLogEvent = (event, format) => {
-  const { request, logs: logEntries, exceptions } = event;
+  const { logs: logEntries, exceptions } = event;
+  if (format === "request" && logEntries.length === 0) {
+    consola.log(formatRequestLine(event));
+  }
   logEntries.forEach((entry) => {
     const msg = formatMessages(entry.messages);
     const level = entry.level.toUpperCase();
@@ -4152,9 +4721,7 @@ var formatLogEvent = (event, format) => {
         consola.log(msg);
         break;
       case "request":
-        consola.log(
-          `[${entry.timestamp}] [${coloredLevel}] ${request.method} ${request.url} (${request.status_code}) ${msg}`
-        );
+        consola.log(formatRequestLine(event, entry));
         break;
       default:
         consola.log(`[${entry.timestamp}] [${coloredLevel}] ${msg}`);
@@ -4290,6 +4857,19 @@ var tailLogs = async (projectUuid, storeHash, accessToken, apiHost, format, conn
 var tail = new Command9("tail").configureHelp({ showGlobalOptions: true }).description("Tail live logs from your deployed application.").addHelpText(
   "after",
   `
+Formats:
+  default  One line per log message: timestamp, level, and message.
+  short    Message text only.
+  request  One line per log message: timestamp, request method, URL, status
+           code, level, and message. Requests that logged no messages are
+           printed too, without the level and message.
+  pretty   Indented JSON of the whole event.
+  json     Raw JSON, one event per line (useful for piping to other tools).
+
+The \`default\` and \`short\` formats only print requests that produced a log
+message. Use \`--format request\` (or \`json\`/\`pretty\`) to see every request,
+including ones with no message body.
+
 Examples:
   $ catalyst logs tail
 
@@ -4349,6 +4929,8 @@ function printPaginationHints(pagination, start2, end, options) {
     ...options.urlLike ? [`--url-like ${quoteArg(options.urlLike)}`] : [],
     ...options.levelMin ? [`--level-min ${options.levelMin}`] : [],
     ...options.limit != null ? [`--limit ${options.limit}`] : [],
+    // The entry_type filter derives from --format (default/short request only
+    // application logs), so echoing --format is enough to reproduce it.
     ...options.format !== "default" ? [`--format ${options.format}`] : []
   ];
   const command = `${invocationPrefix()} logs query ${baseFlags.join(" ")}`;
@@ -4375,6 +4957,10 @@ entries with \`--before\`. Cursors are only valid with the same window and
 filters they came from. With \`--format json\`, the pagination cursors are
 emitted as a final \`{"meta": ...}\` line after the entries.
 
+The \`default\` and \`short\` formats show only application log output,
+excluding Cloudflare's auto-generated per-request rows. Use
+\`--format request\` (or \`json\`/\`pretty\`) to include them.
+
 Examples:
   # Last hour of logs
   $ catalyst logs query --since 1h
@@ -4432,9 +5018,11 @@ Examples:
     await getTelemetry().identify(storeHash);
     const projectUuid = resolveProjectUuid(options);
     const { start: start2, end } = resolveTimeWindow(options);
+    const hideRequestRows = options.format === "default" || options.format === "short";
     const result = await queryLogs(projectUuid, storeHash, accessToken, apiHost, {
       start: start2,
       end,
+      entryType: hideRequestRows ? "log" : void 0,
       method: options.method,
       statusCode: options.statusCode,
       urlLike: options.urlLike,
@@ -4466,9 +5054,12 @@ Examples:
       return;
     }
     const lineFormat = options.format;
-    ordered.forEach((entry) => consola.log(formatLogEntry(entry, lineFormat)));
+    const visible = hideRequestRows ? ordered.filter((entry) => !isRequestLogEntry(entry)) : ordered;
+    const hiddenCount = ordered.length - visible.length;
+    visible.forEach((entry) => consola.log(formatLogEntry(entry, lineFormat)));
+    const shownPart = `${visible.length} ${visible.length === 1 ? "entry" : "entries"} shown`;
     consola.info(
-      `${entries.length} ${entries.length === 1 ? "entry" : "entries"} shown (oldest first, times in UTC).`
+      hiddenCount > 0 ? `${shownPart}, ${hiddenCount} request ${hiddenCount === 1 ? "row" : "rows"} hidden (oldest first, times in UTC). Use --format request to see request rows.` : `${shownPart} (oldest first, times in UTC).`
     );
     printPaginationHints(result.meta?.cursor_pagination, start2, end, options);
   } catch (error) {
@@ -4476,10 +5067,10 @@ Examples:
     process.exit(1);
   }
 });
-var logs = new Command9("logs").configureHelp({ showGlobalOptions: true }).description("View logs from your deployed application.").addCommand(tail, { isDefault: true }).addCommand(query);
+var logs = new Command9("logs").alias("log").configureHelp({ showGlobalOptions: true }).description("View logs from your deployed application.").addCommand(tail, { isDefault: true }).addCommand(query);
 
-// src/cli/commands/project.ts
-import { confirm as confirm5, input as input5, select as select7 } from "@inquirer/prompts";
+// src/cli/commands/projects.ts
+import { confirm as confirm6, input as input6, select as select7 } from "@inquirer/prompts";
 import { Command as Command10 } from "commander";
 import { colorize as colorize11 } from "consola/utils";
 async function offerCommerceHostingSetup(projectUuid, credentials) {
@@ -4488,7 +5079,7 @@ async function offerCommerceHostingSetup(projectUuid, credentials) {
     await cleanupCloudflareIncompatibilities(projectDir);
     return;
   }
-  const shouldSetup = await confirm5({
+  const shouldSetup = await confirm6({
     message: "Your project has been linked, but is not fully set up for Commerce Hosting deployments yet. Would you like to run the setup now?",
     default: true
   });
@@ -4507,22 +5098,22 @@ var list3 = new Command10("list").configureHelp({ showGlobalOptions: true }).des
   "after",
   `
 Example:
-  $ catalyst project list`
+  $ catalyst projects list`
 ).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).action(async (options) => {
   const config2 = getProjectConfig();
   const apiHost = resolveApiHost(options, config2);
   const { storeHash, accessToken } = resolveCredentials(options, config2);
   await getTelemetry().identify(storeHash);
   consola.start("Fetching projects...");
-  const projects = await fetchProjects(storeHash, accessToken, apiHost);
+  const storeProjects = await fetchProjects(storeHash, accessToken, apiHost);
   consola.success("Projects fetched.");
-  if (projects.length === 0) {
+  if (storeProjects.length === 0) {
     consola.info("No projects found.");
     process.exit(0);
     return;
   }
   const linkedProjectUuid = config2.get("projectUuid");
-  const projectList = projects.map((p) => {
+  const projectList = storeProjects.map((p) => {
     const marker = p.uuid === linkedProjectUuid ? ` ${colorize11("green", "[linked]")}` : "";
     const hostnames = p.deployment_hostnames.length === 0 ? ["  (not deployed)"] : p.deployment_hostnames.map(
       (hostname) => `  ${colorize11("blue", `https://${hostname}`)}`
@@ -4538,7 +5129,7 @@ var create3 = new Command10("create").configureHelp({ showGlobalOptions: true })
   "after",
   `
 Example:
-  $ catalyst project create`
+  $ catalyst projects create`
 ).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).addOption(loginUrlOption()).action(async (options) => {
   const config2 = getProjectConfig();
   const apiHost = resolveApiHost(options, config2);
@@ -4558,7 +5149,7 @@ Example:
     } catch (error) {
       if (error instanceof LoginAbortedError) {
         consola.info(
-          "Login aborted. Re-run `catalyst project create` when you have your credentials ready."
+          "Login aborted. Re-run `catalyst projects create` when you have your credentials ready."
         );
         process.exit(0);
         return;
@@ -4567,7 +5158,7 @@ Example:
     }
   }
   await getTelemetry().identify(storeHash);
-  const newProjectName = await input5({ message: "Enter a name for the new project:" });
+  const newProjectName = await input6({ message: "Enter a name for the new project:" });
   const data = await createProject(newProjectName, storeHash, accessToken, apiHost);
   consola.success(`Project "${data.name}" created successfully.`);
   consola.start("Writing project UUID to .bigcommerce/project.json...");
@@ -4584,10 +5175,10 @@ var link2 = new Command10("link").configureHelp({ showGlobalOptions: true }).des
   `
 Examples:
   # Link interactively (prompts to select or create)
-  $ catalyst project link
+  $ catalyst projects link
 
   # Link using a project UUID directly
-  $ catalyst project link --project-uuid <UUID>`
+  $ catalyst projects link --project-uuid <UUID>`
 ).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).addOption(projectUuidOption()).action(async (options) => {
   const config2 = getProjectConfig();
   const apiHost = resolveApiHost(options, config2);
@@ -4617,7 +5208,7 @@ Examples:
   } catch (error) {
     if (error instanceof NoLinkedProjectError) {
       consola.info(
-        "When you're ready to create a project, run `catalyst project create` or re-run `catalyst project link`."
+        "When you're ready to create a project, run `catalyst projects create` or re-run `catalyst projects link`."
       );
       process.exit(0);
       throw error;
@@ -4635,13 +5226,13 @@ var del = new Command10("delete").configureHelp({ showGlobalOptions: true }).des
   `
 Examples:
   # Select a project to delete interactively
-  $ catalyst project delete
+  $ catalyst projects delete
 
   # Delete a specific project (still prompts for confirmation)
-  $ catalyst project delete --project-uuid <UUID>
+  $ catalyst projects delete --project-uuid <UUID>
 
   # Skip the confirmation prompt
-  $ catalyst project delete --project-uuid <UUID> --force`
+  $ catalyst projects delete --project-uuid <UUID> --force`
 ).addOption(storeHashOption()).addOption(accessTokenOption()).addOption(apiHostOption()).addOption(projectUuidOption()).option("--force", "Skip the confirmation prompt before deleting.").action(async (options) => {
   const config2 = getProjectConfig();
   const apiHost = resolveApiHost(options, config2);
@@ -4651,9 +5242,9 @@ Examples:
   let targetName;
   if (!targetUuid) {
     consola.start("Fetching projects...");
-    const projects = await fetchProjects(storeHash, accessToken, apiHost);
+    const storeProjects = await fetchProjects(storeHash, accessToken, apiHost);
     consola.success("Projects fetched.");
-    if (projects.length === 0) {
+    if (storeProjects.length === 0) {
       consola.info("No projects found.");
       process.exit(0);
       return;
@@ -4662,7 +5253,7 @@ Examples:
     const selected = await select7({
       message: "Select a project to delete (Press <enter> to select).",
       choices: [
-        ...projects.map((p) => ({
+        ...storeProjects.map((p) => ({
           name: p.uuid === linkedProjectUuid ? `${p.name} ${colorize11("green", "[linked]")}` : p.name,
           value: p.uuid,
           description: p.uuid
@@ -4675,7 +5266,7 @@ Examples:
       process.exit(0);
       return;
     }
-    const matched = projects.find((p) => p.uuid === selected);
+    const matched = storeProjects.find((p) => p.uuid === selected);
     if (!matched) {
       throw new Error(`Selected project ${String(selected)} not found in fetched list.`);
     }
@@ -4684,7 +5275,7 @@ Examples:
   }
   if (!options.force) {
     const label = targetName ? `"${targetName}" (${targetUuid})` : targetUuid;
-    const confirmed = await confirm5({
+    const confirmed = await confirm6({
       message: `Are you sure you want to delete project ${label}? This action is irreversible and will permanently destroy the project and all of its data.`,
       default: false
     });
@@ -4703,13 +5294,13 @@ Examples:
   }
   process.exit(0);
 });
-var project = new Command10("project").configureHelp({ showGlobalOptions: true }).description("Manage your BigCommerce infrastructure project.").addCommand(create3).addCommand(list3).addCommand(link2).addCommand(del);
+var projects = new Command10("projects").alias("project").configureHelp({ showGlobalOptions: true }).description("Manage your BigCommerce infrastructure projects.").addCommand(create3).addCommand(list3).addCommand(link2).addCommand(del);
 
 // src/cli/commands/start.ts
 import { Command as Command11 } from "commander";
 import { execa as execa3 } from "execa";
 import { existsSync as existsSync6, lstatSync, symlinkSync } from "fs";
-import { join as join13, relative } from "path";
+import { join as join14, relative } from "path";
 var start = new Command11("start").configureHelp({ showGlobalOptions: true }).description(
   "Start a local preview of your Catalyst storefront using the OpenNext Cloudflare adapter."
 ).addHelpText(
@@ -4727,11 +5318,11 @@ Example:
     });
     return;
   }
-  const envLocal = join13(process.cwd(), ".env.local");
-  const devVars = join13(process.cwd(), ".bigcommerce", ".dev.vars");
+  const envLocal = join14(process.cwd(), ".env.local");
+  const devVars = join14(process.cwd(), ".bigcommerce", ".dev.vars");
   if (existsSync6(envLocal)) {
     if (!existsSync6(devVars)) {
-      const target = relative(join13(process.cwd(), ".bigcommerce"), envLocal);
+      const target = relative(join14(process.cwd(), ".bigcommerce"), envLocal);
       symlinkSync(target, devVars);
       consola.success("Symlinked .bigcommerce/.dev.vars \u2192 .env.local");
     } else if (!lstatSync(devVars).isSymbolicLink()) {
@@ -4751,7 +5342,7 @@ Example:
       "opennextjs-cloudflare",
       "preview",
       "--config",
-      join13(".bigcommerce", "wrangler.jsonc")
+      join14(".bigcommerce", "wrangler.jsonc")
     ],
     {
       stdio: "inherit",
@@ -4807,10 +5398,10 @@ Examples:
 
 // src/cli/commands/upgrade.ts
 import { Command as Command13, Option as Option10 } from "@commander-js/extra-typings";
-import { confirm as confirm6 } from "@inquirer/prompts";
+import { confirm as confirm7 } from "@inquirer/prompts";
 import { execa as execa4 } from "execa";
 import {
-  access as access2,
+  access as access3,
   copyFile as copyFile2,
   cp as cp2,
   mkdir,
@@ -4822,7 +5413,8 @@ import {
   writeFile as writeFile2
 } from "fs/promises";
 import { homedir, tmpdir } from "os";
-import { dirname as dirname5, join as join14, relative as relative2 } from "path";
+import { dirname as dirname5, join as join15, relative as relative2 } from "path";
+import { minVersion as minVersion2, satisfies as satisfies2, lt as semverLt2, validRange as validRange2, valid as validSemver2 } from "semver";
 import yoctoSpinner4 from "yocto-spinner";
 import { z as z17 } from "zod";
 var CorePackageJson = z17.object({
@@ -4830,6 +5422,20 @@ var CorePackageJson = z17.object({
   version: z17.string(),
   catalyst: z17.object({ version: z17.string(), ref: z17.string() }).optional()
 });
+var DEP_FIELDS2 = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+var DepsPackageJson = z17.looseObject({
+  dependencies: z17.record(z17.string(), z17.string()).optional(),
+  devDependencies: z17.record(z17.string(), z17.string()).optional(),
+  optionalDependencies: z17.record(z17.string(), z17.string()).optional(),
+  peerDependencies: z17.record(z17.string(), z17.string()).optional()
+});
+var WorkspacePackageJson = z17.object({ name: z17.string(), version: z17.string() });
+var CATALYST_CLI_PACKAGE = "@bigcommerce/catalyst";
 var DEFAULT_REPOSITORY = "bigcommerce/catalyst";
 var MOVING_TAGS = /* @__PURE__ */ new Set(["latest", "canary", "alpha"]);
 var KNOWN_FAMILIES = /* @__PURE__ */ new Set([
@@ -4838,14 +5444,14 @@ var KNOWN_FAMILIES = /* @__PURE__ */ new Set([
   "@bigcommerce/catalyst-b2b-makeswift",
   "@bigcommerce/catalyst-b2b"
 ]);
-var CACHE_DIR = join14(homedir(), ".cache", "catalyst-cli", "cores");
-var pathExists = (p) => access2(p).then(() => true).catch(() => false);
+var CACHE_DIR = join15(homedir(), ".cache", "catalyst-cli", "cores");
+var pathExists = (p) => access3(p).then(() => true).catch(() => false);
 async function listFiles(dir, prefix = "") {
   const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
   const nested = await Promise.all(
     entries.map((entry) => {
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-      return entry.isDirectory() ? listFiles(join14(dir, entry.name), rel) : Promise.resolve([rel]);
+      return entry.isDirectory() ? listFiles(join15(dir, entry.name), rel) : Promise.resolve([rel]);
     })
   );
   return nested.flat();
@@ -4861,7 +5467,7 @@ async function computeBaseSimilarity(baseDir, destDir) {
   const baseFiles = await listFiles(baseDir);
   if (baseFiles.length === 0) return 0;
   const matches = await Promise.all(
-    baseFiles.map((rel) => filesEqual(join14(baseDir, rel), join14(destDir, rel)))
+    baseFiles.map((rel) => filesEqual(join15(baseDir, rel), join15(destDir, rel)))
   );
   return matches.filter(Boolean).length / baseFiles.length;
 }
@@ -4880,10 +5486,79 @@ function parseRef(ref) {
   return { packageName: ref.slice(0, lastAt), version: ref.slice(lastAt + 1) };
 }
 async function readResolvedVersion(coreDir) {
-  const raw = await readFile2(join14(coreDir, "package.json"), "utf-8");
+  const raw = await readFile2(join15(coreDir, "package.json"), "utf-8");
   const pkg = CorePackageJson.parse(JSON.parse(raw));
   return pkg.catalyst?.version ?? pkg.version;
 }
+var readDepSpecifiers = (raw) => {
+  let parsed;
+  try {
+    parsed = DepsPackageJson.parse(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+  return Object.fromEntries(DEP_FIELDS2.flatMap((field) => Object.entries(parsed[field] ?? {})));
+};
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var rewriteWorkspaceSpecifier = (raw, name, version2) => raw.replace(
+  new RegExp(`("${escapeRegExp(name)}"\\s*:\\s*)"workspace:[^"]*"`, "g"),
+  (_match, key) => `${key}"^${version2}"`
+);
+async function normalizeWorkspaceDeps(ourPkgRaw, baseDir, theirsDir, baseVersions, targetVersions) {
+  const basePath = join15(baseDir, "package.json");
+  const theirsPath = join15(theirsDir, "package.json");
+  const [originalBase, originalTheirs] = await Promise.all([
+    readFile2(basePath, "utf-8").catch(() => null),
+    readFile2(theirsPath, "utf-8").catch(() => null)
+  ]);
+  if (originalBase === null || originalTheirs === null) return { workspace: [], bumped: [] };
+  const ourSpecifiers = readDepSpecifiers(ourPkgRaw);
+  const names = new Set(
+    [
+      ...Object.entries(readDepSpecifiers(originalBase)),
+      ...Object.entries(readDepSpecifiers(originalTheirs))
+    ].filter(([, range]) => range?.startsWith("workspace:")).map(([name]) => name)
+  );
+  const decisions = [...names].map((name) => ({
+    name,
+    ours: ourSpecifiers[name],
+    baseVersion: baseVersions[name],
+    targetVersion: targetVersions[name]
+  }));
+  const workspace = decisions.flatMap(
+    ({ name, ours, targetVersion }) => ours?.startsWith("workspace:") && targetVersion !== void 0 ? [{ name, ours, version: targetVersion }] : []
+  );
+  const normalizable = decisions.filter(({ ours }) => !ours?.startsWith("workspace:"));
+  const baseRaw = normalizable.reduce(
+    (acc, { name, baseVersion }) => baseVersion === void 0 ? acc : rewriteWorkspaceSpecifier(acc, name, baseVersion),
+    originalBase
+  );
+  const theirsRaw = normalizable.reduce(
+    (acc, { name, targetVersion }) => targetVersion === void 0 ? acc : rewriteWorkspaceSpecifier(acc, name, targetVersion),
+    originalTheirs
+  );
+  const bumped = normalizable.filter(
+    ({ baseVersion, targetVersion }) => baseVersion !== void 0 && targetVersion !== void 0 && baseVersion !== targetVersion
+  ).map(({ name }) => name);
+  await Promise.all([
+    baseRaw === originalBase ? null : writeFile2(basePath, baseRaw),
+    theirsRaw === originalTheirs ? null : writeFile2(theirsPath, theirsRaw)
+  ]);
+  return { workspace, bumped };
+}
+var migrateWorkspaceDeps = (raw, findings) => findings.reduce((acc, { name, version: version2 }) => rewriteWorkspaceSpecifier(acc, name, version2), raw);
+async function findStaleCli(pkgRaw) {
+  const range = readDepSpecifiers(pkgRaw)[CATALYST_CLI_PACKAGE];
+  if (range === void 0 || !validRange2(range)) return null;
+  const body = await fetch(`https://registry.npmjs.org/${CATALYST_CLI_PACKAGE}/latest`, {
+    // A hanging registry would otherwise stall the CLI indefinitely.
+    signal: AbortSignal.timeout(5e3)
+  }).then((res) => res.ok ? res.json() : null).catch(() => null);
+  const latest = z17.object({ version: z17.string() }).safeParse(body).data?.version;
+  if (latest === void 0 || !validSemver2(latest) || satisfies2(latest, range)) return null;
+  const current = minVersion2(range)?.version;
+  return current !== void 0 && semverLt2(current, latest) ? { current, latest } : null;
+}
 async function mergeFile(oursPath, basePath, theirsPath) {
   const merged = await execa4(
     "git",
@@ -4907,9 +5582,9 @@ async function mergeFile(oursPath, basePath, theirsPath) {
   return (merged.exitCode ?? 0) > 0;
 }
 async function mergeModified(rel, baseDir, theirsDir, catalystRoot) {
-  const basePath = join14(baseDir, rel);
-  const theirsPath = join14(theirsDir, rel);
-  const oursPath = join14(catalystRoot, rel);
+  const basePath = join15(baseDir, rel);
+  const theirsPath = join15(theirsDir, rel);
+  const oursPath = join15(catalystRoot, rel);
   if (await filesEqual(basePath, theirsPath)) return null;
   if (!await pathExists(oursPath)) {
     await copyInto(theirsPath, oursPath);
@@ -4925,8 +5600,8 @@ async function mergeModified(rel, baseDir, theirsDir, catalystRoot) {
   return await mergeFile(oursPath, basePath, theirsPath) ? "conflicted" : "applied";
 }
 async function mergeAdded(rel, theirsDir, catalystRoot, emptyFile) {
-  const theirsPath = join14(theirsDir, rel);
-  const oursPath = join14(catalystRoot, rel);
+  const theirsPath = join15(theirsDir, rel);
+  const oursPath = join15(catalystRoot, rel);
   if (!await pathExists(oursPath)) {
     await copyInto(theirsPath, oursPath);
     return "added";
@@ -4937,8 +5612,8 @@ async function mergeAdded(rel, theirsDir, catalystRoot, emptyFile) {
   return hadConflict ? "conflicted" : "applied";
 }
 async function mergeDeleted(rel, baseDir, catalystRoot) {
-  const basePath = join14(baseDir, rel);
-  const oursPath = join14(catalystRoot, rel);
+  const basePath = join15(baseDir, rel);
+  const oursPath = join15(catalystRoot, rel);
   if (!await pathExists(oursPath)) return null;
   if (await filesEqual(oursPath, basePath)) {
     await rm2(oursPath, { force: true });
@@ -4984,15 +5659,15 @@ async function resolveStrategy(strategy) {
   return "per-file";
 }
 async function mergeCoreTree(baseDir, theirsDir, catalystRoot) {
-  const scratch = await mkdtemp(join14(tmpdir(), "catalyst-merge-"));
+  const scratch = await mkdtemp(join15(tmpdir(), "catalyst-merge-"));
   try {
     await execa4("git", ["init", "-q", scratch]);
     await execa4("git", ["config", "core.autocrlf", "false"], {
-      env: { ...process.env, GIT_DIR: join14(scratch, ".git") }
+      env: { ...process.env, GIT_DIR: join15(scratch, ".git") }
     });
     const env2 = {
       ...process.env,
-      GIT_DIR: join14(scratch, ".git"),
+      GIT_DIR: join15(scratch, ".git"),
       GIT_AUTHOR_NAME: "catalyst",
       GIT_AUTHOR_EMAIL: "catalyst@bigcommerce.com",
       GIT_COMMITTER_NAME: "catalyst",
@@ -5002,7 +5677,7 @@ async function mergeCoreTree(baseDir, theirsDir, catalystRoot) {
       const sideEnv = {
         ...env2,
         GIT_WORK_TREE: workTree,
-        GIT_INDEX_FILE: join14(scratch, `index.${tag}`)
+        GIT_INDEX_FILE: join15(scratch, `index.${tag}`)
       };
       await execa4("git", ["add", "-A"], { env: sideEnv });
       return (await execa4("git", ["write-tree"], { env: sideEnv })).stdout.trim();
@@ -5046,7 +5721,7 @@ async function mergeCoreTree(baseDir, theirsDir, catalystRoot) {
     const outEnv = {
       ...env2,
       GIT_WORK_TREE: catalystRoot,
-      GIT_INDEX_FILE: join14(scratch, "index.out")
+      GIT_INDEX_FILE: join15(scratch, "index.out")
     };
     await execa4("git", ["read-tree", mergedTree], { env: outEnv });
     await execa4("git", ["checkout-index", "-a", "-f"], { env: outEnv });
@@ -5065,7 +5740,7 @@ async function mergeCoreTree(baseDir, theirsDir, catalystRoot) {
       }
     }
     const deleted = changes.filter((change) => change.status === "D").map((change) => change.path);
-    await Promise.all(deleted.map((path) => rm2(join14(catalystRoot, path), { force: true })));
+    await Promise.all(deleted.map((path) => rm2(join15(catalystRoot, path), { force: true })));
     return {
       applied: changes.filter((change) => change.status !== "A" && change.status !== "D").map((change) => change.path),
       added: changes.filter((change) => change.status === "A").map((change) => change.path),
@@ -5108,9 +5783,9 @@ async function applyIndexState(gitRoot, relDir, baseDir, theirsDir, result, stam
     stillConflicted.map(async (rel) => {
       const repoPath = toRepoPath(rel);
       const [base, ours, theirs] = await Promise.all([
-        hashBlob(join14(baseDir, rel)),
+        hashBlob(join15(baseDir, rel)),
         headEntry(repoPath),
-        hashBlob(join14(theirsDir, rel))
+        hashBlob(join15(theirsDir, rel))
       ]);
       return [
         `0 ${NULL_OID}	${repoPath}`,
@@ -5133,10 +5808,10 @@ async function resolveProject2(cwd) {
   } catch {
     return null;
   }
-  const candidateDirs = [.../* @__PURE__ */ new Set([join14(gitRoot, "core"), gitRoot, join14(cwd, "core"), cwd])];
+  const candidateDirs = [.../* @__PURE__ */ new Set([join15(gitRoot, "core"), gitRoot, join15(cwd, "core"), cwd])];
   const parsed = (await Promise.all(
     candidateDirs.map(async (dir) => {
-      const pkgPath = join14(dir, "package.json");
+      const pkgPath = join15(dir, "package.json");
       const raw = await readFile2(pkgPath, "utf-8").catch(() => null);
       if (!raw) return null;
       let pkgJson;
@@ -5160,13 +5835,44 @@ async function resolveProject2(cwd) {
     pkg: chosen.pkg
   };
 }
+var readWorkspaceVersions = async (repoDir) => {
+  const packagesDir = join15(repoDir, "packages");
+  const entries = await readdir2(packagesDir, { withFileTypes: true }).catch(() => []);
+  const manifests = await Promise.all(
+    entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+      const raw = await readFile2(join15(packagesDir, entry.name, "package.json"), "utf-8").catch(
+        () => null
+      );
+      if (raw === null) return null;
+      try {
+        return WorkspacePackageJson.parse(JSON.parse(raw));
+      } catch {
+        return null;
+      }
+    })
+  );
+  return Object.fromEntries(
+    manifests.filter((pkg) => pkg !== null).map(({ name, version: version2 }) => [name, version2])
+  );
+};
+var readCachedVersions = async (path) => {
+  const raw = await readFile2(path, "utf-8").catch(() => null);
+  if (raw === null) return null;
+  try {
+    return z17.record(z17.string(), z17.string()).parse(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+};
 async function downloadCore(repository, ref, destDir, token) {
   const cacheable = !MOVING_TAGS.has(parseRef(ref).version);
   const cacheKey = `${repository.replace(/[^a-zA-Z0-9._-]/g, "_")}__${ref.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-  const cachePath = join14(CACHE_DIR, cacheKey);
-  if (cacheable && await pathExists(cachePath) && await pathExists(join14(cachePath, "package.json"))) {
+  const cachePath = join15(CACHE_DIR, cacheKey);
+  const versionsPath = `${cachePath}.versions.json`;
+  const cachedVersions = cacheable && await pathExists(join15(cachePath, "package.json")) ? await readCachedVersions(versionsPath) : null;
+  if (cachedVersions) {
     await cp2(cachePath, destDir, { recursive: true });
-    return;
+    return cachedVersions;
   }
   const url = `https://api.github.com/repos/${repository}/tarball/${encodeURIComponent(ref)}`;
   const headers = {
@@ -5186,32 +5892,52 @@ async function downloadCore(repository, ref, destDir, token) {
   await writeFile2(tarballPath, Buffer.from(await res.arrayBuffer()));
   await mkdir(rawDir, { recursive: true });
   await execa4("tar", ["-xzf", tarballPath, "-C", rawDir, "--strip-components=1"]);
-  const coreDir = join14(rawDir, "core");
+  const coreDir = join15(rawDir, "core");
   const sourceDir = await pathExists(coreDir) ? coreDir : rawDir;
+  const workspaceVersions = await readWorkspaceVersions(rawDir);
   await rename(sourceDir, destDir);
   await rm2(tarballPath, { force: true });
   await rm2(rawDir, { recursive: true, force: true });
   if (cacheable) {
     await mkdir(CACHE_DIR, { recursive: true });
-    await cp2(destDir, cachePath, { recursive: true }).catch(() => {
+    await cp2(destDir, cachePath, { recursive: true }).then(() => writeFile2(versionsPath, JSON.stringify(workspaceVersions))).catch(() => {
     });
   }
+  return workspaceVersions;
 }
-async function resolveBaseRef(project2, fromOption, assumeYes) {
-  if (project2.pkg.catalyst?.ref) return project2.pkg.catalyst.ref;
+async function resolveBaseRef(project, fromOption, assumeYes) {
+  if (project.pkg.catalyst?.ref) return project.pkg.catalyst.ref;
   if (fromOption) return fromOption;
-  const family = project2.pkg.name && KNOWN_FAMILIES.has(project2.pkg.name) ? project2.pkg.name : "@bigcommerce/catalyst-core";
-  const guess = `${family}@${project2.pkg.version}`;
+  const family = project.pkg.name && KNOWN_FAMILIES.has(project.pkg.name) ? project.pkg.name : "@bigcommerce/catalyst-core";
+  const guess = `${family}@${project.pkg.version}`;
   consola.warn(`No \`catalyst.ref\` found in package.json. Inferred base: ${guess}`);
   if (assumeYes) return guess;
-  const ok = await confirm6({ message: `Upgrade from ${guess}?`, default: true }).catch(() => false);
+  const ok = await confirm7({ message: `Upgrade from ${guess}?`, default: true }).catch(() => false);
   if (!ok) {
     consola.info("Re-run with `--from <ref>` to set the base version explicitly.");
     return null;
   }
   return guess;
 }
-function printSummary(result, relDir, stampedPkg) {
+function printWorkspaceFindings(findings) {
+  if (findings.length === 0) return;
+  const pad = Math.max(...findings.map((finding) => finding.name.length));
+  const rows = findings.map((finding) => `  ${finding.name.padEnd(pad)}  ${finding.ours} \u2192 ^${finding.version}`).join("\n");
+  consola.warn(
+    `Catalyst dependencies still using the workspace protocol (${findings.length}):
+${rows}
+
+They resolve to your local packages/ copies, which \`catalyst upgrade\` does not update \u2014 so they never receive upgrades.`
+  );
+}
+function printSummary({
+  result,
+  relDir,
+  stampedPkg,
+  migratedDeps,
+  packageManager,
+  staleCli
+}) {
   const unresolved = result.conflicted.filter((f) => !(stampedPkg && f === "package.json"));
   const parts = [
     `${result.applied.length} updated`,
@@ -5221,18 +5947,31 @@ function printSummary(result, relDir, stampedPkg) {
   if (unresolved.length) parts.push(`${unresolved.length} with conflicts`);
   consola.log(`
 ${parts.join(", ")}`);
+  const pkgConflicted = unresolved.includes("package.json");
+  const depsChanged = migratedDeps > 0 || [...result.applied, ...result.added, ...result.conflicted].includes("package.json");
+  if (depsChanged && !pkgConflicted) {
+    consola.info(
+      `Dependencies changed \u2014 run \`${packageManager} install\` to update your lockfile.`
+    );
+  }
   if (unresolved.length) {
     const files = unresolved.map((f) => `  ${f}`).join("\n");
+    const install = depsChanged && pkgConflicted ? ` && ${packageManager} install` : "";
     consola.warn(
       `
 Staged the clean changes. ${unresolved.length} file(s) need conflict resolution (the <<<ours/===/theirs>>> markers):
 ${files}
 
-Resolve them, then: git add ${relDir} && git commit`
+Resolve them, then: git add ${relDir} && git commit${install}`
     );
   } else {
     consola.success("Staged all changes \u2014 review with `git diff --cached`, then commit.");
   }
+  if (staleCli) {
+    consola.info(
+      `Your Catalyst CLI is behind (${staleCli.current} \u2192 ${staleCli.latest}). Update it with \`${packageManager} add -D ${CATALYST_CLI_PACKAGE}@${staleCli.latest}\`.`
+    );
+  }
 }
 var upgrade = new Command13("upgrade").configureHelp({ showGlobalOptions: true }).aliases([
   "up",
@@ -5273,15 +6012,15 @@ Conflicts are written as standard <<<ours/===/theirs>>> markers \u2014 the upgra
 never aborts. Versions are git tags on the repository (not npm). Set GITHUB_TOKEN
 to raise the GitHub API rate limit.`
 ).action(async (version2, options) => {
-  const project2 = await resolveProject2(process.cwd());
-  if (!project2) {
+  const project = await resolveProject2(process.cwd());
+  if (!project) {
     consola.error(
       "Run `catalyst upgrade` from inside a Catalyst git repository (flat core/ repo or a project containing core/)."
     );
     process.exit(1);
   }
-  const { gitRoot, catalystRoot, relDir, pkgPath } = project2;
-  const baseRef = await resolveBaseRef(project2, options.from, options.yes ?? false);
+  const { gitRoot, catalystRoot, relDir, pkgPath } = project;
+  const baseRef = await resolveBaseRef(project, options.from, options.yes ?? false);
   if (!baseRef) process.exit(1);
   let basePackage;
   let upstreamRef;
@@ -5316,7 +6055,7 @@ to raise the GitHub API rate limit.`
       process.exit(1);
     }
   }
-  if (!project2.pkg.catalyst?.ref && !options.from && !options.dryRun) {
+  if (!project.pkg.catalyst?.ref && !options.from && !options.dryRun) {
     const { version: baseVersion } = parseRef(baseRef);
     const rawPkg = await readFile2(pkgPath, "utf-8");
     const parsedPkg = z17.record(z17.string(), z17.unknown()).parse(JSON.parse(rawPkg));
@@ -5327,15 +6066,18 @@ to raise the GitHub API rate limit.`
     consola.success(`Added catalyst.ref \u2192 ${baseRef}`);
   }
   const token = process.env.GITHUB_TOKEN;
-  const tmpDir = await mkdtemp(join14(tmpdir(), "catalyst-upgrade-"));
+  const tmpDir = await mkdtemp(join15(tmpdir(), "catalyst-upgrade-"));
   try {
-    const baseDir = join14(tmpDir, "base");
-    const theirsDir = join14(tmpDir, "theirs");
-    const emptyFile = join14(tmpDir, ".empty");
+    const baseDir = join15(tmpDir, "base");
+    const theirsDir = join15(tmpDir, "theirs");
+    const emptyFile = join15(tmpDir, ".empty");
     await writeFile2(emptyFile, "");
+    const staleCliCheck = findStaleCli(project.rawContent).catch(() => null);
     const downloadSpinner = yoctoSpinner4().start(`Downloading ${baseRef} and ${upstreamRef}...`);
+    let baseVersions;
+    let targetVersions;
     try {
-      await Promise.all([
+      [baseVersions, targetVersions] = await Promise.all([
         downloadCore(options.repository, baseRef, baseDir, token),
         downloadCore(options.repository, upstreamRef, theirsDir, token)
       ]);
@@ -5344,7 +6086,7 @@ to raise the GitHub API rate limit.`
       downloadSpinner.error("Download failed");
       throw err;
     }
-    if (!project2.pkg.catalyst?.ref && !options.from) {
+    if (!project.pkg.catalyst?.ref && !options.from) {
       const similarity = await computeBaseSimilarity(baseDir, catalystRoot);
       const pct = Math.round(similarity * 100);
       if (similarity < 0.5) {
@@ -5355,6 +6097,13 @@ to raise the GitHub API rate limit.`
     }
     const resolvedVersion = MOVING_TAGS.has(upstreamTagVersion) ? await readResolvedVersion(theirsDir) : upstreamTagVersion;
     const newRef = MOVING_TAGS.has(upstreamTagVersion) ? `${basePackage}@${resolvedVersion}` : upstreamRef;
+    const { workspace: workspaceDeps, bumped } = await normalizeWorkspaceDeps(
+      project.rawContent,
+      baseDir,
+      theirsDir,
+      baseVersions,
+      targetVersions
+    );
     if (options.dryRun) {
       const diffSpinner = yoctoSpinner4().start("Generating diff...");
       const diff = await execa4(
@@ -5374,6 +6123,7 @@ to raise the GitHub API rate limit.`
       diffSpinner.success(`Diff ready \u2014 ${fileCount} file(s) affected.`);
       consola.log("\nDiff preview (--dry-run, not applied):\n");
       consola.log(diff.stdout);
+      printWorkspaceFindings(workspaceDeps);
       return;
     }
     const strategy = await resolveStrategy(options.strategy);
@@ -5390,13 +6140,13 @@ to raise the GitHub API rate limit.`
       mergeSpinner.success("Merged cleanly.");
     }
     const patchedRaw = await readFile2(pkgPath, "utf-8");
-    let stampedPkg = false;
+    let stampedText = null;
     try {
       const patchedPkg = z17.record(z17.string(), z17.unknown()).parse(JSON.parse(patchedRaw));
       patchedPkg.catalyst = { version: resolvedVersion, ref: newRef };
-      await writeFile2(pkgPath, `${JSON.stringify(patchedPkg, null, 2)}
-`);
-      stampedPkg = true;
+      stampedText = `${JSON.stringify(patchedPkg, null, 2)}
+`;
+      await writeFile2(pkgPath, stampedText);
       consola.success(`catalyst.ref updated \u2192 ${newRef}`);
     } catch {
       const catalystReplacement = JSON.stringify(
@@ -5421,14 +6171,35 @@ to raise the GitHub API rate limit.`
         );
       }
     }
+    printWorkspaceFindings(workspaceDeps);
+    let migratedDeps = 0;
+    if (workspaceDeps.length) {
+      const accepted = stampedText !== null && (options.yes === true || Boolean(process.stdin.isTTY) && await confirm7({
+        message: "Replace them with the published versions?",
+        default: true
+      }).catch(() => false));
+      if (accepted && stampedText !== null) {
+        await writeFile2(pkgPath, migrateWorkspaceDeps(stampedText, workspaceDeps));
+        migratedDeps = workspaceDeps.length;
+        consola.success(
+          `Migrated ${migratedDeps} dependenc${migratedDeps === 1 ? "y" : "ies"} to published versions.`
+        );
+      } else {
+        consola.info(
+          "Keeping the workspace references. Switching abandons any local packages/ copy you've customized; otherwise apply the versions above in package.json and reinstall."
+        );
+      }
+    }
     try {
-      await applyIndexState(gitRoot, relDir, baseDir, theirsDir, result, stampedPkg);
+      await applyIndexState(gitRoot, relDir, baseDir, theirsDir, result, stampedText !== null);
     } catch (err) {
       consola.warn(
         `Couldn't auto-stage the changes (${err instanceof Error ? err.message : String(err)}). Your files are merged on disk \u2014 run \`git add ${relDir}\` yourself.`
       );
     }
     const gitVersion = await execa4("git", ["--version"]).then((r) => r.stdout.trim()).catch(() => "unknown");
+    const packageManager = await detectLockfileManager(gitRoot) ?? "pnpm";
+    const staleCli = await staleCliCheck;
     await getTelemetry().track("upgrade", {
       strategy,
       gitVersion,
@@ -5437,9 +6208,20 @@ to raise the GitHub API rate limit.`
       added: result.added.length,
       deleted: result.deleted.length,
       conflicts: result.conflicted.length,
-      hasConflicts: result.conflicted.length > 0
+      hasConflicts: result.conflicted.length > 0,
+      workspaceDepsFound: workspaceDeps.length,
+      workspaceDepsMigrated: migratedDeps,
+      catalystDepsBumped: bumped.length,
+      cliOutdated: staleCli !== null
+    });
+    printSummary({
+      result,
+      relDir,
+      stampedPkg: stampedText !== null,
+      migratedDeps,
+      packageManager,
+      staleCli
     });
-    printSummary(result, relDir, stampedPkg);
   } finally {
     await rm2(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 500 });
   }
@@ -5516,7 +6298,7 @@ consola.log(colorize13("cyanBright", `\u25E2 ${package_default.name} v${package_
 `));
 program.name(package_default.name).version(package_default.version).summary("CLI tool for Catalyst development").description(
   "CLI tool for Catalyst development.\n\nConfiguration priority: flags > process.env > .bigcommerce/project.json. `build` and `deploy` additionally load env files (--env-path, or an auto-loaded .env.local/.env) for the build.\n\nCATALYST_STORE_HASH falls back to BIGCOMMERCE_STORE_HASH if unset.\n\nRun `catalyst <command> --help` for details on a specific command."
-).configureHelp({ showGlobalOptions: true }).addCommand(version).addCommand(create2).addCommand(start).addCommand(build).addCommand(deploy).addCommand(domains).addCommand(logs).addCommand(project).addCommand(env).addCommand(channel).addCommand(auth).addCommand(upgrade).addCommand(telemetry).addCommand(debug).hook("preAction", telemetryPreHook).hook("postAction", telemetryPostHook);
+).configureHelp({ showGlobalOptions: true }).addCommand(version).addCommand(create2).addCommand(start).addCommand(build).addCommand(deploy).addCommand(domains).addCommand(logs).addCommand(projects).addCommand(env).addCommand(channels).addCommand(auth).addCommand(upgrade).addCommand(telemetry).addCommand(debug).hook("preAction", telemetryPreHook).hook("postAction", telemetryPostHook);
 
 // src/cli/index.ts
 var handleFatalError = async (error) => {