create-prisma 0.11.2 → 0.11.3

package/dist/json-output-DzDD1nb9.mjs

@@ -0,0 +1,2131 @@
+#!/usr/bin/env node
+import { Cause, Clock, Context, Effect, Exit, FileSystem, Layer, ManagedRuntime, Option, Ref, Result, Schema, SchemaTransformation } from "effect";
+import { cancel, confirm, intro, isCancel, log, note, outro, select, spinner, taskLog, text } from "@clack/prompts";
+import { NodeChildProcessSpawner, NodeFileSystem, NodePath, NodeStdio, NodeTerminal } from "@effect/platform-node-shared";
+import { execa } from "execa";
+import { createInterface } from "node:readline";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { PostHog } from "posthog-node";
+import Handlebars from "handlebars";
+import { fileURLToPath } from "node:url";
+import { Writable } from "node:stream";
+import { styleText } from "node:util";
+
+//#region src/create-outcome.ts
+const CreateFailureStageSchema = Schema.Literals([
+	"validate_input",
+	"collect_context",
+	"scaffold_template",
+	"initialize_prisma",
+	"configure_project",
+	"install_dependencies",
+	"initialize_agent_skills",
+	"emit_contract",
+	"plan_migration",
+	"initialize_git",
+	"authenticate",
+	"select_workspace",
+	"check_project_name",
+	"build",
+	"composer_deploy",
+	"unknown"
+]);
+const CreateFailureReasonSchema = Schema.Literals([
+	"invalid_input",
+	"unsupported_node_version",
+	"invalid_project_name",
+	"target_path_not_directory",
+	"target_directory_not_empty",
+	"unsupported_configuration",
+	"template_scaffold_failed",
+	"prisma_init_failed",
+	"project_configuration_failed",
+	"dependency_install_failed",
+	"agent_skills_init_failed",
+	"contract_emit_failed",
+	"migration_plan_failed",
+	"git_initialization_failed",
+	"prisma_auth_command_failed",
+	"not_authenticated",
+	"authentication_failed",
+	"workspace_missing",
+	"workspace_mismatch",
+	"workspace_selection_failed",
+	"project_lookup_failed",
+	"project_name_collision",
+	"build_failed",
+	"composer_deploy_failed",
+	"unexpected_error"
+]);
+const CreateCancellationStageSchema = Schema.Literals([
+	"project_name",
+	"template",
+	"database_provider",
+	"authoring_style",
+	"package_manager",
+	"deployment_intent",
+	"select_workspace"
+]);
+var CreateCancellationError = class extends Schema.TaggedError()("CreateCancellationError", {
+	stage: CreateCancellationStageSchema,
+	message: Schema.optionalKey(Schema.String)
+}) {
+	constructor(options) {
+		super({
+			message: "Operation cancelled.",
+			...options
+		});
+	}
+};
+var CreateFailure = class extends Schema.TaggedError()("CreateFailure", {
+	stage: CreateFailureStageSchema,
+	reason: CreateFailureReasonSchema,
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect()),
+	errorReported: Schema.optionalKey(Schema.Boolean)
+}) {};
+var PrismaCliCommandError = class extends Schema.TaggedError()("PrismaCliCommandError", {
+	message: Schema.String,
+	command: Schema.optionalKey(Schema.String),
+	code: Schema.optionalKey(Schema.String),
+	stderr: Schema.optionalKey(Schema.String),
+	exitCode: Schema.optionalKey(Schema.Number)
+}) {
+	prismaCliCommand = this.command;
+	prismaCliErrorCode = this.code;
+};
+
+//#endregion
+//#region src/types.ts
+const databaseProviders = ["postgres", "mongo"];
+const databaseProviderInputs = [
+	"postgres",
+	"postgresql",
+	"mongo",
+	"mongodb"
+];
+const packageManagers = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun",
+	"deno"
+];
+const authoringStyles = ["psl", "typescript"];
+const createTemplates = [
+	"minimal",
+	"hono",
+	"elysia",
+	"nest",
+	"next",
+	"svelte",
+	"astro",
+	"nuxt",
+	"tanstack-start"
+];
+const DatabaseProviderInputSchema = Schema.Literals(databaseProviderInputs);
+const DatabaseProviderSchema = Schema.Literals(databaseProviders);
+const PackageManagerSchema = Schema.Literals(packageManagers);
+const AuthoringStyleSchema = Schema.Literals(authoringStyles);
+const CreateTemplateSchema = Schema.Literals(createTemplates);
+const OptionalBoolean = Schema.optionalKey(Schema.Boolean);
+const OptionalTrimmedString = Schema.optionalKey(Schema.Trim);
+const OptionalNonEmptyTrimmedString = Schema.optionalKey(Schema.Trim.pipe(Schema.decodeTo(Schema.NonEmptyString, SchemaTransformation.passthrough())));
+const CommonCommandOptionsSchema = Schema.Struct({
+	yes: OptionalBoolean,
+	verbose: OptionalBoolean,
+	json: OptionalBoolean
+});
+const PrismaSetupOptionsSchema = Schema.Struct({
+	provider: Schema.optionalKey(DatabaseProviderSchema),
+	authoring: Schema.optionalKey(AuthoringStyleSchema),
+	packageManager: Schema.optionalKey(PackageManagerSchema),
+	deploy: OptionalBoolean,
+	workspace: OptionalNonEmptyTrimmedString
+});
+const PrismaSetupCommandInputSchema = Schema.Struct({
+	...CommonCommandOptionsSchema.fields,
+	...PrismaSetupOptionsSchema.fields
+});
+const CreateScaffoldOptionsSchema = Schema.Struct({
+	name: OptionalTrimmedString,
+	template: Schema.optionalKey(CreateTemplateSchema),
+	force: OptionalBoolean
+});
+const CreateCommandInputSchema = Schema.Struct({
+	...PrismaSetupCommandInputSchema.fields,
+	...CreateScaffoldOptionsSchema.fields
+});
+const decodeCreateCommandInput = Schema.decodeUnknownEffect(CreateCommandInputSchema);
+function normalizeDatabaseProvider(value) {
+	switch (value) {
+		case "postgresql": return "postgres";
+		case "mongodb": return "mongo";
+		default: return value;
+	}
+}
+
+//#endregion
+//#region src/result.ts
+const CREATE_PRISMA_RESULT_SCHEMA_VERSION = 1;
+const PrismaWorkspaceSchema = Schema.Struct({
+	id: Schema.String,
+	name: Schema.NullOr(Schema.String)
+});
+const ComposerDeployResultSchema = Schema.Struct({
+	appName: Schema.String,
+	appUrl: Schema.optionalKey(Schema.String),
+	serviceId: Schema.optionalKey(Schema.String),
+	workspace: Schema.optionalKey(PrismaWorkspaceSchema),
+	project: Schema.Struct({
+		id: Schema.optionalKey(Schema.String),
+		name: Schema.String,
+		consoleUrl: Schema.optionalKey(Schema.String)
+	})
+});
+const CreateNextStepSchema = Schema.Struct({
+	command: Schema.String,
+	description: Schema.String
+});
+const CreateProjectResultSchema = Schema.Struct({
+	name: Schema.String,
+	path: Schema.String,
+	template: CreateTemplateSchema,
+	databaseProvider: DatabaseProviderSchema,
+	authoring: AuthoringStyleSchema,
+	packageManager: PackageManagerSchema
+});
+const CreateCommandFailureStageSchema = Schema.Union([
+	CreateFailureStageSchema,
+	CreateCancellationStageSchema,
+	Schema.Literal("parse_arguments")
+]);
+const CreateCommandSuccessResultSchema = Schema.Struct({
+	schemaVersion: Schema.Literal(CREATE_PRISMA_RESULT_SCHEMA_VERSION),
+	ok: Schema.Literal(true),
+	project: CreateProjectResultSchema,
+	deployment: Schema.NullOr(ComposerDeployResultSchema),
+	nextSteps: Schema.Array(CreateNextStepSchema),
+	warnings: Schema.Array(Schema.String)
+});
+const CreateCommandFailureResultSchema = Schema.Struct({
+	schemaVersion: Schema.Literal(CREATE_PRISMA_RESULT_SCHEMA_VERSION),
+	ok: Schema.Literal(false),
+	error: Schema.Struct({
+		stage: CreateCommandFailureStageSchema,
+		message: Schema.String
+	}),
+	project: Schema.optionalKey(CreateProjectResultSchema)
+});
+const CreateCommandResultSchema = Schema.Union([CreateCommandSuccessResultSchema, CreateCommandFailureResultSchema]);
+function createCommandFailureResult(stage, message, project) {
+	return {
+		schemaVersion: CREATE_PRISMA_RESULT_SCHEMA_VERSION,
+		ok: false,
+		error: {
+			stage,
+			message
+		},
+		...project ? { project } : {}
+	};
+}
+
+//#endregion
+//#region src/services/command-runner.ts
+var CommandExecutionError = class extends Schema.TaggedError()("CommandExecutionError", {
+	command: Schema.String,
+	args: Schema.Array(Schema.String),
+	exitCode: Schema.optionalKey(Schema.Number),
+	stdout: Schema.String,
+	stderr: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {
+	get message() {
+		const detail = this.stderr.trim() || this.stdout.trim();
+		const invocation = [this.command, ...this.args].join(" ");
+		return detail || `Command failed${this.exitCode === void 0 ? "" : ` with exit code ${this.exitCode}`}: ${invocation}`;
+	}
+};
+var CommandRunner = class CommandRunner extends Context.Service()("create-prisma/services/CommandRunner") {
+	static layer = Layer.sync(CommandRunner, () => {
+		const run = Effect.fn("CommandRunner.run")((spec) => Effect.tryPromise({
+			try: async (signal) => {
+				const subprocess = execa(spec.command, [...spec.args], {
+					cwd: spec.cwd,
+					env: spec.env,
+					stdio: spec.stdio ?? "pipe",
+					reject: false,
+					cancelSignal: signal
+				});
+				const stderr = subprocess.stderr;
+				const stderrLines = spec.onStderrLine && stderr ? (async () => {
+					const lines = createInterface({ input: stderr });
+					for await (const line of lines) if (line.trim()) spec.onStderrLine?.(line);
+				})() : Promise.resolve();
+				let result;
+				try {
+					[result] = await Promise.all([subprocess, stderrLines]);
+				} catch (cause) {
+					const error = cause instanceof Error ? cause : new Error(String(cause));
+					subprocess.kill(error);
+					await subprocess.catch(() => void 0);
+					throw cause;
+				}
+				return {
+					exitCode: result.exitCode ?? 1,
+					stdout: typeof result.stdout === "string" ? result.stdout : "",
+					stderr: typeof result.stderr === "string" ? result.stderr : ""
+				};
+			},
+			catch: (cause) => new CommandExecutionError({
+				command: spec.command,
+				args: [...spec.args],
+				stdout: "",
+				stderr: "",
+				cause
+			})
+		}));
+		const runChecked = Effect.fn("CommandRunner.runChecked")((spec) => Effect.flatMap(run(spec), (result) => result.exitCode === 0 ? Effect.succeed(result) : Effect.fail(new CommandExecutionError({
+			command: spec.command,
+			args: [...spec.args],
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr
+		}))));
+		return CommandRunner.of({
+			run,
+			runChecked
+		});
+	});
+};
+
+//#endregion
+//#region src/runtime.ts
+const NodeCliLayer = Layer.provideMerge(NodeChildProcessSpawner.layer, Layer.mergeAll(NodeFileSystem.layer, NodePath.layer, NodeStdio.layer, NodeTerminal.layer));
+const ApplicationLayer = Layer.merge(NodeCliLayer, CommandRunner.layer);
+const applicationRuntime = ManagedRuntime.make(ApplicationLayer);
+
+//#endregion
+//#region src/telemetry/client.ts
+const TELEMETRY_API_KEY = "phc_cmc85avbWyuJ2JyKdGPdv7dxXli8xLdWDBPbvIXWJfs";
+const TELEMETRY_HOST = "https://us.i.posthog.com";
+const TELEMETRY_CONFIG_FILE = "telemetry.json";
+const TELEMETRY_TIMEOUT_MS = 2e3;
+const AnonymousId = Schema.String.check(Schema.isUUID(4));
+const decodeAnonymousId = Schema.decodeUnknownExit(AnonymousId);
+const isTruthyEnvValue = (value) => [
+	"1",
+	"true",
+	"yes",
+	"on"
+].includes(String(value ?? "").trim().toLowerCase());
+function shouldDisableTelemetry() {
+	return isTruthyEnvValue(process.env.CI) || isTruthyEnvValue(process.env.GITHUB_ACTIONS) || process.env.CREATE_PRISMA_DISABLE_TELEMETRY !== void 0 || process.env.CREATE_PRISMA_TELEMETRY_DISABLED !== void 0 || process.env.DO_NOT_TRACK !== void 0;
+}
+function getTelemetryConfigDir() {
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "create-prisma");
+	if (process.platform === "win32") return path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), "create-prisma");
+	return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), "create-prisma");
+}
+const getAnonymousIdEffect = Effect.fn("Telemetry.getAnonymousId")(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const configPath = path.join(getTelemetryConfigDir(), TELEMETRY_CONFIG_FILE);
+	const decoded = decodeAnonymousId((yield* fs.readFileString(configPath).pipe(Effect.flatMap((source) => Effect.try({
+		try: () => JSON.parse(source),
+		catch: () => ({ anonymousId: void 0 })
+	})), Effect.catch(() => Effect.succeed({ anonymousId: void 0 })))).anonymousId);
+	if (decoded._tag === "Success") return decoded.value;
+	const anonymousId = randomUUID();
+	yield* Effect.gen(function* () {
+		yield* fs.makeDirectory(path.dirname(configPath), { recursive: true });
+		yield* fs.writeFileString(configPath, `${JSON.stringify({ anonymousId }, null, 2)}\n`);
+	}).pipe(Effect.catch(() => Effect.void));
+	return anonymousId;
+});
+const getCommonProperties = () => ({
+	"cli-version": "0.11.3",
+	"node-version": process.version,
+	platform: process.platform,
+	arch: process.arch
+});
+const sanitizeProperties = (properties) => Object.fromEntries(Object.entries(properties).filter(([, value]) => value !== void 0));
+const shutdownTelemetryClientEffect = (client, timeoutMs = TELEMETRY_TIMEOUT_MS) => Effect.tryPromise({
+	try: () => Promise.resolve(client.shutdown(timeoutMs)),
+	catch: () => void 0
+}).pipe(Effect.timeout(timeoutMs), Effect.interruptible, Effect.catch(() => Effect.void));
+const trackCliTelemetryEffect = Effect.fn("Telemetry.track")(function* (event, properties) {
+	if (shouldDisableTelemetry()) return;
+	const distinctId = yield* getAnonymousIdEffect();
+	const client = yield* Effect.acquireRelease(Effect.sync(() => new PostHog(TELEMETRY_API_KEY, {
+		host: TELEMETRY_HOST,
+		disableGeoip: true,
+		flushAt: 1,
+		flushInterval: 0
+	})), (posthog) => shutdownTelemetryClientEffect(posthog));
+	yield* Effect.tryPromise(() => client.captureImmediate({
+		distinctId,
+		event,
+		properties: sanitizeProperties({
+			...getCommonProperties(),
+			...properties,
+			$process_person_profile: false
+		}),
+		disableGeoip: true
+	}));
+});
+
+//#endregion
+//#region src/telemetry/create.ts
+const CREATE_PRISMA_NEXT_COMPLETED_EVENT = "cli:create_prisma_next_command_completed";
+const CREATE_PRISMA_NEXT_FAILED_EVENT = "cli:create_prisma_next_command_failed";
+const CREATE_PRISMA_NEXT_CANCELLED_EVENT = "cli:create_prisma_next_command_cancelled";
+const expectedRejectionReasons = new Set([
+	"invalid_input",
+	"unsupported_node_version",
+	"invalid_project_name",
+	"target_path_not_directory",
+	"target_directory_not_empty",
+	"unsupported_configuration",
+	"not_authenticated",
+	"workspace_missing",
+	"workspace_mismatch",
+	"project_name_collision"
+]);
+function getFailureClass(reason) {
+	return expectedRejectionReasons.has(reason) ? "expected_rejection" : "technical_failure";
+}
+function getTargetDirectoryState(context) {
+	if (!context.targetPathState.exists) return "new";
+	if (context.targetPathState.isEmptyDirectory) return "empty_directory";
+	return "non_empty_directory";
+}
+function getBaseCreateProperties(input, context) {
+	return {
+		"telemetry-schema-version": 2,
+		command: "create",
+		"uses-defaults": input.yes === true || input.json === true,
+		json: input.json === true,
+		verbose: input.verbose === true,
+		force: input.force === true,
+		template: context?.template ?? input.template ?? null,
+		"database-provider": context?.prismaSetupContext.databaseProvider ?? input.provider ?? null,
+		"authoring-style": context?.prismaSetupContext.authoring ?? input.authoring ?? null,
+		"package-manager": context?.prismaSetupContext.packageManager ?? input.packageManager ?? null,
+		"should-deploy": context?.prismaSetupContext.shouldDeploy ?? input.deploy ?? null,
+		"target-directory-state": context ? getTargetDirectoryState(context) : null
+	};
+}
+function getErrorName(error) {
+	if (error instanceof Error) return error.name;
+	return error === void 0 ? null : "UnknownError";
+}
+function getErrorCode(error) {
+	if (typeof error !== "object" || error === null) return null;
+	const exitCode = Reflect.get(error, "exitCode");
+	if (typeof exitCode === "number") return exitCode;
+	const code = Reflect.get(error, "code");
+	return typeof code === "number" || typeof code === "string" ? code : null;
+}
+function getPrismaCliFailureProperty(error, property) {
+	if (typeof error !== "object" || error === null) return null;
+	const value = Reflect.get(error, property);
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+const trackCreateCompletedEffect = Effect.fn("Telemetry.createCompleted")(function* (params) {
+	yield* trackCliTelemetryEffect(CREATE_PRISMA_NEXT_COMPLETED_EVENT, {
+		...getBaseCreateProperties(params.input, params.context),
+		"duration-ms": params.durationMs
+	}).pipe(Effect.scoped, Effect.timeout(TELEMETRY_TIMEOUT_MS), Effect.catch(() => Effect.void));
+});
+const trackCreateFailedEffect = Effect.fn("Telemetry.createFailed")(function* (params) {
+	yield* trackCliTelemetryEffect(CREATE_PRISMA_NEXT_FAILED_EVENT, {
+		...getBaseCreateProperties(params.input, params.context),
+		"duration-ms": params.durationMs,
+		"failure-class": getFailureClass(params.reason),
+		"failure-stage": params.stage,
+		"failure-reason": params.reason,
+		"error-name": getErrorName(params.error),
+		"error-code": getErrorCode(params.error),
+		"prisma-cli-command": getPrismaCliFailureProperty(params.error, "prismaCliCommand"),
+		"prisma-cli-error-code": getPrismaCliFailureProperty(params.error, "prismaCliErrorCode")
+	}).pipe(Effect.scoped, Effect.timeout(TELEMETRY_TIMEOUT_MS), Effect.catch(() => Effect.void));
+});
+const trackCreateCancelledEffect = Effect.fn("Telemetry.createCancelled")(function* (params) {
+	yield* trackCliTelemetryEffect(CREATE_PRISMA_NEXT_CANCELLED_EVENT, {
+		...getBaseCreateProperties(params.input, params.context),
+		"duration-ms": params.durationMs,
+		"cancellation-stage": params.stage
+	}).pipe(Effect.scoped, Effect.timeout(TELEMETRY_TIMEOUT_MS), Effect.catch(() => Effect.void));
+});
+
+//#endregion
+//#region src/utils/package-manager.ts
+const DENO_ALLOW_FRESH_DEPENDENCIES = "--minimum-dependency-age=0";
+const packageManagerManifestValues = {
+	npm: "npm@10.9.0",
+	pnpm: "pnpm@11.21.0",
+	yarn: "yarn@4.13.0",
+	bun: "bun@1.3.9"
+};
+function parseUserAgent(userAgent) {
+	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("yarn")) return "yarn";
+	if (userAgent?.startsWith("bun")) return "bun";
+	if (userAgent?.startsWith("deno")) return "deno";
+	if (userAgent?.startsWith("npm")) return "npm";
+	return null;
+}
+function parsePackageManagerField(packageManagerField) {
+	if (typeof packageManagerField !== "string" || packageManagerField.length === 0) return null;
+	const managerName = packageManagerField.split("@")[0];
+	return packageManagers.includes(managerName) ? managerName : null;
+}
+const detectFromPackageJson = Effect.fn("PackageManager.detectFromPackageJson")(function* (projectDir) {
+	const fs = yield* FileSystem.FileSystem;
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (!(yield* fs.exists(packageJsonPath))) return null;
+	const packageJsonSource = yield* fs.readFileString(packageJsonPath).pipe(Effect.catch(() => Effect.succeed("")));
+	const packageJson = yield* Effect.try(() => JSON.parse(packageJsonSource)).pipe(Effect.catch(() => Effect.succeed(null)));
+	return packageJson ? parsePackageManagerField(packageJson.packageManager) : null;
+});
+const detectFromDenoConfig = Effect.fn("PackageManager.detectFromDenoConfig")(function* (projectDir) {
+	const fs = yield* FileSystem.FileSystem;
+	for (const configFile of ["deno.json", "deno.jsonc"]) if (yield* fs.exists(path.join(projectDir, configFile))) return "deno";
+	return null;
+});
+const detectFromLockfile = Effect.fn("PackageManager.detectFromLockfile")(function* (projectDir) {
+	const fs = yield* FileSystem.FileSystem;
+	for (const check of [
+		{
+			manager: "pnpm",
+			lockfile: "pnpm-lock.yaml"
+		},
+		{
+			manager: "yarn",
+			lockfile: "yarn.lock"
+		},
+		{
+			manager: "bun",
+			lockfile: "bun.lockb"
+		},
+		{
+			manager: "bun",
+			lockfile: "bun.lock"
+		},
+		{
+			manager: "npm",
+			lockfile: "package-lock.json"
+		},
+		{
+			manager: "npm",
+			lockfile: "npm-shrinkwrap.json"
+		},
+		{
+			manager: "deno",
+			lockfile: "deno.lock"
+		}
+	]) if (yield* fs.exists(path.join(projectDir, check.lockfile))) return check.manager;
+	return null;
+});
+const detectPackageManagerEffect = Effect.fn("PackageManager.detect")(function* (projectDir = process.cwd()) {
+	const fromPackageJson = yield* detectFromPackageJson(projectDir);
+	if (fromPackageJson) return fromPackageJson;
+	const fromLockfile = yield* detectFromLockfile(projectDir);
+	if (fromLockfile) return fromLockfile;
+	const fromDenoConfig = yield* detectFromDenoConfig(projectDir);
+	if (fromDenoConfig) return fromDenoConfig;
+	const fromUserAgent = parseUserAgent(process.env.npm_config_user_agent);
+	if (fromUserAgent) return fromUserAgent;
+	return "npm";
+});
+function getPackageManagerManifestValue(packageManager) {
+	if (!packageManager) return;
+	if (packageManager === "deno") return;
+	return packageManagerManifestValues[packageManager];
+}
+function getInstallCommand(packageManager) {
+	if (packageManager === "deno") return "deno install";
+	return `${packageManager} install`;
+}
+function getRunScriptCommand(packageManager, scriptName) {
+	switch (packageManager) {
+		case "deno": return `deno task ${scriptName}`;
+		case "bun": return `bun run ${scriptName}`;
+		case "pnpm": return `pnpm run ${scriptName}`;
+		case "yarn": return `yarn run ${scriptName}`;
+		default: return `npm run ${scriptName}`;
+	}
+}
+function getRuntimeScriptCommand(packageManager, kind, options) {
+	const { sourceEntrypoint, builtEntrypoint } = options;
+	if (packageManager === "deno") switch (kind) {
+		case "dev": return `deno run -A --env-file=.env --watch ${sourceEntrypoint}`;
+		case "build": return `deno check ${sourceEntrypoint}`;
+		case "start": return `deno run -A --env-file=.env ${sourceEntrypoint}`;
+	}
+	if (packageManager === "bun") switch (kind) {
+		case "dev": return `bun --watch ${sourceEntrypoint}`;
+		case "build": return "tsc --noEmit";
+		case "start": return `bun ${sourceEntrypoint}`;
+	}
+	switch (kind) {
+		case "dev": return `tsx watch ${sourceEntrypoint}`;
+		case "build": return "tsc";
+		case "start": return builtEntrypoint ? `node ${builtEntrypoint}` : `tsx ${sourceEntrypoint}`;
+	}
+}
+function getInstallArgs(packageManager) {
+	if (packageManager === "deno") return {
+		command: "deno",
+		args: ["install", DENO_ALLOW_FRESH_DEPENDENCIES]
+	};
+	return {
+		command: packageManager,
+		args: ["install"]
+	};
+}
+function getLocalPackageBinaryArgs(packageManager, binaryName, binaryArgs) {
+	switch (packageManager) {
+		case "deno": return {
+			command: "deno",
+			args: [
+				"run",
+				"-A",
+				"--frozen",
+				`npm:${binaryName}@latest`,
+				...binaryArgs
+			]
+		};
+		case "pnpm": return {
+			command: "pnpm",
+			args: [
+				"exec",
+				binaryName,
+				...binaryArgs
+			]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: [binaryName, ...binaryArgs]
+		};
+		case "bun": return {
+			command: "bun",
+			args: [binaryName, ...binaryArgs]
+		};
+		default: return {
+			command: "npm",
+			args: [
+				"exec",
+				"--offline",
+				"--yes=false",
+				"--",
+				binaryName,
+				...binaryArgs
+			]
+		};
+	}
+}
+function getLocalPackageBinaryCommand(packageManager, binaryName, binaryArgs) {
+	const execution = getLocalPackageBinaryArgs(packageManager, binaryName, binaryArgs);
+	return [execution.command, ...execution.args].join(" ");
+}
+function getRunScriptArgs(packageManager, scriptName) {
+	switch (packageManager) {
+		case "deno": return {
+			command: "deno",
+			args: ["task", scriptName]
+		};
+		case "bun": return {
+			command: "bun",
+			args: ["run", scriptName]
+		};
+		case "pnpm": return {
+			command: "pnpm",
+			args: ["run", scriptName]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: ["run", scriptName]
+		};
+		default: return {
+			command: "npm",
+			args: ["run", scriptName]
+		};
+	}
+}
+
+//#endregion
+//#region src/templates/shared.ts
+Handlebars.registerHelper("eq", (left, right) => left === right);
+Handlebars.registerHelper("runScriptCommand", (packageManager, scriptName) => packageManager ? getRunScriptCommand(packageManager, scriptName) : "");
+Handlebars.registerHelper("packageManagerManifestValue", (packageManager) => getPackageManagerManifestValue(packageManager) ?? "");
+Handlebars.registerHelper("runtimeScript", (packageManager, kind, sourceEntrypoint, builtEntrypoint, _options) => packageManager ? getRuntimeScriptCommand(packageManager, kind, {
+	sourceEntrypoint,
+	builtEntrypoint
+}) : "");
+const findPackageRootEffect = Effect.fn("Templates.findPackageRoot")(function* (startDir) {
+	const fs = yield* FileSystem.FileSystem;
+	let currentDir = startDir;
+	while (true) {
+		if (yield* fs.exists(path.join(currentDir, "package.json"))) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return yield* Effect.fail(/* @__PURE__ */ new Error(`Unable to locate package root from: ${startDir}`));
+		currentDir = parentDir;
+	}
+});
+const resolveTemplatesDirEffect = Effect.fn("Templates.resolveDirectory")(function* (relativeTemplatesDir) {
+	const fs = yield* FileSystem.FileSystem;
+	const currentFilePath = fileURLToPath(import.meta.url);
+	const packageRoot = yield* findPackageRootEffect(path.dirname(currentFilePath));
+	const templatePath = path.join(packageRoot, relativeTemplatesDir);
+	if (!(yield* fs.exists(templatePath))) return yield* Effect.fail(/* @__PURE__ */ new Error(`Template directory not found at: ${templatePath}`));
+	return templatePath;
+});
+const ensureTrailingNewline = (content) => content.endsWith("\n") ? content : `${content}\n`;
+const stripHbsExtension = (filePath) => filePath.endsWith(".hbs") ? filePath.slice(0, -4) : filePath;
+const renderTemplateFileEffect = Effect.fn("Templates.renderFile")(function* (opts) {
+	const fs = yield* FileSystem.FileSystem;
+	const templateContent = yield* fs.readFileString(opts.templateFilePath);
+	const outputContent = yield* Effect.try({
+		try: () => opts.templateFilePath.endsWith(".hbs") ? Handlebars.compile(templateContent, {
+			noEscape: true,
+			strict: true
+		})(opts.context) : templateContent,
+		catch: (cause) => new Error(`Could not render ${opts.templateFilePath}`, { cause })
+	});
+	if (opts.templateFilePath.endsWith(".hbs") && outputContent.trim().length === 0) return;
+	yield* fs.makeDirectory(path.dirname(opts.outputPath), { recursive: true });
+	yield* fs.writeFileString(opts.outputPath, ensureTrailingNewline(outputContent));
+});
+const renderTemplateTreeEffect = Effect.fn("Templates.renderTree")(function* (opts) {
+	const fs = yield* FileSystem.FileSystem;
+	const entries = yield* fs.readDirectory(opts.templateRoot, { recursive: true });
+	for (const relativePath of entries) {
+		const templateFilePath = path.join(opts.templateRoot, relativePath);
+		if ((yield* fs.stat(templateFilePath)).type !== "File") continue;
+		yield* renderTemplateFileEffect({
+			templateFilePath,
+			outputPath: path.join(opts.outputDir, stripHbsExtension(relativePath)),
+			context: opts.context
+		});
+	}
+});
+
+//#endregion
+//#region src/templates/render-create-template.ts
+const tsdownEntries = {
+	minimal: "src/index.ts",
+	hono: "src/index.ts",
+	elysia: "src/index.ts",
+	nest: "src/main.ts"
+};
+function createTemplateContext(options) {
+	return {
+		projectName: options.projectName,
+		template: options.template,
+		provider: options.provider,
+		authoring: options.authoring,
+		packageManager: options.packageManager,
+		tsdownEntry: tsdownEntries[options.template] ?? null
+	};
+}
+const scaffoldCreateSharedTemplatesEffect = Effect.fn("Templates.scaffoldShared")(function* (options) {
+	yield* renderTemplateTreeEffect({
+		templateRoot: yield* resolveTemplatesDirEffect("templates/create/_shared"),
+		outputDir: options.projectDir,
+		context: createTemplateContext(options)
+	});
+});
+const scaffoldCreateFrameworkTemplateEffect = Effect.fn("Templates.scaffoldFramework")(function* (options) {
+	yield* renderTemplateTreeEffect({
+		templateRoot: yield* resolveTemplatesDirEffect(`templates/create/${options.template}`),
+		outputDir: options.projectDir,
+		context: createTemplateContext(options)
+	});
+});
+const scaffoldCreateTemplateEffect = Effect.fn("Templates.scaffold")(function* (options) {
+	yield* scaffoldCreateFrameworkTemplateEffect(options);
+	yield* scaffoldCreateSharedTemplatesEffect(options);
+});
+
+//#endregion
+//#region src/constants/dependencies.ts
+const dependencyVersionMap = {
+	"@astrojs/node": "^10.0.2",
+	"@elysiajs/node": "^1.4.5",
+	"@prisma/composer": "0.16.0",
+	"@prisma/composer-prisma-cloud": "0.16.0",
+	"@prisma/orm-mongo": "8.0.0-rc.8",
+	"@prisma/orm-postgres": "8.0.0-rc.8",
+	"@sveltejs/adapter-node": "^5.3.2",
+	"@types/node": "^25.6.2",
+	alchemy: "2.0.0-beta.74",
+	arktype: "^2.2.3",
+	dotenv: "^17.4.2",
+	effect: "4.0.0-rc.112",
+	mongodb: "^7.1.0",
+	"mongodb-memory-server": "^11.1.0",
+	nitro: "^3.0.260610-beta",
+	prisma: "latest",
+	"temporal-polyfill": "^1.0.4",
+	tsdown: "^0.22.14",
+	tsx: "^4.21.0",
+	typescript: "^5.9.3"
+};
+const PRISMA_PLATFORM_CLI_PACKAGE = "prisma@latest";
+const PRISMA_DENO_CLI_PACKAGE = PRISMA_PLATFORM_CLI_PACKAGE;
+function getDependencyVersion(packageName) {
+	return dependencyVersionMap[packageName];
+}
+function usesTsdown(template) {
+	return template === "minimal" || template === "hono" || template === "elysia" || template === "nest";
+}
+function getCreateTemplateDependencies(template, _packageManager) {
+	const dependencies = [
+		"@prisma/composer",
+		"@prisma/composer-prisma-cloud",
+		"alchemy"
+	];
+	const devDependencies = [];
+	if (usesTsdown(template)) {
+		devDependencies.push("tsdown");
+		devDependencies.push("tsx");
+	}
+	if (template === "minimal") devDependencies.push("typescript");
+	if (template === "elysia") {
+		dependencies.push("@elysiajs/node");
+		devDependencies.push("@types/node");
+	}
+	if (template === "svelte") devDependencies.push("@sveltejs/adapter-node");
+	if (template === "astro") dependencies.push("@astrojs/node");
+	if (template === "tanstack-start") devDependencies.push("nitro");
+	return [{
+		packageJsonPath: "package.json",
+		dependencies,
+		devDependencies
+	}];
+}
+
+//#endregion
+//#region src/constants/db-packages.ts
+function getDbPackages(provider) {
+	switch (provider) {
+		case "postgres": return "@prisma/orm-postgres";
+		case "mongo": return "@prisma/orm-mongo";
+	}
+}
+
+//#endregion
+//#region src/utils/run-command.ts
+const runSetupCommand = Effect.fn("runSetupCommand")(function* (options) {
+	const runner = yield* CommandRunner;
+	const shouldInheritOutput = options.verbose && !options.json;
+	yield* runner.runChecked({
+		command: options.command,
+		args: options.args,
+		cwd: options.cwd,
+		...options.env ? { env: options.env } : {},
+		stdio: shouldInheritOutput ? "inherit" : "pipe"
+	});
+});
+
+//#endregion
+//#region src/tasks/install.ts
+function getPrismaScriptMap(packageManager) {
+	if (packageManager === "deno") {
+		const prismaCommand = (needsDatabase, ...args) => [
+			"deno run -A",
+			...needsDatabase ? ["--env-file=.env"] : [],
+			`npm:${PRISMA_DENO_CLI_PACKAGE}`,
+			...args
+		].join(" ");
+		return {
+			"contract:emit": prismaCommand(false, "contract", "emit"),
+			"db:init": prismaCommand(true, "db", "init"),
+			"db:update": prismaCommand(true, "db", "update"),
+			"db:verify": prismaCommand(true, "db", "verify"),
+			"migration:plan": prismaCommand(true, "migration", "plan"),
+			migrate: prismaCommand(true, "db", "migrate"),
+			"migration:status": prismaCommand(true, "migration", "status"),
+			"migration:show": prismaCommand(true, "migration", "show")
+		};
+	}
+	const prismaCommand = (...args) => ["prisma", ...args].join(" ");
+	return {
+		"contract:emit": prismaCommand("contract", "emit"),
+		"db:init": prismaCommand("db", "init"),
+		"db:update": prismaCommand("db", "update"),
+		"db:verify": prismaCommand("db", "verify"),
+		"migration:plan": prismaCommand("migration", "plan"),
+		migrate: prismaCommand("db", "migrate"),
+		"migration:status": prismaCommand("migration", "status"),
+		"migration:show": prismaCommand("migration", "show"),
+		"skills:sync": `${prismaCommand("skills", "sync")} || exit 0`
+	};
+}
+function getComposerScriptMap(packageManager) {
+	if (packageManager === "deno") return {};
+	const composerCommand = (subcommand) => [
+		"prisma",
+		subcommand,
+		"module.ts"
+	].join(" ");
+	return {
+		"composer:dev": composerCommand("dev"),
+		"composer:deploy": composerCommand("deploy"),
+		deploy: `${getRunScriptCommand(packageManager, "build")} && ${getRunScriptCommand(packageManager, "composer:deploy")}`,
+		"dev:composer": `${getRunScriptCommand(packageManager, "build")} && ${getRunScriptCommand(packageManager, "composer:dev")}`
+	};
+}
+const unique = (items) => [...new Set(items)];
+const sortRecord = (record) => Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+const readPackageJson = Effect.fn("Dependencies.readPackageJson")(function* (packageJsonPath) {
+	const source = yield* (yield* FileSystem.FileSystem).readFileString(packageJsonPath);
+	return yield* Effect.try({
+		try: () => JSON.parse(source),
+		catch: (cause) => new Error(`Invalid package.json at ${packageJsonPath}`, { cause })
+	});
+});
+const writePackageJson = Effect.fn("Dependencies.writePackageJson")(function* (packageJsonPath, packageJson) {
+	yield* (yield* FileSystem.FileSystem).writeFileString(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+});
+const addPackageDependencyEffect = Effect.fn("Dependencies.add")(function* (opts) {
+	const fs = yield* FileSystem.FileSystem;
+	const dependencies = opts.dependencies ?? [];
+	const devDependencies = opts.devDependencies ?? [];
+	const customDependencies = opts.customDependencies ?? {};
+	const scripts = opts.scripts ?? {};
+	const packageJsonPath = path.join(opts.projectDir, "package.json");
+	if (!(yield* fs.exists(packageJsonPath))) return yield* Effect.fail(/* @__PURE__ */ new Error(`No package.json found in ${opts.projectDir}. Run this command inside an existing JavaScript/TypeScript project.`));
+	const packageJson = yield* readPackageJson(packageJsonPath);
+	packageJson.dependencies ??= {};
+	packageJson.devDependencies ??= {};
+	packageJson.scripts ??= {};
+	for (const packageName of unique(dependencies)) {
+		const version = getDependencyVersion(packageName);
+		if (!version) return yield* Effect.fail(/* @__PURE__ */ new Error(`Dependency ${packageName} is missing from the version map.`));
+		packageJson.dependencies[packageName] = version;
+	}
+	for (const packageName of unique(devDependencies)) {
+		const version = getDependencyVersion(packageName);
+		if (!version) return yield* Effect.fail(/* @__PURE__ */ new Error(`Dependency ${packageName} is missing from the version map.`));
+		packageJson.devDependencies[packageName] = version;
+	}
+	Object.assign(packageJson.dependencies, customDependencies);
+	for (const [scriptName, command] of Object.entries(scripts)) {
+		if (opts.scriptMode === "if-missing" && typeof packageJson.scripts[scriptName] === "string" && packageJson.scripts[scriptName].trim().length > 0) continue;
+		packageJson.scripts[scriptName] = command;
+	}
+	packageJson.dependencies = sortRecord(packageJson.dependencies);
+	packageJson.devDependencies = sortRecord(packageJson.devDependencies);
+	packageJson.scripts = sortRecord(packageJson.scripts);
+	yield* writePackageJson(packageJsonPath, packageJson);
+});
+const writePrismaDependenciesEffect = Effect.fn("Dependencies.writePrisma")(function* (provider, packageManager, _authoring, projectDir = process.cwd()) {
+	const dependencies = [getDbPackages(provider)];
+	if (provider === "postgres" && packageManager !== "deno") dependencies.push("temporal-polyfill");
+	if (provider === "mongo") dependencies.push("arktype", "mongodb");
+	if (packageManager === "deno") dependencies.push("dotenv");
+	yield* addPackageDependencyEffect({
+		dependencies,
+		devDependencies: ["@types/node", "prisma"],
+		scripts: getPrismaScriptMap(packageManager),
+		projectDir
+	});
+});
+const writeCreateTemplateDependenciesEffect = Effect.fn("Dependencies.writeTemplate")(function* (opts) {
+	const projectDir = opts.projectDir ?? process.cwd();
+	if (opts.packageManager === "deno") return;
+	for (const target of getCreateTemplateDependencies(opts.template, opts.packageManager)) yield* addPackageDependencyEffect({
+		dependencies: target.dependencies,
+		devDependencies: target.devDependencies,
+		customDependencies: target.customDependencies,
+		scripts: getComposerScriptMap(opts.packageManager),
+		projectDir: path.join(projectDir, path.dirname(target.packageJsonPath))
+	});
+	const packageJsonPath = path.join(projectDir, "package.json");
+	const packageJson = yield* readPackageJson(packageJsonPath);
+	const effectVersion = getDependencyVersion("effect");
+	if (!effectVersion) return yield* Effect.fail(/* @__PURE__ */ new Error("Dependency effect is missing from the version map."));
+	if (opts.packageManager === "yarn") packageJson.resolutions = {
+		...packageJson.resolutions,
+		effect: effectVersion
+	};
+	else if (opts.packageManager !== "pnpm") packageJson.overrides = {
+		...packageJson.overrides,
+		effect: effectVersion
+	};
+	yield* writePackageJson(packageJsonPath, packageJson);
+});
+const installProjectDependenciesEffect = Effect.fn("Dependencies.install")(function* (packageManager, projectDir = process.cwd(), options = {}) {
+	const installCommand = getInstallArgs(packageManager);
+	yield* runSetupCommand({
+		command: installCommand.command,
+		args: installCommand.args,
+		cwd: projectDir,
+		...packageManager === "yarn" ? { env: { YARN_ENABLE_IMMUTABLE_INSTALLS: "false" } } : {},
+		verbose: options.verbose === true,
+		json: options.json === true
+	});
+});
+
+//#endregion
+//#region src/utils/errors.ts
+function redactSecrets(message) {
+	return message.replace(/\b((?:(?:prisma\+)?postgres(?:ql)?|mongodb(?:\+srv)?):\/\/)[^\s'"]+/gi, "$1<redacted>").replace(/\b([A-Z0-9_]*(?:MONGODB_(?:URL|URI)|DATABASE_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY)[A-Z0-9_]*\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s]+)/gi, "$1<redacted>").replace(/(\bAuthorization\s*:\s*Bearer\s+)[^\s'"]+/gi, "$1<redacted>");
+}
+function getErrorMessage(error) {
+	if (error instanceof Error && "stderr" in error) {
+		const stderr = String(error.stderr ?? "").trim();
+		if (stderr) return redactSecrets(stderr);
+	}
+	return redactSecrets(error instanceof Error ? error.message : String(error));
+}
+
+//#endregion
+//#region src/workflow/failure.ts
+const atCreateStage = (effect, stage, reason) => effect.pipe(Effect.mapError((error) => error instanceof CreateFailure || error instanceof CreateCancellationError ? error : new CreateFailure({
+	stage,
+	reason,
+	message: getErrorMessage(error),
+	cause: error
+})));
+
+//#endregion
+//#region src/tasks/composer/prisma-cli.ts
+const PrismaCliEnvelopeSchema = Schema.Struct({
+	ok: Schema.Boolean,
+	command: Schema.optionalKey(Schema.String),
+	commandId: Schema.optionalKey(Schema.String),
+	result: Schema.optionalKey(Schema.Unknown),
+	error: Schema.optionalKey(Schema.Struct({
+		code: Schema.optionalKey(Schema.String),
+		summary: Schema.optionalKey(Schema.String),
+		message: Schema.optionalKey(Schema.String),
+		why: Schema.optionalKey(Schema.String)
+	}))
+});
+const decodePrismaCliEnvelope = Schema.decodeUnknownExit(PrismaCliEnvelopeSchema);
+function parsePrismaCliEnvelope(output) {
+	const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).reverse();
+	for (const line of lines) try {
+		const parsed = JSON.parse(line);
+		const decoded = decodePrismaCliEnvelope(parsed.kind === "result" ? parsed.envelope : parsed);
+		if (decoded._tag === "Success") return decoded.value;
+	} catch {}
+	throw new Error("Prisma CLI returned output that is not a valid result envelope.");
+}
+const runPrismaJsonCommandEffect = Effect.fn("PrismaCli.runJson")(function* (options) {
+	const runner = yield* CommandRunner;
+	const invocation = getLocalPackageBinaryArgs(options.packageManager, "prisma", [
+		...options.args,
+		"--json",
+		"--no-interactive"
+	]);
+	const result = yield* runner.run({
+		command: invocation.command,
+		args: invocation.args,
+		cwd: options.projectDir,
+		env: process.env,
+		...options.onStderrLine ? { onStderrLine: options.onStderrLine } : {}
+	});
+	let envelope;
+	try {
+		envelope = parsePrismaCliEnvelope(result.stdout);
+	} catch (cause) {
+		return yield* new PrismaCliCommandError({
+			message: result.stderr.trim() || getErrorMessage(cause),
+			stderr: result.stderr,
+			exitCode: result.exitCode
+		});
+	}
+	if (result.exitCode !== 0 || !envelope.ok || envelope.result === void 0) return yield* new PrismaCliCommandError({
+		message: [envelope.error?.summary ?? envelope.error?.message, envelope.error?.why].filter(Boolean).join(": ") || result.stderr.trim() || "Prisma CLI command failed.",
+		...envelope.commandId || envelope.command ? { command: envelope.commandId ?? envelope.command } : {},
+		...envelope.error?.code ? { code: envelope.error.code } : {},
+		stderr: result.stderr,
+		exitCode: result.exitCode
+	});
+	return envelope.result;
+});
+const decodePrismaCommandResult = (schema, value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new PrismaCliCommandError({ message: `Prisma CLI returned an invalid result: ${cause.message}` })));
+
+//#endregion
+//#region src/tasks/composer/workspace.ts
+const getWorkspaceLabel = (workspace) => workspace.name ?? workspace.id;
+
+//#endregion
+//#region src/tasks/composer/auth.ts
+const WhoamiResultSchema = Schema.Struct({
+	authenticated: Schema.Boolean,
+	workspace: Schema.NullOr(PrismaWorkspaceSchema),
+	source: Schema.NullOr(Schema.Literals(["stored", "environment"]))
+});
+const WorkspaceListResultSchema = Schema.Struct({ items: Schema.Array(Schema.Struct({
+	workspaceId: Schema.String,
+	workspaceName: Schema.NullOr(Schema.String),
+	current: Schema.Boolean
+})) });
+const WorkspaceUseResultSchema = Schema.Struct({ workspace: PrismaWorkspaceSchema });
+const ensureAuthentication = Effect.fn("Deployment.ensureAuthentication")(function* (options) {
+	const whoami = Effect.fn("PrismaCli.whoami")(function* () {
+		return yield* decodePrismaCommandResult(WhoamiResultSchema, yield* runPrismaJsonCommandEffect({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			args: ["auth", "whoami"]
+		}));
+	});
+	const authState = yield* whoami();
+	if (authState.authenticated) return authState;
+	const loginCommand = getLocalPackageBinaryCommand(options.packageManager, "prisma", ["auth", "login"]);
+	if (!options.allowInteractiveLogin || process.stdin.isTTY !== true) return yield* new CreateFailure({
+		stage: "authenticate",
+		reason: "not_authenticated",
+		message: `Sign in first with ${loginCommand}, then run ${getRunScriptCommand(options.packageManager, "deploy")}.`
+	});
+	yield* Effect.sync(() => {
+		options.beforeInteractiveLogin?.();
+		log.info("Sign in to Prisma to deploy.", { output: options.output });
+	});
+	const runner = yield* CommandRunner;
+	const login = getLocalPackageBinaryArgs(options.packageManager, "prisma", ["auth", "login"]);
+	yield* runner.runChecked({
+		command: login.command,
+		args: login.args,
+		cwd: options.projectDir,
+		env: process.env,
+		stdio: "inherit"
+	});
+	const authenticatedState = yield* whoami();
+	if (!authenticatedState.authenticated) return yield* new CreateFailure({
+		stage: "authenticate",
+		reason: "authentication_failed",
+		message: "Prisma sign-in completed without an active workspace session."
+	});
+	return authenticatedState;
+});
+const useWorkspace = Effect.fn("Deployment.useWorkspace")(function* (options) {
+	return (yield* decodePrismaCommandResult(WorkspaceUseResultSchema, yield* runPrismaJsonCommandEffect({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		args: [
+			"auth",
+			"workspace",
+			"use",
+			options.workspace
+		]
+	}))).workspace;
+});
+const selectDeploymentWorkspace = Effect.fn("Deployment.selectWorkspace")(function* (options) {
+	const activeWorkspace = options.authState.workspace;
+	if (!activeWorkspace) return yield* new CreateFailure({
+		stage: "select_workspace",
+		reason: "workspace_missing",
+		message: "The active Prisma credential does not specify a workspace."
+	});
+	if (options.workspace) {
+		if (options.authState.source === "environment") {
+			if (options.workspace === activeWorkspace.id || options.workspace === activeWorkspace.name) return activeWorkspace;
+			return yield* new CreateFailure({
+				stage: "select_workspace",
+				reason: "workspace_mismatch",
+				message: `The environment credential is fixed to workspace ${getWorkspaceLabel(activeWorkspace)}. Unset it before using --workspace ${options.workspace}.`
+			});
+		}
+		return yield* useWorkspace({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			workspace: options.workspace
+		});
+	}
+	if (!options.shouldPrompt || process.stdin.isTTY !== true) return activeWorkspace;
+	const available = yield* decodePrismaCommandResult(WorkspaceListResultSchema, yield* runPrismaJsonCommandEffect({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		args: [
+			"auth",
+			"workspace",
+			"list"
+		]
+	}));
+	if (available.items.length <= 1) return activeWorkspace;
+	yield* Effect.sync(() => options.beforePrompt?.());
+	const selectedWorkspaceId = yield* Effect.tryPromise(() => select({
+		message: "Select Prisma workspace for deployment",
+		initialValue: activeWorkspace.id,
+		options: available.items.map((workspace) => ({
+			value: workspace.workspaceId,
+			label: workspace.workspaceName ?? workspace.workspaceId,
+			hint: workspace.current ? `${workspace.workspaceId}, current` : workspace.workspaceId
+		})),
+		output: options.output
+	}));
+	if (isCancel(selectedWorkspaceId)) {
+		yield* Effect.sync(() => cancel("Operation cancelled.", { output: options.output }));
+		return yield* new CreateCancellationError({ stage: "select_workspace" });
+	}
+	yield* Effect.sync(() => options.afterPrompt?.());
+	if (selectedWorkspaceId === activeWorkspace.id) return activeWorkspace;
+	return yield* useWorkspace({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		workspace: selectedWorkspaceId
+	});
+});
+
+//#endregion
+//#region src/tasks/composer/deployment-result.ts
+const ComposerDeployCommandResultSchema = Schema.Struct({ summary: Schema.NullOr(Schema.Struct({
+	app: Schema.String,
+	nodes: Schema.Array(Schema.Struct({ entities: Schema.Array(Schema.Struct({
+		kind: Schema.String,
+		id: Schema.String,
+		url: Schema.optionalKey(Schema.String)
+	})) }))
+})) });
+function parseComposerDeployResult(result) {
+	if (!result.summary) return;
+	const computeService = result.summary.nodes.flatMap((node) => node.entities).find((entity) => entity.kind === "compute-service");
+	return {
+		appName: result.summary.app,
+		...computeService?.id ? { serviceId: computeService.id } : {},
+		...computeService?.url ? { appUrl: computeService.url.replace(/\/$/, "") } : {}
+	};
+}
+
+//#endregion
+//#region src/tasks/composer/projects.ts
+const ProjectShowResultSchema = Schema.Struct({
+	workspace: PrismaWorkspaceSchema,
+	project: Schema.NullOr(Schema.Struct({
+		id: Schema.String,
+		name: Schema.String
+	}))
+});
+const ProjectListResultSchema = Schema.Struct({ items: Schema.Array(Schema.Struct({
+	id: Schema.String,
+	name: Schema.String
+})) });
+const stripResourcePrefix = (id, prefix) => id.startsWith(`${prefix}_`) ? id.slice(prefix.length + 1) : id;
+function getConsoleProjectUrl(workspaceId, projectId) {
+	return `https://console.prisma.io/${encodeURIComponent(stripResourcePrefix(workspaceId, "wksp"))}/${encodeURIComponent(stripResourcePrefix(projectId, "proj"))}`;
+}
+function findProjectNameCollisions(projects, appName) {
+	return projects.filter((project) => project.name === appName);
+}
+const ensureProjectNameAvailable = Effect.fn("Deployment.ensureProjectNameAvailable")(function* (options) {
+	const collisions = findProjectNameCollisions((yield* decodePrismaCommandResult(ProjectListResultSchema, yield* runPrismaJsonCommandEffect({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		args: ["project", "list"]
+	}))).items, options.appName);
+	if (collisions.length === 0) return;
+	const projectIds = collisions.map((project) => project.id).join(", ");
+	return yield* new CreateFailure({
+		stage: "check_project_name",
+		reason: "project_name_collision",
+		message: `A Prisma project named "${options.appName}" already exists in workspace ${getWorkspaceLabel(options.workspace)} (${options.workspace.id}). Choose a different project name or delete the existing project (${projectIds}) in Prisma Console, then retry.`
+	});
+});
+const getProjectDetails = Effect.fn("Deployment.getProjectDetails")(function* (options) {
+	return yield* Effect.gen(function* () {
+		const result = yield* decodePrismaCommandResult(ProjectShowResultSchema, yield* runPrismaJsonCommandEffect({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			args: [
+				"project",
+				"show",
+				options.appName
+			]
+		}));
+		if (!result.project) return void 0;
+		return {
+			workspace: result.workspace,
+			project: {
+				id: result.project.id,
+				name: result.project.name,
+				consoleUrl: getConsoleProjectUrl(result.workspace.id, result.project.id)
+			}
+		};
+	}).pipe(Effect.catch(() => Effect.succeed(void 0)));
+});
+
+//#endregion
+//#region src/tasks/deploy-with-composer.ts
+const deployNewProjectWithComposerEffect = Effect.fn("Deployment.deploy")(function* (options) {
+	const output = options.output ?? process.stdout;
+	const progress = options.verbose ? void 0 : spinner({ output });
+	let deploymentLog;
+	let progressRunning = false;
+	const showProgress = (message) => {
+		if (!progress) return;
+		if (progressRunning) progress.message(message);
+		else {
+			progress.start(message);
+			progressRunning = true;
+		}
+	};
+	const clearProgress = () => {
+		if (!progress || !progressRunning) return;
+		progress.clear();
+		progressRunning = false;
+	};
+	return yield* Effect.gen(function* () {
+		yield* Effect.sync(() => {
+			showProgress("Checking Prisma account...");
+			if (options.verbose) log.step("Checking Prisma account.", { output });
+		});
+		const authState = yield* atCreateStage(ensureAuthentication({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			output,
+			allowInteractiveLogin: options.allowInteractiveLogin ?? true,
+			beforeInteractiveLogin: clearProgress
+		}), "authenticate", "prisma_auth_command_failed");
+		yield* Effect.sync(() => {
+			showProgress("Checking Prisma workspace...");
+			if (options.verbose) log.step("Checking Prisma workspace.", { output });
+		});
+		const selectedWorkspace = yield* atCreateStage(selectDeploymentWorkspace({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			shouldPrompt: options.shouldPromptForWorkspace,
+			authState,
+			output,
+			beforePrompt: clearProgress,
+			afterPrompt: () => showProgress("Selecting Prisma workspace..."),
+			...options.workspace ? { workspace: options.workspace } : {}
+		}), "select_workspace", "workspace_selection_failed");
+		yield* Effect.sync(() => {
+			showProgress("Checking Prisma project name...");
+			if (options.verbose) log.step("Checking Prisma project name.", { output });
+		});
+		yield* atCreateStage(ensureProjectNameAvailable({
+			appName: options.appName,
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			workspace: selectedWorkspace
+		}), "check_project_name", "project_lookup_failed");
+		yield* Effect.sync(() => {
+			showProgress("Building for deployment...");
+			if (options.verbose) log.step("Building for deployment.", { output });
+		});
+		const build = getRunScriptArgs(options.packageManager, "build");
+		yield* atCreateStage(runSetupCommand({
+			command: build.command,
+			args: build.args,
+			cwd: options.projectDir,
+			env: process.env,
+			verbose: options.verbose,
+			json: options.json === true
+		}), "build", "build_failed");
+		const deployCommand = getLocalPackageBinaryCommand(options.packageManager, "prisma", ["deploy", "module.ts"]);
+		yield* Effect.sync(() => {
+			clearProgress();
+			if (options.verbose) log.step(`Deploying to Prisma with ${deployCommand}.`, { output });
+			else {
+				deploymentLog = taskLog({
+					title: "Deploying to Prisma...",
+					limit: 10,
+					output
+				});
+				deploymentLog.message(`$ ${deployCommand}`);
+			}
+		});
+		const deployment = parseComposerDeployResult(yield* atCreateStage(decodePrismaCommandResult(ComposerDeployCommandResultSchema, yield* atCreateStage(runPrismaJsonCommandEffect({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			args: ["deploy", "module.ts"],
+			onStderrLine: (line) => {
+				const redacted = redactSecrets(line);
+				if (options.verbose) output.write(`${redacted}\n`);
+				else deploymentLog?.message(redacted);
+			}
+		}), "composer_deploy", "composer_deploy_failed")), "composer_deploy", "composer_deploy_failed"));
+		const appName = deployment?.appName ?? options.appName;
+		yield* Effect.sync(() => {
+			if (options.verbose) log.step("Loading deployment details.", { output });
+			else deploymentLog?.message("Loading deployment details...");
+		});
+		const details = yield* getProjectDetails({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			appName
+		});
+		yield* Effect.sync(() => {
+			deploymentLog?.success("Deployed to Prisma.");
+			deploymentLog = void 0;
+			progressRunning = false;
+			if (options.verbose) log.success("Deployed to Prisma.", { output });
+		});
+		return {
+			appName,
+			...deployment?.appUrl ? { appUrl: deployment.appUrl } : {},
+			...deployment?.serviceId ? { serviceId: deployment.serviceId } : {},
+			workspace: details?.workspace ?? selectedWorkspace,
+			project: details?.project ?? { name: appName }
+		};
+	}).pipe(Effect.tapCause((cause) => Effect.sync(() => {
+		const error = Cause.squash(cause);
+		if (deploymentLog) {
+			deploymentLog.error("Deployment failed.");
+			deploymentLog = void 0;
+		} else progress?.error("Deployment failed.");
+		progressRunning = false;
+		if (!(error instanceof CreateCancellationError)) log.error(`Deploy failed: ${getErrorMessage(error)}`, { output });
+	})), Effect.mapError((error) => error instanceof CreateFailure ? new CreateFailure({
+		stage: error.stage,
+		reason: error.reason,
+		message: error.message,
+		cause: error.cause,
+		errorReported: true
+	}) : error));
+});
+
+//#endregion
+//#region src/tasks/initialize-git.ts
+const initializeGitRepositoryEffect = Effect.fn("Git.initialize")(function* (projectDir, env = process.env) {
+	const runner = yield* CommandRunner;
+	const fs = yield* FileSystem.FileSystem;
+	const existing = yield* runner.run({
+		command: "git",
+		args: ["rev-parse", "--is-inside-work-tree"],
+		cwd: projectDir,
+		env
+	}).pipe(Effect.result);
+	if (Result.isFailure(existing)) return {
+		status: "skipped",
+		reason: getErrorMessage(existing.failure)
+	};
+	if (existing.success.exitCode === 0 && existing.success.stdout.trim() === "true") return { status: "already-in-repository" };
+	return yield* Effect.gen(function* () {
+		yield* runner.runChecked({
+			command: "git",
+			args: ["init"],
+			cwd: projectDir,
+			env
+		});
+		yield* runner.runChecked({
+			command: "git",
+			args: ["add", "--all"],
+			cwd: projectDir,
+			env
+		});
+		yield* runner.runChecked({
+			command: "git",
+			args: [
+				"commit",
+				"--no-verify",
+				"-m",
+				"Initial commit from create-prisma"
+			],
+			cwd: projectDir,
+			env
+		});
+		return { status: "initialized" };
+	}).pipe(Effect.catch((error) => fs.remove(path.join(projectDir, ".git"), {
+		recursive: true,
+		force: true
+	}).pipe(Effect.catch(() => Effect.void), Effect.as({
+		status: "skipped",
+		reason: getErrorMessage(error)
+	}))));
+});
+
+//#endregion
+//#region src/tasks/prisma-setup/commands.ts
+const getContractPath = (authoring) => `src/prisma/contract${authoring === "typescript" ? ".ts" : ".prisma"}`;
+const getInitTarget = (provider) => provider === "mongo" ? "mongodb" : "postgres";
+const runPrismaCli = Effect.fn("PrismaSetup.runCli")(function* (context, projectDir, args) {
+	const invocation = getLocalPackageBinaryArgs(context.packageManager, "prisma", args);
+	yield* Effect.sync(() => {
+		if (context.verbose) log.step([invocation.command, ...invocation.args].join(" "), { output: context.output });
+	});
+	yield* runSetupCommand({
+		command: invocation.command,
+		args: invocation.args,
+		cwd: projectDir,
+		env: {
+			...process.env,
+			CI: "1"
+		},
+		verbose: context.verbose,
+		json: context.json
+	});
+});
+const runPrismaInit = Effect.fn("PrismaSetup.init")(function* (context, projectDir) {
+	yield* runPrismaCli(context, projectDir, [
+		"orm",
+		"init",
+		"--yes",
+		"--no-interactive",
+		"--target",
+		getInitTarget(context.databaseProvider),
+		"--authoring",
+		context.authoring,
+		"--schema-path",
+		getContractPath(context.authoring),
+		"--skip-install"
+	]);
+	if (context.packageManager === "deno") yield* (yield* FileSystem.FileSystem).remove(path.join(projectDir, "prisma-next.md"), { force: true });
+});
+const initializeAgentSkills = Effect.fn("PrismaSetup.initializeSkills")(function* (context, projectDir) {
+	if (context.packageManager === "deno") return;
+	yield* runPrismaCli(context, projectDir, [
+		"init",
+		"--yes",
+		"--no-interactive"
+	]);
+});
+
+//#endregion
+//#region src/ui/output.ts
+const silentOutput = new Writable({ write(_chunk, _encoding, callback) {
+	callback();
+} });
+/** Resolves the shared interaction policy for human and machine-readable modes. */
+function resolveExecutionSettings(options) {
+	const json = options.json === true;
+	return {
+		json,
+		output: json ? silentOutput : process.stdout,
+		useDefaults: options.yes === true || json
+	};
+}
+
+//#endregion
+//#region src/tasks/prisma-setup/context.ts
+const DEFAULT_DATABASE_PROVIDER = "postgres";
+const DEFAULT_AUTHORING = "psl";
+const decodePromptValue = (schema, value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new CreateFailure({
+	stage: "collect_context",
+	reason: "invalid_input",
+	message: cause.message,
+	cause
+})));
+const promptForDatabaseProvider = Effect.fn("Prompts.databaseProvider")(function* (output) {
+	const value = yield* Effect.tryPromise(() => select({
+		message: "Select your database",
+		initialValue: DEFAULT_DATABASE_PROVIDER,
+		options: [{
+			value: "postgres",
+			label: "PostgreSQL",
+			hint: "Prisma Postgres with Composer"
+		}, {
+			value: "mongo",
+			label: "MongoDB",
+			hint: "Connect an existing MongoDB database"
+		}],
+		output
+	}));
+	if (isCancel(value)) {
+		yield* Effect.sync(() => cancel("Operation cancelled.", { output }));
+		return yield* new CreateCancellationError({ stage: "database_provider" });
+	}
+	return yield* decodePromptValue(DatabaseProviderSchema, value);
+});
+const promptForAuthoringStyle = Effect.fn("Prompts.authoringStyle")(function* (output) {
+	const value = yield* Effect.tryPromise(() => select({
+		message: "Choose contract authoring style",
+		initialValue: DEFAULT_AUTHORING,
+		options: [{
+			value: "psl",
+			label: "PSL",
+			hint: "Prisma schema syntax"
+		}, {
+			value: "typescript",
+			label: "TypeScript",
+			hint: "TypeScript contract builder"
+		}],
+		output
+	}));
+	if (isCancel(value)) {
+		yield* Effect.sync(() => cancel("Operation cancelled.", { output }));
+		return yield* new CreateCancellationError({ stage: "authoring_style" });
+	}
+	return yield* decodePromptValue(AuthoringStyleSchema, value);
+});
+const packageManagerHint = (option, detected) => {
+	const hints = {
+		npm: "Node.js default",
+		pnpm: "Fast, disk-efficient package manager",
+		yarn: "Yarn package manager",
+		bun: "Fast runtime and package manager",
+		deno: "Deno runtime (minimal PostgreSQL apps)"
+	};
+	return option === detected ? `Detected; ${hints[option]}` : hints[option];
+};
+const promptForPackageManager = Effect.fn("Prompts.packageManager")(function* (detected, output) {
+	const value = yield* Effect.tryPromise(() => select({
+		message: "Choose package manager",
+		initialValue: detected,
+		options: packageManagers.map((packageManager) => ({
+			value: packageManager,
+			label: packageManager,
+			hint: packageManagerHint(packageManager, detected)
+		})),
+		output
+	}));
+	if (isCancel(value)) {
+		yield* Effect.sync(() => cancel("Operation cancelled.", { output }));
+		return yield* new CreateCancellationError({ stage: "package_manager" });
+	}
+	return yield* decodePromptValue(PackageManagerSchema, value);
+});
+const promptForDeployment = Effect.fn("Prompts.deployment")(function* (output) {
+	const value = yield* Effect.tryPromise(() => confirm({
+		message: "Deploy to Prisma now?",
+		initialValue: true,
+		output
+	}));
+	if (isCancel(value)) {
+		yield* Effect.sync(() => cancel("Operation cancelled.", { output }));
+		return yield* new CreateCancellationError({ stage: "deployment_intent" });
+	}
+	return Boolean(value);
+});
+const collectPrismaSetupContextEffect = Effect.fn("PrismaSetup.collectContext")(function* (input, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? process.cwd());
+	const { json, output, useDefaults } = resolveExecutionSettings(input);
+	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : yield* promptForDatabaseProvider(output));
+	const authoring = input.authoring ?? (useDefaults ? DEFAULT_AUTHORING : yield* promptForAuthoringStyle(output));
+	const detectedPackageManager = yield* detectPackageManagerEffect(projectDir);
+	const packageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : yield* promptForPackageManager(detectedPackageManager, output));
+	if (packageManager === "deno" && databaseProvider !== "postgres") return yield* new CreateFailure({
+		stage: "collect_context",
+		reason: "unsupported_configuration",
+		message: "Deno support currently requires PostgreSQL."
+	});
+	if (packageManager === "deno" && options.template && options.template !== "minimal") return yield* new CreateFailure({
+		stage: "collect_context",
+		reason: "unsupported_configuration",
+		message: "Deno support currently requires the minimal template."
+	});
+	if (packageManager === "deno" && input.deploy === true) return yield* new CreateFailure({
+		stage: "collect_context",
+		reason: "unsupported_configuration",
+		message: "Prisma Compute does not support Deno deployments yet. Use --no-deploy."
+	});
+	const shouldDeploy = packageManager === "deno" ? false : input.deploy ?? (json ? true : useDefaults ? false : yield* promptForDeployment(output));
+	return {
+		projectDir,
+		verbose: input.verbose === true,
+		json,
+		output,
+		databaseProvider,
+		authoring,
+		packageManager,
+		shouldDeploy,
+		shouldPromptForWorkspace: !useDefaults,
+		...input.workspace ? { workspace: input.workspace } : {}
+	};
+});
+
+//#endregion
+//#region src/tasks/prisma-setup/project-files.ts
+const ensureGitignoreEntry = Effect.fn("PrismaSetup.ensureGitignoreEntry")(function* (projectDir, entry) {
+	const fs = yield* FileSystem.FileSystem;
+	const gitignorePath = path.join(projectDir, ".gitignore");
+	const existing = (yield* fs.exists(gitignorePath)) ? yield* fs.readFileString(gitignorePath) : "";
+	const entries = existing.split(/\r?\n/).map((line) => line.trim());
+	if (entries.includes(entry) || entries.includes(`/${entry}`)) return;
+	const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+	yield* fs.writeFileString(gitignorePath, `${existing}${separator}${entry}\n`);
+});
+const ensureMongoEnvironment = Effect.fn("PrismaSetup.ensureMongoEnvironment")(function* (projectDir) {
+	const fs = yield* FileSystem.FileSystem;
+	const envPath = path.join(projectDir, ".env");
+	if (!(yield* fs.exists(envPath))) yield* fs.writeFileString(envPath, "DATABASE_URL=\"mongodb://localhost:27017/mydb?replicaSet=rs0&directConnection=true\"\n");
+	yield* ensureGitignoreEntry(projectDir, ".env");
+});
+const ensureComposerTypeScriptOptions = Effect.fn("PrismaSetup.ensureComposerTypeScriptOptions")(function* (projectDir) {
+	const fs = yield* FileSystem.FileSystem;
+	const tsconfigPath = path.join(projectDir, "tsconfig.json");
+	const tsconfig = yield* fs.readFileString(tsconfigPath);
+	const additions = [];
+	if (!/"allowImportingTsExtensions"\s*:/.test(tsconfig)) additions.push("    \"allowImportingTsExtensions\": true,");
+	if (!/"noEmit"\s*:/.test(tsconfig)) additions.push("    \"noEmit\": true,");
+	if (additions.length === 0) return;
+	const updated = tsconfig.replace(/"compilerOptions"\s*:\s*\{/, (match) => `${match}\n${additions.join("\n")}`);
+	if (updated === tsconfig) return yield* Effect.fail(/* @__PURE__ */ new Error("tsconfig.json is missing compilerOptions."));
+	yield* fs.writeFileString(tsconfigPath, updated);
+});
+
+//#endregion
+//#region src/tasks/prisma-setup/presentation.ts
+const formatNextSteps = (steps) => steps.map((step) => `${step.command}\n  ${step.description}`).join("\n\n");
+const formatPlatformTarget = (name, id) => name ? `${name} (${id})` : id;
+function formatProjectSummary(options) {
+	const lines = [];
+	if (options.createdProjectPath) lines.push(`Path: ${path.resolve(options.createdProjectPath)}`);
+	if (options.deployment?.workspace) lines.push(`Workspace: ${formatPlatformTarget(options.deployment.workspace.name, options.deployment.workspace.id)}`);
+	if (options.deployment) {
+		lines.push(`Project: ${options.deployment.project.id ? formatPlatformTarget(options.deployment.project.name, options.deployment.project.id) : options.deployment.project.name}`);
+		lines.push(`App: ${options.deployment.appUrl ?? options.deployment.appName}`);
+		if (options.deployment.project.consoleUrl) lines.push(`Console: ${options.deployment.project.consoleUrl}`);
+	}
+	return lines.join("\n");
+}
+function buildNextSteps(context, options) {
+	const nextSteps = [...options.prependNextSteps ?? []];
+	if (context.databaseProvider === "mongo") nextSteps.push({
+		command: "Set MONGODB_URL in your environment",
+		description: "Composer uses this secret when deploying the MongoDB template."
+	});
+	if (options.includeDevNextStep) nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, context.packageManager === "deno" ? "dev" : "dev:composer"),
+		description: context.packageManager === "deno" ? "Start the Deno app after setting DATABASE_URL in .env." : "Build and start the app with Prisma Composer locally."
+	});
+	if (context.packageManager !== "deno") nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "deploy"),
+		description: "Build and deploy the app with Prisma Composer."
+	});
+	return nextSteps;
+}
+
+//#endregion
+//#region src/tasks/setup-prisma.ts
+const executePrismaSetupContextEffect = Effect.fn("PrismaSetup.execute")(function* (context, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
+	const projectName = options.projectName ?? path.basename(projectDir);
+	const template = options.template ?? "minimal";
+	const progress = context.verbose ? void 0 : options.progressSpinner ?? spinner({ output: context.output });
+	const ownsProgress = progress !== void 0 && !options.progressSpinner;
+	let gitInitialization;
+	if (ownsProgress) yield* Effect.sync(() => progress.start("Creating Prisma 8 project..."));
+	yield* Effect.gen(function* () {
+		yield* atCreateStage(writePrismaDependenciesEffect(context.databaseProvider, context.packageManager, context.authoring, projectDir), "configure_project", "project_configuration_failed");
+		yield* Effect.sync(() => progress?.message(`Installing dependencies with ${getInstallCommand(context.packageManager)}...`));
+		yield* atCreateStage(installProjectDependenciesEffect(context.packageManager, projectDir, {
+			verbose: context.verbose,
+			json: context.json
+		}), "install_dependencies", "dependency_install_failed");
+		yield* Effect.sync(() => progress?.message("Preparing Prisma 8 project files..."));
+		yield* atCreateStage(runPrismaInit(context, projectDir), "initialize_prisma", "prisma_init_failed");
+		yield* atCreateStage(Effect.gen(function* () {
+			yield* scaffoldCreateSharedTemplatesEffect({
+				projectDir,
+				projectName,
+				template,
+				provider: context.databaseProvider,
+				authoring: context.authoring,
+				packageManager: context.packageManager
+			});
+			yield* ensureComposerTypeScriptOptions(projectDir);
+			if (context.databaseProvider === "mongo") yield* ensureMongoEnvironment(projectDir);
+			if (context.packageManager !== "deno") {
+				yield* ensureGitignoreEntry(projectDir, "/.alchemy");
+				yield* ensureGitignoreEntry(projectDir, "/.prisma-composer");
+			}
+		}), "configure_project", "project_configuration_failed");
+		yield* Effect.sync(() => progress?.message("Installing Prisma agent skills..."));
+		yield* atCreateStage(initializeAgentSkills(context, projectDir), "initialize_agent_skills", "agent_skills_init_failed");
+		yield* Effect.sync(() => progress?.message("Generating Prisma 8 contract artifacts..."));
+		yield* atCreateStage(runPrismaCli(context, projectDir, ["contract", "emit"]), "emit_contract", "contract_emit_failed");
+		if (context.databaseProvider === "postgres") {
+			yield* Effect.sync(() => progress?.message("Authoring the baseline migration..."));
+			yield* atCreateStage(runPrismaCli(context, projectDir, [
+				"migration",
+				"plan",
+				"--name",
+				"init"
+			]), "plan_migration", "migration_plan_failed");
+		}
+		if (options.initializeGit) {
+			yield* Effect.sync(() => progress?.message("Initializing Git repository..."));
+			gitInitialization = yield* atCreateStage(initializeGitRepositoryEffect(projectDir), "initialize_git", "git_initialization_failed");
+		}
+	}).pipe(Effect.tap(() => Effect.sync(() => {
+		progress?.stop("Prisma 8 project ready.");
+		if (gitInitialization?.status === "initialized" && context.verbose) log.success("Initialized Git repository with an initial commit.", { output: context.output });
+		else if (gitInitialization?.status === "skipped") log.warn(`Could not initialize Git repository: ${gitInitialization.reason}`, { output: context.output });
+	})), Effect.tapError((error) => Effect.sync(() => {
+		progress?.error("Could not create Prisma 8 project.");
+		if (!(error instanceof CreateCancellationError)) cancel(getErrorMessage(error), { output: context.output });
+	})), Effect.mapError((error) => error instanceof CreateFailure ? new CreateFailure({
+		stage: error.stage,
+		reason: error.reason,
+		message: error.message,
+		cause: error.cause,
+		errorReported: true
+	}) : error));
+	const deployment = context.shouldDeploy ? yield* deployNewProjectWithComposerEffect({
+		appName: projectName,
+		packageManager: context.packageManager,
+		projectDir,
+		shouldPromptForWorkspace: context.shouldPromptForWorkspace,
+		verbose: context.verbose,
+		output: context.output,
+		allowInteractiveLogin: !context.json,
+		json: context.json,
+		...context.workspace ? { workspace: context.workspace } : {}
+	}) : null;
+	const nextSteps = buildNextSteps(context, options);
+	const warnings = gitInitialization?.status === "skipped" ? [`Could not initialize Git repository: ${gitInitialization.reason}`] : [];
+	const projectSummary = formatProjectSummary({
+		createdProjectPath: options.createdProjectPath,
+		...deployment ? { deployment } : {}
+	});
+	yield* Effect.sync(() => {
+		if (projectSummary) note(projectSummary, context.shouldDeploy ? "Deployment" : "Project", { output: context.output });
+		note(formatNextSteps(nextSteps), "Next steps", { output: context.output });
+		outro(context.shouldDeploy ? "Prisma 8 app deployed." : "Prisma 8 project ready.", { output: context.output });
+	});
+	return {
+		deployment,
+		nextSteps,
+		...gitInitialization ? { gitInitialization } : {},
+		warnings
+	};
+});
+
+//#endregion
+//#region src/ui/branding.ts
+const prismaTitle = `${styleText(["bold", "cyanBright"], "◭")} ${styleText(["bold", "cyanBright"], "Create")} ${styleText(["bold", "magentaBright"], "Prisma")} ${styleText(["bold", "blueBright"], "8")}`;
+function getCreatePrismaIntro() {
+	return prismaTitle;
+}
+
+//#endregion
+//#region src/utils/node-version.ts
+const MINIMUM_NODE_VERSION = [
+	22,
+	18,
+	0
+];
+function parseVersion(version) {
+	const [major = "0", minor = "0", patch = "0"] = version.replace(/^v/, "").split(".");
+	return [
+		Number(major),
+		Number(minor),
+		Number.parseInt(patch, 10)
+	];
+}
+function supportsPrisma(nodeVersion = process.versions.node) {
+	const current = parseVersion(nodeVersion);
+	for (let index = 0; index < MINIMUM_NODE_VERSION.length; index += 1) {
+		if (current[index] > MINIMUM_NODE_VERSION[index]) return true;
+		if (current[index] < MINIMUM_NODE_VERSION[index]) return false;
+	}
+	return true;
+}
+function getUnsupportedNodeMessage(nodeVersion = process.versions.node) {
+	return [
+		`Node.js ${nodeVersion} is unsupported by create-prisma@latest.`,
+		"Required: Node.js 22.18 or newer.",
+		"Update Node.js and run the command again."
+	].join("\n");
+}
+
+//#endregion
+//#region src/commands/create-context.ts
+const DEFAULT_PROJECT_NAME = "my-app";
+const DEFAULT_TEMPLATE = "minimal";
+const toPackageName = (projectName) => projectName.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+/, "").replace(/-+$/, "") || "app";
+const formatPathForDisplay = (filePath) => path.relative(process.cwd(), filePath) || ".";
+function validateProjectName(value) {
+	const trimmed = String(value ?? "").trim();
+	if (trimmed.length === 0) return "Please enter a project name.";
+	if (trimmed === "..") return "Project name cannot be '..'.";
+	if (path.isAbsolute(trimmed)) return "Use a relative project name instead of an absolute path.";
+}
+const createProjectResult = (context) => ({
+	name: context.projectPackageName,
+	path: context.targetDirectory,
+	template: context.template,
+	databaseProvider: context.prismaSetupContext.databaseProvider,
+	authoring: context.prismaSetupContext.authoring,
+	packageManager: context.prismaSetupContext.packageManager
+});
+const promptForProjectName = Effect.fn("Prompts.projectName")(function* (output) {
+	const value = yield* Effect.tryPromise(() => text({
+		message: "Project name",
+		placeholder: DEFAULT_PROJECT_NAME,
+		initialValue: DEFAULT_PROJECT_NAME,
+		validate: validateProjectName,
+		output
+	}));
+	if (isCancel(value)) {
+		yield* Effect.sync(() => cancel("Operation cancelled.", { output }));
+		return yield* new CreateCancellationError({ stage: "project_name" });
+	}
+	return String(value).trim();
+});
+const promptForCreateTemplate = Effect.fn("Prompts.template")(function* (output) {
+	const value = yield* Effect.tryPromise(() => select({
+		message: "Select template",
+		initialValue: DEFAULT_TEMPLATE,
+		options: [
+			{
+				value: "minimal",
+				label: "Minimal",
+				hint: "Script-first Prisma 8 starter with no web framework"
+			},
+			{
+				value: "hono",
+				label: "Hono",
+				hint: "Lightweight TypeScript API server"
+			},
+			{
+				value: "elysia",
+				label: "Elysia",
+				hint: "Bun-friendly TypeScript API server"
+			},
+			{
+				value: "nest",
+				label: "NestJS",
+				hint: "Structured Node API with controllers and services"
+			},
+			{
+				value: "next",
+				label: "Next.js",
+				hint: "Full-stack React app with App Router"
+			},
+			{
+				value: "svelte",
+				label: "SvelteKit",
+				hint: "Full-stack Svelte 5 app with Vite"
+			},
+			{
+				value: "astro",
+				label: "Astro",
+				hint: "Content-oriented web app with server routes"
+			},
+			{
+				value: "nuxt",
+				label: "Nuxt",
+				hint: "Full-stack Vue app with Nitro server routes"
+			},
+			{
+				value: "tanstack-start",
+				label: "TanStack Start",
+				hint: "React app with file routes and server functions"
+			}
+		],
+		output
+	}));
+	if (isCancel(value)) {
+		yield* Effect.sync(() => cancel("Operation cancelled.", { output }));
+		return yield* new CreateCancellationError({ stage: "template" });
+	}
+	return yield* Schema.decodeUnknownEffect(CreateTemplateSchema)(value).pipe(Effect.mapError((cause) => new CreateFailure({
+		stage: "collect_context",
+		reason: "invalid_input",
+		message: cause.message,
+		cause
+	})));
+});
+const inspectTargetPath = Effect.fn("Create.inspectTargetPath")(function* (targetPath) {
+	const fs = yield* FileSystem.FileSystem;
+	if (!(yield* fs.exists(targetPath))) return {
+		exists: false,
+		isDirectory: true,
+		isEmptyDirectory: true
+	};
+	if ((yield* fs.stat(targetPath)).type !== "Directory") return {
+		exists: true,
+		isDirectory: false,
+		isEmptyDirectory: false
+	};
+	return {
+		exists: true,
+		isDirectory: true,
+		isEmptyDirectory: (yield* fs.readDirectory(targetPath)).length === 0
+	};
+});
+const collectCreateContext = Effect.fn("Create.collectContext")(function* (input) {
+	const force = input.force === true;
+	const { output, useDefaults } = resolveExecutionSettings(input);
+	const projectName = String(input.name ?? (useDefaults ? DEFAULT_PROJECT_NAME : yield* promptForProjectName(output))).trim();
+	const validationError = validateProjectName(projectName);
+	if (validationError) {
+		yield* Effect.sync(() => cancel(validationError, { output }));
+		return yield* new CreateFailure({
+			stage: "collect_context",
+			reason: "invalid_project_name",
+			message: validationError,
+			errorReported: true
+		});
+	}
+	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : yield* promptForCreateTemplate(output));
+	const targetDirectory = path.resolve(process.cwd(), projectName);
+	const targetPathState = yield* inspectTargetPath(targetDirectory);
+	if (targetPathState.exists && !targetPathState.isDirectory) {
+		const message = `Target path ${formatPathForDisplay(targetDirectory)} already exists and is not a directory. Choose a different project name.`;
+		yield* Effect.sync(() => cancel(message, { output }));
+		return yield* new CreateFailure({
+			stage: "collect_context",
+			reason: "target_path_not_directory",
+			message,
+			errorReported: true
+		});
+	}
+	if (targetPathState.exists && !targetPathState.isEmptyDirectory && !force) {
+		const message = `Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`;
+		yield* Effect.sync(() => cancel(message, { output }));
+		return yield* new CreateFailure({
+			stage: "collect_context",
+			reason: "target_directory_not_empty",
+			message,
+			errorReported: true
+		});
+	}
+	const prismaSetupContext = yield* collectPrismaSetupContextEffect(input, {
+		projectDir: targetDirectory,
+		template
+	});
+	return {
+		targetDirectory,
+		targetPathState,
+		force,
+		template,
+		projectPackageName: toPackageName(path.basename(targetDirectory)),
+		prismaSetupContext
+	};
+});
+
+//#endregion
+//#region src/commands/create.ts
+const executeCreateContext = Effect.fn("Create.execute")(function* (context) {
+	const output = context.prismaSetupContext.output;
+	const createSpinner = context.prismaSetupContext.verbose ? void 0 : spinner({ output });
+	yield* Effect.sync(() => {
+		createSpinner?.start("Creating Prisma 8 project...");
+		if (context.prismaSetupContext.verbose) log.step(`Scaffolding ${context.template} starter.`, { output });
+	});
+	yield* atCreateStage(scaffoldCreateFrameworkTemplateEffect({
+		projectDir: context.targetDirectory,
+		projectName: context.projectPackageName,
+		template: context.template,
+		provider: context.prismaSetupContext.databaseProvider,
+		authoring: context.prismaSetupContext.authoring,
+		packageManager: context.prismaSetupContext.packageManager
+	}).pipe(Effect.andThen(writeCreateTemplateDependenciesEffect({
+		template: context.template,
+		packageManager: context.prismaSetupContext.packageManager,
+		projectDir: context.targetDirectory
+	})), Effect.tap(() => Effect.sync(() => {
+		if (context.prismaSetupContext.verbose) log.success("Starter files scaffolded.", { output });
+	})), Effect.tapError(() => Effect.sync(() => createSpinner?.error("Could not create Prisma 8 project.")))), "scaffold_template", "template_scaffold_failed");
+	const forceWarning = context.targetPathState.exists && !context.targetPathState.isEmptyDirectory && context.force ? `Used --force in non-empty directory ${formatPathForDisplay(context.targetDirectory)}.` : void 0;
+	if (forceWarning) yield* Effect.sync(() => log.warn(forceWarning, { output }));
+	const nextSteps = formatPathForDisplay(context.targetDirectory) === "." ? [] : [{
+		command: `cd ${formatPathForDisplay(context.targetDirectory)}`,
+		description: "Enter your new project directory."
+	}];
+	const setup = yield* executePrismaSetupContextEffect(context.prismaSetupContext, {
+		prependNextSteps: nextSteps,
+		projectDir: context.targetDirectory,
+		projectName: context.projectPackageName,
+		template: context.template,
+		createdProjectPath: context.targetDirectory,
+		includeDevNextStep: true,
+		initializeGit: !context.targetPathState.exists || context.targetPathState.isEmptyDirectory,
+		progressSpinner: createSpinner
+	});
+	const warnings = [...setup.warnings];
+	if (forceWarning) warnings.unshift(forceWarning);
+	return {
+		schemaVersion: CREATE_PRISMA_RESULT_SCHEMA_VERSION,
+		ok: true,
+		project: createProjectResult(context),
+		deployment: setup.deployment,
+		nextSteps: setup.nextSteps,
+		warnings
+	};
+});
+const createProjectEffect = Effect.fn("Create.project")(function* (rawInput, inputRef, contextRef) {
+	const input = yield* decodeCreateCommandInput(rawInput).pipe(Effect.mapError((cause) => new CreateFailure({
+		stage: "validate_input",
+		reason: "invalid_input",
+		message: cause.message,
+		cause
+	})));
+	yield* Ref.set(inputRef, input);
+	const { output } = resolveExecutionSettings(input);
+	if (input.json && input.verbose) return yield* new CreateFailure({
+		stage: "validate_input",
+		reason: "invalid_input",
+		message: "--verbose cannot be used with --json because JSON mode is output-only."
+	});
+	if (!supportsPrisma()) {
+		const message = getUnsupportedNodeMessage();
+		yield* Effect.sync(() => cancel(message, { output }));
+		return yield* new CreateFailure({
+			stage: "validate_input",
+			reason: "unsupported_node_version",
+			message,
+			errorReported: true
+		});
+	}
+	yield* Effect.sync(() => intro(getCreatePrismaIntro(), { output }));
+	const context = yield* atCreateStage(collectCreateContext(input), "collect_context", "unexpected_error");
+	yield* Ref.set(contextRef, Option.some(context));
+	return {
+		input,
+		context,
+		result: yield* executeCreateContext(context)
+	};
+});
+const runCreateCommandEffect = Effect.fn("Create.run")(function* (rawInput = {}) {
+	const startedAt = yield* Clock.currentTimeMillis;
+	const inputRef = yield* Ref.make(rawInput);
+	const contextRef = yield* Ref.make(Option.none());
+	const exit = yield* Effect.exit(createProjectEffect(rawInput, inputRef, contextRef));
+	const durationMs = (yield* Clock.currentTimeMillis) - startedAt;
+	if (Exit.isSuccess(exit)) {
+		yield* trackCreateCompletedEffect({
+			input: exit.value.input,
+			context: exit.value.context,
+			durationMs
+		});
+		return exit.value.result;
+	}
+	const error = Cause.squash(exit.cause);
+	const input = yield* Ref.get(inputRef);
+	const context = Option.getOrUndefined(yield* Ref.get(contextRef));
+	if (error instanceof CreateCancellationError) {
+		yield* trackCreateCancelledEffect({
+			input,
+			...context ? { context } : {},
+			durationMs,
+			stage: error.stage
+		});
+		return createCommandFailureResult(error.stage, error.message ?? "Operation cancelled.", context ? createProjectResult(context) : void 0);
+	}
+	const failure = error instanceof CreateFailure ? error : new CreateFailure({
+		stage: "unknown",
+		reason: "unexpected_error",
+		message: getErrorMessage(error),
+		cause: error
+	});
+	const { output } = resolveExecutionSettings(rawInput);
+	if (!failure.errorReported) yield* Effect.sync(() => cancel(`Create command failed: ${failure.message}`, { output }));
+	yield* trackCreateFailedEffect({
+		input,
+		...context ? { context } : {},
+		durationMs,
+		error: failure.cause ?? failure,
+		stage: failure.stage,
+		reason: failure.reason
+	});
+	return createCommandFailureResult(failure.stage, failure.message, context ? createProjectResult(context) : void 0);
+});
+
+//#endregion
+//#region src/ui/json-output.ts
+function isJsonOutputRequested(argv) {
+	let requested = false;
+	for (const [index, argument] of argv.entries()) {
+		if (argument === "--json") requested = argv[index + 1]?.toLowerCase() !== "false";
+		if (argument.startsWith("--json=")) requested = argument.slice(7).toLowerCase() !== "false";
+		if (argument === "--no-json") requested = false;
+	}
+	return requested;
+}
+const writeJsonResult = Effect.fn("JsonOutput.write")((result) => Effect.sync(() => process.stdout.write(`${JSON.stringify(result)}\n`)));
+
+//#endregion
+export { databaseProviderInputs as _, ApplicationLayer as a, CreateCommandResultSchema as c, CreateCommandInputSchema as d, CreateTemplateSchema as f, createTemplates as g, authoringStyles as h, getErrorMessage as i, createCommandFailureResult as l, PackageManagerSchema as m, writeJsonResult as n, applicationRuntime as o, DatabaseProviderSchema as p, runCreateCommandEffect as r, CREATE_PRISMA_RESULT_SCHEMA_VERSION as s, isJsonOutputRequested as t, AuthoringStyleSchema as u, normalizeDatabaseProvider as v, packageManagers as y };