@prisma/cli 3.0.0-beta.0 → 3.0.0-beta.10

package/dist/controllers/app.js

@@ -7,16 +7,23 @@ import { canPrompt } from "../shell/runtime.js";
 import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { readAuthState } from "../lib/auth/auth-ops.js";
-import { parseEnvAssignments } from "../lib/app/env-vars.js";
-import { renderDeployOutputRows } from "../lib/app/deploy-output.js";
-import { readBunPackageJson } from "../lib/app/bun-project.js";
+import { envVarNames, parseEnvInputs } from "../lib/app/env-vars.js";
+import { renderDeployOutputRows, renderDeploySettingsPreview } from "../lib/app/deploy-output.js";
+import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
 import { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp } from "../lib/app/local-dev.js";
-import { inferTargetName, projectNotFoundError, resolveProjectTarget } from "../lib/project/resolution.js";
-import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, readLocalResolutionPin, writeLocalResolutionPin } from "../lib/project/local-pin.js";
+import { formatCommandArgument } from "../shell/command-arguments.js";
+import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
+import { buildProjectSetupNextActions, inferTargetName, projectNotFoundError, 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 { readLocalGitBranch } from "../lib/git/local-branch.js";
+import { resolveOrCreatePreviewBuildSettings } from "../lib/app/preview-build-settings.js";
 import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild } from "../lib/app/preview-build.js";
 import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
+import { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.js";
 import { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress } from "../lib/app/preview-progress.js";
 import { PreviewDomainApiError, createPreviewAppProvider } from "../lib/app/preview-provider.js";
+import { enforceProductionDeployGate } from "../lib/app/production-deploy-gate.js";
 import { formatDomainFailureFix } from "../lib/app/domain-guidance.js";
 import { createSelectPromptPort } from "./select-prompt-port.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
@@ -24,12 +31,15 @@ import { listRealWorkspaceProjects } from "./project.js";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import open from "open";
+import { Result, matchError } from "better-result";
 //#region src/controllers/app.ts
 const DEPLOY_FRAMEWORKS = [
 	"nextjs",
 	"hono",
-	"tanstack-start"
+	"tanstack-start",
+	"bun"
 ];
+const TANSTACK_START_PACKAGES = ["@tanstack/react-start", "@tanstack/solid-start"];
 const FRAMEWORK_DEFAULT_HTTP_PORT = 3e3;
 const PRISMA_PROJECT_ID_ENV_VAR = "PRISMA_PROJECT_ID";
 const PRISMA_APP_ID_ENV_VAR = "PRISMA_APP_ID";
@@ -43,7 +53,8 @@ async function runAppBuild(context, entrypoint, requestedBuildType) {
 		const { artifact, buildType: actualBuildType } = await executePreviewBuild({
 			appPath: context.runtime.cwd,
 			entrypoint,
-			buildType
+			buildType,
+			signal: context.runtime.signal
 		});
 		return {
 			command: "app.build",
@@ -73,12 +84,13 @@ async function runAppRun(context, entrypoint, requestedBuildType, requestedPort)
 			buildType: resolvedBuildType,
 			entrypoint,
 			port,
-			env: context.runtime.env
+			env: context.runtime.env,
+			signal: context.runtime.signal
 		});
 	} catch (error) {
 		throw runFailedError("Local app run failed", error);
 	}
