@prisma/cli 3.0.0-dev.97.1 → 8.0.0-rc.1

package/dist/controllers/app.js

@@ -1,21 +1,21 @@
-import { SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "../lib/auth/client.js";
-import { FileTokenStorage } from "../adapters/token-storage.js";
-import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
-import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
-import { DEFAULT_REGION } from "../lib/app/app-interaction.js";
-import { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, resolveConfiguredAppBuildSettings, resolveInferredAppBuildSettings } from "../lib/app/build-settings.js";
-import { APP_BUILD_TYPES, RESOLVED_APP_BUILD_TYPES, executeAppBuild } from "../lib/app/build.js";
-import { envVarNames, parseEnvInputs } from "../lib/app/env-vars.js";
-import { DomainApiError, createAppProvider } from "../lib/app/app-provider.js";
+import { formatCommandArgument } from "../command-arguments.js";
+import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../errors.js";
 import { renderCommandHeader } from "../shell/ui.js";
+import { getApiBaseUrl } from "../auth/client.js";
+import { sameWorkspaceId } from "../lib/workspace-id.js";
+import { FileTokenStorage } from "../auth/token-storage.js";
+import { authenticatedManagementApiClient } from "../auth/guard.js";
+import { readAuthState } from "../auth/operations.js";
 import { canPrompt } from "../shell/runtime.js";
-import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
-import { formatCommandArgument } from "../shell/command-arguments.js";
-import { buildProjectSetupNextActions, inferTargetName, localProjectWorkspaceMismatchError, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
-import { bindProjectToDirectory, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
+import { writeJsonEvent } from "../shell/output.js";
+import { APP_BUILD_TYPES, APP_BUILD_TYPE_LABELS, RESOLVED_APP_BUILD_TYPES, executeAppBuild } from "../lib/app/build.js";
+import { envVarNames, parseEnvInputs } from "../lib/app/env-vars.js";
+import { DomainApiError, createAppProvider } from "../lib/app/app-provider.js";
+import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
 import { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.js";
+import { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, resolveConfiguredAppBuildSettings, resolveInferredAppBuildSettings } from "../lib/app/build-settings.js";
 import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
-import { COMPUTE_CONFIG_FILENAME as COMPUTE_CONFIG_FILENAME$1, ComputeConfigTargetRequiredError, computeConfigErrorToCliError, computeFrameworkToBuildType, computeTargetAppDir, inferComputeTargetFromCwd, loadComputeConfig as loadComputeConfig$1, mergeComputeDeployInputs, mergeComputeLocalInputs, selectComputeDeployTarget } from "../lib/app/compute-config.js";
+import { computeConfigErrorToCliError, computeFrameworkToBuildType, loadComputeConfig as loadComputeConfig$1, mergeComputeDeployInputs, mergeComputeLocalInputs } from "../lib/app/compute-config.js";
 import { renderDeployOutputRows, renderDeploySettingsPreview } from "../lib/app/deploy-output.js";
 import { describeDeployAllFailure, perAppInputsForDeployAll, planAppDeploy } from "../lib/app/deploy-plan.js";
 import { createDeployProgress, createDeployProgressState, createPromoteProgress } from "../lib/app/deploy-progress.js";
@@ -23,26 +23,41 @@ import { formatDomainFailureFix } from "../lib/app/domain-guidance.js";
 import { DEFAULT_LOCAL_DEV_PORT, runLocalApp } from "../lib/app/local-dev.js";
 import { enforceProductionDeployGate } from "../lib/app/production-deploy-gate.js";
 import { resolveReadBranch } from "../lib/app/read-branch.js";
-import { requireComputeAuth } from "../lib/auth/guard.js";
-import { readAuthState } from "../lib/auth/auth-ops.js";
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
+import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
+import { buildProjectSetupNextActions, inferTargetName, localProjectWorkspaceMismatchError, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
+import { bindProjectToDirectory, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
-import { writeJsonEvent } from "../shell/output.js";
+import { maybePromptForAgentSetup } from "./agent-setup.js";
 import { createSelectPromptPort } from "./select-prompt-port.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
-import { ENTRYPOINT_BUILD_TYPES, FRAMEWORKS, LOCAL_DEV_BUILD_TYPES, frameworkByKey, frameworkFromAlias, isConfigBackedBuildType } from "@prisma/compute-sdk/config";
-import { access, readFile } from "node:fs/promises";
 import path from "node:path";
-import { Result, matchError } from "better-result";
+import { access } from "node:fs/promises";
+import { COMPUTE_CONFIG_FILENAME, COMPUTE_REGIONS, ComputeConfigTargetRequiredError, ENTRYPOINT_BUILD_TYPES, FRAMEWORKS, LOCAL_DEV_BUILD_TYPES, computeTargetAppDir, frameworkByKey, frameworkFromAlias, inferComputeTargetFromCwd, isConfigBackedBuildType, selectComputeDeployTarget } from "@prisma/compute-sdk/config";
+import { SERVICE_TOKEN_ENV_VAR } from "@prisma/cli-engine";
 import open from "open";
+import { detectComputeAppFromDirectory } from "@prisma/compute-sdk/config/directory";
+import { matchError } from "better-result";
 //#region src/controllers/app.ts
 const FRAMEWORK_DEFAULT_HTTP_PORT = 3e3;
 const PRISMA_PROJECT_ID_ENV_VAR = "PRISMA_PROJECT_ID";
 const PRISMA_APP_ID_ENV_VAR = "PRISMA_APP_ID";
-function isRealMode(context) {
-	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
-}
+const COMPUTE_REGION_IDS = new Set(COMPUTE_REGIONS);
+const APP_COMMAND_PREFIX = /^app /;
+const TRAILING_DOT = /\.$/;
+const DOMAIN_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const CNAME_TO_PHRASE = /\bcname(?:s)?\s+to\b/;
+const PRISMA_BUILD_HOSTNAME = /\b((?:[a-z0-9-]+\.)+prisma\.build)\b/i;
+const WAIT_TIMEOUT_DURATION = /^(\d+)(ms|s|m|h)$/;
+const WAIT_TIMEOUT_UNIT_MULTIPLIER_MS = {
+	ms: 1,
+	s: 1e3,
+	m: 60 * 1e3,
+	h: 3600 * 1e3
+};
+const NEXTJS_MENTION = /next\.?js/i;
+const STANDALONE_OUTPUT_MENTION = /standalone output/i;
 async function runAppBuild(context, options) {
 	const compute = await resolveComputeTargetOrThrow(context, options?.configTarget, "build");
 	const merged = mergeComputeLocalInputs({
@@ -102,7 +117,7 @@ async function runAppRun(context, options) {
 		},
 		target: compute.target
 	});
-	if (merged.buildTypeFromConfig && compute.target?.framework && !frameworkByKey(compute.target.framework).hasLocalDevServer) throw usageError(`App run does not support the ${compute.target?.framework} framework yet`, `${compute.config?.relativeConfigPath ?? COMPUTE_CONFIG_FILENAME$1} sets a framework that has no local dev server in the current preview.`, "Run the framework dev server directly, or pass --build-type nextjs or --build-type bun to override.", ["prisma-cli app run --build-type nextjs", "prisma-cli app run --build-type bun --entry server.ts"], "app");
+	if (merged.buildTypeFromConfig && compute.target?.framework && !frameworkByKey(compute.target.framework).hasLocalDevServer) throw usageError(`App run does not support the ${compute.target?.framework} framework yet`, `${compute.config?.relativeConfigPath ?? COMPUTE_CONFIG_FILENAME} sets a framework that has no local dev server in the current preview.`, "Run the framework dev server directly, or pass --build-type nextjs or --build-type bun to override.", ["prisma-cli app run --build-type nextjs", "prisma-cli app run --build-type bun --entry server.ts"], "app");
 	const appDir = await resolveComputeAppDir(context, compute);
 	const buildType = normalizeBuildType(merged.buildType);
 	assertSupportedEntrypoint(buildType, merged.entrypoint, "run");
@@ -110,7 +125,8 @@ async function runAppRun(context, options) {
 	const framework = await resolveLocalRunFramework(context, {
 		requestedBuildType: buildType,
 		configFramework: compute.target?.framework ?? null,
-		appDir
+		appDir,
+		entrypoint: merged.entrypoint
 	});
 	const entrypoint = framework.buildType === "bun" ? await resolveDeployEntrypoint(appDir, framework, merged.entrypoint, context.runtime.signal) : merged.entrypoint;
 	let runResult;
@@ -141,7 +157,6 @@ async function runAppRun(context, options) {
 	};
 }
 async function runAppDeploy(context, appName, options) {
-	ensurePreviewAppMode(context);
 	const loaded = await loadComputeConfig$1(context.runtime.cwd, context.runtime.signal);
 	if (loaded.isErr()) throw computeConfigErrorToCliError(loaded.error, "deploy");
 	const config = loaded.value;
@@ -154,7 +169,7 @@ async function runAppDeploy(context, appName, options) {
 	return runSingleAppDeploy(context, appName, options, config);
 }
 async function runAppDeployAll(context, config, plannedTargets, appName, options) {
-	assertNoPerAppInputsForDeployAll(context, config, appName, options);
+	assertNoPerAppInputsForDeployAll(context, plannedTargets, appName, options);
 	const deployments = [];
 	const warnings = [];
 	for (const planned of plannedTargets) {
@@ -172,7 +187,7 @@ async function runAppDeployAll(context, config, plannedTargets, appName, options
 			});
 			warnings.push(...single.warnings);
 		} catch (error) {
-			throw deployAllFailedError(error, config, planned.index, deployments);
+			throw deployAllFailedError(error, plannedTargets, planned.index, deployments);
 		}
 	}
 	return {
@@ -182,12 +197,13 @@ async function runAppDeployAll(context, config, plannedTargets, appName, options
 		nextSteps: ["prisma-cli app list-deploys <app>"]
 	};
 }
-function assertNoPerAppInputsForDeployAll(context, config, appName, options) {
+function assertNoPerAppInputsForDeployAll(context, plannedTargets, appName, options) {
 	const used = perAppInputsForDeployAll({
 		appName,
 		framework: options?.framework,
 		entrypoint: options?.entrypoint,
 		httpPort: options?.httpPort,
+		region: options?.region,
 		envAssignments: options?.envAssignments,
 		appIdEnvVar: {
 			name: PRISMA_APP_ID_ENV_VAR,
@@ -195,17 +211,17 @@ function assertNoPerAppInputsForDeployAll(context, config, appName, options) {
 		}
 	});
 	if (used.length === 0) return;
-	const targets = config.targets.map((target) => target.key).join(", ");
-	throw usageError(`Deploying all apps does not accept ${used.join(", ")}`, `Without a target, app deploy deploys every configured app (${targets}), so per-app inputs are ambiguous.`, "Pass the app target to apply per-app inputs to one app, or remove them to deploy all apps.", config.targets.map((target) => `prisma-cli app deploy ${target.key}`), "app");
+	const targetKeys = plannedTargets.map((target) => target.targetKey);
+	throw usageError(`Deploying all apps does not accept ${used.join(", ")}`, `Without a target, app deploy deploys every configured app (${targetKeys.join(", ")}), so per-app inputs are ambiguous.`, "Pass the app target to apply per-app inputs to one app, or remove them to deploy all apps.", targetKeys.map((target) => `prisma-cli app deploy ${target}`), "app");
 }
 function maybeRenderDeployAllTargetHeader(context, planned) {
 	if (context.flags.json || context.flags.quiet) return;
 	context.output.stderr.write(`${planned.index > 0 ? "\n" : ""}── ${planned.targetKey} (${planned.index + 1}/${planned.total}) ──\n\n`);
 }
-function deployAllFailedError(error, config, failedIndex, deployments) {
+function deployAllFailedError(error, plannedTargets, failedIndex, deployments) {
 	if (!(error instanceof CliError)) return error;
 	const failure = describeDeployAllFailure({
-		targetKeys: config.targets.map((target) => target.key),
+		targetKeys: plannedTargets.map((target) => target.targetKey),
 		failedIndex,
 		completed: deployments.map(({ target, result }) => ({
 			target,
@@ -255,18 +271,25 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 			framework: options?.framework,
 			entrypoint: options?.entrypoint,
 			httpPort: options?.httpPort,
+			region: options?.region,
 			envInputs: options?.envAssignments
 		},
 		target: computeConfig.target,
-		configFilename: computeConfig.config?.relativeConfigPath ?? COMPUTE_CONFIG_FILENAME$1
+		configFilename: computeConfig.config?.relativeConfigPath ?? COMPUTE_CONFIG_FILENAME
 	});
 	const appDir = await resolveComputeAppDir(context, computeConfig);
 	const projectDir = computeConfig.config?.configDir ?? context.runtime.cwd;
-	const localPinReadResult = Boolean(envProjectId || options?.projectRef || options?.createProjectName) ? Result.ok({ kind: "missing" }) : await readLocalResolutionPin(projectDir, context.runtime.signal);
-	if (localPinReadResult.isErr()) throw localPinReadErrorToDeployError(localPinReadResult.error);
-	const localPin = localPinReadResult.value;
+	const agentSetupWarnings = await maybePromptForAgentSetup(context, projectDir);
+	const localPin = await readDeployLocalPin({
+		projectDir,
+		signal: context.runtime.signal,
+		envProjectId,
+		projectRef: options?.projectRef,
+		createProjectName: options?.createProjectName
+	});
 	const branch = await resolveDeployBranch(context, options?.branchName);
 	if (merged.httpPort) parseDeployHttpPort(merged.httpPort.value);
+	const deployRegion = normalizeDeployRegionInput(merged.region);
 	assertSupportedEntrypointForRequestedDeployShape({
 		requestedFramework: merged.framework?.value,
 		entrypoint: merged.entrypoint?.value
@@ -274,17 +297,11 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 	const { provider, target, projectId } = await requireProviderAndDeployProjectContext(context, options?.projectRef, {
 		branch,
 		createProjectName: options?.createProjectName,
+		createProjectRegion: deployRegion?.value,
 		envProjectId,
 		localPin
 	});
-	let localPinResult;
-	if (target.localPinAction) {
-		const setupResult = await bindProjectToDirectory(context, target.workspace, target.project, target.localPinAction, projectDir);
-		if (setupResult.isErr()) throw projectDirectoryBindingErrorToCliError(setupResult.error);
-		const projectSetup = setupResult.value;
-		localPinResult = projectSetup.localPin;
-		maybeRenderProjectLinked(context, projectSetup.directory, projectSetup.project.name, projectSetup.localPin.path);
-	}
+	const localPinResult = await bindDeployProjectDirectory(context, target, projectDir);
 	let framework = await resolveDeployFramework(context, {
 		requestedFramework: merged.framework?.value,
 		requestedFrameworkAnnotation: merged.framework?.annotation,
@@ -299,6 +316,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 		explicitAppName: appName,
 		explicitAppId: envAppId,
 		configAppName: merged.configAppName,
+		configRegion: deployRegion,
 		firstDeploy: Boolean(target.localPinAction),
 		inferName: () => inferTargetName(appDir, context.runtime.signal)
 	});
@@ -319,7 +337,8 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 	});
 	framework = customized.framework;
 	runtime = customized.runtime;
-	const productionDeployGate = await enforceProductionDeployGate(context, provider, {
+	const noPromote = options?.noPromote === true;
+	const productionDeployGate = noPromote ? { firstProductionDeploy: false } : await enforceProductionDeployGate(context, provider, {
 		appId: selectedApp.appId,
 		appName: selectedApp.displayName,
 		branchKind: target.branch.kind,
@@ -328,15 +347,9 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 	const buildType = framework.buildType;
 	assertSupportedEntrypoint(buildType, merged.entrypoint?.value, "deploy");
 	const entrypoint = await resolveDeployEntrypoint(appDir, framework, merged.entrypoint?.value, context.runtime.signal);
-	if (computeConfig.target?.build) assertConfigBackedBuildSettings(buildType);
-	const buildSettingsResolution = computeConfig.config && computeConfig.target?.build && isConfigBackedBuildType(buildType) ? await resolveConfiguredAppBuildSettings({
-		appPath: appDir,
-		buildType,
-		configured: computeConfig.target.build,
-		configPath: computeConfig.config.configPath,
-		signal: context.runtime.signal
-	}) : await resolveInferredAppBuildSettings({
-		appPath: appDir,
+	const buildSettingsResolution = await resolveDeployBuildSettings({
+		computeConfig,
+		appDir,
 		buildType,
 		signal: context.runtime.signal
 	});
@@ -363,6 +376,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 		buildSettings: buildSettingsResolution.settings,
 		portMapping,
 		envVars,
+		skipPromote: noPromote,
 		interaction: void 0,
 		signal: context.runtime.signal,
 		progress: createDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
@@ -370,11 +384,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 		throw appDeployFailedError(error, progressState);
 	});
 	const deployDurationMs = Date.now() - deployStartedAt;
-	await context.stateStore.setSelectedApp(projectId, {
-		id: deployResult.app.id,
-		name: deployResult.app.name
-	});
-	await context.stateStore.setKnownLiveDeployment(projectId, deployResult.app.id, deployResult.deployment.id);
+	await cacheDeployedApp(context, projectId, deployResult);
 	return {
 		command: "app.deploy",
 		result: {
@@ -388,9 +398,10 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 				name: deployResult.app.name
 			},
 			deployment: deployResult.deployment,
+			promoted: deployResult.promoted,
 			deploySettings: {
 				config: {
-					path: buildSettingsResolution.relativeConfigPath,
+					path: computeConfig.config?.relativeConfigPath ?? null,
 					status: buildSettingsResolution.status
 				},
 				buildCommand: {
@@ -407,20 +418,62 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 					name: framework.displayName,
 					source: framework.annotation
 				},
-				entrypoint: entrypoint ?? null,
+				entrypoint: entrypoint ?? buildSettingsResolution.settings.entrypoint ?? null,
 				httpPort: runtime.port,
-				region: selectedApp.region ?? null,
+				region: deployResult.app.region ?? selectedApp.region ?? null,
+				regionSource: deployRegion?.annotation ?? null,
 				envVars: envVarNames(envVars)
 			},
 			durationMs: deployDurationMs,
 			localPin: localPinResult
 		},
-		warnings: [...legacyWarnings, ...branchDatabaseSetup.warnings],
-		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`]
+		warnings: [
+			...agentSetupWarnings,
+			...legacyWarnings,
+			...branchDatabaseSetup.warnings
+		],
+		nextSteps: deployResult.promoted ? ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`] : [`prisma-cli app promote ${deployResult.deployment.id}`, `prisma-cli app show-deploy ${deployResult.deployment.id}`]
 	};
 }
+async function readDeployLocalPin(options) {
+	if (options.envProjectId || options.projectRef || options.createProjectName) return { kind: "missing" };
+	const readResult = await readLocalResolutionPin(options.projectDir, options.signal);
+	if (readResult.isErr()) throw localPinReadErrorToDeployError(readResult.error);
+	return readResult.value;
+}
+async function bindDeployProjectDirectory(context, target, projectDir) {
+	if (!target.localPinAction) return;
+	const setupResult = await bindProjectToDirectory(context, target.workspace, target.project, target.localPinAction, projectDir);
+	if (setupResult.isErr()) throw projectDirectoryBindingErrorToCliError(setupResult.error);
+	const projectSetup = setupResult.value;
+	maybeRenderProjectLinked(context, projectSetup.directory, projectSetup.project.name, projectSetup.localPin.path);
+	return projectSetup.localPin;
+}
+async function cacheDeployedApp(context, projectId, deployResult) {
+	await context.stateStore.setSelectedApp(projectId, {
+		id: deployResult.app.id,
+		name: deployResult.app.name
+	});
+	const knownLiveDeploymentId = deployResult.promoted ? deployResult.deployment.id : deployResult.app.liveDeploymentId;
+	if (knownLiveDeploymentId) await context.stateStore.setKnownLiveDeployment(projectId, deployResult.app.id, knownLiveDeploymentId);
+}
+async function resolveDeployBuildSettings(options) {
+	const { computeConfig, appDir, buildType, signal } = options;
+	if (computeConfig.target?.build) assertConfigBackedBuildSettings(buildType);
+	if (computeConfig.config && computeConfig.target?.build && isConfigBackedBuildType(buildType)) return resolveConfiguredAppBuildSettings({
+		appPath: appDir,
+		buildType,
+		configured: computeConfig.target.build,
+		configPath: computeConfig.config.configPath,
+		signal
+	});
+	return resolveInferredAppBuildSettings({
+		appPath: appDir,
+		buildType,
+		signal
+	});
+}
 async function runAppListDeploys(context, appName, projectRef, configTarget) {
-	ensurePreviewAppMode(context);
 	const compute = await resolveComputeManagementContext(context, configTarget, "list-deploys");
 	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
 		commandName: "app list-deploys",
@@ -463,7 +516,6 @@ async function runAppListDeploys(context, appName, projectRef, configTarget) {
 	};
 }
 async function runAppShow(context, appName, projectRef, configTarget) {
-	ensurePreviewAppMode(context);
 	const compute = await resolveComputeManagementContext(context, configTarget, "show");
 	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
 		commandName: "app show",
@@ -511,7 +563,6 @@ async function runAppShow(context, appName, projectRef, configTarget) {
 	};
 }
 async function runAppShowDeploy(context, deploymentId) {
-	ensurePreviewAppMode(context);
 	const deployment = await (await requirePreviewAppProvider(context)).showDeployment(deploymentId, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to show deployment", error, ["prisma-cli app list-deploys"]);
 	});
@@ -527,7 +578,7 @@ async function runAppShowDeploy(context, deploymentId) {
 	const workspaceId = deployment?.app ? await readCurrentWorkspaceId(context) : null;
 	const rememberedProject = workspaceId ? await context.stateStore.readRememberedProject(workspaceId) : null;
 	const knownLiveDeploymentId = deployment?.app && rememberedProject ? await context.stateStore.readKnownLiveDeployment(rememberedProject.id, deployment.app.id) : null;
-	const providerLiveDeploymentId = deployment.app?.liveDeploymentId ?? null;
+	const liveDeploymentId = deployment.app?.liveDeploymentId || knownLiveDeploymentId;
 	return {
 		command: "app.show-deploy",
 		result: {
@@ -537,17 +588,16 @@ async function runAppShowDeploy(context, deploymentId) {
 			} : null,
 			deployment: {
 				...deployment.deployment,
-				live: providerLiveDeploymentId ? deployment.deployment.id === providerLiveDeploymentId : knownLiveDeploymentId ? deployment.deployment.id === knownLiveDeploymentId : deployment.deployment.live
+				live: liveDeploymentId ? deployment.deployment.id === liveDeploymentId : deployment.deployment.live
 			}
 		},
 		warnings: [],
 		nextSteps: []
 	};
 }
-async function runAppOpen(context, appName, projectRef, configTarget) {
-	ensurePreviewAppMode(context);
+async function runAppOpen(context, appNameArg, projectRef, configTarget) {
 	const compute = await resolveComputeManagementContext(context, configTarget, "open");
-	appName = appName ?? compute.configAppName;
+	const appName = appNameArg ?? compute.configAppName;
 	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
 		commandName: "app open",
 		projectDir: compute.projectDir
@@ -715,10 +765,9 @@ async function runAppDomainWait(context, hostname, options) {
 		});
 	}
 }
-async function runAppLogs(context, appName, deploymentId, projectRef, configTarget) {
-	ensurePreviewAppMode(context);
+async function runAppLogs(context, appNameArg, deploymentId, projectRef, configTarget) {
 	const compute = await resolveComputeManagementContext(context, configTarget, "logs");
-	appName = appName ?? compute.configAppName;
+	const appName = appNameArg ?? compute.configAppName;
 	const { provider, target: resolvedTarget, projectId } = await requireProviderAndProjectContext(context, projectRef, {
 		commandName: "app logs",
 		projectDir: compute.projectDir
@@ -844,10 +893,9 @@ function writeLogRecord(context, record) {
 		if (!record.text.endsWith("\n")) context.output.stdout.write("\n");
 	}
 }
-async function runAppPromote(context, deploymentId, appName, projectRef, configTarget) {
-	ensurePreviewAppMode(context);
+async function runAppPromote(context, deploymentId, appNameArg, projectRef, configTarget) {
 	const compute = await resolveComputeManagementContext(context, configTarget, "promote");
-	appName = appName ?? compute.configAppName;
+	const appName = appNameArg ?? compute.configAppName;
 	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
 		commandName: "app promote",
 		projectDir: compute.projectDir
@@ -891,10 +939,9 @@ async function runAppPromote(context, deploymentId, appName, projectRef, configT
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${targetDeployment.id}`]
 	};
 }
-async function runAppRollback(context, appName, deploymentId, projectRef, configTarget) {
-	ensurePreviewAppMode(context);
+async function runAppRollback(context, appNameArg, deploymentId, projectRef, configTarget) {
 	const compute = await resolveComputeManagementContext(context, configTarget, "rollback");
-	appName = appName ?? compute.configAppName;
+	const appName = appNameArg ?? compute.configAppName;
 	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
 		commandName: "app rollback",
 		projectDir: compute.projectDir
@@ -940,11 +987,18 @@ async function runAppRollback(context, appName, deploymentId, projectRef, config
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${targetDeployment.id}`]
 	};
 }
-async function runAppRemove(context, appName, projectRef, configTarget) {
-	ensurePreviewAppMode(context);
+/**
+* Removes an app and every deployment it owns in the resolved branch.
+*
+* @param branchName Scopes the removal to this branch. When omitted the branch
+* is inferred from the local Git branch, falling back to the production branch.
+*/
+async function runAppRemove(context, appNameArg, projectRef, configTarget, branchName) {
 	const compute = await resolveComputeManagementContext(context, configTarget, "remove");
-	appName = appName ?? compute.configAppName;
+	const appName = appNameArg ?? compute.configAppName;
+	if (branchName !== void 0 && branchName.trim() === "") throw usageError("The --branch value cannot be empty", "app remove scopes the removal to the given branch; an empty --branch would silently fall back to the inferred (possibly production) branch.", "Pass a non-empty branch name, e.g. --branch <branch>, or omit --branch to use the inferred branch.", ["prisma-cli app remove --app <name> --branch <branch>"], "app");
 	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
+		branch: branchName !== void 0 ? await resolveDeployBranch(context, branchName) : void 0,
 		commandName: "app remove",
 		projectDir: compute.projectDir
 	});
@@ -970,8 +1024,7 @@ async function runAppRemove(context, appName, projectRef, configTarget) {
 	};
 }
 async function resolveAppDomainTarget(context, options, commandName = "app domain") {
-	ensurePreviewAppMode(context);
-	const compute = await resolveComputeManagementContext(context, options?.configTarget, commandName.replace(/^app /, ""));
+	const compute = await resolveComputeManagementContext(context, options?.configTarget, commandName.replace(APP_COMMAND_PREFIX, ""));
 	const branch = resolveDomainBranch(options?.branchName);
 	if (toBranchKind(branch.name) !== "production") throw new CliError({
 		code: "BRANCH_NOT_DEPLOYABLE",
@@ -1036,7 +1089,7 @@ async function resolveDomainByHostname(provider, appId, hostname, command, signa
 	throw domainNotFoundError(hostname);
 }
 function normalizeDomainHostname(hostname) {
-	const normalized = hostname.trim().replace(/\.$/, "").toLowerCase();
+	const normalized = hostname.trim().replace(TRAILING_DOT, "").toLowerCase();
 	if (!isValidDomainHostname(normalized)) throw new CliError({
 		code: "DOMAIN_HOSTNAME_INVALID",
 		domain: "app",
@@ -1053,10 +1106,10 @@ function isValidDomainHostname(hostname) {
 	if (hostname.includes("://") || hostname.includes("/") || hostname.includes(":") || hostname.startsWith("*.")) return false;
 	const labels = hostname.split(".");
 	if (labels.length < 2) return false;
-	return labels.every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label));
+	return labels.every((label) => DOMAIN_LABEL.test(label));
 }
 function sameDomainHostname(left, right) {
-	return left.trim().replace(/\.$/, "").toLowerCase() === right.trim().replace(/\.$/, "").toLowerCase();
+	return left.trim().replace(TRAILING_DOT, "").toLowerCase() === right.trim().replace(TRAILING_DOT, "").toLowerCase();
 }
 function toAppDomainSummary(domain) {
 	return {
@@ -1064,7 +1117,7 @@ function toAppDomainSummary(domain) {
 		type: domain.type,
 		url: domain.url,
 		hostname: domain.hostname,
-		computeServiceId: domain.computeServiceId,
+		appId: domain.appId,
 		status: domain.status,
 		foundryStatus: domain.foundryStatus,
 		failureReason: domain.failureReason,
@@ -1102,55 +1155,15 @@ async function confirmDomainRemoval(context, target, hostname) {
 	if (!await confirmPrompt({
 		input: context.runtime.stdin,
 		output: context.output.stderr,
+		signal: context.runtime.signal,
 		message: `Detach ${hostname} from App "${target.app.name}"?`,
 		initialValue: false
 	})) throw usageError("Custom domain removal canceled", "The command was canceled before the domain was detached.", "Rerun the command and confirm removal, or pass --yes.", [`prisma-cli app domain remove ${hostname} --app ${target.app.name} --yes`], "app");
 }
 function domainCommandError(command, error, hostname) {
 	if (error instanceof DomainApiError) {
-		if (command === "add" && (error.status === 400 || error.status === 422) && isDomainDnsError(error)) return domainDnsNotConfiguredError(hostname, error);
-		if (command === "add" && error.status === 400) return new CliError({
-			code: "DOMAIN_HOSTNAME_INVALID",
-			domain: "app",
-			summary: `Invalid custom domain "${hostname}"`,
-			why: error.message,
-			fix: "Pass a valid hostname like shop.acme.com and make sure DNS can be verified.",
-			debug: formatDebugDetails(error),
-			exitCode: 2,
-			nextSteps: ["prisma-cli app domain add shop.acme.com"]
-		});
-		if (command === "add" && (error.status === 429 || isDomainQuotaError(error))) return new CliError({
-			code: "DOMAIN_QUOTA_EXCEEDED",
-			domain: "app",
-			summary: "Custom domain quota exceeded",
-			why: error.message,
-			fix: "Remove an existing custom domain before adding another one.",
-			debug: formatDebugDetails(error),
-			exitCode: 1,
-			nextSteps: ["prisma-cli app domain remove <hostname>"]
-		});
-		if (command === "add" && error.status === 409) return domainAlreadyRegisteredError(hostname, error);
-		if (command === "add" && error.status === 422) return new CliError({
-			code: "NO_DEPLOYMENTS",
-			domain: "app",
-			summary: "Custom domain requires a live production deployment",
-			why: "The selected production app does not have a promoted version that can receive a custom domain.",
-			fix: "Deploy the app to the production branch, then rerun the domain command.",
-			debug: formatDebugDetails(error),
-			exitCode: 1,
-			nextSteps: ["prisma-cli app deploy --branch production", `prisma-cli app domain add ${hostname}`]
-		});
-		if ((command === "show" || command === "remove" || command === "retry" || command === "wait") && error.status === 404) return domainNotFoundError(hostname);
-		if (command === "retry" && error.status === 409) return new CliError({
-			code: "DOMAIN_RETRY_NOT_ELIGIBLE",
-			domain: "app",
-			summary: `Custom domain "${hostname}" is not eligible for retry`,
-			why: error.message,
-			fix: "Wait for the current verification or TLS step to finish, then rerun retry if the domain fails.",
-			debug: formatDebugDetails(error),
-			exitCode: 1,
-			nextSteps: [`prisma-cli app domain show ${hostname}`]
-		});
+		const apiError = command === "add" ? domainAddApiError(hostname, error) : domainLookupApiError(command, hostname, error);
+		if (apiError) return apiError;
 	}
 	return new CliError({
 		code: "DEPLOY_FAILED",
@@ -1163,6 +1176,55 @@ function domainCommandError(command, error, hostname) {
 		nextSteps: [`prisma-cli app domain show ${hostname}`]
 	});
 }
+function domainAddApiError(hostname, error) {
+	if ((error.status === 400 || error.status === 422) && isDomainDnsError(error)) return domainDnsNotConfiguredError(hostname, error);
+	if (error.status === 400) return new CliError({
+		code: "DOMAIN_HOSTNAME_INVALID",
+		domain: "app",
+		summary: `Invalid custom domain "${hostname}"`,
+		why: error.message,
+		fix: "Pass a valid hostname like shop.acme.com and make sure DNS can be verified.",
+		debug: formatDebugDetails(error),
+		exitCode: 2,
+		nextSteps: ["prisma-cli app domain add shop.acme.com"]
+	});
+	if (error.status === 429 || isDomainQuotaError(error)) return new CliError({
+		code: "DOMAIN_QUOTA_EXCEEDED",
+		domain: "app",
+		summary: "Custom domain quota exceeded",
+		why: error.message,
+		fix: "Remove an existing custom domain before adding another one.",
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: ["prisma-cli app domain remove <hostname>"]
+	});
+	if (error.status === 409) return domainAlreadyRegisteredError(hostname, error);
+	if (error.status === 422) return new CliError({
+		code: "NO_DEPLOYMENTS",
+		domain: "app",
+		summary: "Custom domain requires a live production deployment",
+		why: "The selected production app does not have a promoted version that can receive a custom domain.",
+		fix: "Deploy the app to the production branch, then rerun the domain command.",
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: ["prisma-cli app deploy --branch production", `prisma-cli app domain add ${hostname}`]
+	});
+	return null;
+}
+function domainLookupApiError(command, hostname, error) {
+	if (error.status === 404) return domainNotFoundError(hostname);
+	if (command === "retry" && error.status === 409) return new CliError({
+		code: "DOMAIN_RETRY_NOT_ELIGIBLE",
+		domain: "app",
+		summary: `Custom domain "${hostname}" is not eligible for retry`,
+		why: error.message,
+		fix: "Wait for the current verification or TLS step to finish, then rerun retry if the domain fails.",
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: [`prisma-cli app domain show ${hostname}`]
+	});
+	return null;
+}
 function isDomainQuotaError(error) {
 	if (error.status !== 409) return false;
 	const text = `${error.message} ${error.hint ?? ""}`.toLowerCase();
@@ -1182,7 +1244,7 @@ function domainAlreadyRegisteredError(hostname, error) {
 }
 function isDomainDnsError(error) {
 	const text = `${error.message} ${error.hint ?? ""}`.toLowerCase();
-	return text.includes("dns is not configured") || text.includes("dns verification failed") || text.includes("no cname") || text.includes("cname record") || text.includes("no a/aaaa") || /\bcname(?:s)?\s+to\b/.test(text);
+	return text.includes("dns is not configured") || text.includes("dns verification failed") || text.includes("no cname") || text.includes("cname record") || text.includes("no a/aaaa") || CNAME_TO_PHRASE.test(text);
 }
 function domainDnsNotConfiguredError(hostname, error) {
 	const target = extractDomainDnsTarget(error);
@@ -1200,7 +1262,7 @@ function domainDnsNotConfiguredError(hostname, error) {
 }
 function extractDomainDnsTarget(error) {
 	const text = `${error.hint ?? ""} ${error.message}`;
-	return /\b((?:[a-z0-9-]+\.)+prisma\.build)\b/i.exec(text)?.[1]?.toLowerCase() ?? null;
+	return PRISMA_BUILD_HOSTNAME.exec(text)?.[1]?.toLowerCase() ?? null;
 }
 function domainNotFoundError(hostname) {
 	return new CliError({
@@ -1221,11 +1283,9 @@ function parseDomainWaitTimeout(value) {
 	if (!value) return 900 * 1e3;
 	const trimmed = value.trim().toLowerCase();
 	if (trimmed === "0") return 0;
-	const match = /^(\d+)(ms|s|m|h)$/.exec(trimmed);
+	const match = WAIT_TIMEOUT_DURATION.exec(trimmed);
 	if (!match) throw usageError(`Invalid timeout "${value}"`, "Timeout must be a duration such as 0, 30s, 15m, or 1h.", "Pass --timeout 15m, or --timeout 0 to poll once.", ["prisma-cli app domain wait shop.acme.com --timeout 15m"], "app");
-	const amount = Number.parseInt(match[1], 10);
-	const unit = match[2];
-	return amount * (unit === "h" ? 3600 * 1e3 : unit === "m" ? 60 * 1e3 : unit === "s" ? 1e3 : 1);
+	return Number.parseInt(match[1], 10) * (WAIT_TIMEOUT_UNIT_MULTIPLIER_MS[match[2]] ?? 1);
 }
 function readDomainWaitPollIntervalMs(context) {
 	const raw = context.runtime.env.PRISMA_CLI_DOMAIN_WAIT_POLL_MS;
@@ -1276,27 +1336,19 @@ async function sleep(milliseconds, signal) {
 	});
 }
 async function resolveDeployAppSelection(context, projectId, apps, options) {
-	if (options.explicitAppName) {
-		const matches = findAppsByName(apps, options.explicitAppName);
-		if (matches.length > 1) return resolveAmbiguousDeployApp(context, matches, options.explicitAppName, options.firstDeploy);
-		const matched = matches[0];
-		if (matched) return {
-			appId: matched.id,
-			displayName: matched.name,
-			annotation: "set by --app",
-			firstDeploy: options.firstDeploy
-		};
-		return {
-			appName: options.explicitAppName,
-			region: DEFAULT_REGION,
-			displayName: options.explicitAppName,
-			annotation: "set by --app",
-			firstDeploy: options.firstDeploy
-		};
-	}
+	const newAppRegion = deployNewAppRegion(options.configRegion);
+	if (options.explicitAppName) return resolveDeployAppByName(context, apps, {
+		name: options.explicitAppName,
+		matchedAnnotation: "set by --app",
+		newAnnotation: "set by --app",
+		requestedRegion: options.configRegion,
+		newAppRegion,
+		firstDeploy: options.firstDeploy
+	});
 	if (options.explicitAppId) {
 		const matched = apps.find((app) => app.id === options.explicitAppId);
 		if (!matched) throw usageError("Selected app does not exist in the resolved project", `The app "${options.explicitAppId}" from ${PRISMA_APP_ID_ENV_VAR} could not be found in resolved project "${projectId}".`, `Unset ${PRISMA_APP_ID_ENV_VAR}, pass --app <name>, or choose an app from prisma-cli app list-deploys.`, ["prisma-cli app list-deploys"], "app");
+		assertDeployRegionMatchesExistingApp(matched, options.configRegion);
 		return {
 			appId: matched.id,
 			displayName: matched.name,
@@ -1306,42 +1358,52 @@ async function resolveDeployAppSelection(context, projectId, apps, options) {
 	}
 	if (options.configAppName) {
 		const configName = options.configAppName;
-		const matches = findAppsByName(apps, configName.value);
-		if (matches.length > 1) return resolveAmbiguousDeployApp(context, matches, configName.value, options.firstDeploy);
-		const matched = matches[0];
-		if (matched) return {
-			appId: matched.id,
-			displayName: matched.name,
-			annotation: configName.annotation,
+		return resolveDeployAppByName(context, apps, {
+			name: configName.value,
+			matchedAnnotation: configName.annotation,
+			newAnnotation: configName.annotation,
+			requestedRegion: options.configRegion,
+			newAppRegion,
 			firstDeploy: options.firstDeploy
-		};
+		});
+	}
+	const inferredName = await options.inferName();
+	const newAnnotation = inferredName.source === "package-name" ? "created from package.json" : "created from directory name";
+	return resolveDeployAppByName(context, apps, {
+		name: inferredName.name,
+		matchedAnnotation: "existing app on this branch",
+		newAnnotation,
+		requestedRegion: options.configRegion,
+		newAppRegion,
+		firstDeploy: options.firstDeploy
+	});
+}
+async function resolveDeployAppByName(context, apps, options) {
+	const matches = findAppsByName(apps, options.name);
+	if (matches.length > 1) return resolveAmbiguousDeployApp(context, matches, options.name, options.requestedRegion, options.newAppRegion, options.firstDeploy);
+	const matched = matches[0];
+	if (matched) {
+		assertDeployRegionMatchesExistingApp(matched, options.requestedRegion);
 		return {
-			appName: configName.value,
-			region: DEFAULT_REGION,
-			displayName: configName.value,
-			annotation: configName.annotation,
+			appId: matched.id,
+			displayName: matched.name,
+			annotation: options.matchedAnnotation,
 			firstDeploy: options.firstDeploy
 		};
 	}
-	const inferredName = await options.inferName();
-	const matches = findAppsByName(apps, inferredName.name);
-	if (matches.length > 1) return resolveAmbiguousDeployApp(context, matches, inferredName.name, options.firstDeploy);
-	const matched = matches[0];
-	if (matched) return {
-		appId: matched.id,
-		displayName: matched.name,
-		annotation: "existing app on this branch",
-		firstDeploy: options.firstDeploy
-	};
 	return {
-		appName: inferredName.name,
-		region: DEFAULT_REGION,
-		displayName: inferredName.name,
-		annotation: inferredName.source === "package-name" ? "created from package.json" : "created from directory name",
+		appName: options.name,
+		region: options.newAppRegion,
+		displayName: options.name,
+		annotation: options.newAnnotation,
 		firstDeploy: options.firstDeploy
 	};
 }
-async function resolveAmbiguousDeployApp(context, matches, targetName, firstDeploy) {
+function assertDeployRegionMatchesExistingApp(app, requestedRegion) {
+	if (requestedRegion?.annotation !== "set by --region" || !app.region || app.region === requestedRegion.value) return;
+	throw usageError("App already exists in another region", `The selected app "${app.name}" is in region "${app.region}", but --region requested "${requestedRegion.value}".`, "Remove --region to deploy the existing app, or pass --app <new-name> to create a new app in that region.", [`prisma-cli app deploy --app ${formatCommandArgument(app.name)}`, `prisma-cli app deploy --app <new-name> --region ${formatCommandArgument(requestedRegion.value)}`], "app");
+}
+async function resolveAmbiguousDeployApp(context, matches, targetName, requestedRegion, newAppRegion, firstDeploy) {
 	if (canPrompt(context)) {
 		const createNew = "__create_new_app__";
 		const cancel = "__cancel__";
@@ -1367,11 +1429,12 @@ async function resolveAmbiguousDeployApp(context, matches, targetName, firstDepl
 		if (selected === cancel) throw usageError("App selection canceled", "The command was canceled before an app was selected.", "Re-run the command and choose an app, or pass --app <name>.", ["prisma-cli app deploy --app <name>"], "app");
 		if (selected === createNew) return {
 			appName: targetName,
-			region: DEFAULT_REGION,
+			region: newAppRegion,
 			displayName: targetName,
 			annotation: "created from package.json",
 			firstDeploy
 		};
+		assertDeployRegionMatchesExistingApp(selected, requestedRegion);
 		return {
 			appId: selected.id,
 			displayName: selected.name,
@@ -1393,6 +1456,9 @@ async function resolveAmbiguousDeployApp(context, matches, targetName, firstDepl
 		nextSteps: ["prisma-cli app deploy --app <name>"]
 	});
 }
+function deployNewAppRegion(configRegion) {
+	return configRegion?.value;
+}
 async function resolveExistingAppSelection(context, projectId, apps, explicitAppName) {
 	if (explicitAppName) {
 		const matched = findAppByName(apps, explicitAppName);
@@ -1435,6 +1501,7 @@ async function confirmAppRemoval(context, app) {
 	await textPrompt({
 		input: context.runtime.stdin,
 		output: context.output.stderr,
+		signal: context.runtime.signal,
 		message: `Type ${app.name} to confirm app removal`,
 		placeholder: app.name,
 		validate: (value) => value === app.name ? void 0 : `Type "${app.name}" to confirm removal.`
@@ -1467,13 +1534,21 @@ function requireDeploymentForApp(deployments, deploymentId, appName) {
 		nextSteps: ["prisma-cli app list-deploys"]
 	});
 }
+/**
+* Resolves the app's live deployment from the app pointer, the provider's live
+* flag, then locally cached state.
+*
+* @returns the live deployment id, or null when no authoritative signal exists.
+* Callers must treat null as "not known to be live" rather than assuming the
+* newest deployment is live.
+*/
 async function resolveCurrentLiveDeploymentId(context, projectId, app, deployments) {
 	if (app.liveDeploymentId && deployments.some((deployment) => deployment.id === app.liveDeploymentId)) return app.liveDeploymentId;
 	const providerLiveDeployment = deployments.find((deployment) => deployment.live === true);
 	if (providerLiveDeployment) return providerLiveDeployment.id;
 	const knownLiveDeploymentId = await context.stateStore.readKnownLiveDeployment(projectId, app.id);
 	if (knownLiveDeploymentId && deployments.some((deployment) => deployment.id === knownLiveDeploymentId)) return knownLiveDeploymentId;
-	return deployments[0]?.id ?? null;
+	return null;
 }
 function buildAppShowNextSteps(liveUrl, liveDeployment, deployments) {
 	const nextSteps = [];
@@ -1528,7 +1603,7 @@ async function requirePreviewAppProvider(context) {
 	return provider;
 }
 async function requirePreviewAppProviderWithClient(context) {
-	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
 	return {
 		client,
@@ -1572,15 +1647,15 @@ async function requireProviderAndDeployProjectContext(context, explicitProject,
 	};
 }
 async function resolveProjectContext(context, client, explicitProject, options) {
-	const authState = await requireAuthenticatedAuthState(context);
-	if (!authState.workspace) throw workspaceRequiredError();
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
 	const resolvedResult = await resolveProjectTarget({
 		context,
-		workspace: authState.workspace,
+		workspace,
 		explicitProject,
 		envProjectId: options?.envProjectId,
 		projectDir: options?.projectDir,
-		listProjects: () => listRealWorkspaceProjects(client, authState.workspace, context.runtime.signal),
+		listProjects: () => listRealWorkspaceProjects(client, context.runtime.signal),
 		commandName: options?.commandName
 	});
 	if (resolvedResult.isErr()) throw projectResolutionErrorToCliError(resolvedResult.error);
@@ -1604,7 +1679,7 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
 	const branch = options.branch ?? await resolveDeployBranch(context, void 0);
-	const projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
+	const projects = await listRealWorkspaceProjects(client, context.runtime.signal);
 	if (explicitProject) return withRemoteDeployBranch(provider, {
 		workspace,
 		project: toProjectSummary(resolveProjectForSetup(explicitProject, projects, workspace)),
@@ -1615,54 +1690,12 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 		},
 		localPinAction: "linked"
 	}, branch, context.runtime.signal);
-	if (options.createProjectName) {
-		const projectName = options.createProjectName.trim();
-		if (!projectName) throw projectSetupNameRequiredError("app deploy --create-project");
-		return withRemoteDeployBranch(provider, {
-			workspace,
-			project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal)),
-			resolution: {
-				projectSource: "created",
-				targetName: projectName,
-				targetNameSource: "explicit"
-			},
-			localPinAction: "created"
-		}, branch, context.runtime.signal);
-	}
-	if (options.envProjectId) {
-		const project = projects.find((candidate) => candidate.id === options.envProjectId);
-		if (!project) throw projectNotFoundError(options.envProjectId, workspace);
-		return withRemoteDeployBranch(provider, {
-			workspace,
-			project: toProjectSummary(project),
-			resolution: {
-				projectSource: "env",
-				targetName: options.envProjectId,
-				targetNameSource: "env"
-			}
-		}, branch, context.runtime.signal);
-	}
+	if (options.createProjectName) return withRemoteDeployBranch(provider, await resolveCreatedDeployProject(provider, options.createProjectName, workspace, context.runtime.signal, options.createProjectRegion), branch, context.runtime.signal);
+	if (options.envProjectId) return withRemoteDeployBranch(provider, resolveEnvDeployProject(options.envProjectId, projects, workspace), branch, context.runtime.signal);
 	const localPin = options.localPin;
-	if (localPin.kind === "present") {
-		if (localPin.pin.workspaceId !== workspace.id) throw localProjectWorkspaceMismatchError({
-			pinnedWorkspaceId: localPin.pin.workspaceId,
-			pinnedProjectId: localPin.pin.projectId,
-			activeWorkspace: workspace
-		});
-		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
-		if (!project) throw localResolutionPinStaleError();
-		return withRemoteDeployBranch(provider, {
-			workspace,
-			project: toProjectSummary(project),
-			resolution: {
-				projectSource: "local-pin",
-				targetName: project.name,
-				targetNameSource: "local-pin"
-			}
-		}, branch, context.runtime.signal);
-	}
+	if (localPin.kind === "present") return withRemoteDeployBranch(provider, resolveLocalPinDeployProject(localPin.pin, projects, workspace), branch, context.runtime.signal);
 	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping && platformMapping.workspace.id === workspace.id) return withRemoteDeployBranch(provider, {
+	if (platformMapping && sameWorkspaceId(platformMapping.workspace.id, workspace.id)) return withRemoteDeployBranch(provider, {
 		workspace,
 		project: toProjectSummary(platformMapping),
 		resolution: {
@@ -1671,14 +1704,59 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 			targetNameSource: "platform-mapping"
 		}
 	}, branch, context.runtime.signal);
-	if (canPrompt(context) && !context.flags.yes) return withRemoteDeployBranch(provider, await resolveInteractiveDeployProjectSetup(context, provider, workspace, projects), branch, context.runtime.signal);
+	if (canPrompt(context) && !context.flags.yes) return withRemoteDeployBranch(provider, await resolveInteractiveDeployProjectSetup(context, provider, workspace, projects, options.createProjectRegion), branch, context.runtime.signal);
 	throw projectSetupRequiredError(projects, await inferTargetName(context.runtime.cwd, context.runtime.signal));
 }
-async function resolveInteractiveDeployProjectSetup(context, provider, workspace, projects) {
+async function resolveCreatedDeployProject(provider, createProjectName, workspace, signal, createProjectRegion) {
+	const projectName = createProjectName.trim();
+	if (!projectName) throw projectSetupNameRequiredError("app deploy --create-project");
+	return {
+		workspace,
+		project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace, signal, createProjectRegion)),
+		resolution: {
+			projectSource: "created",
+			targetName: projectName,
+			targetNameSource: "explicit"
+		},
+		localPinAction: "created"
+	};
+}
+function resolveEnvDeployProject(envProjectId, projects, workspace) {
+	const project = projects.find((candidate) => candidate.id === envProjectId);
+	if (!project) throw projectNotFoundError(envProjectId, workspace);
+	return {
+		workspace,
+		project: toProjectSummary(project),
+		resolution: {
+			projectSource: "env",
+			targetName: envProjectId,
+			targetNameSource: "env"
+		}
+	};
+}
+function resolveLocalPinDeployProject(pin, projects, workspace) {
+	if (!sameWorkspaceId(pin.workspaceId, workspace.id)) throw localProjectWorkspaceMismatchError({
+		pinnedWorkspaceId: pin.workspaceId,
+		pinnedProjectId: pin.projectId,
+		activeWorkspace: workspace
+	});
+	const project = projects.find((candidate) => candidate.id === pin.projectId);
+	if (!project) throw localResolutionPinStaleError();
+	return {
+		workspace,
+		project: toProjectSummary(project),
+		resolution: {
+			projectSource: "local-pin",
+			targetName: project.name,
+			targetNameSource: "local-pin"
+		}
+	};
+}
+async function resolveInteractiveDeployProjectSetup(context, provider, workspace, projects, createProjectRegion) {
 	const setup = await promptForProjectSetupChoice({
 		context,
 		projects,
-		createProject: (projectName) => createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal),
+		createProject: (projectName) => createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal, createProjectRegion),
 		cancel: {
 			why: "Deploy needs a Project before it can continue.",
 			fix: "Choose an existing Project or create a new one, then rerun deploy.",
@@ -1696,9 +1774,10 @@ async function resolveInteractiveDeployProjectSetup(context, provider, workspace
 		localPinAction: setup.action
 	};
 }
-async function createProjectForDeploySetup(provider, projectName, workspace, signal) {
+async function createProjectForDeploySetup(provider, projectName, workspace, signal, region) {
 	const created = await provider.createProject({
 		name: projectName,
+		region,
 		signal
 	}).catch((error) => {
 		throw projectCreateFailedError(error, projectName, workspace, {
@@ -1714,6 +1793,7 @@ async function createProjectForDeploySetup(provider, projectName, workspace, sig
 	return {
 		id: created.id,
 		name: created.name,
+		...created.defaultRegion != null ? { defaultRegion: created.defaultRegion } : {},
 		workspace
 	};
 }
@@ -1794,7 +1874,7 @@ async function resolveComputeTargetOrThrow(context, configTarget, commandName, o
 		config = loaded.value;
 	}
 	if (!config) {
-		if (configTarget) throw usageError(`App target "${configTarget}" requires a compute config file`, `No ${COMPUTE_CONFIG_FILENAME$1} exists in the current directory, so there are no named app targets.`, `Create ${COMPUTE_CONFIG_FILENAME$1} with an apps entry named "${configTarget}", or rerun without the target argument.`, [`prisma-cli app ${commandName}`], "app");
+		if (configTarget) throw usageError(`App target "${configTarget}" requires a compute config file`, `No ${COMPUTE_CONFIG_FILENAME} exists in the current directory, so there are no named app targets.`, `Create ${COMPUTE_CONFIG_FILENAME} with an apps entry named "${configTarget}", or rerun without the target argument.`, [`prisma-cli app ${commandName}`], "app");
 		return {
 			config: null,
 			target: null
@@ -1937,55 +2017,21 @@ async function resolveDeployEntrypoint(cwd, framework, explicitEntrypoint, signa
 	}
 }
 async function detectDeployFramework(cwd, signal) {
-	const packageJson = await readBunPackageJson(cwd, signal);
-	for (const framework of FRAMEWORKS) {
-		if (framework.detectConfigFiles.length === 0 && framework.detectPackages.length === 0) continue;
-		const configFile = await detectFrameworkConfigFile(cwd, framework, signal);
-		if (!configFile.exists && !hasAnyPackageDependency(packageJson, framework.detectPackages)) continue;
-		const annotation = framework.key === "nextjs" && configFile.standalone ? "standalone output detected" : configFile.exists ? `detected from ${path.basename(configFile.path)}` : "detected from package.json";
-		return {
-			key: framework.key,
-			buildType: framework.buildType,
-			displayName: framework.displayName,
-			annotation
-		};
-	}
-	return null;
-}
-async function detectFrameworkConfigFile(cwd, framework, signal) {
-	for (const candidate of framework.detectConfigFiles) {
-		const filePath = path.join(cwd, candidate);
-		signal.throwIfAborted();
-		try {
-			const content = await readFile(filePath, {
-				encoding: "utf8",
-				signal
-			});
-			return {
-				exists: true,
-				standalone: /\boutput\s*:\s*["'`]standalone["'`]/.test(content),
-				path: filePath
-			};
-		} catch (error) {
-			if (signal.aborted) throw error;
-			if (error.code !== "ENOENT") throw error;
-		}
-	}
+	const detected = await detectComputeAppFromDirectory({
+		appPath: cwd,
+		signal
+	});
+	if (!detected) return null;
+	let annotation = "detected from package.json";
+	if (detected.configFile?.standaloneOutput) annotation = "standalone output detected";
+	else if (detected.configFile) annotation = `detected from ${path.basename(detected.configFile.path)}`;
 	return {
-		exists: false,
-		standalone: false,
-		path: null
+		key: detected.framework,
+		buildType: detected.buildType,
+		displayName: detected.frameworkName,
+		annotation
 	};
 }
-function hasPackageDependency(packageJson, dependencyName) {
-	return hasDependency(packageJson?.dependencies, dependencyName) || hasDependency(packageJson?.devDependencies, dependencyName);
-}
-function hasAnyPackageDependency(packageJson, dependencyNames) {
-	return dependencyNames.some((dependencyName) => hasPackageDependency(packageJson, dependencyName));
-}
-function hasDependency(dependencies, dependencyName) {
-	return Boolean(dependencies && typeof dependencies === "object" && dependencyName in dependencies);
-}
 function frameworkFromUserFacingValue(value, annotation) {
 	const framework = frameworkFromAlias(value);
 	if (!framework) throw frameworkNotDetectedError(void 0, value);
@@ -1996,11 +2042,6 @@ function frameworkFromUserFacingValue(value, annotation) {
 		annotation
 	};
 }
-/**
-* The nuxt and astro strategies build with their framework CLI and stage
-* fixed output, so a compute config `build` block has nothing to apply to.
-* Erroring beats silently ignoring committed settings.
-*/
 function assertConfigBackedBuildSettings(buildType) {
 	if (isConfigBackedBuildType(buildType)) return;
 	const displayName = FRAMEWORKS.find((framework) => framework.buildType === buildType)?.displayName ?? buildType;
@@ -2042,15 +2083,23 @@ function maybeRenderDeployBuildSettings(context, resolution) {
 	if (context.flags.json || context.flags.quiet) return;
 	const settings = resolution.settings;
 	const title = resolution.status === "config" ? `Using ${resolution.relativeConfigPath}` : "Build settings";
-	context.output.stderr.write(`${title}\n${renderDeployOutputRows(context.ui, [{
-		label: "Build Command",
-		value: settings.buildCommand ?? "none",
-		origin: settings.buildCommandSource ?? void 0
-	}, {
-		label: "Output Directory",
-		value: settings.outputDirectory,
-		origin: settings.outputDirectorySource ?? void 0
-	}]).join("\n")}\n\n`);
+	context.output.stderr.write(`${title}\n${renderDeployOutputRows(context.ui, [
+		{
+			label: "Build Command",
+			value: settings.buildCommand ?? "none",
+			origin: settings.buildCommandSource ?? void 0
+		},
+		{
+			label: "Output Directory",
+			value: settings.outputDirectory,
+			origin: settings.outputDirectorySource ?? void 0
+		},
+		...settings.entrypoint ? [{
+			label: "Entrypoint",
+			value: settings.entrypoint,
+			origin: settings.entrypointSource ?? void 0
+		}] : []
+	]).join("\n")}\n\n`);
 }
 function maybeRenderProjectLinked(context, directory, projectName, localPinPath) {
 	if (context.flags.json || context.flags.quiet) return;
@@ -2068,6 +2117,7 @@ async function maybeCustomizeDeploySettings(context, options) {
 	if (!await confirmPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message: "Customize build settings?",
 		initialValue: false
 	})) return {
@@ -2077,6 +2127,7 @@ async function maybeCustomizeDeploySettings(context, options) {
 	const framework = frameworkFromUserFacingValue(await selectPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message: `Framework (${options.framework.displayName})`,
 		choices: FRAMEWORKS.map((framework) => ({
 			label: framework.displayName,
@@ -2086,6 +2137,7 @@ async function maybeCustomizeDeploySettings(context, options) {
 	const requestedPort = await textPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message: `HTTP port (${options.runtime.port})`,
 		placeholder: String(options.runtime.port),
 		validate: validateDeployHttpPortText
@@ -2149,7 +2201,7 @@ async function readCurrentWorkspaceId(context) {
 function normalizeBuildType(requestedBuildType) {
 	if (!requestedBuildType) return "auto";
 	if (isPreviewBuildType(requestedBuildType)) return requestedBuildType;
-	throw usageError(`Unsupported build type "${requestedBuildType}"`, `Only ${APP_BUILD_TYPES.join(", ")} are supported in the current preview.`, "Pass a supported --build-type value.", getBuildTypeExamples("build"), "app");
+	throw usageError(`Unsupported build type "${requestedBuildType}"`, `Only ${APP_BUILD_TYPE_LABELS} are supported in the current preview.`, "Pass a supported --build-type value.", getBuildTypeExamples("build"), "app");
 }
 function isPreviewBuildType(value) {
 	return APP_BUILD_TYPES.includes(value);
@@ -2172,8 +2224,9 @@ function assertSupportedEntrypoint(buildType, entrypoint, commandName) {
 * and Bun/Hono have dev servers in the current preview.
 */
 async function resolveLocalRunFramework(context, options) {
+	if (options.requestedBuildType === "auto" && options.entrypoint) return frameworkFromUserFacingValue("bun", "set by --entry");
 	if (LOCAL_DEV_BUILD_TYPES.includes(options.requestedBuildType)) {
-		if (options.configFramework && computeFrameworkToBuildType(options.configFramework) === options.requestedBuildType) return frameworkFromUserFacingValue(options.configFramework, `set by ${COMPUTE_CONFIG_FILENAME$1}`);
+		if (options.configFramework && computeFrameworkToBuildType(options.configFramework) === options.requestedBuildType) return frameworkFromUserFacingValue(options.configFramework, `set by ${COMPUTE_CONFIG_FILENAME}`);
 		return frameworkFromUserFacingValue(options.requestedBuildType, "set by --build-type");
 	}
 	const detected = await detectDeployFramework(options.appDir, context.runtime.signal);
@@ -2195,9 +2248,18 @@ function parseDeployHttpPort(requestedPort) {
 	if (!Number.isInteger(port) || port <= 0 || port > 65535) throw usageError(`Invalid HTTP port "${requestedPort}"`, "HTTP port must be an integer between 1 and 65535.", "Pass --http-port <number> with a valid port value.", ["prisma-cli app deploy --http-port 3000"], "app");
 	return port;
 }
-function ensurePreviewAppMode(context) {
-	if (isRealMode(context)) return;
-	throw featureUnavailableError("App commands are not available in fixture mode", "Preview app commands require live app deployment integration.", "Rerun without fixture mode enabled to use preview app deployment workflows.", ["prisma-cli auth login", "prisma-cli project show"], "app");
+function parseDeployRegion(requestedRegion, source) {
+	const region = requestedRegion.trim();
+	if (region.length === 0) throw usageError("Invalid app region", `The app region ${source} must be a non-empty region id.`, "Pass a Prisma Compute region id.", ["prisma-cli app deploy --region eu-central-1"], "app");
+	if (!COMPUTE_REGION_IDS.has(region)) throw usageError("Invalid app region", `The app region ${source} must be one of: ${COMPUTE_REGIONS.join(", ")}.`, "Pass a supported Prisma Compute region id.", ["prisma-cli app deploy --region eu-central-1"], "app");
+	return region;
+}
+function normalizeDeployRegionInput(region) {
+	if (!region) return;
+	return {
+		...region,
+		value: parseDeployRegion(region.value, region.annotation)
+	};
 }
 function deployFailedError(summary, error, nextSteps) {
 	return new CliError({
@@ -2211,47 +2273,53 @@ function deployFailedError(summary, error, nextSteps) {
 		nextSteps
 	});
 }
+function describeStalledDeployPhase(progress) {
+	if (progress.uploadCompleted) return "The artifact uploaded, but the deployment did not start.";
+	if (progress.archiveReady) return "The app built locally, but the artifact did not finish uploading.";
+	return "The app built locally, but the deployment did not start.";
+}
+function localBuildFailedError(why, debug) {
+	const standaloneOutputFailure = isNextStandaloneOutputFailure(why);
+	const fix = standaloneOutputFailure ? "Add output: \"standalone\" to next.config.*, then rerun deploy." : "Inspect the build output above, fix the error, and redeploy.";
+	const nextSteps = standaloneOutputFailure ? ["Add output: \"standalone\" to next.config.*, then rerun prisma-cli app deploy"] : [];
+	const nextActions = standaloneOutputFailure ? [{
+		kind: "edit-file",
+		journey: "deploy-app",
+		label: "Add Next.js standalone output",
+		reason: "Prisma Compute needs Next.js standalone output to build a deployable server artifact."
+	}, {
+		kind: "run-command",
+		journey: "deploy-app",
+		label: "Rerun deploy",
+		command: "prisma-cli app deploy"
+	}] : [];
+	return new CliError({
+		code: "BUILD_FAILED",
+		domain: "app",
+		summary: "Build failed locally.",
+		why,
+		fix,
+		debug,
+		meta: { phase: "build" },
+		humanLines: [
+			"Build failed locally.",
+			"",
+			`✗ Built       ${why}`,
+			"",
+			`Fix: ${fix}`
+		],
+		exitCode: 1,
+		nextSteps,
+		nextActions
+	});
+}
 function appDeployFailedError(error, progress) {
 	const why = error instanceof Error ? error.message : String(error);
 	const debug = formatDebugDetails(error);
-	if (progress.buildStarted && !progress.buildCompleted) {
-		const standaloneOutputFailure = isNextStandaloneOutputFailure(why);
-		const fix = standaloneOutputFailure ? "Add output: \"standalone\" to next.config.*, then rerun deploy." : "Inspect the build output above, fix the error, and redeploy.";
-		const nextSteps = standaloneOutputFailure ? ["Add output: \"standalone\" to next.config.*, then rerun prisma-cli app deploy"] : [];
-		const nextActions = standaloneOutputFailure ? [{
-			kind: "edit-file",
-			journey: "deploy-app",
-			label: "Add Next.js standalone output",
-			reason: "Prisma Compute needs Next.js standalone output to build a deployable server artifact."
-		}, {
-			kind: "run-command",
-			journey: "deploy-app",
-			label: "Rerun deploy",
-			command: "prisma-cli app deploy"
-		}] : [];
-		return new CliError({
-			code: "BUILD_FAILED",
-			domain: "app",
-			summary: "Build failed locally.",
-			why,
-			fix,
-			debug,
-			meta: { phase: "build" },
-			humanLines: [
-				"Build failed locally.",
-				"",
-				`✗ Built       ${why}`,
-				"",
-				`Fix: ${fix}`
-			],
-			exitCode: 1,
-			nextSteps,
-			nextActions
-		});
-	}
+	if (progress.buildStarted && !progress.buildCompleted) return localBuildFailedError(why, debug);
 	if (!progress.buildStarted) return deployFailedError("App deploy failed", error, ["prisma-cli app deploy"]);
 	const phaseHeadline = progress.containerLive ? "The deployment started, but the app is not ready yet." : "Deploy failed after the build completed.";
-	const recoveryLines = progress.versionId ? ["See what happened", `prisma-cli app logs --deployment ${progress.versionId}`] : ["Fix", "Retry the command, or rerun with --trace for more detailed diagnostics."];
+	const recoveryLines = progress.deploymentId ? ["See what happened", `prisma-cli app logs --deployment ${progress.deploymentId}`] : ["Fix", "Retry the command, or rerun with --trace for more detailed diagnostics."];
 	const urlLines = progress.deploymentUrl ? [
 		"",
 		"URL",
@@ -2268,7 +2336,7 @@ function appDeployFailedError(error, progress) {
 	] : [
 		phaseHeadline,
 		"",
-		progress.uploadCompleted ? "The artifact uploaded, but the deployment did not start." : progress.archiveReady ? "The app built locally, but the artifact did not finish uploading." : "The app built locally, but the deployment did not start.",
+		describeStalledDeployPhase(progress),
 		"",
 		...recoveryLines
 	];
@@ -2277,11 +2345,11 @@ function appDeployFailedError(error, progress) {
 		domain: "app",
 		summary: phaseHeadline,
 		why,
-		fix: progress.versionId ? `Inspect logs with prisma-cli app logs --deployment ${progress.versionId}.` : "Retry the command, or rerun with --trace for more detailed diagnostics.",
+		fix: progress.deploymentId ? `Inspect logs with prisma-cli app logs --deployment ${progress.deploymentId}.` : "Retry the command, or rerun with --trace for more detailed diagnostics.",
 		debug,
 		meta: {
 			phase: progress.containerLive ? "runtime_ready" : "deploy",
-			deploymentId: progress.versionId,
+			deploymentId: progress.deploymentId,
 			deploymentUrl: progress.deploymentUrl
 		},
 		humanLines,
@@ -2352,7 +2420,7 @@ function projectSetupRequiredError(projects, suggestedName) {
 	});
 }
 function isNextStandaloneOutputFailure(message) {
-	return /next\.?js/i.test(message) && /standalone output/i.test(message);
+	return NEXTJS_MENTION.test(message) && STANDALONE_OUTPUT_MENTION.test(message);
 }
 function noDeploymentsError(summary, why) {
 	return new CliError({
@@ -2395,15 +2463,12 @@ function isAutoBuildDetectionError(error) {
 	return error instanceof Error && error.message.startsWith("Entrypoint is required.");
 }
 function formatBuildTypeName(buildType) {
-	switch (buildType) {
-		case "nextjs": return "Next.js";
-		case "nuxt": return "Nuxt";
-		case "astro": return "Astro";
-		case "nestjs": return "NestJS";
-		case "tanstack-start": return "TanStack Start";
-		case "bun": return "Bun";
-		case "auto": return "Auto";
+	if (buildType === "auto") return "Auto";
+	for (let index = FRAMEWORKS.length - 1; index >= 0; index -= 1) {
+		const framework = FRAMEWORKS[index];
+		if (framework?.buildType === buildType) return framework.displayName;
 	}
+	return buildType;
 }
 function removeFailedError(summary, error, nextSteps) {
 	return new CliError({
@@ -2440,4 +2505,4 @@ function toOptionalEnvVars(envVars) {
 	return Object.keys(envVars).length > 0 ? envVars : void 0;
 }
 //#endregion
-export { runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy };
+export { detectDeployFramework, runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy };