@prisma/cli 3.0.0-dev.99.1 → 8.0.0-rc.2

package/dist/lib/project/interactive-setup.js

@@ -1,56 +0,0 @@
-import { usageError } from "../../shell/errors.js";
-import { selectPrompt, textPrompt } from "../../shell/prompt.js";
-import { inferTargetName, sortProjects } from "./resolution.js";
-import { toProjectSummary, validateProjectSetupNameText } from "./setup.js";
-//#region src/lib/project/interactive-setup.ts
-async function promptForProjectSetupChoice(options) {
-	const sortedProjects = sortProjects(options.projects);
-	const projectNames = sortedProjects.map((project) => project.name);
-	const duplicateNames = new Set(projectNames.filter((name, index) => projectNames.indexOf(name) !== index));
-	const choice = await selectPrompt({
-		input: options.context.runtime.stdin,
-		output: options.context.runtime.stderr,
-		message: "Which Project should this directory use?",
-		choices: [
-			...sortedProjects.map((project) => ({
-				label: duplicateNames.has(project.name) ? `${project.name} (${project.id})` : project.name,
-				value: {
-					kind: "project",
-					project
-				}
-			})),
-			{
-				label: "Create a new Project",
-				value: { kind: "create" }
-			},
-			{
-				label: "Cancel",
-				value: { kind: "cancel" }
-			}
-		]
-	});
-	if (choice.kind === "cancel") throw usageError("Project setup canceled", options.cancel.why, options.cancel.fix, options.cancel.nextSteps, "project");
-	if (choice.kind === "project") return {
-		project: toProjectSummary(choice.project),
-		action: "linked",
-		targetName: choice.project.name,
-		targetNameSource: "prompt"
-	};
-	const suggestedName = await inferTargetName(options.context.runtime.cwd, options.context.runtime.signal);
-	const rawName = await textPrompt({
-		input: options.context.runtime.stdin,
-		output: options.context.runtime.stderr,
-		message: "Project name",
-		placeholder: suggestedName.name,
-		validate: (value) => validateProjectSetupNameText(value, suggestedName.name)
-	});
-	const projectName = rawName.trim() || suggestedName.name;
-	return {
-		project: toProjectSummary(await options.createProject(projectName)),
-		action: "created",
-		targetName: projectName,
-		targetNameSource: rawName.trim() ? "prompt" : suggestedName.source
-	};
-}
-//#endregion
-export { promptForProjectSetupChoice };

package/dist/lib/project/local-pin.js

@@ -1,200 +0,0 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { Result, TaggedError, UnhandledException } from "better-result";
-//#region src/lib/project/local-pin.ts
-const LOCAL_RESOLUTION_PIN_RELATIVE_PATH = ".prisma/local.json";
-var LocalResolutionPinInvalidJsonError = class extends TaggedError("LocalResolutionPinInvalidJsonError")() {
-	constructor(cause) {
-		super({
-			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} contains invalid JSON.`,
-			cause,
-			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
-		});
-	}
-};
-var LocalResolutionPinInvalidShapeError = class extends TaggedError("LocalResolutionPinInvalidShapeError")() {
-	constructor() {
-		super({
-			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} must contain workspaceId and projectId string fields only.`,
-			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
-		});
-	}
-};
-var LocalResolutionPinReadAbortedError = class extends TaggedError("LocalResolutionPinReadAbortedError")() {
-	constructor(cause) {
-		super({
-			message: `Reading ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} was aborted.`,
-			cause,
-			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
-		});
-	}
-};
-var LocalResolutionPinSerializationError = class extends TaggedError("LocalResolutionPinSerializationError")() {
-	constructor(cause) {
-		super({
-			message: `Could not serialize ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
-			cause,
-			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
-		});
-	}
-};
-var LocalResolutionPinWriteAbortedError = class extends TaggedError("LocalResolutionPinWriteAbortedError")() {
-	constructor(cause) {
-		super({
-			message: `Writing ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} was aborted.`,
-			cause,
-			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
-		});
-	}
-};
-var LocalResolutionPinWriteFailedError = class extends TaggedError("LocalResolutionPinWriteFailedError")() {
-	constructor(operation, cause) {
-		super({
-			message: `Could not write ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
-			cause,
-			operation,
-			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
-		});
-	}
-};
-var LocalResolutionPinGitignoreUpdateAbortedError = class extends TaggedError("LocalResolutionPinGitignoreUpdateAbortedError")() {
-	constructor(cause) {
-		super({
-			message: "Updating .gitignore for the local Project binding was aborted.",
-			cause,
-			gitignorePath: ".gitignore"
-		});
-	}
-};
-var LocalResolutionPinGitignoreUpdateFailedError = class extends TaggedError("LocalResolutionPinGitignoreUpdateFailedError")() {
-	constructor(operation, cause) {
-		super({
-			message: "Could not update .gitignore for the local Project binding.",
-			cause,
-			operation,
-			gitignorePath: ".gitignore"
-		});
-	}
-};
-async function readLocalResolutionPin(cwd, signal) {
-	return Result.gen(async function* () {
-		yield* ensureLocalResolutionPinReadNotAborted(signal);
-		const file = yield* Result.await(readLocalResolutionPinFile(cwd, signal));
-		if (file.kind === "missing") return Result.ok({ kind: "missing" });
-		const parsed = yield* parseLocalResolutionPin(file.raw);
-		if (!isLocalResolutionPin(parsed)) return Result.err(new LocalResolutionPinInvalidShapeError());
-		return Result.ok({
-			kind: "present",
-			pin: parsed
-		});
-	});
-}
-function ensureLocalResolutionPinReadNotAborted(signal) {
-	return Result.try({
-		try: () => signal?.throwIfAborted(),
-		catch: (cause) => new LocalResolutionPinReadAbortedError(cause)
-	});
-}
-async function readLocalResolutionPinFile(cwd, signal) {
-	const readResult = await Result.tryPromise({
-		try: () => readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), {
-			encoding: "utf8",
-			signal
-		}),
-		catch: (cause) => signal?.aborted ? new LocalResolutionPinReadAbortedError(cause) : new UnhandledException({ cause })
-	});
-	if (readResult.isErr()) {
-		if (readResult.error instanceof UnhandledException && readResult.error.cause.code === "ENOENT") return Result.ok({ kind: "missing" });
-		return Result.err(readResult.error);
-	}
-	return Result.ok({
-		kind: "present",
-		raw: readResult.value
-	});
-}
-function parseLocalResolutionPin(raw) {
-	return Result.try({
-		try: () => JSON.parse(raw),
-		catch: (cause) => cause instanceof SyntaxError ? new LocalResolutionPinInvalidJsonError(cause) : new UnhandledException({ cause })
-	});
-}
-async function writeLocalResolutionPin(cwd, pin, signal) {
-	return Result.gen(async function* () {
-		const prismaDir = path.join(cwd, ".prisma");
-		yield* ensureLocalResolutionPinWriteNotAborted(signal);
-		yield* Result.await(writeLocalResolutionPinBoundary(() => mkdir(prismaDir, { recursive: true }), "create-directory", signal));
-		const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
-		const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
-		const serialized = yield* serializeLocalResolutionPin(pin);
-		yield* Result.await(writeLocalResolutionPinBoundary(() => writeFile(tmpPath, serialized, {
-			encoding: "utf8",
-			signal
-		}), "write-temp-file", signal));
-		yield* ensureLocalResolutionPinWriteNotAborted(signal);
-		yield* Result.await(writeLocalResolutionPinBoundary(() => rename(tmpPath, pinPath), "rename-temp-file", signal));
-		return Result.ok(void 0);
-	});
-}
-async function ensureLocalResolutionPinGitignore(cwd, signal) {
-	const gitignorePath = path.join(cwd, ".gitignore");
-	let existing = null;
-	const notAborted = ensureLocalResolutionPinGitignoreUpdateNotAborted(signal);
-	if (notAborted.isErr()) return Result.err(notAborted.error);
-	const existingResult = await Result.tryPromise({
-		try: () => readFile(gitignorePath, {
-			encoding: "utf8",
-			signal
-		}),
-		catch: (cause) => signal?.aborted ? new LocalResolutionPinGitignoreUpdateAbortedError(cause) : new LocalResolutionPinGitignoreUpdateFailedError("read", cause)
-	});
-	if (existingResult.isErr()) if (existingResult.error instanceof LocalResolutionPinGitignoreUpdateFailedError && existingResult.error.cause.code === "ENOENT") existing = null;
-	else return Result.err(existingResult.error);
-	else existing = existingResult.value;
-	if (existing === null) return writeLocalResolutionPinGitignore(gitignorePath, ".prisma/\n", signal);
-	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return Result.ok(void 0);
-	return writeLocalResolutionPinGitignore(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, signal);
-}
-function ensureLocalResolutionPinWriteNotAborted(signal) {
-	return Result.try({
-		try: () => signal?.throwIfAborted(),
-		catch: (cause) => new LocalResolutionPinWriteAbortedError(cause)
-	});
-}
-function serializeLocalResolutionPin(pin) {
-	return Result.try({
-		try: () => `${JSON.stringify(pin, null, 2)}\n`,
-		catch: (cause) => new LocalResolutionPinSerializationError(cause)
-	});
-}
-function writeLocalResolutionPinBoundary(run, operation, signal) {
-	return Result.tryPromise({
-		try: async () => {
-			await run();
-		},
-		catch: (cause) => signal?.aborted ? new LocalResolutionPinWriteAbortedError(cause) : new LocalResolutionPinWriteFailedError(operation, cause)
-	});
-}
-function ensureLocalResolutionPinGitignoreUpdateNotAborted(signal) {
-	return Result.try({
-		try: () => signal?.throwIfAborted(),
-		catch: (cause) => new LocalResolutionPinGitignoreUpdateAbortedError(cause)
-	});
-}
-function writeLocalResolutionPinGitignore(gitignorePath, contents, signal) {
-	return Result.tryPromise({
-		try: () => writeFile(gitignorePath, contents, {
-			encoding: "utf8",
-			signal
-		}),
-		catch: (cause) => signal?.aborted ? new LocalResolutionPinGitignoreUpdateAbortedError(cause) : new LocalResolutionPinGitignoreUpdateFailedError("write", cause)
-	});
-}
-function isLocalResolutionPin(value) {
-	if (!value || typeof value !== "object") return false;
-	const keys = Object.keys(value);
-	if (keys.length !== 2 || !keys.includes("workspaceId") || !keys.includes("projectId")) return false;
-	const candidate = value;
-	return typeof candidate.workspaceId === "string" && candidate.workspaceId.trim().length > 0 && typeof candidate.projectId === "string" && candidate.projectId.trim().length > 0;
-}
-//#endregion
-export { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, readLocalResolutionPin, writeLocalResolutionPin };