-	if (runResult.signal === "SIGINT" || runResult.signal === "SIGTERM") process.exitCode = runResult.signal === "SIGINT" ? 130 : 143;
+	if (runResult.signal === "SIGINT" || runResult.signal === "SIGTERM") throw new DOMException("Command canceled", "AbortError");
 	else if (runResult.exitCode !== 0) throw runFailedError("Local app run failed", `The ${formatFrameworkName(runResult.framework)} process exited with code ${runResult.exitCode}.`, runResult.exitCode);
 	return {
 		command: "app.run",
@@ -96,67 +108,84 @@ async function runAppDeploy(context, appName, options) {
 	ensurePreviewAppMode(context);
 	const envProjectId = readDeployEnvOverride(context, PRISMA_PROJECT_ID_ENV_VAR);
 	const envAppId = readDeployEnvOverride(context, PRISMA_APP_ID_ENV_VAR);
-	const skipLocalPin = Boolean(envProjectId || envAppId);
-	const localPin = skipLocalPin ? { kind: "missing" } : await readLocalResolutionPin(context.runtime.cwd);
-	if (!skipLocalPin && localPin.kind === "invalid") throw localResolutionPinStaleError();
-	const explicitBuildType = Boolean(options?.buildType && options.buildType !== "auto");
+	assertExclusiveDeployProjectInputs({
+		projectRef: options?.projectRef,
+		createProjectName: options?.createProjectName,
+		envProjectId
+	});
+	const localPinReadResult = Boolean(envProjectId || options?.projectRef || options?.createProjectName) ? Result.ok({ kind: "missing" }) : await readLocalResolutionPin(context.runtime.cwd, context.runtime.signal);
+	if (localPinReadResult.isErr()) throw localPinReadErrorToDeployError(localPinReadResult.error);
+	const localPin = localPinReadResult.value;
 	const branch = await resolveDeployBranch(context, options?.branchName);
 	if (options?.httpPort) parseDeployHttpPort(options.httpPort);
-	let framework = await resolveDeployFramework(context, {
+	assertSupportedEntrypointForRequestedDeployShape({
 		requestedFramework: options?.framework,
-		requestedBuildType: options?.buildType,
-		explicitBuildType
+		entrypoint: options?.entrypoint
 	});
-	let runtime = resolveDeployRuntime(options?.httpPort, framework);
-	assertSupportedEntrypoint(framework.buildType, options?.entrypoint, "deploy");
-	const envVars = toOptionalEnvVars(parseEnvAssignments(options?.envAssignments, { commandName: "deploy" }));
-	const firstDeploy = !skipLocalPin && localPin.kind === "missing";
 	const { provider, target, projectId } = await requireProviderAndDeployProjectContext(context, options?.projectRef, {
-		allowCreate: true,
 		branch,
+		createProjectName: options?.createProjectName,
 		envProjectId,
 		localPin
 	});
+	let localPinResult;
+	if (target.localPinAction) {
+		const setupResult = await bindProjectToDirectory(context, target.workspace, target.project, target.localPinAction);
+		if (setupResult.isErr()) throw projectDirectoryBindingErrorToCliError(setupResult.error);
+		const projectSetup = setupResult.value;
+		localPinResult = projectSetup.localPin;
+		maybeRenderProjectLinked(context, projectSetup.directory, projectSetup.project.name, projectSetup.localPin.path);
+	}
+	let framework = await resolveDeployFramework(context, {
+		requestedFramework: options?.framework,
+		entrypoint: options?.entrypoint
+	});
+	let runtime = resolveDeployRuntime(options?.httpPort, framework);
+	assertSupportedEntrypoint(framework.buildType, options?.entrypoint, "deploy");
+	const envVars = toOptionalEnvVars(await parseEnvInputs(context.runtime.cwd, options?.envAssignments, { commandName: "deploy" }));
 	const selectedApp = await resolveDeployAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), {
 		explicitAppName: appName,
 		explicitAppId: envAppId,
-		firstDeploy,
-		inferName: () => inferTargetName(context.runtime.cwd)
+		firstDeploy: Boolean(target.localPinAction),
+		inferName: () => inferTargetName(context.runtime.cwd, context.runtime.signal)
 	});
 	await maybeRenderDeploySetupBlock(context, {
-		firstDeploy: selectedApp.firstDeploy,
-		workspaceName: target.workspace.name,
+		includeDirectory: !target.localPinAction,
 		projectName: target.project.name,
-		projectAnnotation: annotationForProjectResolution(target.resolution),
 		branchName: target.branch.name,
-		branchAnnotation: branch.annotation,
-		appName: selectedApp.displayName,
-		appAnnotation: selectedApp.annotation,
-		framework,
-		runtime
+		appName: selectedApp.displayName
 	});
 	const customized = await maybeCustomizeDeploySettings(context, {
 		framework,
 		runtime,
 		firstDeploy: selectedApp.firstDeploy,
 		explicitFramework: Boolean(options?.framework),
-		explicitBuildType,
+		explicitEntrypoint: Boolean(options?.entrypoint),
 		explicitHttpPort: Boolean(options?.httpPort)
 	});
 	framework = customized.framework;
 	runtime = customized.runtime;
+	const productionDeployGate = await enforceProductionDeployGate(context, provider, {
+		appId: selectedApp.appId,
+		appName: selectedApp.displayName,
+		branchKind: target.branch.kind,
+		prod: options?.prod === true
+	});
 	const buildType = framework.buildType;
 	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
+	const entrypoint = await resolveDeployEntrypoint(context.runtime.cwd, framework, options?.entrypoint, context.runtime.signal);
+	const buildSettingsResolution = await resolveOrCreatePreviewBuildSettings({
+		appPath: context.runtime.cwd,
+		buildType,
+		signal: context.runtime.signal
+	});
+	maybeRenderDeployBuildSettings(context, buildSettingsResolution);
 	const portMapping = parseDeployPortMapping(String(runtime.port));
-	const shouldWriteLocalPin = firstDeploy && !skipLocalPin;
-	if (shouldWriteLocalPin) {
-		await writeLocalResolutionPin(context.runtime.cwd, {
-			workspaceId: target.workspace.id,
-			projectId: target.project.id
-		});
-		await ensureLocalResolutionPinGitignore(context.runtime.cwd);
-		maybeRenderLocalPinBound(context, target.project.name);
-	}
+	const branchDatabaseSetup = await maybeSetupBranchDatabase(context, provider, projectId, toBranchDatabaseDeployBranch(target.branch), {
+		db: options?.db,
+		providedEnvVars: envVars,
+		firstProductionDeploy: productionDeployGate.firstProductionDeploy
+	});
 	const progressState = createPreviewDeployProgressState();
 	const deployStartedAt = Date.now();
 	const deployResult = await provider.deployApp({
@@ -166,11 +195,13 @@ async function runAppDeploy(context, appName, options) {
 		appId: selectedApp.appId,
 		appName: selectedApp.appName,
 		region: selectedApp.region,
-		entrypoint: options?.entrypoint,
+		entrypoint,
 		buildType,
+		buildSettings: buildSettingsResolution.settings,
 		portMapping,
 		envVars,
 		interaction: void 0,
+		signal: context.runtime.signal,
 		progress: createPreviewDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
 	}).catch((error) => {
 		throw appDeployFailedError(error, progressState);
@@ -186,38 +217,61 @@ async function runAppDeploy(context, appName, options) {
 		result: {
 			workspace: target.workspace,
 			project: target.project,
-			branch: target.branch,
+			branch: toResultBranch(target.branch),
 			resolution: target.resolution,
+			branchDatabase: branchDatabaseSetup.result,
 			app: {
 				id: deployResult.app.id,
 				name: deployResult.app.name
 			},
 			deployment: deployResult.deployment,
+			deploySettings: {
+				config: {
+					path: buildSettingsResolution.relativeConfigPath,
+					status: buildSettingsResolution.status
+				},
+				buildCommand: {
+					value: buildSettingsResolution.settings.buildCommand,
+					source: buildSettingsResolution.settings.buildCommandSource
+				},
+				outputDirectory: {
+					value: buildSettingsResolution.settings.outputDirectory,
+					source: buildSettingsResolution.settings.outputDirectorySource
+				},
+				framework: {
+					key: framework.key,
+					buildType,
+					name: framework.displayName,
+					source: framework.annotation
+				},
+				entrypoint: entrypoint ?? null,
+				httpPort: runtime.port,
+				region: selectedApp.region ?? null,
+				envVars: envVarNames(envVars)
+			},
 			durationMs: deployDurationMs,
-			localPin: shouldWriteLocalPin ? {
-				path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
-				written: true
-			} : void 0
+			localPin: localPinResult
 		},
-		warnings: [],
+		warnings: branchDatabaseSetup.warnings,
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`]
 	};
 }
 async function runAppListDeploys(context, appName, projectRef) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef);
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app list-deploys" });
 	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName);
 	if (!selectedApp) return {
 		command: "app.list-deploys",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: null,
 			deployments: []
 		},
 		warnings: [],
 		nextSteps: ["prisma-cli app deploy"]
 	};
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app deploy"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -230,6 +284,7 @@ async function runAppListDeploys(context, appName, projectRef) {
 		command: "app.list-deploys",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -242,12 +297,13 @@ async function runAppListDeploys(context, appName, projectRef) {
 }
 async function runAppShow(context, appName, projectRef) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef);
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app show" });
 	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName);
 	if (!selectedApp) return {
 		command: "app.show",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: null,
 			liveDeployment: null,
 			liveUrl: null,
@@ -256,7 +312,7 @@ async function runAppShow(context, appName, projectRef) {
 		warnings: [],
 		nextSteps: ["prisma-cli app deploy"]
 	};
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to inspect app", error, ["prisma-cli app list-deploys"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -270,6 +326,7 @@ async function runAppShow(context, appName, projectRef) {
 		command: "app.show",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -284,7 +341,7 @@ async function runAppShow(context, appName, projectRef) {
 }
 async function runAppShowDeploy(context, deploymentId) {
 	ensurePreviewAppMode(context);
-	const deployment = await (await requirePreviewAppProvider(context)).showDeployment(deploymentId).catch((error) => {
+	const deployment = await (await requirePreviewAppProvider(context)).showDeployment(deploymentId, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to show deployment", error, ["prisma-cli app list-deploys"]);
 	});
 	if (!deployment) throw new CliError({
@@ -318,10 +375,10 @@ async function runAppShowDeploy(context, deploymentId) {
 }
 async function runAppOpen(context, appName, projectRef) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef);
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app open" });
 	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName);
 	if (!selectedApp) throw noDeploymentsError("No deployments available to open", "The resolved project does not have any deployed app yet.");
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to resolve app URL", error, ["prisma-cli app show"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -334,11 +391,16 @@ async function runAppOpen(context, appName, projectRef) {
 	if (!liveDeployment) throw noDeploymentsError("No deployments available to open", `The selected app "${deploymentsResult.app.name}" does not have any deployments yet.`);
 	if (!deploymentsResult.app.liveUrl) throw featureUnavailableError("Live URL is not available for the selected app", "Deployments exist, but the provider does not expose a stable live service URL for this app yet.", "Run prisma-cli app show to inspect the current deployment state and try again after the app reports a live URL.", ["prisma-cli app show"], "app");
 	const shouldOpen = canPrompt(context);
-	if (shouldOpen) await open(deploymentsResult.app.liveUrl);
+	if (shouldOpen) {
+		context.runtime.signal.throwIfAborted();
+		await open(deploymentsResult.app.liveUrl);
+		context.runtime.signal.throwIfAborted();
+	}
 	return {
 		command: "app.open",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -352,10 +414,11 @@ async function runAppOpen(context, appName, projectRef) {
 }
 async function runAppDomainAdd(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
-	const target = await resolveAppDomainTarget(context, options);
+	const target = await resolveAppDomainTarget(context, options, `app domain add ${normalizedHostname}`);
 	const added = await target.provider.addDomain({
 		appId: target.app.id,
-		hostname: normalizedHostname
+		hostname: normalizedHostname,
+		signal: context.runtime.signal
 	}).catch((error) => {
 		throw domainCommandError("add", error, normalizedHostname);
 	});
@@ -372,9 +435,9 @@ async function runAppDomainAdd(context, hostname, options) {
 }
 async function runAppDomainShow(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
-	const target = await resolveAppDomainTarget(context, options);
-	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "show");
-	const detail = await target.provider.showDomain(domain.id).catch((error) => {
+	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 {
@@ -389,10 +452,10 @@ async function runAppDomainShow(context, hostname, options) {
 }
 async function runAppDomainRemove(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
-	const target = await resolveAppDomainTarget(context, options);
-	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "remove");
+	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).catch((error) => {
+	await target.provider.removeDomain(domain.id, { signal: context.runtime.signal }).catch((error) => {
 		throw domainCommandError("remove", error, normalizedHostname);
 	});
 	return {
@@ -408,9 +471,9 @@ async function runAppDomainRemove(context, hostname, options) {
 }
 async function runAppDomainRetry(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
-	const target = await resolveAppDomainTarget(context, options);
-	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "retry");
-	const retried = await target.provider.retryDomain(domain.id).catch((error) => {
+	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 {
@@ -426,8 +489,8 @@ async function runAppDomainRetry(context, hostname, options) {
 async function runAppDomainWait(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
 	const timeoutMs = parseDomainWaitTimeout(options?.timeout);
-	const target = await resolveAppDomainTarget(context, options);
-	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "wait");
+	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.`,
 		"",
@@ -470,15 +533,15 @@ async function runAppDomainWait(context, hostname, options) {
 			exitCode: 1,
 			nextSteps: [`prisma-cli app domain show ${normalizedHostname}`]
 		});
-		await sleep(Math.min(pollIntervalMs, Math.max(deadline - Date.now(), 0)));
-		current = await target.provider.showDomain(current.id).catch((error) => {
+		await sleep(Math.min(pollIntervalMs, Math.max(deadline - Date.now(), 0)), context.runtime.signal);
+		current = await target.provider.showDomain(current.id, { signal: context.runtime.signal }).catch((error) => {
 			throw domainCommandError("wait", error, normalizedHostname);
 		});
 	}
 }
 async function runAppLogs(context, appName, deploymentId, projectRef) {
 	ensurePreviewAppMode(context);
-	const { provider, target: resolvedTarget, projectId } = await requireProviderAndProjectContext(context, projectRef);
+	const { provider, target: resolvedTarget, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app logs" });
 	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, {
@@ -504,6 +567,7 @@ async function runAppLogs(context, appName, deploymentId, projectRef) {
 	}
 	await provider.streamDeploymentLogs({
 		deploymentId: target.deployment.id,
+		signal: context.runtime.signal,
 		onRecord: (record) => writeLogRecord(context, record)
 	}).catch((error) => {
 		throw deployFailedError("Failed to stream app logs", error, [`prisma-cli app show-deploy ${target.deployment.id}`, "prisma-cli app list-deploys"]);
@@ -513,7 +577,7 @@ async function resolveExplicitLogDeployment(context, provider, projectId, branch
 	if (appName) {
 		const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, branchName), appName);
 		if (!selectedApp) throw noDeploymentsError("No deployments available to stream logs", "The resolved project does not have any deployed app yet.");
-		const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+		const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 			throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
 		});
 		const deployment = requireDeploymentForApp(deploymentsResult.deployments, deploymentId, selectedApp.name);
@@ -526,7 +590,7 @@ async function resolveExplicitLogDeployment(context, provider, projectId, branch
 			deployment
 		};
 	}
-	const shown = await provider.showDeployment(deploymentId).catch((error) => {
+	const shown = await provider.showDeployment(deploymentId, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to show deployment", error, ["prisma-cli app list-deploys"]);
 	});
 	if (!shown) throw new CliError({
@@ -569,7 +633,7 @@ async function resolveExplicitLogDeployment(context, provider, projectId, branch
 async function resolveLiveLogDeployment(context, provider, projectId, branchName, appName) {
 	const selectedApp = await resolveExistingAppSelection(context, projectId, await listApps(context, provider, projectId, branchName), appName);
 	if (!selectedApp) throw noDeploymentsError("No deployments available to stream logs", "The resolved project does not have any deployed app yet.");
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -602,9 +666,9 @@ function writeLogRecord(context, record) {
 }
 async function runAppPromote(context, deploymentId, appName, projectRef) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef);
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app promote" });
 	const selectedApp = await requireReleaseAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName, "promote");
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -617,6 +681,7 @@ async function runAppPromote(context, deploymentId, appName, projectRef) {
 	if (!targetAlreadyLive) await provider.promoteDeployment({
 		appId: selectedApp.id,
 		deploymentId: targetDeployment.id,
+		signal: context.runtime.signal,
 		progress: createPreviewPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
 	}).catch((error) => {
 		throw deployFailedError("Failed to promote deployment", error, ["prisma-cli app list-deploys"]);
@@ -626,6 +691,7 @@ async function runAppPromote(context, deploymentId, appName, projectRef) {
 		command: "app.promote",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -642,9 +708,9 @@ async function runAppPromote(context, deploymentId, appName, projectRef) {
 }
 async function runAppRollback(context, appName, deploymentId, projectRef) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef);
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app rollback" });
 	const selectedApp = await requireReleaseAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName, "rollback");
-	const deploymentsResult = await provider.listDeployments(selectedApp.id).catch((error) => {
+	const deploymentsResult = await provider.listDeployments(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
 	});
 	const currentLiveDeploymentId = await resolveCurrentLiveDeploymentId(context, projectId, deploymentsResult.app, deploymentsResult.deployments);
@@ -658,6 +724,7 @@ async function runAppRollback(context, appName, deploymentId, projectRef) {
 	if (!targetAlreadyLive) await provider.promoteDeployment({
 		appId: selectedApp.id,
 		deploymentId: targetDeployment.id,
+		signal: context.runtime.signal,
 		progress: createPreviewPromoteProgress(context.output.stderr, !context.flags.json && !context.flags.quiet)
 	}).catch((error) => {
 		throw deployFailedError("Failed to roll back deployment", error, ["prisma-cli app list-deploys"]);
@@ -667,6 +734,7 @@ async function runAppRollback(context, appName, deploymentId, projectRef) {
 		command: "app.rollback",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -684,10 +752,10 @@ async function runAppRollback(context, appName, deploymentId, projectRef) {
 }
 async function runAppRemove(context, appName, projectRef) {
 	ensurePreviewAppMode(context);
-	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef);
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, projectRef, { commandName: "app remove" });
 	const selectedApp = await requireReleaseAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), appName, "remove");
 	await confirmAppRemoval(context, selectedApp);
-	const removedApp = await provider.removeApp(selectedApp.id).catch((error) => {
+	const removedApp = await provider.removeApp(selectedApp.id, { signal: context.runtime.signal }).catch((error) => {
 		throw removeFailedError("Failed to remove app", error, ["prisma-cli app show", "prisma-cli app list-deploys"]);
 	});
 	const warnings = await cleanupRemovedAppState(context, projectId, removedApp.id);
@@ -695,6 +763,7 @@ async function runAppRemove(context, appName, projectRef) {
 		command: "app.remove",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: removedApp.id,
 				name: removedApp.name
@@ -705,7 +774,7 @@ async function runAppRemove(context, appName, projectRef) {
 		nextSteps: ["prisma-cli app deploy", "prisma-cli app list-deploys"]
 	};
 }
-async function resolveAppDomainTarget(context, options) {
+async function resolveAppDomainTarget(context, options, commandName = "app domain") {
 	ensurePreviewAppMode(context);
 	const branch = resolveDomainBranch(options?.branchName);
 	if (toBranchKind(branch.name) !== "production") throw new CliError({
@@ -719,14 +788,10 @@ async function resolveAppDomainTarget(context, options) {
 	});
 	const envProjectId = readDeployEnvOverride(context, PRISMA_PROJECT_ID_ENV_VAR);
 	const envAppId = readDeployEnvOverride(context, PRISMA_APP_ID_ENV_VAR);
-	const skipLocalPin = Boolean(envProjectId || envAppId);
-	const localPin = skipLocalPin ? { kind: "missing" } : await readLocalResolutionPin(context.runtime.cwd);
-	if (!skipLocalPin && localPin.kind === "invalid") throw localResolutionPinStaleError();
-	const { provider, target, projectId } = await requireProviderAndDeployProjectContext(context, options?.projectRef, {
-		allowCreate: false,
+	const { provider, target, projectId } = await requireProviderAndProjectContext(context, options?.projectRef, {
 		branch,
-		envProjectId,
-		localPin
+		commandName,
+		envProjectId
 	});
 	const selectedApp = await resolveDomainAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), {
 		explicitAppName: options?.appName,
@@ -742,7 +807,7 @@ async function resolveAppDomainTarget(context, options) {
 		resultTarget: {
 			workspace: target.workspace,
 			project: target.project,
-			branch: target.branch,
+			branch: toResultBranch(target.branch),
 			app: {
 				id: selectedApp.id,
 				name: selectedApp.name
@@ -766,8 +831,8 @@ async function resolveDomainAppSelection(context, projectId, apps, options) {
 	if (selectedApp) return selectedApp;
 	throw usageError("Custom domain requires an existing app on the production branch", "The resolved production branch does not have an app that can receive a custom domain.", "Deploy or promote an app to production first, then rerun the domain command.", ["prisma-cli app deploy --branch production", "prisma-cli app show"], "app");
 }
-async function resolveDomainByHostname(provider, appId, hostname, command) {
-	const matched = (await provider.listDomains(appId).catch((error) => {
+async function resolveDomainByHostname(provider, appId, hostname, command, signal) {
+	const matched = (await provider.listDomains(appId, { signal }).catch((error) => {
 		throw domainCommandError(command, error, hostname);
 	})).find((domain) => sameDomainHostname(domain.hostname, hostname));
 	if (matched) return matched;
@@ -998,9 +1063,20 @@ function formatElapsed(milliseconds) {
 	const remainingSeconds = seconds % 60;
 	return `${minutes}:${String(remainingSeconds).padStart(2, "0")}`;
 }
-async function sleep(milliseconds) {
+async function sleep(milliseconds, signal) {
 	if (milliseconds <= 0) return;
-	await new Promise((resolve) => setTimeout(resolve, milliseconds));
+	signal.throwIfAborted();
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(signal.reason);
+		};
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, milliseconds);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
 }
 async function resolveDeployAppSelection(context, projectId, apps, options) {
 	if (options.explicitAppName) {
@@ -1215,15 +1291,18 @@ function resolveRollbackTarget(deployments, currentLiveDeploymentId) {
 	});
 }
 async function listApps(context, provider, projectId, branchName) {
-	return provider.listApps(projectId, { branchName }).then(sortApps).catch((error) => {
+	return provider.listApps(projectId, {
+		branchName,
+		signal: context.runtime.signal
+	}).then(sortApps).catch((error) => {
 		if (isMissingProjectError(error)) throw new CliError({
 			code: "PROJECT_NOT_FOUND",
 			domain: "project",
 			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 resolution for this directory.",
+			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 app deploy --project <id-or-name>"]
+			nextSteps: ["prisma-cli project show", "prisma-cli project link <id-or-name>"]
 		});
 		throw deployFailedError("Failed to list apps", error, ["prisma-cli project show"]);
 	});
@@ -1233,20 +1312,20 @@ async function requirePreviewAppProvider(context) {
 	return provider;
 }
 async function requirePreviewAppProviderWithClient(context) {
-	const client = await requireComputeAuth(context.runtime.env);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
 	return {
 		client,
-		provider: createPreviewAppProvider(client, createPreviewLogAuthOptions(context.runtime.env))
+		provider: createPreviewAppProvider(client, createPreviewLogAuthOptions(context.runtime.env, context.runtime.signal))
 	};
 }
-function createPreviewLogAuthOptions(env) {
+function createPreviewLogAuthOptions(env, signal) {
 	const rawToken = env[SERVICE_TOKEN_ENV_VAR]?.trim();
 	if (rawToken) return {
 		baseUrl: getApiBaseUrl(env),
 		getToken: async () => rawToken
 	};
-	const tokenStorage = new FileTokenStorage(env);
+	const tokenStorage = new FileTokenStorage(env, signal);
 	return {
 		baseUrl: getApiBaseUrl(env),
 		getToken: async () => {
@@ -1258,7 +1337,7 @@ function createPreviewLogAuthOptions(env) {
 }
 async function requireProviderAndProjectContext(context, explicitProject, options) {
 	const { client, provider } = await requirePreviewAppProviderWithClient(context);
-	const target = await resolveProjectContext(context, client, provider, explicitProject, options);
+	const target = await resolveProjectContext(context, client, explicitProject, options);
 	return {
 		client,
 		provider,
@@ -1276,36 +1355,24 @@ async function requireProviderAndDeployProjectContext(context, explicitProject,
 		projectId: target.project.id
 	};
 }
-async function resolveProjectContext(context, client, provider, explicitProject, options) {
+async function resolveProjectContext(context, client, explicitProject, options) {
 	const authState = await requireAuthenticatedAuthState(context);
 	if (!authState.workspace) throw workspaceRequiredError();
-	const resolved = await resolveProjectTarget({
+	const resolvedResult = await resolveProjectTarget({
 		context,
 		workspace: authState.workspace,
 		explicitProject,
-		listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
-		createProject: options?.allowCreate ? async (name) => {
-			const project = await provider.createProject({ name }).catch((error) => {
-				throw createProjectOnFirstDeployError({
-					error,
-					inferredName: name,
-					workspaceName: authState.workspace.name
-				});
-			});
-			return {
-				id: project.id,
-				name: project.name,
-				workspace: authState.workspace
-			};
-		} : void 0,
-		allowCreate: options?.allowCreate,
-		prompt: createSelectPromptPort(context),
-		remember: true
+		envProjectId: options?.envProjectId,
+		listProjects: () => listRealWorkspaceProjects(client, authState.workspace, context.runtime.signal),
+		commandName: options?.commandName
 	});
+	if (resolvedResult.isErr()) throw projectResolutionErrorToCliError(resolvedResult.error);
+	const resolved = resolvedResult.value;
 	const branch = options?.branch ?? await resolveDeployBranch(context, void 0);
 	return {
 		...resolved,
 		branch: {
+			id: null,
 			name: branch.name,
 			kind: toBranchKind(branch.name)
 		}
@@ -1315,35 +1382,35 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
 	const branch = options.branch ?? await resolveDeployBranch(context, void 0);
-	const projects = await listRealWorkspaceProjects(client, workspace);
-	const createProject = options.allowCreate ? async (name) => {
-		const project = await provider.createProject({ name }).catch((error) => {
-			throw createProjectOnFirstDeployError({
-				error,
-				inferredName: name,
-				workspaceName: workspace.name
-			});
-		});
-		return {
-			id: project.id,
-			name: project.name,
-			workspace
-		};
-	} : void 0;
-	if (explicitProject) return withDeployBranch(await resolveProjectTarget({
-		context,
+	const projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
+	if (explicitProject) return withRemoteDeployBranch(provider, {
 		workspace,
-		explicitProject,
-		listProjects: async () => projects,
-		createProject,
-		allowCreate: options.allowCreate,
-		prompt: createSelectPromptPort(context),
-		remember: true
-	}), branch);
+		project: toProjectSummary(resolveProjectForSetup(explicitProject, projects, workspace)),
+		resolution: {
+			projectSource: "explicit",
+			targetName: explicitProject,
+			targetNameSource: "explicit"
+		},
+		localPinAction: "linked"
+	}, branch, context.runtime.signal);
+	if (options.createProjectName) {
+		const projectName = options.createProjectName.trim();
+		if (!projectName) throw projectSetupNameRequiredError("app deploy --create-project");
+		return withRemoteDeployBranch(provider, {
+			workspace,
+			project: toProjectSummary(await createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal)),
+			resolution: {
+				projectSource: "created",
+				targetName: projectName,
+				targetNameSource: "explicit"
+			},
+			localPinAction: "created"
+		}, branch, context.runtime.signal);
+	}
 	if (options.envProjectId) {
 		const project = projects.find((candidate) => candidate.id === options.envProjectId);
 		if (!project) throw projectNotFoundError(options.envProjectId, workspace);
-		return withDeployBranch({
+		return withRemoteDeployBranch(provider, {
 			workspace,
 			project: toProjectSummary(project),
 			resolution: {
@@ -1351,14 +1418,14 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 				targetName: options.envProjectId,
 				targetNameSource: "env"
 			}
-		}, branch);
+		}, branch, context.runtime.signal);
 	}
 	const localPin = options.localPin;
 	if (localPin.kind === "present") {
 		if (localPin.pin.workspaceId !== workspace.id) throw localResolutionPinStaleError();
 		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
 		if (!project) throw localResolutionPinStaleError();
-		return withDeployBranch({
+		return withRemoteDeployBranch(provider, {
 			workspace,
 			project: toProjectSummary(project),
 			resolution: {
@@ -1366,42 +1433,123 @@ async function resolveDeployProjectContext(context, client, provider, explicitPr
 				targetName: project.name,
 				targetNameSource: "local-pin"
 			}
-		}, branch);
+		}, branch, context.runtime.signal);
 	}
-	return withDeployBranch(await resolveProjectTarget({
+	const platformMapping = await resolveDurablePlatformMapping();
+	if (platformMapping && 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), branch, context.runtime.signal);
+	throw projectSetupRequiredError(projects, await inferTargetName(context.runtime.cwd, context.runtime.signal));
+}
+async function resolveInteractiveDeployProjectSetup(context, provider, workspace, projects) {
+	const setup = await promptForProjectSetupChoice({
 		context,
+		projects,
+		createProject: (projectName) => createProjectForDeploySetup(provider, projectName, workspace, context.runtime.signal),
+		cancel: {
+			why: "Deploy needs a Project before it can continue.",
+			fix: "Choose an existing Project or create a new one, then rerun deploy.",
+			nextSteps: ["prisma-cli app deploy --project <id-or-name>", "prisma-cli app deploy --create-project <name>"]
+		}
+	});
+	return {
 		workspace,
-		listProjects: async () => projects,
-		createProject,
-		allowCreate: options.allowCreate,
-		prompt: createSelectPromptPort(context),
-		remember: true
-	}), branch);
-}
-function withDeployBranch(target, branch) {
+		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) {
+	const created = await provider.createProject({
+		name: projectName,
+		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,
+		workspace
+	};
+}
+async function withRemoteDeployBranch(provider, target, branch, signal) {
+	const remoteBranch = await provider.resolveBranch(target.project.id, {
+		branchName: branch.name,
+		signal
+	});
 	return {
 		...target,
 		branch: {
-			name: branch.name,
-			kind: toBranchKind(branch.name)
+			id: remoteBranch.id,
+			name: remoteBranch.name,
+			kind: remoteBranch.role
 		}
 	};
 }
-function toProjectSummary(project) {
+function toBranchKind(name) {
+	return name === "production" || name === "main" ? "production" : "preview";
+}
+function toResultBranch(branch) {
 	return {
-		id: project.id,
-		name: project.name
+		id: branch.id,
+		name: branch.name,
+		kind: branch.kind
 	};
 }
-function toBranchKind(name) {
-	return name === "production" || name === "main" ? "production" : "preview";
+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);
+	const gitBranch = await readLocalGitBranch(context.runtime.cwd, context.runtime.signal);
 	if (gitBranch) return {
 		name: gitBranch,
 		annotation: "from local Git branch"
@@ -1411,41 +1559,15 @@ async function resolveDeployBranch(context, explicitBranchName) {
 		annotation: "default"
 	};
 }
-async function readLocalGitBranch(cwd) {
-	const headPath = await resolveGitHeadPath(path.join(cwd, ".git"));
-	if (!headPath) return null;
-	try {
-		const head = (await readFile(headPath, "utf8")).trim();
-		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
-	} catch {
-		return null;
-	}
-	return null;
-}
-async function resolveGitHeadPath(gitPath) {
-	try {
-		const raw = await readFile(gitPath, "utf8");
-		if (raw.startsWith("gitdir:")) return path.join(path.resolve(path.dirname(gitPath), raw.slice(7).trim()), "HEAD");
-	} catch {}
-	try {
-		await access(path.join(gitPath, "HEAD"));
-		return path.join(gitPath, "HEAD");
-	} catch {
-		return null;
-	}
-}
 async function resolveDeployFramework(context, options) {
 	if (options.requestedFramework) return frameworkFromUserFacingValue(options.requestedFramework, "set by --framework");
-	if (options.explicitBuildType) {
-		const buildType = normalizeBuildType(options.requestedBuildType);
-		if (buildType !== "auto") return {
-			key: buildType,
-			buildType,
-			displayName: formatBuildTypeName(buildType),
-			annotation: "set by --build-type"
-		};
-	}
-	const detected = await detectDeployFramework(context.runtime.cwd);
+	if (options.entrypoint) return {
+		key: "bun",
+		buildType: "bun",
+		displayName: "Bun",
+		annotation: "set by --entry"
+	};
+	const detected = await detectDeployFramework(context.runtime.cwd, context.runtime.signal);
 	if (detected) return detected;
 	throw frameworkNotDetectedError(context.runtime.cwd);
 }
@@ -1459,9 +1581,30 @@ function resolveDeployRuntime(requestedHttpPort, framework) {
 		annotation: `${framework.displayName} default`
 	};
 }
-async function detectDeployFramework(cwd) {
-	const packageJson = await readBunPackageJson(cwd);
-	const nextConfig = await detectNextConfig(cwd);
+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;
+	if (framework.key !== "hono") return;
+	const defaultEntrypoint = "src/index.ts";
+	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 packageJson = await readBunPackageJson(cwd, signal);
+	const nextConfig = await detectNextConfig(cwd, signal);
 	if (nextConfig.exists || hasPackageDependency(packageJson, "next")) return {
 		key: "nextjs",
 		buildType: "nextjs",
@@ -1474,7 +1617,7 @@ async function detectDeployFramework(cwd) {
 		displayName: "Hono",
 		annotation: "detected from package.json"
 	};
-	if (hasPackageDependency(packageJson, "@tanstack/start")) return {
+	if (hasAnyPackageDependency(packageJson, TANSTACK_START_PACKAGES)) return {
 		key: "tanstack-start",
 		buildType: "tanstack-start",
 		displayName: "TanStack Start",
@@ -1482,21 +1625,26 @@ async function detectDeployFramework(cwd) {
 	};
 	return null;
 }
-async function detectNextConfig(cwd) {
+async function detectNextConfig(cwd, signal) {
 	for (const candidate of [
 		"next.config.js",
 		"next.config.mjs",
-		"next.config.cjs",
-		"next.config.ts"
+		"next.config.ts",
+		"next.config.mts"
 	]) {
 		const filePath = path.join(cwd, candidate);
+		signal.throwIfAborted();
 		try {
-			const content = await readFile(filePath, "utf8");
+			const content = await readFile(filePath, {
+				encoding: "utf8",
+				signal
+			});
 			return {
 				exists: true,
 				standalone: /\boutput\s*:\s*["'`]standalone["'`]/.test(content)
 			};
 		} catch (error) {
+			if (signal.aborted) throw error;
 			if (error.code !== "ENOENT") throw error;
 		}
 	}
@@ -1508,6 +1656,9 @@ async function detectNextConfig(cwd) {
 function hasPackageDependency(packageJson, dependencyName) {
 	return hasDependency(packageJson?.dependencies, dependencyName) || hasDependency(packageJson?.devDependencies, dependencyName);
 }
+function hasAnyPackageDependency(packageJson, dependencyNames) {
+	return dependencyNames.some((dependencyName) => hasPackageDependency(packageJson, dependencyName));
+}
 function hasDependency(dependencies, dependencyName) {
 	return Boolean(dependencies && typeof dependencies === "object" && dependencyName in dependencies);
 }
@@ -1527,9 +1678,16 @@ function frameworkFromUserFacingValue(value, annotation) {
 			displayName: "Hono",
 			annotation
 		};
+		case "bun": return {
+			key: "bun",
+			buildType: "bun",
+			displayName: "Bun",
+			annotation
+		};
 		case "tanstack":
 		case "tanstack-start":
-		case "@tanstack/start": return {
+		case "@tanstack/react-start":
+		case "@tanstack/solid-start": return {
 			key: "tanstack-start",
 			buildType: "tanstack-start",
 			displayName: "TanStack Start",
@@ -1539,82 +1697,61 @@ function frameworkFromUserFacingValue(value, annotation) {
 	}
 }
 function frameworkNotDetectedError(cwd, requestedFramework) {
-	const supported = "Next.js, Hono, TanStack Start";
+	const supported = "Next.js, Hono, TanStack Start, Bun";
 	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, or pass --framework <nextjs|hono|tanstack-start>.",
+		fix: "Add one of these frameworks as a dependency, pass --framework <nextjs|hono|tanstack-start|bun>, 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 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 = formatDeployDirectory(context.runtime.cwd);
-	if (!details.firstDeploy) {
-		context.output.stderr.write(`Deploying ${directory} to ${details.projectName} / ${details.branchName} / ${details.appName}\n\n`);
-		return;
-	}
-	const title = `Setting up your local directory ${formatLocalDirectory(context.runtime.cwd, context.runtime.env)}`;
-	const rows = details.firstDeploy ? [
-		{
-			label: "Workspace",
-			value: details.workspaceName
-		},
-		{
-			label: "Project",
-			value: details.projectName,
-			origin: details.projectAnnotation
-		},
-		{
-			label: "Branch",
-			value: details.branchName,
-			origin: details.branchAnnotation
-		},
-		{
-			label: "App",
-			value: details.appName,
-			origin: details.appAnnotation
-		},
-		{
-			label: "Framework",
-			value: details.framework.displayName,
-			origin: details.framework.annotation
-		},
-		{
-			label: "Runtime",
-			value: `HTTP ${details.runtime.port}`,
-			origin: details.runtime.annotation
-		}
-	] : [];
-	const lines = [
-		title,
-		"",
-		...renderDeployOutputRows(context.ui, rows),
-		""
-	];
-	context.output.stderr.write(`${lines.join("\n")}\n`);
+	const prefix = details.includeDirectory ? `Deploying ${directory} to` : "Deploying to";
+	context.output.stderr.write(`${prefix} ${details.projectName} / ${details.branchName} / ${details.appName}\n\n`);
 }
-function maybeRenderLocalPinBound(context, projectName) {
+function maybeRenderDeployBuildSettings(context, resolution) {
+	if (context.flags.json || context.flags.quiet) return;
+	const settings = resolution.settings;
+	const title = resolution.status === "created" ? `Created ${resolution.relativeConfigPath}` : `Using ${resolution.relativeConfigPath}`;
+	context.output.stderr.write(`${title}\n${renderDeployOutputRows(context.ui, [{
+		label: "Build Command",
+		value: settings.buildCommand ?? "none",
+		origin: settings.buildCommandSource ?? void 0
+	}, {
+		label: "Output Directory",
+		value: settings.outputDirectory,
+		origin: settings.outputDirectorySource ?? void 0
+	}]).join("\n")}\n\n`);
+}
+function maybeRenderProjectLinked(context, directory, projectName, localPinPath) {
 	if (context.flags.json || context.flags.quiet) return;
-	context.output.stderr.write(`This directory is now linked to project ${projectName}.\n\n`);
+	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.explicitBuildType || options.explicitHttpPort || !canPrompt(context)) return {
+	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,
-		message: "Customize settings?",
+		message: "Customize build settings?",
 		initialValue: false
 	})) return {
 		framework: options.framework,
@@ -1659,24 +1796,22 @@ async function maybeCustomizeDeploySettings(context, options) {
 		runtime
 	};
 }
-function annotationForProjectResolution(resolution) {
-	switch (resolution.projectSource) {
-		case "explicit": return "set by --project";
-		case "env": return `from ${PRISMA_PROJECT_ID_ENV_VAR}`;
-		case "local-pin": return "from local pin";
-		case "created": return resolution.targetNameSource === "directory-name" ? "created from directory name" : "created from package.json";
-		case "package-name":
-		case "directory-name": return "linked to existing project";
-		case "platform-mapping":
-		case "remembered-local": return "linked to existing project";
-		case "prompt": return "selected by you";
-	}
+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 frameworkDisplayName(framework) {
 	switch (framework) {
 		case "nextjs": return "Next.js";
 		case "hono": return "Hono";
 		case "tanstack-start": return "TanStack Start";
+		case "bun": return "Bun";
 	}
 }
 function validateDeployHttpPortText(value) {
@@ -1692,19 +1827,10 @@ function formatDeployDirectory(cwd) {
 	const basename = path.basename(cwd);
 	return basename ? `./${basename}` : ".";
 }
-function formatLocalDirectory(cwd, env) {
-	const resolved = path.resolve(cwd);
-	const home = env.HOME ? path.resolve(env.HOME) : null;
-	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
-		const relative = path.relative(home, resolved);
-		return relative ? `~/${relative}` : "~";
-	}
-	return resolved;
-}
 async function readCurrentWorkspaceId(context) {
 	const state = await context.stateStore.read();
 	if (state.auth?.workspaceId) return state.auth.workspaceId;
-	return (await readAuthState(context.runtime.env)).workspace?.id ?? null;
+	return (await readAuthState(context.runtime.env, context.runtime.signal)).workspace?.id ?? null;
 }
 function normalizeBuildType(requestedBuildType) {
 	if (!requestedBuildType) return "auto";
@@ -1720,10 +1846,13 @@ function getBuildTypeExamples(commandName) {
 	});
 }
 function assertSupportedEntrypoint(buildType, entrypoint, commandName) {
-	if (buildType !== "auto" && buildType !== "bun" && entrypoint) 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");
+	if (buildType !== "auto" && buildType !== "bun" && entrypoint) {
+		if (commandName === "deploy") throw usageError(`App deploy does not accept --entry with ${formatBuildTypeName(buildType)}`, `${formatBuildTypeName(buildType)} apps derive their runtime entrypoint from build output.`, "Remove --entry, or use --framework bun when you want to target a Bun entrypoint directly.", [`prisma-cli app deploy --framework ${buildType}`, "prisma-cli app deploy --framework bun --entry server.ts"], "app");
+		throw usageError(`App ${commandName} does not accept --entry with --build-type ${buildType}`, `${formatBuildTypeName(buildType)} apps do not use an entrypoint flag in the current preview.`, `Remove --entry, or rerun prisma-cli app ${commandName} with --build-type bun when you want to target a Bun entrypoint directly.`, [`prisma-cli app ${commandName} --build-type ${buildType}`, `prisma-cli app ${commandName} --build-type bun --entry server.ts`], "app");
+	}
 }
 async function requireLocalBuildType(context, buildType, commandName) {
-	const resolvedBuildType = await resolveLocalBuildType(context.runtime.cwd, buildType);
+	const resolvedBuildType = await resolveLocalBuildType(context.runtime.cwd, buildType, context.runtime.signal);
 	if (resolvedBuildType) return resolvedBuildType;
 	throw usageError(`App ${commandName} requires an explicit framework when detection is ambiguous`, "This preview only starts local dev servers for clear Next.js or Bun project shapes.", "Pass --build-type nextjs for a Next.js app, or pass --build-type bun with --entry <path> for a Bun app.", [`prisma-cli app ${commandName} --build-type nextjs`, `prisma-cli app ${commandName} --build-type bun --entry server.ts`], "app");
 }
@@ -1761,24 +1890,41 @@ function deployFailedError(summary, error, nextSteps) {
 function appDeployFailedError(error, progress) {
 	const why = error instanceof Error ? error.message : String(error);
 	const debug = formatDebugDetails(error);
-	if (progress.buildStarted && !progress.buildCompleted) return new CliError({
-		code: "BUILD_FAILED",
-		domain: "app",
-		summary: "Build failed locally.",
-		why,
-		fix: "Inspect the build output above, fix the error, and redeploy.",
-		debug,
-		meta: { phase: "build" },
-		humanLines: [
-			"Build failed locally.",
-			"",
-			`✗ Built       ${why}`,
-			"",
-			"Fix: Inspect the build output above, fix the error, and redeploy."
-		],
-		exitCode: 1,
-		nextSteps: []
-	});
+	if (progress.buildStarted && !progress.buildCompleted) {
+		const standaloneOutputFailure = isNextStandaloneOutputFailure(why);
+		const fix = standaloneOutputFailure ? "Add output: \"standalone\" to next.config.*, then rerun deploy." : "Inspect the build output above, fix the error, and redeploy.";
+		const nextSteps = standaloneOutputFailure ? ["Add output: \"standalone\" to next.config.*, then rerun prisma-cli app deploy"] : [];
+		const nextActions = standaloneOutputFailure ? [{
+			kind: "edit-file",
+			journey: "deploy-app",
+			label: "Add Next.js standalone output",
+			reason: "Prisma Compute needs Next.js standalone output to build a deployable server artifact."
+		}, {
+			kind: "run-command",
+			journey: "deploy-app",
+			label: "Rerun deploy",
+			command: "prisma-cli app deploy"
+		}] : [];
+		return new CliError({
+			code: "BUILD_FAILED",
+			domain: "app",
+			summary: "Build failed locally.",
+			why,
+			fix,
+			debug,
+			meta: { phase: "build" },
+			humanLines: [
+				"Build failed locally.",
+				"",
+				`✗ Built       ${why}`,
+				"",
+				`Fix: ${fix}`
+			],
+			exitCode: 1,
+			nextSteps,
+			nextActions
+		});
+	}
 	if (!progress.buildStarted) return deployFailedError("App deploy failed", error, ["prisma-cli app deploy"]);
 	const phaseHeadline = progress.containerLive ? "The deployment started, but the app is not ready yet." : "Deploy failed after the build completed.";
 	const recoveryLines = progress.versionId ? ["See what happened", `prisma-cli app logs --deployment ${progress.versionId}`] : ["Fix", "Retry the command, or rerun with --trace for more detailed diagnostics."];
@@ -1825,61 +1971,64 @@ function localResolutionPinStaleError() {
 		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} and re-run to re-bootstrap.`,
+		fix: `Delete ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}, then choose a Project explicitly.`,
 		meta: { pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH },
 		exitCode: 1,
-		nextSteps: ["prisma-cli app deploy"]
+		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;
 }
-/**
-* `app deploy` falls into "create a new project on first deploy" when no
-* existing project matches the package.json name (or the cwd basename as a
-* fallback). When the create call fails the user often doesn't realise the
-* CLI was attempting to create a project at all — they thought the deploy
-* would find an existing project. Surface that context, and recommend the
-* explicit `--project` flag as the unambiguous way out.
-*/
-function createProjectOnFirstDeployError(options) {
-	const { error, inferredName, workspaceName } = options;
-	const status = extractHttpStatus(error);
-	const errorMessage = error instanceof Error ? error.message : String(error);
-	const inferredContext = `No existing project matched the package.json name \`${inferredName}\`, so the CLI attempted to create one.`;
-	const nextSteps = ["prisma-cli project list", "prisma-cli app deploy --project <id-or-name>"];
-	if (status === 401 || status === 403) return new CliError({
-		code: "AUTH_FORBIDDEN",
-		domain: "auth",
-		summary: "Could not create a new project for this deploy",
-		why: `${inferredContext} The platform rejected the create (HTTP ${status}).`,
-		fix: `Pass --project <id-or-name> to deploy into an existing project, or grant the service token project-create permission on workspace \`${workspaceName}\`.`,
-		debug: formatDebugDetails(error),
-		exitCode: 1,
-		nextSteps
-	});
+function projectSetupRequiredError(projects, suggestedName) {
+	const createCommand = `prisma-cli app deploy --create-project ${formatCommandArgument(suggestedName.name)}`;
 	return new CliError({
-		code: "DEPLOY_FAILED",
-		domain: "app",
-		summary: "Could not create a new project for this deploy",
-		why: `${inferredContext} ${errorMessage}`.trim(),
-		fix: "Pass --project <id-or-name> to deploy into an existing project, or retry after addressing the platform error above.",
-		debug: formatDebugDetails(error),
+		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
+		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 extractHttpStatus(error) {
-	if (!error || typeof error !== "object") return null;
-	const candidate = error;
-	if (typeof candidate.statusCode === "number") return candidate.statusCode;
-	if (typeof candidate.status === "number") return candidate.status;
-	if (typeof candidate.message === "string") {
-		const match = /\(HTTP (\d{3})\)/.exec(candidate.message);
-		if (match) return Number.parseInt(match[1], 10);
-	}
-	return null;
+function isNextStandaloneOutputFailure(message) {
+	return /next\.?js/i.test(message) && /standalone output/i.test(message);
 }
 function noDeploymentsError(summary, why) {
 	return new CliError({