create-prisma 0.11.2 → 0.11.3

package/dist/cli.mjs

@@ -1,63 +1,11 @@
 #!/usr/bin/env node
-import { c as createCommandFailureResult } from "./create-TR_gtjND.mjs";
-import { createCreatePrismaCli } from "./index.mjs";
+import { a as ApplicationLayer } from "./json-output-DzDD1nb9.mjs";
+import { runCreatePrismaCli } from "./index.mjs";
+import { Effect } from "effect";
+import { NodeRuntime } from "@effect/platform-node-shared";
 
-//#region src/ui/json-output.ts
-function isCreateCommandResult(value) {
-	if (typeof value !== "object" || value === null) return false;
-	return Reflect.get(value, "schemaVersion") === 1 && typeof Reflect.get(value, "ok") === "boolean";
-}
-function formatLoggerMessage(values) {
-	return values.map((value) => {
-		if (value instanceof Error) return value.message;
-		if (typeof value === "string") return value.trim();
-		try {
-			return JSON.stringify(value);
-		} catch {
-			return String(value);
-		}
-	}).filter(Boolean).join(" ");
-}
-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;
-}
-function createJsonOutputLogger(write = (output) => process.stdout.write(output)) {
-	let didWrite = false;
-	const writeResult = (result) => {
-		if (didWrite) return;
-		didWrite = true;
-		write(`${JSON.stringify(result)}\n`);
-	};
-	return {
-		info(...values) {
-			const result = values.length === 1 ? values[0] : void 0;
-			if (isCreateCommandResult(result)) {
-				writeResult(result);
-				return;
-			}
-			writeResult(createCommandFailureResult("parse_arguments", formatLoggerMessage(values) || "The CLI returned an unexpected result."));
-		},
-		error(...values) {
-			writeResult(createCommandFailureResult("parse_arguments", formatLoggerMessage(values) || "Could not parse command arguments."));
-		}
-	};
-}
-
-//#endregion
 //#region src/cli.ts
-createCreatePrismaCli().run({
-	...isJsonOutputRequested(process.argv) ? { logger: createJsonOutputLogger() } : {},
-	process: { exit(code) {
-		const commandExitCode = typeof process.exitCode === "number" && process.exitCode !== 0 ? process.exitCode : code;
-		process.exit(commandExitCode);
-	} }
-});
+runCreatePrismaCli().pipe(Effect.provide(ApplicationLayer), NodeRuntime.runMain({ disableErrorReporting: true }));
 
 //#endregion
 export {  };

package/dist/index.d.mts

@@ -1,348 +1,212 @@
 #!/usr/bin/env node
-import * as _orpc_server0 from "@orpc/server";
-import * as trpc_cli0 from "trpc-cli";
-import { z } from "zod";
-import { Writable } from "node:stream";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Command } from "effect/unstable/cli";
+import * as effect_FileSystem0 from "effect/FileSystem";
+import * as effect_Cause0 from "effect/Cause";
 
