@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.10-dev.80

package/dist/controllers/app.js

@@ -1,2508 +0,0 @@
-import { formatCommandArgument } from "../command-arguments.js";
-import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../errors.js";
-import { renderCommandHeader } from "../shell/ui.js";
-import { getApiBaseUrl } from "../auth/client.js";
-import { sameWorkspaceId } from "../lib/workspace-id.js";
-import { FileTokenStorage } from "../auth/token-storage.js";
-import { authenticatedManagementApiClient } from "../auth/guard.js";
-import { readAuthState } from "../auth/operations.js";
-import { canPrompt } from "../shell/runtime.js";
-import { writeJsonEvent } from "../shell/output.js";
-import { APP_BUILD_TYPES, APP_BUILD_TYPE_LABELS, RESOLVED_APP_BUILD_TYPES, executeAppBuild } from "../lib/app/build.js";
-import { envVarNames, parseEnvInputs } from "../lib/app/env-vars.js";
-import { DomainApiError, createAppProvider } from "../lib/app/app-provider.js";
-import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
-import { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.js";
-import { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, resolveConfiguredAppBuildSettings, resolveInferredAppBuildSettings } from "../lib/app/build-settings.js";
-import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
-import { computeConfigErrorToCliError, computeFrameworkToBuildType, loadComputeConfig as loadComputeConfig$1, mergeComputeDeployInputs, mergeComputeLocalInputs } from "../lib/app/compute-config.js";
-import { renderDeployOutputRows, renderDeploySettingsPreview } from "../lib/app/deploy-output.js";
-import { describeDeployAllFailure, perAppInputsForDeployAll, planAppDeploy } from "../lib/app/deploy-plan.js";
-import { createDeployProgress, createDeployProgressState, createPromoteProgress } from "../lib/app/deploy-progress.js";
-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 { readLocalGitBranch } from "../lib/git/local-branch.js";
-import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
-import { buildProjectSetupNextActions, inferTargetName, localProjectWorkspaceMismatchError, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
-import { bindProjectToDirectory, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
-import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
-import { maybePromptForAgentSetup } from "./agent-setup.js";
-import { createSelectPromptPort } from "./select-prompt-port.js";
-import { requireAuthenticatedAuthState } from "./auth.js";
-import { listRealWorkspaceProjects } from "./project.js";
-import path from "node:path";
-import { access } from "node:fs/promises";
-import { COMPUTE_CONFIG_FILENAME, COMPUTE_REGIONS, ComputeConfigTargetRequiredError, ENTRYPOINT_BUILD_TYPES, FRAMEWORKS, LOCAL_DEV_BUILD_TYPES, computeTargetAppDir, frameworkByKey, frameworkFromAlias, inferComputeTargetFromCwd, isConfigBackedBuildType, selectComputeDeployTarget } from "@prisma/compute-sdk/config";
-import { SERVICE_TOKEN_ENV_VAR } from "@prisma/cli-engine";
-import open from "open";
-import { detectComputeAppFromDirectory } from "@prisma/compute-sdk/config/directory";
-import { matchError } from "better-result";
-//#region src/controllers/app.ts
-const FRAMEWORK_DEFAULT_HTTP_PORT = 3e3;
-const PRISMA_PROJECT_ID_ENV_VAR = "PRISMA_PROJECT_ID";
-const PRISMA_APP_ID_ENV_VAR = "PRISMA_APP_ID";
-const COMPUTE_REGION_IDS = new Set(COMPUTE_REGIONS);
-const APP_COMMAND_PREFIX = /^app /;
-const TRAILING_DOT = /\.$/;
-const DOMAIN_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
-const CNAME_TO_PHRASE = /\bcname(?:s)?\s+to\b/;
-const PRISMA_BUILD_HOSTNAME = /\b((?:[a-z0-9-]+\.)+prisma\.build)\b/i;
-const WAIT_TIMEOUT_DURATION = /^(\d+)(ms|s|m|h)$/;
-const WAIT_TIMEOUT_UNIT_MULTIPLIER_MS = {
-	ms: 1,
-	s: 1e3,
-	m: 60 * 1e3,
-	h: 3600 * 1e3
-};
-const NEXTJS_MENTION = /next\.?js/i;
-const STANDALONE_OUTPUT_MENTION = /standalone output/i;
-async function runAppBuild(context, options) {
-	const compute = await resolveComputeTargetOrThrow(context, options?.configTarget, "build");
-	const merged = mergeComputeLocalInputs({
-		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 executeAppBuild({
-			appPath: appDir,
-			entrypoint: merged.entrypoint,
-			buildType,
-			buildSettings,
-			signal: context.runtime.signal
-		});
-		return {
-			command: "app.build",
-			result: {
-				directory: artifact.directory,
-				entrypoint: artifact.entrypoint,
-				buildType: actualBuildType
-			},
-			warnings: [],
-			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_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, 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 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} 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,
-		entrypoint: merged.entrypoint
-	});
-	const entrypoint = framework.buildType === "bun" ? await resolveDeployEntrypoint(appDir, framework, merged.entrypoint, context.runtime.signal) : merged.entrypoint;
-	let runResult;
-	try {
-		runResult = await runLocalApp({
-			appPath: appDir,
-			buildType: framework.buildType,
-			entrypoint,
-			port,
-			env: context.runtime.env,
-			signal: context.runtime.signal
-		});
-	} catch (error) {
-		throw runFailedError("Local app run failed", error);
-	}
-	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",
-		result: {
-			framework: runResult.framework,
-			entrypoint: runResult.entrypoint,
-			port: runResult.port,
-			command: runResult.command
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runAppDeploy(context, appName, options) {
-	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({
-		projectRef: options?.projectRef,
-		createProjectName: options?.createProjectName,
-		envProjectId
-	});
-	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
-	});
-	const appDir = await resolveComputeAppDir(context, computeConfig);
-	const projectDir = computeConfig.config?.configDir ?? context.runtime.cwd;
-	const agentSetupWarnings = await maybePromptForAgentSetup(context, projectDir);
-	const localPin = await readDeployLocalPin({
-		projectDir,
-		signal: context.runtime.signal,
-		envProjectId,
-		projectRef: options?.projectRef,
-		createProjectName: options?.createProjectName
-	});
-	const branch = await resolveDeployBranch(context, options?.branchName);
-	if (merged.httpPort) parseDeployHttpPort(merged.httpPort.value);
-	const deployRegion = normalizeDeployRegionInput(merged.region);
-	assertSupportedEntrypointForRequestedDeployShape({
-		requestedFramework: merged.framework?.value,
-		entrypoint: merged.entrypoint?.value
-	});
-	const { provider, target, projectId } = await requireProviderAndDeployProjectContext(context, options?.projectRef, {
-		branch,
-		createProjectName: options?.createProjectName,
-		createProjectRegion: deployRegion?.value,
-		envProjectId,
-		localPin
-	});
-	const localPinResult = await bindDeployProjectDirectory(context, target, projectDir);
-	let framework = await resolveDeployFramework(context, {
-		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(appDir, context.runtime.signal)
-	});
-	await maybeRenderDeploySetupBlock(context, {
-		includeDirectory: !target.localPinAction,
-		appDir,
-		projectName: target.project.name,
-		branchName: target.branch.name,
-		appName: selectedApp.displayName
-	});
-	const customized = await maybeCustomizeDeploySettings(context, {
-		framework,
-		runtime,
-		firstDeploy: selectedApp.firstDeploy,
-		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, 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 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: appDir,
-		projectId,
-		branchName: target.branch.name,
-		appId: selectedApp.appId,
-		appName: selectedApp.appName,
-		region: selectedApp.region,
-		entrypoint,
-		buildType,
-		buildSettings: buildSettingsResolution.settings,
-		portMapping,
-		envVars,
-		skipPromote: noPromote,
-		interaction: void 0,
-		signal: context.runtime.signal,
-		progress: createDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
-	}).catch((error) => {
-		throw appDeployFailedError(error, progressState);
-	});
-	const deployDurationMs = Date.now() - deployStartedAt;
-	await cacheDeployedApp(context, projectId, deployResult);
-	return {
-		command: "app.deploy",
-		result: {
-			workspace: target.workspace,
-			project: target.project,
-			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: computeConfig.config?.relativeConfigPath ?? null,
-					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,
-				regionSource: deployRegion?.annotation ?? null,
-				envVars: envVarNames(envVars)
-			},
-			durationMs: deployDurationMs,
-			localPin: localPinResult
-		},
-		warnings: [
-			...agentSetupWarnings,
-			...legacyWarnings,
-			...branchDatabaseSetup.warnings
-		],
-		nextSteps: deployResult.promoted ? ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`] : [`prisma-cli app promote ${deployResult.deployment.id}`, `prisma-cli app show-deploy ${deployResult.deployment.id}`]
-	};
-}
-async function readDeployLocalPin(options) {
-	if (options.envProjectId || options.projectRef || options.createProjectName) return { kind: "missing" };
-	const readResult = await readLocalResolutionPin(options.projectDir, options.signal);
-	if (readResult.isErr()) throw localPinReadErrorToDeployError(readResult.error);
-	return readResult.value;
-}
-async function bindDeployProjectDirectory(context, target, projectDir) {
-	if (!target.localPinAction) return;
-	const setupResult = await bindProjectToDirectory(context, target.workspace, target.project, target.localPinAction, projectDir);
-	if (setupResult.isErr()) throw projectDirectoryBindingErrorToCliError(setupResult.error);
-	const projectSetup = setupResult.value;
-	maybeRenderProjectLinked(context, projectSetup.directory, projectSetup.project.name, projectSetup.localPin.path);
-	return projectSetup.localPin;
-}
-async function cacheDeployedApp(context, projectId, deployResult) {
-	await context.stateStore.setSelectedApp(projectId, {
-		id: deployResult.app.id,
-		name: deployResult.app.name
-	});
-	const knownLiveDeploymentId = deployResult.promoted ? deployResult.deployment.id : deployResult.app.liveDeploymentId;
-	if (knownLiveDeploymentId) await context.stateStore.setKnownLiveDeployment(projectId, deployResult.app.id, knownLiveDeploymentId);
-}
-async function resolveDeployBuildSettings(options) {
-	const { computeConfig, appDir, buildType, signal } = options;
-	if (computeConfig.target?.build) assertConfigBackedBuildSettings(buildType);
-	if (computeConfig.config && computeConfig.target?.build && isConfigBackedBuildType(buildType)) return resolveConfiguredAppBuildSettings({
-		appPath: appDir,
-		buildType,
-		configured: computeConfig.target.build,
-		configPath: computeConfig.config.configPath,
-		signal
-	});
-	return resolveInferredAppBuildSettings({
-		appPath: appDir,
-		buildType,
-		signal
-	});
-}
-async function runAppListDeploys(context, appName, projectRef, configTarget) {
-	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, { 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);
-	const deployments = applyLiveDeploymentHint(deploymentsResult.deployments, currentLiveDeploymentId).slice().sort((left, right) => right.createdAt.localeCompare(left.createdAt) || right.id.localeCompare(left.id));
-	await context.stateStore.setSelectedApp(projectId, {
-		id: deploymentsResult.app.id,
-		name: deploymentsResult.app.name
-	});
-	return {
-		command: "app.list-deploys",
-		result: {
-			projectId,
-			verboseContext: toAppVerboseContext(target),
-			app: {
-				id: deploymentsResult.app.id,
-				name: deploymentsResult.app.name
-			},
-			deployments
-		},
-		warnings: [],
-		nextSteps: deployments.length > 0 ? [`prisma-cli app show-deploy ${deployments[0]?.id}`] : ["prisma-cli app deploy"]
-	};
-}
-async function runAppShow(context, appName, projectRef, configTarget) {
-	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,
-			recentDeployments: []
-		},
-		warnings: [],
-		nextSteps: ["prisma-cli app deploy"]
-	};
-	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);
-	const deployments = applyLiveDeploymentHint(deploymentsResult.deployments, currentLiveDeploymentId).slice().sort((left, right) => right.createdAt.localeCompare(left.createdAt) || right.id.localeCompare(left.id));
-	const liveDeployment = currentLiveDeploymentId ? deployments.find((deployment) => deployment.id === currentLiveDeploymentId) ?? null : null;
-	await context.stateStore.setSelectedApp(projectId, {
-		id: deploymentsResult.app.id,
-		name: deploymentsResult.app.name
-	});
-	return {
-		command: "app.show",
-		result: {
-			projectId,
-			verboseContext: toAppVerboseContext(target),
-			app: {
-				id: deploymentsResult.app.id,
-				name: deploymentsResult.app.name
-			},
-			liveDeployment,
-			liveUrl: deploymentsResult.app.liveUrl,
-			recentDeployments: deployments.slice(0, 5)
-		},
-		warnings: [],
-		nextSteps: buildAppShowNextSteps(deploymentsResult.app.liveUrl, liveDeployment, deployments)
-	};
-}
-async function runAppShowDeploy(context, deploymentId) {
-	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({
-		code: "DEPLOYMENT_NOT_FOUND",
-		domain: "app",
-		summary: `Deployment "${deploymentId}" not found`,
-		why: "The requested deployment does not exist or is no longer available.",
-		fix: "Run prisma-cli app list-deploys to choose an available deployment id.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli app list-deploys"]
-	});
-	const workspaceId = deployment?.app ? await readCurrentWorkspaceId(context) : null;
-	const rememberedProject = workspaceId ? await context.stateStore.readRememberedProject(workspaceId) : null;
-	const knownLiveDeploymentId = deployment?.app && rememberedProject ? await context.stateStore.readKnownLiveDeployment(rememberedProject.id, deployment.app.id) : null;
-	const liveDeploymentId = deployment.app?.liveDeploymentId || knownLiveDeploymentId;
-	return {
-		command: "app.show-deploy",
-		result: {
-			app: deployment.app ? {
-				id: deployment.app.id,
-				name: deployment.app.name
-			} : null,
-			deployment: {
-				...deployment.deployment,
-				live: liveDeploymentId ? deployment.deployment.id === liveDeploymentId : deployment.deployment.live
-			}
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runAppOpen(context, appNameArg, projectRef, configTarget) {
-	const compute = await resolveComputeManagementContext(context, configTarget, "open");
-	const appName = appNameArg ?? 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, { 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);
-	const deployments = applyLiveDeploymentHint(deploymentsResult.deployments, currentLiveDeploymentId).slice().sort((left, right) => right.createdAt.localeCompare(left.createdAt) || right.id.localeCompare(left.id));
-	const liveDeployment = currentLiveDeploymentId ? deployments.find((deployment) => deployment.id === currentLiveDeploymentId) ?? null : null;
-	await context.stateStore.setSelectedApp(projectId, {
-		id: deploymentsResult.app.id,
-		name: deploymentsResult.app.name
-	});
-	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) {
-		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
-			},
-			url: deploymentsResult.app.liveUrl,
-			opened: shouldOpen
-		},
-		warnings: [],
-		nextSteps: ["prisma-cli app show", `prisma-cli app show-deploy ${liveDeployment.id}`]
-	};
-}
-async function runAppDomainAdd(context, hostname, options) {
-	const normalizedHostname = normalizeDomainHostname(hostname);
-	const target = await resolveAppDomainTarget(context, options, `app domain add ${normalizedHostname}`);
-	const added = await target.provider.addDomain({
-		appId: target.app.id,
-		hostname: normalizedHostname,
-		signal: context.runtime.signal
-	}).catch((error) => {
-		throw domainCommandError("add", error, normalizedHostname);
-	});
-	return {
-		command: "app.domain.add",
-		result: {
-			...target.resultTarget,
-			domain: toAppDomainSummary(added.domain),
-			existing: added.existing
-		},
-		warnings: [],
-		nextSteps: [`prisma-cli app domain wait ${normalizedHostname}`, `prisma-cli app domain show ${normalizedHostname}`]
-	};
-}
-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", context.runtime.signal);
-	const detail = await target.provider.showDomain(domain.id, { signal: context.runtime.signal }).catch((error) => {
-		throw domainCommandError("show", error, normalizedHostname);
-	});
-	return {
-		command: "app.domain.show",
-		result: {
-			...target.resultTarget,
-			domain: toAppDomainSummary(detail)
-		},
-		warnings: [],
-		nextSteps: buildDomainShowNextSteps(detail)
-	};
-}
-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", context.runtime.signal);
-	await confirmDomainRemoval(context, target.resultTarget, normalizedHostname);
-	await target.provider.removeDomain(domain.id, { signal: context.runtime.signal }).catch((error) => {
-		throw domainCommandError("remove", error, normalizedHostname);
-	});
-	return {
-		command: "app.domain.remove",
-		result: {
-			...target.resultTarget,
-			hostname: normalizedHostname,
-			removed: true
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-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", context.runtime.signal);
-	const retried = await target.provider.retryDomain(domain.id, { signal: context.runtime.signal }).catch((error) => {
-		throw domainCommandError("retry", error, normalizedHostname);
-	});
-	return {
-		command: "app.domain.retry",
-		result: {
-			...target.resultTarget,
-			domain: toAppDomainSummary(retried)
-		},
-		warnings: [],
-		nextSteps: [`prisma-cli app domain wait ${normalizedHostname}`]
-	};
-}
-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", context.runtime.signal);
-	if (!context.flags.json && !context.flags.quiet) context.output.stderr.write([
-		`app domain wait -> Waiting for ${normalizedHostname} to become active.`,
-		"",
-		`Workspace: ${target.resultTarget.workspace.name}   Project: ${target.resultTarget.project.name}   Branch: ${target.resultTarget.branch.name}   App: ${target.resultTarget.app.name}`,
-		""
-	].join("\n"));
-	const start = Date.now();
-	const deadline = start + timeoutMs;
-	const pollIntervalMs = readDomainWaitPollIntervalMs(context);
-	let lastStatus = null;
-	let current = domain;
-	while (true) {
-		emitDomainWaitStatus(context, {
-			hostname: normalizedHostname,
-			domainId: current.id,
-			previousStatus: lastStatus,
-			status: current.status,
-			elapsedMs: Date.now() - start
-		});
-		lastStatus = current.status;
-		if (current.status === "active") {
-			if (!context.flags.json && !context.flags.quiet) context.output.stderr.write(`\n${normalizedHostname} is live at https://${normalizedHostname}\n`);
-			return;
-		}
-		if (current.status === "failed") throw new CliError({
-			code: "DOMAIN_VERIFICATION_FAILED",
-			domain: "app",
-			summary: `Custom domain "${normalizedHostname}" failed verification`,
-			why: formatDomainFailureWhy(current),
-			fix: formatDomainFailureFix(current) ?? `Run prisma-cli app domain retry ${normalizedHostname}.`,
-			exitCode: 1,
-			nextSteps: [`prisma-cli app domain show ${normalizedHostname}`, `prisma-cli app domain retry ${normalizedHostname}`]
-		});
-		if (timeoutMs === 0 || Date.now() >= deadline) throw new CliError({
-			code: "DOMAIN_VERIFICATION_TIMEOUT",
-			domain: "app",
-			summary: `Timed out waiting for "${normalizedHostname}" to become active`,
-			why: `The domain is still "${current.status}".`,
-			fix: `Run prisma-cli app domain show ${normalizedHostname} to inspect the current status, or retry wait with a longer --timeout.`,
-			exitCode: 1,
-			nextSteps: [`prisma-cli app domain show ${normalizedHostname}`]
-		});
-		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, appNameArg, deploymentId, projectRef, configTarget) {
-	const compute = await resolveComputeManagementContext(context, configTarget, "logs");
-	const appName = appNameArg ?? 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.",
-			rows: [
-				{
-					key: "project",
-					value: projectId
-				},
-				{
-					key: "app",
-					value: target.app.name
-				},
-				{
-					key: "deployment",
-					value: target.deployment.id
-				}
-			]
-		});
-		if (lines.length > 0) context.output.stderr.write(`${lines.join("\n")}\n`);
-	}
-	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"]);
-	});
-}
-async function resolveExplicitLogDeployment(context, provider, projectId, branchName, appName, deploymentId) {
-	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, { 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);
-		await context.stateStore.setSelectedApp(projectId, {
-			id: deploymentsResult.app.id,
-			name: deploymentsResult.app.name
-		});
-		return {
-			app: deploymentsResult.app,
-			deployment
-		};
-	}
-	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({
-		code: "DEPLOYMENT_NOT_FOUND",
-		domain: "app",
-		summary: `Deployment "${deploymentId}" not found`,
-		why: "The requested deployment does not exist or is no longer available.",
-		fix: "Run prisma-cli app list-deploys to choose an available deployment id.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli app list-deploys"]
-	});
-	if (!shown.app) throw new CliError({
-		code: "DEPLOYMENT_NOT_FOUND",
-		domain: "app",
-		summary: `Deployment "${deploymentId}" is not attached to an app`,
-		why: "The requested deployment could be found, but its app could not be resolved.",
-		fix: "Run prisma-cli app list-deploys to choose an available deployment id for the selected app.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli app list-deploys"]
-	});
-	const resolvedProjectApp = (await listApps(context, provider, projectId, branchName)).find((app) => app.id === shown.app?.id);
-	if (!resolvedProjectApp) throw new CliError({
-		code: "DEPLOYMENT_NOT_FOUND",
-		domain: "app",
-		summary: `Deployment "${deploymentId}" not found in the resolved project`,
-		why: "The requested deployment does not belong to an app in the resolved project.",
-		fix: "Run prisma-cli app list-deploys to choose an available deployment id for this project.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli app list-deploys"]
-	});
-	await context.stateStore.setSelectedApp(projectId, {
-		id: resolvedProjectApp.id,
-		name: resolvedProjectApp.name
-	});
-	return {
-		app: resolvedProjectApp,
-		deployment: shown.deployment
-	};
-}
-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, { 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);
-	const deployments = applyLiveDeploymentHint(deploymentsResult.deployments, currentLiveDeploymentId);
-	const deployment = currentLiveDeploymentId ? deployments.find((candidate) => candidate.id === currentLiveDeploymentId) ?? null : null;
-	await context.stateStore.setSelectedApp(projectId, {
-		id: deploymentsResult.app.id,
-		name: deploymentsResult.app.name
-	});
-	if (!deployment) throw noDeploymentsError("No deployments available to stream logs", `The selected app "${deploymentsResult.app.name}" does not have any deployments yet.`);
-	return {
-		app: deploymentsResult.app,
-		deployment
-	};
-}
-function writeLogRecord(context, record) {
-	if (context.flags.json) {
-		writeJsonEvent(context.output, {
-			type: record.type,
-			command: "app.logs",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			data: record
-		});
-		return;
-	}
-	if (record.type === "log") {
-		context.output.stdout.write(record.text);
-		if (!record.text.endsWith("\n")) context.output.stdout.write("\n");
-	}
-}
-async function runAppPromote(context, deploymentId, appNameArg, projectRef, configTarget) {
-	const compute = await resolveComputeManagementContext(context, configTarget, "promote");
-	const appName = appNameArg ?? 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, { 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);
-	const targetDeployment = requireDeploymentForApp(deploymentsResult.deployments, deploymentId, selectedApp.name);
-	const targetAlreadyLive = currentLiveDeploymentId === targetDeployment.id;
-	await context.stateStore.setSelectedApp(projectId, {
-		id: deploymentsResult.app.id,
-		name: deploymentsResult.app.name
-	});
-	if (!targetAlreadyLive) await provider.promoteDeployment({
-		appId: selectedApp.id,
-		deploymentId: targetDeployment.id,
-		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"]);
-	});
-	await context.stateStore.setKnownLiveDeployment(projectId, deploymentsResult.app.id, targetDeployment.id);
-	return {
-		command: "app.promote",
-		result: {
-			projectId,
-			verboseContext: toAppVerboseContext(target),
-			app: {
-				id: deploymentsResult.app.id,
-				name: deploymentsResult.app.name
-			},
-			deployment: {
-				...targetDeployment,
-				status: "running",
-				live: true
-			}
-		},
-		warnings: targetAlreadyLive ? ["The selected deployment is already live for this app."] : [],
-		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${targetDeployment.id}`]
-	};
-}
-async function runAppRollback(context, appNameArg, deploymentId, projectRef, configTarget) {
-	const compute = await resolveComputeManagementContext(context, configTarget, "rollback");
-	const appName = appNameArg ?? 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, { 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);
-	const currentLiveDeployment = currentLiveDeploymentId ? deploymentsResult.deployments.find((deployment) => deployment.id === currentLiveDeploymentId) ?? null : null;
-	const targetDeployment = deploymentId ? requireDeploymentForApp(deploymentsResult.deployments, deploymentId, selectedApp.name) : resolveRollbackTarget(deploymentsResult.deployments, currentLiveDeploymentId);
-	const targetAlreadyLive = currentLiveDeploymentId === targetDeployment.id;
-	await context.stateStore.setSelectedApp(projectId, {
-		id: deploymentsResult.app.id,
-		name: deploymentsResult.app.name
-	});
-	if (!targetAlreadyLive) await provider.promoteDeployment({
-		appId: selectedApp.id,
-		deploymentId: targetDeployment.id,
-		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"]);
-	});
-	await context.stateStore.setKnownLiveDeployment(projectId, deploymentsResult.app.id, targetDeployment.id);
-	return {
-		command: "app.rollback",
-		result: {
-			projectId,
-			verboseContext: toAppVerboseContext(target),
-			app: {
-				id: deploymentsResult.app.id,
-				name: deploymentsResult.app.name
-			},
-			deployment: {
-				...targetDeployment,
-				status: "running",
-				live: true
-			},
-			previousLiveDeploymentId: currentLiveDeployment?.id ?? null
-		},
-		warnings: targetAlreadyLive ? ["The selected deployment is already live for this app."] : [],
-		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${targetDeployment.id}`]
-	};
-}
-/**
-* Removes an app and every deployment it owns in the resolved branch.
-*
-* @param branchName Scopes the removal to this branch. When omitted the branch
-* is inferred from the local Git branch, falling back to the production branch.
-*/
-async function runAppRemove(context, appNameArg, projectRef, configTarget, branchName) {
-	const compute = await resolveComputeManagementContext(context, configTarget, "remove");
-	const appName = appNameArg ?? compute.configAppName;
-	if (branchName !== void 0 && branchName.trim() === "") throw usageError("The --branch value cannot be empty", "app remove scopes the removal to the given branch; an empty --branch would silently fall back to the inferred (possibly production) branch.", "Pass a non-empty branch name, e.g. --branch <branch>, or omit --branch to use the inferred branch.", ["prisma-cli app remove --app <name> --branch <branch>"], "app");
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, {
-		branch: branchName !== void 0 ? await resolveDeployBranch(context, branchName) : void 0,
-		commandName: "app remove",
-		projectDir: compute.projectDir
-	});
-	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, { 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);
-	return {
-		command: "app.remove",
-		result: {
-			projectId,
-			verboseContext: toAppVerboseContext(target),
-			app: {
-				id: removedApp.id,
-				name: removedApp.name
-			},
-			removed: true
-		},
-		warnings,
-		nextSteps: ["prisma-cli app deploy", "prisma-cli app list-deploys"]
-	};
-}
-async function resolveAppDomainTarget(context, options, commandName = "app domain") {
-	const compute = await resolveComputeManagementContext(context, options?.configTarget, commandName.replace(APP_COMMAND_PREFIX, ""));
-	const branch = resolveDomainBranch(options?.branchName);
-	if (toBranchKind(branch.name) !== "production") throw new CliError({
-		code: "BRANCH_NOT_DEPLOYABLE",
-		domain: "branch",
-		summary: "Custom domains require the production branch",
-		why: `Custom domains on preview branch "${branch.name}" are not supported in Public Beta.`,
-		fix: "Use --branch production, or attach the domain after promoting/deploying to the production branch.",
-		exitCode: 2,
-		nextSteps: ["prisma-cli app domain add <hostname> --branch production"]
-	});
-	const envProjectId = readDeployEnvOverride(context, PRISMA_PROJECT_ID_ENV_VAR);
-	const envAppId = readDeployEnvOverride(context, PRISMA_APP_ID_ENV_VAR);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, options?.projectRef, {
-		branch,
-		commandName,
-		envProjectId,
-		projectDir: compute.projectDir
-	});
-	const selectedApp = await resolveDomainAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), {
-		explicitAppName: options?.appName ?? compute.configAppName,
-		explicitAppId: envAppId
-	});
-	await context.stateStore.setSelectedApp(projectId, {
-		id: selectedApp.id,
-		name: selectedApp.name
-	});
-	return {
-		provider,
-		app: selectedApp,
-		resultTarget: {
-			workspace: target.workspace,
-			project: target.project,
-			branch: toResultBranch(target.branch),
-			app: {
-				id: selectedApp.id,
-				name: selectedApp.name
-			}
-		}
-	};
-}
-function resolveDomainBranch(explicitBranchName) {
-	return {
-		name: explicitBranchName?.trim() || "production",
-		annotation: explicitBranchName ? "set by --branch" : "production default"
-	};
-}
-async function resolveDomainAppSelection(context, projectId, apps, options) {
-	if (options.explicitAppId) {
-		const matched = apps.find((app) => app.id === options.explicitAppId);
-		if (!matched) throw usageError("Selected app does not exist in the resolved production branch", `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 deploy the app on the production branch.`, ["prisma-cli app deploy --branch production"], "app");
-		return matched;
-	}
-	const selectedApp = await resolveExistingAppSelection(context, projectId, apps, options.explicitAppName);
-	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, 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;
-	throw domainNotFoundError(hostname);
-}
-function normalizeDomainHostname(hostname) {
-	const normalized = hostname.trim().replace(TRAILING_DOT, "").toLowerCase();
-	if (!isValidDomainHostname(normalized)) throw new CliError({
-		code: "DOMAIN_HOSTNAME_INVALID",
-		domain: "app",
-		summary: `Invalid custom domain "${hostname}"`,
-		why: "Custom domains must be valid hostnames without protocol, path, wildcard, or port.",
-		fix: "Pass a hostname like shop.acme.com.",
-		exitCode: 2,
-		nextSteps: ["prisma-cli app domain add shop.acme.com"]
-	});
-	return normalized;
-}
-function isValidDomainHostname(hostname) {
-	if (hostname.length < 1 || hostname.length > 253) return false;
-	if (hostname.includes("://") || hostname.includes("/") || hostname.includes(":") || hostname.startsWith("*.")) return false;
-	const labels = hostname.split(".");
-	if (labels.length < 2) return false;
-	return labels.every((label) => DOMAIN_LABEL.test(label));
-}
-function sameDomainHostname(left, right) {
-	return left.trim().replace(TRAILING_DOT, "").toLowerCase() === right.trim().replace(TRAILING_DOT, "").toLowerCase();
-}
-function toAppDomainSummary(domain) {
-	return {
-		id: domain.id,
-		type: domain.type,
-		url: domain.url,
-		hostname: domain.hostname,
-		appId: domain.appId,
-		status: domain.status,
-		foundryStatus: domain.foundryStatus,
-		failureReason: domain.failureReason,
-		failureCategory: domain.failureCategory,
-		certExpiresAt: domain.certExpiresAt,
-		createdAt: domain.createdAt,
-		updatedAt: domain.updatedAt,
-		dnsRecords: toAppDomainDnsRecords(domain)
-	};
-}
-function toAppDomainDnsRecords(domain) {
-	return domain.dnsRecords.map((record) => ({
-		type: record.type,
-		name: record.name,
-		value: record.value,
-		ttl: record.ttl
-	}));
-}
-function buildDomainShowNextSteps(domain) {
-	if (domain.status === "active") return [];
-	if (domain.status === "failed") return [`prisma-cli app domain retry ${domain.hostname}`];
-	return [`prisma-cli app domain wait ${domain.hostname}`];
-}
-async function confirmDomainRemoval(context, target, hostname) {
-	if (context.flags.yes) return;
-	if (!canPrompt(context)) throw new CliError({
-		code: "CONFIRMATION_REQUIRED",
-		domain: "app",
-		summary: "Custom domain removal requires confirmation in the current mode",
-		why: "This command detaches a domain and cannot prompt for confirmation in the current mode.",
-		fix: `Pass --yes to confirm removal of "${hostname}", or rerun prisma-cli app domain remove in an interactive TTY.`,
-		exitCode: 1,
-		nextSteps: [`prisma-cli app domain remove ${hostname} --app ${target.app.name} --yes`]
-	});
-	if (!await confirmPrompt({
-		input: context.runtime.stdin,
-		output: context.output.stderr,
-		signal: context.runtime.signal,
-		message: `Detach ${hostname} from App "${target.app.name}"?`,
-		initialValue: false
-	})) throw usageError("Custom domain removal canceled", "The command was canceled before the domain was detached.", "Rerun the command and confirm removal, or pass --yes.", [`prisma-cli app domain remove ${hostname} --app ${target.app.name} --yes`], "app");
-}
-function domainCommandError(command, error, hostname) {
-	if (error instanceof DomainApiError) {
-		const apiError = command === "add" ? domainAddApiError(hostname, error) : domainLookupApiError(command, hostname, error);
-		if (apiError) return apiError;
-	}
-	return new CliError({
-		code: "DEPLOY_FAILED",
-		domain: "app",
-		summary: `Custom domain ${command} failed`,
-		why: error instanceof Error ? error.message : String(error),
-		fix: "Retry the command, or rerun with --trace for more detailed diagnostics.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps: [`prisma-cli app domain show ${hostname}`]
-	});
-}
-function domainAddApiError(hostname, error) {
-	if ((error.status === 400 || error.status === 422) && isDomainDnsError(error)) return domainDnsNotConfiguredError(hostname, error);
-	if (error.status === 400) return new CliError({
-		code: "DOMAIN_HOSTNAME_INVALID",
-		domain: "app",
-		summary: `Invalid custom domain "${hostname}"`,
-		why: error.message,
-		fix: "Pass a valid hostname like shop.acme.com and make sure DNS can be verified.",
-		debug: formatDebugDetails(error),
-		exitCode: 2,
-		nextSteps: ["prisma-cli app domain add shop.acme.com"]
-	});
-	if (error.status === 429 || isDomainQuotaError(error)) return new CliError({
-		code: "DOMAIN_QUOTA_EXCEEDED",
-		domain: "app",
-		summary: "Custom domain quota exceeded",
-		why: error.message,
-		fix: "Remove an existing custom domain before adding another one.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps: ["prisma-cli app domain remove <hostname>"]
-	});
-	if (error.status === 409) return domainAlreadyRegisteredError(hostname, error);
-	if (error.status === 422) return new CliError({
-		code: "NO_DEPLOYMENTS",
-		domain: "app",
-		summary: "Custom domain requires a live production deployment",
-		why: "The selected production app does not have a promoted version that can receive a custom domain.",
-		fix: "Deploy the app to the production branch, then rerun the domain command.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps: ["prisma-cli app deploy --branch production", `prisma-cli app domain add ${hostname}`]
-	});
-	return null;
-}
-function domainLookupApiError(command, hostname, error) {
-	if (error.status === 404) return domainNotFoundError(hostname);
-	if (command === "retry" && error.status === 409) return new CliError({
-		code: "DOMAIN_RETRY_NOT_ELIGIBLE",
-		domain: "app",
-		summary: `Custom domain "${hostname}" is not eligible for retry`,
-		why: error.message,
-		fix: "Wait for the current verification or TLS step to finish, then rerun retry if the domain fails.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps: [`prisma-cli app domain show ${hostname}`]
-	});
-	return null;
-}
-function isDomainQuotaError(error) {
-	if (error.status !== 409) return false;
-	const text = `${error.message} ${error.hint ?? ""}`.toLowerCase();
-	return text.includes("quota") || text.includes("maximum") || text.includes("limit");
-}
-function domainAlreadyRegisteredError(hostname, error) {
-	return new CliError({
-		code: "DOMAIN_ALREADY_REGISTERED",
-		domain: "app",
-		summary: `Custom domain "${hostname}" is already registered`,
-		why: error.hint ?? error.message,
-		fix: "Select the app that owns this hostname and remove it there, or contact support if you cannot access it.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps: [`Select the owning app and remove ${hostname} there.`, "Contact Prisma support if you cannot access the owning app."]
-	});
-}
-function isDomainDnsError(error) {
-	const text = `${error.message} ${error.hint ?? ""}`.toLowerCase();
-	return text.includes("dns is not configured") || text.includes("dns verification failed") || text.includes("no cname") || text.includes("cname record") || text.includes("no a/aaaa") || CNAME_TO_PHRASE.test(text);
-}
-function domainDnsNotConfiguredError(hostname, error) {
-	const target = extractDomainDnsTarget(error);
-	const record = target ? `CNAME ${hostname} -> ${target}` : null;
-	return new CliError({
-		code: "DOMAIN_DNS_NOT_CONFIGURED",
-		domain: "app",
-		summary: `DNS is not configured for "${hostname}"`,
-		why: error.hint ?? error.message,
-		fix: record ? `Add ${record} at your DNS provider, then rerun the domain command.` : "The platform did not return the required DNS target. Re-run with --trace for the underlying API response details.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps: record ? [`add ${record}`, `prisma-cli app domain add ${hostname}`] : [`prisma-cli app domain add ${hostname} --trace`]
-	});
-}
-function extractDomainDnsTarget(error) {
-	const text = `${error.hint ?? ""} ${error.message}`;
-	return PRISMA_BUILD_HOSTNAME.exec(text)?.[1]?.toLowerCase() ?? null;
-}
-function domainNotFoundError(hostname) {
-	return new CliError({
-		code: "DOMAIN_NOT_FOUND",
-		domain: "app",
-		summary: `Custom domain "${hostname}" not found`,
-		why: "The hostname is not attached to the selected app.",
-		fix: "Check the hostname and selected app, or add the domain first.",
-		exitCode: 1,
-		nextSteps: [`prisma-cli app domain add ${hostname}`]
-	});
-}
-function formatDomainFailureWhy(domain) {
-	if (domain.failureReason) return domain.failureCategory ? `${domain.failureCategory}: ${domain.failureReason}` : domain.failureReason;
-	return "The platform reported a terminal failed state for this custom domain.";
-}
-function parseDomainWaitTimeout(value) {
-	if (!value) return 900 * 1e3;
-	const trimmed = value.trim().toLowerCase();
-	if (trimmed === "0") return 0;
-	const match = WAIT_TIMEOUT_DURATION.exec(trimmed);
-	if (!match) throw usageError(`Invalid timeout "${value}"`, "Timeout must be a duration such as 0, 30s, 15m, or 1h.", "Pass --timeout 15m, or --timeout 0 to poll once.", ["prisma-cli app domain wait shop.acme.com --timeout 15m"], "app");
-	return Number.parseInt(match[1], 10) * (WAIT_TIMEOUT_UNIT_MULTIPLIER_MS[match[2]] ?? 1);
-}
-function readDomainWaitPollIntervalMs(context) {
-	const raw = context.runtime.env.PRISMA_CLI_DOMAIN_WAIT_POLL_MS;
-	if (!raw) return 5e3;
-	const parsed = Number.parseInt(raw, 10);
-	return Number.isInteger(parsed) && parsed > 0 ? parsed : 5e3;
-}
-function emitDomainWaitStatus(context, event) {
-	if (context.flags.json) {
-		writeJsonEvent(context.output, {
-			type: "status",
-			command: "app.domain.wait",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			data: {
-				hostname: event.hostname,
-				domainId: event.domainId,
-				previousStatus: event.previousStatus,
-				status: event.status,
-				elapsedMs: event.elapsedMs
-			}
-		});
-		return;
-	}
-	if (context.flags.quiet) return;
-	if (event.previousStatus === event.status) return;
-	const transition = event.previousStatus ? `${event.previousStatus} -> ${event.status}` : event.status;
-	context.output.stderr.write(`  ${transition} (${formatElapsed(event.elapsedMs)})\n`);
-}
-function formatElapsed(milliseconds) {
-	const seconds = Math.max(Math.floor(milliseconds / 1e3), 0);
-	const minutes = Math.floor(seconds / 60);
-	const remainingSeconds = seconds % 60;
-	return `${minutes}:${String(remainingSeconds).padStart(2, "0")}`;
-}
-async function sleep(milliseconds, signal) {
-	if (milliseconds <= 0) return;
-	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) {
-	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,
-			annotation: `from ${PRISMA_APP_ID_ENV_VAR}`,
-			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 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: options.name,
-		region: options.newAppRegion,
-		displayName: options.name,
-		annotation: options.newAnnotation,
-		firstDeploy: options.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__";
-		const selected = await selectPrompt({
-			input: context.runtime.stdin,
-			output: context.runtime.stderr,
-			message: `Multiple apps are named "${targetName}"`,
-			choices: [
-				...sortApps(matches).map((app) => ({
-					label: `${app.name} (${app.id})`,
-					value: app
-				})),
-				{
-					label: `Create a new app named "${targetName}"`,
-					value: createNew
-				},
-				{
-					label: "Cancel",
-					value: cancel
-				}
-			]
-		});
-		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: newAppRegion,
-			displayName: targetName,
-			annotation: "created from package.json",
-			firstDeploy
-		};
-		assertDeployRegionMatchesExistingApp(selected, requestedRegion);
-		return {
-			appId: selected.id,
-			displayName: selected.name,
-			annotation: "selected by you",
-			firstDeploy
-		};
-	}
-	throw new CliError({
-		code: "APP_AMBIGUOUS",
-		domain: "app",
-		summary: "App resolution is ambiguous",
-		why: `Multiple apps matched "${targetName}".`,
-		fix: "Pass --app <name> to choose the app explicitly.",
-		meta: { candidates: matches.map((app) => ({
-			id: app.id,
-			name: app.name
-		})) },
-		exitCode: 2,
-		nextSteps: ["prisma-cli app deploy --app <name>"]
-	});
-}
-function deployNewAppRegion(configRegion) {
-	return configRegion?.value;
-}
-async function resolveExistingAppSelection(context, projectId, apps, explicitAppName) {
-	if (explicitAppName) {
-		const matched = findAppByName(apps, explicitAppName);
-		if (!matched) throw usageError("Selected app does not exist in the resolved project", `The app "${explicitAppName}" could not be found in resolved project "${projectId}".`, "Pass the name of an existing app, or rerun prisma-cli app list-deploys in a TTY to choose one.", ["prisma-cli app list-deploys"], "app");
-		return matched;
-	}
-	const savedSelection = await context.stateStore.readSelectedApp(projectId);
-	if (savedSelection) {
-		const matched = apps.find((app) => app.id === savedSelection.id) ?? findAppByName(apps, savedSelection.name);
-		if (matched) return matched;
-		if (!canPrompt(context)) throw usageError("Saved app selection is no longer available", "The locally selected app could not be found in the resolved project.", "Pass --app <name>, or rerun prisma-cli app list-deploys in a TTY to choose an available app.", ["prisma-cli app list-deploys"], "app");
-	}
-	if (apps.length === 0) return null;
-	if (!canPrompt(context)) throw usageError("App selection required in non-interactive mode", "This command cannot choose an app in the current mode.", "Pass --app <name>, or rerun prisma-cli app list-deploys in a TTY to choose an app.", ["prisma-cli app list-deploys"], "app");
-	const selectedId = await createSelectPromptPort(context).select({
-		message: "Select an app",
-		choices: sortApps(apps).map((app) => ({
-			label: app.name,
-			value: app.id
-		}))
-	});
-	return apps.find((app) => app.id === selectedId) ?? null;
-}
-async function requireReleaseAppSelection(context, projectId, apps, explicitAppName, commandName) {
-	const selectedApp = await resolveExistingAppSelection(context, projectId, apps, explicitAppName);
-	if (selectedApp) return selectedApp;
-	throw usageError(`App ${commandName} requires an existing app`, "The resolved project does not have an app that can be selected for this command.", `Deploy an app first, or rerun prisma-cli app ${commandName} with --app <name> after an app exists.`, ["prisma-cli app deploy", "prisma-cli app list-deploys"], "app");
-}
-async function confirmAppRemoval(context, app) {
-	if (context.flags.yes) return;
-	if (!canPrompt(context)) throw new CliError({
-		code: "CONFIRMATION_REQUIRED",
-		domain: "app",
-		summary: "App remove requires confirmation in the current mode",
-		why: "This command is destructive and cannot prompt for confirmation in the current mode.",
-		fix: `Pass --yes to confirm removal of "${app.name}", or rerun prisma-cli app remove in an interactive TTY.`,
-		exitCode: 1,
-		nextSteps: [`prisma-cli app remove --app ${app.name} --yes`]
-	});
-	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.`
-	});
-}
-async function cleanupRemovedAppState(context, projectId, appId) {
-	const warnings = [];
-	try {
-		await context.stateStore.clearSelectedApp(projectId, appId);
-	} catch (error) {
-		warnings.push(localStateCleanupWarning("selected app", error));
-	}
-	try {
-		await context.stateStore.clearKnownLiveDeployment(projectId, appId);
-	} catch (error) {
-		warnings.push(localStateCleanupWarning("known live deployment", error));
-	}
-	return warnings;
-}
-function requireDeploymentForApp(deployments, deploymentId, appName) {
-	const deployment = deployments.find((candidate) => candidate.id === deploymentId);
-	if (deployment) return deployment;
-	throw new CliError({
-		code: "DEPLOYMENT_NOT_FOUND",
-		domain: "app",
-		summary: `Deployment "${deploymentId}" not found for app "${appName}"`,
-		why: "The requested deployment does not belong to the resolved app or is no longer available.",
-		fix: "Run prisma-cli app list-deploys to choose an available deployment id for this app.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli app list-deploys"]
-	});
-}
-/**
-* Resolves the app's live deployment from the app pointer, the provider's live
-* flag, then locally cached state.
-*
-* @returns the live deployment id, or null when no authoritative signal exists.
-* Callers must treat null as "not known to be live" rather than assuming the
-* newest deployment is live.
-*/
-async function resolveCurrentLiveDeploymentId(context, projectId, app, deployments) {
-	if (app.liveDeploymentId && deployments.some((deployment) => deployment.id === app.liveDeploymentId)) return app.liveDeploymentId;
-	const providerLiveDeployment = deployments.find((deployment) => deployment.live === true);
-	if (providerLiveDeployment) return providerLiveDeployment.id;
-	const knownLiveDeploymentId = await context.stateStore.readKnownLiveDeployment(projectId, app.id);
-	if (knownLiveDeploymentId && deployments.some((deployment) => deployment.id === knownLiveDeploymentId)) return knownLiveDeploymentId;
-	return null;
-}
-function buildAppShowNextSteps(liveUrl, liveDeployment, deployments) {
-	const nextSteps = [];
-	if (liveUrl) nextSteps.push("prisma-cli app open");
-	if (liveDeployment) nextSteps.push(`prisma-cli app show-deploy ${liveDeployment.id}`);
-	else if (deployments[0]) nextSteps.push(`prisma-cli app show-deploy ${deployments[0].id}`);
-	else nextSteps.push("prisma-cli app deploy");
-	return nextSteps;
-}
-function applyLiveDeploymentHint(deployments, currentLiveDeploymentId) {
-	if (!currentLiveDeploymentId) return deployments.map((deployment) => ({
-		...deployment,
-		live: deployment.live ?? null
-	}));
-	return deployments.map((deployment) => ({
-		...deployment,
-		live: deployment.id === currentLiveDeploymentId
-	}));
-}
-function resolveRollbackTarget(deployments, currentLiveDeploymentId) {
-	const previousDeployment = deployments.find((deployment) => deployment.id !== currentLiveDeploymentId);
-	if (previousDeployment) return previousDeployment;
-	throw new CliError({
-		code: "NO_PREVIOUS_DEPLOYMENT",
-		domain: "app",
-		summary: "No previous deployment available for rollback",
-		why: "The selected app does not have an earlier deployment to switch back to.",
-		fix: "Deploy a second version first, or rerun prisma-cli app rollback --to <deployment-id> for a specific earlier deployment.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli app deploy", "prisma-cli app list-deploys"]
-	});
-}
-async function listApps(context, provider, projectId, branchName) {
-	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",
-			summary: "Project not found",
-			why: `The resolved project "${projectId}" does not exist in the authenticated workspace or is no longer accessible.`,
-			fix: "Pass --project <id-or-name>, or run prisma-cli project show to inspect this directory's binding.",
-			exitCode: 1,
-			nextSteps: ["prisma-cli project show", "prisma-cli project link <id-or-name>"]
-		});
-		throw deployFailedError("Failed to list apps", error, ["prisma-cli project show"]);
-	});
-}
-async function requirePreviewAppProvider(context) {
-	const { provider } = await requirePreviewAppProviderWithClient(context);
-	return provider;
-}
-async function requirePreviewAppProviderWithClient(context) {
-	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
-	if (!client) throw authRequiredError(["prisma-cli auth login"]);
-	return {
-		client,
-		provider: createAppProvider(client, createPreviewLogAuthOptions(context.runtime.env, context.runtime.signal))
-	};
-}
-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, signal);
-	return {
-		baseUrl: getApiBaseUrl(env),
-		getToken: async () => {
-			const tokens = await tokenStorage.getTokens();
-			if (!tokens) throw new Error("Authentication token is no longer available. Run prisma-cli auth login and try again.");
-			return tokens.accessToken;
-		}
-	};
-}
-async function requireProviderAndProjectContext(context, explicitProject, options) {
-	const { client, provider } = await requirePreviewAppProviderWithClient(context);
-	const target = await resolveProjectContext(context, client, explicitProject, options);
-	return {
-		client,
-		provider,
-		target,
-		projectId: target.project.id
-	};
-}
-async function requireProviderAndDeployProjectContext(context, explicitProject, options) {
-	const { client, provider } = await requirePreviewAppProviderWithClient(context);
-	const target = await resolveDeployProjectContext(context, client, provider, explicitProject, options);
-	return {
-		client,
-		provider,
-		target,
-		projectId: target.project.id
-	};
-}
-async function resolveProjectContext(context, client, explicitProject, options) {
-	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
-	if (!workspace) throw workspaceRequiredError();
-	const resolvedResult = await resolveProjectTarget({
-		context,
-		workspace,
-		explicitProject,
-		envProjectId: options?.envProjectId,
-		projectDir: options?.projectDir,
-		listProjects: () => listRealWorkspaceProjects(client, context.runtime.signal),
-		commandName: options?.commandName
-	});
-	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: remoteBranch ?? {
-			id: null,
-			name: requested.name,
-			kind: toBranchKind(requested.name)
-		}
-	};
-}
-async function resolveDeployProjectContext(context, client, provider, explicitProject, options) {
-	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
-	if (!workspace) throw workspaceRequiredError();
-	const branch = options.branch ?? await resolveDeployBranch(context, void 0);
-	const projects = await listRealWorkspaceProjects(client, context.runtime.signal);
-	if (explicitProject) return withRemoteDeployBranch(provider, {
-		workspace,
-		project: toProjectSummary(resolveProjectForSetup(explicitProject, projects, workspace)),
-		resolution: {
-			projectSource: "explicit",
-			targetName: explicitProject,
-			targetNameSource: "explicit"
-		},
-		localPinAction: "linked"
-	}, branch, context.runtime.signal);
-	if (options.createProjectName) return withRemoteDeployBranch(provider, await resolveCreatedDeployProject(provider, options.createProjectName, workspace, context.runtime.signal, options.createProjectRegion), branch, context.runtime.signal);
-	if (options.envProjectId) return withRemoteDeployBranch(provider, resolveEnvDeployProject(options.envProjectId, projects, workspace), branch, context.runtime.signal);
-	const localPin = options.localPin;
-	if (localPin.kind === "present") return withRemoteDeployBranch(provider, resolveLocalPinDeployProject(localPin.pin, projects, workspace), branch, context.runtime.signal);
-	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping && sameWorkspaceId(platformMapping.workspace.id, workspace.id)) return withRemoteDeployBranch(provider, {
-		workspace,
-		project: toProjectSummary(platformMapping),
-		resolution: {
-			projectSource: "platform-mapping",
-			targetName: platformMapping.name,
-			targetNameSource: "platform-mapping"
-		}
-	}, branch, context.runtime.signal);
-	if (canPrompt(context) && !context.flags.yes) return withRemoteDeployBranch(provider, await resolveInteractiveDeployProjectSetup(context, provider, workspace, projects, options.createProjectRegion), branch, context.runtime.signal);
-	throw projectSetupRequiredError(projects, await inferTargetName(context.runtime.cwd, context.runtime.signal));
-}
-async function resolveCreatedDeployProject(provider, createProjectName, workspace, signal, createProjectRegion) {
-	const projectName = createProjectName.trim();
-	if (!projectName) throw projectSetupNameRequiredError("app deploy --create-project");
-	return {
-		workspace,
-		project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace, signal, createProjectRegion)),
-		resolution: {
-			projectSource: "created",
-			targetName: projectName,
-			targetNameSource: "explicit"
-		},
-		localPinAction: "created"
-	};
-}
-function resolveEnvDeployProject(envProjectId, projects, workspace) {
-	const project = projects.find((candidate) => candidate.id === envProjectId);
-	if (!project) throw projectNotFoundError(envProjectId, workspace);
-	return {
-		workspace,
-		project: toProjectSummary(project),
-		resolution: {
-			projectSource: "env",
-			targetName: envProjectId,
-			targetNameSource: "env"
-		}
-	};
-}
-function resolveLocalPinDeployProject(pin, projects, workspace) {
-	if (!sameWorkspaceId(pin.workspaceId, workspace.id)) throw localProjectWorkspaceMismatchError({
-		pinnedWorkspaceId: pin.workspaceId,
-		pinnedProjectId: pin.projectId,
-		activeWorkspace: workspace
-	});
-	const project = projects.find((candidate) => candidate.id === pin.projectId);
-	if (!project) throw localResolutionPinStaleError();
-	return {
-		workspace,
-		project: toProjectSummary(project),
-		resolution: {
-			projectSource: "local-pin",
-			targetName: project.name,
-			targetNameSource: "local-pin"
-		}
-	};
-}
-async function resolveInteractiveDeployProjectSetup(context, provider, workspace, projects, createProjectRegion) {
-	const setup = await promptForProjectSetupChoice({
-		context,
-		projects,
-		createProject: (projectName) => createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal, createProjectRegion),
-		cancel: {
-			why: "Deploy needs a Project before it can continue.",
-			fix: "Choose an existing Project or create a new one, then rerun deploy.",
-			nextSteps: ["prisma-cli app deploy --project <id-or-name>", "prisma-cli app deploy --create-project <name>"]
-		}
-	});
-	return {
-		workspace,
-		project: setup.project,
-		resolution: {
-			projectSource: setup.action === "created" ? "created" : "prompt",
-			targetName: setup.targetName,
-			targetNameSource: setup.targetNameSource
-		},
-		localPinAction: setup.action
-	};
-}
-async function createProjectForDeploySetup(provider, projectName, workspace, signal, region) {
-	const created = await provider.createProject({
-		name: projectName,
-		region,
-		signal
-	}).catch((error) => {
-		throw projectCreateFailedError(error, projectName, workspace, {
-			nextSteps: [
-				"prisma-cli project list",
-				"prisma-cli app deploy --project <id-or-name>",
-				`prisma-cli app deploy --create-project ${formatCommandArgument(projectName)}`
-			],
-			permissionFix: "Choose an existing Project with --project, or grant the token permission to create Projects in this workspace.",
-			fallbackFix: "Choose an existing Project with --project, or retry after addressing the platform error above."
-		});
-	});
-	return {
-		id: created.id,
-		name: created.name,
-		...created.defaultRegion != null ? { defaultRegion: created.defaultRegion } : {},
-		workspace
-	};
-}
-async function withRemoteDeployBranch(provider, target, branch, signal) {
-	const remoteBranch = await provider.resolveBranch(target.project.id, {
-		branchName: branch.name,
-		signal
-	});
-	return {
-		...target,
-		branch: {
-			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,
-		options.createProjectName ? "--create-project" : null,
-		options.envProjectId ? PRISMA_PROJECT_ID_ENV_VAR : null
-	].filter((value) => Boolean(value));
-	if (provided.length <= 1) return;
-	throw usageError("Project selection is ambiguous", `${provided.join(", ")} cannot be used together.`, "Choose exactly one Project source for this deploy.", [
-		"prisma-cli app deploy --project <id-or-name>",
-		"prisma-cli app deploy --create-project <name>",
-		`unset ${PRISMA_PROJECT_ID_ENV_VAR}`
-	], "project");
-}
-async function resolveDeployBranch(context, explicitBranchName) {
-	if (explicitBranchName) return {
-		name: explicitBranchName,
-		annotation: "set by --branch"
-	};
-	const gitBranch = await readLocalGitBranch(context.runtime.cwd, context.runtime.signal);
-	if (gitBranch) return {
-		name: gitBranch,
-		annotation: "from local Git branch"
-	};
-	return {
-		name: "main",
-		annotation: "default"
-	};
-}
-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;
-	}
-	if (!config) {
-		if (configTarget) throw usageError(`App target "${configTarget}" requires a compute config file`, `No ${COMPUTE_CONFIG_FILENAME} exists in the current directory, so there are no named app targets.`, `Create ${COMPUTE_CONFIG_FILENAME} with an apps entry named "${configTarget}", or rerun without the target argument.`, [`prisma-cli app ${commandName}`], "app");
-		return {
-			config: null,
-			target: null
-		};
-	}
-	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
-	};
-}
-/**
-* 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(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, options.requestedFrameworkAnnotation ?? "set by --framework");
-	if (options.entrypoint) return {
-		key: "bun",
-		buildType: "bun",
-		displayName: "Bun",
-		annotation: options.entrypointAnnotation ?? "set by --entry"
-	};
-	const detected = await detectDeployFramework(options.appDir, context.runtime.signal);
-	if (detected) return detected;
-	throw frameworkNotDetectedError(options.appDir);
-}
-function resolveDeployRuntime(requestedHttpPort, requestedHttpPortAnnotation, framework) {
-	if (requestedHttpPort) return {
-		port: parseDeployHttpPort(requestedHttpPort),
-		annotation: requestedHttpPortAnnotation ?? "set by --http-port"
-	};
-	return {
-		port: FRAMEWORK_DEFAULT_HTTP_PORT,
-		annotation: `${framework.displayName} default`
-	};
-}
-function assertSupportedEntrypointForRequestedDeployShape(options) {
-	if (!options.requestedFramework) return;
-	assertSupportedEntrypoint(frameworkFromUserFacingValue(options.requestedFramework, "set by --framework").buildType, options.entrypoint, "deploy");
-}
-async function resolveDeployEntrypoint(cwd, framework, explicitEntrypoint, signal) {
-	if (explicitEntrypoint || framework.buildType !== "bun") return explicitEntrypoint;
-	const packageEntrypoint = readBunPackageEntrypoint(await readBunPackageJson(cwd, signal));
-	if (packageEntrypoint) return packageEntrypoint;
-	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, signal) {
-	const detected = await detectComputeAppFromDirectory({
-		appPath: cwd,
-		signal
-	});
-	if (!detected) return null;
-	let annotation = "detected from package.json";
-	if (detected.configFile?.standaloneOutput) annotation = "standalone output detected";
-	else if (detected.configFile) annotation = `detected from ${path.basename(detected.configFile.path)}`;
-	return {
-		key: detected.framework,
-		buildType: detected.buildType,
-		displayName: detected.frameworkName,
-		annotation
-	};
-}
-function frameworkFromUserFacingValue(value, annotation) {
-	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 = 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 <${FRAMEWORKS.map((framework) => framework.key).join("|")}>, or pass --entry <path> for a Bun app.`,
-		exitCode: 2,
-		nextSteps: [
-			"prisma-cli app deploy --framework nextjs",
-			"prisma-cli app deploy --framework hono",
-			"prisma-cli app deploy --framework tanstack-start",
-			"prisma-cli app deploy --framework bun --entry server.ts",
-			"prisma-cli app deploy --entry server.ts"
-		]
-	});
-}
-async function maybeRenderDeploySetupBlock(context, details) {
-	if (context.flags.json || context.flags.quiet) return;
-	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 maybeCustomizeDeploySettings(context, options) {
-	if (!options.firstDeploy || context.flags.yes || options.explicitFramework || options.explicitEntrypoint || options.explicitHttpPort || !canPrompt(context)) return {
-		framework: options.framework,
-		runtime: options.runtime
-	};
-	maybeRenderDeploySettingsPreview(context, {
-		framework: options.framework,
-		runtime: options.runtime
-	});
-	if (!await confirmPrompt({
-		input: context.runtime.stdin,
-		output: context.runtime.stderr,
-		signal: context.runtime.signal,
-		message: "Customize build settings?",
-		initialValue: false
-	})) return {
-		framework: options.framework,
-		runtime: options.runtime
-	};
-	const framework = frameworkFromUserFacingValue(await selectPrompt({
-		input: context.runtime.stdin,
-		output: context.runtime.stderr,
-		signal: context.runtime.signal,
-		message: `Framework (${options.framework.displayName})`,
-		choices: FRAMEWORKS.map((framework) => ({
-			label: framework.displayName,
-			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
-	});
-	const runtime = {
-		port: requestedPort.trim() ? parseDeployHttpPort(requestedPort) : options.runtime.port,
-		annotation: "set by you"
-	};
-	const changedRows = [framework.key !== options.framework.key ? {
-		label: "Framework",
-		value: framework.displayName,
-		annotation: framework.annotation
-	} : null, runtime.port !== options.runtime.port ? {
-		label: "Runtime",
-		value: `HTTP ${runtime.port}`,
-		annotation: runtime.annotation
-	} : null].filter((row) => Boolean(row));
-	if (changedRows.length > 0 && !context.flags.quiet && !context.flags.json) context.output.stderr.write(`${renderDeployOutputRows(context.ui, changedRows.map((row) => ({
-		label: row.label,
-		value: row.value,
-		origin: row.annotation
-	}))).join("\n")}\n\n`);
-	return {
-		framework,
-		runtime
-	};
-}
-function maybeRenderDeploySettingsPreview(context, options) {
-	if (context.flags.quiet || context.flags.json) return;
-	context.output.stderr.write(`Detected ${options.framework.displayName}\n${renderDeploySettingsPreview(context.ui, [{
-		key: "framework",
-		value: options.framework.displayName
-	}, {
-		key: "runtime",
-		value: `HTTP ${options.runtime.port}`
-	}]).join("\n")}\n\n`);
-}
-function validateDeployHttpPortText(value) {
-	if (!value?.trim()) return;
-	try {
-		parseDeployHttpPort(value);
-		return;
-	} catch (error) {
-		return error instanceof CliError ? error.summary : String(error);
-	}
-}
-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, 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 ${APP_BUILD_TYPE_LABELS} are supported in the current preview.`, "Pass a supported --build-type value.", getBuildTypeExamples("build"), "app");
-}
-function isPreviewBuildType(value) {
-	return APP_BUILD_TYPES.includes(value);
-}
-function getBuildTypeExamples(commandName) {
-	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" && !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");
-	}
-}
-/**
-* 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 (options.requestedBuildType === "auto" && options.entrypoint) return frameworkFromUserFacingValue("bun", "set by --entry");
-	if (LOCAL_DEV_BUILD_TYPES.includes(options.requestedBuildType)) {
-		if (options.configFramework && computeFrameworkToBuildType(options.configFramework) === options.requestedBuildType) return frameworkFromUserFacingValue(options.configFramework, `set by ${COMPUTE_CONFIG_FILENAME}`);
-		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;
-	const port = Number.parseInt(requestedPort, 10);
-	if (!Number.isInteger(port) || port <= 0 || port > 65535) throw usageError(`Invalid port "${requestedPort}"`, "Port must be an integer between 1 and 65535.", "Pass --port <number> with a valid local port value.", ["prisma-cli app run --port 3000"], "app");
-	return port;
-}
-function parseDeployPortMapping(requestedPort) {
-	if (!requestedPort) return;
-	return { http: parseDeployHttpPort(requestedPort) };
-}
-function parseDeployHttpPort(requestedPort) {
-	const port = Number.parseInt(requestedPort, 10);
-	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 deployFailedError(summary, error, nextSteps) {
-	return new CliError({
-		code: "DEPLOY_FAILED",
-		domain: "app",
-		summary,
-		why: error instanceof Error ? error.message : String(error),
-		fix: "Retry the command, or rerun with --trace for more detailed diagnostics.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps
-	});
-}
-function describeStalledDeployPhase(progress) {
-	if (progress.uploadCompleted) return "The artifact uploaded, but the deployment did not start.";
-	if (progress.archiveReady) return "The app built locally, but the artifact did not finish uploading.";
-	return "The app built locally, but the deployment did not start.";
-}
-function localBuildFailedError(why, debug) {
-	const standaloneOutputFailure = isNextStandaloneOutputFailure(why);
-	const fix = standaloneOutputFailure ? "Add output: \"standalone\" to next.config.*, then rerun deploy." : "Inspect the build output above, fix the error, and redeploy.";
-	const nextSteps = standaloneOutputFailure ? ["Add output: \"standalone\" to next.config.*, then rerun prisma-cli app deploy"] : [];
-	const nextActions = standaloneOutputFailure ? [{
-		kind: "edit-file",
-		journey: "deploy-app",
-		label: "Add Next.js standalone output",
-		reason: "Prisma Compute needs Next.js standalone output to build a deployable server artifact."
-	}, {
-		kind: "run-command",
-		journey: "deploy-app",
-		label: "Rerun deploy",
-		command: "prisma-cli app deploy"
-	}] : [];
-	return new CliError({
-		code: "BUILD_FAILED",
-		domain: "app",
-		summary: "Build failed locally.",
-		why,
-		fix,
-		debug,
-		meta: { phase: "build" },
-		humanLines: [
-			"Build failed locally.",
-			"",
-			`✗ Built       ${why}`,
-			"",
-			`Fix: ${fix}`
-		],
-		exitCode: 1,
-		nextSteps,
-		nextActions
-	});
-}
-function appDeployFailedError(error, progress) {
-	const why = error instanceof Error ? error.message : String(error);
-	const debug = formatDebugDetails(error);
-	if (progress.buildStarted && !progress.buildCompleted) return localBuildFailedError(why, debug);
-	if (!progress.buildStarted) return deployFailedError("App deploy failed", error, ["prisma-cli app deploy"]);
-	const phaseHeadline = progress.containerLive ? "The deployment started, but the app is not ready yet." : "Deploy failed after the build completed.";
-	const recoveryLines = progress.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",
-		progress.deploymentUrl
-	] : [];
-	const humanLines = progress.containerLive ? [
-		phaseHeadline,
-		"",
-		"This is usually a missing env var, a failed DB connection,",
-		"or a crash on startup.",
-		"",
-		...recoveryLines,
-		...urlLines
-	] : [
-		phaseHeadline,
-		"",
-		describeStalledDeployPhase(progress),
-		"",
-		...recoveryLines
-	];
-	return new CliError({
-		code: "DEPLOY_FAILED",
-		domain: "app",
-		summary: phaseHeadline,
-		why,
-		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.deploymentId,
-			deploymentUrl: progress.deploymentUrl
-		},
-		humanLines,
-		exitCode: 1,
-		nextSteps: []
-	});
-}
-function localResolutionPinStaleError() {
-	return new CliError({
-		code: "LOCAL_STATE_STALE",
-		domain: "project",
-		summary: "Local project binding is stale",
-		why: `The target recorded in ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} is no longer available in the selected workspace.`,
-		fix: `Delete ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}, then choose a Project explicitly.`,
-		meta: { pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH },
-		exitCode: 1,
-		nextSteps: [
-			"prisma-cli project list",
-			"prisma-cli project link <id-or-name>",
-			"prisma-cli app deploy --project <id-or-name>"
-		]
-	});
-}
-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;
-}
-function projectSetupRequiredError(projects, suggestedName) {
-	const createCommand = `prisma-cli app deploy --create-project ${formatCommandArgument(suggestedName.name)}`;
-	return new CliError({
-		code: "PROJECT_SETUP_REQUIRED",
-		domain: "project",
-		summary: "Choose a Project before deploying this directory",
-		why: "This directory is not linked to a Prisma Project, and deploy will not choose or create one implicitly.",
-		fix: "Choose an existing Project with --project, create one with --create-project, or rerun interactively to pick from the setup list.",
-		meta: {
-			candidates: sortProjects(projects).map((project) => ({
-				id: project.id,
-				name: project.name
-			})),
-			suggestedProjectName: suggestedName.name,
-			suggestedProjectNameSource: suggestedName.source,
-			recoveryCommands: ["prisma-cli app deploy --project <id-or-name>", createCommand]
-		},
-		exitCode: 1,
-		nextSteps: [
-			"prisma-cli project list",
-			"prisma-cli app deploy --project <id-or-name>",
-			createCommand
-		],
-		nextActions: buildProjectSetupNextActions({
-			commandName: "app deploy",
-			createCommand,
-			reason: "This directory is not linked to a Prisma Project. Ask the user which Project to use before deploying; package and directory names are setup suggestions only."
-		})
-	});
-}
-function isNextStandaloneOutputFailure(message) {
-	return NEXTJS_MENTION.test(message) && STANDALONE_OUTPUT_MENTION.test(message);
-}
-function noDeploymentsError(summary, why) {
-	return new CliError({
-		code: "NO_DEPLOYMENTS",
-		domain: "app",
-		summary,
-		why,
-		fix: "Run prisma-cli app deploy first, or use prisma-cli app show to inspect the current app state.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli app deploy", "prisma-cli app show"]
-	});
-}
-function buildFailedError(summary, error) {
-	return new CliError({
-		code: "BUILD_FAILED",
-		domain: "app",
-		summary,
-		why: error instanceof Error ? error.message : String(error),
-		fix: "Inspect the framework output, fix the build issue, and rerun prisma-cli app build.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps: ["prisma-cli app build", "prisma-cli app deploy"]
-	});
-}
-function runFailedError(summary, error, exitCode = 1) {
-	return new CliError({
-		code: "RUN_FAILED",
-		domain: "app",
-		summary,
-		why: error instanceof Error ? error.message : String(error),
-		fix: "Inspect the framework output above, fix the issue, and rerun prisma-cli app run.",
-		exitCode,
-		nextSteps: ["prisma-cli app run"]
-	});
-}
-function formatFrameworkName(framework) {
-	return framework === "nextjs" ? "Next.js" : "Bun";
-}
-function isAutoBuildDetectionError(error) {
-	return error instanceof Error && error.message.startsWith("Entrypoint is required.");
-}
-function formatBuildTypeName(buildType) {
-	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({
-		code: "REMOVE_FAILED",
-		domain: "app",
-		summary,
-		why: error instanceof Error ? error.message : String(error),
-		fix: "Retry the command, or rerun with --trace for more detailed diagnostics.",
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps
-	});
-}
-function localStateCleanupWarning(target, error) {
-	return `The app was removed remotely, but the local ${target} state could not be cleared: ${error instanceof Error ? error.message : String(error)}`;
-}
-function formatDebugDetails(error) {
-	if (error instanceof Error) return error.stack ?? error.message;
-	return typeof error === "string" ? error : null;
-}
-function isMissingProjectError(error) {
-	return error instanceof Error && error.message === "Resource Not Found";
-}
-function findAppByName(apps, name) {
-	return apps.find((app) => app.name === name);
-}
-function findAppsByName(apps, name) {
-	return apps.filter((app) => app.name === name);
-}
-function sortApps(apps) {
-	return apps.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
-}
-function toOptionalEnvVars(envVars) {
-	return Object.keys(envVars).length > 0 ? envVars : void 0;
-}
-//#endregion
-export { detectDeployFramework, runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy };