@prisma/cli 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/controllers/app.js

@@ -1,54 +1,85 @@
-import { SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "../lib/auth/client.js";
-import { FileTokenStorage } from "../adapters/token-storage.js";
+import { resolvePrismaCliPackageCommand } from "../lib/agent/cli-command.js";
+import { PRISMA_AGENT_INSTALL_ARGS, PRISMA_COMPUTE_AGENT_SKILL } from "../lib/agent/constants.js";
+import { readPrismaAgentSetupStatus, shouldOfferPrismaAgentSetup } from "../lib/agent/setup-status.js";
+import { formatCommandArgument } from "../shell/command-arguments.js";
 import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
-import { renderCommandHeader } from "../shell/ui.js";
-import { writeJsonEvent } from "../shell/output.js";
+import { runAgentInstall } from "./agent.js";
+import { renderCommandHeader, renderSummaryLine } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
+import { writeJsonEvent } from "../shell/output.js";
+import { SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "../lib/auth/client.js";
+import { FileTokenStorage } from "../adapters/token-storage.js";
 import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
+import "../lib/app/app-interaction.js";
+import { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, resolveConfiguredAppBuildSettings, resolveInferredAppBuildSettings } from "../lib/app/build-settings.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 { 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 { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.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 { 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";
+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 { parseEnvAssignments } from "../lib/app/env-vars.js";
-import { renderDeployOutputRows, renderDeploySettingsPreview } from "../lib/app/deploy-output.js";
-import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
-import { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp } from "../lib/app/local-dev.js";
-import { formatCommandArgument } from "../shell/command-arguments.js";
-import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
-import { buildProjectSetupNextActions, inferTargetName, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
-import { bindProjectToDirectory, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
+import { readLocalGitBranch } from "../lib/git/local-branch.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
-import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild } from "../lib/app/preview-build.js";
-import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
-import { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress } from "../lib/app/preview-progress.js";
-import { PreviewDomainApiError, createPreviewAppProvider } from "../lib/app/preview-provider.js";
-import { formatDomainFailureFix } from "../lib/app/domain-guidance.js";
 import { createSelectPromptPort } from "./select-prompt-port.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
-import { access, readFile } from "node:fs/promises";
 import path from "node:path";
+import { access, readFile } from "node:fs/promises";
+import { COMPUTE_REGIONS, ENTRYPOINT_BUILD_TYPES, FRAMEWORKS, LOCAL_DEV_BUILD_TYPES, frameworkByKey, frameworkFromAlias, isConfigBackedBuildType } from "@prisma/compute-sdk/config";
+import { Result, matchError } from "better-result";
 import open from "open";
 //#region src/controllers/app.ts
-const DEPLOY_FRAMEWORKS = [
-	"nextjs",
-	"hono",
-	"tanstack-start",
-	"bun"
-];
-const TANSTACK_START_PACKAGES = ["@tanstack/react-start", "@tanstack/solid-start"];
 const FRAMEWORK_DEFAULT_HTTP_PORT = 3e3;
 const PRISMA_PROJECT_ID_ENV_VAR = "PRISMA_PROJECT_ID";
 const PRISMA_APP_ID_ENV_VAR = "PRISMA_APP_ID";
+const COMPUTE_REGION_IDS = new Set(COMPUTE_REGIONS);
 function isRealMode(context) {
 	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
 }
-async function runAppBuild(context, entrypoint, requestedBuildType) {
-	const buildType = normalizeBuildType(requestedBuildType);
-	assertSupportedEntrypoint(buildType, entrypoint, "build");
+async function runAppBuild(context, options) {
+	const compute = await resolveComputeTargetOrThrow(context, options?.configTarget, "build");
+	const merged = mergeComputeLocalInputs({
+		cli: {
+			entrypoint: options?.entrypoint,
+			buildType: options?.buildType
+		},
+		target: compute.target
+	});
+	const appDir = await resolveComputeAppDir(context, compute);
+	let buildType = normalizeBuildType(merged.buildType);
+	if (compute.target?.build && buildType === "auto") {
+		const detected = await detectDeployFramework(appDir, context.runtime.signal);
+		if (!detected) throw frameworkNotDetectedError(appDir);
+		buildType = detected.buildType;
+	}
+	assertSupportedEntrypoint(buildType, merged.entrypoint, "build");
+	if (compute.target?.build && buildType !== "auto") assertConfigBackedBuildSettings(buildType);
+	const buildSettings = compute.config && compute.target?.build && isConfigBackedBuildType(buildType) ? (await resolveConfiguredAppBuildSettings({
+		appPath: appDir,
+		buildType,
+		configured: compute.target.build,
+		configPath: compute.config.configPath,
+		signal: context.runtime.signal
+	})).settings : void 0;
 	try {
-		const { artifact, buildType: actualBuildType } = await executePreviewBuild({
-			appPath: context.runtime.cwd,
-			entrypoint,
-			buildType
+		const { artifact, buildType: actualBuildType } = await executeAppBuild({
+			appPath: appDir,
+			entrypoint: merged.entrypoint,
+			buildType,
+			buildSettings,
+			signal: context.runtime.signal
 		});
 		return {
 			command: "app.build",
@@ -61,29 +92,46 @@ async function runAppBuild(context, entrypoint, requestedBuildType) {
 			nextSteps: ["prisma-cli app deploy"]
 		};
 	} catch (error) {
-		if (buildType === "auto" && isAutoBuildDetectionError(error)) throw usageError("App build requires an explicit framework when detection is ambiguous", `This preview auto-detects clear project shapes for ${RESOLVED_PREVIEW_BUILD_TYPES.map(formatBuildTypeName).join(", ")}.`, "Pass a supported --build-type value, or pass --entry <path> for a Bun app.", getBuildTypeExamples("build"), "app");
+		if (buildType === "auto" && isAutoBuildDetectionError(error)) throw usageError("App build requires an explicit framework when detection is ambiguous", `This preview auto-detects clear project shapes for ${RESOLVED_APP_BUILD_TYPES.map(formatBuildTypeName).join(", ")}.`, "Pass a supported --build-type value, or pass --entry <path> for a Bun app.", getBuildTypeExamples("build"), "app");
 		throw buildFailedError("Local app build failed", error);
 	}
 }
-async function runAppRun(context, entrypoint, requestedBuildType, requestedPort) {
+async function runAppRun(context, options) {
 	if (context.flags.json) throw usageError("App run does not support --json", "This command streams the framework dev server directly and cannot return structured JSON.", "Rerun without --json to pass framework logs through directly.", ["prisma-cli app run"], "app");
-	const buildType = normalizeBuildType(requestedBuildType);
-	assertSupportedEntrypoint(buildType, entrypoint, "run");
-	const port = parseLocalPort(requestedPort);
-	const resolvedBuildType = await requireLocalBuildType(context, buildType, "run");
+	const compute = await resolveComputeTargetOrThrow(context, options?.configTarget, "run");
+	const merged = mergeComputeLocalInputs({
+		cli: {
+			entrypoint: options?.entrypoint,
+			buildType: options?.buildType,
+			port: options?.port
+		},
+		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");
+	const appDir = await resolveComputeAppDir(context, compute);
+	const buildType = normalizeBuildType(merged.buildType);
+	assertSupportedEntrypoint(buildType, merged.entrypoint, "run");
+	const port = parseLocalPort(merged.port);
+	const framework = await resolveLocalRunFramework(context, {
+		requestedBuildType: buildType,
+		configFramework: compute.target?.framework ?? null,
+		appDir
+	});
+	const entrypoint = framework.buildType === "bun" ? await resolveDeployEntrypoint(appDir, framework, merged.entrypoint, context.runtime.signal) : merged.entrypoint;
 	let runResult;
 	try {
 		runResult = await runLocalApp({
-			appPath: context.runtime.cwd,
-			buildType: resolvedBuildType,
+			appPath: appDir,
+			buildType: framework.buildType,
 			entrypoint,
 			port,
-			env: context.runtime.env
+			env: context.runtime.env,
+			signal: context.runtime.signal
 		});
 	} catch (error) {
 		throw runFailedError("Local app run failed", error);
 	}
-	if (runResult.signal === "SIGINT" || runResult.signal === "SIGTERM") process.exitCode = runResult.signal === "SIGINT" ? 130 : 143;
+	if (runResult.signal === "SIGINT" || runResult.signal === "SIGTERM") throw new DOMException("Command canceled", "AbortError");
 	else if (runResult.exitCode !== 0) throw runFailedError("Local app run failed", `The ${formatFrameworkName(runResult.framework)} process exited with code ${runResult.exitCode}.`, runResult.exitCode);
 	return {
 		command: "app.run",
@@ -99,6 +147,107 @@ async function runAppRun(context, entrypoint, requestedBuildType, requestedPort)
 }
 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;
+	const plan = planAppDeploy({
+		config,
+		requestedTarget: options?.configTarget ?? (config ? inferComputeTargetFromCwd(config, context.runtime.cwd) : void 0),
+		hasCreateProject: options?.createProjectName !== void 0
+	});
+	if (plan.mode === "all") return runAppDeployAll(context, config, plan.targets, appName, options);
+	return runSingleAppDeploy(context, appName, options, config);
+}
+async function runAppDeployAll(context, config, plannedTargets, appName, options) {
+	assertNoPerAppInputsForDeployAll(context, plannedTargets, appName, options);
+	const deployments = [];
+	const warnings = [];
+	for (const planned of plannedTargets) {
+		maybeRenderDeployAllTargetHeader(context, planned);
+		const targetOptions = {
+			...options,
+			configTarget: planned.targetKey,
+			createProjectName: planned.bindsCreateProject ? options?.createProjectName : void 0
+		};
+		try {
+			const single = await runSingleAppDeploy(context, void 0, targetOptions, config);
+			deployments.push({
+				target: planned.targetKey,
+				result: single.result
+			});
+			warnings.push(...single.warnings);
+		} catch (error) {
+			throw deployAllFailedError(error, plannedTargets, planned.index, deployments);
+		}
+	}
+	return {
+		command: "app.deploy",
+		result: { deployments },
+		warnings,
+		nextSteps: ["prisma-cli app list-deploys <app>"]
+	};
+}
+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,
+			value: readDeployEnvOverride(context, PRISMA_APP_ID_ENV_VAR)
+		}
+	});
+	if (used.length === 0) return;
+	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, plannedTargets, failedIndex, deployments) {
+	if (!(error instanceof CliError)) return error;
+	const failure = describeDeployAllFailure({
+		targetKeys: plannedTargets.map((target) => target.targetKey),
+		failedIndex,
+		completed: deployments.map(({ target, result }) => ({
+			target,
+			deploymentId: result.deployment.id,
+			url: result.deployment.url
+		}))
+	});
+	const contextSentence = failure.contextLines.join(" ");
+	return new CliError({
+		code: error.code,
+		domain: error.domain,
+		summary: error.summary,
+		why: error.humanLines ? error.why : [error.why, contextSentence].filter(Boolean).join(" "),
+		fix: error.fix,
+		debug: error.debug,
+		where: error.where,
+		meta: {
+			...error.meta,
+			deployAll: {
+				failedTarget: failure.failedTarget,
+				completed: failure.completed,
+				notAttempted: failure.notAttempted
+			}
+		},
+		docsUrl: error.docsUrl,
+		exitCode: error.exitCode,
+		nextSteps: error.nextSteps,
+		nextActions: error.nextActions,
+		humanLines: error.humanLines ? [
+			...error.humanLines,
+			"",
+			...failure.contextLines
+		] : void 0
+	});
+}
+async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 	const envProjectId = readDeployEnvOverride(context, PRISMA_PROJECT_ID_ENV_VAR);
 	const envAppId = readDeployEnvOverride(context, PRISMA_APP_ID_ENV_VAR);
 	assertExclusiveDeployProjectInputs({
@@ -106,14 +255,30 @@ async function runAppDeploy(context, appName, options) {
 		createProjectName: options?.createProjectName,
 		envProjectId
 	});
-	const skipLocalPin = Boolean(envProjectId || options?.projectRef || options?.createProjectName);
-	const localPin = skipLocalPin ? { kind: "missing" } : await readLocalResolutionPin(context.runtime.cwd);
-	if (!skipLocalPin && localPin.kind === "invalid") throw localResolutionPinStaleError();
+	const computeConfig = await resolveComputeTargetOrThrow(context, options?.configTarget, "deploy", { preloaded: preloadedConfig });
+	const merged = mergeComputeDeployInputs({
+		cli: {
+			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
+	});
+	const appDir = await resolveComputeAppDir(context, computeConfig);
+	const projectDir = computeConfig.config?.configDir ?? context.runtime.cwd;
+	const agentSetupWarnings = await maybePromptForAgentSetup(context, projectDir);
+	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 branch = await resolveDeployBranch(context, options?.branchName);
-	if (options?.httpPort) parseDeployHttpPort(options.httpPort);
+	if (merged.httpPort) parseDeployHttpPort(merged.httpPort.value);
+	const deployRegion = normalizeDeployRegionInput(merged.region);
 	assertSupportedEntrypointForRequestedDeployShape({
-		requestedFramework: options?.framework,
-		entrypoint: options?.entrypoint
+		requestedFramework: merged.framework?.value,
+		entrypoint: merged.entrypoint?.value
 	});
 	const { provider, target, projectId } = await requireProviderAndDeployProjectContext(context, options?.projectRef, {
 		branch,
@@ -123,25 +288,33 @@ async function runAppDeploy(context, appName, options) {
 	});
 	let localPinResult;
 	if (target.localPinAction) {
-		const setupResult = await bindProjectToDirectory(context, target.workspace, target.project, target.localPinAction);
-		localPinResult = setupResult.localPin;
-		maybeRenderProjectLinked(context, setupResult.directory, setupResult.project.name, setupResult.localPin.path);
+		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);
 	}
 	let framework = await resolveDeployFramework(context, {
-		requestedFramework: options?.framework,
-		entrypoint: options?.entrypoint
-	});
-	let runtime = resolveDeployRuntime(options?.httpPort, framework);
-	assertSupportedEntrypoint(framework.buildType, options?.entrypoint, "deploy");
-	const envVars = toOptionalEnvVars(parseEnvAssignments(options?.envAssignments, { commandName: "deploy" }));
+		requestedFramework: merged.framework?.value,
+		requestedFrameworkAnnotation: merged.framework?.annotation,
+		entrypoint: merged.entrypoint?.value,
+		entrypointAnnotation: merged.entrypoint?.annotation,
+		appDir
+	});
+	let runtime = resolveDeployRuntime(merged.httpPort?.value, merged.httpPort?.annotation, framework);
+	assertSupportedEntrypoint(framework.buildType, merged.entrypoint?.value, "deploy");
+	const envVars = toOptionalEnvVars(await parseEnvInputs(merged.envInputsFromConfig ? projectDir : context.runtime.cwd, merged.envInputs, { commandName: "deploy" }));
 	const selectedApp = await resolveDeployAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), {
 		explicitAppName: appName,
 		explicitAppId: envAppId,
+		configAppName: merged.configAppName,
+		configRegion: deployRegion,
 		firstDeploy: Boolean(target.localPinAction),
-		inferName: () => inferTargetName(context.runtime.cwd)
+		inferName: () => inferTargetName(appDir, context.runtime.signal)
 	});
 	await maybeRenderDeploySetupBlock(context, {
 		includeDirectory: !target.localPinAction,
+		appDir,
 		projectName: target.project.name,
 		branchName: target.branch.name,
 		appName: selectedApp.displayName
@@ -150,20 +323,41 @@ async function runAppDeploy(context, appName, options) {
 		framework,
 		runtime,
 		firstDeploy: selectedApp.firstDeploy,
-		explicitFramework: Boolean(options?.framework),
-		explicitEntrypoint: Boolean(options?.entrypoint),
-		explicitHttpPort: Boolean(options?.httpPort)
+		explicitFramework: Boolean(merged.framework),
+		explicitEntrypoint: Boolean(merged.entrypoint),
+		explicitHttpPort: Boolean(merged.httpPort)
 	});
 	framework = customized.framework;
 	runtime = customized.runtime;
+	const noPromote = options?.noPromote === true;
+	const productionDeployGate = noPromote ? { firstProductionDeploy: false } : await enforceProductionDeployGate(context, provider, {
+		appId: selectedApp.appId,
+		appName: selectedApp.displayName,
+		branchKind: target.branch.kind,
+		prod: options?.prod === true
+	});
 	const buildType = framework.buildType;
-	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
-	const entrypoint = await resolveDeployEntrypoint(context.runtime.cwd, framework, options?.entrypoint);
+	assertSupportedEntrypoint(buildType, merged.entrypoint?.value, "deploy");
+	const entrypoint = await resolveDeployEntrypoint(appDir, framework, merged.entrypoint?.value, context.runtime.signal);
+	const buildSettingsResolution = await resolveDeployBuildSettings({
+		computeConfig,
+		appDir,
+		buildType,
+		signal: context.runtime.signal
+	});
+	const legacyWarnings = await handleLegacyBuildSettings(context, appDir, buildSettingsResolution.settings);
+	maybeRenderDeployBuildSettings(context, buildSettingsResolution);
 	const portMapping = parseDeployPortMapping(String(runtime.port));
-	const progressState = createPreviewDeployProgressState();
+	const branchDatabaseSetup = await maybeSetupBranchDatabase(context, provider, projectId, toBranchDatabaseDeployBranch(target.branch), {
+		db: options?.db,
+		providedEnvVars: envVars,
+		firstProductionDeploy: productionDeployGate.firstProductionDeploy,
+		projectDir
+	});
+	const progressState = createDeployProgressState();
 	const deployStartedAt = Date.now();
 	const deployResult = await provider.deployApp({
-		cwd: context.runtime.cwd,
+		cwd: appDir,
 		projectId,
 		branchName: target.branch.name,
 		appId: selectedApp.appId,
@@ -171,10 +365,13 @@ async function runAppDeploy(context, appName, options) {
 		region: selectedApp.region,
 		entrypoint,
 		buildType,
+		buildSettings: buildSettingsResolution.settings,
 		portMapping,
 		envVars,
+		skipPromote: noPromote,
 		interaction: void 0,
-		progress: createPreviewDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
+		signal: context.runtime.signal,
+		progress: createDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
 	}).catch((error) => {
 		throw appDeployFailedError(error, progressState);
 	});
@@ -183,41 +380,93 @@ async function runAppDeploy(context, appName, options) {
 		id: deployResult.app.id,
 		name: deployResult.app.name
 	});
-	await context.stateStore.setKnownLiveDeployment(projectId, deployResult.app.id, deployResult.deployment.id);
+	const knownLiveDeploymentId = deployResult.promoted ? deployResult.deployment.id : deployResult.app.liveDeploymentId;
+	if (knownLiveDeploymentId) await context.stateStore.setKnownLiveDeployment(projectId, deployResult.app.id, knownLiveDeploymentId);
 	return {
 		command: "app.deploy",
 		result: {
 			workspace: target.workspace,
 			project: target.project,
-			branch: target.branch,
+			branch: toResultBranch(target.branch),
 			resolution: target.resolution,
+			branchDatabase: branchDatabaseSetup.result,
 			app: {
 				id: deployResult.app.id,
 				name: deployResult.app.name
 			},
 			deployment: deployResult.deployment,
+			promoted: deployResult.promoted,
+			deploySettings: {
+				config: {
+					path: buildSettingsResolution.relativeConfigPath,
+					status: buildSettingsResolution.status
+				},
+				buildCommand: {
+					value: buildSettingsResolution.settings.buildCommand,
+					source: buildSettingsResolution.settings.buildCommandSource
+				},
+				outputDirectory: {
+					value: buildSettingsResolution.settings.outputDirectory,
+					source: buildSettingsResolution.settings.outputDirectorySource
+				},
+				framework: {
+					key: framework.key,
+					buildType,
+					name: framework.displayName,
+					source: framework.annotation
+				},
+				entrypoint: entrypoint ?? buildSettingsResolution.settings.entrypoint ?? null,
+				httpPort: runtime.port,
+				region: deployResult.app.region ?? selectedApp.region ?? null,
+				envVars: envVarNames(envVars)
+			},
 			durationMs: deployDurationMs,
 			localPin: localPinResult
 		},
-		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 runAppListDeploys(context, appName, projectRef) {
+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 { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app list-deploys" });
-	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName);
+	const compute = await resolveComputeManagementContext(context, configTarget, "list-deploys");
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
+		commandName: "app list-deploys",
+		projectDir: compute.projectDir
+	});
+	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName ?? compute.configAppName);
 	if (!selectedApp) return {
 		command: "app.list-deploys",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: null,
 			deployments: []
 		},
 		warnings: [],
 		nextSteps: ["prisma-cli app deploy"]
 	};
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app deploy"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -230,6 +479,7 @@ async function runAppListDeploys(context, appName, projectRef) {
 		command: "app.list-deploys",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -240,14 +490,19 @@ async function runAppListDeploys(context, appName, projectRef) {
 		nextSteps: deployments.length > 0 ? [`prisma-cli app show-deploy ${deployments[0]?.id}`] : ["prisma-cli app deploy"]
 	};
 }
-async function runAppShow(context, appName, projectRef) {
+async function runAppShow(context, appName, projectRef, configTarget) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app show" });
-	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName);
+	const compute = await resolveComputeManagementContext(context, configTarget, "show");
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
+		commandName: "app show",
+		projectDir: compute.projectDir
+	});
+	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName ?? compute.configAppName);
 	if (!selectedApp) return {
 		command: "app.show",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: null,
 			liveDeployment: null,
 			liveUrl: null,
@@ -256,7 +511,7 @@ async function runAppShow(context, appName, projectRef) {
 		warnings: [],
 		nextSteps: ["prisma-cli app deploy"]
 	};
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to inspect app", error, ["prisma-cli app list-deploys"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -270,6 +525,7 @@ async function runAppShow(context, appName, projectRef) {
 		command: "app.show",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -284,7 +540,7 @@ async function runAppShow(context, appName, projectRef) {
 }
 async function runAppShowDeploy(context, deploymentId) {
 	ensurePreviewAppMode(context);
-	const deployment = await (await requirePreviewAppProvider(context)).showDeployment(deploymentId).catch((error) => {
+	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"]);
 	});
 	if (!deployment) throw new CliError({
@@ -316,12 +572,17 @@ async function runAppShowDeploy(context, deploymentId) {
 		nextSteps: []
 	};
 }
-async function runAppOpen(context, appName, projectRef) {
+async function runAppOpen(context, appName, projectRef, configTarget) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app open" });
+	const compute = await resolveComputeManagementContext(context, configTarget, "open");
+	appName = appName ?? compute.configAppName;
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
+		commandName: "app open",
+		projectDir: compute.projectDir
+	});
 	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName);
 	if (!selectedApp) throw noDeploymentsError("No deployments available to open", "The resolved project does not have any deployed app yet.");
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to resolve app URL", error, ["prisma-cli app show"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -334,11 +595,16 @@ async function runAppOpen(context, appName, projectRef) {
 	if (!liveDeployment) throw noDeploymentsError("No deployments available to open", `The selected app "${deploymentsResult.app.name}" does not have any deployments yet.`);
 	if (!deploymentsResult.app.liveUrl) throw featureUnavailableError("Live URL is not available for the selected app", "Deployments exist, but the provider does not expose a stable live service URL for this app yet.", "Run prisma-cli app show to inspect the current deployment state and try again after the app reports a live URL.", ["prisma-cli app show"], "app");
 	const shouldOpen = canPrompt(context);
-	if (shouldOpen) await open(deploymentsResult.app.liveUrl);
+	if (shouldOpen) {
+		context.runtime.signal.throwIfAborted();
+		await open(deploymentsResult.app.liveUrl);
+		context.runtime.signal.throwIfAborted();
+	}
 	return {
 		command: "app.open",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -355,7 +621,8 @@ async function runAppDomainAdd(context, hostname, options) {
 	const target = await resolveAppDomainTarget(context, options, `app domain add ${normalizedHostname}`);
 	const added = await target.provider.addDomain({
 		appId: target.app.id,
-		hostname: normalizedHostname
+		hostname: normalizedHostname,
+		signal: context.runtime.signal
 	}).catch((error) => {
 		throw domainCommandError("add", error, normalizedHostname);
 	});
@@ -373,8 +640,8 @@ async function runAppDomainAdd(context, hostname, options) {
 async function runAppDomainShow(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
 	const target = await resolveAppDomainTarget(context, options, `app domain show ${normalizedHostname}`);
-	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "show");
-	const detail = await target.provider.showDomain(domain.id).catch((error) => {
+	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "show", context.runtime.signal);
+	const detail = await target.provider.showDomain(domain.id, { signal: context.runtime.signal }).catch((error) => {
 		throw domainCommandError("show", error, normalizedHostname);
 	});
 	return {
@@ -390,9 +657,9 @@ async function runAppDomainShow(context, hostname, options) {
 async function runAppDomainRemove(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
 	const target = await resolveAppDomainTarget(context, options, `app domain remove ${normalizedHostname}`);
-	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "remove");
+	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "remove", context.runtime.signal);
 	await confirmDomainRemoval(context, target.resultTarget, normalizedHostname);
-	await target.provider.removeDomain(domain.id).catch((error) => {
+	await target.provider.removeDomain(domain.id, { signal: context.runtime.signal }).catch((error) => {
 		throw domainCommandError("remove", error, normalizedHostname);
 	});
 	return {
@@ -409,8 +676,8 @@ async function runAppDomainRemove(context, hostname, options) {
 async function runAppDomainRetry(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
 	const target = await resolveAppDomainTarget(context, options, `app domain retry ${normalizedHostname}`);
-	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "retry");
-	const retried = await target.provider.retryDomain(domain.id).catch((error) => {
+	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "retry", context.runtime.signal);
+	const retried = await target.provider.retryDomain(domain.id, { signal: context.runtime.signal }).catch((error) => {
 		throw domainCommandError("retry", error, normalizedHostname);
 	});
 	return {
@@ -427,7 +694,7 @@ async function runAppDomainWait(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
 	const timeoutMs = parseDomainWaitTimeout(options?.timeout);
 	const target = await resolveAppDomainTarget(context, options, `app domain wait ${normalizedHostname}`);
-	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "wait");
+	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "wait", context.runtime.signal);
 	if (!context.flags.json && !context.flags.quiet) context.output.stderr.write([
 		`app domain wait -> Waiting for ${normalizedHostname} to become active.`,
 		"",
@@ -470,21 +737,25 @@ async function runAppDomainWait(context, hostname, options) {
 			exitCode: 1,
 			nextSteps: [`prisma-cli app domain show ${normalizedHostname}`]
 		});
-		await sleep(Math.min(pollIntervalMs, Math.max(deadline - Date.now(), 0)));
-		current = await target.provider.showDomain(current.id).catch((error) => {
+		await sleep(Math.min(pollIntervalMs, Math.max(deadline - Date.now(), 0)), context.runtime.signal);
+		current = await target.provider.showDomain(current.id, { signal: context.runtime.signal }).catch((error) => {
 			throw domainCommandError("wait", error, normalizedHostname);
 		});
 	}
 }
-async function runAppLogs(context, appName, deploymentId, projectRef) {
+async function runAppLogs(context, appName, deploymentId, projectRef, configTarget) {
 	ensurePreviewAppMode(context);
-	const { provider, target: resolvedTarget, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app logs" });
+	const compute = await resolveComputeManagementContext(context, configTarget, "logs");
+	appName = appName ?? compute.configAppName;
+	const { provider, target: resolvedTarget, projectId } = await requireProviderAndProjectContext(context, projectRef, {
+		commandName: "app logs",
+		projectDir: compute.projectDir
+	});
 	const target = deploymentId ? await resolveExplicitLogDeployment(context, provider, projectId, resolvedTarget.branch.name, appName, deploymentId) : await resolveLiveLogDeployment(context, provider, projectId, resolvedTarget.branch.name, appName);
 	if (!context.flags.json && !context.flags.quiet) {
 		const lines = renderCommandHeader(context.ui, {
 			commandLabel: "app logs",
 			description: "Streaming logs for the selected deployment.",
-			docsPath: "docs/product/command-spec.md#prisma-cli-app-logs---app-name---deployment-id",
 			rows: [
 				{
 					key: "project",
@@ -504,6 +775,7 @@ async function runAppLogs(context, appName, deploymentId, projectRef) {
 	}
 	await provider.streamDeploymentLogs({
 		deploymentId: target.deployment.id,
+		signal: context.runtime.signal,
 		onRecord: (record) => writeLogRecord(context, record)
 	}).catch((error) => {
 		throw deployFailedError("Failed to stream app logs", error, [`prisma-cli app show-deploy ${target.deployment.id}`, "prisma-cli app list-deploys"]);
@@ -513,7 +785,7 @@ async function resolveExplicitLogDeployment(context, provider, projectId, branch
 	if (appName) {
 		const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, branchName), appName);
 		if (!selectedApp) throw noDeploymentsError("No deployments available to stream logs", "The resolved project does not have any deployed app yet.");
-		const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+		const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 			throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
 		});
 		const deployment = requireDeploymentForApp(deploymentsResult.deployments, deploymentId, selectedApp.name);
@@ -526,7 +798,7 @@ async function resolveExplicitLogDeployment(context, provider, projectId, branch
 			deployment
 		};
 	}
-	const shown = await provider.showDeployment(deploymentId).catch((error) => {
+	const shown = await provider.showDeployment(deploymentId, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to show deployment", error, ["prisma-cli app list-deploys"]);
 	});
 	if (!shown) throw new CliError({
@@ -569,7 +841,7 @@ async function resolveExplicitLogDeployment(context, provider, projectId, branch
 async function resolveLiveLogDeployment(context, provider, projectId, branchName, appName) {
 	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, branchName), appName);
 	if (!selectedApp) throw noDeploymentsError("No deployments available to stream logs", "The resolved project does not have any deployed app yet.");
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -600,11 +872,16 @@ function writeLogRecord(context, record) {
 		if (!record.text.endsWith("\n")) context.output.stdout.write("\n");
 	}
 }
-async function runAppPromote(context, deploymentId, appName, projectRef) {
+async function runAppPromote(context, deploymentId, appName, projectRef, configTarget) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app promote" });
+	const compute = await resolveComputeManagementContext(context, configTarget, "promote");
+	appName = appName ?? compute.configAppName;
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
+		commandName: "app promote",
+		projectDir: compute.projectDir
+	});
 	const selectedApp = await requireReleaseAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName, "promote");
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -617,7 +894,8 @@ async function runAppPromote(context, deploymentId, appName, projectRef) {
 	if (!targetAlreadyLive) await provider.promoteDeployment({
 		appId: selectedApp.id,
 		deploymentId: targetDeployment.id,
-		progress: createPreviewPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
+		signal: context.runtime.signal,
+		progress: createPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
 	}).catch((error) => {
 		throw deployFailedError("Failed to promote deployment", error, ["prisma-cli app list-deploys"]);
 	});
@@ -626,6 +904,7 @@ async function runAppPromote(context, deploymentId, appName, projectRef) {
 		command: "app.promote",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -640,11 +919,16 @@ async function runAppPromote(context, deploymentId, appName, projectRef) {
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${targetDeployment.id}`]
 	};
 }
-async function runAppRollback(context, appName, deploymentId, projectRef) {
+async function runAppRollback(context, appName, deploymentId, projectRef, configTarget) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app rollback" });
+	const compute = await resolveComputeManagementContext(context, configTarget, "rollback");
+	appName = appName ?? compute.configAppName;
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
+		commandName: "app rollback",
+		projectDir: compute.projectDir
+	});
 	const selectedApp = await requireReleaseAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName, "rollback");
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -658,7 +942,8 @@ async function runAppRollback(context, appName, deploymentId, projectRef) {
 	if (!targetAlreadyLive) await provider.promoteDeployment({
 		appId: selectedApp.id,
 		deploymentId: targetDeployment.id,
-		progress: createPreviewPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
+		signal: context.runtime.signal,
+		progress: createPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
 	}).catch((error) => {
 		throw deployFailedError("Failed to roll back deployment", error, ["prisma-cli app list-deploys"]);
 	});
@@ -667,6 +952,7 @@ async function runAppRollback(context, appName, deploymentId, projectRef) {
 		command: "app.rollback",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -682,12 +968,17 @@ async function runAppRollback(context, appName, deploymentId, projectRef) {
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${targetDeployment.id}`]
 	};
 }
-async function runAppRemove(context, appName, projectRef) {
+async function runAppRemove(context, appName, projectRef, configTarget) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app remove" });
+	const compute = await resolveComputeManagementContext(context, configTarget, "remove");
+	appName = appName ?? compute.configAppName;
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
+		commandName: "app remove",
+		projectDir: compute.projectDir
+	});
 	const selectedApp = await requireReleaseAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName, "remove");
 	await confirmAppRemoval(context, selectedApp);
-	const removedApp = await provider.removeApp(selectedApp.id).catch((error) => {
+	const removedApp = await provider.removeApp(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw removeFailedError("Failed to remove app", error, ["prisma-cli app show", "prisma-cli app list-deploys"]);
 	});
 	const warnings = await cleanupRemovedAppState(context, projectId, removedApp.id);
@@ -695,6 +986,7 @@ async function runAppRemove(context, appName, projectRef) {
 		command: "app.remove",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: removedApp.id,
 				name: removedApp.name
@@ -707,6 +999,7 @@ async function runAppRemove(context, appName, projectRef) {
 }
 async function resolveAppDomainTarget(context, options, commandName = "app domain") {
 	ensurePreviewAppMode(context);
+	const compute = await resolveComputeManagementContext(context, options?.configTarget, commandName.replace(/^app /, ""));
 	const branch = resolveDomainBranch(options?.branchName);
 	if (toBranchKind(branch.name) !== "production") throw new CliError({
 		code: "BRANCH_NOT_DEPLOYABLE",
@@ -722,10 +1015,11 @@ async function resolveAppDomainTarget(context, options, commandName = "app domai
 	const { provider, target, projectId } = await requireProviderAndProjectContext(context, options?.projectRef, {
 		branch,
 		commandName,
-		envProjectId
+		envProjectId,
+		projectDir: compute.projectDir
 	});
 	const selectedApp = await resolveDomainAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), {
-		explicitAppName: options?.appName,
+		explicitAppName: options?.appName ?? compute.configAppName,
 		explicitAppId: envAppId
 	});
 	await context.stateStore.setSelectedApp(projectId, {
@@ -738,7 +1032,7 @@ async function resolveAppDomainTarget(context, options, commandName = "app domai
 		resultTarget: {
 			workspace: target.workspace,
 			project: target.project,
-			branch: target.branch,
+			branch: toResultBranch(target.branch),
 			app: {
 				id: selectedApp.id,
 				name: selectedApp.name
@@ -762,8 +1056,8 @@ async function resolveDomainAppSelection(context, projectId, apps, options) {
 	if (selectedApp) return selectedApp;
 	throw usageError("Custom domain requires an existing app on the production branch", "The resolved production branch does not have an app that can receive a custom domain.", "Deploy or promote an app to production first, then rerun the domain command.", ["prisma-cli app deploy --branch production", "prisma-cli app show"], "app");
 }
-async function resolveDomainByHostname(provider, appId, hostname, command) {
-	const matched = (await provider.listDomains(appId).catch((error) => {
+async function resolveDomainByHostname(provider, appId, hostname, command, signal) {
+	const matched = (await provider.listDomains(appId, { signal }).catch((error) => {
 		throw domainCommandError(command, error, hostname);
 	})).find((domain) => sameDomainHostname(domain.hostname, hostname));
 	if (matched) return matched;
@@ -798,7 +1092,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,
@@ -836,12 +1130,13 @@ 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 PreviewDomainApiError) {
+	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",
@@ -994,32 +1289,35 @@ function formatElapsed(milliseconds) {
 	const remainingSeconds = seconds % 60;
 	return `${minutes}:${String(remainingSeconds).padStart(2, "0")}`;
 }
-async function sleep(milliseconds) {
+async function sleep(milliseconds, signal) {
 	if (milliseconds <= 0) return;
-	await new Promise((resolve) => setTimeout(resolve, milliseconds));
+	signal.throwIfAborted();
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(signal.reason);
+		};
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, milliseconds);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
 }
 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: PREVIEW_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,
@@ -1027,25 +1325,54 @@ async function resolveDeployAppSelection(context, projectId, apps, options) {
 			firstDeploy: options.firstDeploy
 		};
 	}
+	if (options.configAppName) {
+		const configName = options.configAppName;
+		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 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",
+	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 {
+			appId: matched.id,
+			displayName: matched.name,
+			annotation: options.matchedAnnotation,
+			firstDeploy: options.firstDeploy
+		};
+	}
 	return {
-		appName: inferredName.name,
-		region: PREVIEW_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__";
@@ -1071,11 +1398,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: PREVIEW_DEFAULT_REGION,
+			region: newAppRegion,
 			displayName: targetName,
 			annotation: "created from package.json",
 			firstDeploy
 		};
+		assertDeployRegionMatchesExistingApp(selected, requestedRegion);
 		return {
 			appId: selected.id,
 			displayName: selected.name,
@@ -1097,6 +1425,9 @@ async function resolveAmbiguousDeployApp(context, matches, targetName, firstDepl
 		nextSteps: ["prisma-cli app deploy --app <name>"]
 	});
 }
+function deployNewAppRegion(configRegion) {
+	return configRegion?.value ?? "eu-central-1";
+}
 async function resolveExistingAppSelection(context, projectId, apps, explicitAppName) {
 	if (explicitAppName) {
 		const matched = findAppByName(apps, explicitAppName);
@@ -1139,6 +1470,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.`
@@ -1211,7 +1543,10 @@ function resolveRollbackTarget(deployments, currentLiveDeploymentId) {
 	});
 }
 async function listApps(context, provider, projectId, branchName) {
-	return provider.listApps(projectId, { branchName }).then(sortApps).catch((error) => {
+	return provider.listApps(projectId, {
+		branchName,
+		signal: context.runtime.signal
+	}).then(sortApps).catch((error) => {
 		if (isMissingProjectError(error)) throw new CliError({
 			code: "PROJECT_NOT_FOUND",
 			domain: "project",
@@ -1229,20 +1564,20 @@ async function requirePreviewAppProvider(context) {
 	return provider;
 }
 async function requirePreviewAppProviderWithClient(context) {
-	const client = await requireComputeAuth(context.runtime.env);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
 	return {
 		client,
-		provider: createPreviewAppProvider(client, createPreviewLogAuthOptions(context.runtime.env))
+		provider: createAppProvider(client, createPreviewLogAuthOptions(context.runtime.env, context.runtime.signal))
 	};
 }
-function createPreviewLogAuthOptions(env) {
+function createPreviewLogAuthOptions(env, signal) {
 	const rawToken = env[SERVICE_TOKEN_ENV_VAR]?.trim();
 	if (rawToken) return {
 		baseUrl: getApiBaseUrl(env),
 		getToken: async () => rawToken
 	};
-	const tokenStorage = new FileTokenStorage(env);
+	const tokenStorage = new FileTokenStorage(env, signal);
 	return {
 		baseUrl: getApiBaseUrl(env),
 		getToken: async () => {
@@ -1275,20 +1610,29 @@ async function requireProviderAndDeployProjectContext(context, explicitProject,
 async function resolveProjectContext(context, client, explicitProject, options) {
 	const authState = await requireAuthenticatedAuthState(context);
 	if (!authState.workspace) throw workspaceRequiredError();
-	const resolved = await resolveProjectTarget({
+	const resolvedResult = await resolveProjectTarget({
 		context,
 		workspace: authState.workspace,
 		explicitProject,
 		envProjectId: options?.envProjectId,
-		listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
+		projectDir: options?.projectDir,
+		listProjects: () => listRealWorkspaceProjects(client, authState.workspace, context.runtime.signal),
 		commandName: options?.commandName
 	});
-	const branch = options?.branch ?? await resolveDeployBranch(context, void 0);
+	if (resolvedResult.isErr()) throw projectResolutionErrorToCliError(resolvedResult.error);
+	const resolved = resolvedResult.value;
+	const requested = options?.branch ?? await resolveDeployBranch(context, void 0);
+	const remoteBranch = options?.branch ? null : await resolveReadBranch(client, {
+		projectId: resolved.project.id,
+		branchName: requested.name,
+		signal: context.runtime.signal
+	});
 	return {
 		...resolved,
-		branch: {
-			name: branch.name,
-			kind: toBranchKind(branch.name)
+		branch: remoteBranch ?? {
+			id: null,
+			name: requested.name,
+			kind: toBranchKind(requested.name)
 		}
 	};
 }
@@ -1296,8 +1640,8 @@ 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);
-	if (explicitProject) return withDeployBranch({
+	const projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
+	if (explicitProject) return withRemoteDeployBranch(provider, {
 		workspace,
 		project: toProjectSummary(resolveProjectForSetup(explicitProject, projects, workspace)),
 		resolution: {
@@ -1306,25 +1650,25 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 			targetNameSource: "explicit"
 		},
 		localPinAction: "linked"
-	}, branch);
+	}, branch, context.runtime.signal);
 	if (options.createProjectName) {
 		const projectName = options.createProjectName.trim();
 		if (!projectName) throw projectSetupNameRequiredError("app deploy --create-project");
-		return withDeployBranch({
+		return withRemoteDeployBranch(provider, {
 			workspace,
-			project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace)),
+			project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal)),
 			resolution: {
 				projectSource: "created",
 				targetName: projectName,
 				targetNameSource: "explicit"
 			},
 			localPinAction: "created"
-		}, branch);
+		}, branch, context.runtime.signal);
 	}
 	if (options.envProjectId) {
 		const project = projects.find((candidate) => candidate.id === options.envProjectId);
 		if (!project) throw projectNotFoundError(options.envProjectId, workspace);
-		return withDeployBranch({
+		return withRemoteDeployBranch(provider, {
 			workspace,
 			project: toProjectSummary(project),
 			resolution: {
@@ -1332,14 +1676,18 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 				targetName: options.envProjectId,
 				targetNameSource: "env"
 			}
-		}, branch);
+		}, branch, context.runtime.signal);
 	}
 	const localPin = options.localPin;
 	if (localPin.kind === "present") {
-		if (localPin.pin.workspaceId !== workspace.id) throw localResolutionPinStaleError();
+		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 withDeployBranch({
+		return withRemoteDeployBranch(provider, {
 			workspace,
 			project: toProjectSummary(project),
 			resolution: {
@@ -1347,10 +1695,10 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 				targetName: project.name,
 				targetNameSource: "local-pin"
 			}
-		}, branch);
+		}, branch, context.runtime.signal);
 	}
 	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping && platformMapping.workspace.id === workspace.id) return withDeployBranch({
+	if (platformMapping && platformMapping.workspace.id === workspace.id) return withRemoteDeployBranch(provider, {
 		workspace,
 		project: toProjectSummary(platformMapping),
 		resolution: {
@@ -1358,15 +1706,15 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 			targetName: platformMapping.name,
 			targetNameSource: "platform-mapping"
 		}
-	}, branch);
-	if (canPrompt(context) && !context.flags.yes) return withDeployBranch(await resolveInteractiveDeployProjectSetup(context, provider, workspace, projects), branch);
-	throw projectSetupRequiredError(projects, await inferTargetName(context.runtime.cwd));
+	}, branch, context.runtime.signal);
+	if (canPrompt(context) && !context.flags.yes) return withRemoteDeployBranch(provider, await resolveInteractiveDeployProjectSetup(context, provider, workspace, projects), branch, context.runtime.signal);
+	throw projectSetupRequiredError(projects, await inferTargetName(context.runtime.cwd, context.runtime.signal));
 }
 async function resolveInteractiveDeployProjectSetup(context, provider, workspace, projects) {
 	const setup = await promptForProjectSetupChoice({
 		context,
 		projects,
-		createProject: (projectName) => createProjectForDeploySetup(provider, projectName, workspace),
+		createProject: (projectName) => createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal),
 		cancel: {
 			why: "Deploy needs a Project before it can continue.",
 			fix: "Choose an existing Project or create a new one, then rerun deploy.",
@@ -1384,8 +1732,11 @@ async function resolveInteractiveDeployProjectSetup(context, provider, workspace
 		localPinAction: setup.action
 	};
 }
-async function createProjectForDeploySetup(provider, projectName, workspace) {
-	const created = await provider.createProject({ name: projectName }).catch((error) => {
+async function createProjectForDeploySetup(provider, projectName, workspace, signal) {
+	const created = await provider.createProject({
+		name: projectName,
+		signal
+	}).catch((error) => {
 		throw projectCreateFailedError(error, projectName, workspace, {
 			nextSteps: [
 				"prisma-cli project list",
@@ -1402,18 +1753,46 @@ async function createProjectForDeploySetup(provider, projectName, workspace) {
 		workspace
 	};
 }
-function withDeployBranch(target, branch) {
+async function withRemoteDeployBranch(provider, target, branch, signal) {
+	const remoteBranch = await provider.resolveBranch(target.project.id, {
+		branchName: branch.name,
+		signal
+	});
 	return {
 		...target,
 		branch: {
-			name: branch.name,
-			kind: toBranchKind(branch.name)
+			id: remoteBranch.id,
+			name: remoteBranch.name,
+			kind: remoteBranch.role
 		}
 	};
 }
 function toBranchKind(name) {
 	return name === "production" || name === "main" ? "production" : "preview";
 }
+function toResultBranch(branch) {
+	return {
+		id: branch.id,
+		name: branch.name,
+		kind: branch.kind
+	};
+}
+function toAppVerboseContext(target) {
+	return {
+		workspace: target.workspace,
+		project: target.project,
+		branch: target.branch,
+		resolution: target.resolution
+	};
+}
+function toBranchDatabaseDeployBranch(branch) {
+	if (!branch.id) throw new Error(`Deploy branch "${branch.name}" was not resolved remotely.`);
+	return {
+		id: branch.id,
+		name: branch.name,
+		kind: branch.kind
+	};
+}
 function assertExclusiveDeployProjectInputs(options) {
 	const provided = [
 		options.projectRef ? "--project" : null,
@@ -1432,7 +1811,7 @@ async function resolveDeployBranch(context, explicitBranchName) {
 		name: explicitBranchName,
 		annotation: "set by --branch"
 	};
-	const gitBranch = await readLocalGitBranch(context.runtime.cwd);
+	const gitBranch = await readLocalGitBranch(context.runtime.cwd, context.runtime.signal);
 	if (gitBranch) return {
 		name: gitBranch,
 		annotation: "from local Git branch"
@@ -1442,45 +1821,130 @@ async function resolveDeployBranch(context, explicitBranchName) {
 		annotation: "default"
 	};
 }
-async function readLocalGitBranch(cwd) {
-	const headPath = await resolveGitHeadPath(path.join(cwd, ".git"));
-	if (!headPath) return null;
-	try {
-		const head = (await readFile(headPath, "utf8")).trim();
-		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
-	} catch {
-		return null;
+async function resolveComputeTargetOrThrow(context, configTarget, commandName, options) {
+	let config;
+	if (options?.preloaded !== void 0) config = options.preloaded;
+	else {
+		const loaded = await loadComputeConfig$1(context.runtime.cwd, context.runtime.signal);
+		if (loaded.isErr()) throw computeConfigErrorToCliError(loaded.error, commandName);
+		config = loaded.value;
 	}
-	return null;
+	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");
+		return {
+			config: null,
+			target: null
+		};
+	}
+	const requestedTarget = configTarget ?? inferComputeTargetFromCwd(config, context.runtime.cwd);
+	const selected = selectComputeDeployTarget(config, requestedTarget);
+	if (selected.isErr()) {
+		if (options?.targetOptional && selected.error instanceof ComputeConfigTargetRequiredError) return {
+			config,
+			target: null
+		};
+		throw computeConfigErrorToCliError(selected.error, commandName);
+	}
+	return {
+		config,
+		target: selected.value
+	};
 }
-async function resolveGitHeadPath(gitPath) {
-	try {
-		const raw = await readFile(gitPath, "utf8");
-		if (raw.startsWith("gitdir:")) return path.join(path.resolve(path.dirname(gitPath), raw.slice(7).trim()), "HEAD");
-	} catch {}
+/**
+* Compute-config context for app management commands: the project directory
+* (where `.prisma/local.json` lives) and the config-selected app name, which
+* ranks below `--app` but above the remembered app selection.
+*/
+async function resolveComputeManagementContext(context, configTarget, commandName) {
+	const compute = await resolveComputeTargetOrThrow(context, configTarget, commandName, { targetOptional: true });
+	return {
+		projectDir: compute.config?.configDir ?? context.runtime.cwd,
+		configAppName: compute.target?.name ?? compute.target?.key ?? void 0
+	};
+}
+async function resolveComputeAppDir(context, compute) {
+	if (!compute.config || !compute.target) return context.runtime.cwd;
+	const appDir = computeTargetAppDir(compute.config, compute.target);
+	if (!compute.target.root) return appDir;
+	context.runtime.signal.throwIfAborted();
 	try {
-		await access(path.join(gitPath, "HEAD"));
-		return path.join(gitPath, "HEAD");
-	} catch {
-		return null;
+		await access(appDir);
+		context.runtime.signal.throwIfAborted();
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
+		throw new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: `App root "${compute.target.root}" does not exist`,
+			why: `${compute.config.relativeConfigPath} points the selected app at "${compute.target.root}", but that directory does not exist.`,
+			fix: `Fix the root path in ${compute.config.relativeConfigPath} or create the directory.`,
+			where: appDir,
+			meta: {
+				appRoot: compute.target.root,
+				appDir
+			},
+			exitCode: 2,
+			nextSteps: ["prisma-cli app deploy"]
+		});
+	}
+	return appDir;
+}
+/**
+* `prisma.app.json` is no longer read or written. A leftover file that
+* matches the effective settings only warns; one with custom values fails
+* with migration guidance so builds never silently change.
+*/
+async function handleLegacyBuildSettings(context, appDir, effective) {
+	const legacy = await detectLegacyBuildSettings({
+		appPath: appDir,
+		effective,
+		signal: context.runtime.signal
+	});
+	switch (legacy.kind) {
+		case "absent": return [];
+		case "matching": return [`${PRISMA_APP_CONFIG_FILENAME} is no longer used and matches the resolved build settings. Delete it.`];
+		case "invalid": return [`${PRISMA_APP_CONFIG_FILENAME} is no longer used and could not be parsed. Delete it.`];
+		case "custom": {
+			const buildBlock = [
+				"build: {",
+				`  command: ${legacy.buildCommand === null ? "null" : JSON.stringify(legacy.buildCommand)},`,
+				`  outputDirectory: ${JSON.stringify(legacy.outputDirectory)},`,
+				"}"
+			].join(" ");
+			throw new CliError({
+				code: "BUILD_SETTINGS_MIGRATION_REQUIRED",
+				domain: "app",
+				summary: `${PRISMA_APP_CONFIG_FILENAME} is no longer supported`,
+				why: `${PRISMA_APP_CONFIG_FILENAME} contains custom build settings that differ from the resolved defaults, and the file is no longer read.`,
+				fix: `Move the settings into prisma.compute.ts as \`${buildBlock}\` on this app, then delete ${PRISMA_APP_CONFIG_FILENAME}.`,
+				where: legacy.configPath,
+				meta: {
+					configPath: legacy.configPath,
+					buildCommand: legacy.buildCommand,
+					outputDirectory: legacy.outputDirectory
+				},
+				exitCode: 2,
+				nextSteps: ["prisma-cli app deploy"]
+			});
+		}
 	}
 }
 async function resolveDeployFramework(context, options) {
-	if (options.requestedFramework) return frameworkFromUserFacingValue(options.requestedFramework, "set by --framework");
+	if (options.requestedFramework) return frameworkFromUserFacingValue(options.requestedFramework, options.requestedFrameworkAnnotation ?? "set by --framework");
 	if (options.entrypoint) return {
 		key: "bun",
 		buildType: "bun",
 		displayName: "Bun",
-		annotation: "set by --entry"
+		annotation: options.entrypointAnnotation ?? "set by --entry"
 	};
-	const detected = await detectDeployFramework(context.runtime.cwd);
+	const detected = await detectDeployFramework(options.appDir, context.runtime.signal);
 	if (detected) return detected;
-	throw frameworkNotDetectedError(context.runtime.cwd);
+	throw frameworkNotDetectedError(options.appDir);
 }
-function resolveDeployRuntime(requestedHttpPort, framework) {
+function resolveDeployRuntime(requestedHttpPort, requestedHttpPortAnnotation, framework) {
 	if (requestedHttpPort) return {
 		port: parseDeployHttpPort(requestedHttpPort),
-		annotation: "set by --http-port"
+		annotation: requestedHttpPortAnnotation ?? "set by --http-port"
 	};
 	return {
 		port: FRAMEWORK_DEFAULT_HTTP_PORT,
@@ -1491,65 +1955,62 @@ function assertSupportedEntrypointForRequestedDeployShape(options) {
 	if (!options.requestedFramework) return;
 	assertSupportedEntrypoint(frameworkFromUserFacingValue(options.requestedFramework, "set by --framework").buildType, options.entrypoint, "deploy");
 }
-async function resolveDeployEntrypoint(cwd, framework, explicitEntrypoint) {
+async function resolveDeployEntrypoint(cwd, framework, explicitEntrypoint, signal) {
 	if (explicitEntrypoint || framework.buildType !== "bun") return explicitEntrypoint;
-	const packageEntrypoint = readBunPackageEntrypoint(await readBunPackageJson(cwd));
+	const packageEntrypoint = readBunPackageEntrypoint(await readBunPackageJson(cwd, signal));
 	if (packageEntrypoint) return packageEntrypoint;
-	if (framework.key !== "hono") return;
-	const defaultEntrypoint = "src/index.ts";
+	const defaultEntrypoint = frameworkFromAlias(framework.key)?.defaultEntrypoint;
+	if (!defaultEntrypoint) return;
+	signal.throwIfAborted();
 	try {
 		await access(path.join(cwd, defaultEntrypoint));
+		signal.throwIfAborted();
 		return defaultEntrypoint;
 	} catch (error) {
+		if (signal.aborted) throw error;
 		if (error.code !== "ENOENT") throw error;
 		return;
 	}
 }
-async function detectDeployFramework(cwd) {
-	const packageJson = await readBunPackageJson(cwd);
-	const nextConfig = await detectNextConfig(cwd);
-	if (nextConfig.exists || hasPackageDependency(packageJson, "next")) return {
-		key: "nextjs",
-		buildType: "nextjs",
-		displayName: "Next.js",
-		annotation: nextConfig.standalone ? "standalone output detected" : nextConfig.exists ? "detected from next.config" : "detected from package.json"
-	};
-	if (hasPackageDependency(packageJson, "hono")) return {
-		key: "hono",
-		buildType: "bun",
-		displayName: "Hono",
-		annotation: "detected from package.json"
-	};
-	if (hasAnyPackageDependency(packageJson, TANSTACK_START_PACKAGES)) return {
-		key: "tanstack-start",
-		buildType: "tanstack-start",
-		displayName: "TanStack Start",
-		annotation: "detected from package.json"
-	};
+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 detectNextConfig(cwd) {
-	for (const candidate of [
-		"next.config.js",
-		"next.config.mjs",
-		"next.config.cjs",
-		"next.config.ts",
-		"next.config.mts"
-	]) {
+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, "utf8");
+			const content = await readFile(filePath, {
+				encoding: "utf8",
+				signal
+			});
 			return {
 				exists: true,
-				standalone: /\boutput\s*:\s*["'`]standalone["'`]/.test(content)
+				standalone: /\boutput\s*:\s*["'`]standalone["'`]/.test(content),
+				path: filePath
 			};
 		} catch (error) {
+			if (signal.aborted) throw error;
 			if (error.code !== "ENOENT") throw error;
 		}
 	}
 	return {
 		exists: false,
-		standalone: false
+		standalone: false,
+		path: null
 	};
 }
 function hasPackageDependency(packageJson, dependencyName) {
@@ -1562,48 +2023,36 @@ function hasDependency(dependencies, dependencyName) {
 	return Boolean(dependencies && typeof dependencies === "object" && dependencyName in dependencies);
 }
 function frameworkFromUserFacingValue(value, annotation) {
-	switch (value.trim().toLowerCase()) {
-		case "next":
-		case "next.js":
-		case "nextjs": return {
-			key: "nextjs",
-			buildType: "nextjs",
-			displayName: "Next.js",
-			annotation
-		};
-		case "hono": return {
-			key: "hono",
-			buildType: "bun",
-			displayName: "Hono",
-			annotation
-		};
-		case "bun": return {
-			key: "bun",
-			buildType: "bun",
-			displayName: "Bun",
-			annotation
-		};
-		case "tanstack":
-		case "tanstack-start":
-		case "@tanstack/react-start":
-		case "@tanstack/solid-start": return {
-			key: "tanstack-start",
-			buildType: "tanstack-start",
-			displayName: "TanStack Start",
-			annotation
-		};
-		default: throw frameworkNotDetectedError(void 0, value);
-	}
+	const framework = frameworkFromAlias(value);
+	if (!framework) throw frameworkNotDetectedError(void 0, value);
+	return {
+		key: framework.key,
+		buildType: framework.buildType,
+		displayName: framework.displayName,
+		annotation
+	};
+}
+function assertConfigBackedBuildSettings(buildType) {
+	if (isConfigBackedBuildType(buildType)) return;
+	const displayName = FRAMEWORKS.find((framework) => framework.buildType === buildType)?.displayName ?? buildType;
+	throw new CliError({
+		code: "BUILD_SETTINGS_UNSUPPORTED",
+		domain: "app",
+		summary: `build settings are not supported for ${displayName} apps`,
+		why: `${displayName} deploys run \`${buildType} build\` and package its output automatically.`,
+		fix: "Remove the `build` block from prisma.compute.ts for this app.",
+		exitCode: 2
+	});
 }
 function frameworkNotDetectedError(cwd, requestedFramework) {
-	const supported = "Next.js, Hono, TanStack Start, Bun";
+	const supported = FRAMEWORKS.map((framework) => framework.displayName).join(", ");
 	const directory = cwd ? ` in ${formatDeployDirectory(cwd)}` : "";
 	return new CliError({
 		code: "FRAMEWORK_NOT_DETECTED",
 		domain: "app",
 		summary: requestedFramework ? `Unsupported framework "${requestedFramework}"` : `Cannot detect a supported framework${directory}`,
 		why: `Supported Beta frameworks: ${supported}.`,
-		fix: "Add one of these frameworks as a dependency, pass --framework <nextjs|hono|tanstack-start|bun>, or pass --entry <path> for a Bun app.",
+		fix: `Add one of these frameworks as a dependency, pass --framework <${FRAMEWORKS.map((framework) => framework.key).join("|")}>, or pass --entry <path> for a Bun app.`,
 		exitCode: 2,
 		nextSteps: [
 			"prisma-cli app deploy --framework nextjs",
@@ -1616,14 +2065,72 @@ function frameworkNotDetectedError(cwd, requestedFramework) {
 }
 async function maybeRenderDeploySetupBlock(context, details) {
 	if (context.flags.json || context.flags.quiet) return;
-	const directory = formatDeployDirectory(context.runtime.cwd);
+	const directory = formatAppDirectoryLabel(context.runtime.cwd, details.appDir);
 	const prefix = details.includeDirectory ? `Deploying ${directory} to` : "Deploying to";
 	context.output.stderr.write(`${prefix} ${details.projectName} / ${details.branchName} / ${details.appName}\n\n`);
 }
+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
+		},
+		...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;
 	context.output.stderr.write(`${context.ui.success("✔")} Linked "${directory}" to Project "${projectName}"\nSaved ${localPinPath}\n\n`);
 }
+async function maybePromptForAgentSetup(context, projectDir) {
+	if (!canPrompt(context) || context.flags.yes) return [];
+	if (!shouldOfferPrismaAgentSetup(await readPrismaAgentSetupStatus({
+		cwd: projectDir,
+		stateStore: context.stateStore,
+		signal: context.runtime.signal,
+		requiredSkill: "prisma-compute"
+	}))) return [];
+	if (!await confirmPrompt({
+		input: context.runtime.stdin,
+		output: context.runtime.stderr,
+		signal: context.runtime.signal,
+		message: "Install the Prisma Compute skill for this project?",
+		initialValue: true
+	})) {
+		await context.stateStore.setAgentSetupPromptDismissedAt((/* @__PURE__ */ new Date()).toISOString());
+		return [];
+	}
+	try {
+		await runAgentInstall(context, { skill: [PRISMA_COMPUTE_AGENT_SKILL] }, "install", { cwd: projectDir });
+		if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderSummaryLine(context.ui, "success", "Installed the Prisma Compute skill for this project.")}\n\n`);
+		return [];
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Prisma skill install failed.";
+		if (!context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderSummaryLine(context.ui, "warning", `Skipped Prisma skill install: ${message}`)}\n\n`);
+		return [`The Prisma Compute skill was not installed. Run ${await resolvePrismaCliPackageCommand({
+			cwd: projectDir,
+			signal: context.runtime.signal,
+			args: [
+				...PRISMA_AGENT_INSTALL_ARGS,
+				"--skill",
+				PRISMA_COMPUTE_AGENT_SKILL
+			]
+		})} to try again.`];
+	}
+}
 async function maybeCustomizeDeploySettings(context, options) {
 	if (!options.firstDeploy || context.flags.yes || options.explicitFramework || options.explicitEntrypoint || options.explicitHttpPort || !canPrompt(context)) return {
 		framework: options.framework,
@@ -1636,6 +2143,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 {
@@ -1645,15 +2153,17 @@ 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: DEPLOY_FRAMEWORKS.map((framework) => ({
-			label: frameworkDisplayName(framework),
-			value: framework
+		choices: FRAMEWORKS.map((framework) => ({
+			label: framework.displayName,
+			value: framework.key
 		}))
 	}), "set by you");
 	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
@@ -1691,14 +2201,6 @@ function maybeRenderDeploySettingsPreview(context, options) {
 		value: `HTTP ${options.runtime.port}`
 	}]).join("\n")}\n\n`);
 }
-function frameworkDisplayName(framework) {
-	switch (framework) {
-		case "nextjs": return "Next.js";
-		case "hono": return "Hono";
-		case "tanstack-start": return "TanStack Start";
-		case "bun": return "Bun";
-	}
-}
 function validateDeployHttpPortText(value) {
 	if (!value?.trim()) return;
 	try {
@@ -1712,34 +2214,49 @@ function formatDeployDirectory(cwd) {
 	const basename = path.basename(cwd);
 	return basename ? `./${basename}` : ".";
 }
+function formatAppDirectoryLabel(cwd, appDir) {
+	if (appDir === cwd) return formatDeployDirectory(cwd);
+	const relative = path.relative(cwd, appDir).split(path.sep).join("/");
+	return relative.startsWith("..") ? relative : `./${relative}`;
+}
 async function readCurrentWorkspaceId(context) {
 	const state = await context.stateStore.read();
 	if (state.auth?.workspaceId) return state.auth.workspaceId;
-	return (await readAuthState(context.runtime.env)).workspace?.id ?? null;
+	return (await readAuthState(context.runtime.env, context.runtime.signal)).workspace?.id ?? null;
 }
 function normalizeBuildType(requestedBuildType) {
 	if (!requestedBuildType) return "auto";
 	if (isPreviewBuildType(requestedBuildType)) return requestedBuildType;
-	throw usageError(`Unsupported build type "${requestedBuildType}"`, `Only ${PREVIEW_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 PREVIEW_BUILD_TYPES.includes(value);
+	return APP_BUILD_TYPES.includes(value);
 }
 function getBuildTypeExamples(commandName) {
-	return RESOLVED_PREVIEW_BUILD_TYPES.map((buildType) => {
+	return RESOLVED_APP_BUILD_TYPES.map((buildType) => {
 		return `prisma-cli app ${commandName} --build-type ${buildType}${buildType === "bun" ? " --entry server.ts" : ""}`;
 	});
 }
 function assertSupportedEntrypoint(buildType, entrypoint, commandName) {
-	if (buildType !== "auto" && buildType !== "bun" && entrypoint) {
+	if (buildType !== "auto" && !ENTRYPOINT_BUILD_TYPES.includes(buildType) && entrypoint) {
 		if (commandName === "deploy") throw usageError(`App deploy does not accept --entry with ${formatBuildTypeName(buildType)}`, `${formatBuildTypeName(buildType)} apps derive their runtime entrypoint from build output.`, "Remove --entry, or use --framework bun when you want to target a Bun entrypoint directly.", [`prisma-cli app deploy --framework ${buildType}`, "prisma-cli app deploy --framework bun --entry server.ts"], "app");
 		throw usageError(`App ${commandName} does not accept --entry with --build-type ${buildType}`, `${formatBuildTypeName(buildType)} apps do not use an entrypoint flag in the current preview.`, `Remove --entry, or rerun prisma-cli app ${commandName} with --build-type bun when you want to target a Bun entrypoint directly.`, [`prisma-cli app ${commandName} --build-type ${buildType}`, `prisma-cli app ${commandName} --build-type bun --entry server.ts`], "app");
 	}
 }
-async function requireLocalBuildType(context, buildType, commandName) {
-	const resolvedBuildType = await resolveLocalBuildType(context.runtime.cwd, buildType);
-	if (resolvedBuildType) return resolvedBuildType;
-	throw usageError(`App ${commandName} requires an explicit framework when detection is ambiguous`, "This preview only starts local dev servers for clear Next.js or Bun project shapes.", "Pass --build-type nextjs for a Next.js app, or pass --build-type bun with --entry <path> for a Bun app.", [`prisma-cli app ${commandName} --build-type nextjs`, `prisma-cli app ${commandName} --build-type bun --entry server.ts`], "app");
+/**
+* Resolves the framework for `app run` with the same detection as deploy, so
+* a repo that deploys without flags also runs without flags. Local dev server
+* support is intentionally narrower than deploy build support: only Next.js
+* and Bun/Hono have dev servers in the current preview.
+*/
+async function resolveLocalRunFramework(context, options) {
+	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}`);
+		return frameworkFromUserFacingValue(options.requestedBuildType, "set by --build-type");
+	}
+	const detected = await detectDeployFramework(options.appDir, context.runtime.signal);
+	if (detected && LOCAL_DEV_BUILD_TYPES.includes(detected.buildType)) return detected;
+	throw usageError("App run requires an explicit framework when detection is ambiguous", "This preview only starts local dev servers for clear Next.js or Bun project shapes.", "Pass --build-type nextjs for a Next.js app, or pass --build-type bun with --entry <path> for a Bun app.", ["prisma-cli app run --build-type nextjs", "prisma-cli app run --build-type bun --entry server.ts"], "app");
 }
 function parseLocalPort(requestedPort) {
 	if (!requestedPort) return DEFAULT_LOCAL_DEV_PORT;
@@ -1756,6 +2273,19 @@ 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 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 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");
@@ -1812,7 +2342,7 @@ function appDeployFailedError(error, progress) {
 	}
 	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",
@@ -1838,11 +2368,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,
@@ -1866,6 +2396,18 @@ function localResolutionPinStaleError() {
 		]
 	});
 }
+function localPinReadErrorToDeployError(error) {
+	return matchError(error, {
+		LocalResolutionPinInvalidJsonError: () => localResolutionPinStaleError(),
+		LocalResolutionPinInvalidShapeError: () => localResolutionPinStaleError(),
+		LocalResolutionPinReadAbortedError: (error) => {
+			throw error;
+		},
+		UnhandledException: (error) => {
+			throw error;
+		}
+	});
+}
 function readDeployEnvOverride(context, name) {
 	const value = context.runtime.env[name]?.trim();
 	return value ? value : void 0;
@@ -1944,14 +2486,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 "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({