-//#region src/create-outcome.d.ts
-type CreateFailureStage = "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";
-type CreateCancellationStage = "project_name" | "template" | "database_provider" | "authoring_style" | "package_manager" | "deployment_intent" | "select_workspace";
+//#region src/services/command-runner.d.ts
+type CommandSpec = {
+  command: string;
+  args: readonly string[];
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+  stdio?: "pipe" | "inherit";
+  onStderrLine?: (line: string) => void;
+};
+type CommandResult = {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+};
+declare const CommandExecutionError_base: Schema.Class<CommandExecutionError, Schema.TaggedStruct<"CommandExecutionError", {
+  readonly command: Schema.String;
+  readonly args: Schema.$Array<Schema.String>;
+  readonly exitCode: Schema.optionalKey<Schema.Number>;
+  readonly stdout: Schema.String;
+  readonly stderr: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, effect_Cause0.YieldableError>;
+declare class CommandExecutionError extends CommandExecutionError_base {
+  get message(): string;
+}
+declare const CommandRunner_base: Context.ServiceClass<CommandRunner, "create-prisma/services/CommandRunner", {
+  run(spec: CommandSpec): Effect.Effect<CommandResult, CommandExecutionError>;
+  runChecked(spec: CommandSpec): Effect.Effect<CommandResult, CommandExecutionError>;
+}>;
+declare class CommandRunner extends CommandRunner_base {
+  static readonly layer: Layer.Layer<CommandRunner, never, never>;
+}
 //#endregion
 //#region src/types.d.ts
-declare const DatabaseProviderSchema: z.ZodPipe<z.ZodEnum<{
-  postgres: "postgres";
-  postgresql: "postgresql";
-  mongo: "mongo";
-  mongodb: "mongodb";
-}>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>;
-type DatabaseProvider = z.infer<typeof DatabaseProviderSchema>;
-declare const PackageManagerSchema: z.ZodEnum<{
-  npm: "npm";
-  pnpm: "pnpm";
-  yarn: "yarn";
-  bun: "bun";
-  deno: "deno";
-}>;
-type PackageManager = z.infer<typeof PackageManagerSchema>;
-declare const AuthoringStyleSchema: z.ZodEnum<{
-  psl: "psl";
-  typescript: "typescript";
-}>;
-type AuthoringStyle = z.infer<typeof AuthoringStyleSchema>;
-declare const CreateTemplateSchema: z.ZodEnum<{
-  minimal: "minimal";
-  hono: "hono";
-  elysia: "elysia";
-  nest: "nest";
-  next: "next";
-  svelte: "svelte";
-  astro: "astro";
-  nuxt: "nuxt";
-  "tanstack-start": "tanstack-start";
+declare const DatabaseProviderSchema: Schema.Literals<readonly ["postgres", "mongo"]>;
+declare const PackageManagerSchema: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun", "deno"]>;
+declare const AuthoringStyleSchema: Schema.Literals<readonly ["psl", "typescript"]>;
+declare const CreateTemplateSchema: Schema.Literals<readonly ["minimal", "hono", "elysia", "nest", "next", "svelte", "astro", "nuxt", "tanstack-start"]>;
+declare const CreateCommandInputSchema: Schema.Struct<{
+  readonly name: Schema.optionalKey<Schema.Trim>;
+  readonly template: Schema.optionalKey<Schema.Literals<readonly ["minimal", "hono", "elysia", "nest", "next", "svelte", "astro", "nuxt", "tanstack-start"]>>;
+  readonly force: Schema.optionalKey<Schema.Boolean>;
+  readonly provider: Schema.optionalKey<Schema.Literals<readonly ["postgres", "mongo"]>>;
+  readonly authoring: Schema.optionalKey<Schema.Literals<readonly ["psl", "typescript"]>>;
+  readonly packageManager: Schema.optionalKey<Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun", "deno"]>>;
+  readonly deploy: Schema.optionalKey<Schema.Boolean>;
+  readonly workspace: Schema.optionalKey<Schema.decodeTo<Schema.NonEmptyString, Schema.Trim, never, never>>;
+  readonly yes: Schema.optionalKey<Schema.Boolean>;
+  readonly verbose: Schema.optionalKey<Schema.Boolean>;
+  readonly json: Schema.optionalKey<Schema.Boolean>;
 }>;
-type CreateTemplate = z.infer<typeof CreateTemplateSchema>;
-declare const CreateCommandInputSchema: z.ZodObject<{
-  yes: z.ZodOptional<z.ZodBoolean>;
-  verbose: z.ZodOptional<z.ZodBoolean>;
-  json: z.ZodOptional<z.ZodBoolean>;
-  provider: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
-    postgres: "postgres";
-    postgresql: "postgresql";
-    mongo: "mongo";
-    mongodb: "mongodb";
-  }>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>>;
-  authoring: z.ZodOptional<z.ZodEnum<{
-    psl: "psl";
-    typescript: "typescript";
-  }>>;
-  packageManager: z.ZodOptional<z.ZodEnum<{
-    npm: "npm";
-    pnpm: "pnpm";
-    yarn: "yarn";
-    bun: "bun";
-    deno: "deno";
-  }>>;
-  deploy: z.ZodOptional<z.ZodBoolean>;
-  workspace: z.ZodOptional<z.ZodString>;
-  name: z.ZodOptional<z.ZodString>;
-  template: z.ZodOptional<z.ZodEnum<{
-    minimal: "minimal";
-    hono: "hono";
-    elysia: "elysia";
-    nest: "nest";
-    next: "next";
-    svelte: "svelte";
-    astro: "astro";
-    nuxt: "nuxt";
-    "tanstack-start": "tanstack-start";
-  }>>;
-  force: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type CreateCommandInput = z.infer<typeof CreateCommandInputSchema>;
+type CreateCommandInput = typeof CreateCommandInputSchema.Type;
 //#endregion
-//#region src/tasks/deploy-with-composer.d.ts
-type PrismaWorkspace = {
-  id: string;
-  name: string | null;
-};
-type ComposerDeployResult = {
-  appName: string;
-  appUrl?: string;
-  serviceId?: string;
-  workspace?: PrismaWorkspace;
-  project: {
-    id?: string;
-    name: string;
-    consoleUrl?: string;
-  };
-};
+//#region src/create-outcome.d.ts
+declare const CreateFailureStageSchema: Schema.Literals<readonly ["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"]>;
+type CreateFailureStage = typeof CreateFailureStageSchema.Type;
+declare const CreateCancellationStageSchema: Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "deployment_intent", "select_workspace"]>;
+type CreateCancellationStage = typeof CreateCancellationStageSchema.Type;
 //#endregion
 //#region src/result.d.ts
 declare const CREATE_PRISMA_RESULT_SCHEMA_VERSION: 1;
-type CreateNextStep = {
-  command: string;
-  description: string;
-};
-type CreateProjectResult = {
-  name: string;
-  path: string;
-  template: CreateTemplate;
-  databaseProvider: DatabaseProvider;
-  authoring: AuthoringStyle;
-  packageManager: PackageManager;
-};
+declare const CreateNextStepSchema: Schema.Struct<{
+  readonly command: Schema.String;
+  readonly description: Schema.String;
+}>;
+type CreateNextStep = typeof CreateNextStepSchema.Type;
+declare const CreateProjectResultSchema: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly path: Schema.String;
+  readonly template: Schema.Literals<readonly ["minimal", "hono", "elysia", "nest", "next", "svelte", "astro", "nuxt", "tanstack-start"]>;
+  readonly databaseProvider: Schema.Literals<readonly ["postgres", "mongo"]>;
+  readonly authoring: Schema.Literals<readonly ["psl", "typescript"]>;
+  readonly packageManager: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun", "deno"]>;
+}>;
+type CreateProjectResult = typeof CreateProjectResultSchema.Type;
 type CreateCommandFailureStage = CreateFailureStage | CreateCancellationStage | "parse_arguments";
-type CreateCommandSuccessResult = {
-  schemaVersion: typeof CREATE_PRISMA_RESULT_SCHEMA_VERSION;
-  ok: true;
-  project: CreateProjectResult;
-  deployment: ComposerDeployResult | null;
-  nextSteps: CreateNextStep[];
-  warnings: string[];
-};
-type CreateCommandFailureResult = {
-  schemaVersion: typeof CREATE_PRISMA_RESULT_SCHEMA_VERSION;
-  ok: false;
-  error: {
-    stage: CreateCommandFailureStage;
-    message: string;
-  };
-  project?: CreateProjectResult;
-};
-type CreateCommandResult = CreateCommandSuccessResult | CreateCommandFailureResult;
-//#endregion
-//#region node_modules/@orpc/client/dist/index.d.mts
-declare const COMMON_ORPC_ERROR_DEFS: {
-  readonly BAD_REQUEST: {
-    readonly status: 400;
-    readonly message: "Bad Request";
-  };
-  readonly UNAUTHORIZED: {
-    readonly status: 401;
-    readonly message: "Unauthorized";
-  };
-  readonly FORBIDDEN: {
-    readonly status: 403;
-    readonly message: "Forbidden";
-  };
-  readonly NOT_FOUND: {
-    readonly status: 404;
-    readonly message: "Not Found";
-  };
-  readonly METHOD_NOT_SUPPORTED: {
-    readonly status: 405;
-    readonly message: "Method Not Supported";
-  };
-  readonly NOT_ACCEPTABLE: {
-    readonly status: 406;
-    readonly message: "Not Acceptable";
-  };
-  readonly TIMEOUT: {
-    readonly status: 408;
-    readonly message: "Request Timeout";
-  };
-  readonly CONFLICT: {
-    readonly status: 409;
-    readonly message: "Conflict";
-  };
-  readonly PRECONDITION_FAILED: {
-    readonly status: 412;
-    readonly message: "Precondition Failed";
-  };
-  readonly PAYLOAD_TOO_LARGE: {
-    readonly status: 413;
-    readonly message: "Payload Too Large";
-  };
-  readonly UNSUPPORTED_MEDIA_TYPE: {
-    readonly status: 415;
-    readonly message: "Unsupported Media Type";
-  };
-  readonly UNPROCESSABLE_CONTENT: {
-    readonly status: 422;
-    readonly message: "Unprocessable Content";
-  };
-  readonly TOO_MANY_REQUESTS: {
-    readonly status: 429;
-    readonly message: "Too Many Requests";
-  };
-  readonly CLIENT_CLOSED_REQUEST: {
-    readonly status: 499;
-    readonly message: "Client Closed Request";
-  };
-  readonly INTERNAL_SERVER_ERROR: {
-    readonly status: 500;
-    readonly message: "Internal Server Error";
-  };
-  readonly NOT_IMPLEMENTED: {
-    readonly status: 501;
-    readonly message: "Not Implemented";
-  };
-  readonly BAD_GATEWAY: {
-    readonly status: 502;
-    readonly message: "Bad Gateway";
-  };
-  readonly SERVICE_UNAVAILABLE: {
-    readonly status: 503;
-    readonly message: "Service Unavailable";
-  };
-  readonly GATEWAY_TIMEOUT: {
-    readonly status: 504;
-    readonly message: "Gateway Timeout";
-  };
-};
-type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
-type ORPCErrorCode = CommonORPCErrorCode | (string & {});
-//#endregion
-//#region node_modules/@standard-schema/spec/dist/index.d.ts
-/** The Standard Typed interface. This is a base type extended by other specs. */
-interface StandardTypedV1<Input = unknown, Output = Input> {
-  /** The Standard properties. */
-  readonly "~standard": StandardTypedV1.Props<Input, Output>;
-}
-declare namespace StandardTypedV1 {
-  /** The Standard Typed properties interface. */
-  interface Props<Input = unknown, Output = Input> {
-    /** The version number of the standard. */
-    readonly version: 1;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
-    /** Inferred types associated with the schema. */
-    readonly types?: Types<Input, Output> | undefined;
-  }
-  /** The Standard Typed types interface. */
-  interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
-  }
-  /** Infers the input type of a Standard Typed. */
-  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-  /** Infers the output type of a Standard Typed. */
-  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-/** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard Schema properties. */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-  /** The Standard Schema properties interface. */
-  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
-  }
-  /** The result interface of the validate function. */
-  type Result<Output> = SuccessResult<Output> | FailureResult;
-  /** The result interface if validation succeeds. */
-  interface SuccessResult<Output> {
-    /** The typed output value. */
-    readonly value: Output;
-    /** A falsy value for `issues` indicates success. */
-    readonly issues?: undefined;
-  }
-  interface Options {
-    /** Explicit support for additional vendor-specific parameters, if needed. */
-    readonly libraryOptions?: Record<string, unknown> | undefined;
-  }
-  /** The result interface if validation fails. */
-  interface FailureResult {
-    /** The issues of failed validation. */
-    readonly issues: ReadonlyArray<Issue>;
-  }
-  /** The issue interface of the failure output. */
-  interface Issue {
-    /** The error message of the issue. */
-    readonly message: string;
-    /** The path of the issue, if any. */
-    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-  }
-  /** The path segment interface of the issue. */
-  interface PathSegment {
-    /** The key representing a path segment. */
-    readonly key: PropertyKey;
-  }
-  /** The Standard types interface. */
-  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
-  /** Infers the input type of a Standard. */
-  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
-  /** Infers the output type of a Standard. */
-  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
-}
-/** The Standard JSON Schema interface. */
-//#endregion
-//#region node_modules/@orpc/contract/dist/shared/contract.TuRtB1Ca.d.mts
-type Schema<TInput, TOutput> = StandardSchemaV1<TInput, TOutput>;
-type AnySchema = Schema<any, any>;
-interface ErrorMapItem<TDataSchema extends AnySchema> {
-  status?: number;
-  message?: string;
-  data?: TDataSchema;
-}
-type ErrorMap = { [key in ORPCErrorCode]?: ErrorMapItem<AnySchema> };
-type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
-//#endregion
-//#region src/index.d.ts
-declare const router: {
-  create: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, z.ZodTuple<[z.ZodOptional<z.ZodString>, z.ZodObject<{
-    yes: z.ZodOptional<z.ZodBoolean>;
-    verbose: z.ZodOptional<z.ZodBoolean>;
-    json: z.ZodOptional<z.ZodBoolean>;
-    provider: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
-      postgres: "postgres";
-      postgresql: "postgresql";
-      mongo: "mongo";
-      mongodb: "mongodb";
-    }>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>>;
-    authoring: z.ZodOptional<z.ZodEnum<{
-      psl: "psl";
-      typescript: "typescript";
-    }>>;
-    packageManager: z.ZodOptional<z.ZodEnum<{
-      npm: "npm";
-      pnpm: "pnpm";
-      yarn: "yarn";
-      bun: "bun";
-      deno: "deno";
+declare const CreateCommandSuccessResultSchema: Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly ok: Schema.Literal<true>;
+  readonly project: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly path: Schema.String;
+    readonly template: Schema.Literals<readonly ["minimal", "hono", "elysia", "nest", "next", "svelte", "astro", "nuxt", "tanstack-start"]>;
+    readonly databaseProvider: Schema.Literals<readonly ["postgres", "mongo"]>;
+    readonly authoring: Schema.Literals<readonly ["psl", "typescript"]>;
+    readonly packageManager: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun", "deno"]>;
+  }>;
+  readonly deployment: Schema.NullOr<Schema.Struct<{
+    readonly appName: Schema.String;
+    readonly appUrl: Schema.optionalKey<Schema.String>;
+    readonly serviceId: Schema.optionalKey<Schema.String>;
+    readonly workspace: Schema.optionalKey<Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.NullOr<Schema.String>;
     }>>;
-    deploy: z.ZodOptional<z.ZodBoolean>;
-    workspace: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-    template: z.ZodOptional<z.ZodEnum<{
-      minimal: "minimal";
-      hono: "hono";
-      elysia: "elysia";
-      nest: "nest";
-      next: "next";
-      svelte: "svelte";
-      astro: "astro";
-      nuxt: "nuxt";
-      "tanstack-start": "tanstack-start";
+    readonly project: Schema.Struct<{
+      readonly id: Schema.optionalKey<Schema.String>;
+      readonly name: Schema.String;
+      readonly consoleUrl: Schema.optionalKey<Schema.String>;
+    }>;
+  }>>;
+  readonly nextSteps: Schema.$Array<Schema.Struct<{
+    readonly command: Schema.String;
+    readonly description: Schema.String;
+  }>>;
+  readonly warnings: Schema.$Array<Schema.String>;
+}>;
+type CreateCommandSuccessResult = typeof CreateCommandSuccessResultSchema.Type;
+declare const CreateCommandFailureResultSchema: Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly ok: Schema.Literal<false>;
+  readonly error: Schema.Struct<{
+    readonly stage: Schema.Union<readonly [Schema.Literals<readonly ["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"]>, Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "deployment_intent", "select_workspace"]>, Schema.Literal<"parse_arguments">]>;
+    readonly message: Schema.String;
+  }>;
+  readonly project: Schema.optionalKey<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly path: Schema.String;
+    readonly template: Schema.Literals<readonly ["minimal", "hono", "elysia", "nest", "next", "svelte", "astro", "nuxt", "tanstack-start"]>;
+    readonly databaseProvider: Schema.Literals<readonly ["postgres", "mongo"]>;
+    readonly authoring: Schema.Literals<readonly ["psl", "typescript"]>;
+    readonly packageManager: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun", "deno"]>;
+  }>>;
+}>;
+type CreateCommandFailureResult = typeof CreateCommandFailureResultSchema.Type;
+declare const CreateCommandResultSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly ok: Schema.Literal<true>;
+  readonly project: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly path: Schema.String;
+    readonly template: Schema.Literals<readonly ["minimal", "hono", "elysia", "nest", "next", "svelte", "astro", "nuxt", "tanstack-start"]>;
+    readonly databaseProvider: Schema.Literals<readonly ["postgres", "mongo"]>;
+    readonly authoring: Schema.Literals<readonly ["psl", "typescript"]>;
+    readonly packageManager: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun", "deno"]>;
+  }>;
+  readonly deployment: Schema.NullOr<Schema.Struct<{
+    readonly appName: Schema.String;
+    readonly appUrl: Schema.optionalKey<Schema.String>;
+    readonly serviceId: Schema.optionalKey<Schema.String>;
+    readonly workspace: Schema.optionalKey<Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.NullOr<Schema.String>;
     }>>;
