@prisma/cli 3.0.0-dev.39.1 → 3.0.0-dev.41.1

package/dist/commands/app/index.js

@@ -62,13 +62,13 @@ function createDeployCommand(runtime) {
 	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--create-project <name>", "Create and link a new Project before deploying")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([
 		"nextjs",
 		"hono",
-		"tanstack-start"
-	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto deploys")).addOption(new Option("--build-type <type>", "Legacy deploy build type").choices([...PREVIEW_BUILD_TYPES]).default("auto").hideHelp()).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+		"tanstack-start",
+		"bun"
+	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
 		const entry = options.entry;
-		const buildType = options.buildType;
 		const branchName = options.branch;
 		const framework = options.framework;
 		const httpPort = options.httpPort;
@@ -80,7 +80,6 @@ function createDeployCommand(runtime) {
 			createProjectName,
 			branchName,
 			entrypoint: entry,
-			buildType,
 			framework,
 			httpPort,
 			envAssignments

package/dist/controllers/app-env.js

@@ -1,7 +1,6 @@
 import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { resolveProjectTarget } from "../lib/project/resolution.js";
-import { createSelectPromptPort } from "./select-prompt-port.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
 import { formatScopeLabel, parseKeyValuePositional, resolveEnvScope } from "../lib/app/env-config.js";
@@ -19,7 +18,7 @@ async function runEnvAdd(context, rawAssignment, flags) {
 		command: "add"
 	});
 	if (!scope) throw usageError(`prisma-cli project env add requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env add ${key}=${value} --role production`], "app");
-	const { client, projectId } = await requireClientAndProject(context, flags.projectRef);
+	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env add");
 	const resolved = await resolveScopeToApi(client, projectId, scope, { createBranchIfMissing: true });
 	if (await findVariableByNaturalKey(client, projectId, key, resolved)) throw new CliError({
 		code: "ENV_VARIABLE_ALREADY_EXISTS",
@@ -70,7 +69,7 @@ async function runEnvUpdate(context, rawAssignment, flags) {
 		command: "update"
 	});
 	if (!scope) throw usageError(`prisma-cli project env update requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env update ${key}=${value} --role production`], "app");
-	const { client, projectId } = await requireClientAndProject(context, flags.projectRef);
+	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env update");
 	const resolved = await resolveScopeToApi(client, projectId, scope, { createBranchIfMissing: false });
 	const existing = await findVariableByNaturalKey(client, projectId, key, resolved);
 	if (!existing) throw new CliError({
@@ -103,7 +102,7 @@ async function runEnvList(context, flags) {
 		requireExplicit: false,
 		command: "list"
 	}) ?? defaultRoleScope();
-	const { client, projectId } = await requireClientAndProject(context, flags.projectRef);
+	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env list");
 	const resolved = await resolveScopeToApi(client, projectId, scope, { createBranchIfMissing: false });
 	const variables = await listVariables(client, projectId, resolved);
 	return {
@@ -124,7 +123,7 @@ async function runEnvRemove(context, key, flags) {
 		command: "remove"
 	});
 	if (!scope) throw usageError("prisma-cli project env remove requires --role or --branch", "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env remove ${key} --role production`], "app");
-	const { client, projectId } = await requireClientAndProject(context, flags.projectRef);
+	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env remove");
 	const resolved = await resolveScopeToApi(client, projectId, scope, { createBranchIfMissing: false });
 	const existing = await findVariableByNaturalKey(client, projectId, key, resolved);
 	if (!existing) throw new CliError({
@@ -149,7 +148,7 @@ async function runEnvRemove(context, key, flags) {
 		nextSteps: []
 	};
 }
-async function requireClientAndProject(context, explicitProject) {
+async function requireClientAndProject(context, explicitProject, commandName) {
 	const authState = await requireAuthenticatedAuthState(context);
 	const client = await requireComputeAuth(context.runtime.env);
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
@@ -161,8 +160,7 @@ async function requireClientAndProject(context, explicitProject) {
 			workspace: authState.workspace,
 			explicitProject,
 			listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
-			prompt: createSelectPromptPort(context),
-			remember: true
+			commandName
 		})).project.id
 	};
 }

package/dist/controllers/app.js

@@ -9,10 +9,10 @@ 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 { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
 import { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp } from "../lib/app/local-dev.js";
-import { inferTargetName, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "../lib/project/local-pin.js";
+import { inferTargetName, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
 import { bindProjectToDirectory, formatCommandArgument, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild } from "../lib/app/preview-build.js";
 import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
@@ -29,8 +29,10 @@ import open from "open";
 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";
@@ -105,15 +107,12 @@ async function runAppDeploy(context, appName, options) {
 	const skipLocalPin = Boolean(envProjectId || options?.projectRef || options?.createProjectName);
 	const localPin = skipLocalPin ? { kind: "missing" } : await readLocalResolutionPin(context.runtime.cwd);
 	if (!skipLocalPin && localPin.kind === "invalid") throw localResolutionPinStaleError();
-	const explicitBuildType = Boolean(options?.buildType && options.buildType !== "auto");
+	const branch = await resolveDeployBranch(context, options?.branchName);
 	if (options?.httpPort) parseDeployHttpPort(options.httpPort);
 	assertSupportedEntrypointForRequestedDeployShape({
 		requestedFramework: options?.framework,
-		requestedBuildType: options?.buildType,
-		explicitBuildType,
 		entrypoint: options?.entrypoint
 	});
-	const branch = await resolveDeployBranch(context, options?.branchName);
 	const { provider, target, projectId } = await requireProviderAndDeployProjectContext(context, options?.projectRef, {
 		branch,
 		createProjectName: options?.createProjectName,
@@ -128,8 +127,7 @@ async function runAppDeploy(context, appName, options) {
 	}
 	let framework = await resolveDeployFramework(context, {
 		requestedFramework: options?.framework,
-		requestedBuildType: options?.buildType,
-		explicitBuildType
+		entrypoint: options?.entrypoint
 	});
 	let runtime = resolveDeployRuntime(options?.httpPort, framework);
 	assertSupportedEntrypoint(framework.buildType, options?.entrypoint, "deploy");
@@ -151,13 +149,14 @@ async function runAppDeploy(context, appName, options) {
 		runtime,
 		firstDeploy: selectedApp.firstDeploy,
 		explicitFramework: Boolean(options?.framework),
-		explicitBuildType,
+		explicitEntrypoint: Boolean(options?.entrypoint),
 		explicitHttpPort: Boolean(options?.httpPort)
 	});
 	framework = customized.framework;
 	runtime = customized.runtime;
 	const buildType = framework.buildType;
 	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
+	const entrypoint = await resolveDeployEntrypoint(context.runtime.cwd, framework, options?.entrypoint);
 	const portMapping = parseDeployPortMapping(String(runtime.port));
 	const progressState = createPreviewDeployProgressState();
 	const deployStartedAt = Date.now();
@@ -168,7 +167,7 @@ async function runAppDeploy(context, appName, options) {
 		appId: selectedApp.appId,
 		appName: selectedApp.appName,
 		region: selectedApp.region,
-		entrypoint: options?.entrypoint,
+		entrypoint,
 		buildType,
 		portMapping,
 		envVars,
@@ -204,7 +203,7 @@ async function runAppDeploy(context, appName, options) {
 }
 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",
@@ -241,7 +240,7 @@ 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",
@@ -317,7 +316,7 @@ 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) => {
@@ -351,7 +350,7 @@ 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
@@ -371,7 +370,7 @@ async function runAppDomainAdd(context, hostname, options) {
 }
 async function runAppDomainShow(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
-	const target = await resolveAppDomainTarget(context, options);
+	const target = await resolveAppDomainTarget(context, options, `app domain show ${normalizedHostname}`);
 	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "show");
 	const detail = await target.provider.showDomain(domain.id).catch((error) => {
 		throw domainCommandError("show", error, normalizedHostname);
@@ -388,7 +387,7 @@ async function runAppDomainShow(context, hostname, options) {
 }
 async function runAppDomainRemove(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
-	const target = await resolveAppDomainTarget(context, options);
+	const target = await resolveAppDomainTarget(context, options, `app domain remove ${normalizedHostname}`);
 	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "remove");
 	await confirmDomainRemoval(context, target.resultTarget, normalizedHostname);
 	await target.provider.removeDomain(domain.id).catch((error) => {
@@ -407,7 +406,7 @@ async function runAppDomainRemove(context, hostname, options) {
 }
 async function runAppDomainRetry(context, hostname, options) {
 	const normalizedHostname = normalizeDomainHostname(hostname);
-	const target = await resolveAppDomainTarget(context, options);
+	const target = await resolveAppDomainTarget(context, options, `app domain retry ${normalizedHostname}`);
 	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "retry");
 	const retried = await target.provider.retryDomain(domain.id).catch((error) => {
 		throw domainCommandError("retry", error, normalizedHostname);
@@ -425,7 +424,7 @@ 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 target = await resolveAppDomainTarget(context, options, `app domain wait ${normalizedHostname}`);
 	const domain = await resolveDomainByHostname(target.provider, target.app.id, normalizedHostname, "wait");
 	if (!context.flags.json && !context.flags.quiet) context.output.stderr.write([
 		`app domain wait -> Waiting for ${normalizedHostname} to become active.`,
@@ -477,7 +476,7 @@ async function runAppDomainWait(context, hostname, options) {
 }
 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, {
@@ -601,7 +600,7 @@ 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) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
@@ -641,7 +640,7 @@ 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) => {
 		throw deployFailedError("Failed to list app deployments", error, ["prisma-cli app list-deploys"]);
@@ -683,7 +682,7 @@ 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) => {
@@ -704,7 +703,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({
@@ -718,13 +717,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);
-	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, {
+	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,
@@ -1219,9 +1215,9 @@ async function listApps(context, provider, projectId, branchName) {
 			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"]);
 	});
@@ -1281,8 +1277,9 @@ async function resolveProjectContext(context, client, explicitProject, options)
 		context,
 		workspace: authState.workspace,
 		explicitProject,
+		envProjectId: options?.envProjectId,
 		listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
-		remember: true
+		commandName: options?.commandName
 	});
 	const branch = options?.branch ?? await resolveDeployBranch(context, void 0);
 	return {
@@ -1505,15 +1502,12 @@ async function resolveGitHeadPath(gitPath) {
 }
 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"
-		};
-	}
+	if (options.entrypoint) return {
+		key: "bun",
+		buildType: "bun",
+		displayName: "Bun",
+		annotation: "set by --entry"
+	};
 	const detected = await detectDeployFramework(context.runtime.cwd);
 	if (detected) return detected;
 	throw frameworkNotDetectedError(context.runtime.cwd);
@@ -1529,12 +1523,22 @@ function resolveDeployRuntime(requestedHttpPort, framework) {
 	};
 }
 function assertSupportedEntrypointForRequestedDeployShape(options) {
-	if (options.requestedFramework) {
-		assertSupportedEntrypoint(frameworkFromUserFacingValue(options.requestedFramework, "set by --framework").buildType, options.entrypoint, "deploy");
+	if (!options.requestedFramework) return;
+	assertSupportedEntrypoint(frameworkFromUserFacingValue(options.requestedFramework, "set by --framework").buildType, options.entrypoint, "deploy");
+}
+async function resolveDeployEntrypoint(cwd, framework, explicitEntrypoint) {
+	if (explicitEntrypoint || framework.buildType !== "bun") return explicitEntrypoint;
+	const packageEntrypoint = readBunPackageEntrypoint(await readBunPackageJson(cwd));
+	if (packageEntrypoint) return packageEntrypoint;
+	if (framework.key !== "hono") return;
+	const defaultEntrypoint = "src/index.ts";
+	try {
+		await access(path.join(cwd, defaultEntrypoint));
+		return defaultEntrypoint;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
 		return;
 	}
-	if (!options.explicitBuildType) return;
-	assertSupportedEntrypoint(normalizeBuildType(options.requestedBuildType), options.entrypoint, "deploy");
 }
 async function detectDeployFramework(cwd) {
 	const packageJson = await readBunPackageJson(cwd);
@@ -1551,7 +1555,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",
@@ -1564,7 +1568,8 @@ async function detectNextConfig(cwd) {
 		"next.config.js",
 		"next.config.mjs",
 		"next.config.cjs",
-		"next.config.ts"
+		"next.config.ts",
+		"next.config.mts"
 	]) {
 		const filePath = path.join(cwd, candidate);
 		try {
@@ -1585,6 +1590,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);
 }
@@ -1604,9 +1612,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",
@@ -1616,19 +1631,21 @@ 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"
 		]
 	});
 }
@@ -1643,7 +1660,7 @@ function maybeRenderProjectLinked(context, directory, projectName, localPinPath)
 	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
 	};
@@ -1700,6 +1717,7 @@ function frameworkDisplayName(framework) {
 		case "nextjs": return "Next.js";
 		case "hono": return "Hono";
 		case "tanstack-start": return "TanStack Start";
+		case "bun": return "Bun";
 	}
 }
 function validateDeployHttpPortText(value) {
@@ -1734,7 +1752,10 @@ 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);
@@ -1839,10 +1860,14 @@ 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 readDeployEnvOverride(context, name) {

package/dist/controllers/project.js

@@ -2,8 +2,8 @@ import { CliError, authRequiredError, featureUnavailableError, usageError, works
 import { renderSummaryLine } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
-import { resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
-import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup } from "../lib/project/setup.js";
+import { inspectProjectBinding, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
+import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
@@ -94,7 +94,7 @@ async function runGitConnect(context, gitUrl, options = {}) {
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env);
 		if (!client) throw authRequiredError();
-		const target = await resolveProjectShowInRealMode(context, workspace, options.project);
+		const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git connect");
 		const repository = await resolveRepositoryForConnect(context, gitUrl);
 		const api = client;
 		const existing = await readFirstSourceRepository(api, target.project.id);
@@ -129,7 +129,7 @@ async function runGitConnect(context, gitUrl, options = {}) {
 			nextSteps: []
 		};
 	}
-	const target = await resolveProjectShowInFixtureMode(context, workspace, options.project);
+	const target = await resolveRequiredProjectInFixtureMode(context, workspace, options.project, "git connect");
 	const repository = await resolveRepositoryForConnect(context, gitUrl);
 	const existingConnection = await context.stateStore.readRepositoryConnection(target.project.id);
 	if (existingConnection) {
@@ -162,7 +162,7 @@ async function runGitDisconnect(context, options = {}) {
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env);
 		if (!client) throw authRequiredError();
-		const target = await resolveProjectShowInRealMode(context, workspace, options.project);
+		const target = await resolveRequiredProjectInRealMode(context, workspace, options.project, "git disconnect");
 		const api = client;
 		const existing = await readFirstSourceRepository(api, target.project.id);
 		if (!existing) throw repoNotConnectedError();
@@ -178,7 +178,7 @@ async function runGitDisconnect(context, options = {}) {
 			nextSteps: []
 		};
 	}
-	const target = await resolveProjectShowInFixtureMode(context, workspace, options.project);
+	const target = await resolveRequiredProjectInFixtureMode(context, workspace, options.project, "git disconnect");
 	const existingConnection = await context.stateStore.readRepositoryConnection(target.project.id);
 	if (!existingConnection) throw repoNotConnectedError();
 	await context.stateStore.clearRepositoryConnection(target.project.id);
@@ -193,6 +193,17 @@ async function runGitDisconnect(context, options = {}) {
 	};
 }
 async function resolveProjectShowInRealMode(context, workspace, explicitProject) {
+	const client = await requireComputeAuth(context.runtime.env);
+	if (!client) throw authRequiredError();
+	return inspectProjectBinding({
+		context,
+		workspace,
+		explicitProject,
+		listProjects: () => listRealWorkspaceProjects(client, workspace),
+		commandName: "project show"
+	});
+}
+async function resolveRequiredProjectInRealMode(context, workspace, explicitProject, commandName) {
 	const client = await requireComputeAuth(context.runtime.env);
 	if (!client) throw authRequiredError();
 	return resolveProjectTarget({
@@ -200,7 +211,7 @@ async function resolveProjectShowInRealMode(context, workspace, explicitProject)
 		workspace,
 		explicitProject,
 		listProjects: () => listRealWorkspaceProjects(client, workspace),
-		remember: false
+		commandName
 	});
 }
 async function listRealProjectsForLink(context, workspace) {
@@ -209,12 +220,21 @@ async function listRealProjectsForLink(context, workspace) {
 	return listRealWorkspaceProjects(client, workspace);
 }
 async function resolveProjectShowInFixtureMode(context, workspace, explicitProject) {
+	return inspectProjectBinding({
+		context,
+		workspace,
+		explicitProject,
+		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
+		commandName: "project show"
+	});
+}
+async function resolveRequiredProjectInFixtureMode(context, workspace, explicitProject, commandName) {
 	return resolveProjectTarget({
 		context,
 		workspace,
 		explicitProject,
 		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
-		remember: false
+		commandName
 	});
 }
 async function listRealWorkspaceProjects(client, workspace) {
@@ -539,11 +559,5 @@ function repoConnectionFixForStatus(status) {
 	if (status === 422) return "Make sure the GitHub App installation has access to this repository.";
 	return "Re-run with --trace for the underlying API response details.";
 }
-function toProjectSummary(project) {
-	return {
-		id: project.id,
-		name: project.name
-	};
-}
 //#endregion
 export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectShow };

package/dist/lib/project/resolution.js

@@ -1,73 +1,31 @@
 import { CliError } from "../../shell/errors.js";
-import { canPrompt } from "../../shell/runtime.js";
+import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "./local-pin.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/lib/project/resolution.ts
 async function resolveProjectTarget(options) {
 	const projects = await options.listProjects();
-	const inferredName = await inferTargetName(options.context.runtime.cwd);
-	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
-		targetName: options.explicitProject,
-		targetNameSource: "explicit"
+	const target = await resolveBoundProjectTarget(options, projects, { allowEnvProjectId: true });
+	if (target) return target;
+	throw await projectSetupRequiredError({
+		cwd: options.context.runtime.cwd,
+		projects,
+		commandName: options.commandName
 	});
-	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping) return rememberIfRequested(options, platformMapping, "platform-mapping");
-	let staleRemembered = false;
-	if (!options.allowCreate) {
-		const rememberedResult = await resolveRememberedProject(options, projects);
-		if (rememberedResult.target) return rememberedResult.target;
-		staleRemembered = rememberedResult.stale;
-	}
-	const packageName = inferredName.source === "package-name" ? inferredName.name : null;
-	if (packageName) {
-		const matches = projects.filter((project) => projectMatchesPackageName(project, packageName));
-		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name", {
-			targetName: packageName,
-			targetNameSource: "package-name"
-		});
-		if (matches.length > 1) return resolveAmbiguousProject(options, matches, packageName, "package-name");
-	}
-	if (options.allowCreate && options.createProject) {
-		if (inferredName.name) {
-			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName.name));
-			if (existing.length === 1) return rememberIfRequested(options, existing[0], inferredName.source, {
-				targetName: inferredName.name,
-				targetNameSource: inferredName.source
-			});
-			if (existing.length > 1) return resolveAmbiguousProject(options, existing, inferredName.name, inferredName.source);
-			return rememberIfRequested(options, await options.createProject(inferredName.name), "created", {
-				targetName: inferredName.name,
-				targetNameSource: inferredName.source
-			});
-		}
-	}
-	if (options.prompt && canPrompt(options.context) && projects.length > 0) return rememberIfRequested(options, await options.prompt.select({
-		message: "Select a project",
-		choices: sortProjects(projects).map((project) => ({
-			label: `${project.name} (${project.id})`,
-			value: project
-		}))
-	}), "prompt");
-	if (staleRemembered && projects.length > 1) throw localStateStaleError();
-	throw projectUnresolvedError();
-}
-async function resolveRememberedProject(options, projects) {
-	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
-	if (!remembered) return {
-		target: null,
-		stale: false
-	};
-	const matched = projects.find((project) => project.id === remembered.id);
-	if (!matched) return {
-		target: null,
-		stale: true
-	};
+}
+async function inspectProjectBinding(options) {
+	const projects = await options.listProjects();
+	const target = await resolveBoundProjectTarget(options, projects, { allowEnvProjectId: false });
+	if (target) return target;
 	return {
-		target: await rememberIfRequested(options, matched, "remembered-local", {
-			targetName: remembered.name,
-			targetNameSource: "remembered-local"
-		}),
-		stale: false
+		workspace: options.workspace,
+		project: null,
+		resolution: { projectSource: "unbound" },
+		...await buildProjectSetupSuggestion({
+			cwd: options.context.runtime.cwd,
+			projects,
+			commandName: options.commandName ?? "project show"
+		})
 	};
 }
 function projectNotFoundError(projectRef, workspace) {
@@ -99,26 +57,39 @@ function projectAmbiguousError(projectRef, matches) {
 		nextSteps
 	});
 }
-function projectUnresolvedError() {
+function localStateStaleError() {
 	return new CliError({
-		code: "PROJECT_UNRESOLVED",
+		code: "LOCAL_STATE_STALE",
 		domain: "project",
-		summary: "No project is resolved for this directory",
-		why: "No project could be resolved from explicit input, platform mappings, remembered local context, or package metadata.",
-		fix: "Pass --project <id-or-name> on the command that needs a project, or add a package.json name that matches an accessible 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 show --project <id-or-name>"]
+		nextSteps: ["prisma-cli project list", "prisma-cli project link <id-or-name>"]
 	});
 }
-function localStateStaleError() {
+async function buildProjectSetupSuggestion(options) {
+	const suggestedName = await inferTargetName(options.cwd);
+	const candidates = sortProjects(options.projects.filter((project) => projectMatchesSuggestedName(project, suggestedName.name))).map(toProjectSummary);
+	return {
+		suggestedProjectName: suggestedName.name,
+		suggestedProjectNameSource: suggestedName.source,
+		candidates,
+		recoveryCommands: buildProjectRecoveryCommands(options.commandName)
+	};
+}
+async function projectSetupRequiredError(options) {
+	const suggestion = await buildProjectSetupSuggestion(options);
 	return new CliError({
-		code: "LOCAL_STATE_STALE",
+		code: "PROJECT_SETUP_REQUIRED",
 		domain: "project",
-		summary: "Remembered project context is stale",
-		why: "The remembered project is no longer available in the selected workspace, and automatic resolution would be ambiguous.",
-		fix: "Pass --project <id-or-name> to choose the project explicitly.",
+		summary: "Choose a Project before running this command",
+		why: `This directory is not linked to a Prisma Project, and ${options.commandName ? `prisma-cli ${options.commandName}` : "this command"} will not choose one from package or directory names.`,
+		fix: "Link the directory to an existing Project, or pass --project <id-or-name> for this command.",
+		meta: { ...suggestion },
 		exitCode: 1,
-		nextSteps: ["prisma-cli project list"]
+		nextSteps: ["prisma-cli project list", ...suggestion.recoveryCommands]
 	});
 }
 async function readPackageName(cwd) {
@@ -157,33 +128,46 @@ function resolveExplicitProject(projectRef, projects, workspace) {
 	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
 	throw projectNotFoundError(projectRef, workspace);
 }
-function resolveAmbiguousProject(options, matches, projectRef, targetNameSource) {
-	if (options.prompt && canPrompt(options.context)) return options.prompt.select({
-		message: "Select a project",
-		choices: sortProjects(matches).map((project) => ({
-			label: `${project.name} (${project.id})`,
-			value: project
-		}))
-	}).then((selected) => rememberIfRequested(options, selected, "prompt", {
-		targetName: projectRef,
-		targetNameSource
-	}));
-	throw projectAmbiguousError(projectRef, matches);
-}
-function projectMatchesPackageName(project, packageName) {
-	return project.id === packageName || project.name === packageName || project.slug === packageName;
+function projectMatchesSuggestedName(project, suggestedName) {
+	return project.id === suggestedName || project.name === suggestedName || project.slug === suggestedName;
 }
 async function resolveDurablePlatformMapping() {
 	return null;
 }
-async function rememberIfRequested(options, project, projectSource, resolutionDetails) {
-	if (options.remember) await options.context.stateStore.setRememberedProject({
-		id: project.id,
-		name: project.name,
-		workspaceId: options.workspace.id
+async function resolveBoundProjectTarget(options, projects, settings) {
+	if (options.explicitProject) return resolvedTarget(options.workspace, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
+		targetName: options.explicitProject,
+		targetNameSource: "explicit"
 	});
+	if (settings.allowEnvProjectId && options.envProjectId) {
+		const project = projects.find((candidate) => candidate.id === options.envProjectId);
+		if (!project) throw projectNotFoundError(options.envProjectId, options.workspace);
+		return resolvedTarget(options.workspace, project, "env", {
+			targetName: options.envProjectId,
+			targetNameSource: "env"
+		});
+	}
+	const localPin = await readLocalResolutionPin(options.context.runtime.cwd);
+	if (localPin.kind === "invalid") throw localStateStaleError();
+	if (localPin.kind === "present") {
+		if (localPin.pin.workspaceId !== options.workspace.id) throw localStateStaleError();
+		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
+		if (!project) throw localStateStaleError();
+		return resolvedTarget(options.workspace, project, "local-pin", {
+			targetName: project.name,
+			targetNameSource: "local-pin"
+		});
+	}
+	const platformMapping = await resolveDurablePlatformMapping();
+	if (platformMapping && platformMapping.workspace.id === options.workspace.id) return resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
+		targetName: platformMapping.name,
+		targetNameSource: "platform-mapping"
+	});
+	return null;
+}
+function resolvedTarget(workspace, project, projectSource, resolutionDetails) {
 	return {
-		workspace: options.workspace,
+		workspace,
 		project: toProjectSummary(project),
 		resolution: {
 			projectSource,
@@ -191,6 +175,11 @@ async function rememberIfRequested(options, project, projectSource, resolutionDe
 		}
 	};
 }
+function buildProjectRecoveryCommands(commandName) {
+	const commands = ["prisma-cli project link <id-or-name>"];
+	if (commandName) commands.push(`prisma-cli ${commandName} --project <id-or-name>`);
+	return commands;
+}
 function toProjectSummary(project) {
 	return {
 		id: project.id,
@@ -198,4 +187,4 @@ function toProjectSummary(project) {
 	};
 }
 //#endregion
-export { inferTargetName, projectAmbiguousError, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };
+export { inferTargetName, inspectProjectBinding, projectAmbiguousError, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };

package/dist/lib/project/setup.js

@@ -1,6 +1,6 @@
 import { CliError, usageError } from "../../shell/errors.js";
-import { projectAmbiguousError, projectNotFoundError } from "./resolution.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, writeLocalResolutionPin } from "./local-pin.js";
+import { projectAmbiguousError, projectNotFoundError } from "./resolution.js";
 //#region src/lib/project/setup.ts
 function isValidProjectSetupName(projectName) {
 	return projectName.trim().length > 0;

package/dist/presenters/project.js

@@ -30,8 +30,35 @@ function serializeProjectList(result) {
 	});
 }
 function renderProjectShow(context, descriptor, result) {
+	if (result.project === null) return renderShow({
+		title: "No Project linked to this directory.",
+		descriptor,
+		fields: [
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "project",
+				value: "unbound",
+				tone: "warning"
+			},
+			{
+				key: "suggested",
+				value: `${result.suggestedProjectName} (${formatSuggestionSource(result.suggestedProjectNameSource)})`
+			},
+			{
+				key: "match",
+				value: formatCandidateList(result.candidates)
+			},
+			{
+				key: "next",
+				value: result.recoveryCommands[0] ?? "prisma-cli project link <id-or-name>"
+			}
+		]
+	}, context.ui);
 	return renderShow({
-		title: "Showing the project Prisma resolves for this directory.",
+		title: "Showing this directory's Project binding.",
 		descriptor,
 		fields: [
 			{
@@ -117,13 +144,21 @@ function formatProjectSource(source) {
 		case "env": return "environment";
 		case "local-pin": return "local pin";
 		case "platform-mapping": return "platform mapping";
-		case "remembered-local": return "remembered local context";
-		case "package-name": return "package name";
-		case "directory-name": return "directory name";
 		case "created": return "created";
 		case "prompt": return "prompt";
+		case "unbound": return "unbound";
 	}
 }
+function formatSuggestionSource(source) {
+	switch (source) {
+		case "package-name": return "package name";
+		case "directory-name": return "directory name";
+	}
+}
+function formatCandidateList(candidates) {
+	if (candidates.length === 0) return "none";
+	return candidates.map((project) => project.name).join(", ");
+}
 function formatGitConnectionDetail(status) {
 	switch (status) {
 		case "active": return "GitHub branch automation is active for this project.";

package/dist/shell/command-meta.js

@@ -95,7 +95,7 @@ const DESCRIPTORS = [
 			"project",
 			"show"
 		],
-		description: "Show which project is active for this directory",
+		description: "Show this directory's Project binding",
 		examples: ["prisma-cli project show", "prisma-cli project show --project proj_123 --json"]
 	},
 	{
@@ -212,7 +212,8 @@ const DESCRIPTORS = [
 			"prisma-cli app deploy --app my-app --env DATABASE_URL=postgresql://example",
 			"prisma-cli app deploy --app my-app --framework nextjs --http-port 3000",
 			"prisma-cli app deploy --branch feat-login --framework hono",
-			"pnpm dlx skills@latest add prisma/prisma-cli/skills#cli-v<cli-version> --all"
+			"pnpm dlx skills@latest add prisma/prisma-cli/skills#cli-v<cli-version> --all",
+			"prisma-cli app deploy --framework bun --entry src/server.ts"
 		]
 	},
 	{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.39.1",
+  "version": "3.0.0-dev.41.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {