@prisma-next/cli 0.5.0-dev.7 → 0.5.0-dev.71

package/src/cli.ts

@@ -50,8 +50,18 @@ program.configureOutput({
   writeErr: () => {
     // Suppress all default error output - we handle errors in exitOverride
   },
-  writeOut: () => {
-    // Suppress all default output - our custom formatters handle everything
+  writeOut: (str) => {
+    // Commander routes explicitly-requested `--help` (success-path help)
+    // through writeOut; per the Style Guide § Output Conventions rule 8,
+    // user-requested help is data and goes to stdout. Error-path help
+    // (e.g. usage shown after an unknown command) goes through writeErr,
+    // which stays suppressed because we render that ourselves with the
+    // matching error envelope.
+    //
+    // Explicit `--version` is short-circuited before `program.parse()`
+    // (see the argv pre-scan at the bottom of this file), so it does not
+    // reach this writer.
+    process.stdout.write(str);
   },
 });
 
@@ -261,14 +271,25 @@ const helpCommand = new Command('help')
   .action(() => {
     const flags = parseGlobalFlags({});
     const helpText = formatRootHelp({ program, flags });
-    // Help is decoration → stderr
-    process.stderr.write(`${helpText}\n`);
+    // The `help` command was invoked explicitly: help is the data the
+    // caller asked for. Per Style Guide § Output Conventions rule 8,
+    // explicit help goes to stdout with exit code 0.
+    process.stdout.write(`${helpText}\n`);
     process.exit(0);
   });
 
 program.addCommand(helpCommand);
 
-// Set help as the default action when no command is provided
+// Set help as the default action when no command is provided. The user
+// did not invoke `--help`; we are voluntarily showing usage to help them
+// recover from an underspecified invocation, so the help text is
+// decoration around an implicit "what did you want me to do?" and goes
+// to stderr (Style Guide § Output Conventions rule 8).
+//
+// FOLLOW-UP: the exit code here is 0 today, but a no-arg invocation is
+// arguably a usage error (PRECONDITION → exit 2) for consistency with
+// the unknown-command path. Out of scope for the explicit-help routing
+// work; revisit when tightening exit-code semantics across the CLI.
 program.action(() => {
   const flags = parseGlobalFlags({});
   const helpText = formatRootHelp({ program, flags });
@@ -304,7 +325,12 @@ if (args.length > 0) {
       process.stderr.write(`${helpText}\n`);
       process.exit(2);
     } else if (command.commands.length > 0 && args.length === 1) {
-      // Parent command called with no subcommand - show help and exit with 0
+      // Parent command called with no subcommand. Same shape as the
+      // no-args case above: the user did not request help, we are
+      // voluntarily rendering it as decoration around an underspecified
+      // invocation, so it goes to stderr per Style Guide § Output
+      // Conventions rule 8. Exit code 0 today; the FOLLOW-UP note on
+      // `program.action` applies here too (arguably should be 2).
       const flags = parseGlobalFlags({});
       const helpText = formatCommandHelp({ command, flags });
       process.stderr.write(`${helpText}\n`);

package/src/commands/contract-emit.ts

@@ -1,18 +1,13 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
 import { getEmittedArtifactPaths } from '@prisma-next/emitter';
 import { errorContractConfigMissing } from '@prisma-next/errors/control';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { dirname, relative, resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
-import { createControlClient } from '../control-api/client';
-import type { EmitFailure } from '../control-api/types';
-import {
-  CliStructuredError,
-  errorContractValidationFailed,
-  errorRuntime,
-  errorUnexpected,
-} from '../utils/cli-errors';
+import { executeContractEmit } from '../control-api/operations/contract-emit';
+import type { ContractEmitResult } from '../control-api/types';
+import { CliStructuredError, errorUnexpected } from '../utils/cli-errors';
 import {
   addGlobalOptions,
   setCommandDescriptions,
@@ -34,74 +29,29 @@ interface ContractEmitOptions extends CommonCommandOptions {
   readonly config?: string;
 }
 
-function mapDiagnosticsToIssues(
-  failure: EmitFailure,
-): ReadonlyArray<{ kind: string; message: string }> {
-  const diagnostics = failure.diagnostics?.diagnostics ?? [];
-  return diagnostics.map((diagnostic) => {
-    const location =
-      diagnostic.sourceId && diagnostic.span
-        ? ` (${diagnostic.sourceId}:${diagnostic.span.start.line}:${diagnostic.span.start.column})`
-        : diagnostic.sourceId
-          ? ` (${diagnostic.sourceId})`
-          : '';
-    return {
-      kind: diagnostic.code,
-      message: `${diagnostic.message}${location}`,
-    };
-  });
+interface HeaderPaths {
+  readonly displayConfigPath: string;
+  readonly outputJsonPath: string;
+  readonly outputDtsPath: string;
 }
 
 /**
- * Maps an EmitFailure to a CliStructuredError for consistent error handling.
+ * Pre-load the config just to compute display paths for the styled header. The
+ * actual emit work goes through `executeContractEmit`, which loads the config
+ * itself; the redundant load here is bounded and lets the header render before
+ * the emit spans start.
  */
-function mapEmitFailure(
-  failure: EmitFailure,
-  context?: { readonly configPath?: string },
-): CliStructuredError {
-  if (failure.code === 'CONTRACT_SOURCE_INVALID') {
-    const issues = mapDiagnosticsToIssues(failure);
-    return errorRuntime(failure.summary, {
-      why: failure.why ?? 'Contract source provider failed',
-      fix: 'Check your contract source provider in prisma-next.config.ts and ensure it returns Result<Contract, Diagnostics>',
-      ...(issues.length > 0 ? { meta: { issues } } : {}),
-    });
-  }
-
-  if (failure.code === 'CONTRACT_VALIDATION_FAILED') {
-    return errorContractValidationFailed(
-      failure.why ?? 'Contract validation failed while emitting',
-      context?.configPath ? { where: { path: context.configPath } } : undefined,
-    );
-  }
-
-  if (failure.code === 'EMIT_FAILED') {
-    return errorRuntime(failure.summary, {
-      why: failure.why ?? 'Failed to emit contract',
-      fix: 'Check your contract configuration and ensure the source is valid',
-    });
-  }
-
-  // Exhaustive check - TypeScript will error if a new code is added but not handled
-  const exhaustive: never = failure.code;
-  throw new Error(`Unhandled EmitFailure code: ${exhaustive}`);
-}
+async function resolveHeaderPaths(
+  configOption: string | undefined,
+): Promise<Result<HeaderPaths, CliStructuredError>> {
+  const displayConfigPath = configOption
+    ? relative(process.cwd(), resolve(configOption))
+    : 'prisma-next.config.ts';
 
-/**
- * Executes the contract emit command and returns a structured Result.
- */
-async function executeContractEmitCommand(
-  options: ContractEmitOptions,
-  flags: GlobalFlags,
-  ui: TerminalUI,
-  startTime: number,
-): Promise<Result<EmitContractResult, CliStructuredError>> {
-  // Load config
   let config: Awaited<ReturnType<typeof loadConfig>>;
   try {
-    config = await loadConfig(options.config);
+    config = await loadConfig(configOption);
   } catch (error) {
-    // Convert thrown CliStructuredError to Result
     if (error instanceof CliStructuredError) {
       return notOk(error);
     }
@@ -112,33 +62,19 @@ async function executeContractEmitCommand(
     );
   }
 
-  const configPath = options.config
-    ? relative(process.cwd(), resolve(options.config))
-    : 'prisma-next.config.ts';
-
-  // Resolve contract from config
-  if (!config.contract) {
+  if (!config.contract?.output) {
     return notOk(
       errorContractConfigMissing({
-        why: 'Config.contract is required for emit. Define it in your config: contract: { source: ..., output: ... }',
+        why: 'Config.contract.output is required for emit. Define it in your config: contract: { source: ..., output: ... }',
       }),
     );
   }
 
-  // Contract config is already normalized by defineConfig() with defaults applied
-  const contractConfig = config.contract;
-
-  // Resolve artifact paths from config (already normalized by defineConfig() with defaults)
-  if (!contractConfig.output) {
-    return notOk(
-      errorContractConfigMissing({
-        why: 'Contract config must have output path. This should not happen if defineConfig() was used.',
-      }),
-    );
-  }
-  let outputPaths: ReturnType<typeof getEmittedArtifactPaths>;
   try {
-    outputPaths = getEmittedArtifactPaths(contractConfig.output);
+    const { jsonPath: outputJsonPath, dtsPath: outputDtsPath } = getEmittedArtifactPaths(
+      config.contract.output,
+    );
+    return ok({ displayConfigPath, outputJsonPath, outputDtsPath });
   } catch (error) {
     return notOk(
       errorContractConfigMissing({
@@ -146,96 +82,65 @@ async function executeContractEmitCommand(
       }),
     );
   }
-  const { jsonPath: outputJsonPath, dtsPath: outputDtsPath } = outputPaths;
+}
 
-  // Output header to stderr (decoration)
-  if (!flags.json && !flags.quiet) {
-    const contractPath = relative(process.cwd(), outputJsonPath);
-    const typesPath = relative(process.cwd(), outputDtsPath);
-    const header = formatStyledHeader({
-      command: 'contract emit',
-      description: 'Emit your contract artifacts',
-      url: 'https://pris.ly/contract-emit',
-      details: [
-        { label: 'config', value: configPath },
-        { label: 'contract', value: contractPath },
-        { label: 'types', value: typesPath },
-      ],
-      flags,
-    });
-    ui.stderr(header);
+async function executeContractEmitCommand(
+  options: ContractEmitOptions,
+  flags: GlobalFlags,
+  ui: TerminalUI,
+  startTime: number,
+): Promise<Result<EmitContractResult, CliStructuredError>> {
+  const headerPathsResult = await resolveHeaderPaths(options.config);
+  if (!headerPathsResult.ok) {
+    return headerPathsResult;
   }
+  const { displayConfigPath, outputJsonPath, outputDtsPath } = headerPathsResult.value;
 
-  // Create control client (no driver needed for emit)
-  const client = createControlClient({
-    family: config.family,
-    target: config.target,
-    adapter: config.adapter,
-    extensionPacks: config.extensionPacks ?? [],
-  });
+  if (!flags.json && !flags.quiet) {
+    ui.stderr(
+      formatStyledHeader({
+        command: 'contract emit',
+        description: 'Emit your contract artifacts',
+        url: 'https://pris.ly/contract-emit',
+        details: [
+          { label: 'config', value: displayConfigPath },
+          { label: 'contract', value: relative(process.cwd(), outputJsonPath) },
+          { label: 'types', value: relative(process.cwd(), outputDtsPath) },
+        ],
+        flags,
+      }),
+    );
+  }
 
-  // Create progress adapter
   const onProgress = createProgressAdapter({ ui, flags });
+  const configPath = options.config ? resolve(options.config) : 'prisma-next.config.ts';
 
+  let result: ContractEmitResult;
   try {
-    // Call emit with progress callback
-    const result = await client.emit({
-      contractConfig: {
-        source: contractConfig.source,
-        output: outputJsonPath,
-      },
-      onProgress,
-    });
-
-    // Handle failures by mapping to CLI structured error
-    if (!result.ok) {
-      return notOk(mapEmitFailure(result.failure, { configPath }));
-    }
-
-    // Create directories if needed
-    mkdirSync(dirname(outputJsonPath), { recursive: true });
-    mkdirSync(dirname(outputDtsPath), { recursive: true });
-
-    // Write the results to files
-    writeFileSync(outputJsonPath, result.value.contractJson, 'utf-8');
-    writeFileSync(outputDtsPath, result.value.contractDts, 'utf-8');
-
-    // Validate that contract.d.ts type imports are resolvable
-    const { validateContractDeps } = await import('../utils/validate-contract-deps');
-    const depsValidation = validateContractDeps(result.value.contractDts, dirname(outputDtsPath));
-    if (depsValidation.warning) {
-      ui.warn(depsValidation.warning);
-    }
-
-    // Convert success result to CLI output format
-    const emitResult: EmitContractResult = {
-      storageHash: result.value.storageHash,
-      ...(result.value.executionHash ? { executionHash: result.value.executionHash } : {}),
-      profileHash: result.value.profileHash,
-      outDir: dirname(outputJsonPath),
-      files: {
-        json: outputJsonPath,
-        dts: outputDtsPath,
-      },
-      timings: { total: Date.now() - startTime },
-    };
-
-    return ok(emitResult);
+    result = await executeContractEmit({ configPath, onProgress });
   } catch (error) {
-    // Use static type guard to work across module boundaries
     if (CliStructuredError.is(error)) {
       return notOk(error);
     }
-
-    // Wrap unexpected errors
     return notOk(
       errorUnexpected('Unexpected error during contract emit', {
         why: error instanceof Error ? error.message : String(error),
       }),
     );
-  } finally {
-    await client.close();
   }
+
+  if (result.validationWarning) {
+    ui.warn(result.validationWarning);
+  }
+
+  return ok({
+    storageHash: result.storageHash,
+    ...ifDefined('executionHash', result.executionHash),
+    profileHash: result.profileHash,
+    outDir: dirname(result.files.json),
+    files: result.files,
+    timings: { total: Date.now() - startTime },
+  });
 }
 
 export function createContractEmitCommand(): Command {
@@ -260,7 +165,6 @@ export function createContractEmitCommand(): Command {
 
       const result = await executeContractEmitCommand(options, flags, ui, startTime);
 
-      // Handle result - formats output and returns exit code
       const exitCode = handleResult(result, flags, ui, (emitResult) => {
         if (flags.json) {
           ui.output(formatEmitJson(emitResult));

package/src/commands/contract-infer.ts

@@ -1,12 +1,6 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { errorRuntime } from '@prisma-next/errors/execution';
-import { printPsl, validatePrintableSqlSchemaIR } from '@prisma-next/psl-printer';
-import {
-  createPostgresDefaultMapping,
-  createPostgresTypeMap,
-  extractEnumInfo,
-  parseRawDefault,
-} from '@prisma-next/psl-printer/postgres';
+import { printPsl } from '@prisma-next/psl-printer';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { dirname, relative } from 'pathe';
@@ -59,26 +53,19 @@ async function executeContractInferCommand(
     return inspectResult;
   }
 
-  const { config, target, meta } = inspectResult.value;
+  const { config, target, meta, pslContractAst } = inspectResult.value;
 
-  if (target.familyId !== 'sql') {
+  if (!pslContractAst) {
     return notOk(
-      errorRuntime(`contract infer is not supported for family "${target.familyId}"`, {
-        why: 'contract infer currently supports SQL targets only',
-        fix: 'Use an SQL target (e.g. Postgres) with this command',
+      errorRuntime('contract infer is not supported for this family', {
+        why: 'The configured family does not implement the PslContractInferCapable capability, so an inferred PSL contract cannot be produced from the live database schema.',
+        fix: 'Use a family that supports contract inference (e.g. SQL/Postgres).',
       }),
     );
   }
 
-  const schema = validatePrintableSqlSchemaIR(inspectResult.value.schema);
   const outputPath = resolveContractInferOutputPath(options, config.contract?.output);
-  const enumInfo = extractEnumInfo(schema.annotations);
-  const pslContent = printPsl(schema, {
-    defaultMapping: createPostgresDefaultMapping(),
-    typeMap: createPostgresTypeMap(enumInfo.typeNames),
-    enumInfo,
-    parseRawDefault,
-  });
+  const pslContent = printPsl(pslContractAst);
 
   if (existsSync(outputPath) && !flags.json && !flags.quiet) {
     ui.stderr(`\u26A0 Overwriting existing file: ${relative(process.cwd(), outputPath)}`);

package/src/commands/db-init.ts

@@ -13,6 +13,7 @@ import {
 } from '../utils/cli-errors';
 import type { MigrationCommandOptions } from '../utils/command-helpers';
 import {
+  resolveMigrationPaths,
   sanitizeErrorMessage,
   setCommandDescriptions,
   setCommandExamples,
@@ -111,14 +112,23 @@ async function executeDbInitCommand(
   if (!ctxResult.ok) {
     return ctxResult;
   }
-  const { client, contractJson, dbConnection, onProgress, contractPathAbsolute } = ctxResult.value;
+  const { client, config, contractJson, dbConnection, onProgress, contractPathAbsolute } =
+    ctxResult.value;
+
+  // The aggregate loader (loader → planner → runner pipeline) catches
+  // layout / drift / disjointness violations on its own; the legacy
+  // per-space precheck + marker-check helpers are no longer needed at
+  // this surface. Marker-vs-on-disk drift surfaces through the planner's
+  // graph-walk strategy.
+  const { migrationsDir } = resolveMigrationPaths(options.config, config);
 
   try {
-    // Call dbInit with connection and progress callback
+    await client.connect(dbConnection);
+
     const result = await client.dbInit({
       contract: contractJson,
       mode: options.dryRun ? 'plan' : 'apply',
-      connection: dbConnection,
+      migrationsDir,
       onProgress,
     });
 
@@ -142,6 +152,7 @@ async function executeDbInitCommand(
           label: op.label,
           operationClass: op.operationClass,
         })),
+        ...ifDefined('preview', result.value.plan.preview),
       },
       ...(result.value.execution
         ? {

package/src/commands/db-update.ts

@@ -14,6 +14,7 @@ import {
 } from '../utils/cli-errors';
 import type { MigrationCommandOptions } from '../utils/command-helpers';
 import {
+  resolveMigrationPaths,
   sanitizeErrorMessage,
   setCommandDescriptions,
   setCommandExamples,
@@ -80,14 +81,17 @@ async function executeDbUpdateCommand(
   if (!ctxResult.ok) {
     return ctxResult;
   }
-  const { client, contractJson, dbConnection, onProgress, contractPathAbsolute } = ctxResult.value;
+  const { client, config, contractJson, dbConnection, onProgress, contractPathAbsolute } =
+    ctxResult.value;
+  const { migrationsDir } = resolveMigrationPaths(options.config, config);
 
   try {
-    // Call dbUpdate with connection and progress callback
+    await client.connect(dbConnection);
+
     const result = await client.dbUpdate({
       contract: contractJson,
       mode: options.dryRun ? 'plan' : 'apply',
-      connection: dbConnection,
+      migrationsDir,
       ...(flags.yes ? { acceptDataLoss: true } : {}),
       onProgress,
     });
@@ -112,7 +116,7 @@ async function executeDbUpdateCommand(
           label: op.label,
           operationClass: op.operationClass,
         })),
-        ...ifDefined('sql', result.value.plan.sql),
+        ...ifDefined('preview', result.value.plan.preview),
       },
       ...ifDefined(
         'execution',

package/src/commands/db-verify.ts

@@ -27,10 +27,12 @@ import {
   errorTargetMismatch,
   errorUnexpected,
 } from '../utils/cli-errors';
+import { combineSchemaResults } from '../utils/combine-schema-results';
 import {
   addGlobalOptions,
   maskConnectionUrl,
   resolveContractPath,
+  resolveMigrationPaths,
   setCommandDescriptions,
   setCommandExamples,
 } from '../utils/command-helpers';
@@ -346,22 +348,42 @@ async function executeDbVerifyCommand(
   const setupResult = await resolveVerifySetup(paths, options, mode);
   if (!setupResult.ok) return setupResult;
   const { contractJson, dbConnection, contractPathAbsolute } = setupResult.value;
+  const { migrationsDir } = resolveMigrationPaths(options.config, setupResult.value.config);
 
   const client = createVerifyClient(setupResult.value);
   const onProgress = createProgressAdapter({ ui, flags });
 
   try {
+    // Single-contract marker verification preserved for the existing
+    // marker / target / hash failure surface (`PN-RUN-3001/3002/3003`).
+    // The aggregate verifier (run below for the per-space marker /
+    // schema checks) does not duplicate this: it concerns itself with
+    // marker-vs-on-disk and orphan-marker drift, not the
+    // hash-mismatch-against-the-app-contract lane that today's
+    // `client.verify` covers.
     const verifyResult = await client.verify({
       contract: contractJson,
       connection: dbConnection,
       onProgress,
     });
 
-    // If verification failed, map to CLI structured error
     if (!verifyResult.ok) {
       return notOk(mapVerifyFailure(verifyResult));
     }
 
+    // Aggregate verifier (loader → verifier pipeline). Runs the layout
+    // precheck, marker-aware per-space verifier, and (full mode only)
+    // per-space pre-projected schema verification (closes F23).
+    const aggregateResult = await client.dbVerify({
+      contract: contractJson,
+      migrationsDir,
+      strict: options.strict ?? false,
+      skipSchema: mode === 'marker-only',
+      skipMarker: false,
+      onProgress,
+    });
+    if (!aggregateResult.ok) return notOk(aggregateResult.failure);
+
     if (mode === 'marker-only') {
       return ok({
         ok: true,
@@ -381,14 +403,13 @@ async function executeDbVerifyCommand(
       });
     }
 
-    const schemaVerifyResult = await client.schemaVerify({
-      contract: contractJson,
-      strict: options.strict ?? false,
-      onProgress,
-    });
-
-    if (!schemaVerifyResult.ok) {
-      return notOk(schemaVerifyResult);
+    const combined = combineSchemaResults(
+      aggregateResult.value.schemaResults,
+      aggregateResult.value.appSpaceId,
+      options.strict ?? false,
+    );
+    if (!combined.ok) {
+      return notOk(combined);
     }
 
     return ok({
@@ -401,9 +422,9 @@ async function executeDbVerifyCommand(
       ...ifDefined('missingCodecs', verifyResult.missingCodecs),
       ...ifDefined('codecCoverageSkipped', verifyResult.codecCoverageSkipped),
       schema: {
-        summary: schemaVerifyResult.summary,
-        counts: schemaVerifyResult.schema.counts,
-        strict: schemaVerifyResult.meta?.strict ?? false,
+        summary: combined.summary,
+        counts: combined.schema.counts,
+        strict: combined.meta?.strict ?? false,
       },
       meta: {
         ...(verifyResult.meta ?? {}),
@@ -429,19 +450,30 @@ async function executeDbSchemaOnlyVerifyCommand(
   const setupResult = await resolveVerifySetup(paths, options, 'schema-only');
   if (!setupResult.ok) return setupResult;
   const { contractJson, dbConnection, contractPathAbsolute } = setupResult.value;
+  const { migrationsDir } = resolveMigrationPaths(options.config, setupResult.value.config);
 
   const client = createVerifyClient(setupResult.value);
   const onProgress = createProgressAdapter({ ui, flags });
 
   try {
-    const schemaVerifyResult = await client.schemaVerify({
+    await client.connect(dbConnection);
+    const aggregateResult = await client.dbVerify({
       contract: contractJson,
+      migrationsDir,
       strict: options.strict ?? false,
-      connection: dbConnection,
+      skipSchema: false,
+      skipMarker: true,
       onProgress,
     });
+    if (!aggregateResult.ok) return notOk(aggregateResult.failure);
 
-    return ok(schemaVerifyResult);
+    return ok(
+      combineSchemaResults(
+        aggregateResult.value.schemaResults,
+        aggregateResult.value.appSpaceId,
+        options.strict ?? false,
+      ),
+    );
   } catch (error) {
     return wrapVerifyError(error, contractPathAbsolute, 'db verify --schema-only');
   } finally {

package/src/commands/init/index.ts

@@ -113,7 +113,7 @@ export function createInitCommand(): Command {
  *   we honour it (e.g. testing flows where stdin is stubbed).
  *
  * Exported so callers and tests can derive the same value without
- * touching `process` globals — F14 of the M1/M2 review.
+ * touching `process` globals.
  */
 export function deriveCanPrompt(opts: {
   readonly flagsInteractive: boolean | undefined;

package/src/commands/init/init.ts

@@ -569,7 +569,7 @@ async function runInstall(ctx: {
   /**
    * FR2.1 — set when the user already declares `@types/node` directly in
    * `dependencies` or `devDependencies`. We then skip adding it so a
-   * pinned major (e.g. `^18` for a Node 18 runtime) survives `init`
+   * locked major (e.g. `^18` for a Node 18 runtime) survives `init`
    * unchanged. Transitive presence is intentionally ignored: detecting
    * it requires lockfile introspection and the realistic clobber risk
    * is the direct-pin case.
@@ -585,7 +585,7 @@ async function runInstall(ctx: {
   // Pin it as a devDep rather than relying on a transitive resolution
   // through `dotenv` (whose types bundle is internal and not guaranteed
   // across versions). Skip when the user already declares `@types/node`
-  // directly so a pinned major (e.g. `^18` for a Node 18 runtime) is
+  // directly so a locked major (e.g. `^18` for a Node 18 runtime) is
   // preserved. Listed last so the install log still leads with the
   // user-relevant `prisma-next` line.
   const devDeps = hasTypesNode ? ['prisma-next'] : ['prisma-next', '@types/node'];