-    force: z.ZodOptional<z.ZodBoolean>;
-  }, z.core.$strip>], null>, Schema<CreateCommandResult | undefined, CreateCommandResult | undefined>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
-};
-declare function createCreatePrismaCli(): trpc_cli0.TrpcCli;
+    readonly project: Schema.Struct<{
+      readonly id: Schema.optionalKey<Schema.String>;
+      readonly name: Schema.String;
+      readonly consoleUrl: Schema.optionalKey<Schema.String>;
+    }>;
+  }>>;
+  readonly nextSteps: Schema.$Array<Schema.Struct<{
+    readonly command: Schema.String;
+    readonly description: Schema.String;
+  }>>;
+  readonly warnings: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly ok: Schema.Literal<false>;
+  readonly error: Schema.Struct<{
+    readonly stage: Schema.Union<readonly [Schema.Literals<readonly ["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"]>, Schema.Literals<readonly ["project_name", "template", "database_provider", "authoring_style", "package_manager", "deployment_intent", "select_workspace"]>, Schema.Literal<"parse_arguments">]>;
+    readonly message: Schema.String;
+  }>;
+  readonly project: Schema.optionalKey<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly path: Schema.String;
+    readonly template: Schema.Literals<readonly ["minimal", "hono", "elysia", "nest", "next", "svelte", "astro", "nuxt", "tanstack-start"]>;
+    readonly databaseProvider: Schema.Literals<readonly ["postgres", "mongo"]>;
+    readonly authoring: Schema.Literals<readonly ["psl", "typescript"]>;
+    readonly packageManager: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun", "deno"]>;
+  }>>;
+}>]>;
+type CreateCommandResult = typeof CreateCommandResultSchema.Type;
+//#endregion
+//#region src/index.d.ts
+declare const createPrismaCommand: Command.Command<"create-prisma", {
+  readonly projectName: string | undefined;
+  readonly name: string | undefined;
+  readonly template: "minimal" | "hono" | "elysia" | "nest" | "next" | "svelte" | "astro" | "nuxt" | "tanstack-start" | undefined;
+  readonly provider: "postgres" | "mongo" | undefined;
+  readonly authoring: "psl" | "typescript" | undefined;
+  readonly packageManager: "npm" | "pnpm" | "yarn" | "bun" | "deno" | undefined;
+  readonly deploy: boolean | undefined;
+  readonly workspace: string | undefined;
+  readonly force: boolean | undefined;
+  readonly yes: boolean | undefined;
+  readonly verbose: boolean | undefined;
+  readonly json: boolean | undefined;
+}, {}, never, effect_FileSystem0.FileSystem | CommandRunner>;
+declare function createCreatePrismaCli(): Command.Command<"create-prisma", {
+  readonly projectName: string | undefined;
+  readonly name: string | undefined;
+  readonly template: "minimal" | "hono" | "elysia" | "nest" | "next" | "svelte" | "astro" | "nuxt" | "tanstack-start" | undefined;
+  readonly provider: "postgres" | "mongo" | undefined;
+  readonly authoring: "psl" | "typescript" | undefined;
+  readonly packageManager: "npm" | "pnpm" | "yarn" | "bun" | "deno" | undefined;
+  readonly deploy: boolean | undefined;
+  readonly workspace: string | undefined;
+  readonly force: boolean | undefined;
+  readonly yes: boolean | undefined;
+  readonly verbose: boolean | undefined;
+  readonly json: boolean | undefined;
+}, {}, never, effect_FileSystem0.FileSystem | CommandRunner>;
+declare function runCreatePrismaCli(argv?: readonly string[]): Effect.Effect<void, never, Command.Environment | CommandRunner>;
 declare function create(input?: CreateCommandInput): Promise<void>;
 //#endregion
-export { AuthoringStyleSchema, CREATE_PRISMA_RESULT_SCHEMA_VERSION, type CreateCommandFailureResult, type CreateCommandFailureStage, type CreateCommandInput, CreateCommandInputSchema, type CreateCommandResult, type CreateCommandSuccessResult, type CreateNextStep, type CreateProjectResult, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };
+export { AuthoringStyleSchema, CREATE_PRISMA_RESULT_SCHEMA_VERSION, type CreateCommandFailureResult, type CreateCommandFailureStage, type CreateCommandInput, CreateCommandInputSchema, type CreateCommandResult, CreateCommandResultSchema, type CreateCommandSuccessResult, type CreateNextStep, type CreateProjectResult, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, createPrismaCommand, runCreatePrismaCli };