package/dist/lib/project/resolution.js

@@ -1,386 +0,0 @@
-import { CliError } from "../../shell/errors.js";
-import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "./local-pin.js";
-import { formatCommandArgument } from "../../shell/command-arguments.js";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { Result, TaggedError, matchError } from "better-result";
-//#region src/lib/project/resolution.ts
-var ProjectNotFoundError = class extends TaggedError("ProjectNotFoundError")() {
-	constructor(projectRef, workspace) {
-		super({
-			message: `Project "${projectRef}" was not found in workspace "${workspace.name}".`,
-			projectRef,
-			workspace
-		});
-	}
-};
-var ProjectAmbiguousError = class extends TaggedError("ProjectAmbiguousError")() {
-	constructor(projectRef, matches) {
-		super({
-			message: projectRef ? `Multiple projects matched "${projectRef}".` : "Multiple projects matched the current directory context.",
-			projectRef,
-			matches
-		});
-	}
-};
-var LocalStateStaleError = class extends TaggedError("LocalStateStaleError")() {
-	constructor() {
-		super({
-			message: `The target recorded in ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} is no longer available in the selected workspace.`,
-			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
-		});
-	}
-};
-var LocalProjectWorkspaceMismatchError = class extends TaggedError("LocalProjectWorkspaceMismatchError")() {
-	constructor(options) {
-		super({
-			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} links this directory to project ${options.pinnedProjectId} in workspace ${options.pinnedWorkspaceId}, but the active workspace is "${options.activeWorkspace.name}" (${options.activeWorkspace.id}).`,
-			pinnedWorkspaceId: options.pinnedWorkspaceId,
-			pinnedProjectId: options.pinnedProjectId,
-			activeWorkspace: options.activeWorkspace
-		});
-	}
-};
-var ProjectSetupRequiredError = class extends TaggedError("ProjectSetupRequiredError")() {
-	constructor(options) {
-		const commandLabel = options.commandName ? `prisma-cli ${options.commandName}` : "this command";
-		super({
-			message: `This directory is not linked to a Prisma Project, and ${commandLabel} will not choose one from package or directory names.`,
-			commandName: options.commandName,
-			suggestion: options.suggestion
-		});
-	}
-};
-async function resolveProjectTarget(options) {
-	return Result.gen(async function* () {
-		const localPin = yield* Result.await(readImplicitLocalPin(options, { allowEnvProjectId: true }));
-		const projects = await options.listProjects();
-		const target = yield* Result.await(resolveBoundProjectTarget(options, projects, {
-			allowEnvProjectId: true,
-			localPin
-		}));
-		if (target) return Result.ok(target);
-		return Result.err(await projectSetupRequiredError({
-			cwd: options.context.runtime.cwd,
-			projects,
-			commandName: options.commandName,
-			signal: options.context.runtime.signal
-		}));
-	});
-}
-async function inspectProjectBinding(options) {
-	return Result.gen(async function* () {
-		const localPin = yield* Result.await(readImplicitLocalPin(options, { allowEnvProjectId: false }));
-		const projects = await options.listProjects();
-		const target = yield* Result.await(resolveBoundProjectTarget(options, projects, {
-			allowEnvProjectId: false,
-			localPin
-		}));
-		if (target) return Result.ok(target);
-		return Result.ok({
-			workspace: options.workspace,
-			project: null,
-			localBinding: { status: "not-linked" },
-			resolution: { projectSource: "unbound" },
-			...await buildProjectSetupSuggestion({
-				cwd: options.context.runtime.cwd,
-				projects,
-				commandName: options.commandName ?? "project show",
-				signal: options.context.runtime.signal
-			})
-		});
-	});
-}
-function projectNotFoundError(projectRef, workspace) {
-	return projectResolutionErrorToCliError(new ProjectNotFoundError(projectRef, workspace));
-}
-function projectNotFoundCliError(projectRef, workspace) {
-	return new CliError({
-		code: "PROJECT_NOT_FOUND",
-		domain: "project",
-		summary: "Project not found",
-		why: `The project "${projectRef}" does not exist in workspace "${workspace.name}" or is not accessible.`,
-		fix: "Pass a project id or name from prisma-cli project list.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli project list"]
-	});
-}
-function projectAmbiguousError(projectRef, matches) {
-	return projectResolutionErrorToCliError(new ProjectAmbiguousError(projectRef, matches));
-}
-function projectAmbiguousCliError(projectRef, matches) {
-	const firstMatch = matches[0];
-	const nextSteps = ["prisma-cli project list"];
-	if (firstMatch) nextSteps.push(`prisma-cli app deploy --project ${firstMatch.id}`);
-	return new CliError({
-		code: "PROJECT_AMBIGUOUS",
-		domain: "project",
-		summary: "Project resolution is ambiguous",
-		why: projectRef ? `Multiple projects matched "${projectRef}".` : "Multiple projects matched the current directory context.",
-		fix: "Pass --project <id-or-name> to choose the project explicitly.",
-		meta: { matches: matches.map((project) => ({
-			id: project.id,
-			name: project.name
-		})) },
-		exitCode: 1,
-		nextSteps
-	});
-}
-function localStateStaleCliError() {
-	return new CliError({
-		code: "LOCAL_STATE_STALE",
-		domain: "project",
-		summary: "Local project binding is stale",
-		why: `The target recorded in ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} is no longer available in the selected workspace.`,
-		fix: `Delete ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}, then choose a Project explicitly.`,
-		meta: { pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH },
-		exitCode: 1,
-		nextSteps: ["prisma-cli project list", "prisma-cli project link <id-or-name>"]
-	});
-}
-function localProjectWorkspaceMismatchError(options) {
-	return projectResolutionErrorToCliError(new LocalProjectWorkspaceMismatchError(options));
-}
-function localProjectWorkspaceMismatchCliError(options) {
-	return new CliError({
-		code: "LOCAL_PROJECT_WORKSPACE_MISMATCH",
-		domain: "project",
-		summary: "Project link uses another workspace",
-		why: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} links this directory to project ${options.pinnedProjectId} in workspace ${options.pinnedWorkspaceId}, but your current CLI session is workspace "${options.activeWorkspace.name}" (${options.activeWorkspace.id}).`,
-		fix: "Switch to the linked workspace, or relink this directory to a project in the current workspace.",
-		meta: {
-			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
-			pinnedWorkspaceId: options.pinnedWorkspaceId,
-			pinnedProjectId: options.pinnedProjectId,
-			activeWorkspaceId: options.activeWorkspace.id,
-			activeWorkspaceName: options.activeWorkspace.name
-		},
-		exitCode: 1,
-		nextSteps: [
-			`prisma-cli auth workspace use ${options.pinnedWorkspaceId}`,
-			"prisma-cli project list",
-			"prisma-cli project link <id-or-name>"
-		]
-	});
-}
-/**
-* Converts expected project-resolution variants to command-boundary CliErrors.
-* `LocalResolutionPinReadAbortedError` and `UnhandledException` intentionally
-* propagate as exceptions; callers such as `resolveProjectShowInRealMode`
-* throw this helper's result, so passthrough variants should keep bubbling.
-*/
-function projectResolutionErrorToCliError(error) {
-	return matchError(error, {
-		ProjectNotFoundError: (error) => projectNotFoundCliError(error.projectRef, error.workspace),
-		ProjectAmbiguousError: (error) => projectAmbiguousCliError(error.projectRef, error.matches),
-		ProjectSetupRequiredError: (error) => projectSetupRequiredCliError(error),
-		LocalStateStaleError: () => localStateStaleCliError(),
-		LocalProjectWorkspaceMismatchError: (error) => localProjectWorkspaceMismatchCliError({
-			pinnedWorkspaceId: error.pinnedWorkspaceId,
-			pinnedProjectId: error.pinnedProjectId,
-			activeWorkspace: error.activeWorkspace
-		}),
-		LocalResolutionPinReadAbortedError: (error) => {
-			throw error;
-		},
-		UnhandledException: (error) => {
-			throw error;
-		}
-	});
-}
-async function buildProjectSetupSuggestion(options) {
-	const suggestedName = await inferTargetName(options.cwd, options.signal);
-	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 ProjectSetupRequiredError({
-		commandName: options.commandName,
-		suggestion
-	});
-}
-function projectSetupRequiredCliError(error) {
-	const suggestion = error.suggestion;
-	return new CliError({
-		code: "PROJECT_SETUP_REQUIRED",
-		domain: "project",
-		summary: "Choose a Project before running this command",
-		why: error.message,
-		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", ...suggestion.recoveryCommands],
-		nextActions: buildProjectSetupNextActions({
-			commandName: error.commandName,
-			suggestedProjectName: suggestion.suggestedProjectName
-		})
-	});
-}
-function buildProjectSetupNextActions(options = {}) {
-	const recoveryCommands = buildProjectRecoveryCommands(options.commandName);
-	const linkCommand = recoveryCommands[0] ?? "prisma-cli project link <id-or-name>";
-	const retryCommand = recoveryCommands[1];
-	const actions = [{
-		kind: "user-choice",
-		journey: "project-setup",
-		label: "Ask the user whether to link an existing Project or create a new one",
-		commands: ["prisma-cli project list", ...recoveryCommands],
-		reason: options.reason ?? "This directory is not linked to a Prisma Project. Package and directory names are suggestions only, not a safe Project selection."
-	}, {
-		kind: "run-command",
-		journey: "project-setup",
-		label: "Link the chosen Project",
-		command: linkCommand,
-		reason: "Linking writes the durable local Project binding for this directory."
-	}];
-	const createCommand = options.createCommand ?? (options.suggestedProjectName ? `prisma-cli project create ${formatCommandArgument(options.suggestedProjectName)}` : void 0);
-	if (createCommand) actions.push({
-		kind: "run-command",
-		journey: "project-setup",
-		label: "Create and link a new Project",
-		command: createCommand,
-		reason: "Use this when the user wants a new Prisma Project instead of an existing one."
-	});
-	if (options.commandName) actions.push({
-		kind: "run-command",
-		journey: "recover",
-		label: "Retry with an explicit Project",
-		command: retryCommand ?? `prisma-cli ${options.commandName} --project <id-or-name>`
-	});
-	return actions;
-}
-async function readPackageName(cwd, signal) {
-	signal?.throwIfAborted();
-	try {
-		const raw = await readFile(path.join(cwd, "package.json"), {
-			encoding: "utf8",
-			signal
-		});
-		const parsed = JSON.parse(raw);
-		if (!parsed || typeof parsed !== "object") return null;
-		const packageName = "name" in parsed ? parsed.name : null;
-		return typeof packageName === "string" && packageName.trim().length > 0 ? packageName.trim() : null;
-	} catch (error) {
-		if (error.code === "ENOENT") return null;
-		if (error instanceof SyntaxError) return null;
-		throw error;
-	}
-}
-async function inferTargetName(cwd, signal) {
-	const packageName = await readPackageName(cwd, signal);
-	if (packageName && isValidInferredTargetName(packageName)) return {
-		name: packageName,
-		source: "package-name"
-	};
-	return {
-		name: path.basename(cwd),
-		source: "directory-name"
-	};
-}
-function isValidInferredTargetName(value) {
-	return /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value);
-}
-function sortProjects(projects) {
-	return projects.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
-}
-function resolveExplicitProject(projectRef, projects, workspace) {
-	const matches = projects.filter((project) => project.id === projectRef || project.name === projectRef);
-	if (matches.length === 1) return Result.ok(matches[0]);
-	if (matches.length > 1) return Result.err(new ProjectAmbiguousError(projectRef, matches));
-	return Result.err(new ProjectNotFoundError(projectRef, workspace));
-}
-function projectMatchesSuggestedName(project, suggestedName) {
-	return project.id === suggestedName || project.name === suggestedName || project.slug === suggestedName;
-}
-async function resolveDurablePlatformMapping() {
-	return null;
-}
-async function resolveBoundProjectTarget(options, projects, settings) {
-	if (options.explicitProject) {
-		const projectResult = resolveExplicitProject(options.explicitProject, projects, options.workspace);
-		if (projectResult.isErr()) return Result.err(projectResult.error);
-		return Result.ok(resolvedTarget(options.workspace, projectResult.value, "explicit", {
-			targetName: options.explicitProject,
-			targetNameSource: "explicit"
-		}));
-	}
-	if (settings.allowEnvProjectId && options.envProjectId) {
-		const project = projects.find((candidate) => candidate.id === options.envProjectId);
-		if (!project) return Result.err(new ProjectNotFoundError(options.envProjectId, options.workspace));
-		return Result.ok(resolvedTarget(options.workspace, project, "env", {
-			targetName: options.envProjectId,
-			targetNameSource: "env"
-		}));
-	}
-	const localPin = settings.localPin;
-	if (!localPin) return Result.ok(null);
-	if (localPin.kind === "present") {
-		if (localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({
-			pinnedWorkspaceId: localPin.pin.workspaceId,
-			pinnedProjectId: localPin.pin.projectId,
-			activeWorkspace: options.workspace
-		}));
-		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
-		if (!project) return Result.err(new LocalStateStaleError());
-		return Result.ok(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 Result.ok(resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
-		targetName: platformMapping.name,
-		targetNameSource: "platform-mapping"
-	}));
-	return Result.ok(null);
-}
-async function readImplicitLocalPin(options, settings) {
-	if (options.explicitProject || settings.allowEnvProjectId && options.envProjectId) return Result.ok(null);
-	const localPinResult = await readLocalResolutionPin(options.projectDir ?? options.context.runtime.cwd, options.context.runtime.signal);
-	if (localPinResult.isErr()) return Result.err(localPinReadErrorToProjectError(localPinResult.error));
-	const localPin = localPinResult.value;
-	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({
-		pinnedWorkspaceId: localPin.pin.workspaceId,
-		pinnedProjectId: localPin.pin.projectId,
-		activeWorkspace: options.workspace
-	}));
-	return Result.ok(localPin);
-}
-function localPinReadErrorToProjectError(error) {
-	return matchError(error, {
-		LocalResolutionPinInvalidJsonError: () => new LocalStateStaleError(),
-		LocalResolutionPinInvalidShapeError: () => new LocalStateStaleError(),
-		LocalResolutionPinReadAbortedError: (error) => error,
-		UnhandledException: (error) => error
-	});
-}
-function resolvedTarget(workspace, project, projectSource, resolutionDetails) {
-	return {
-		workspace,
-		project: toProjectSummary(project),
-		resolution: {
-			projectSource,
-			...resolutionDetails
-		}
-	};
-}
-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,
-		name: project.name,
-		...project.url ? { url: project.url } : {}
-	};
-}
-//#endregion
-export { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, localProjectWorkspaceMismatchError, projectAmbiguousError, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };